@morscherlab/mint-sdk 1.0.0-rc.2 → 1.0.0-rc.5

package/dist/composables/autoGroup/classKey.d.ts

@@ -0,0 +1,4 @@
+import { SampleClass } from '../../types/auto-group';
+export declare function classKey(c: Pick<SampleClass, 'kind'> & {
+    subKind?: string;
+}): string;

package/dist/composables/autoGroup/classify.d.ts

@@ -0,0 +1,28 @@
+import { SampleClass } from '../../types/auto-group';
+export interface ClassVocab {
+    blankPattern: RegExp;
+    iqcPattern: RegExp;
+    eqcPattern: RegExp;
+    standardPattern: RegExp;
+    standardAllow: Set<string>;
+    spikeInPattern: RegExp;
+    stockPattern: RegExp;
+    /**
+     * Matrix lookup: lowercase token → canonical display name. Matching is
+     * case-insensitive, and several aliases can collapse to one display name
+     * (cell → Cells, medium → Medium).
+     */
+    matrixVocab: Map<string, string>;
+    /** Lowercase polarity tokens → POS / NEG. */
+    ionizationModes: Map<string, 'POS' | 'NEG'>;
+    /** Lowercase tokens that flag the next token as the organ subKind. */
+    tissueParentTokens: Set<string>;
+}
+export declare const classVocab: ClassVocab;
+export interface DetectClassOptions {
+    vocab?: Partial<ClassVocab>;
+    /** Per-sample explicit `sample_type` hint (e.g. from experiment design data). */
+    sampleTypeHints?: (string | undefined)[];
+}
+/** Classify each tokenized sample into a SampleClass. */
+export declare function detectClass(tokenizedSamples: string[][], options: DetectClassOptions): SampleClass[];

package/dist/composables/autoGroup/colors.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_COLORS: string[];
+export declare const QC_OVERLAY_COLOR = "#6B7280";

package/dist/composables/autoGroup/columns.d.ts

@@ -0,0 +1,10 @@
+import { ColumnRole, ClassSchema, NumericParse, SampleClassKind } from '../../types/auto-group';
+export declare function parseNumeric(token: string): NumericParse | null;
+export interface InferRoleInput {
+    values: string[];
+    position: number;
+    totalPositions: number;
+    classSize: number;
+}
+export declare function inferRole(input: InferRoleInput): ColumnRole;
+export declare function buildClassSchema(tokenizedMembers: string[][], classKind: SampleClassKind, subKind: string | undefined, classTagPositions: number[]): ClassSchema;

package/dist/composables/autoGroup/compose.d.ts

@@ -0,0 +1,8 @@
+import { AutoGroupResult, ClassSchema, SampleClass } from '../../types/auto-group';
+export interface ComposeInput {
+    tokenizedSamples: string[][];
+    sampleNames: string[];
+    schemas: Record<string, ClassSchema>;
+    classes: SampleClass[];
+}
+export declare function composeGroups(input: ComposeInput): AutoGroupResult;

package/dist/composables/autoGroup/cooccurrence.d.ts

@@ -0,0 +1,2 @@
+import { ClassSchema, MergeSuggestion } from '../../types/auto-group';
+export declare function findMerges(schema: ClassSchema, rows: string[][]): MergeSuggestion[];

package/dist/composables/autoGroup/csv-shim.d.ts

@@ -0,0 +1,2 @@
+import { ParsedCsvData } from '../../types/auto-group';
+export declare function parseCSV(text: string): ParsedCsvData;

package/dist/composables/autoGroup/fingerprint.d.ts

@@ -0,0 +1,3 @@
+import { ClassSchema, SchemaFingerprint } from '../../types/auto-group';
+export declare function serializeFingerprint(schemas: ClassSchema[]): SchemaFingerprint;
+export declare function restoreFingerprint(fp: SchemaFingerprint, current: ClassSchema[]): ClassSchema[];

package/dist/composables/autoGroup/index.d.ts

@@ -0,0 +1,16 @@
+export { splitMulti, pickPrimaryDelimiter } from './tokenize';
+export type { Delimiter } from './tokenize';
+export { detectClass, classVocab } from './classify';
+export type { ClassVocab, DetectClassOptions } from './classify';
+export { inferRole, parseNumeric, buildClassSchema } from './columns';
+export type { InferRoleInput } from './columns';
+export { findMerges } from './cooccurrence';
+export { composeGroups } from './compose';
+export type { ComposeInput } from './compose';
+export { serializeFingerprint, restoreFingerprint } from './fingerprint';
+export { composeTemplate } from './template';
+export type { TemplateOptions } from './template';
+export { DEFAULT_COLORS, QC_OVERLAY_COLOR } from './colors';
+export { classKey } from './classKey';
+export { stripReplicateTokens, preGroupReplicates, expandGroupsWithReplicates, } from './replicatePreGroup';
+export type { ReplicatePreGrouping } from './replicatePreGroup';

