@morscherlab/mint-sdk 1.0.0-alpha.2

package/dist/composables/experiment-utils.d.ts

@@ -0,0 +1,8 @@
+import { DatePreset, ExperimentStatus, SelectOption, PillVariant } from '../types';
+export declare function formatExperimentDate(dateStr: string): string;
+export declare function datePresetToISO(preset: DatePreset): string;
+export declare const EXPERIMENT_STATUS_OPTIONS: SelectOption<string>[];
+export declare const EXPERIMENT_STATUS_VARIANT_MAP: Record<ExperimentStatus, PillVariant>;
+export declare const EXPERIMENT_STATUS_LABELS: Record<ExperimentStatus, string>;
+export declare const DATE_PRESET_OPTIONS: SelectOption<string>[];
+export declare const SORT_OPTIONS: SelectOption<string>[];

package/dist/composables/formBuilderRegistry.d.ts

@@ -0,0 +1,13 @@
+import { Component } from 'vue';
+import { FormFieldType } from '../types/form-builder';
+export interface RegistryEntry {
+    component: Component;
+    /** Default props applied to the component. */
+    defaults: Record<string, unknown>;
+    /** Whether the component uses v-model (false for event-only components like FileUploader). */
+    vModel: boolean;
+}
+/** Return the registry entry for a given field type. Throws if the type is unregistered. */
+export declare function getFieldRegistryEntry(type: FormFieldType): RegistryEntry;
+/** Get the default empty value for a given field type. */
+export declare function getTypeDefault(type: FormFieldType): unknown;

package/dist/composables/index.d.ts

@@ -0,0 +1,28 @@
+export { useApi, type ApiClientOptions } from './useApi';
+export { useAuth } from './useAuth';
+export { usePasskey } from './usePasskey';
+export { useTheme } from './useTheme';
+export { useToast } from './useToast';
+export { usePlatformContext } from './usePlatformContext';
+export { useForm, type ValidationRule, type FieldRules, type FieldState, type UseFormReturn, } from './useForm';
+export { useAsync, useAsyncBatch, type AsyncError, type AsyncState, type UseAsyncReturn, type UseAsyncOptions, } from './useAsync';
+export { useWellPlateEditor, type UseWellPlateEditorOptions, type UseWellPlateEditorReturn, } from './useWellPlateEditor';
+export { useConcentrationUnits, type ConcentrationValue, type ConcentrationUnit, type MolarityUnit, type MassVolumeUnit, type PercentageUnit, type UnitCategory, type UseConcentrationUnitsReturn, } from './useConcentrationUnits';
+export { useDoseCalculator, type VolumeUnit, type VolumeValue, type DilutionParams, type DilutionResult, type SerialDilutionParams, type SerialDilutionStep, type SerialDilutionResult, type WellConcentration, type UseDoseCalculatorReturn, } from './useDoseCalculator';
+export { useProtocolTemplates, type ParameterDefinition, type StepTemplate, type ValidationResult, type UseProtocolTemplatesReturn, } from './useProtocolTemplates';
+export { useRackEditor, type UseRackEditorOptions, type UseRackEditorReturn, } from './useRackEditor';
+export { useChemicalFormula, ATOMIC_WEIGHTS, type ParsedElement, type FormulaParseResult, type FormulaPart, type FormulaPartType, } from './useChemicalFormula';
+export { useSequenceUtils, type SequenceType, type SequenceStats, } from './useSequenceUtils';
+export { useTimeUtils, parseTime, formatTime, generateTimeSlots, rangesOverlap, durationMinutes, formatDuration, isTimeInRange, findAvailableSlots, snapToSlot, addMinutes, compareTime, } from './useTimeUtils';
+export { useScheduleDrag } from './useScheduleDrag';
+export { useFormBuilder, evaluateCondition } from './useFormBuilder';
+export { useAutoGroup, DEFAULT_COLORS, extractSamplesFromDesignData } from './useAutoGroup';
+export { useReagentSeries, generateDilutionSeries, DEFAULT_PRESETS, DEFAULT_UNITS, type LevelEntry, type DilutionPreset, type UseReagentSeriesReturn, } from './useReagentSeries';
+export { usePluginConfig, type UsePluginConfigReturn } from './usePluginConfig';
+export { useExperimentSelector, type UseExperimentSelectorOptions, type UseExperimentSelectorReturn, } from './useExperimentSelector';
+export { formatExperimentDate, datePresetToISO, EXPERIMENT_STATUS_OPTIONS, EXPERIMENT_STATUS_VARIANT_MAP, EXPERIMENT_STATUS_LABELS, DATE_PRESET_OPTIONS, SORT_OPTIONS, } from './experiment-utils';
+export { useExperimentData, type UseExperimentDataOptions, type UseExperimentDataReturn, } from './useExperimentData';
+export { getFieldRegistryEntry, getTypeDefault, type RegistryEntry, } from './formBuilderRegistry';
+export { useAppExperiment, APP_EXPERIMENT_KEY, type UseAppExperimentOptions, type UseAppExperimentReturn, type AppExperimentState, } from './useAppExperiment';
+export { useExperimentSave, type UseExperimentSaveOptions, type UseExperimentSaveReturn, } from './useExperimentSave';
+export { usePluginApi, type UsePluginApiOptions, } from './usePluginApi';

