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

package/dist/useScheduleDrag-D4oWdh41.js

@@ -0,0 +1,4371 @@
+import { Dn as useControlWorkspace, Ft as extractTemplateCollection, Mn as useConcentrationUnits, On as getFieldRegistryEntry, Ot as createTemplateCollection, Pt as ensureTemplateFromCollection, Xt as getBioTemplatePresetInfo, _ as toBioTemplateComponentSnippets, d as getBioTemplateComponentProps$1, dt as createBioTemplatePresetCollection, en as getBioTemplatePackInfo, ft as createBioTemplatePresetCollectionFromControls, g as toBioTemplateComponentPropsById, h as toBioTemplateComponentPropsByComponent$1, i as createBioTemplateControlToolkit, kn as getTypeDefault, m as toBioTemplateComponentProps, p as toBioTemplateComponentImports, u as getBioTemplateComponentBindings, ut as createBioTemplatePackCollection, v as toBioTemplateComponentUsage } from "./templates-50NPjaxL.js";
+import { r as useSettingsStore, t as useAuthStore } from "./auth-QQj2kkze.js";
+import { computed, effectScope, getCurrentScope, onMounted, onScopeDispose, onUnmounted, provide, reactive, readonly, ref, shallowRef, toRaw, toValue, watch } from "vue";
+import axios from "axios";
+//#region src/composables/useSortedItems.ts
+/** Shared sorting for SDK tables and lists with stable empty-value handling. */
+function useSortedItems(options) {
+	const sort = computed(() => toValue(options.sort));
+	const enabled = computed(() => toValue(options.enabled) ?? true);
+	return {
+		sort,
+		sortedItems: computed(() => {
+			const items = [...toValue(options.items)];
+			const activeSort = sort.value;
+			if (!enabled.value || !activeSort?.key || !activeSort.direction) return items;
+			const direction = activeSort.direction;
+			const caseSensitive = toValue(options.caseSensitive) ?? true;
+			return items.sort((a, b) => {
+				const aValue = options.getValue(a, activeSort.key);
+				const bValue = options.getValue(b, activeSort.key);
+				if (options.compare) return options.compare(aValue, bValue, {
+					key: activeSort.key,
+					direction,
+					a,
+					b
+				});
+				return compareSortValues(aValue, bValue, direction, { caseSensitive });
+			});
+		})
+	};
+}
+function compareSortValues(aValue, bValue, direction = "asc", options = {}) {
+	const aEmpty = aValue === null || aValue === void 0;
+	const bEmpty = bValue === null || bValue === void 0;
+	if (aEmpty && bEmpty) return 0;
+	if (aEmpty) return 1;
+	if (bEmpty) return -1;
+	const aComparable = toComparableSortValue(aValue, options);
+	const bComparable = toComparableSortValue(bValue, options);
+	let comparison = 0;
+	if (typeof aComparable === "number" && typeof bComparable === "number") comparison = aComparable - bComparable;
+	else comparison = String(aComparable).localeCompare(String(bComparable));
+	return direction === "asc" ? comparison : -comparison;
+}
+function toComparableSortValue(value, options) {
+	if (value instanceof Date) return value.getTime();
+	if (typeof value === "string" && options.caseSensitive === false) return value.toLowerCase();
+	return value;
+}
+//#endregion
+//#region src/composables/useTextSearch.ts
+/** Shared text-search filtering for tables, lists, selectors, and chip inputs. */
+function useTextSearch(options) {
+	const query = computed(() => normalizeSearchQuery(toValue(options.query)));
+	const enabled = computed(() => toValue(options.enabled) ?? true);
+	function matches(item, overrideQuery) {
+		const activeQuery = overrideQuery === void 0 ? query.value : normalizeSearchQuery(overrideQuery);
+		if (!activeQuery) return true;
+		return candidateMatchesSearch(options.getText(item), activeQuery);
+	}
+	return {
+		query,
+		filteredItems: computed(() => {
+			const items = [...toValue(options.items)];
+			if (!enabled.value || !query.value) return items;
+			return items.filter((item) => matches(item));
+		}),
+		matches
+	};
+}
+function normalizeSearchQuery(value) {
+	return (value ?? "").trim().toLowerCase();
+}
+function candidateMatchesSearch(candidate, query) {
+	const normalizedQuery = normalizeSearchQuery(query);
+	if (!normalizedQuery) return true;
+	return (Array.isArray(candidate) ? candidate : [candidate]).some((value) => {
+		if (value === null || value === void 0) return false;
+		return String(value).toLowerCase().includes(normalizedQuery);
+	});
+}
+//#endregion
+//#region src/composables/useToast.ts
+var toasts = ref([]);
+var nextId = 0;
+/** Reactive global toast queue with success/error/warning/info variants and auto-dismiss timers. */
+function useToast() {
+	function show(message, type = "success", duration = 3500) {
+		const id = nextId++;
+		toasts.value.push({
+			id,
+			message,
+			type,
+			duration
+		});
+		setTimeout(() => dismiss(id), duration);
+	}
+	function success(message, duration = 3500) {
+		show(message, "success", duration);
+	}
+	function error(message, duration = 5e3) {
+		show(message, "error", duration);
+	}
+	function warning(message, duration = 4e3) {
+		show(message, "warning", duration);
+	}
+	function info(message, duration = 3500) {
+		show(message, "info", duration);
+	}
+	function dismiss(id) {
+		toasts.value = toasts.value.filter((t) => t.id !== id);
+	}
+	function clear() {
+		toasts.value = [];
+	}
+	return {
+		toasts,
+		show,
+		success,
+		error,
+		warning,
+		info,
+		dismiss,
+		clear
+	};
+}
+//#endregion
+//#region src/composables/useTheme.ts
+/** Reads and toggles the active theme (light/dark/system) with reactivity to OS preference changes. */
+function useTheme() {
+	const settings = useSettingsStore();
+	settings.initialize();
+	const isDark = computed(() => settings.isDark());
+	function toggleTheme() {
+		settings.theme = isDark.value ? "light" : "dark";
+	}
+	function setTheme(theme) {
+		settings.theme = theme;
+	}
+	return {
+		isDark,
+		toggleTheme,
+		setTheme
+	};
+}
+//#endregion
+//#region src/composables/useForm.ts
+var validators = {
+	required: (value, message = "This field is required") => {
+		if (value === null || value === void 0 || value === "") return message;
+		if (Array.isArray(value) && value.length === 0) return message;
+		return null;
+	},
+	minLength: (value, min, message) => {
+		if (typeof value !== "string") return null;
+		if (value.length < min) return message || `Must be at least ${min} characters`;
+		return null;
+	},
+	maxLength: (value, max, message) => {
+		if (typeof value !== "string") return null;
+		if (value.length > max) return message || `Must be at most ${max} characters`;
+		return null;
+	},
+	min: (value, min, message) => {
+		if (typeof value !== "number") return null;
+		if (value < min) return message || `Must be at least ${min}`;
+		return null;
+	},
+	max: (value, max, message) => {
+		if (typeof value !== "number") return null;
+		if (value > max) return message || `Must be at most ${max}`;
+		return null;
+	},
+	pattern: (value, pattern, message) => {
+		if (typeof value !== "string") return null;
+		if (!pattern.test(value)) return message || "Invalid format";
+		return null;
+	},
+	email: (value, message = "Invalid email address") => {
+		if (typeof value !== "string" || !value) return null;
+		if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) return message;
+		return null;
+	}
+};
+/**
+* Form state management composable with validation.
+*
+* @param initialValues - Initial form values
+* @param rules - Validation rules for each field
+*
+* @example
+* ```typescript
+* const { data, errors, isValid, handleSubmit, getFieldProps } = useForm(
+*   { email: '', password: '' },
+*   {
+*     email: { required: true, email: true },
+*     password: { required: true, minLength: 8 },
+*   }
+* )
+*
+* // In template
+* <BaseInput v-bind="getFieldProps('email')" label="Email" />
+* <BaseInput v-bind="getFieldProps('password')" type="password" label="Password" />
+* <BaseButton @click="handleSubmit(onSubmit)" :disabled="!isValid">Submit</BaseButton>
+* ```
+*/
+/** Reactive form state with field-level validation, dirty tracking, and submit handling. */
+function useForm(initialValues, rules = {}) {
+	const cloneableInitialValues = deepToRaw(initialValues);
+	let _initialValues = structuredClone(cloneableInitialValues);
+	const data = reactive(structuredClone(cloneableInitialValues));
+	const errors = reactive(Object.keys(initialValues).reduce((acc, key) => {
+		acc[key] = null;
+		return acc;
+	}, {}));
+	const touched = reactive(Object.keys(initialValues).reduce((acc, key) => {
+		acc[key] = false;
+		return acc;
+	}, {}));
+	const dirty = reactive(Object.keys(initialValues).reduce((acc, key) => {
+		acc[key] = false;
+		return acc;
+	}, {}));
+	const isSubmitting = ref(false);
+	watch(() => ({ ...data }), (newData) => {
+		for (const key of Object.keys(newData)) dirty[key] = newData[key] !== _initialValues[key];
+	}, { deep: true });
+	function validateField(field) {
+		const value = data[field];
+		const fieldRules = rules[field];
+		if (!fieldRules) {
+			errors[field] = null;
+			return true;
+		}
+		if (fieldRules.required) {
+			const message = typeof fieldRules.required === "string" ? fieldRules.required : void 0;
+			const error = validators.required(value, message);
+			if (error) {
+				errors[field] = error;
+				return false;
+			}
+		}
+		if (value === null || value === void 0 || value === "") {
+			errors[field] = null;
+			return true;
+		}
+		if (fieldRules.minLength !== void 0) {
+			const config = typeof fieldRules.minLength === "number" ? {
+				value: fieldRules.minLength,
+				message: void 0
+			} : fieldRules.minLength;
+			const error = validators.minLength(value, config.value, config.message);
+			if (error) {
+				errors[field] = error;
+				return false;
+			}
+		}
+		if (fieldRules.maxLength !== void 0) {
+			const config = typeof fieldRules.maxLength === "number" ? {
+				value: fieldRules.maxLength,
+				message: void 0
+			} : fieldRules.maxLength;
+			const error = validators.maxLength(value, config.value, config.message);
+			if (error) {
+				errors[field] = error;
+				return false;
+			}
+		}
+		if (fieldRules.min !== void 0) {
+			const config = typeof fieldRules.min === "number" ? {
+				value: fieldRules.min,
+				message: void 0
+			} : fieldRules.min;
+			const error = validators.min(value, config.value, config.message);
+			if (error) {
+				errors[field] = error;
+				return false;
+			}
+		}
+		if (fieldRules.max !== void 0) {
+			const config = typeof fieldRules.max === "number" ? {
+				value: fieldRules.max,
+				message: void 0
+			} : fieldRules.max;
+			const error = validators.max(value, config.value, config.message);
+			if (error) {
+				errors[field] = error;
+				return false;
+			}
+		}
+		if (fieldRules.pattern !== void 0) {
+			const config = fieldRules.pattern instanceof RegExp ? {
+				value: fieldRules.pattern,
+				message: void 0
+			} : fieldRules.pattern;
+			const error = validators.pattern(value, config.value, config.message);
+			if (error) {
+				errors[field] = error;
+				return false;
+			}
+		}
+		if (fieldRules.email) {
+			const message = typeof fieldRules.email === "string" ? fieldRules.email : void 0;
+			const error = validators.email(value, message);
+			if (error) {
+				errors[field] = error;
+				return false;
+			}
+		}
+		if (fieldRules.custom) {
+			const customRules = Array.isArray(fieldRules.custom) ? fieldRules.custom : [fieldRules.custom];
+			for (const rule of customRules) {
+				const error = rule(value, data);
+				if (error) {
+					errors[field] = error;
+					return false;
+				}
+			}
+		}
+		errors[field] = null;
+		return true;
+	}
+	function validate() {
+		let isAllValid = true;
+		for (const field of Object.keys(data)) if (!validateField(field)) isAllValid = false;
+		return isAllValid;
+	}
+	const isValid = computed(() => {
+		return Object.values(errors).every((error) => error === null);
+	});
+	const isDirty = computed(() => {
+		return Object.values(dirty).some((d) => d);
+	});
+	function setFieldValue(field, value) {
+		data[field] = value;
+		if (touched[field]) validateField(field);
+	}
+	function setFieldError(field, error) {
+		errors[field] = error;
+	}
+	function setFieldTouched(field, isTouched = true) {
+		touched[field] = isTouched;
+		if (isTouched) validateField(field);
+	}
+	function reset(values) {
+		const resetValues = values ? {
+			..._initialValues,
+			...values
+		} : _initialValues;
+		for (const key of Object.keys(data)) {
+			data[key] = structuredClone(deepToRaw(resetValues[key]));
+			errors[key] = null;
+			touched[key] = false;
+			dirty[key] = false;
+		}
+	}
+	function replaceState(values) {
+		const nextValues = structuredClone(deepToRaw(values));
+		_initialValues = structuredClone(nextValues);
+		for (const key of Object.keys(data)) {
+			if (key in nextValues) continue;
+			delete data[key];
+			delete errors[key];
+			delete touched[key];
+			delete dirty[key];
+		}
+		for (const key of Object.keys(nextValues)) {
+			data[key] = structuredClone(deepToRaw(nextValues[key]));
+			errors[key] = null;
+			touched[key] = false;
+			dirty[key] = false;
+		}
+	}
+	function handleSubmit(onSubmit) {
+		return async (e) => {
+			e?.preventDefault();
+			for (const field of Object.keys(data)) touched[field] = true;
+			if (!validate()) return;
+			isSubmitting.value = true;
+			try {
+				await onSubmit(data);
+			} finally {
+				isSubmitting.value = false;
+			}
+		};
+	}
+	function getFieldProps(field) {
+		const fieldStr = field;
+		return {
+			modelValue: data[field],
+			"onUpdate:modelValue": (value) => setFieldValue(field, value),
+			onBlur: () => setFieldTouched(fieldStr),
+			error: touched[fieldStr] ? errors[fieldStr] : null
+		};
+	}
+	return {
+		data,
+		errors,
+		touched,
+		dirty,
+		isValid,
+		isDirty,
+		isSubmitting,
+		setFieldValue,
+		setFieldError,
+		setFieldTouched,
+		validateField,
+		validate,
+		reset,
+		replaceState,
+		handleSubmit,
+		getFieldProps
+	};
+}
+function deepToRaw(value) {
+	const raw = toRaw(value);
+	if (Array.isArray(raw)) return raw.map((item) => deepToRaw(item));
+	if (isPlainRecord(raw)) return Object.fromEntries(Object.entries(raw).map(([key, item]) => [key, deepToRaw(item)]));
+	return raw;
+}
+function isPlainRecord(value) {
+	return Object.prototype.toString.call(value) === "[object Object]";
+}
+//#endregion
+//#region src/composables/useFormBuilder.ts
+/**
+* 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.
+*/
+function evaluateCondition(condition, data) {
+	if ("and" in condition) return condition.and.every((c) => evaluateCondition(c, data));
+	if ("or" in condition) return condition.or.some((c) => evaluateCondition(c, data));
+	if ("not" in condition) return !evaluateCondition(condition.not, data);
+	const value = data[condition.field];
+	if ("eq" in condition) return value === condition.eq;
+	if ("neq" in condition) return value !== condition.neq;
+	if ("gt" in condition) return typeof value === "number" && value > condition.gt;
+	if ("lt" in condition) return typeof value === "number" && value < condition.lt;
+	if ("gte" in condition) return typeof value === "number" && value >= condition.gte;
+	if ("lte" in condition) return typeof value === "number" && value <= condition.lte;
+	if ("in" in condition) return condition.in.includes(value);
+	if ("notIn" in condition) return !condition.notIn.includes(value);
+	if ("truthy" in condition) return !!value;
+	if ("falsy" in condition) return !value;
+	if ("contains" in condition) {
+		if (typeof value === "string") return value.includes(condition.contains);
+		if (Array.isArray(value)) return value.includes(condition.contains);
+		return false;
+	}
+	return true;
+}
+/** Return all sections across steps (wizard) or directly from a flat schema. */
+function collectSections(schema) {
+	return schema.steps ? schema.steps.flatMap((step) => step.sections) : schema.sections;
+}
+/** Return all field schemas in schema order, flattening sections and steps. */
+function flattenFields(schema) {
+	return collectSections(schema).flatMap((section) => section.fields);
+}
+/** Convert a JSON-safe `FieldValidation` descriptor to a runtime `FieldRules` object. */
+function convertValidation(v) {
+	const rules = {};
+	if (v.required !== void 0) rules.required = v.required;
+	if (v.minLength !== void 0) rules.minLength = v.minLength;
+	if (v.maxLength !== void 0) rules.maxLength = v.maxLength;
+	if (v.min !== void 0) rules.min = v.min;
+	if (v.max !== void 0) rules.max = v.max;
+	if (v.email !== void 0) rules.email = v.email;
+	if (v.pattern !== void 0) rules.pattern = typeof v.pattern === "string" ? new RegExp(v.pattern) : {
+		value: new RegExp(v.pattern.value),
+		message: v.pattern.message
+	};
+	return rules;
+}
+function buildInitialValues(fields, initialData) {
+	const initialValues = {};
+	for (const field of fields) {
+		const key = field.name;
+		if (initialData && hasOwnKey(initialData, key)) initialValues[key] = initialData[key];
+		else if (field.defaultValue !== void 0) initialValues[key] = field.defaultValue;
+		else initialValues[key] = getTypeDefault(field.type);
+	}
+	return initialValues;
+}
+function buildRules(fields, enhancements) {
+	const rules = {};
+	for (const field of fields) {
+		const base = field.validation ? convertValidation(field.validation) : {};
+		const enhancement = enhancements?.fields?.[field.name];
+		const customValidators = [];
+		if (enhancement?.validate) {
+			const fn = enhancement.validate;
+			customValidators.push((value, formData) => fn(value, formData));
+		}
+		if (customValidators.length > 0) base.custom = customValidators;
+		if (Object.keys(base).length > 0) rules[field.name] = base;
+	}
+	return rules;
+}
+function replaceArray(target, values) {
+	target.splice(0, target.length, ...values);
+}
+function replaceRecord(target, source) {
+	for (const key of Object.keys(target)) delete target[key];
+	Object.assign(target, source);
+}
+function hasOwnKey(source, key) {
+	return Object.prototype.hasOwnProperty.call(source, key);
+}
+/**
+* Drive a `FormSchema` as reactive form state.
+*
+* Builds initial values from schema defaults and `initialData`, derives
+* validation rules from `FieldValidation` descriptors and enhancement
+* validators, evaluates `FieldCondition` expressions for field/section
+* visibility, and wires wizard step navigation when `schema.steps` is set.
+*
+* @param schema - Declarative form or wizard schema.
+* @param initialData - Values that override schema defaults.
+* @param enhancements - TypeScript-only callbacks (dynamic options, validators,
+*   submit handler, transform, field-change watcher).
+*/
+/** Drives a declarative FormSchema as reactive state with conditional fields, wizard steps, and validation. */
+function useFormBuilder(schema, initialData, enhancements) {
+	const currentSchema = shallowRef(schema);
+	const fields = reactive(flattenFields(schema));
+	const sections = reactive(collectSections(schema));
+	const rules = reactive(buildRules(fields, enhancements));
+	const form = useForm(buildInitialValues(fields, initialData), rules);
+	function isFieldVisible(name) {
+		const enhancement = enhancements?.fields?.[name];
+		if (enhancement?.visible) return enhancement.visible(form.data);
+		const field = fields.find((f) => f.name === name);
+		if (field?.condition) return evaluateCondition(field.condition, form.data);
+		return true;
+	}
+	function isSectionVisible(id) {
+		const section = sections.find((s) => s.id === id);
+		if (section?.condition) return evaluateCondition(section.condition, form.data);
+		return true;
+	}
+	function getResolvedFieldProps(field) {
+		const entry = getFieldRegistryEntry(field.type);
+		const formProps = form.getFieldProps(field.name);
+		const merged = {
+			...entry.defaults,
+			...field.props ?? {}
+		};
+		const enhancement = enhancements?.fields?.[field.name];
+		if (enhancement?.props) Object.assign(merged, enhancement.props(form.data));
+		const options = getFieldOptions(field.name);
+		if (options) merged.options = options;
+		if (entry.vModel) {
+			merged.modelValue = formProps.modelValue;
+			merged["onUpdate:modelValue"] = formProps["onUpdate:modelValue"];
+		}
+		merged.onBlur = formProps.onBlur;
+		if (formProps.error) merged.error = true;
+		if (field.placeholder) merged.placeholder = field.placeholder;
+		if (field.size) merged.size = field.size;
+		if (field.disabled) merged.disabled = true;
+		if (field.readonly) merged.readonly = true;
+		if (field.type === "radio" && !merged.name) merged.name = field.name;
+		return merged;
+	}
+	function getFieldOptions(name) {
+		const enhancement = enhancements?.fields?.[name];
+		if (enhancement?.options) return enhancement.options(form.data);
+		const field = fields.find((f) => f.name === name);
+		if (field?.props?.options) return field.props.options;
+	}
+	const currentStep = ref(0);
+	const isCurrentStepValid = computed(() => {
+		if (!currentSchema.value.steps) return form.isValid.value;
+		const step = currentSchema.value.steps[currentStep.value];
+		if (!step) return true;
+		for (const section of step.sections) {
+			if (!isSectionVisible(section.id)) continue;
+			for (const field of section.fields) {
+				if (!isFieldVisible(field.name)) continue;
+				if (!form.validateField(field.name)) return false;
+			}
+		}
+		return true;
+	});
+	function goNext() {
+		if (!currentSchema.value.steps) return false;
+		const step = currentSchema.value.steps[currentStep.value];
+		if (!step) return false;
+		let valid = true;
+		for (const section of step.sections) {
+			if (!isSectionVisible(section.id)) continue;
+			for (const field of section.fields) {
+				if (!isFieldVisible(field.name)) continue;
+				form.setFieldTouched(field.name, true);
+				if (!form.validateField(field.name)) valid = false;
+			}
+		}
+		if (!valid) return false;
+		if (currentStep.value < currentSchema.value.steps.length - 1) currentStep.value++;
+		return true;
+	}
+	function goBack() {
+		if (currentStep.value > 0) currentStep.value--;
+	}
+	function goToStep(index) {
+		if (!currentSchema.value.steps) return;
+		if (index >= 0 && index < currentSchema.value.steps.length) currentStep.value = index;
+	}
+	function validate() {
+		let allValid = true;
+		for (const field of fields) {
+			if (!isFieldVisible(field.name)) continue;
+			form.setFieldTouched(field.name, true);
+			if (!form.validateField(field.name)) allValid = false;
+		}
+		return allValid;
+	}
+	async function submit() {
+		if (!validate()) return;
+		let submitData = {};
+		for (const field of fields) if (isFieldVisible(field.name)) submitData[field.name] = form.data[field.name];
+		if (enhancements?.transform) submitData = enhancements.transform(submitData);
+		if (enhancements?.onSubmit) {
+			form.isSubmitting.value = true;
+			try {
+				await enhancements.onSubmit(submitData);
+			} finally {
+				form.isSubmitting.value = false;
+			}
+		}
+	}
+	function reset(values) {
+		form.reset(values);
+		currentStep.value = 0;
+	}
+	function updateSchema(nextSchema, nextData) {
+		currentSchema.value = nextSchema;
+		const nextFields = flattenFields(nextSchema);
+		replaceArray(fields, nextFields);
+		replaceArray(sections, collectSections(nextSchema));
+		replaceRecord(rules, buildRules(nextFields, enhancements));
+		form.replaceState(buildInitialValues(nextFields, nextData));
+		currentStep.value = 0;
+	}
+	if (enhancements?.onFieldChange) {
+		const callback = enhancements.onFieldChange;
+		watch(() => ({ ...form.data }), (newData, oldData) => {
+			if (!oldData) return;
+			for (const key of Object.keys(newData)) if (newData[key] !== oldData[key]) callback(key, newData[key], newData);
+		}, { deep: true });
+	}
+	return {
+		form,
+		rules,
+		isFieldVisible,
+		isSectionVisible,
+		fields,
+		getResolvedFieldProps,
+		getFieldOptions,
+		currentStep,
+		isCurrentStepValid,
+		goNext,
+		goBack,
+		goToStep,
+		validate,
+		reset,
+		submit,
+		updateSchema
+	};
+}
+//#endregion
+//#region src/composables/useApi.ts
+var apiClientInstance = null;
+var interceptorAttached = false;
+function getApiClient() {
+	if (!apiClientInstance) apiClientInstance = axios.create({ headers: { "Content-Type": "application/json" } });
+	return apiClientInstance;
+}
+/** Axios-based API client that injects the plugin base URL and JWT auth header on every request. */
+function useApi(options = {}) {
+	const settingsStore = useSettingsStore();
+	const authStore = useAuthStore();
+	const apiClient = getApiClient();
+	if (!authStore.isInitialized) authStore.initialize();
+	if (!interceptorAttached) {
+		apiClient.interceptors.request.use((config) => {
+			if (authStore.token && config.headers && !config.headers.Authorization) config.headers.Authorization = `Bearer ${authStore.token}`;
+			return config;
+		});
+		interceptorAttached = true;
+	}
+	function requestConfig(config) {
+		const base = {
+			baseURL: options.baseUrl ?? settingsStore.getApiBaseUrl(),
+			timeout: options.timeout ?? settingsStore.requestTimeout,
+			...config
+		};
+		if (options.withAuth === false) base.headers = {
+			...base.headers,
+			Authorization: void 0
+		};
+		return base;
+	}
+	async function get(url, config) {
+		return (await apiClient.get(url, requestConfig(config))).data;
+	}
+	async function post(url, data, config) {
+		return (await apiClient.post(url, data, requestConfig(config))).data;
+	}
+	async function put(url, data, config) {
+		return (await apiClient.put(url, data, requestConfig(config))).data;
+	}
+	async function patch(url, data, config) {
+		return (await apiClient.patch(url, data, requestConfig(config))).data;
+	}
+	async function del(url, config) {
+		return (await apiClient.delete(url, requestConfig(config))).data;
+	}
+	async function upload(url, file, fieldName = "file", additionalData) {
+		const formData = new FormData();
+		formData.append(fieldName, file);
+		if (additionalData) Object.entries(additionalData).forEach(([key, value]) => {
+			if (value !== void 0 && value !== null) formData.append(key, typeof value === "object" ? JSON.stringify(value) : String(value));
+		});
+		return (await apiClient.post(url, formData, requestConfig({ headers: { "Content-Type": void 0 } }))).data;
+	}
+	async function download(url, filename) {
+		const response = await apiClient.get(url, requestConfig({ responseType: "blob" }));
+		const blob = new Blob([response.data]);
+		const blobUrl = URL.createObjectURL(blob);
+		if (filename) {
+			const link = document.createElement("a");
+			link.href = blobUrl;
+			link.download = filename;
+			document.body.appendChild(link);
+			link.click();
+			document.body.removeChild(link);
+			setTimeout(() => URL.revokeObjectURL(blobUrl), 100);
+			return "";
+		}
+		return blobUrl;
+	}
+	function buildUrl(path) {
+		return `${options.baseUrl ?? settingsStore.getApiBaseUrl()}${path}`;
+	}
+	function buildWsUrl(path) {
+		return `${settingsStore.getWsBaseUrl()}${path}`;
+	}
+	return {
+		client: apiClient,
+		get,
+		post,
+		put,
+		patch,
+		delete: del,
+		upload,
+		download,
+		buildUrl,
+		buildWsUrl
+	};
+}
+//#endregion
+//#region src/composables/useDebouncedWatch.ts
+/** Watch a Vue source with debounced callback execution and explicit cancel/flush controls. */
+function useDebouncedWatch(source, callback, options = {}) {
+	const { delay = 300, ...watchOptions } = options;
+	const isPending = ref(false);
+	let timer = null;
+	let hasLatestValue = false;
+	let latestValue;
+	let latestOldValue;
+	let callbackCleanup = null;
+	let stopped = false;
+	function clearTimer() {
+		if (timer) {
+			clearTimeout(timer);
+			timer = null;
+		}
+		isPending.value = false;
+	}
+	function runCallbackCleanup() {
+		if (!callbackCleanup) return;
+		callbackCleanup();
+		callbackCleanup = null;
+	}
+	function cancel() {
+		clearTimer();
+		hasLatestValue = false;
+		latestOldValue = void 0;
+	}
+	function flush() {
+		if (!hasLatestValue) return;
+		const value = latestValue;
+		const oldValue = latestOldValue;
+		cancel();
+		runCallbackCleanup();
+		callback(value, oldValue, (cleanup) => {
+			callbackCleanup = cleanup;
+		});
+	}
+	function schedule(value, oldValue) {
+		cancel();
+		hasLatestValue = true;
+		latestValue = value;
+		latestOldValue = oldValue;
+		isPending.value = true;
+		timer = setTimeout(flush, delay);
+	}
+	const stopWatch = watch(source, (value, oldValue, onCleanup) => {
+		schedule(value, oldValue);
+		onCleanup(() => {
+			cancel();
+			runCallbackCleanup();
+		});
+	}, watchOptions);
+	function stop() {
+		if (stopped) return;
+		stopped = true;
+		stopWatch();
+		cancel();
+		runCallbackCleanup();
+	}
+	onScopeDispose(stop);
+	return {
+		isPending,
+		cancel,
+		flush,
+		stop
+	};
+}
+//#endregion
+//#region src/composables/useRequestSyncState.ts
+/** Shared loading/error/timestamp state for generated plugin request helpers. */
+function useRequestSyncState(defaultErrorMessage = "Request failed.") {
+	const loading = ref(false);
+	const error = ref(null);
+	const lastLoadedAt = ref(null);
+	const lastSavedAt = ref(null);
+	const lastRunAt = ref(null);
+	function clearError() {
+		error.value = null;
+	}
+	function readErrorMessage(value, fallback = defaultErrorMessage) {
+		if (value instanceof Error && value.message) return value.message;
+		if (typeof value === "string" && value.trim()) return value;
+		if (typeof value === "object" && value !== null && "message" in value && typeof value.message === "string" && value.message) return value.message;
+		return fallback;
+	}
+	function setError(value, fallback) {
+		const message = readErrorMessage(value, fallback);
+		error.value = message;
+		return message;
+	}
+	function markLoaded(date = /* @__PURE__ */ new Date()) {
+		lastLoadedAt.value = date;
+	}
+	function markSaved(date = /* @__PURE__ */ new Date()) {
+		lastSavedAt.value = date;
+	}
+	function markRun(date = /* @__PURE__ */ new Date()) {
+		lastRunAt.value = date;
+	}
+	async function run(operation, options = {}) {
+		loading.value = true;
+		clearError();
+		try {
+			const response = await operation();
+			if (options.success === "load") markLoaded();
+			else if (options.success === "save") markSaved();
+			else if (options.success === "run") markRun();
+			return response;
+		} catch (err) {
+			setError(err, options.errorMessage);
+			throw err;
+		} finally {
+			loading.value = false;
+		}
+	}
+	return {
+		loading,
+		error,
+		lastLoadedAt,
+		lastSavedAt,
+		lastRunAt,
+		clearError,
+		readErrorMessage,
+		setError,
+		markLoaded,
+		markSaved,
+		markRun,
+		run
+	};
+}
+//#endregion
+//#region src/composables/experiment-utils.ts
+function formatExperimentDate(dateStr) {
+	try {
+		return new Date(dateStr).toLocaleDateString(void 0, {
+			year: "numeric",
+			month: "short",
+			day: "numeric"
+		});
+	} catch {
+		return dateStr;
+	}
+}
+function datePresetToISO(preset) {
+	const now = /* @__PURE__ */ new Date();
+	const days = preset === "last_7_days" ? 7 : preset === "last_30_days" ? 30 : 90;
+	return (/* @__PURE__ */ new Date(now.getTime() - days * 864e5)).toISOString();
+}
+var EXPERIMENT_STATUS_OPTIONS = [
+	{
+		value: "",
+		label: "All statuses"
+	},
+	{
+		value: "planned",
+		label: "Planned"
+	},
+	{
+		value: "ongoing",
+		label: "Ongoing"
+	},
+	{
+		value: "completed",
+		label: "Completed"
+	},
+	{
+		value: "cancelled",
+		label: "Cancelled"
+	}
+];
+var EXPERIMENT_STATUS_VARIANT_MAP = {
+	planned: "default",
+	ongoing: "primary",
+	completed: "success",
+	cancelled: "error"
+};
+var EXPERIMENT_STATUS_LABELS = {
+	planned: "Planned",
+	ongoing: "Ongoing",
+	completed: "Completed",
+	cancelled: "Cancelled"
+};
+var DATE_PRESET_OPTIONS = [
+	{
+		value: "",
+		label: "Any time"
+	},
+	{
+		value: "last_7_days",
+		label: "Last 7 days"
+	},
+	{
+		value: "last_30_days",
+		label: "Last 30 days"
+	},
+	{
+		value: "last_90_days",
+		label: "Last 90 days"
+	}
+];
+var SORT_OPTIONS = [
+	{
+		value: "created_at:desc",
+		label: "Newest first"
+	},
+	{
+		value: "created_at:asc",
+		label: "Oldest first"
+	},
+	{
+		value: "updated_at:desc",
+		label: "Recently updated"
+	},
+	{
+		value: "name:asc",
+		label: "Name A–Z"
+	},
+	{
+		value: "name:desc",
+		label: "Name Z–A"
+	}
+];
+//#endregion
+//#region src/composables/useExperimentSelector.ts
+function getPlatformContext() {
+	if (typeof window === "undefined") return void 0;
+	return window.__MINT_PLATFORM__;
+}
+function getPlatformApiUrl() {
+	return getPlatformContext()?.platformApiUrl;
+}
+/** Fetches a paginated, filtered experiment list from the platform API for picker and selector UIs. */
+function useExperimentSelector(options = {}) {
+	const { limit = 100, immediate = false, experimentType, apiBaseUrl } = options;
+	const platformBase = apiBaseUrl ?? getPlatformApiUrl();
+	const api = useApi();
+	const experiments = ref([]);
+	const total = ref(0);
+	const selectedExperiment = ref(null);
+	const request = useRequestSyncState("Failed to fetch experiments");
+	const isLoading = request.loading;
+	const error = request.error;
+	const lastLoadedAt = request.lastLoadedAt;
+	const page = ref(0);
+	const sortKey = ref("created_at:desc");
+	const experimentTypes = ref([]);
+	const projects = ref([]);
+	let filterOptionsFetched = false;
+	const hasMore = computed(() => experiments.value.length < total.value);
+	const filters = reactive({
+		search: void 0,
+		status: void 0,
+		project: void 0,
+		experimentType: void 0,
+		datePreset: void 0
+	});
+	function parseSortKey() {
+		const [field, order] = sortKey.value.split(":");
+		return {
+			sortBy: field || "created_at",
+			sortOrder: order || "desc"
+		};
+	}
+	async function fetchExperiments() {
+		try {
+			await request.run(async () => {
+				const params = new URLSearchParams();
+				const allowedTypes = getPlatformContext()?.allowedExperimentTypes;
+				const effectiveType = experimentType ?? (allowedTypes?.length === 1 ? allowedTypes[0] : void 0) ?? filters.experimentType ?? void 0;
+				if (effectiveType) params.set("experiment_type", effectiveType);
+				if (filters.status) params.set("status", filters.status);
+				if (filters.search) params.set("search", filters.search);
+				if (filters.project) params.set("project", filters.project);
+				const { sortBy, sortOrder } = parseSortKey();
+				params.set("sort_by", sortBy);
+				params.set("sort_order", sortOrder);
+				if (filters.datePreset) params.set("created_after", datePresetToISO(filters.datePreset));
+				params.set("limit", String(limit));
+				params.set("skip", String(page.value * limit));
+				const query = params.toString();
+				const url = `${platformBase ?? ""}/experiments${query ? `?${query}` : ""}`;
+				const data = await api.get(url);
+				let filtered = data.experiments;
+				if (!effectiveType && allowedTypes && allowedTypes.length > 1) {
+					const typeSet = new Set(allowedTypes);
+					filtered = filtered.filter((e) => typeSet.has(e.experiment_type));
+				}
+				if (page.value === 0) experiments.value = filtered;
+				else experiments.value = [...experiments.value, ...filtered];
+				if (!effectiveType && allowedTypes && allowedTypes.length > 1) if (data.experiments.length < limit) total.value = experiments.value.length;
+				else total.value = experiments.value.length + 1;
+				else total.value = data.total;
+			}, {
+				success: "load",
+				errorMessage: "Failed to fetch experiments"
+			});
+		} catch {
+			if (page.value === 0) {
+				experiments.value = [];
+				total.value = 0;
+			}
+		}
+	}
+	async function fetchFilterOptions() {
+		if (filterOptionsFetched) return;
+		filterOptionsFetched = true;
+		const base = platformBase ?? "";
+		const [typesRes, projectsRes] = await Promise.allSettled([api.get(`${base}/experiments/experiment-types`), api.get(`${base}/projects`)]);
+		if (typesRes.status === "fulfilled" && Array.isArray(typesRes.value)) experimentTypes.value = typesRes.value.map((t) => ({
+			value: t.value,
+			label: t.label,
+			color: t.color
+		}));
+		if (projectsRes.status === "fulfilled" && projectsRes.value?.projects && Array.isArray(projectsRes.value.projects)) projects.value = projectsRes.value.projects.map((p) => ({
+			value: p.name,
+			label: p.name
+		}));
+	}
+	async function loadMore() {
+		if (!hasMore.value || isLoading.value) return;
+		page.value++;
+		await fetchExperiments();
+	}
+	function reset() {
+		page.value = 0;
+		experiments.value = [];
+		total.value = 0;
+		fetchExperiments();
+	}
+	function select(experiment) {
+		selectedExperiment.value = experiment;
+	}
+	function clear() {
+		selectedExperiment.value = null;
+		filters.search = void 0;
+		filters.status = void 0;
+		filters.project = void 0;
+		filters.experimentType = void 0;
+		filters.datePreset = void 0;
+		sortKey.value = "created_at:desc";
+		page.value = 0;
+		request.clearError();
+	}
+	const groupedByProject = computed(() => {
+		const groups = /* @__PURE__ */ new Map();
+		for (const exp of experiments.value) {
+			const key = exp.project_name ?? exp.project ?? "No project";
+			const list = groups.get(key);
+			if (list) list.push(exp);
+			else groups.set(key, [exp]);
+		}
+		return [...groups.entries()].sort(([a], [b]) => {
+			if (a === "No project") return 1;
+			if (b === "No project") return -1;
+			return a.localeCompare(b);
+		});
+	});
+	const searchWatch = useDebouncedWatch(() => filters.search, () => {
+		page.value = 0;
+		fetchExperiments();
+	}, { delay: 300 });
+	watch(() => [
+		filters.status,
+		filters.project,
+		filters.experimentType,
+		filters.datePreset,
+		sortKey.value
+	], () => {
+		searchWatch.cancel();
+		page.value = 0;
+		fetchExperiments();
+	});
+	if (immediate) fetchExperiments();
+	return {
+		experiments,
+		total,
+		selectedExperiment,
+		filters,
+		isLoading,
+		error,
+		lastLoadedAt,
+		page,
+		hasMore,
+		sortKey,
+		experimentTypes,
+		projects,
+		groupedByProject,
+		fetch: fetchExperiments,
+		loadMore,
+		reset,
+		select,
+		clear,
+		fetchFilterOptions
+	};
+}
+//#endregion
+//#region src/composables/usePlatformContext.ts
+var DEFAULT_CONTEXT = {
+	isIntegrated: false,
+	theme: "system"
+};
+var platformContext = ref({ ...DEFAULT_CONTEXT });
+var inferredOrigins = /* @__PURE__ */ new Set();
+var allowedOrigins = /* @__PURE__ */ new Set();
+var allowAnyOrigin = false;
+var initialized = false;
+var listenerCount = 0;
+var nextConsumerId = 0;
+var currentHandler = null;
+var consumerOrigins = /* @__PURE__ */ new Map();
+var allowAnyOriginConsumers = /* @__PURE__ */ new Set();
+/**
+* Derive origin from URL (protocol + host)
+*/
+function getOriginFromUrl(url) {
+	try {
+		return new URL(url).origin;
+	} catch {
+		return null;
+	}
+}
+function normalizeAllowedOrigins(origins) {
+	const normalized = /* @__PURE__ */ new Set();
+	if (!origins) return normalized;
+	for (const origin of origins) normalized.add(getOriginFromUrl(origin) || origin);
+	return normalized;
+}
+function recomputeOriginPolicy() {
+	allowedOrigins = new Set(inferredOrigins);
+	for (const origins of consumerOrigins.values()) for (const origin of origins) allowedOrigins.add(origin);
+	allowAnyOrigin = allowAnyOriginConsumers.size > 0;
+}
+function resetPlatformContextState() {
+	inferredOrigins = /* @__PURE__ */ new Set();
+	allowedOrigins = /* @__PURE__ */ new Set();
+	allowAnyOrigin = false;
+	initialized = false;
+	listenerCount = 0;
+	currentHandler = null;
+	consumerOrigins.clear();
+	allowAnyOriginConsumers.clear();
+	platformContext.value = { ...DEFAULT_CONTEXT };
+}
+/**
+* Check if an origin is allowed for postMessage communication
+*/
+function isOriginAllowed(origin) {
+	if (allowAnyOrigin) {
+		console.warn("[MINT SDK] postMessage origin validation disabled - only use in development");
+		return true;
+	}
+	if (origin === window.location.origin) return true;
+	return allowedOrigins.has(origin);
+}
+/**
+* Platform context composable for plugin integration with MINT Platform.
+*
+* Provides secure communication with the parent platform via postMessage.
+*
+* @param options - Configuration options
+* @param options.allowedOrigins - List of allowed origins for postMessage
+* @param options.allowAnyOrigin - Allow any origin (UNSAFE, development only)
+*
+* @example
+* ```typescript
+* // Basic usage - derives origin from platform injection
+* const { isIntegrated, user, theme } = usePlatformContext()
+*
+* // With explicit allowed origins
+* const { isIntegrated } = usePlatformContext({
+*   allowedOrigins: ['https://mint.example.com']
+* })
+*
+* // Development mode (UNSAFE)
+* const { isIntegrated } = usePlatformContext({
+*   allowAnyOrigin: import.meta.env.DEV
+* })
+* ```
+*/
+/** Connects a plugin to the MINT platform via postMessage, exposing user, theme, and experiment context. */
+function usePlatformContext(options = {}) {
+	const consumerId = ++nextConsumerId;
+	const instanceOrigins = normalizeAllowedOrigins(options.allowedOrigins);
+	const instanceAllowAnyOrigin = options.allowAnyOrigin === true;
+	function detectPlatform() {
+		const detectedOrigins = /* @__PURE__ */ new Set();
+		const platformData = window.__MINT_PLATFORM__;
+		if (platformData) {
+			platformContext.value = {
+				...platformData,
+				isIntegrated: true
+			};
+			if (platformData.platformOrigin) detectedOrigins.add(platformData.platformOrigin);
+			else if (platformData.platformApiUrl) {
+				const origin = getOriginFromUrl(platformData.platformApiUrl);
+				if (origin) detectedOrigins.add(origin);
+			}
+		} else {
+			const urlParams = new URLSearchParams(window.location.search);
+			const hasPluginParam = urlParams.has("mint-plugin");
+			const platformOrigin = urlParams.get("mint-origin");
+			if (platformOrigin) {
+				const origin = getOriginFromUrl(platformOrigin);
+				if (origin) detectedOrigins.add(origin);
+			}
+			platformContext.value = {
+				isIntegrated: hasPluginParam,
+				theme: (() => {
+					try {
+						const s = localStorage.getItem("mint-settings");
+						if (s) return JSON.parse(s).theme || "system";
+					} catch {}
+					return "system";
+				})(),
+				platformOrigin: platformOrigin || void 0
+			};
+		}
+		inferredOrigins = detectedOrigins;
+	}
+	function handlePlatformMessage(event) {
+		if (event.source !== window.parent) return;
+		if (!isOriginAllowed(event.origin)) {
+			console.warn(`[MINT SDK] Rejected postMessage from untrusted origin: ${event.origin}`);
+			return;
+		}
+		try {
+			const platformEvent = event.data;
+			if (!platformEvent.type?.startsWith("mint:")) return;
+			switch (platformEvent.type) {
+				case "mint:theme-changed":
+					platformContext.value.theme = platformEvent.payload;
+					break;
+				case "mint:user-changed":
+					platformContext.value.user = platformEvent.payload;
+					break;
+			}
+		} catch {}
+	}
+	/**
+	* Send a message to the parent platform.
+	* Uses validated target origin for security.
+	*/
+	function sendToPlatform(event) {
+		if (!platformContext.value.isIntegrated || window.parent === window) return;
+		let targetOrigin;
+		if (platformContext.value.platformOrigin) targetOrigin = platformContext.value.platformOrigin;
+		else if (allowedOrigins.size > 0) targetOrigin = allowedOrigins.values().next().value;
+		else if (allowAnyOrigin) {
+			targetOrigin = "*";
+			console.warn("[MINT SDK] Using wildcard origin for postMessage - only use in development");
+		} else {
+			console.warn("[MINT SDK] Cannot send postMessage: no platform origin configured");
+			return;
+		}
+		window.parent.postMessage(event, targetOrigin);
+	}
+	/**
+	* Request navigation to a path in the platform.
+	*/
+	function navigate(path) {
+		sendToPlatform({
+			type: "mint:navigate",
+			payload: path
+		});
+	}
+	/**
+	* Show a notification in the platform.
+	*/
+	function notify(message, type = "info") {
+		sendToPlatform({
+			type: "mint:notification",
+			payload: {
+				message,
+				type
+			}
+		});
+	}
+	onMounted(() => {
+		consumerOrigins.set(consumerId, instanceOrigins);
+		if (instanceAllowAnyOrigin) allowAnyOriginConsumers.add(consumerId);
+		if (!initialized) {
+			detectPlatform();
+			currentHandler = handlePlatformMessage;
+			window.addEventListener("message", handlePlatformMessage);
+			initialized = true;
+		}
+		listenerCount++;
+		recomputeOriginPolicy();
+	});
+	onUnmounted(() => {
+		consumerOrigins.delete(consumerId);
+		allowAnyOriginConsumers.delete(consumerId);
+		listenerCount = Math.max(0, listenerCount - 1);
+		if (listenerCount === 0) {
+			if (currentHandler) window.removeEventListener("message", currentHandler);
+			resetPlatformContextState();
+			return;
+		}
+		recomputeOriginPolicy();
+	});
+	return {
+		context: platformContext,
+		isIntegrated: computed(() => platformContext.value.isIntegrated),
+		plugin: computed(() => platformContext.value.plugin),
+		user: computed(() => platformContext.value.user),
+		theme: computed(() => platformContext.value.theme),
+		features: computed(() => platformContext.value.features),
+		navigate,
+		notify,
+		sendToPlatform
+	};
+}
+//#endregion
+//#region src/composables/useAppExperiment.ts
+var APP_EXPERIMENT_KEY = Symbol("app-experiment");
+/** Manages the active experiment selection, save flow, and detach action for a plugin's app shell. */
+function useAppExperiment(options = {}) {
+	const experimentName = ref();
+	const experimentCode = ref();
+	const experimentStatus = ref();
+	const experimentId = ref(null);
+	const showModal = ref(false);
+	const saveLoading = ref(false);
+	const saveSuccessMessage = ref();
+	let successTimer = null;
+	const showSave = ref(!!options.onSave);
+	const showDetach = computed(() => experimentId.value !== null);
+	const saveDisabled = computed(() => toValue(options.saveDisabled) ?? false);
+	const saveDisabledMessage = computed(() => toValue(options.saveDisabledMessage));
+	function set(experiment) {
+		experimentId.value = experiment.id;
+		experimentName.value = experiment.name;
+		experimentCode.value = experiment.experiment_code ?? (experiment.id != null ? `EXP-${experiment.id}` : void 0);
+		experimentStatus.value = experiment.status;
+	}
+	function clear() {
+		experimentId.value = null;
+		experimentName.value = void 0;
+		experimentCode.value = void 0;
+		experimentStatus.value = void 0;
+	}
+	function openModal() {
+		showModal.value = true;
+	}
+	function closeModal() {
+		showModal.value = false;
+	}
+	function handleSelect(experiment) {
+		set(experiment);
+		showModal.value = false;
+		options.onSelect?.(experiment);
+	}
+	async function handleSave() {
+		if (!options.onSave || saveLoading.value) return;
+		saveLoading.value = true;
+		try {
+			const message = await options.onSave();
+			if (message) {
+				saveSuccessMessage.value = message;
+				if (successTimer) clearTimeout(successTimer);
+				successTimer = setTimeout(() => {
+					saveSuccessMessage.value = void 0;
+					successTimer = null;
+				}, 3e3);
+			}
+		} finally {
+			saveLoading.value = false;
+		}
+	}
+	function handleDetach() {
+		clear();
+		options.onDetach?.();
+	}
+	onScopeDispose(() => {
+		if (successTimer) clearTimeout(successTimer);
+	});
+	provide(APP_EXPERIMENT_KEY, {
+		experimentName,
+		experimentCode,
+		experimentStatus,
+		experimentId,
+		showModal,
+		saveLoading,
+		saveSuccessMessage,
+		showSave,
+		showDetach,
+		saveDisabled,
+		saveDisabledMessage,
+		openModal,
+		closeModal,
+		handleSelect,
+		handleSave,
+		handleDetach
+	});
+	return {
+		set,
+		clear,
+		experimentName: readonly(experimentName),
+		experimentCode: readonly(experimentCode),
+		experimentId: readonly(experimentId)
+	};
+}
+//#endregion
+//#region src/composables/useDoseCalculator.ts
+var VOLUME_UNITS = [
+	"µL",
+	"mL",
+	"L"
+];
+var VOLUME_FACTORS = {
+	"µL": 1e-6,
+	"mL": .001,
+	"L": 1
+};
+/** Calculates single dilutions, serial dilution series, and plate-filling volumes for dose-response experiments. */
+function useDoseCalculator() {
+	const { convert } = useConcentrationUnits();
+	function convertVolume(value, from, to) {
+		if (from === to) return value;
+		return value * VOLUME_FACTORS[from] / VOLUME_FACTORS[to];
+	}
+	function formatVolume(volume, precision = 3) {
+		const { value, unit } = volume;
+		if (value === 0) return `0 ${unit}`;
+		let formattedValue;
+		if (Math.abs(value) >= 1e3) formattedValue = value.toExponential(precision - 1);
+		else if (Math.abs(value) < .001) formattedValue = value.toExponential(precision - 1);
+		else formattedValue = value.toPrecision(precision);
+		formattedValue = formattedValue.replace(/\.?0+$/, "");
+		formattedValue = formattedValue.replace(/\.?0+e/, "e");
+		return `${formattedValue} ${unit}`;
+	}
+	function calculateDilution(params) {
+		const { stockConcentration, finalConcentration, finalVolume } = params;
+		if (stockConcentration.value <= 0) return {
+			stockVolume: {
+				value: 0,
+				unit: "µL"
+			},
+			diluentVolume: {
+				value: 0,
+				unit: "µL"
+			},
+			dilutionFactor: 0,
+			valid: false,
+			error: "Stock concentration must be positive"
+		};
+		if (finalConcentration.value <= 0) return {
+			stockVolume: {
+				value: 0,
+				unit: "µL"
+			},
+			diluentVolume: {
+				value: 0,
+				unit: "µL"
+			},
+			dilutionFactor: 0,
+			valid: false,
+			error: "Final concentration must be positive"
+		};
+		if (finalVolume.value <= 0) return {
+			stockVolume: {
+				value: 0,
+				unit: "µL"
+			},
+			diluentVolume: {
+				value: 0,
+				unit: "µL"
+			},
+			dilutionFactor: 0,
+			valid: false,
+			error: "Final volume must be positive"
+		};
+		const convertedFinal = convert(finalConcentration.value, finalConcentration.unit, stockConcentration.unit);
+		if (convertedFinal === null) return {
+			stockVolume: {
+				value: 0,
+				unit: "µL"
+			},
+			diluentVolume: {
+				value: 0,
+				unit: "µL"
+			},
+			dilutionFactor: 0,
+			valid: false,
+			error: "Cannot convert between concentration units. Provide molecular weight for mass↔molarity conversion."
+		};
+		if (convertedFinal >= stockConcentration.value) return {
+			stockVolume: {
+				value: 0,
+				unit: "µL"
+			},
+			diluentVolume: {
+				value: 0,
+				unit: "µL"
+			},
+			dilutionFactor: 0,
+			valid: false,
+			error: "Stock concentration must be higher than final concentration"
+		};
+		const dilutionFactor = stockConcentration.value / convertedFinal;
+		const finalVolumeInL = convertVolume(finalVolume.value, finalVolume.unit, "L");
+		const stockVolumeInL = finalVolumeInL / dilutionFactor;
+		const diluentVolumeInL = finalVolumeInL - stockVolumeInL;
+		let outputUnit = "µL";
+		if (stockVolumeInL >= .001) outputUnit = "mL";
+		if (stockVolumeInL >= 1) outputUnit = "L";
+		return {
+			stockVolume: {
+				value: convertVolume(stockVolumeInL, "L", outputUnit),
+				unit: outputUnit
+			},
+			diluentVolume: {
+				value: convertVolume(diluentVolumeInL, "L", outputUnit),
+				unit: outputUnit
+			},
+			dilutionFactor,
+			valid: true
+		};
+	}
+	function calculateSerialDilution(params) {
+		const { startingConcentration, dilutionFactor, numberOfDilutions, volumePerWell } = params;
+		if (startingConcentration.value <= 0) return {
+			steps: [],
+			totalStockVolume: {
+				value: 0,
+				unit: "µL"
+			},
+			valid: false,
+			error: "Starting concentration must be positive"
+		};
+		if (dilutionFactor <= 1) return {
+			steps: [],
+			totalStockVolume: {
+				value: 0,
+				unit: "µL"
+			},
+			valid: false,
+			error: "Dilution factor must be greater than 1"
+		};
+		if (numberOfDilutions < 1) return {
+			steps: [],
+			totalStockVolume: {
+				value: 0,
+				unit: "µL"
+			},
+			valid: false,
+			error: "Number of dilutions must be at least 1"
+		};
+		if (volumePerWell.value <= 0) return {
+			steps: [],
+			totalStockVolume: {
+				value: 0,
+				unit: "µL"
+			},
+			valid: false,
+			error: "Volume per well must be positive"
+		};
+		const steps = [];
+		let currentConcentration = startingConcentration.value;
+		const transferVolume = volumePerWell.value / (dilutionFactor - 1);
+		const diluentVolume = volumePerWell.value - transferVolume;
+		for (let i = 0; i < numberOfDilutions; i++) {
+			steps.push({
+				stepNumber: i + 1,
+				concentration: {
+					value: currentConcentration,
+					unit: startingConcentration.unit
+				},
+				transferVolume: {
+					value: i === 0 ? volumePerWell.value : transferVolume,
+					unit: volumePerWell.unit
+				},
+				diluentVolume: {
+					value: i === 0 ? 0 : diluentVolume,
+					unit: volumePerWell.unit
+				}
+			});
+			currentConcentration /= dilutionFactor;
+		}
+		return {
+			steps,
+			totalStockVolume: {
+				value: volumePerWell.value + transferVolume * (numberOfDilutions - 1),
+				unit: volumePerWell.unit
+			},
+			valid: true
+		};
+	}
+	function convertMassToMolar(mass, massUnit, mw) {
+		const converted = convert(mass, massUnit, "µM", mw);
+		if (converted !== null) return {
+			value: converted,
+			unit: "µM"
+		};
+		return {
+			value: mass * getMassVolumeFactor(massUnit) / mw * 1e6,
+			unit: "µM"
+		};
+	}
+	function convertMolarToMass(molar, molarUnit, mw) {
+		const converted = convert(molar, molarUnit, "µg/mL", mw);
+		if (converted !== null) return {
+			value: converted,
+			unit: "µg/mL"
+		};
+		return {
+			value: molar * getMolarityFactor(molarUnit) * mw * 1e6,
+			unit: "µg/mL"
+		};
+	}
+	function getMassVolumeFactor(unit) {
+		return {
+			"pg/mL": 1e-12,
+			"ng/mL": 1e-9,
+			"µg/mL": 1e-6,
+			"mg/mL": .001,
+			"g/mL": 1
+		}[unit];
+	}
+	function getMolarityFactor(unit) {
+		return {
+			"pM": 1e-12,
+			"nM": 1e-9,
+			"µM": 1e-6,
+			"mM": .001,
+			"M": 1
+		}[unit];
+	}
+	function generateWellConcentrations(result, wellIds) {
+		if (!result.valid || result.steps.length === 0) return [];
+		return result.steps.slice(0, wellIds.length).map((step, index) => ({
+			wellId: wellIds[index],
+			concentration: step.concentration,
+			volume: step.transferVolume
+		}));
+	}
+	return {
+		volumeUnits: VOLUME_UNITS,
+		calculateDilution,
+		calculateSerialDilution,
+		convertMassToMolar,
+		convertMolarToMass,
+		convertVolume,
+		formatVolume,
+		generateWellConcentrations
+	};
+}
+//#endregion
+//#region src/composables/useWellPlateEditor.ts
+var DEFAULT_PALETTE = [
+	"#3B82F6",
+	"#10B981",
+	"#EF4444",
+	"#F59E0B",
+	"#8B5CF6",
+	"#F97316",
+	"#06B6D4",
+	"#14B8A6",
+	"#6B7280"
+];
+var MAX_HISTORY = 50;
+function createEmptyPlate(name, format, id) {
+	return {
+		id: id || `plate-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+		name,
+		format,
+		wells: {}
+	};
+}
+function generateSampleId() {
+	return `sample-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+}
+function cloneValue(value) {
+	return structuredClone(toRaw(value));
+}
+/** Manages multi-plate well-plate state with sample assignment, selection, and undo/redo history. */
+function useWellPlateEditor(initialState, options = {}) {
+	const { maxHistory = MAX_HISTORY, defaultFormat = 96 } = options;
+	const defaultPlate = createEmptyPlate("Plate 1", defaultFormat);
+	const internalState = ref({
+		plates: initialState?.plates || [defaultPlate],
+		activePlateId: initialState?.activePlateId || defaultPlate.id,
+		samples: initialState?.samples || [],
+		selectedWells: initialState?.selectedWells || [],
+		activeSampleId: initialState?.activeSampleId
+	});
+	const history = ref([]);
+	const historyIndex = ref(-1);
+	const state = computed(() => internalState.value);
+	const plates = computed(() => internalState.value.plates);
+	const activePlate = computed(() => internalState.value.plates.find((p) => p.id === internalState.value.activePlateId));
+	const samples = computed(() => internalState.value.samples);
+	const selectedWells = computed(() => internalState.value.selectedWells);
+	const activeSampleId = computed(() => internalState.value.activeSampleId);
+	const canUndo = computed(() => historyIndex.value >= 0);
+	const canRedo = computed(() => historyIndex.value < history.value.length - 1);
+	function saveToHistory() {
+		const entry = {
+			plates: cloneValue(internalState.value.plates),
+			samples: cloneValue(internalState.value.samples)
+		};
+		if (historyIndex.value < history.value.length - 1) history.value = history.value.slice(0, historyIndex.value + 1);
+		history.value.push(entry);
+		if (history.value.length > maxHistory) history.value.shift();
+		else historyIndex.value++;
+	}
+	function setActivePlate(plateId) {
+		if (internalState.value.plates.some((p) => p.id === plateId)) {
+			internalState.value.activePlateId = plateId;
+			internalState.value.selectedWells = [];
+		}
+	}
+	function setActiveSample(sampleId) {
+		internalState.value.activeSampleId = sampleId;
+	}
+	function setSelectedWells(wellIds) {
+		internalState.value.selectedWells = wellIds;
+	}
+	function addPlate(name, format) {
+		saveToHistory();
+		const plateNumber = internalState.value.plates.length + 1;
+		const plate = createEmptyPlate(name || `Plate ${plateNumber}`, format || defaultFormat);
+		internalState.value.plates.push(plate);
+		internalState.value.activePlateId = plate.id;
+		internalState.value.selectedWells = [];
+		return plate;
+	}
+	function removePlate(plateId) {
+		if (internalState.value.plates.length <= 1) return;
+		saveToHistory();
+		const index = internalState.value.plates.findIndex((p) => p.id === plateId);
+		if (index === -1) return;
+		internalState.value.plates.splice(index, 1);
+		if (internalState.value.activePlateId === plateId) {
+			internalState.value.activePlateId = internalState.value.plates[0].id;
+			internalState.value.selectedWells = [];
+		}
+	}
+	function addSample(name, color) {
+		saveToHistory();
+		const sample = {
+			id: generateSampleId(),
+			name,
+			color: color || DEFAULT_PALETTE[internalState.value.samples.length % DEFAULT_PALETTE.length],
+			count: 0
+		};
+		internalState.value.samples.push(sample);
+		return sample;
+	}
+	function removeSample(sampleId) {
+		saveToHistory();
+		const index = internalState.value.samples.findIndex((s) => s.id === sampleId);
+		if (index === -1) return;
+		internalState.value.samples.splice(index, 1);
+		for (const plate of internalState.value.plates) for (const well of Object.values(plate.wells)) if (well.sampleType === sampleId) {
+			delete well.sampleType;
+			well.state = "empty";
+		}
+		if (internalState.value.activeSampleId === sampleId) internalState.value.activeSampleId = void 0;
+		updateSampleCounts();
+	}
+	function assignSample(wellIds, sampleId) {
+		if (wellIds.length === 0) return;
+		saveToHistory();
+		const plate = activePlate.value;
+		if (!plate) return;
+		for (const wellId of wellIds) {
+			const well = plate.wells[wellId] || {
+				id: wellId,
+				row: wellId.charCodeAt(0) - 65,
+				col: parseInt(wellId.slice(1)) - 1,
+				state: "empty"
+			};
+			if (sampleId) {
+				well.sampleType = sampleId;
+				well.state = "filled";
+			} else {
+				delete well.sampleType;
+				well.state = "empty";
+			}
+			plate.wells[wellId] = well;
+		}
+		updateSampleCounts();
+	}
+	function clearWells(wellIds) {
+		assignSample(wellIds, void 0);
+	}
+	function updateSampleCounts() {
+		const counts = {};
+		for (const plate of internalState.value.plates) for (const well of Object.values(plate.wells)) if (well.sampleType) counts[well.sampleType] = (counts[well.sampleType] || 0) + 1;
+		for (const sample of internalState.value.samples) sample.count = counts[sample.id] || 0;
+	}
+	function undo() {
+		if (!canUndo.value) return;
+		const entry = history.value[historyIndex.value];
+		historyIndex.value--;
+		internalState.value.plates = cloneValue(entry.plates);
+		internalState.value.samples = cloneValue(entry.samples);
+		if (!internalState.value.plates.some((p) => p.id === internalState.value.activePlateId)) internalState.value.activePlateId = internalState.value.plates[0]?.id || "";
+		internalState.value.selectedWells = [];
+	}
+	function redo() {
+		if (!canRedo.value) return;
+		historyIndex.value++;
+		const entry = history.value[historyIndex.value];
+		internalState.value.plates = cloneValue(entry.plates);
+		internalState.value.samples = cloneValue(entry.samples);
+		internalState.value.selectedWells = [];
+	}
+	function exportData(format) {
+		if (format === "json") return JSON.stringify({
+			plates: internalState.value.plates,
+			samples: internalState.value.samples
+		}, null, 2);
+		const sampleMap = new Map(internalState.value.samples.map((s) => [s.id, s.name]));
+		const rows = ["Plate,Well,Sample Type,Sample Name"];
+		for (const plate of internalState.value.plates) for (const [wellId, well] of Object.entries(plate.wells)) if (well.sampleType) {
+			const sampleName = sampleMap.get(well.sampleType) || "";
+			rows.push(`"${plate.name}","${wellId}","${well.sampleType}","${sampleName}"`);
+		}
+		return rows.join("\n");
+	}
+	function importData(data, format) {
+		try {
+			saveToHistory();
+			if (format === "json") {
+				const parsed = JSON.parse(data);
+				if (parsed.plates && Array.isArray(parsed.plates)) {
+					internalState.value.plates = parsed.plates;
+					internalState.value.activePlateId = parsed.plates[0]?.id || "";
+				}
+				if (parsed.samples && Array.isArray(parsed.samples)) internalState.value.samples = parsed.samples;
+				internalState.value.selectedWells = [];
+				updateSampleCounts();
+				return true;
+			}
+			const lines = data.trim().split("\n");
+			if (lines.length < 2) return false;
+			const plateMap = /* @__PURE__ */ new Map();
+			const sampleMap = /* @__PURE__ */ new Map();
+			for (let i = 1; i < lines.length; i++) {
+				const parts = lines[i].match(/(?:[^",]+|"[^"]*")+/g);
+				if (!parts || parts.length < 4) continue;
+				const plateName = parts[0].replace(/^"|"$/g, "");
+				const wellId = parts[1].replace(/^"|"$/g, "");
+				const sampleId = parts[2].replace(/^"|"$/g, "");
+				const sampleName = parts[3].replace(/^"|"$/g, "");
+				if (!plateMap.has(plateName)) plateMap.set(plateName, createEmptyPlate(plateName, defaultFormat));
+				if (sampleId && !sampleMap.has(sampleId)) sampleMap.set(sampleId, {
+					id: sampleId,
+					name: sampleName || sampleId,
+					color: DEFAULT_PALETTE[sampleMap.size % DEFAULT_PALETTE.length],
+					count: 0
+				});
+				const plate = plateMap.get(plateName);
+				plate.wells[wellId] = {
+					id: wellId,
+					row: wellId.charCodeAt(0) - 65,
+					col: parseInt(wellId.slice(1)) - 1,
+					state: sampleId ? "filled" : "empty",
+					sampleType: sampleId || void 0
+				};
+			}
+			internalState.value.plates = Array.from(plateMap.values());
+			internalState.value.samples = Array.from(sampleMap.values());
+			internalState.value.activePlateId = internalState.value.plates[0]?.id || "";
+			internalState.value.selectedWells = [];
+			updateSampleCounts();
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	function loadState(state) {
+		saveToHistory();
+		if (state.plates && state.plates.length > 0) {
+			internalState.value.plates = cloneValue(state.plates);
+			internalState.value.activePlateId = state.activePlateId ?? state.plates[0].id;
+		}
+		if (state.samples) internalState.value.samples = cloneValue(state.samples);
+		internalState.value.selectedWells = state.selectedWells ?? [];
+		internalState.value.activeSampleId = state.activeSampleId;
+		updateSampleCounts();
+	}
+	function reset() {
+		const plate = createEmptyPlate("Plate 1", defaultFormat);
+		internalState.value = {
+			plates: [plate],
+			activePlateId: plate.id,
+			samples: [],
+			selectedWells: [],
+			activeSampleId: void 0
+		};
+		history.value = [];
+		historyIndex.value = -1;
+	}
+	return {
+		state,
+		plates,
+		activePlate,
+		samples,
+		selectedWells,
+		activeSampleId,
+		canUndo,
+		canRedo,
+		setActivePlate,
+		setActiveSample,
+		setSelectedWells,
+		addPlate,
+		removePlate,
+		addSample,
+		removeSample,
+		assignSample,
+		clearWells,
+		undo,
+		redo,
+		exportData,
+		importData,
+		loadState,
+		reset
+	};
+}
+//#endregion
+//#region src/composables/useAutoGroup.ts
+var DEFAULT_COLORS = [
+	"#3B82F6",
+	"#10B981",
+	"#F59E0B",
+	"#EF4444",
+	"#8B5CF6",
+	"#EC4899",
+	"#06B6D4",
+	"#84CC16",
+	"#F97316",
+	"#6366F1"
+];
+var DELIMITER_CANDIDATES = [
+	"_",
+	"-",
+	"."
+];
+function analyzeDelimiter(lines) {
+	if (lines.length === 0) return {
+		delimiter: "_",
+		dominantFieldCount: 1,
+		minFieldCount: 1,
+		consistency: 0
+	};
+	let bestDelimiter = "_";
+	let bestConsistency = -1;
+	let bestFieldCount = 1;
+	for (const candidate of DELIMITER_CANDIDATES) {
+		const fieldCounts = lines.map((line) => line.split(candidate).length);
+		const countFrequency = /* @__PURE__ */ new Map();
+		for (const count of fieldCounts) countFrequency.set(count, (countFrequency.get(count) ?? 0) + 1);
+		let modeCount = 1;
+		let modeFrequency = 0;
+		for (const [count, freq] of countFrequency) if (freq > modeFrequency || freq === modeFrequency && count > modeCount) {
+			modeCount = count;
+			modeFrequency = freq;
+		}
+		const rawConsistency = modeFrequency / lines.length;
+		const consistency = modeCount > 1 ? rawConsistency : 0;
+		if (consistency > bestConsistency || consistency === bestConsistency && DELIMITER_CANDIDATES.indexOf(candidate) < DELIMITER_CANDIDATES.indexOf(bestDelimiter)) {
+			bestDelimiter = candidate;
+			bestConsistency = consistency;
+			bestFieldCount = modeCount;
+		}
+	}
+	const multiFieldCounts = lines.map((line) => line.split(bestDelimiter).length).filter((c) => c >= 2);
+	const minFieldCount = multiFieldCounts.length > 0 ? Math.min(...multiFieldCounts) : 1;
+	return {
+		delimiter: bestDelimiter,
+		dominantFieldCount: bestFieldCount,
+		minFieldCount,
+		consistency: bestConsistency
+	};
+}
+function detectOutliers(lines, delimiter, minFieldCount) {
+	const outliers = [];
+	for (let i = 0; i < lines.length; i++) {
+		const fieldCount = lines[i].split(delimiter).length;
+		if (fieldCount < minFieldCount) outliers.push({
+			sample: lines[i],
+			index: i,
+			fieldCount,
+			action: "include"
+		});
+	}
+	return outliers;
+}
+var QC_KEYWORDS = new Set([
+	"eqc",
+	"iqc",
+	"qc",
+	"blank",
+	"std",
+	"standard",
+	"test"
+]);
+function classifyOutlierAction(sample, delimiter) {
+	return sample.split(delimiter).some((seg) => QC_KEYWORDS.has(seg.toLowerCase())) ? "qc" : "include";
+}
+function isUsefulField(field, rowCount) {
+	return field.cardinality > 1 && !(rowCount > 1 && field.cardinality === rowCount);
+}
+function extractColumns(samples, delimiter, minFieldCount) {
+	if (samples.length === 0) return [];
+	const suffixCount = minFieldCount - 1;
+	const rows = samples.map((s) => {
+		const parts = s.split(delimiter);
+		const splitAt = parts.length - suffixCount;
+		return [parts.slice(0, splitAt).join(delimiter), ...parts.slice(splitAt)];
+	});
+	const columnCount = minFieldCount;
+	const columns = [];
+	for (let col = 0; col < columnCount; col++) {
+		const values = rows.map((row) => row[col]);
+		const unique = [...new Set(values)];
+		columns.push({
+			index: col,
+			name: col === 0 ? "Condition" : `Field ${col + 1}`,
+			uniqueValues: unique,
+			cardinality: unique.length,
+			type: col === 0 ? "prefix" : "suffix"
+		});
+	}
+	return columns;
+}
+function parseCSVLine(line, delimiter = ",") {
+	const result = [];
+	let current = "";
+	let inQuotes = false;
+	for (let i = 0; i < line.length; i++) {
+		const char = line[i];
+		if (char === "\"") inQuotes = !inQuotes;
+		else if (char === delimiter && !inQuotes) {
+			result.push(current.trim());
+			current = "";
+		} else current += char;
+	}
+	result.push(current.trim());
+	return result;
+}
+function parseCSV(text) {
+	const lines = text.trim().split("\n");
+	if (lines.length < 2) throw new Error("CSV must have at least a header and one data row");
+	const firstLine = lines[0];
+	const csvDelimiter = firstLine.includes("	") ? "	" : ",";
+	const headers = parseCSVLine(firstLine, csvDelimiter);
+	const rows = [];
+	for (let i = 1; i < lines.length; i++) {
+		const values = parseCSVLine(lines[i], csvDelimiter);
+		if (values.length !== headers.length) continue;
+		const row = {};
+		headers.forEach((header, idx) => {
+			row[header] = values[idx];
+		});
+		rows.push(row);
+	}
+	const sampleKeywords = [
+		"sample",
+		"name",
+		"id",
+		"sample_name",
+		"samplename",
+		"file name",
+		"filename",
+		"file_name"
+	];
+	return {
+		columns: headers,
+		rows,
+		sampleColumn: headers.find((h) => sampleKeywords.includes(h.toLowerCase())) ?? headers[0],
+		delimiter: csvDelimiter
+	};
+}
+function computeGroups(allSamples, columns, enabledFields, outlierActions, delimiter, minFieldCount) {
+	const excludedSamples = [];
+	const qcSamples = [];
+	const conformingSamples = [];
+	for (let i = 0; i < allSamples.length; i++) {
+		const action = outlierActions.get(i);
+		if (action === "exclude") excludedSamples.push(allSamples[i]);
+		else if (action === "qc") qcSamples.push(allSamples[i]);
+		else conformingSamples.push(allSamples[i]);
+	}
+	const groupMap = /* @__PURE__ */ new Map();
+	const metadata = [];
+	const enabledIndices = [...enabledFields].sort((a, b) => a - b);
+	const suffixCount = minFieldCount - 1;
+	for (const sample of conformingSamples) {
+		const parts = sample.split(delimiter);
+		const splitAt = Math.max(1, parts.length - suffixCount);
+		const row = [parts.slice(0, splitAt).join(delimiter), ...parts.slice(splitAt)];
+		const keyParts = [];
+		for (const idx of enabledIndices) if (idx < row.length && idx < columns.length) keyParts.push(row[idx]);
+		const groupKey = keyParts.join(" / ");
+		if (!groupMap.has(groupKey)) groupMap.set(groupKey, []);
+		groupMap.get(groupKey).push(sample);
+		const fields = {};
+		for (const col of columns) if (col.index < row.length) fields[col.name] = row[col.index];
+		metadata.push({
+			sampleName: sample,
+			fields,
+			group: groupKey
+		});
+	}
+	const groups = [];
+	let colorIdx = 0;
+	for (const [name, samples] of groupMap) {
+		groups.push({
+			name,
+			color: DEFAULT_COLORS[colorIdx % DEFAULT_COLORS.length],
+			samples
+		});
+		colorIdx++;
+	}
+	if (qcSamples.length > 0) {
+		groups.push({
+			name: "QC",
+			color: "#6B7280",
+			samples: qcSamples
+		});
+		for (const sample of qcSamples) metadata.push({
+			sampleName: sample,
+			fields: {},
+			group: "QC"
+		});
+	}
+	return {
+		groups,
+		metadata,
+		excludedSamples
+	};
+}
+/**
+* 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.
+*/
+function extractSamplesFromDesignData(rawData) {
+	const samples = rawData.samples;
+	if (!Array.isArray(samples) || samples.length === 0) return null;
+	const allConditionKeys = [];
+	const keySet = /* @__PURE__ */ new Set();
+	const filteredSamples = [];
+	for (const sample of samples) {
+		const sampleType = String(sample.sample_type ?? "sample").toLowerCase();
+		if (sampleType === "qc" || sampleType === "blank") continue;
+		filteredSamples.push(sample);
+		const conditions = sample.conditions;
+		if (conditions && typeof conditions === "object") {
+			for (const key of Object.keys(conditions)) if (!keySet.has(key)) {
+				keySet.add(key);
+				allConditionKeys.push(key);
+			}
+		}
+	}
+	if (filteredSamples.length === 0 || allConditionKeys.length === 0) return null;
+	return {
+		columns: ["sample_name", ...allConditionKeys],
+		rows: filteredSamples.map((sample) => {
+			const conditions = sample.conditions ?? {};
+			const row = { sample_name: String(sample.sample_name ?? "") };
+			for (const key of allConditionKeys) row[key] = conditions[key] ?? "";
+			return row;
+		}),
+		sampleColumn: "sample_name",
+		delimiter: ","
+	};
+}
+function computeGroupsFromCsv(csvData, columns, enabledFields) {
+	const groupMap = /* @__PURE__ */ new Map();
+	const metadata = [];
+	const enabledCols = columns.filter((c) => enabledFields.has(c.index)).sort((a, b) => a.index - b.index);
+	for (const row of csvData.rows) {
+		const sampleName = row[csvData.sampleColumn];
+		const groupKey = enabledCols.map((col) => row[col.originalName ?? col.name]).join(" / ");
+		if (!groupMap.has(groupKey)) groupMap.set(groupKey, []);
+		groupMap.get(groupKey).push(sampleName);
+		const fields = {};
+		for (const col of columns) fields[col.name] = row[col.originalName ?? col.name];
+		metadata.push({
+			sampleName,
+			fields,
+			group: groupKey
+		});
+	}
+	const groups = [];
+	let colorIdx = 0;
+	for (const [name, samples] of groupMap) {
+		groups.push({
+			name,
+			color: DEFAULT_COLORS[colorIdx % DEFAULT_COLORS.length],
+			samples
+		});
+		colorIdx++;
+	}
+	return {
+		groups,
+		metadata,
+		excludedSamples: []
+	};
+}
+/** Parses sample names or CSV data to propose group assignments with outlier detection and preview. */
+function useAutoGroup() {
+	const inputMode = ref("paste");
+	const rawText = ref("");
+	const csvData = ref(null);
+	const delimiter = ref("_");
+	const dominantFieldCount = ref(1);
+	const minFieldCount = ref(1);
+	const outliers = ref([]);
+	const fields = ref([]);
+	const fieldNames = ref({});
+	const enabledFields = ref(/* @__PURE__ */ new Set());
+	const isTabularMode = computed(() => (inputMode.value === "csv" || inputMode.value === "experiment") && csvData.value !== null);
+	const samples = computed(() => {
+		if (isTabularMode.value && csvData.value) return csvData.value.rows.map((r) => r[csvData.value.sampleColumn]);
+		return rawText.value.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
+	});
+	const hasOutliers = computed(() => outliers.value.length > 0);
+	const conformingSamples = computed(() => {
+		const outlierIndices = new Set(outliers.value.map((o) => o.index));
+		return samples.value.filter((_, i) => !outlierIndices.has(i));
+	});
+	const outlierActions = computed(() => {
+		const map = /* @__PURE__ */ new Map();
+		for (const o of outliers.value) map.set(o.index, o.action);
+		return map;
+	});
+	const effectiveColumns = computed(() => {
+		return fields.value.map((col) => ({
+			...col,
+			name: fieldNames.value[col.index] ?? col.name
+		}));
+	});
+	const _computedResult = computed(() => {
+		if (effectiveColumns.value.length === 0 || enabledFields.value.size === 0) return {
+			groups: [],
+			metadata: [],
+			excludedSamples: []
+		};
+		if (isTabularMode.value && csvData.value) return computeGroupsFromCsv(csvData.value, effectiveColumns.value, enabledFields.value);
+		return computeGroups(samples.value, effectiveColumns.value, enabledFields.value, outlierActions.value, delimiter.value, minFieldCount.value);
+	});
+	const groups = computed(() => _computedResult.value.groups);
+	const metadata = computed(() => _computedResult.value.metadata);
+	const excludedSamples = computed(() => _computedResult.value.excludedSamples);
+	const allSingletons = computed(() => groups.value.length > 1 && groups.value.every((g) => g.samples.length === 1));
+	const result = _computedResult;
+	function parseInput() {
+		if (isTabularMode.value) parseCsvInput();
+		else parsePasteInput();
+	}
+	function parsePasteInput() {
+		const lines = samples.value;
+		if (lines.length === 0) return;
+		const analysis = analyzeDelimiter(lines);
+		delimiter.value = analysis.delimiter;
+		dominantFieldCount.value = analysis.dominantFieldCount;
+		outliers.value = detectOutliers(lines, analysis.delimiter, analysis.dominantFieldCount);
+		for (const outlier of outliers.value) outlier.action = classifyOutlierAction(outlier.sample, analysis.delimiter);
+		const conforming = lines.filter((_, i) => !outliers.value.some((o) => o.index === i));
+		const conformingFieldCounts = conforming.map((s) => s.split(analysis.delimiter).length);
+		minFieldCount.value = conformingFieldCounts.length > 0 ? Math.min(...conformingFieldCounts) : analysis.dominantFieldCount;
+		fields.value = extractColumns(conforming, analysis.delimiter, minFieldCount.value);
+		fieldNames.value = {};
+		const rowCount = conforming.length;
+		enabledFields.value = new Set(fields.value.filter((f) => isUsefulField(f, rowCount)).map((f) => f.index));
+	}
+	function parseCsvInput() {
+		if (!csvData.value) return;
+		const csv = csvData.value;
+		fields.value = csv.columns.filter((c) => c !== csv.sampleColumn).map((col, i) => {
+			const values = csv.rows.map((r) => r[col]);
+			const unique = [...new Set(values)];
+			return {
+				index: i,
+				name: col,
+				originalName: col,
+				uniqueValues: unique,
+				cardinality: unique.length
+			};
+		});
+		outliers.value = [];
+		delimiter.value = csv.delimiter;
+		dominantFieldCount.value = csv.columns.length;
+		fieldNames.value = Object.fromEntries(fields.value.map((f) => [f.index, f.name]));
+		const rowCount = csv.rows.length;
+		enabledFields.value = new Set(fields.value.filter((f) => isUsefulField(f, rowCount)).map((f) => f.index));
+	}
+	function setOutlierAction(index, action) {
+		const outlier = outliers.value.find((o) => o.index === index);
+		if (outlier) {
+			outlier.action = action;
+			outliers.value = [...outliers.value];
+		}
+	}
+	function setAllOutlierActions(action) {
+		for (const outlier of outliers.value) outlier.action = action;
+		outliers.value = [...outliers.value];
+	}
+	function toggleField(index) {
+		const newSet = new Set(enabledFields.value);
+		if (newSet.has(index)) newSet.delete(index);
+		else newSet.add(index);
+		enabledFields.value = newSet;
+	}
+	function renameField(index, name) {
+		fieldNames.value = {
+			...fieldNames.value,
+			[index]: name
+		};
+	}
+	function loadExperimentData(rawData) {
+		const parsed = extractSamplesFromDesignData(rawData);
+		if (!parsed) return false;
+		inputMode.value = "experiment";
+		csvData.value = parsed;
+		parseCsvInput();
+		return true;
+	}
+	function reset() {
+		rawText.value = "";
+		csvData.value = null;
+		delimiter.value = "_";
+		dominantFieldCount.value = 1;
+		minFieldCount.value = 1;
+		outliers.value = [];
+		fields.value = [];
+		fieldNames.value = {};
+		enabledFields.value = /* @__PURE__ */ new Set();
+	}
+	return {
+		inputMode,
+		rawText,
+		csvData,
+		delimiter,
+		dominantFieldCount,
+		minFieldCount,
+		outliers,
+		fields,
+		fieldNames,
+		enabledFields,
+		samples,
+		hasOutliers,
+		conformingSamples,
+		groups,
+		metadata,
+		excludedSamples,
+		allSingletons,
+		result,
+		effectiveColumns,
+		parseInput,
+		loadExperimentData,
+		setOutlierAction,
+		setAllOutlierActions,
+		toggleField,
+		renameField,
+		reset
+	};
+}
+//#endregion
+//#region src/utils/color.ts
+var HEX_RE = /^#?([0-9a-f]{3}|[0-9a-f]{6})$/i;
+function clamp(n, min, max) {
+	return Math.min(max, Math.max(min, n));
+}
+function hexToHsl(hex) {
+	const match = HEX_RE.exec(hex.trim());
+	if (!match) return {
+		h: 0,
+		s: 0,
+		l: 50
+	};
+	let raw = match[1];
+	if (raw.length === 3) raw = raw.split("").map((c) => c + c).join("");
+	const r = parseInt(raw.slice(0, 2), 16) / 255;
+	const g = parseInt(raw.slice(2, 4), 16) / 255;
+	const b = parseInt(raw.slice(4, 6), 16) / 255;
+	const max = Math.max(r, g, b);
+	const min = Math.min(r, g, b);
+	const delta = max - min;
+	let h = 0;
+	if (delta !== 0) if (max === r) h = (g - b) / delta % 6;
+	else if (max === g) h = (b - r) / delta + 2;
+	else h = (r - g) / delta + 4;
+	h = (h * 60 + 360) % 360;
+	const l = (max + min) / 2;
+	const s = delta === 0 ? 0 : delta / (1 - Math.abs(2 * l - 1));
+	return {
+		h,
+		s: s * 100,
+		l: l * 100
+	};
+}
+function hslToHex(h, s, l) {
+	const sNorm = clamp(s, 0, 100) / 100;
+	const lNorm = clamp(l, 0, 100) / 100;
+	const hNorm = (h % 360 + 360) % 360;
+	const c = (1 - Math.abs(2 * lNorm - 1)) * sNorm;
+	const x = c * (1 - Math.abs(hNorm / 60 % 2 - 1));
+	const m = lNorm - c / 2;
+	let r = 0, g = 0, b = 0;
+	if (hNorm < 60) [r, g, b] = [
+		c,
+		x,
+		0
+	];
+	else if (hNorm < 120) [r, g, b] = [
+		x,
+		c,
+		0
+	];
+	else if (hNorm < 180) [r, g, b] = [
+		0,
+		c,
+		x
+	];
+	else if (hNorm < 240) [r, g, b] = [
+		0,
+		x,
+		c
+	];
+	else if (hNorm < 300) [r, g, b] = [
+		x,
+		0,
+		c
+	];
+	else [r, g, b] = [
+		c,
+		0,
+		x
+	];
+	const toHex = (n) => Math.round((n + m) * 255).toString(16).padStart(2, "0");
+	return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+}
+/**
+* Derive a same-hue-family shade of `parentHex` for child at `index` of `total`.
+*
+* Lightness is distributed evenly within [35, 75] so all children remain
+* readable on light/dark backgrounds. Hue and saturation are inherited from
+* the parent. With `total <= 1`, returns the parent unchanged.
+*
+* Children are ordered light → dark by index, so index 0 is the brightest
+* sibling and index `total - 1` is the darkest.
+*/
+function deriveShade(parentHex, index, total) {
+	if (total <= 1) return parentHex;
+	const { h, s, l } = hexToHsl(parentHex);
+	const L_MIN = 35;
+	const L_MAX = 75;
+	const spread = Math.min(L_MAX - L_MIN, 40);
+	const center = clamp(l, L_MIN + spread / 2, L_MAX - spread / 2);
+	const top = center + spread / 2;
+	const bot = center - spread / 2;
+	const childL = top - (total === 1 ? .5 : index / (total - 1)) * (top - bot);
+	return hslToHex(h, clamp(s, 35, 100), childL);
+}
+//#endregion
+//#region src/composables/useSampleGroups.ts
+/** Shared sample-group hierarchy, color, and ungrouped-sample derivation for lab selectors. */
+function useSampleGroups(options) {
+	const groups = computed(() => [...toValue(options.groups)]);
+	const samples = computed(() => [...toValue(options.samples) ?? []]);
+	const fallbackColor = computed(() => toValue(options.fallbackColor) || "#3B82F6");
+	const separator = computed(() => {
+		const explicit = toValue(options.separator);
+		if (explicit) return explicit;
+		return groups.value.some((group) => group.name.includes("/")) ? "/" : "_";
+	});
+	const hierarchicalGroups = computed(() => {
+		if (groups.value.length === 0) return [];
+		const groupedByMajor = /* @__PURE__ */ new Map();
+		for (const group of groups.value) {
+			const majorName = getMajorGroupName(group.name, separator.value);
+			const existing = groupedByMajor.get(majorName);
+			if (existing) existing.push(group);
+			else groupedByMajor.set(majorName, [group]);
+		}
+		return [...groupedByMajor.entries()].map(([majorName, subGroups]) => {
+			const color = subGroups[0]?.color || fallbackColor.value;
+			return {
+				name: majorName,
+				color,
+				subGroups: subGroups.map((subGroup, index) => {
+					const displayColor = deriveShade(color, index, subGroups.length);
+					return {
+						...subGroup,
+						displayColor,
+						displayBg: displayColor + "20",
+						displayBorder: displayColor + "40"
+					};
+				}),
+				allSamples: subGroups.flatMap((group) => group.samples)
+			};
+		});
+	});
+	const showHierarchy = computed(() => hierarchicalGroups.value.some((major) => major.subGroups.length > 1 || major.subGroups.length === 1 && major.name !== major.subGroups[0].name));
+	const groupedSamples = computed(() => new Set(groups.value.flatMap((group) => group.samples)));
+	const ungroupedSamples = computed(() => samples.value.filter((sample) => !groupedSamples.value.has(sample)));
+	function findGroup(groupName) {
+		return groups.value.find((group) => group.name === groupName);
+	}
+	function getGroupColor(groupName) {
+		return findGroup(groupName)?.color || fallbackColor.value;
+	}
+	return {
+		groups,
+		separator,
+		hierarchicalGroups,
+		showHierarchy,
+		groupedSamples,
+		ungroupedSamples,
+		findGroup,
+		getGroupColor
+	};
+}
+function getMajorGroupName(groupName, separator) {
+	const parts = groupName.split(separator);
+	return parts.length > 1 ? parts[0] : groupName;
+}
+//#endregion
+//#region src/composables/useExpansionSet.ts
+/** Shared expansion state for trees, grouped selectors, and disclosure lists. */
+function useExpansionSet(options = {}) {
+	const expandedIds = ref(new Set(normalizeIds(toValue(options.defaultIds))));
+	const expandedList = computed(() => [...expandedIds.value]);
+	if (options.expandAll !== void 0) watch(() => toValue(options.expandAll), (shouldExpandAll) => {
+		if (shouldExpandAll === void 0 || shouldExpandAll === null) return;
+		if (shouldExpandAll) setExpanded(normalizeIds(toValue(options.allIds)));
+		else reset();
+	}, { immediate: true });
+	if (options.allIds !== void 0) watch(() => normalizeIds(toValue(options.allIds)), (ids) => {
+		if (toValue(options.expandAll)) setExpanded(ids);
+	});
+	function isExpanded(id) {
+		return expandedIds.value.has(id);
+	}
+	function expand(id) {
+		if (expandedIds.value.has(id)) return;
+		expandedIds.value = new Set([...expandedIds.value, id]);
+	}
+	function collapse(id) {
+		if (!expandedIds.value.has(id)) return;
+		const next = new Set(expandedIds.value);
+		next.delete(id);
+		expandedIds.value = next;
+	}
+	function toggle(id) {
+		if (expandedIds.value.has(id)) {
+			collapse(id);
+			return false;
+		}
+		expand(id);
+		return true;
+	}
+	function expandMany(ids) {
+		expandedIds.value = new Set([...expandedIds.value, ...normalizeIds(ids)]);
+	}
+	function setExpanded(ids) {
+		expandedIds.value = new Set(normalizeIds(ids));
+	}
+	function collapseAll() {
+		expandedIds.value = /* @__PURE__ */ new Set();
+	}
+	function reset() {
+		setExpanded(normalizeIds(toValue(options.defaultIds)));
+	}
+	return {
+		expandedIds,
+		expandedList,
+		isExpanded,
+		expand,
+		collapse,
+		toggle,
+		expandMany,
+		setExpanded,
+		collapseAll,
+		reset
+	};
+}
+function normalizeIds(ids) {
+	if (!ids) return [];
+	return [...new Set(ids.filter(Boolean))];
+}
+//#endregion
+//#region src/composables/platformContextHelpers.ts
+function getInjectedPlatformContext() {
+	if (typeof window === "undefined") return void 0;
+	return window.__MINT_PLATFORM__;
+}
+function getInjectedExperimentContext() {
+	return getInjectedPlatformContext();
+}
+function currentExperimentFromContext(context = getInjectedExperimentContext()) {
+	const candidate = context?.currentExperiment ?? context?.experiment;
+	return candidate && typeof candidate === "object" ? candidate : void 0;
+}
+function currentExperimentIdFromContext(context = getInjectedExperimentContext()) {
+	return parseExperimentId(context?.currentExperimentId ?? context?.experimentId ?? context?.currentExperiment ?? context?.experiment);
+}
+function currentExperimentIdFromUrl() {
+	if (typeof window === "undefined") return void 0;
+	const params = new URLSearchParams(window.location.search);
+	return parseExperimentId(params.get("experimentId") ?? params.get("experiment_id")) ?? experimentIdFromPath(window.location.pathname) ?? experimentIdFromPath(window.location.hash.replace(/^#\/?/, "/"));
+}
+function resolveCurrentExperimentId(context = getInjectedExperimentContext()) {
+	return currentExperimentIdFromContext(context) ?? currentExperimentIdFromUrl();
+}
+function parseExperimentId(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value === "string" && value.trim()) {
+		const parsed = Number(value);
+		return Number.isFinite(parsed) ? parsed : void 0;
+	}
+	if (value && typeof value === "object" && "id" in value) return parseExperimentId(value.id);
+}
+function experimentIdFromPath(path) {
+	const segments = path.split("/").filter(Boolean);
+	for (let index = 0; index < segments.length - 1; index += 1) {
+		const segment = segments[index]?.toLowerCase();
+		if (segment === "experiment" || segment === "experiments") return parseExperimentId(decodeURIComponent(segments[index + 1] ?? ""));
+	}
+}
+//#endregion
+//#region src/composables/useExperimentSave.ts
+/** Persists experiment design, analysis, and built-in template preset data through the platform API. */
+function useExperimentSave(options = {}) {
+	const injectedContext = getInjectedPlatformContext();
+	const api = useApi({ baseUrl: options.apiBaseUrl ?? injectedContext?.platformApiUrl });
+	const pluginId = options.pluginId ?? injectedContext?.plugin?.id;
+	const schemaVersion = options.schemaVersion ?? "1.0";
+	const currentExperimentId = computed(() => {
+		return resolveCurrentExperimentId(injectedContext);
+	});
+	const hasCurrentExperiment = computed(() => currentExperimentId.value !== void 0);
+	const request = useRequestSyncState("Experiment request failed.");
+	const isSaving = ref(false);
+	const isLoading = ref(false);
+	const error = request.error;
+	const lastLoadedAt = request.lastLoadedAt;
+	const lastSavedAt = request.lastSavedAt;
+	function requireCurrentExperimentId() {
+		const id = currentExperimentId.value;
+		if (id === void 0) throw new Error("[MINT SDK] No current experiment is selected.");
+		return id;
+	}
+	function currentExperimentIdOrError(action) {
+		const id = currentExperimentId.value;
+		if (id === void 0) {
+			request.setError(`No current experiment is selected for ${action}`);
+			return;
+		}
+		return id;
+	}
+	async function saveDesign(experimentId, data) {
+		if (!pluginId) {
+			request.setError("pluginId is required for saveDesign");
+			return false;
+		}
+		isSaving.value = true;
+		try {
+			await request.run(async () => {
+				await api.put(`/experiments/${experimentId}/data`, {
+					plugin_id: pluginId,
+					data,
+					schema_version: schemaVersion
+				});
+			}, { success: "save" });
+			return true;
+		} catch {
+			return false;
+		} finally {
+			isSaving.value = false;
+		}
+	}
+	async function saveCurrentDesign(data) {
+		const experimentId = currentExperimentIdOrError("saveDesign");
+		return experimentId === void 0 ? false : saveDesign(experimentId, data);
+	}
+	async function saveTemplatePreset(experimentId, name, presetOptions = {}) {
+		return saveDesign(experimentId, createBioTemplatePresetCollection(name, presetOptions));
+	}
+	async function saveCurrentTemplatePreset(name, presetOptions = {}) {
+		const experimentId = currentExperimentIdOrError("saveTemplatePreset");
+		return experimentId === void 0 ? false : saveTemplatePreset(experimentId, name, presetOptions);
+	}
+	async function saveAnalysis(experimentId, result) {
+		if (!pluginId) {
+			request.setError("pluginId is required for saveAnalysis");
+			return false;
+		}
+		isSaving.value = true;
+		try {
+			await request.run(async () => {
+				await api.put(`/experiments/${experimentId}/results/${pluginId}`, { result });
+			}, { success: "save" });
+			return true;
+		} catch {
+			return false;
+		} finally {
+			isSaving.value = false;
+		}
+	}
+	async function saveCurrentAnalysis(result) {
+		const experimentId = currentExperimentIdOrError("saveAnalysis");
+		return experimentId === void 0 ? false : saveAnalysis(experimentId, result);
+	}
+	async function save(experimentId, opts) {
+		if ((opts.design || opts.analysis) && !pluginId) {
+			request.setError("pluginId is required for save");
+			return false;
+		}
+		isSaving.value = true;
+		try {
+			await request.run(async () => {
+				if (opts.design) await api.put(`/experiments/${experimentId}/data`, {
+					plugin_id: pluginId,
+					data: opts.design,
+					schema_version: schemaVersion
+				});
+				if (opts.analysis) await api.put(`/experiments/${experimentId}/results/${pluginId}`, { result: opts.analysis });
+			}, { success: "save" });
+			return true;
+		} catch {
+			return false;
+		} finally {
+			isSaving.value = false;
+		}
+	}
+	async function loadDesign(experimentId) {
+		isLoading.value = true;
+		try {
+			return await request.run(() => api.get(`/experiments/${experimentId}/data`), { success: "load" });
+		} catch {
+			return null;
+		} finally {
+			isLoading.value = false;
+		}
+	}
+	async function loadCurrentDesign() {
+		const experimentId = currentExperimentIdOrError("loadDesign");
+		return experimentId === void 0 ? null : loadDesign(experimentId);
+	}
+	async function loadAnalysis(experimentId) {
+		if (!pluginId) {
+			request.setError("pluginId is required for loadAnalysis");
+			return null;
+		}
+		isLoading.value = true;
+		try {
+			return await request.run(() => api.get(`/experiments/${experimentId}/results/${pluginId}`), { success: "load" });
+		} catch {
+			return null;
+		} finally {
+			isLoading.value = false;
+		}
+	}
+	async function loadCurrentAnalysis() {
+		const experimentId = currentExperimentIdOrError("loadAnalysis");
+		return experimentId === void 0 ? null : loadAnalysis(experimentId);
+	}
+	async function deleteDesign(experimentId) {
+		isLoading.value = true;
+		try {
+			await request.run(() => api.delete(`/experiments/${experimentId}/data`));
+			return true;
+		} catch {
+			return false;
+		} finally {
+			isLoading.value = false;
+		}
+	}
+	async function deleteCurrentDesign() {
+		const experimentId = currentExperimentIdOrError("deleteDesign");
+		return experimentId === void 0 ? false : deleteDesign(experimentId);
+	}
+	async function deleteAnalysis(experimentId) {
+		if (!pluginId) {
+			request.setError("pluginId is required for deleteAnalysis");
+			return false;
+		}
+		isLoading.value = true;
+		try {
+			await request.run(() => api.delete(`/experiments/${experimentId}/results/${pluginId}`));
+			return true;
+		} catch {
+			return false;
+		} finally {
+			isLoading.value = false;
+		}
+	}
+	async function deleteCurrentAnalysis() {
+		const experimentId = currentExperimentIdOrError("deleteAnalysis");
+		return experimentId === void 0 ? false : deleteAnalysis(experimentId);
+	}
+	return {
+		currentExperimentId,
+		hasCurrentExperiment,
+		isSaving,
+		isLoading,
+		error,
+		lastLoadedAt,
+		lastSavedAt,
+		saveDesign,
+		saveCurrentDesign,
+		saveTemplatePreset,
+		saveCurrentTemplatePreset,
+		saveAnalysis,
+		saveCurrentAnalysis,
+		save,
+		loadDesign,
+		loadCurrentDesign,
+		loadAnalysis,
+		loadCurrentAnalysis,
+		deleteDesign,
+		deleteCurrentDesign,
+		deleteAnalysis,
+		deleteCurrentAnalysis,
+		requireCurrentExperimentId
+	};
+}
+//#endregion
+//#region src/composables/useTemplateCollection.ts
+/** Manages a biology template collection in the current experiment's design_data. */
+function useTemplateCollection(options = {}) {
+	const experimentSave = useExperimentSave(options);
+	const templateCollection = ref(createInitialCollection(options));
+	const templates = computed(() => extractTemplateCollection(templateCollection.value));
+	const metadata = computed(() => templateCollection.value.metadata ?? {});
+	const templateIds = computed(() => Object.keys(templates.value));
+	const hasTemplates = computed(() => templateIds.value.length > 0);
+	function apply(value, metadata) {
+		templateCollection.value = normalizeTemplateCollection(value, metadata);
+		return templateCollection.value;
+	}
+	function reset() {
+		templateCollection.value = createInitialCollection(options);
+		return templateCollection.value;
+	}
+	function setTemplate(template) {
+		const nextTemplates = {
+			...templates.value,
+			[template.template_id]: template
+		};
+		templateCollection.value = createTemplateCollectionEnvelope(Object.values(nextTemplates), templateCollection.value.metadata);
+		return templateCollection.value;
+	}
+	function removeTemplate(templateId) {
+		if (!templates.value[templateId]) return false;
+		const nextTemplates = { ...templates.value };
+		delete nextTemplates[templateId];
+		templateCollection.value = createTemplateCollectionEnvelope(Object.values(nextTemplates), templateCollection.value.metadata);
+		return true;
+	}
+	function getTemplate(templateId) {
+		return templates.value[templateId] ?? null;
+	}
+	function requireTemplate(templateId) {
+		return ensureTemplateFromCollection(templateCollection.value, templateId);
+	}
+	async function load(experimentId) {
+		const data = await experimentSave.loadDesign(experimentId);
+		return data === null ? null : apply(data);
+	}
+	async function loadCurrent() {
+		const data = await experimentSave.loadCurrentDesign();
+		return data === null ? null : apply(data);
+	}
+	async function save(experimentId) {
+		return experimentSave.saveDesign(experimentId, templateCollection.value);
+	}
+	async function saveCurrent() {
+		return experimentSave.saveCurrentDesign(templateCollection.value);
+	}
+	return {
+		currentExperimentId: experimentSave.currentExperimentId,
+		hasCurrentExperiment: experimentSave.hasCurrentExperiment,
+		templateCollection,
+		templates,
+		metadata,
+		templateIds,
+		hasTemplates,
+		isLoading: experimentSave.isLoading,
+		isSaving: experimentSave.isSaving,
+		error: experimentSave.error,
+		lastLoadedAt: experimentSave.lastLoadedAt,
+		lastSavedAt: experimentSave.lastSavedAt,
+		apply,
+		reset,
+		setTemplate,
+		removeTemplate,
+		getTemplate,
+		requireTemplate,
+		load,
+		loadCurrent,
+		save,
+		saveCurrent,
+		requireCurrentExperimentId: experimentSave.requireCurrentExperimentId
+	};
+}
+function createInitialCollection(options) {
+	const initial = typeof options.initial === "function" ? options.initial() : options.initial;
+	if (initial === void 0) return { templates: {} };
+	return normalizeTemplateCollection(initial);
+}
+function normalizeTemplateCollection(value, metadata) {
+	if (Array.isArray(value)) return createTemplateCollectionEnvelope(value, metadata);
+	return createTemplateCollectionEnvelope(Object.values(extractTemplateCollection(value)), readCollectionMetadata(value) ?? metadata);
+}
+function createTemplateCollectionEnvelope(templates, metadata) {
+	return metadata === void 0 ? createTemplateCollection(templates) : createTemplateCollection(templates, metadata);
+}
+function readCollectionMetadata(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value) || !("metadata" in value)) return;
+	const metadata = value.metadata;
+	if (typeof metadata === "object" && metadata !== null && !Array.isArray(metadata)) return metadata;
+}
+//#endregion
+//#region src/composables/useBioTemplateControls.ts
+/** Build FormBuilder schema, AppSidebar panels, and defaults for a built-in biology template or preset. */
+function useBioTemplateControls(target, options = {}) {
+	const { initialValues, topBarSettings: _topBarSettings, ...schemaOptions } = options;
+	const controls = createBioTemplateControlToolkit(target, schemaOptions);
+	if (initialValues === void 0) return controls;
+	return {
+		...controls,
+		initialValues: {
+			...controls.initialValues,
+			...initialValues
+		}
+	};
+}
+//#endregion
+//#region src/composables/useBioTemplateComponents.ts
+/** Return component props grouped by SDK component name for direct WellPlate/DoseCalculator binding. */
+function toBioTemplateComponentPropsByComponent(target) {
+	return toBioTemplateComponentPropsByComponent$1(target);
+}
+/** Return the first props object for an SDK component, optionally restricted by template id or binding id. */
+function getBioTemplateComponentProps(target, component, options = {}) {
+	return getBioTemplateComponentProps$1(target, component, options);
+}
+/** Map built-in biology templates to SDK components such as WellPlate, DataFrame, DoseCalculator, and PlateMapEditor. */
+function useBioTemplateComponents(target) {
+	return {
+		bindings: getBioTemplateComponentBindings(target),
+		imports: toBioTemplateComponentImports(target),
+		componentProps: typeof target === "string" ? [] : toBioTemplateComponentProps(target),
+		componentPropsById: typeof target === "string" ? {} : toBioTemplateComponentPropsById(target),
+		componentPropsByComponent: typeof target === "string" ? {} : toBioTemplateComponentPropsByComponent(target),
+		snippets: typeof target === "string" ? [] : toBioTemplateComponentSnippets(target),
+		usage: typeof target === "string" ? null : toBioTemplateComponentUsage(target),
+		getComponentProps: (component, options) => typeof target === "string" ? void 0 : getBioTemplateComponentProps(target, component, options)
+	};
+}
+//#endregion
+//#region src/composables/useBioTemplateWorkspace.ts
+/** One-stop wiring for BioTemplateRenderer, FormBuilder, AppSidebar, and template-aware SDK components. */
+function useBioTemplateWorkspace(target, options = {}) {
+	const controls = useBioTemplateControls(target, options);
+	const workspace = useControlWorkspace(controls.controls, options);
+	const components = useBioTemplateComponents(target);
+	const renderer = isTemplateObjectTarget(target) ? { target } : null;
+	const bindings = {
+		renderer,
+		form: workspace.bindings.form,
+		sidebar: workspace.bindings.sidebar,
+		topBar: workspace.bindings.topBar,
+		topBarTabs: workspace.bindings.topBarTabs,
+		topBarSettings: workspace.bindings.topBarSettings,
+		pillNav: workspace.bindings.pillNav,
+		componentBindings: components.bindings,
+		componentProps: components.componentProps,
+		componentPropsById: components.componentPropsById,
+		componentPropsByComponent: components.componentPropsByComponent,
+		componentSnippets: components.snippets,
+		componentUsage: components.usage,
+		getComponentProps: components.getComponentProps
+	};
+	return {
+		target,
+		controls,
+		workspace,
+		controlSchema: controls.controls,
+		components,
+		values: workspace.values,
+		activeView: workspace.activeView,
+		form: workspace.form,
+		sidebar: workspace.sidebar,
+		topBar: workspace.topBar,
+		pillNav: workspace.pillNav,
+		topBarSettings: workspace.topBarSettings,
+		bindings,
+		renderer,
+		componentBindings: components.bindings,
+		componentImports: components.imports,
+		componentProps: components.componentProps,
+		componentPropsById: components.componentPropsById,
+		componentPropsByComponent: components.componentPropsByComponent,
+		componentSnippets: components.snippets,
+		componentUsage: components.usage,
+		getComponentProps: components.getComponentProps
+	};
+}
+function isTemplateObjectTarget(target) {
+	return typeof target !== "string";
+}
+//#endregion
+//#region src/composables/useBioTemplatePackWorkspace.ts
+/** Create a complete workspace for a curated biology template pack from a single pack id. */
+function useBioTemplatePackWorkspace(packId, options = {}) {
+	const pack = getBioTemplatePackInfo(packId);
+	if (!pack) throw new Error(`Unknown template pack '${packId}'.`);
+	const resolvedPack = pack;
+	const templateCollection = useTemplateCollection({
+		...options,
+		initial: createDefaultCollection
+	});
+	const collection = templateCollection.templateCollection;
+	let workspaceScope;
+	function createWorkspace(value) {
+		workspaceScope?.stop();
+		workspaceScope = effectScope();
+		return workspaceScope.run(() => useBioTemplateWorkspace(value));
+	}
+	const workspaceRef = shallowRef(createWorkspace(collection.value));
+	const workspace = computed(() => workspaceRef.value);
+	const renderer = computed(() => ({ target: collection.value }));
+	const form = computed(() => workspace.value.form);
+	const sidebar = computed(() => workspace.value.sidebar);
+	const topBar = computed(() => workspace.value.topBar);
+	const pillNav = computed(() => workspace.value.pillNav);
+	const topBarSettings = computed(() => workspace.value.topBarSettings);
+	const bindings = computed(() => workspace.value.bindings);
+	const componentBindings = computed(() => workspace.value.componentBindings);
+	const componentImports = computed(() => workspace.value.componentImports);
+	const componentProps = computed(() => workspace.value.componentProps);
+	const componentPropsById = computed(() => workspace.value.componentPropsById);
+	const componentPropsByComponent = computed(() => workspace.value.componentPropsByComponent);
+	const componentSnippets = computed(() => workspace.value.componentSnippets);
+	const componentUsage = computed(() => workspace.value.componentUsage);
+	watch(collection, (value) => {
+		workspaceRef.value = createWorkspace(value);
+	});
+	if (getCurrentScope()) onScopeDispose(() => workspaceScope?.stop());
+	function createDefaultCollection() {
+		return createBioTemplatePackCollection(resolvedPack.name);
+	}
+	function applyCollection(value, metadata) {
+		return templateCollection.apply(value, metadata);
+	}
+	function resetToDefaultCollection() {
+		return templateCollection.apply(createDefaultCollection());
+	}
+	return {
+		packId: resolvedPack.name,
+		pack: resolvedPack,
+		collection,
+		templates: templateCollection.templates,
+		templateIds: templateCollection.templateIds,
+		currentExperimentId: templateCollection.currentExperimentId,
+		hasCurrentExperiment: templateCollection.hasCurrentExperiment,
+		loading: templateCollection.isLoading,
+		saving: templateCollection.isSaving,
+		error: templateCollection.error,
+		lastLoadedAt: templateCollection.lastLoadedAt,
+		lastSavedAt: templateCollection.lastSavedAt,
+		renderer,
+		workspace,
+		form,
+		sidebar,
+		topBar,
+		pillNav,
+		topBarSettings,
+		bindings,
+		componentBindings,
+		componentImports,
+		componentProps,
+		componentPropsById,
+		componentPropsByComponent,
+		componentSnippets,
+		componentUsage,
+		getComponentProps: (component, options) => workspace.value.getComponentProps(component, options),
+		applyCollection,
+		resetToDefaultCollection,
+		save: templateCollection.save,
+		saveCurrent: templateCollection.saveCurrent,
+		load: templateCollection.load,
+		loadCurrent: templateCollection.loadCurrent,
+		requireCurrentExperimentId: templateCollection.requireCurrentExperimentId
+	};
+}
+//#endregion
+//#region src/composables/useBioTemplatePresetWorkspace.ts
+/** Create a complete editable WellPlate/DoseCalculator workspace for dose design from a built-in biology template preset with current-experiment save wiring. */
+function useBioTemplatePresetWorkspace(presetId, options = {}) {
+	const { controlOptions, initialValues, ...collectionOptions } = options;
+	const resolvedControlOptions = mergeInitialValues(controlOptions, initialValues);
+	const presetWorkspace = useBioTemplateWorkspace(presetId, resolvedControlOptions);
+	const presetInfo = computed(() => getBioTemplatePresetInfo(presetId));
+	const presetLabel = computed(() => presetInfo.value?.label ?? humanizePresetId(presetId));
+	const controls = presetWorkspace.controls;
+	const controlValues = ref({ ...controls.initialValues });
+	const controlViewIds = computed(() => controls.viewIds);
+	const controlViewItems = computed(() => controls.viewItems);
+	const activeControlView = ref(controls.defaultView);
+	const templateCollection = useTemplateCollection({
+		...collectionOptions,
+		initial: createDefaultCollection
+	});
+	const collection = templateCollection.templateCollection;
+	const workspace = computed(() => useBioTemplateWorkspace(collection.value, resolvedControlOptions));
+	const renderer = computed(() => ({ target: collection.value }));
+	const componentBindings = computed(() => workspace.value.componentBindings);
+	const componentImports = computed(() => workspace.value.componentImports);
+	const componentProps = computed(() => workspace.value.componentProps);
+	const componentPropsById = computed(() => workspace.value.componentPropsById);
+	const componentPropsByComponent = computed(() => workspace.value.componentPropsByComponent);
+	const componentSnippets = computed(() => workspace.value.componentSnippets);
+	const componentUsage = computed(() => workspace.value.componentUsage);
+	const form = reactive({
+		...controls.form,
+		modelValue: controlValues.value,
+		"onUpdate:modelValue": setControlValues
+	});
+	const sidebar = reactive({
+		...controls.sidebar,
+		activeView: activeControlView.value,
+		modelValue: controlValues.value,
+		"onUpdate:modelValue": setControlValues,
+		values: controlValues.value,
+		"onUpdate:values": setControlValues
+	});
+	const topBar = reactive({
+		tabs: controls.topBarTabs,
+		currentTabId: activeControlView.value,
+		onTabSelect: (tab) => setActiveControlView(tab.id)
+	});
+	const pillNav = reactive({
+		items: controls.viewItems,
+		currentItemId: activeControlView.value,
+		onSelect: (item) => setActiveControlView(item.id)
+	});
+	const topBarSettings = reactive({
+		showSettings: true,
+		settingsConfig: {
+			...controls.topBarSettingsConfig,
+			values: controlValues.value
+		},
+		onSettingsValuesChange: setControlValues
+	});
+	const topBarProps = computed(() => ({
+		pillNav: pillNav.items,
+		currentPillId: pillNav.currentItemId,
+		onPillSelect: pillNav.onSelect,
+		...topBarSettings
+	}));
+	const topBarTabsProps = computed(() => ({
+		tabs: topBar.tabs,
+		currentTabId: topBar.currentTabId,
+		onTabSelect: topBar.onTabSelect,
+		...topBarSettings
+	}));
+	function getComponentProps(component, options) {
+		return workspace.value.getComponentProps(component, options);
+	}
+	const bindings = {
+		renderer,
+		form,
+		sidebar,
+		topBar: topBarProps,
+		topBarTabs: topBarTabsProps,
+		topBarSettings,
+		pillNav,
+		componentBindings,
+		componentProps,
+		componentPropsById,
+		componentPropsByComponent,
+		componentSnippets,
+		componentUsage,
+		getComponentProps
+	};
+	function createDefaultCollection() {
+		return createBioTemplatePresetCollectionFromControls(presetId, controls.initialValues);
+	}
+	watch(controlValues, (values) => {
+		syncControlValueBindings(values);
+		templateCollection.apply(createBioTemplatePresetCollectionFromControls(presetId, values));
+	}, { deep: true });
+	watch(activeControlView, (viewId) => {
+		sidebar.activeView = viewId;
+		topBar.currentTabId = viewId;
+		pillNav.currentItemId = viewId;
+	}, { flush: "sync" });
+	watch(() => sidebar.activeView, setActiveControlView, { flush: "sync" });
+	watch(() => topBar.currentTabId, setActiveControlView, { flush: "sync" });
+	watch(() => pillNav.currentItemId, setActiveControlView, { flush: "sync" });
+	function applyCollection(value) {
+		return templateCollection.apply(value);
+	}
+	function setActiveControlView(viewId) {
+		if (!controlViewIds.value.includes(viewId)) return;
+		activeControlView.value = viewId;
+	}
+	function setControlValues(values) {
+		const nextValues = { ...values };
+		controlValues.value = nextValues;
+		syncControlValueBindings(nextValues);
+		return templateCollection.apply(createBioTemplatePresetCollectionFromControls(presetId, nextValues));
+	}
+	function updateControlValues(values) {
+		return setControlValues({
+			...controlValues.value,
+			...values
+		});
+	}
+	function resetToDefaultCollection() {
+		return setControlValues({ ...controls.initialValues });
+	}
+	function syncControlValueBindings(values) {
+		form.modelValue = values;
+		sidebar.modelValue = values;
+		sidebar.values = values;
+		topBarSettings.settingsConfig = {
+			...topBarSettings.settingsConfig,
+			values
+		};
+	}
+	return {
+		presetId,
+		presetInfo,
+		presetLabel,
+		collection,
+		templates: templateCollection.templates,
+		templateIds: templateCollection.templateIds,
+		currentExperimentId: templateCollection.currentExperimentId,
+		hasCurrentExperiment: templateCollection.hasCurrentExperiment,
+		saving: templateCollection.isSaving,
+		error: templateCollection.error,
+		lastSavedAt: templateCollection.lastSavedAt,
+		controls,
+		controlSchema: controls.controls,
+		controlValues,
+		controlViewIds,
+		controlViewItems,
+		activeControlView,
+		form,
+		sidebar,
+		topBar,
+		pillNav,
+		topBarSettings,
+		bindings,
+		renderer,
+		workspace,
+		componentBindings,
+		componentImports,
+		componentProps,
+		componentPropsById,
+		componentPropsByComponent,
+		componentSnippets,
+		componentUsage,
+		getComponentProps,
+		setActiveControlView,
+		setControlValues,
+		updateControlValues,
+		applyCollection,
+		resetToDefaultCollection,
+		save: templateCollection.save,
+		saveCurrent: templateCollection.saveCurrent
+	};
+}
+function humanizePresetId(value) {
+	return value.replace(/[-_]+/g, " ").replace(/\b\w/g, (match) => match.toUpperCase());
+}
+function mergeInitialValues(controlOptions, initialValues) {
+	if (initialValues === void 0) return controlOptions;
+	return {
+		...controlOptions ?? {},
+		initialValues: {
+			...controlOptions?.initialValues ?? {},
+			...initialValues
+		}
+	};
+}
+//#endregion
+//#region src/composables/useRackEditor.ts
+var SLOT_CYCLE = [
+	"R",
+	"G",
+	"B",
+	"Y"
+];
+var PLATE_CONFIGS = {
+	6: {
+		rows: 2,
+		cols: 3
+	},
+	12: {
+		rows: 3,
+		cols: 4
+	},
+	24: {
+		rows: 4,
+		cols: 6
+	},
+	48: {
+		rows: 6,
+		cols: 8
+	},
+	54: {
+		rows: 6,
+		cols: 9
+	},
+	96: {
+		rows: 8,
+		cols: 12
+	},
+	384: {
+		rows: 16,
+		cols: 24
+	}
+};
+var globalIdCounter = 0;
+function generateId() {
+	globalIdCounter++;
+	return `rack-${Date.now()}-${globalIdCounter}`;
+}
+/** Manages a set of sample racks with well-level assignment, series fill, and multi-rack reordering. */
+function useRackEditor(initialRacks, options) {
+	const defaultFormat = options?.defaultFormat ?? 54;
+	const defaultInjVol = options?.defaultInjectionVolume ?? 5;
+	const maxRacks = options?.maxRacks ?? 10;
+	const minRacks = options?.minRacks ?? 1;
+	function createDefaultRack(name, slotIndex) {
+		const slot = SLOT_CYCLE[(slotIndex ?? 0) % SLOT_CYCLE.length];
+		return {
+			id: generateId(),
+			name: name ?? `Rack ${racks.value.length + 1}`,
+			format: defaultFormat,
+			slot,
+			injectionVolume: defaultInjVol,
+			wells: {}
+		};
+	}
+	const racks = ref(initialRacks && initialRacks.length > 0 ? initialRacks.map((r) => ({ ...r })) : [createDefaultRack("Rack 1", 0)]);
+	const activeRackId = ref(racks.value[0]?.id ?? "");
+	const activeRack = computed(() => racks.value.find((r) => r.id === activeRackId.value) ?? racks.value[0]);
+	function addRack(name) {
+		if (racks.value.length >= maxRacks) return racks.value[racks.value.length - 1];
+		const rack = createDefaultRack(name, racks.value.length);
+		racks.value.push(rack);
+		activeRackId.value = rack.id;
+		return rack;
+	}
+	function removeRack(rackId) {
+		if (racks.value.length <= minRacks) return;
+		const index = racks.value.findIndex((r) => r.id === rackId);
+		if (index === -1) return;
+		racks.value.splice(index, 1);
+		if (activeRackId.value === rackId && racks.value[0]) activeRackId.value = racks.value[0].id;
+	}
+	function reorderRacks(fromIndex, toIndex) {
+		if (fromIndex < 0 || fromIndex >= racks.value.length) return;
+		if (toIndex < 0 || toIndex >= racks.value.length) return;
+		if (fromIndex === toIndex) return;
+		const [moved] = racks.value.splice(fromIndex, 1);
+		if (moved) racks.value.splice(toIndex, 0, moved);
+	}
+	function updateRack(rackId, data) {
+		const rack = racks.value.find((r) => r.id === rackId);
+		if (!rack) return;
+		if (data.name !== void 0) rack.name = data.name;
+		if (data.format !== void 0) rack.format = data.format;
+		if (data.slot !== void 0) rack.slot = data.slot;
+		if (data.injectionVolume !== void 0) rack.injectionVolume = data.injectionVolume;
+		if (data.wells !== void 0) rack.wells = data.wells;
+	}
+	function setActiveRack(rackId) {
+		if (racks.value.some((r) => r.id === rackId)) activeRackId.value = rackId;
+	}
+	function setWellData(rackId, wellId, data) {
+		const rack = racks.value.find((r) => r.id === rackId);
+		if (!rack) return;
+		rack.wells[wellId] = {
+			...rack.wells[wellId],
+			...data
+		};
+	}
+	function clearWell(rackId, wellId) {
+		const rack = racks.value.find((r) => r.id === rackId);
+		if (!rack) return;
+		delete rack.wells[wellId];
+	}
+	function clearAllWells(rackId) {
+		const rack = racks.value.find((r) => r.id === rackId);
+		if (!rack) return;
+		rack.wells = {};
+	}
+	function fillSeries(rackId, prefix = "S") {
+		const rack = racks.value.find((r) => r.id === rackId);
+		if (!rack) return;
+		const config = PLATE_CONFIGS[rack.format];
+		if (!config) return;
+		let counter = 1;
+		for (let row = 0; row < config.rows; row++) for (let col = 0; col < config.cols; col++) {
+			const wellId = `${String.fromCharCode(65 + row)}${col + 1}`;
+			if (!rack.wells[wellId]?.sampleType) {
+				const paddedNum = String(counter).padStart(3, "0");
+				rack.wells[wellId] = {
+					id: wellId,
+					row,
+					col,
+					state: "filled",
+					sampleType: "sample",
+					metadata: {
+						label: `${prefix}${paddedNum}`,
+						injectionVolume: rack.injectionVolume,
+						injectionCount: 1
+					}
+				};
+			}
+			counter++;
+		}
+	}
+	function getAllWells() {
+		const result = [];
+		for (const rack of racks.value) for (const [wellId, well] of Object.entries(rack.wells)) result.push({
+			rackId: rack.id,
+			wellId,
+			well
+		});
+		return result;
+	}
+	const totalSampleCount = computed(() => {
+		let count = 0;
+		for (const rack of racks.value) count += Object.keys(rack.wells).length;
+		return count;
+	});
+	function reset() {
+		racks.value = [createDefaultRack("Rack 1", 0)];
+		activeRackId.value = racks.value[0].id;
+	}
+	return {
+		racks,
+		activeRack,
+		activeRackId,
+		addRack,
+		removeRack,
+		reorderRacks,
+		updateRack,
+		setActiveRack,
+		setWellData,
+		clearWell,
+		clearAllWells,
+		fillSeries,
+		getAllWells,
+		totalSampleCount,
+		reset
+	};
+}
+//#endregion
+//#region src/composables/useGroupAssignment.ts
+/** Shared two-zone group assignment model for control/treatment style workflows. */
+function useGroupAssignment(options) {
+	const groups = computed(() => [...toValue(options.groups)]);
+	const group1 = computed(() => [...toValue(options.group1)]);
+	const group2 = computed(() => [...toValue(options.group2)]);
+	const label1 = computed(() => toValue(options.label1) || "Control");
+	const label2 = computed(() => toValue(options.label2) || "Treatment");
+	const minPerGroup = computed(() => normalizeMinimum(toValue(options.minPerGroup)));
+	const group1Set = computed(() => new Set(group1.value));
+	const group2Set = computed(() => new Set(group2.value));
+	const unassignedGroups = computed(() => groups.value.filter((group) => !group1Set.value.has(group.name) && !group2Set.value.has(group.name)));
+	const zone1Groups = computed(() => groups.value.filter((group) => group1Set.value.has(group.name)));
+	const zone2Groups = computed(() => groups.value.filter((group) => group2Set.value.has(group.name)));
+	const zone1Count = computed(() => zone1Groups.value.reduce((sum, group) => sum + group.count, 0));
+	const zone2Count = computed(() => zone2Groups.value.reduce((sum, group) => sum + group.count, 0));
+	const isValid = computed(() => group1.value.length >= minPerGroup.value && group2.value.length >= minPerGroup.value);
+	const validationMessage = computed(() => {
+		if (isValid.value) return null;
+		const missing1 = Math.max(0, minPerGroup.value - group1.value.length);
+		const missing2 = Math.max(0, minPerGroup.value - group2.value.length);
+		const parts = [];
+		if (missing1 > 0) parts.push(`${missing1} more to ${label1.value}`);
+		if (missing2 > 0) parts.push(`${missing2} more to ${label2.value}`);
+		return `Add ${parts.join(" and ")}`;
+	});
+	function getZoneForGroup(groupName) {
+		if (group1Set.value.has(groupName)) return "zone1";
+		if (group2Set.value.has(groupName)) return "zone2";
+		return null;
+	}
+	function assignToZone(groupName, zone) {
+		const next = removeFromBoth(groupName);
+		if (zone === "zone1") return {
+			group1: [...next.group1, groupName],
+			group2: next.group2
+		};
+		return {
+			group1: next.group1,
+			group2: [...next.group2, groupName]
+		};
+	}
+	function removeFromZone(groupName, zone) {
+		if (zone === "zone1") return {
+			group1: group1.value.filter((name) => name !== groupName),
+			group2: group2.value
+		};
+		return {
+			group1: group1.value,
+			group2: group2.value.filter((name) => name !== groupName)
+		};
+	}
+	function clearAll() {
+		return {
+			group1: [],
+			group2: []
+		};
+	}
+	function removeFromBoth(groupName) {
+		return {
+			group1: group1.value.filter((name) => name !== groupName),
+			group2: group2.value.filter((name) => name !== groupName)
+		};
+	}
+	return {
+		unassignedGroups,
+		zone1Groups,
+		zone2Groups,
+		zone1Count,
+		zone2Count,
+		isValid,
+		validationMessage,
+		getZoneForGroup,
+		assignToZone,
+		removeFromZone,
+		clearAll
+	};
+}
+function normalizeMinimum(value) {
+	if (value === null || value === void 0 || !Number.isFinite(value)) return 1;
+	return Math.max(0, Math.floor(value));
+}
+//#endregion
+//#region src/composables/useReagentSeries.ts
+var DEFAULT_PRESETS = [
+	{
+		label: "2x",
+		factor: 2
+	},
+	{
+		label: "3x",
+		factor: 3
+	},
+	{
+		label: "½ log",
+		factor: "half-log"
+	},
+	{
+		label: "10x",
+		factor: 10
+	}
+];
+var DEFAULT_UNITS = [
+	"µM",
+	"nM",
+	"mM",
+	"pM"
+];
+function resolveFactor(factor) {
+	return factor === "half-log" ? Math.sqrt(10) : factor;
+}
+function roundToSignificant(value, digits = 4) {
+	if (value === 0) return 0;
+	const magnitude = Math.floor(Math.log10(Math.abs(value))) + 1;
+	const factor = Math.pow(10, digits - magnitude);
+	return Math.round(value * factor) / factor;
+}
+function generateDilutionSeries(startConcentration, count, factor, defaultReplicates = 1) {
+	if (count < 1 || startConcentration <= 0) return [];
+	const divisor = resolveFactor(factor);
+	const levels = [];
+	for (let i = 0; i < count; i++) levels.push({
+		value: roundToSignificant(startConcentration / Math.pow(divisor, i)),
+		replicates: defaultReplicates
+	});
+	return levels;
+}
+/** Generates and sorts geometric dilution series (2x, 3x, ½ log, 10x) for plate-based experiments. */
+function useReagentSeries() {
+	function generateSeries(start, count, factor, defaultReplicates = 1) {
+		return generateDilutionSeries(start, count, factor, defaultReplicates);
+	}
+	function sortLevels(levels, order = "desc") {
+		return [...levels].sort((a, b) => order === "desc" ? b.value - a.value : a.value - b.value);
+	}
+	function totalPositions(levels) {
+		return levels.reduce((sum, l) => sum + l.replicates, 0);
+	}
+	return {
+		generateSeries,
+		sortLevels,
+		totalPositions
+	};
+}
+//#endregion
+//#region src/composables/useProtocolTemplates.ts
+var BUILT_IN_TEMPLATES = [
+	{
+		id: "builtin-incubation",
+		type: "incubation",
+		name: "Incubation",
+		description: "Incubate samples at specified conditions",
+		defaultDuration: 60,
+		isBuiltIn: true,
+		parameters: [
+			{
+				key: "temperature",
+				label: "Temperature",
+				type: "temperature",
+				unit: "°C",
+				required: true,
+				default: 37,
+				min: -80,
+				max: 100
+			},
+			{
+				key: "duration",
+				label: "Duration",
+				type: "duration",
+				unit: "hours",
+				required: true,
+				default: 24,
+				min: 0
+			},
+			{
+				key: "co2",
+				label: "CO2",
+				type: "number",
+				unit: "%",
+				required: false,
+				default: 5,
+				min: 0,
+				max: 100
+			},
+			{
+				key: "humidity",
+				label: "Humidity",
+				type: "number",
+				unit: "%",
+				required: false,
+				default: 95,
+				min: 0,
+				max: 100
+			}
+		]
+	},
+	{
+		id: "builtin-wash",
+		type: "wash",
+		name: "Wash",
+		description: "Wash samples with buffer",
+		defaultDuration: 5,
+		isBuiltIn: true,
+		parameters: [
+			{
+				key: "buffer",
+				label: "Buffer",
+				type: "select",
+				required: true,
+				default: "PBS",
+				options: [
+					{
+						value: "PBS",
+						label: "PBS"
+					},
+					{
+						value: "PBST",
+						label: "PBST"
+					},
+					{
+						value: "TBS",
+						label: "TBS"
+					},
+					{
+						value: "TBST",
+						label: "TBST"
+					},
+					{
+						value: "Water",
+						label: "Water"
+					},
+					{
+						value: "Other",
+						label: "Other"
+					}
+				]
+			},
+			{
+				key: "volume",
+				label: "Volume",
+				type: "number",
+				unit: "µL",
+				required: true,
+				default: 200,
+				min: 0
+			},
+			{
+				key: "cycles",
+				label: "Wash Cycles",
+				type: "number",
+				required: true,
+				default: 3,
+				min: 1,
+				max: 10
+			}
+		]
+	},
+	{
+		id: "builtin-addition",
+		type: "addition",
+		name: "Addition",
+		description: "Add reagent or compound to samples",
+		defaultDuration: 5,
+		isBuiltIn: true,
+		parameters: [
+			{
+				key: "reagent",
+				label: "Reagent",
+				type: "text",
+				required: true,
+				placeholder: "Enter reagent name"
+			},
+			{
+				key: "volume",
+				label: "Volume",
+				type: "number",
+				unit: "µL",
+				required: true,
+				default: 100,
+				min: 0
+			},
+			{
+				key: "concentration",
+				label: "Concentration",
+				type: "concentration",
+				required: false
+			}
+		]
+	},
+	{
+		id: "builtin-measurement",
+		type: "measurement",
+		name: "Measurement",
+		description: "Take measurements using specified instrument",
+		defaultDuration: 15,
+		isBuiltIn: true,
+		parameters: [
+			{
+				key: "instrument",
+				label: "Instrument",
+				type: "select",
+				required: true,
+				options: [
+					{
+						value: "plate_reader",
+						label: "Plate Reader"
+					},
+					{
+						value: "microscope",
+						label: "Microscope"
+					},
+					{
+						value: "flow_cytometer",
+						label: "Flow Cytometer"
+					},
+					{
+						value: "spectrophotometer",
+						label: "Spectrophotometer"
+					},
+					{
+						value: "other",
+						label: "Other"
+					}
+				]
+			},
+			{
+				key: "readout",
+				label: "Readout Type",
+				type: "text",
+				required: false,
+				placeholder: "e.g., Absorbance 450nm"
+			},
+			{
+				key: "notes",
+				label: "Parameters",
+				type: "text",
+				required: false,
+				placeholder: "Additional parameters"
+			}
+		]
+	},
+	{
+		id: "builtin-centrifuge",
+		type: "centrifuge",
+		name: "Centrifuge",
+		description: "Centrifuge samples",
+		defaultDuration: 10,
+		isBuiltIn: true,
+		parameters: [
+			{
+				key: "speed",
+				label: "Speed",
+				type: "number",
+				unit: "RPM",
+				required: true,
+				default: 1e3,
+				min: 100,
+				max: 2e4
+			},
+			{
+				key: "duration",
+				label: "Duration",
+				type: "number",
+				unit: "min",
+				required: true,
+				default: 5,
+				min: 1
+			},
+			{
+				key: "temperature",
+				label: "Temperature",
+				type: "temperature",
+				unit: "°C",
+				required: false,
+				default: 4,
+				min: -10,
+				max: 40
+			}
+		]
+	},
+	{
+		id: "builtin-transfer",
+		type: "transfer",
+		name: "Transfer",
+		description: "Transfer samples between containers",
+		defaultDuration: 10,
+		isBuiltIn: true,
+		parameters: [
+			{
+				key: "source",
+				label: "Source",
+				type: "text",
+				required: true,
+				placeholder: "Source container"
+			},
+			{
+				key: "destination",
+				label: "Destination",
+				type: "text",
+				required: true,
+				placeholder: "Destination container"
+			},
+			{
+				key: "volume",
+				label: "Volume",
+				type: "number",
+				unit: "µL",
+				required: true,
+				default: 100,
+				min: 0
+			}
+		]
+	},
+	{
+		id: "builtin-mix",
+		type: "mix",
+		name: "Mix",
+		description: "Mix samples",
+		defaultDuration: 5,
+		isBuiltIn: true,
+		parameters: [
+			{
+				key: "method",
+				label: "Method",
+				type: "select",
+				required: true,
+				default: "pipette",
+				options: [
+					{
+						value: "pipette",
+						label: "Pipette mixing"
+					},
+					{
+						value: "vortex",
+						label: "Vortex"
+					},
+					{
+						value: "shaker",
+						label: "Orbital shaker"
+					},
+					{
+						value: "inversion",
+						label: "Inversion"
+					}
+				]
+			},
+			{
+				key: "duration",
+				label: "Duration",
+				type: "number",
+				unit: "sec",
+				required: false,
+				default: 30,
+				min: 1
+			},
+			{
+				key: "speed",
+				label: "Speed/Intensity",
+				type: "text",
+				required: false,
+				placeholder: "e.g., 300 RPM"
+			}
+		]
+	},
+	{
+		id: "builtin-custom",
+		type: "custom",
+		name: "Custom Step",
+		description: "Custom protocol step",
+		defaultDuration: 15,
+		isBuiltIn: true,
+		parameters: [{
+			key: "description",
+			label: "Description",
+			type: "text",
+			required: true,
+			placeholder: "Describe the step"
+		}, {
+			key: "notes",
+			label: "Notes",
+			type: "text",
+			required: false,
+			placeholder: "Additional notes"
+		}]
+	}
+];
+var STORAGE_KEY = "mint-custom-protocol-templates";
+function loadCustomTemplates() {
+	try {
+		const stored = localStorage.getItem(STORAGE_KEY);
+		if (stored) return JSON.parse(stored);
+	} catch {}
+	return [];
+}
+function saveCustomTemplatesToStorage(templates) {
+	try {
+		localStorage.setItem(STORAGE_KEY, JSON.stringify(templates));
+	} catch {}
+}
+/** Provides built-in and custom protocol step templates with validation and step creation helpers. */
+function useProtocolTemplates() {
+	const customTemplates = ref(loadCustomTemplates());
+	const allTemplates = computed(() => {
+		return [...BUILT_IN_TEMPLATES, ...customTemplates.value];
+	});
+	function getTemplateByType(type) {
+		return customTemplates.value.find((t) => t.type === type) || BUILT_IN_TEMPLATES.find((t) => t.type === type);
+	}
+	function getTemplateById(id) {
+		return customTemplates.value.find((t) => t.id === id) || BUILT_IN_TEMPLATES.find((t) => t.id === id);
+	}
+	function saveCustomTemplate(template) {
+		const newTemplate = {
+			...template,
+			isBuiltIn: false,
+			id: template.id || `custom-${Date.now()}`
+		};
+		const index = customTemplates.value.findIndex((t) => t.id === newTemplate.id);
+		if (index >= 0) customTemplates.value[index] = newTemplate;
+		else customTemplates.value.push(newTemplate);
+		saveCustomTemplatesToStorage(customTemplates.value);
+	}
+	function deleteCustomTemplate(templateId) {
+		const index = customTemplates.value.findIndex((t) => t.id === templateId);
+		if (index >= 0) {
+			customTemplates.value.splice(index, 1);
+			saveCustomTemplatesToStorage(customTemplates.value);
+		}
+	}
+	function validateStep(step, template) {
+		const errors = {};
+		if (!step.name || step.name.trim() === "") errors.name = "Step name is required";
+		for (const param of template.parameters) {
+			if (param.required) {
+				const value = step.parameters?.[param.key];
+				if (value === void 0 || value === null || value === "") errors[param.key] = `${param.label} is required`;
+			}
+			if (param.type === "number" || param.type === "temperature" || param.type === "duration") {
+				const value = step.parameters?.[param.key];
+				if (value !== void 0 && value !== null && value !== "") {
+					const numValue = Number(value);
+					if (isNaN(numValue)) errors[param.key] = `${param.label} must be a number`;
+					else {
+						if (param.min !== void 0 && numValue < param.min) errors[param.key] = `${param.label} must be at least ${param.min}`;
+						if (param.max !== void 0 && numValue > param.max) errors[param.key] = `${param.label} must be at most ${param.max}`;
+					}
+				}
+			}
+		}
+		return {
+			valid: Object.keys(errors).length === 0,
+			errors
+		};
+	}
+	function createStepFromTemplate(template, overrides) {
+		const parameters = {};
+		for (const param of template.parameters) if (param.default !== void 0) parameters[param.key] = param.default;
+		return {
+			id: `step-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+			type: template.type,
+			name: template.name,
+			description: template.description,
+			duration: template.defaultDuration,
+			status: "pending",
+			parameters,
+			order: 0,
+			...overrides
+		};
+	}
+	function formatParameterValue(value, param) {
+		if (value === void 0 || value === null || value === "") return "-";
+		if (param.type === "select" && param.options) {
+			const option = param.options.find((o) => o.value === value);
+			if (option) return option.label;
+		}
+		if (param.type === "concentration" && typeof value === "object") {
+			const conc = value;
+			return `${conc.value} ${conc.unit}`;
+		}
+		const strValue = String(value);
+		if (param.unit) return `${strValue} ${param.unit}`;
+		return strValue;
+	}
+	return {
+		builtInTemplates: BUILT_IN_TEMPLATES,
+		customTemplates,
+		allTemplates,
+		getTemplateByType,
+		getTemplateById,
+		saveCustomTemplate,
+		deleteCustomTemplate,
+		validateStep,
+		createStepFromTemplate,
+		formatParameterValue
+	};
+}
+//#endregion
+//#region src/composables/useExperimentData.ts
+/** Fetches and normalises experiment output data (tree, table, summary) from the platform API. */
+function useExperimentData(options = {}) {
+	const api = useApi({ baseUrl: options.apiBaseUrl });
+	const data = ref(null);
+	const request = useRequestSyncState("Failed to fetch experiment data");
+	const isLoading = request.loading;
+	const error = request.error;
+	const lastLoadedAt = request.lastLoadedAt;
+	let lastExperimentId = null;
+	const treeData = computed(() => {
+		if (!data.value) return [];
+		const tree = data.value.tree_data ?? data.value.treeData;
+		return Array.isArray(tree) ? tree : [];
+	});
+	const tableData = computed(() => {
+		if (!data.value) return [];
+		const table = data.value.table_data ?? data.value.tableData;
+		return Array.isArray(table) ? table : [];
+	});
+	const summaryData = computed(() => {
+		if (!data.value) return null;
+		const summary = data.value.summary_data ?? data.value.summaryData;
+		if (summary && typeof summary === "object" && "metadata" in summary) return summary;
+		return null;
+	});
+	async function fetchData(experimentId) {
+		lastExperimentId = experimentId;
+		try {
+			data.value = await request.run(() => api.get(`/experiments/${experimentId}/data`), {
+				success: "load",
+				errorMessage: "Failed to fetch experiment data"
+			});
+		} catch {
+			data.value = null;
+		}
+	}
+	async function refresh() {
+		if (lastExperimentId !== null) await fetchData(lastExperimentId);
+	}
+	return {
+		data,
+		treeData,
+		tableData,
+		summaryData,
+		isLoading,
+		error,
+		lastLoadedAt,
+		fetch: fetchData,
+		refresh
+	};
+}
+//#endregion
+//#region src/composables/useScheduleDrag.ts
+/** Handles pointer-driven create, move, and resize drag interactions for the ScheduleCalendar grid. */
+function useScheduleDrag(options) {
+	const isDragging = ref(false);
+	const dragState = ref(null);
+	const ghost = computed(() => {
+		if (!dragState.value) return null;
+		const state = dragState.value;
+		const slotH = options.slotHeight.value;
+		const slotMin = options.slotDuration.value;
+		const dayStart = options.dayStartHour.value * 60;
+		if (state.type === "create") {
+			const deltaY = state.currentY - state.startY;
+			const startOffset = state.startY;
+			const endOffset = startOffset + deltaY;
+			const topPx = Math.min(startOffset, endOffset);
+			const bottomPx = Math.max(startOffset, endOffset);
+			const startMinutes = dayStart + Math.round(topPx / slotH * slotMin);
+			const endMinutes = dayStart + Math.round(bottomPx / slotH * slotMin);
+			const snappedStart = snapMinutes(startMinutes, slotMin);
+			const snappedEnd = Math.max(snapMinutes(endMinutes, slotMin), snappedStart + slotMin);
+			const snappedTopPx = (snappedStart - dayStart) / slotMin * slotH;
+			const snappedHeightPx = (snappedEnd - snappedStart) / slotMin * slotH;
+			return {
+				start: minutesToDate(state.startDate, snappedStart),
+				end: minutesToDate(state.startDate, snappedEnd),
+				dayIndex: state.dayIndex,
+				style: {
+					top: `${snappedTopPx}px`,
+					height: `${snappedHeightPx}px`
+				}
+			};
+		}
+		if (state.type === "move" && state.event) {
+			const deltaY = state.currentY - state.startY;
+			const eventStart = dateToMinutes(new Date(state.event.start));
+			const duration = dateToMinutes(new Date(state.event.end)) - eventStart;
+			const newStart = snapMinutes(eventStart + Math.round(deltaY / slotH * slotMin), slotMin);
+			const clamped = clampRange(newStart, newStart + duration, dayStart, options.dayEndHour.value * 60);
+			const topPx = (clamped.start - dayStart) / slotMin * slotH;
+			const heightPx = (clamped.end - clamped.start) / slotMin * slotH;
+			return {
+				start: minutesToDate(state.startDate, clamped.start),
+				end: minutesToDate(state.startDate, clamped.end),
+				dayIndex: state.currentDayIndex,
+				style: {
+					top: `${topPx}px`,
+					height: `${heightPx}px`
+				}
+			};
+		}
+		if ((state.type === "resize-top" || state.type === "resize-bottom") && state.event) {
+			const eventStart = dateToMinutes(new Date(state.event.start));
+			const eventEnd = dateToMinutes(new Date(state.event.end));
+			const deltaY = state.currentY - state.startY;
+			const pixelDelta = Math.round(deltaY / slotH * slotMin);
+			let newStart = eventStart;
+			let newEnd = eventEnd;
+			if (state.type === "resize-top") {
+				newStart = snapMinutes(eventStart + pixelDelta, slotMin);
+				newStart = Math.min(newStart, newEnd - slotMin);
+			} else {
+				newEnd = snapMinutes(eventEnd + pixelDelta, slotMin);
+				newEnd = Math.max(newEnd, newStart + slotMin);
+			}
+			const clamped = clampRange(newStart, newEnd, dayStart, options.dayEndHour.value * 60);
+			const topPx = (clamped.start - dayStart) / slotMin * slotH;
+			const heightPx = (clamped.end - clamped.start) / slotMin * slotH;
+			return {
+				start: minutesToDate(state.startDate, clamped.start),
+				end: minutesToDate(state.startDate, clamped.end),
+				dayIndex: state.dayIndex,
+				style: {
+					top: `${topPx}px`,
+					height: `${heightPx}px`
+				}
+			};
+		}
+		return null;
+	});
+	function startCreate(date, y, dayIndex) {
+		if (options.readonly.value) return;
+		isDragging.value = true;
+		dragState.value = {
+			type: "create",
+			startDate: date,
+			startY: y,
+			currentY: y,
+			dayIndex,
+			currentDayIndex: dayIndex
+		};
+		addListeners();
+	}
+	function startMove(event, y, dayIndex) {
+		if (options.readonly.value || event.draggable === false) return;
+		isDragging.value = true;
+		dragState.value = {
+			type: "move",
+			event,
+			startDate: new Date(event.start),
+			startY: y,
+			currentY: y,
+			dayIndex,
+			currentDayIndex: dayIndex
+		};
+		addListeners();
+	}
+	function startResize(event, edge, y, dayIndex) {
+		if (options.readonly.value || event.resizable === false) return;
+		isDragging.value = true;
+		dragState.value = {
+			type: edge === "top" ? "resize-top" : "resize-bottom",
+			event,
+			startDate: new Date(event.start),
+			startY: y,
+			currentY: y,
+			dayIndex,
+			currentDayIndex: dayIndex
+		};
+		addListeners();
+	}
+	function onPointerMove(e) {
+		if (!dragState.value) return;
+		dragState.value = {
+			...dragState.value,
+			currentY: e.clientY
+		};
+	}
+	function onPointerUp() {
+		if (!dragState.value || !ghost.value) {
+			cleanup();
+			return;
+		}
+		const g = ghost.value;
+		const state = dragState.value;
+		if (state.type === "create" && options.onCreateComplete) options.onCreateComplete(g.start, g.end);
+		else if (state.type === "move" && state.event && options.onMoveComplete) options.onMoveComplete(state.event, g.start, g.end);
+		else if ((state.type === "resize-top" || state.type === "resize-bottom") && state.event && options.onResizeComplete) options.onResizeComplete(state.event, g.start, g.end);
+		cleanup();
+	}
+	function addListeners() {
+		document.addEventListener("pointermove", onPointerMove);
+		document.addEventListener("pointerup", onPointerUp);
+	}
+	function cleanup() {
+		isDragging.value = false;
+		dragState.value = null;
+		document.removeEventListener("pointermove", onPointerMove);
+		document.removeEventListener("pointerup", onPointerUp);
+	}
+	onUnmounted(cleanup);
+	return {
+		isDragging,
+		dragState,
+		ghost,
+		startCreate,
+		startMove,
+		startResize
+	};
+}
+function snapMinutes(minutes, step) {
+	return Math.round(minutes / step) * step;
+}
+function dateToMinutes(date) {
+	return date.getHours() * 60 + date.getMinutes();
+}
+function minutesToDate(baseDate, minutes) {
+	const d = new Date(baseDate);
+	d.setHours(Math.floor(minutes / 60), minutes % 60, 0, 0);
+	return d;
+}
+function clampRange(start, end, min, max) {
+	const s = Math.max(start, min);
+	const e = Math.min(end, max);
+	return {
+		start: s,
+		end: Math.max(e, s)
+	};
+}
+//#endregion
+export { normalizeSearchQuery as $, useAutoGroup as A, EXPERIMENT_STATUS_VARIANT_MAP as B, useSampleGroups as C, DEFAULT_COLORS as D, hslToHex as E, usePlatformContext as F, useDebouncedWatch as G, datePresetToISO as H, useExperimentSelector as I, useFormBuilder as J, useApi as K, DATE_PRESET_OPTIONS as L, useDoseCalculator as M, APP_EXPERIMENT_KEY as N, extractSamplesFromDesignData as O, useAppExperiment as P, candidateMatchesSearch as Q, EXPERIMENT_STATUS_LABELS as R, useExpansionSet as S, hexToHsl as T, formatExperimentDate as U, SORT_OPTIONS as V, useRequestSyncState as W, useTheme as X, useForm as Y, useToast as Z, useTemplateCollection as _, DEFAULT_UNITS as a, getInjectedPlatformContext as b, useGroupAssignment as c, useBioTemplatePackWorkspace as d, useTextSearch as et, useBioTemplateWorkspace as f, useBioTemplateControls as g, useBioTemplateComponents as h, DEFAULT_PRESETS as i, useWellPlateEditor as j, parseCSV as k, useRackEditor as l, toBioTemplateComponentPropsByComponent as m, useExperimentData as n, useSortedItems as nt, generateDilutionSeries as o, getBioTemplateComponentProps as p, evaluateCondition as q, useProtocolTemplates as r, useReagentSeries as s, useScheduleDrag as t, compareSortValues as tt, useBioTemplatePresetWorkspace as u, useExperimentSave as v, deriveShade as w, resolveCurrentExperimentId as x, currentExperimentFromContext as y, EXPERIMENT_STATUS_OPTIONS as z };
+
+//# sourceMappingURL=useScheduleDrag-D4oWdh41.js.map