package/dist/composables/autoGroup/replicatePreGroup.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Replicate pre-grouping.
+ *
+ * Strip the replicate / injection-number markers from each sample's name, then
+ * collapse samples that share a base name. Those samples ARE replicates of one
+ * another by definition; the remaining unique base names are what the rest of
+ * the pipeline (tokenize → classify → schema → compose) should operate on.
+ *
+ * This pre-pass replaces the older "treat every sample as independent, then
+ * infer replicate columns" approach. Identifying replicate-equivalence by name
+ * before tokenisation removes a class of fragile cardinality heuristics.
+ */
+/**
+ * Iteratively strip every replicate / injection-number marker from `name`.
+ * Each pattern is applied repeatedly until it stops matching, so a sample like
+ * `study_T1_Rep2_004` collapses to `study` in one call.
+ */
+export declare function stripReplicateTokens(name: string): string;
+export interface ReplicatePreGrouping {
+    /** Unique base names in first-seen order. Length === `originalSamples.length` only if every sample has a distinct base. */
+    baseNames: string[];
+    /**
+     * `membersByBase[i]` = original-sample indices that collapsed onto `baseNames[i]`.
+     * Length of each entry is the replicate count for that base.
+     */
+    membersByBase: number[][];
+    /** Original sample names indexed by their position in `samples`. Retained so the compose layer can expand groups back to originals. */
+    originalSamples: string[];
+}
+export declare function preGroupReplicates(samples: string[]): ReplicatePreGrouping;
+/**
+ * Expand groups produced over base names back to groups of original sample
+ * names. Each entry in `group.samples` is treated as a base name and replaced
+ * by the list of original samples that collapsed onto it.
+ */
+export declare function expandGroupsWithReplicates<G extends {
+    samples: string[];
+}>(groups: G[], preGrouping: ReplicatePreGrouping): G[];

package/dist/composables/autoGroup/template.d.ts

@@ -0,0 +1,15 @@
+import { ClassSchema, SampleClass } from '../../types/auto-group';
+export interface TemplateOptions {
+    mode: 'blank' | 'prefilled';
+    format: 'csv' | 'tsv';
+    /** For prefilled mode. Indexed parallel to `samples`. */
+    tokenizedSamples?: string[][];
+    /** Used to compute the filename; omitted → falls back to `sample_metadata_<date>`. */
+    experimentCode?: string;
+    /** Override the blank-mode suggested headers. Defaults to ['group','class','replicate','notes']. */
+    suggestedColumns?: string[];
+}
+export declare function composeTemplate(samples: string[], schemas: ClassSchema[] | null, classes: SampleClass[] | null, options: TemplateOptions): {
+    content: string;
+    filename: string;
+};

package/dist/composables/autoGroup/tokenize.d.ts

@@ -0,0 +1,8 @@
+declare const DELIMITER_CANDIDATES: readonly ["_", "-", "."];
+export type Delimiter = (typeof DELIMITER_CANDIDATES)[number];
+/** Pick the delimiter whose split produces the most consistent field count across `lines`. */
+export declare function pickPrimaryDelimiter(lines: string[]): Delimiter;
+/** Split a single sample name on `delimiter`. Empty input returns `['']` so callers
+ *  always receive at least one token. */
+export declare function splitMulti(name: string, delimiter: Delimiter): string[];
+export {};

package/dist/composables/autoGroupConstants.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_COLORS: string[];

package/dist/composables/autoGroupGrouping.d.ts

@@ -0,0 +1,3 @@
+import { AutoGroupResult, ColumnInfo, OutlierAction, ParsedCsvData } from '../types/auto-group';
+export declare function computeGroups(allSamples: string[], columns: ColumnInfo[], enabledFields: Set<number>, outlierActions: Map<number, OutlierAction>, delimiter: string, minFieldCount: number): AutoGroupResult;
+export declare function computeGroupsFromCsv(csvData: ParsedCsvData, columns: ColumnInfo[], enabledFields: Set<number>): AutoGroupResult;

package/dist/composables/controlComponentBindings.d.ts

@@ -0,0 +1,7 @@
+import { ControlComponentBinding, ControlComponentBindingsById, ControlComponentBindingsConfig, ControlComponentPropsMap } from './controlSchemaTypes';
+/** Map control workspace values into component props for direct `v-bind` usage. */
+export declare function controlValuesToComponentProps<TValues extends Record<string, unknown>>(values: TValues, mapping?: ControlComponentPropsMap<TValues>): Record<string, unknown>;
+/** Map control workspace values into named SDK component bindings for direct slot rendering. */
+export declare function controlValuesToComponentBindings<TValues extends Record<string, unknown>>(values: TValues, bindings?: ControlComponentBindingsConfig<TValues>): ControlComponentBinding[];
+/** Map control workspace values into SDK component bindings keyed by binding id. */
+export declare function controlValuesToComponentBindingsById<TValues extends Record<string, unknown>>(values: TValues, bindings?: ControlComponentBindingsConfig<TValues>): ControlComponentBindingsById;

package/dist/composables/controlSchemaAdapters.d.ts

@@ -0,0 +1,20 @@
+import { PillNavItem, SidebarToolSection, SettingsModalSchema, TopBarSettingsConfig } from '../types';
+import { ControlFormSchema, ControlSchema, ControlSchemaOptions } from './controlSchemaTypes';
+/** Convert a compact control schema into a FormBuilder schema. */
+export declare function controlsToFormSchema(controls: ControlSchema, options?: ControlSchemaOptions): ControlFormSchema;
+/** Convert controls into AppSidebar panels grouped by view and section. */
+export declare function controlsToSidebarPanels(controls: ControlSchema, options?: ControlSchemaOptions): Record<string, SidebarToolSection[]>;
+/** Convert controls into a SettingsModal schema grouped by the same sections. */
+export declare function controlsToSettingsSchema(controls: ControlSchema, options?: ControlSchemaOptions): SettingsModalSchema;
+/** Convert controls into an AppTopBar settingsConfig object that passes compact controls through to SettingsModal. */
+export declare function controlsToTopBarSettingsConfig(controls: ControlSchema, options?: ControlSchemaOptions, config?: Omit<TopBarSettingsConfig, 'schema' | 'controls' | 'controlOptions'>): TopBarSettingsConfig;
+/** Return generated control view IDs that have at least one sidebar panel. */
+export declare function controlsToViewIds(controls: ControlSchema, options?: ControlSchemaOptions): string[];
+/** Return AppTopBar pillNav-compatible view items for switching generated control sidebars. */
+export declare function controlsToViewItems(controls: ControlSchema, options?: ControlSchemaOptions): PillNavItem[];
+/** Return the first generated sidebar view ID, or an empty string when controls render no sidebar panels. */
+export declare function getDefaultControlView(controls: ControlSchema, options?: ControlSchemaOptions): string;
+/** Return a headerless single-section FormBuilder schema for rendering inside an AppSidebar section slot. */
+export declare function controlsToSectionFormSchema(controls: ControlSchema, sectionId: string, options?: ControlSchemaOptions): ControlFormSchema;
+/** Return headerless FormBuilder schemas keyed by section ID for AppSidebar auto-rendering. */
+export declare function controlsToSectionFormSchemas(controls: ControlSchema, options?: ControlSchemaOptions): Record<string, ControlFormSchema>;