package/dist/composables/index.js

@@ -0,0 +1,3 @@
+import { $ as formatTime, A as APP_EXPERIMENT_KEY, B as formatExperimentDate, D as useAutoGroup, F as EXPERIMENT_STATUS_LABELS, H as useTheme, I as EXPERIMENT_STATUS_OPTIONS, J as addMinutes, L as EXPERIMENT_STATUS_VARIANT_MAP, M as usePlatformContext, N as useExperimentSelector, O as useWellPlateEditor, P as DATE_PRESET_OPTIONS, Q as formatDuration, R as SORT_OPTIONS, S as useConcentrationUnits, T as extractSamplesFromDesignData, U as useToast, V as useApi, X as durationMinutes, Y as compareTime, Z as findAvailableSlots, _ as DEFAULT_UNITS, a as getFieldRegistryEntry, at as useTimeUtils, b as useDoseCalculator, c as useForm, d as useSequenceUtils, et as generateTimeSlots, g as DEFAULT_PRESETS, h as useProtocolTemplates, i as useFormBuilder, it as snapToSlot, j as useAppExperiment, k as useRackEditor, m as useChemicalFormula, n as useExperimentData, nt as parseTime, o as getTypeDefault, p as ATOMIC_WEIGHTS, r as evaluateCondition, rt as rangesOverlap, t as useScheduleDrag, tt as isTimeInRange, v as generateDilutionSeries, w as DEFAULT_COLORS, y as useReagentSeries, z as datePresetToISO } from "../useScheduleDrag-DAJueTbK.js";
+import { a as useAsyncBatch, i as useAsync, n as useExperimentSave, o as usePasskey, r as usePluginConfig, s as useAuth, t as usePluginApi } from "../composables-D0QfFzq1.js";
+export { APP_EXPERIMENT_KEY, ATOMIC_WEIGHTS, DATE_PRESET_OPTIONS, DEFAULT_COLORS, DEFAULT_PRESETS, DEFAULT_UNITS, EXPERIMENT_STATUS_LABELS, EXPERIMENT_STATUS_OPTIONS, EXPERIMENT_STATUS_VARIANT_MAP, SORT_OPTIONS, addMinutes, compareTime, datePresetToISO, durationMinutes, evaluateCondition, extractSamplesFromDesignData, findAvailableSlots, formatDuration, formatExperimentDate, formatTime, generateDilutionSeries, generateTimeSlots, getFieldRegistryEntry, getTypeDefault, isTimeInRange, parseTime, rangesOverlap, snapToSlot, useApi, useAppExperiment, useAsync, useAsyncBatch, useAuth, useAutoGroup, useChemicalFormula, useConcentrationUnits, useDoseCalculator, useExperimentData, useExperimentSave, useExperimentSelector, useForm, useFormBuilder, usePasskey, usePlatformContext, usePluginApi, usePluginConfig, useProtocolTemplates, useRackEditor, useReagentSeries, useScheduleDrag, useSequenceUtils, useTheme, useTimeUtils, useToast, useWellPlateEditor };