package/dist/composables/controlSchemaDoseDesign.d.ts

@@ -0,0 +1,11 @@
+import { ControlComponentBindingsConfig, ControlComponentPropsByIdMap, ControlComponentPropsMap, ControlModelBinding, DoseCalculatorControlPropsOptions, DoseDesignControlModelOptions, WellPlateControlPropsOptions, WellPlateDoseControlPropsOptions } from './controlSchemaTypes';
+/** Return a default WellPlate prop mapping for generated control workspaces. */
+export declare function defineWellPlateControlProps<TValues extends Record<string, unknown> = Record<string, unknown>>(options?: WellPlateControlPropsOptions<TValues>): ControlComponentPropsMap<TValues>;
+/** Return a default DoseCalculator prop mapping for generated control workspaces. */
+export declare function defineDoseCalculatorControlProps<TValues extends Record<string, unknown> = Record<string, unknown>>(options?: DoseCalculatorControlPropsOptions<TValues>): ControlComponentPropsMap<TValues>;
+/** Return named WellPlate + DoseCalculator prop mappings for one dose-design control model. */
+export declare function defineWellPlateDoseControlProps<TValues extends Record<string, unknown> = Record<string, unknown>>(options?: WellPlateDoseControlPropsOptions<TValues>): ControlComponentPropsByIdMap<TValues>;
+/** Return named WellPlate + DoseCalculator component bindings for one dose-design control model. */
+export declare function defineWellPlateDoseComponentBindings<TValues extends Record<string, unknown> = Record<string, unknown>>(options?: WellPlateDoseControlPropsOptions<TValues>): ControlComponentBindingsConfig<TValues>;
+/** Return a complete ControlWorkspaceView model for WellPlate + DoseCalculator dose design. */
+export declare function defineDoseDesignControlModel(options?: DoseDesignControlModelOptions): ControlModelBinding;

package/dist/composables/controlSchemaFormFields.d.ts

@@ -0,0 +1,3 @@
+import { FormFieldSchema } from '../types/form-builder';
+import { NormalizedControl } from './controlSchemaNormalize';
+export declare function controlToFormField(control: NormalizedControl): FormFieldSchema;

package/dist/composables/controlSchemaLayout.d.ts

@@ -0,0 +1,7 @@
+import { PillNavItem } from '../types';
+import { NormalizedControl } from './controlSchemaNormalize';
+import { ControlDefinition, ControlSchemaOptions, ControlSectionConfig, ControlSidebarConfig } from './controlSchemaTypes';
+export declare function sectionConfig(sectionId: string, controls: NormalizedControl[], options: ControlSchemaOptions): ControlSectionConfig;
+export declare function firstSidebarConfig(controls: NormalizedControl[]): ControlSidebarConfig | undefined;
+export declare function isSidebarEnabled(sidebar: ControlDefinition['sidebar']): boolean;
+export declare function controlViewItem(viewId: string, options: ControlSchemaOptions): PillNavItem;

package/dist/composables/controlSchemaModel.d.ts

@@ -0,0 +1,5 @@
+import { ControlModel, ControlModelBinding } from './controlSchemaTypes';
+export declare function isControlModelBinding<TBinding extends ControlModelBinding = ControlModelBinding>(model: unknown): model is TBinding;
+export declare function resolveControlModel(model: ControlModel | ControlModelBinding | undefined): ControlModelBinding | undefined;
+/** Create a complete workspace component binding from a simple controls data model for ControlWorkspaceView, generated forms, and sidebars. */
+export declare function defineControlModel(model: ControlModel): ControlModelBinding;

package/dist/composables/controlSchemaNormalize.d.ts

@@ -0,0 +1,15 @@
+import { SelectOption } from '../types';
+import { FormFieldType } from '../types/form-builder';
+import { ControlDefinition, ControlInput, ControlOption, ControlSchema, ControlSchemaOptions } from './controlSchemaTypes';
+export interface NormalizedControl {
+    name: string;
+    definition: ControlDefinition;
+    type: FormFieldType;
+    sectionId: string;
+    viewId: string;
+    order: number;
+}
+export declare function normalizeControls(controls: ControlSchema, options?: ControlSchemaOptions): NormalizedControl[];
+export declare function normalizeControlDefinition(input: ControlInput): ControlDefinition;
+export declare function defaultValueForControl(definition: ControlDefinition, type: FormFieldType): unknown;
+export declare function normalizeOption(option: ControlOption): SelectOption<unknown>;

package/dist/composables/controlSchemaTypes.d.ts

@@ -0,0 +1,305 @@
+import { ComputedRef, Ref } from 'vue';
+import { PillNavItem, SidebarToolSection, SelectOption, SettingsModalSchema, TopBarSettingsConfig } from '../types';
+import { AccessPolicy, AccessAudienceInput } from '../permissions';
+import { FieldCondition, FieldValidation, FormFieldSchema, FormFieldType, FormSchema, FormSectionSchema } from '../types/form-builder';
+import { WellConcentration } from './useDoseCalculator';
+export type ControlOptionValue = string | number | boolean;
+export type ControlOption = ControlOptionValue | SelectOption<unknown>;
+export type ControlPrimitive = string | number | boolean;
+export type ControlShorthand = ControlPrimitive | readonly ControlOption[];
+export type ControlInput = ControlDefinition | ControlShorthand;
+export interface ControlSectionConfig {
+    id?: string;
+    label?: string;
+    title?: string;
+    description?: string;
+    subtitle?: string;
+    icon?: string | string[];
+    iconColor?: string;
+    iconBg?: string;
+    columns?: 1 | 2 | 3;
+    condition?: FieldCondition;
+    access?: AccessPolicy;
+    visibleFor?: AccessAudienceInput;
+    requiresAdmin?: boolean;
+    permissions?: readonly string[];
+    anyPermissions?: readonly string[];
+    defaultOpen?: boolean;
+    showToggle?: boolean;
+}
+export interface ControlViewConfig {
+    label?: string;
+    icon?: string;
+    to?: string;
+    href?: string;
+    disabled?: boolean;
+    children?: PillNavItem['children'];
+}
+export interface ControlSidebarConfig extends Omit<ControlSectionConfig, 'id' | 'title' | 'description' | 'columns'> {
+    enabled?: boolean;
+}
+export interface ControlDefinition {
+    type?: FormFieldType;
+    label?: string;
+    default?: unknown;
+    defaultValue?: unknown;
+    placeholder?: string;
+    hint?: string;
+    size?: 'sm' | 'md' | 'lg';
+    disabled?: boolean;
+    readonly?: boolean;
+    required?: boolean | string;
+    min?: number | {
+        value: number;
+        message: string;
+    };
+    max?: number | {
+        value: number;
+        message: string;
+    };
+    minLength?: number | {
+        value: number;
+        message: string;
+    };
+    maxLength?: number | {
+        value: number;
+        message: string;
+    };
+    email?: boolean | string;
+    pattern?: string | {
+        value: string;
+        message: string;
+    };
+    validation?: FieldValidation;
+    condition?: FieldCondition;
+    access?: AccessPolicy;
+    visibleFor?: AccessAudienceInput;
+    requiresAdmin?: boolean;
+    permissions?: readonly string[];
+    anyPermissions?: readonly string[];
+    options?: readonly ControlOption[];
+    section?: string;
+    sectionLabel?: string;
+    sectionDescription?: string;
+    sectionSubtitle?: string;
+    view?: string;
+    order?: number;
+    colSpan?: number;
+    props?: Record<string, unknown>;
+    sidebar?: boolean | ControlSidebarConfig;
+}
+export type ControlSchema = Record<string, ControlInput>;
+export type ControlFormSchema = Extract<FormSchema, {
+    sections: FormSectionSchema[];
+}>;
+export interface ControlSchemaOptions {
+    view?: string;
+    views?: Record<string, ControlViewConfig>;
+    section?: string;
+    sectionLabel?: string;
+    sections?: Record<string, ControlSectionConfig>;
+    columns?: 1 | 2 | 3;
+    submitLabel?: string;
+    cancelLabel?: string;
+    showCancel?: boolean;
+}
+export interface ControlWorkspaceOptions extends ControlSchemaOptions {
+    initialValues?: Record<string, unknown>;
+    topBarSettings?: Omit<TopBarSettingsConfig, 'schema' | 'controls' | 'controlOptions' | 'values'>;
+}
+export interface ControlModelSectionConfig extends ControlSectionConfig {
+    controls: ControlSchema;
+    sidebar?: boolean | ControlSidebarConfig;
+}
+export interface ControlModelViewConfig extends ControlViewConfig {
+    controls?: ControlSchema;
+    section?: string;
+    sectionLabel?: string;
+    sectionDescription?: string;
+    sections?: Record<string, ControlModelSectionConfig>;
+}
+export interface ControlModel extends Omit<ControlWorkspaceOptions, 'sections' | 'views'> {
+    controls?: ControlSchema;
+    sections?: Record<string, ControlModelSectionConfig>;
+    views?: Record<string, ControlModelViewConfig>;
+    /** Optional SDK component bindings returned with generated component props for custom workspace slots. */
+    componentBindings?: ControlComponentBindingsConfig;
+    /** Alias for componentBindings in raw control models. */
+    components?: ControlComponentBindingsConfig;
+    /** Optional ControlWorkspaceView componentProps mapping returned with the generated controls/options. */
+    componentProps?: ControlComponentPropsMap;
+    /** Optional named componentProps mappings returned for multiple SDK components. */
+    componentPropsById?: ControlComponentPropsByIdMap;
+}
+export interface ControlModelBinding {
+    controls: ControlSchema;
+    controlOptions: ControlWorkspaceOptions;
+    componentBindings?: ControlComponentBindingsConfig;
+    componentProps?: ControlComponentPropsMap;
+    componentPropsById?: ControlComponentPropsByIdMap;
+}
+export interface ControlSidebarBinding {
+    panels: Record<string, SidebarToolSection[]>;
+    forms: Record<string, ControlFormSchema>;
+    viewIds: string[];
+    viewItems: PillNavItem[];
+    defaultView: string;
+}
+export interface ControlFormBinding {
+    schema: ControlFormSchema;
+}
+export interface ControlSettingsBinding {
+    schema: SettingsModalSchema;
+}
+export interface ControlTopBarSettingsBinding {
+    showSettings: true;
+    settingsConfig: TopBarSettingsConfig;
+}
+export interface ControlWorkspaceFormBinding extends ControlFormBinding {
+    modelValue: Record<string, unknown>;
+    'onUpdate:modelValue': (values: Record<string, unknown>) => void;
+}
+export interface ControlWorkspaceSidebarBinding extends ControlSidebarBinding {
+    activeView: string;
+    modelValue: Record<string, unknown>;
+    'onUpdate:modelValue': (values: Record<string, unknown>) => void;
+    values: Record<string, unknown>;
+    'onUpdate:values': (values: Record<string, unknown>) => void;
+}
+export interface ControlWorkspaceTopBarSettingsBinding extends ControlTopBarSettingsBinding {
+    onSettingsValuesChange: (values: Record<string, unknown>) => void;
+}
+export interface ControlWorkspacePillNavBinding {
+    items: PillNavItem[];
+    currentItemId: string;
+    onSelect: (item: PillNavItem) => void;
+}
+export interface ControlWorkspaceTopBarBinding extends ControlWorkspaceTopBarSettingsBinding {
+    pillNav: PillNavItem[];
+    currentPillId: string;
+    onPillSelect: (item: PillNavItem) => void;
+}
+export type ControlWorkspaceAppTopBarPillBinding = ControlWorkspaceTopBarBinding;
+export interface ControlWorkspaceComponentBindings {
+    form: ControlWorkspaceFormBinding;
+    sidebar: ControlWorkspaceSidebarBinding;
+    topBar: ComputedRef<ControlWorkspaceTopBarBinding>;
+    topBarSettings: ControlWorkspaceTopBarSettingsBinding;
+    pillNav: ControlWorkspacePillNavBinding;
+    componentBindings: ComputedRef<ControlComponentBinding[]>;
+    componentBindingsById: ComputedRef<ControlComponentBindingsById>;
+    componentProps: ComputedRef<Record<string, unknown>>;
+    componentPropsById: ComputedRef<Record<string, Record<string, unknown>>>;
+}
+export type ControlComponentPropSource<TValues extends Record<string, unknown> = Record<string, unknown>> = (keyof TValues & string) | ((values: TValues) => unknown);
+export type ControlComponentPropsMap<TValues extends Record<string, unknown> = Record<string, unknown>> = readonly (keyof TValues & string)[] | Record<string, ControlComponentPropSource<TValues>>;
+export type ControlComponentPropsByIdMap<TValues extends Record<string, unknown> = Record<string, unknown>> = Record<string, ControlComponentPropsMap<TValues>>;
+export interface ControlComponentBindingConfig<TValues extends Record<string, unknown> = Record<string, unknown>> {
+    id?: string;
+    component: string;
+    props?: ControlComponentPropsMap<TValues>;
+}
+export interface ControlComponentBindingRecordConfig<TValues extends Record<string, unknown> = Record<string, unknown>> {
+    component: string;
+    props?: ControlComponentPropsMap<TValues>;
+}
+export type ControlComponentBindingsConfig<TValues extends Record<string, unknown> = Record<string, unknown>> = readonly ControlComponentBindingConfig<TValues>[] | Record<string, ControlComponentBindingRecordConfig<TValues>>;
+export interface ControlComponentBinding {
+    id: string;
+    component: string;
+    props: Record<string, unknown>;
+}
+export type ControlComponentBindingsById = Record<string, ControlComponentBinding>;
+export interface WellPlateControlPropsOptions<TValues extends Record<string, unknown> = Record<string, unknown>> {
+    selectedWells?: ControlComponentPropSource<TValues>;
+    format?: ControlComponentPropSource<TValues>;
+    wells?: ControlComponentPropSource<TValues>;
+    disabled?: ControlComponentPropSource<TValues>;
+    readonly?: ControlComponentPropSource<TValues>;
+    showLegend?: ControlComponentPropSource<TValues>;
+    showSampleTypeIndicator?: ControlComponentPropSource<TValues>;
+    /** Listener for WellPlate v-model updates. Set false to keep generated props one-way. */
+    onUpdateModelValue?: ((values: TValues) => (wellIds: string[]) => void) | false;
+}
+export interface DoseCalculatorControlPropsOptions<TValues extends Record<string, unknown> = Record<string, unknown>> {
+    mode?: ControlComponentPropSource<TValues>;
+    targetWells?: ControlComponentPropSource<TValues>;
+    /** Control value key used by the default apply-to-wells handler. */
+    wells?: ControlComponentPropSource<TValues>;
+    disabled?: ControlComponentPropSource<TValues>;
+    molecularWeight?: ControlComponentPropSource<TValues>;
+    /** Listener for DoseCalculator apply-to-wells. Set false to keep generated props one-way. */
+    onApplyToWells?: ((values: TValues) => (results: WellConcentration[]) => void) | false;
+}
+export interface WellPlateDoseControlPropsOptions<TValues extends Record<string, unknown> = Record<string, unknown>> {
+    plateId?: string;
+    doseId?: string;
+    plate?: WellPlateControlPropsOptions<TValues>;
+    dose?: DoseCalculatorControlPropsOptions<TValues>;
+}
+export interface DoseDesignControlModelOptions {
+    viewId?: string;
+    viewLabel?: string;
+    sectionId?: string;
+    sectionLabel?: string;
+    sectionDescription?: string;
+    selectedWells?: readonly string[];
+    plateFormat?: number;
+    plateFormats?: readonly number[];
+    doseMode?: 'serial' | 'dilution' | 'conversion';
+    doseModes?: readonly ('serial' | 'dilution' | 'conversion')[];
+    disabled?: boolean;
+    includeMolecularWeight?: boolean;
+    molecularWeight?: number;
+    componentProps?: WellPlateDoseControlPropsOptions;
+}
+export interface UseControlSchemaReturn<TControls extends ControlSchema> {
+    controls: TControls;
+    fields: FormFieldSchema[];
+    formSchema: ControlFormSchema;
+    form: ControlFormBinding;
+    settingsSchema: SettingsModalSchema;
+    settings: ControlSettingsBinding;
+    topBarSettingsConfig: TopBarSettingsConfig;
+    topBarSettings: ControlTopBarSettingsBinding;
+    sidebarPanels: Record<string, SidebarToolSection[]>;
+    viewIds: string[];
+    viewItems: PillNavItem[];
+    defaultView: string;
+    sectionSchemas: Record<string, ControlFormSchema>;
+    sidebar: ControlSidebarBinding;
+    initialValues: ControlValues<TControls>;
+    sectionSchema: (sectionId: string) => ControlFormSchema;
+}
+export interface UseControlWorkspaceReturn<TControls extends ControlSchema> extends Omit<UseControlSchemaReturn<TControls>, 'form' | 'sidebar' | 'topBarSettings'> {
+    schema: UseControlSchemaReturn<TControls>;
+    values: ControlValues<TControls> & Record<string, unknown>;
+    activeView: Ref<string>;
+    form: ControlWorkspaceFormBinding;
+    sidebar: ControlWorkspaceSidebarBinding;
+    topBar: ComputedRef<ControlWorkspaceTopBarBinding>;
+    pillNav: ControlWorkspacePillNavBinding;
+    topBarSettings: ControlWorkspaceTopBarSettingsBinding;
+    bindings: ControlWorkspaceComponentBindings;
+    componentBindings: ComputedRef<ControlComponentBinding[]>;
+    componentBindingsById: ComputedRef<ControlComponentBindingsById>;
+    componentProps: ComputedRef<Record<string, unknown>>;
+    componentPropsById: ComputedRef<Record<string, Record<string, unknown>>>;
+    setActiveView: (viewId: string) => void;
+    setValues: (values: Record<string, unknown>) => void;
+    resetValues: (values?: Record<string, unknown>) => void;
+    getComponentProps: (mapping?: ControlComponentPropsMap<ControlValues<TControls> & Record<string, unknown>>) => Record<string, unknown>;
+    getComponentPropsById: (mappings?: ControlComponentPropsByIdMap<ControlValues<TControls> & Record<string, unknown>>) => Record<string, Record<string, unknown>>;
+    getComponentBindings: (bindings?: ControlComponentBindingsConfig<ControlValues<TControls> & Record<string, unknown>>) => ControlComponentBinding[];
+    getComponentBindingsById: (bindings?: ControlComponentBindingsConfig<ControlValues<TControls> & Record<string, unknown>>) => ControlComponentBindingsById;
+}
+export type ControlValues<TControls extends ControlSchema> = {
+    [K in keyof TControls]: ControlValue<TControls[K]>;
+};
+type ControlValue<TControl> = TControl extends {
+    default: infer TDefault;
+} ? TDefault : TControl extends {
+    defaultValue: infer TDefaultValue;
+} ? TDefaultValue : TControl extends readonly [infer First, ...unknown[]] ? OptionValue<First> : TControl extends ControlPrimitive ? TControl : unknown;
+type OptionValue<TOption> = TOption extends SelectOption<infer TValue> ? TValue : TOption;
+export {};