package/dist/composables/useApi.d.ts

@@ -0,0 +1,20 @@
+import { AxiosInstance, AxiosRequestConfig } from 'axios';
+export interface ApiClientOptions {
+    baseUrl?: string;
+    timeout?: number;
+    withAuth?: boolean;
+}
+export interface UseApiReturn {
+    client: AxiosInstance;
+    get: <T>(url: string, config?: AxiosRequestConfig) => Promise<T>;
+    post: <T>(url: string, data?: unknown, config?: AxiosRequestConfig) => Promise<T>;
+    put: <T>(url: string, data?: unknown, config?: AxiosRequestConfig) => Promise<T>;
+    patch: <T>(url: string, data?: unknown, config?: AxiosRequestConfig) => Promise<T>;
+    delete: <T>(url: string, config?: AxiosRequestConfig) => Promise<T>;
+    upload: <T>(url: string, file: File, fieldName?: string, additionalData?: Record<string, unknown>) => Promise<T>;
+    download: (url: string, filename?: string) => Promise<string>;
+    buildUrl: (path: string) => string;
+    buildWsUrl: (path: string) => string;
+}
+/** Axios-based API client that injects the plugin base URL and JWT auth header on every request. */
+export declare function useApi(options?: ApiClientOptions): UseApiReturn;

package/dist/composables/useAppExperiment.d.ts

@@ -0,0 +1,37 @@
+import { Ref, ComputedRef, InjectionKey } from 'vue';
+import { ExperimentSummary, ExperimentStatus } from '../types';
+export interface UseAppExperimentOptions {
+    onSelect?: (experiment: ExperimentSummary) => void | Promise<void>;
+    onSave?: () => string | null | Promise<string | null>;
+    onDetach?: () => void;
+    saveDisabled?: Ref<boolean> | ComputedRef<boolean>;
+    saveDisabledMessage?: string | Ref<string | undefined> | ComputedRef<string | undefined>;
+}
+export interface UseAppExperimentReturn {
+    set: (experiment: Pick<ExperimentSummary, 'id' | 'name' | 'status' | 'experiment_code'>) => void;
+    clear: () => void;
+    experimentName: Readonly<Ref<string | undefined>>;
+    experimentCode: Readonly<Ref<string | undefined>>;
+    experimentId: Readonly<Ref<number | null>>;
+}
+export interface AppExperimentState {
+    experimentName: Ref<string | undefined>;
+    experimentCode: Ref<string | undefined>;
+    experimentStatus: Ref<ExperimentStatus | undefined>;
+    experimentId: Ref<number | null>;
+    showModal: Ref<boolean>;
+    saveLoading: Ref<boolean>;
+    saveSuccessMessage: Ref<string | undefined>;
+    showSave: Ref<boolean>;
+    showDetach: ComputedRef<boolean>;
+    closeModal: () => void;
+    saveDisabled: ComputedRef<boolean>;
+    saveDisabledMessage: ComputedRef<string | undefined>;
+    openModal: () => void;
+    handleSelect: (experiment: ExperimentSummary) => void;
+    handleSave: () => Promise<void>;
+    handleDetach: () => void;
+}
+export declare const APP_EXPERIMENT_KEY: InjectionKey<AppExperimentState>;
+/** Manages the active experiment selection, save flow, and detach action for a plugin's app shell. */
+export declare function useAppExperiment(options?: UseAppExperimentOptions): UseAppExperimentReturn;

package/dist/composables/useAsync.d.ts

@@ -0,0 +1,128 @@
+import { Ref, ComputedRef } from 'vue';
+/**
+ * Error type for async operations.
+ */
+export interface AsyncError {
+    message: string;
+    code?: string;
+    details?: Record<string, unknown>;
+    originalError?: unknown;
+}
+/**
+ * State of an async operation.
+ */
+export type AsyncState = 'idle' | 'loading' | 'success' | 'error';
+/**
+ * Return type for useAsync composable.
+ */
+export interface UseAsyncReturn<T> {
+    data: Ref<T | null>;
+    error: Ref<AsyncError | null>;
+    state: Ref<AsyncState>;
+    isIdle: ComputedRef<boolean>;
+    isLoading: ComputedRef<boolean>;
+    isSuccess: ComputedRef<boolean>;
+    isError: ComputedRef<boolean>;
+    execute: (...args: unknown[]) => Promise<T | null>;
+    reset: () => void;
+    setData: (data: T | null) => void;
+    setError: (error: AsyncError | null) => void;
+}
+/**
+ * Options for useAsync.
+ */
+export interface UseAsyncOptions<T> {
+    initialData?: T | null;
+    immediate?: boolean;
+    immediateArgs?: unknown[];
+    transformError?: (error: unknown) => AsyncError;
+    onSuccess?: (data: T) => void;
+    onError?: (error: AsyncError) => void;
+    resetOnExecute?: boolean;
+}
+/**
+ * Composable for managing async operation state.
+ *
+ * Provides standardized loading, error, and success state management
+ * for any async function.
+ *
+ * @param asyncFn - The async function to wrap
+ * @param options - Configuration options
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const { data, isLoading, error, execute } = useAsync(
+ *   async (id: string) => {
+ *     const response = await api.get(`/users/${id}`)
+ *     return response.data
+ *   }
+ * )
+ *
+ * // Execute the function
+ * await execute('user-123')
+ *
+ * // In template
+ * <div v-if="isLoading">Loading...</div>
+ * <div v-else-if="error">{{ error.message }}</div>
+ * <div v-else-if="data">{{ data.name }}</div>
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With options
+ * const { data, execute } = useAsync(
+ *   fetchUser,
+ *   {
+ *     immediate: true,
+ *     immediateArgs: ['default-user'],
+ *     onSuccess: (user) => console.log('Fetched:', user.name),
+ *     onError: (error) => toast.error(error.message),
+ *   }
+ * )
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Form submission
+ * const { isLoading, error, execute: submit } = useAsync(
+ *   async (formData: FormData) => {
+ *     await api.post('/submit', formData)
+ *   },
+ *   {
+ *     onSuccess: () => {
+ *       toast.success('Submitted!')
+ *       router.push('/success')
+ *     },
+ *   }
+ * )
+ *
+ * const handleSubmit = () => submit(new FormData(formRef.value))
+ * ```
+ */
+/** Wraps an async function with reactive loading, error, and success state plus optional auto-execute. */
+export declare function useAsync<T>(asyncFn: (...args: unknown[]) => Promise<T>, options?: UseAsyncOptions<T>): UseAsyncReturn<T>;
+/**
+ * Create a batch of async operations that can be executed in parallel.
+ *
+ * @example
+ * ```typescript
+ * const { results, isLoading, execute } = useAsyncBatch([
+ *   () => fetchUser(userId),
+ *   () => fetchPosts(userId),
+ *   () => fetchComments(userId),
+ * ])
+ *
+ * await execute()
+ * // results.value = [user, posts, comments]
+ * ```
+ */
+export declare function useAsyncBatch<T extends readonly (() => Promise<unknown>)[]>(asyncFns: T): {
+    results: Ref<{
+        [K in keyof T]: Awaited<ReturnType<T[K]>> | null;
+    }>;
+    errors: Ref<(AsyncError | null)[]>;
+    isLoading: Ref<boolean>;
+    execute: () => Promise<void>;
+    reset: () => void;
+};

package/dist/composables/useAuth.d.ts