package/dist/composables/controlSchemaUtils.d.ts

@@ -0,0 +1,9 @@
+export declare function recordValue(value: unknown): Record<string, unknown>;
+export declare function numericValue(value: number | {
+    value: number;
+    message: string;
+}): number;
+export declare function orderedUnique(values: string[]): string[];
+export declare function replaceRecord(target: Record<string, unknown>, values: Record<string, unknown>): void;
+export declare function omitUndefined<T extends object>(record: T): T;
+export declare function humanize(value: string): string;

package/dist/composables/controlWorkspaceOptions.d.ts

@@ -0,0 +1,2 @@
+import { ControlWorkspaceOptions } from './controlSchemaTypes';
+export declare function mergeControlWorkspaceOptions(base?: ControlWorkspaceOptions, override?: ControlWorkspaceOptions): ControlWorkspaceOptions;

package/dist/composables/formBuilderSchema.d.ts

@@ -0,0 +1,18 @@
+import { FieldRules } from './useForm';
+import { FieldCondition, FormEnhancements, FormFieldSchema, FormSchema, FormSectionSchema } from '../types/form-builder';
+/**
+ * Evaluate a JSON-serializable field condition against the current form data.
+ *
+ * Supports logical operators (`and`, `or`, `not`) and comparison operators
+ * (`eq`, `neq`, `gt`, `lt`, `gte`, `lte`, `in`, `notIn`, `truthy`, `falsy`,
+ * `contains`). Returns `true` if the condition passes.
+ */
+export declare function evaluateCondition(condition: FieldCondition, data: Record<string, unknown>): boolean;
+/** Return all sections across steps (wizard) or directly from a flat schema. */
+export declare function collectSections(schema: FormSchema): FormSectionSchema[];
+/** Return all field schemas in schema order, flattening sections and steps. */
+export declare function flattenFields(schema: FormSchema): FormFieldSchema[];
+export declare function buildInitialValues<T extends Record<string, unknown>>(fields: readonly FormFieldSchema[], initialData?: Partial<T>): Record<string, unknown>;
+export declare function buildRules<T extends Record<string, unknown>>(fields: readonly FormFieldSchema[], enhancements?: FormEnhancements<T>): Partial<Record<string, FieldRules>>;
+export declare function replaceArray<T>(target: T[], values: readonly T[]): void;
+export declare function replaceRecord<TValue>(target: Partial<Record<string, TValue>>, source: Partial<Record<string, TValue>>): void;