@@ -0,0 +1,47 @@
+import { Ref } from 'vue';
+import { AuthConfig, UserInfo } from '../types';
+/**
+ * Authentication composable with automatic token refresh.
+ *
+ * Features:
+ * - Automatic token refresh before expiration
+ * - Login/logout/register functionality
+ * - Token verification on startup
+ * - User profile management
+ *
+ * @example
+ * ```typescript
+ * const { login, logout, isAuthenticated, user } = useAuth()
+ *
+ * // Login
+ * const success = await login('username', 'password')
+ *
+ * // Automatic refresh is enabled by default
+ * // Tokens are refreshed 5 minutes before expiration
+ * ```
+ */
+export interface UseAuthReturn {
+    login: (username: string, password: string) => Promise<boolean>;
+    logout: () => void;
+    register: (username: string, password: string, email?: string) => Promise<boolean>;
+    verifyToken: () => Promise<boolean>;
+    fetchAuthConfig: () => Promise<AuthConfig>;
+    initializeAuth: () => Promise<void>;
+    getCurrentUser: () => Promise<UserInfo | null>;
+    getAuthHeader: () => Record<string, string>;
+    updateProfile: (data: {
+        email?: string;
+        shortname?: string;
+        currentPassword?: string;
+        newPassword?: string;
+    }) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    refreshToken: () => Promise<boolean>;
+    isRefreshing: Ref<boolean>;
+}
+/** @internal Reset module-level state — only for use in tests. */
+export declare function _resetAuthStateForTesting(): void;
+/** Manages authentication state with login/logout/register and automatic JWT token refresh. */
+export declare function useAuth(): UseAuthReturn;

package/dist/composables/useAutoGroup.d.ts

@@ -0,0 +1,106 @@
+import { InputMode, OutlierAction, OutlierInfo, ColumnInfo, MetadataRow, AutoGroupResult, ParsedCsvData } from '../types/auto-group';
+import { SampleGroup } from '../types/components';
+export declare const DEFAULT_COLORS: string[];
+export declare function analyzeDelimiter(lines: string[]): {
+    delimiter: string;
+    dominantFieldCount: number;
+    minFieldCount: number;
+    consistency: number;
+};
+export declare function detectOutliers(lines: string[], delimiter: string, minFieldCount: number): OutlierInfo[];
+export declare function classifyOutlierAction(sample: string, delimiter: string): OutlierAction;
+export declare function isUsefulField(field: ColumnInfo, rowCount: number): boolean;
+export declare function extractColumns(samples: string[], delimiter: string, minFieldCount: number): ColumnInfo[];
+export declare function parseCSVLine(line: string, delimiter?: string): string[];
+export declare function parseCSV(text: string): ParsedCsvData;
+export declare function computeGroups(allSamples: string[], columns: ColumnInfo[], enabledFields: Set<number>, outlierActions: Map<number, OutlierAction>, delimiter: string, minFieldCount: number): {
+    groups: SampleGroup[];
+    metadata: MetadataRow[];
+    excludedSamples: string[];
+};
+/**
+ * Extract sample metadata from raw design_data into ParsedCsvData format.
+ *
+ * Looks for a `samples` array in the design data. For each sample, merges
+ * the `conditions` dict (the metadata table) with the `sample_name` to
+ * produce a flat tabular row. QC and blank samples are filtered out by
+ * their explicit `sample_type` field.
+ *
+ * Returns null if no samples with conditions are found.
+ */
+export declare function extractSamplesFromDesignData(rawData: Record<string, unknown>): ParsedCsvData | null;
+export declare function computeGroupsFromCsv(csvData: ParsedCsvData, columns: ColumnInfo[], enabledFields: Set<number>): {
+    groups: SampleGroup[];
+    metadata: MetadataRow[];
+    excludedSamples: string[];
+};
+/** Parses sample names or CSV data to propose group assignments with outlier detection and preview. */
+export declare function useAutoGroup(): {
+    inputMode: import('vue').Ref<InputMode, InputMode>;
+    rawText: import('vue').Ref<string, string>;
+    csvData: import('vue').Ref<{
+        columns: string[];
+        rows: Record<string, string>[];
+        sampleColumn: string;
+        delimiter: string;
+    } | null, ParsedCsvData | {
+        columns: string[];
+        rows: Record<string, string>[];
+        sampleColumn: string;
+        delimiter: string;
+    } | null>;
+    delimiter: import('vue').Ref<string, string>;
+    dominantFieldCount: import('vue').Ref<number, number>;
+    minFieldCount: import('vue').Ref<number, number>;
+    outliers: import('vue').Ref<{
+        sample: string;
+        index: number;
+        fieldCount: number;
+        action: OutlierAction;
+    }[], OutlierInfo[] | {
+        sample: string;
+        index: number;
+        fieldCount: number;
+        action: OutlierAction;
+    }[]>;
+    fields: import('vue').Ref<{
+        index: number;
+        name: string;
+        uniqueValues: string[];
+        cardinality: number;
+        type?: "prefix" | "suffix" | undefined;
+        originalName?: string | undefined;
+    }[], ColumnInfo[] | {
+        index: number;
+        name: string;
+        uniqueValues: string[];
+        cardinality: number;
+        type?: "prefix" | "suffix" | undefined;
+        originalName?: string | undefined;
+    }[]>;
+    fieldNames: import('vue').Ref<Record<number, string>, Record<number, string>>;
+    enabledFields: import('vue').Ref<Set<number> & Omit<Set<number>, keyof Set<any>>, Set<number> | (Set<number> & Omit<Set<number>, keyof Set<any>>)>;
+    samples: import('vue').ComputedRef<string[]>;
+    hasOutliers: import('vue').ComputedRef<boolean>;
+    conformingSamples: import('vue').ComputedRef<string[]>;
+    groups: import('vue').ComputedRef<SampleGroup[]>;
+    metadata: import('vue').ComputedRef<MetadataRow[]>;
+    excludedSamples: import('vue').ComputedRef<string[]>;
+    allSingletons: import('vue').ComputedRef<boolean>;
+    result: import('vue').ComputedRef<AutoGroupResult>;
+    effectiveColumns: import('vue').ComputedRef<{
+        name: string;
+        index: number;
+        uniqueValues: string[];
+        cardinality: number;
+        type?: "prefix" | "suffix" | undefined;
+        originalName?: string | undefined;
+    }[]>;
+    parseInput: () => void;
+    loadExperimentData: (rawData: Record<string, unknown>) => boolean;
+    setOutlierAction: (index: number, action: OutlierAction) => void;
+    setAllOutlierActions: (action: OutlierAction) => void;
+    toggleField: (index: number) => void;
+    renameField: (index: number, name: string) => void;
+    reset: () => void;
+};