package/dist/composables/index.js

@@ -1,4 +1,4 @@
-import { $n as addMinutes, An as defineWellPlateDoseComponentBindings, Cn as controlsToViewItems, Dn as defineDoseCalculatorControlProps, En as defineControls, Fn as useControlSchema, In as useControlWorkspace, Kn as ATOMIC_WEIGHTS, Ln as getFieldRegistryEntry, Mn as getControlDefaults, Nn as getDefaultControlView, On as defineDoseDesignControlModel, Rn as getTypeDefault, Sn as controlsToViewIds, Tn as defineControlModel, Vn as useConcentrationUnits, Wn as useSequenceUtils, _n as controlsToSectionFormSchema, ar as formatTime, bn as controlsToSidebarPanels, br as useEventListener, cr as generateTimeSlots, dr as rangesOverlap, er as compareTime, fr as snapToSlot, g as toBioTemplateComponentProps, gn as controlsToFormSchema, hn as controlValuesToComponentProps, ir as formatDuration, jn as defineWellPlateDoseControlProps, kn as defineWellPlateControlProps, l as requireBioTemplateControlSchema, lr as isTimeInRange, m as toBioTemplateComponentBindingsById, mn as controlValuesToComponentBindingsById, mr as useTimeUtils, nr as findAvailableSlots, o as getBioTemplateControlSchema, or as formatTimeSlot, p as toBioTemplateComponentBindings, pn as controlValuesToComponentBindings, pr as toMinutes, qn as useChemicalFormula, rr as findNearestTimeSlotIndex, sr as fromMinutes, tr as durationMinutes, u as getBioTemplateComponentBindings, ur as parseTime, v as toBioTemplateComponentPropsById, vn as controlsToSectionFormSchemas, vr as useListSelection, wn as defineControlComponentBindings, xn as controlsToTopBarSettingsConfig, yn as controlsToSettingsSchema, yr as useSelectionLimit } from "../templates-BorLR_7p.js";
-import { $ as usePlatformContext, B as useRequestSyncState, C as useExpansionSet, F as useWellPlateEditor, G as EXPERIMENT_STATUS_OPTIONS, H as useApi, I as useDoseCalculator, J as datePresetToISO, K as EXPERIMENT_STATUS_VARIANT_MAP, L as APP_EXPERIMENT_KEY, M as extractSampleNamesFromDesignData, N as extractSampleOptionsFromDesignData, O as DEFAULT_COLORS, P as unwrapExperimentDesignData, Q as resolveExperimentCode, R as useAppExperiment, U as DATE_PRESET_OPTIONS, V as useDebouncedWatch, W as EXPERIMENT_STATUS_LABELS, X as formatExperimentStatus, Y as formatExperimentDate, Z as getExperimentStatusVariant, _ as useScheduleDrag, a as useReagentSeries, at as candidateMatchesSearch, c as useBioTemplatePresetWorkspace, ct as compareSortValues, d as getBioTemplateComponentProps, et as evaluateCondition, f as toBioTemplateComponentPropsByComponent, g as useExperimentSave, h as useTemplateCollection, i as generateDilutionSeries, it as useToast, j as useAutoGroup, k as extractSamplesFromDesignData, l as useBioTemplatePackWorkspace, lt as useSortedItems, m as useBioTemplateControls, n as DEFAULT_PRESETS, nt as useForm, o as useGroupAssignment, ot as normalizeSearchQuery, p as useBioTemplateComponents, q as SORT_OPTIONS, r as DEFAULT_UNITS, rt as useTheme, s as useRackEditor, st as useTextSearch, t as useProtocolTemplates, tt as useFormBuilder, u as useBioTemplateWorkspace, v as useExperimentSamples, w as useSampleGroups, y as useExperimentData, z as useExperimentSelector } from "../useProtocolTemplates-n6AJqSqv.js";
-import { a as useCurrentExperiment, c as usePluginConfig, d as usePasskey, f as useAuth, i as resolvePluginBaseUrl, l as useAsync, n as createPluginClient, o as usePluginClient, r as getPluginPageSelectorItems, s as usePluginSettings, t as buildPluginEndpointUrl, u as useAsyncBatch } from "../composables-Bg7CFuNz.js";
+import { An as controlsToSectionFormSchema, B as toBioTemplateComponentProps, Cn as defineControlModel, Dn as controlValuesToComponentProps, En as controlValuesToComponentBindingsById, Fn as controlsToViewIds, Gn as useSequenceUtils, H as toBioTemplateComponentPropsById, Hn as useConcentrationUnits, In as controlsToViewItems, Jn as useChemicalFormula, L as toBioTemplateComponentBindings, Ln as getDefaultControlView, Mn as controlsToSettingsSchema, Nn as controlsToSidebarPanels, P as getBioTemplateComponentBindings, Pn as controlsToTopBarSettingsConfig, R as toBioTemplateComponentBindingsById, Rn as getFieldRegistryEntry, Sn as useControlWorkspace, Tn as controlValuesToComponentBindings, _n as defineDoseCalculatorControlProps, ar as formatDuration, bn as defineWellPlateDoseComponentBindings, br as useSelectionLimit, cr as fromMinutes, dr as parseTime, er as addMinutes, fr as rangesOverlap, gn as useControlSchema, hn as getControlDefaults, hr as useTimeUtils, ir as findNearestTimeSlotIndex, jn as controlsToSectionFormSchemas, kn as controlsToFormSchema, l as requireBioTemplateControlSchema, lr as generateTimeSlots, mn as defineControls, mr as toMinutes, nr as durationMinutes, o as getBioTemplateControlSchema, or as formatTime, pn as defineControlComponentBindings, pr as snapToSlot, qn as ATOMIC_WEIGHTS, rr as findAvailableSlots, sr as formatTimeSlot, tr as compareTime, ur as isTimeInRange, vn as defineDoseDesignControlModel, xn as defineWellPlateDoseControlProps, xr as useEventListener, yn as defineWellPlateControlProps, yr as useListSelection, zn as getTypeDefault } from "../templates-DtdUvJ4c.js";
+import { $ as resolveExperimentCode, B as useExperimentSelector, C as useExpansionSet, G as EXPERIMENT_STATUS_LABELS, H as useDebouncedWatch, I as useWellPlateEditor, J as SORT_OPTIONS, K as EXPERIMENT_STATUS_OPTIONS, L as useDoseCalculator, M as extractSampleOptionsFromDesignData, N as unwrapExperimentDesignData, O as extractSamplesFromDesignData, P as DEFAULT_COLORS, Q as getExperimentStatusVariant, R as APP_EXPERIMENT_KEY, U as useApi, V as useRequestSyncState, W as DATE_PRESET_OPTIONS, X as formatExperimentDate, Y as datePresetToISO, Z as formatExperimentStatus, _ as useScheduleDrag, a as useReagentSeries, at as useToast, c as useBioTemplatePresetWorkspace, ct as useTextSearch, d as getBioTemplateComponentProps, et as usePlatformContext, f as toBioTemplateComponentPropsByComponent, g as useExperimentSave, h as useTemplateCollection, i as generateDilutionSeries, it as useTheme, j as extractSampleNamesFromDesignData, k as useAutoGroup, l as useBioTemplatePackWorkspace, lt as compareSortValues, m as useBioTemplateControls, n as DEFAULT_PRESETS, nt as evaluateCondition, o as useGroupAssignment, ot as candidateMatchesSearch, p as useBioTemplateComponents, q as EXPERIMENT_STATUS_VARIANT_MAP, r as DEFAULT_UNITS, rt as useForm, s as useRackEditor, st as normalizeSearchQuery, t as useProtocolTemplates, tt as useFormBuilder, u as useBioTemplateWorkspace, ut as useSortedItems, v as useExperimentSamples, w as useSampleGroups, y as useExperimentData, z as useAppExperiment } from "../useProtocolTemplates-Bm5vyH4_.js";
+import { a as usePluginSettings, c as usePluginConfig, d as usePasskey, f as useAuth, i as usePluginClient, l as useAsync, n as getPluginPageSelectorItems, o as buildPluginEndpointUrl, r as useCurrentExperiment, s as resolvePluginBaseUrl, t as createPluginClient, u as useAsyncBatch } from "../composables-Dlg8jenH.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, buildPluginEndpointUrl, candidateMatchesSearch, compareSortValues, compareTime, controlValuesToComponentBindings, controlValuesToComponentBindingsById, controlValuesToComponentProps, controlsToFormSchema, controlsToSectionFormSchema, controlsToSectionFormSchemas, controlsToSettingsSchema, controlsToSidebarPanels, controlsToTopBarSettingsConfig, controlsToViewIds, controlsToViewItems, createPluginClient, datePresetToISO, defineControlComponentBindings, defineControlModel, defineControls, defineDoseCalculatorControlProps, defineDoseDesignControlModel, defineWellPlateControlProps, defineWellPlateDoseComponentBindings, defineWellPlateDoseControlProps, durationMinutes, evaluateCondition, extractSampleNamesFromDesignData, extractSampleOptionsFromDesignData, extractSamplesFromDesignData, findAvailableSlots, findNearestTimeSlotIndex, formatDuration, formatExperimentDate, formatExperimentStatus, formatTime, formatTimeSlot, fromMinutes, generateDilutionSeries, generateTimeSlots, getBioTemplateComponentBindings, getBioTemplateComponentProps, getBioTemplateControlSchema, getControlDefaults, getDefaultControlView, getExperimentStatusVariant, getFieldRegistryEntry, getPluginPageSelectorItems, getTypeDefault, isTimeInRange, normalizeSearchQuery, parseTime, rangesOverlap, requireBioTemplateControlSchema, resolveExperimentCode, resolvePluginBaseUrl, snapToSlot, toBioTemplateComponentBindings, toBioTemplateComponentBindingsById, toBioTemplateComponentProps, toBioTemplateComponentPropsByComponent, toBioTemplateComponentPropsById, toMinutes, unwrapExperimentDesignData, useApi, useAppExperiment, useAsync, useAsyncBatch, useAuth, useAutoGroup, useBioTemplateComponents, useBioTemplateControls, useBioTemplatePackWorkspace, useBioTemplatePresetWorkspace, useBioTemplateWorkspace, useChemicalFormula, useConcentrationUnits, useControlSchema, useControlWorkspace, useCurrentExperiment, useDebouncedWatch, useDoseCalculator, useEventListener, useExpansionSet, useExperimentData, useExperimentSamples, useExperimentSave, useExperimentSelector, useForm, useFormBuilder, useGroupAssignment, useListSelection, usePasskey, usePlatformContext, usePluginClient, usePluginConfig, usePluginSettings, useProtocolTemplates, useRackEditor, useReagentSeries, useRequestSyncState, useSampleGroups, useScheduleDrag, useSelectionLimit, useSequenceUtils, useSortedItems, useTemplateCollection, useTextSearch, useTheme, useTimeUtils, useToast, useWellPlateEditor };

package/dist/composables/pluginEndpointBuilder.d.ts

@@ -0,0 +1,13 @@
+import { BuildPluginEndpointUrlOptions, PluginContract, PluginEndpointDefinition } from './usePluginClient';
+/** Resolve the runtime plugin API base URL from env, explicit options, platform injection, or contract metadata. */
+export declare function resolvePluginBaseUrl(contract: PluginContract, explicitBaseUrl?: string): string;
+export declare function hasKeys(value: Record<string, unknown>): boolean;
+export declare function requestBodyFromPayload(payload: unknown, requestPayload: Record<string, unknown>, endpoint: PluginEndpointDefinition): unknown;
+export declare function pluginEndpointRequestParts(contract: PluginContract, endpoint: PluginEndpointDefinition, payload?: unknown, explicitBaseUrl?: string): {
+    baseUrl: string;
+    path: string;
+    query: Record<string, unknown>;
+    requestPayload: Record<string, unknown>;
+};
+/** Build the concrete URL for a generated plugin endpoint without making a request. */
+export declare function buildPluginEndpointUrl(contract: PluginContract, endpoint: PluginEndpointDefinition, payload?: unknown, options?: BuildPluginEndpointUrlOptions): string;