package/dist/composables/useChemicalFormula.d.ts

@@ -0,0 +1,21 @@
+export interface ParsedElement {
+    symbol: string;
+    count: number;
+}
+export interface FormulaParseResult {
+    elements: Record<string, number>;
+    valid: boolean;
+    error?: string;
+}
+export type FormulaPartType = 'element' | 'subscript' | 'superscript' | 'paren' | 'dot' | 'charge';
+export interface FormulaPart {
+    type: FormulaPartType;
+    text: string;
+}
+export declare const ATOMIC_WEIGHTS: Record<string, number>;
+/** Parses and renders chemical formulas, computes molecular weight, and generates rich-text formula parts. */
+export declare function useChemicalFormula(): {
+    parseFormula: (formula: string) => FormulaParseResult;
+    calculateMW: (elements: Record<string, number>) => number;
+    renderFormulaParts: (formula: string) => FormulaPart[];
+};

package/dist/composables/useConcentrationUnits.d.ts

@@ -0,0 +1,29 @@
+import { ComputedRef } from 'vue';
+export type MolarityUnit = 'pM' | 'nM' | 'µM' | 'mM' | 'M';
+export type MassVolumeUnit = 'pg/mL' | 'ng/mL' | 'µg/mL' | 'mg/mL' | 'g/mL';
+export type PercentageUnit = '% v/v' | '% w/v' | '% w/w';
+export type ConcentrationUnit = MolarityUnit | MassVolumeUnit | PercentageUnit | string;
+export interface ConcentrationValue {
+    value: number;
+    unit: ConcentrationUnit;
+}
+export interface UnitCategory {
+    label: string;
+    units: ConcentrationUnit[];
+}
+export interface UseConcentrationUnitsReturn {
+    unitCategories: ComputedRef<UnitCategory[]>;
+    molarityUnits: MolarityUnit[];
+    massVolumeUnits: MassVolumeUnit[];
+    percentageUnits: PercentageUnit[];
+    convert: (value: number, from: ConcentrationUnit, to: ConcentrationUnit, mw?: number) => number | null;
+    formatWithUnit: (concentration: ConcentrationValue, precision?: number) => string;
+    parseConcentration: (input: string) => ConcentrationValue | null;
+    getBaseUnit: (unit: ConcentrationUnit) => ConcentrationUnit;
+    getConversionHint: (concentration: ConcentrationValue) => string | null;
+    isMolarity: (unit: ConcentrationUnit) => boolean;
+    isMassVolume: (unit: ConcentrationUnit) => boolean;
+    isPercentage: (unit: ConcentrationUnit) => boolean;
+}
+/** Converts between molarity, mass/volume, and percentage concentration units with formatting helpers. */
+export declare function useConcentrationUnits(): UseConcentrationUnitsReturn;

package/dist/composables/useDoseCalculator.d.ts

@@ -0,0 +1,58 @@
+import { ConcentrationValue, MolarityUnit, MassVolumeUnit } from './useConcentrationUnits';
+export type VolumeUnit = 'µL' | 'mL' | 'L';
+export interface VolumeValue {
+    value: number;
+    unit: VolumeUnit;
+}
+export interface DilutionParams {
+    stockConcentration: ConcentrationValue;
+    finalConcentration: ConcentrationValue;
+    finalVolume: VolumeValue;
+}
+export interface DilutionResult {
+    stockVolume: VolumeValue;
+    diluentVolume: VolumeValue;
+    dilutionFactor: number;
+    valid: boolean;
+    error?: string;
+}
+export interface SerialDilutionParams {
+    startingConcentration: ConcentrationValue;
+    dilutionFactor: number;
+    numberOfDilutions: number;
+    volumePerWell: VolumeValue;
+}
+export interface SerialDilutionStep {
+    stepNumber: number;
+    concentration: ConcentrationValue;
+    transferVolume: VolumeValue;
+    diluentVolume: VolumeValue;
+}
+export interface SerialDilutionResult {
+    steps: SerialDilutionStep[];
+    totalStockVolume: VolumeValue;
+    valid: boolean;
+    error?: string;
+}
+export interface ConversionResult {
+    result: ConcentrationValue;
+    valid: boolean;
+    error?: string;
+}
+export interface WellConcentration {
+    wellId: string;
+    concentration: ConcentrationValue;
+    volume?: VolumeValue;
+}
+export interface UseDoseCalculatorReturn {
+    volumeUnits: VolumeUnit[];
+    calculateDilution: (params: DilutionParams) => DilutionResult;
+    calculateSerialDilution: (params: SerialDilutionParams) => SerialDilutionResult;
+    convertMassToMolar: (mass: number, massUnit: MassVolumeUnit, mw: number) => ConcentrationValue;
+    convertMolarToMass: (molar: number, molarUnit: MolarityUnit, mw: number) => ConcentrationValue;
+    convertVolume: (value: number, from: VolumeUnit, to: VolumeUnit) => number;
+    formatVolume: (volume: VolumeValue, precision?: number) => string;
+    generateWellConcentrations: (result: SerialDilutionResult, wellIds: string[]) => WellConcentration[];
+}
+/** Calculates single dilutions, serial dilution series, and plate-filling volumes for dose-response experiments. */
+export declare function useDoseCalculator(): UseDoseCalculatorReturn;

package/dist/composables/useExperimentData.d.ts

@@ -0,0 +1,18 @@
+import { Ref, ComputedRef } from 'vue';
+import { TreeNode, SummaryData } from '../types';
+export interface UseExperimentDataOptions {
+    apiBaseUrl?: string;
+    immediate?: boolean;
+}
+export interface UseExperimentDataReturn {
+    data: Ref<Record<string, unknown> | null>;
+    treeData: ComputedRef<TreeNode[]>;
+    tableData: ComputedRef<Record<string, unknown>[]>;
+    summaryData: ComputedRef<SummaryData | null>;
+    isLoading: Ref<boolean>;
+    error: Ref<string | null>;
+    fetch: (experimentId: number) => Promise<void>;
+    refresh: () => Promise<void>;
+}
+/** Fetches and normalises experiment output data (tree, table, summary) from the platform API. */
+export declare function useExperimentData(options?: UseExperimentDataOptions): UseExperimentDataReturn;

package/dist/composables/useExperimentSave.d.ts

@@ -0,0 +1,36 @@
+import { Ref } from 'vue';
+export interface UseExperimentSaveOptions {
+    /** Default plugin_id for all save/load calls. */
+    pluginId?: string;
+    /** Default schema version for design saves (defaults to "1.0"). */
+    schemaVersion?: string;
+    /** Override API base URL. */
+    apiBaseUrl?: string;
+}
+export interface UseExperimentSaveReturn {
+    /** Whether a save operation is in progress. */
+    isSaving: Ref<boolean>;
+    /** Error message from the last failed operation, or null. */
+    error: Ref<string | null>;
+    /** Timestamp of the last successful save, or null. */
+    lastSavedAt: Ref<Date | null>;
+    /** Save design data for an experiment. */
+    saveDesign: (experimentId: number, data: Record<string, unknown>) => Promise<boolean>;
+    /** Save analysis result for an experiment. */
+    saveAnalysis: (experimentId: number, result: Record<string, unknown>) => Promise<boolean>;
+    /** Save design and/or analysis in one call. */
+    save: (experimentId: number, opts: {
+        design?: Record<string, unknown>;
+        analysis?: Record<string, unknown>;
+    }) => Promise<boolean>;
+    /** Load design data for an experiment. */
+    loadDesign: (experimentId: number) => Promise<Record<string, unknown> | null>;
+    /** Load analysis result for an experiment. */
+    loadAnalysis: (experimentId: number) => Promise<Record<string, unknown> | null>;
+    /** Delete design data for an experiment. */
+    deleteDesign: (experimentId: number) => Promise<boolean>;
+    /** Delete analysis result for an experiment. */
+    deleteAnalysis: (experimentId: number) => Promise<boolean>;
+}
+/** Persists and loads experiment design and analysis data via the plugin's API endpoint. */
+export declare function useExperimentSave(options?: UseExperimentSaveOptions): UseExperimentSaveReturn;

package/dist/composables/useExperimentSelector.d.ts

@@ -0,0 +1,30 @@
+import { Ref, ComputedRef } from 'vue';
+import { ExperimentSummary, ExperimentFilters, ExperimentTypeOption, SelectOption } from '../types';
+export interface UseExperimentSelectorOptions {
+    experimentType?: string;
+    apiBaseUrl?: string;
+    limit?: number;
+    immediate?: boolean;
+}
+export interface UseExperimentSelectorReturn {
+    experiments: Ref<ExperimentSummary[]>;
+    total: Ref<number>;
+    selectedExperiment: Ref<ExperimentSummary | null>;
+    filters: ExperimentFilters;
+    isLoading: Ref<boolean>;
+    error: Ref<string | null>;
+    page: Ref<number>;
+    hasMore: ComputedRef<boolean>;
+    sortKey: Ref<string>;
+    experimentTypes: Ref<ExperimentTypeOption[]>;
+    projects: Ref<SelectOption<string>[]>;
+    groupedByProject: ComputedRef<[string, ExperimentSummary[]][]>;
+    fetch: () => Promise<void>;
+    loadMore: () => Promise<void>;
+    reset: () => void;
+    select: (experiment: ExperimentSummary) => void;
+    clear: () => void;
+    fetchFilterOptions: () => Promise<void>;
+}
+/** Fetches a paginated, filtered experiment list from the platform API for picker and selector UIs. */
+export declare function useExperimentSelector(options?: UseExperimentSelectorOptions): UseExperimentSelectorReturn;