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

package/dist/{useProtocolTemplates-n6AJqSqv.js → useProtocolTemplates-Bm5vyH4_.js}

@@ -1,4 +1,4 @@
-import { Bt as ensureTemplateFromCollection, In as useControlWorkspace, Ln as getFieldRegistryEntry, Pt as createTemplateCollection, Rn as getTypeDefault, Vn as useConcentrationUnits, Vt as extractTemplateCollection, _ as toBioTemplateComponentPropsByComponent$1, _t as createBioTemplatePresetCollectionFromControls, b as toBioTemplateComponentUsage, d as getBioTemplateComponentProps$1, g as toBioTemplateComponentProps, gt as createBioTemplatePresetCollection, h as toBioTemplateComponentImports, ht as createBioTemplatePackCollection, i as createBioTemplateControlToolkit, m as toBioTemplateComponentBindingsById, nn as getBioTemplatePresetInfo, on as getBioTemplatePackInfo, p as toBioTemplateComponentBindings, u as getBioTemplateComponentBindings, v as toBioTemplateComponentPropsById, y as toBioTemplateComponentSnippets } from "./templates-BorLR_7p.js";
+import { B as toBioTemplateComponentProps, F as getBioTemplateComponentProps$1, H as toBioTemplateComponentPropsById, Hn as useConcentrationUnits, Jt as getBioTemplatePresetInfo, L as toBioTemplateComponentBindings, P as getBioTemplateComponentBindings, Qt as getBioTemplatePackInfo, R as toBioTemplateComponentBindingsById, Rn as getFieldRegistryEntry, Sn as useControlWorkspace, U as toBioTemplateComponentSnippets, V as toBioTemplateComponentPropsByComponent$1, W as toBioTemplateComponentUsage, d as createBioTemplatePresetCollectionFromControls, dn as extractTemplateCollection, i as createBioTemplateControlToolkit, p as createBioTemplatePackCollection, sn as createTemplateCollection, u as createBioTemplatePresetCollection, un as ensureTemplateFromCollection, z as toBioTemplateComponentImports, zn as getTypeDefault } from "./templates-DtdUvJ4c.js";
 import { g as useSettingsStore, t as useAuthStore } from "./auth-B7g4J4ZF.js";
 import { computed, effectScope, getCurrentScope, inject, onMounted, onScopeDispose, onUnmounted, provide, reactive, readonly, ref, shallowRef, toRaw, toValue, watch } from "vue";
 import axios from "axios";
@@ -144,7 +144,7 @@ function useTheme() {
 	};
 }
 //#endregion
-//#region src/composables/useForm.ts
+//#region src/composables/useFormValidation.ts
 var validators = {
 	required: (value, message = "This field is required") => {
 		if (value === null || value === void 0 || value === "") return message;
@@ -182,6 +182,70 @@ var validators = {
 		return null;
 	}
 };
+function validateFieldValue(value, fieldRules, formData) {
+	if (!fieldRules) return null;
+	if (fieldRules.required) {
+		const message = typeof fieldRules.required === "string" ? fieldRules.required : void 0;
+		const error = validators.required(value, message);
+		if (error) return error;
+	}
+	if (value === null || value === void 0 || value === "") return null;
+	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) return error;
+	}
+	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) return error;
+	}
+	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) return error;
+	}
+	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) return error;
+	}
+	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) return error;
+	}
+	if (fieldRules.email) {
+		const message = typeof fieldRules.email === "string" ? fieldRules.email : void 0;
+		const error = validators.email(value, message);
+		if (error) return error;
+	}
+	if (fieldRules.custom) {
+		const customRules = Array.isArray(fieldRules.custom) ? fieldRules.custom : [fieldRules.custom];
+		for (const rule of customRules) {
+			const error = rule(value, formData);
+			if (error) return error;
+		}
+	}
+	return null;
+}
+//#endregion
+//#region src/composables/useForm.ts
 /**
 * Form state management composable with validation.
 *
@@ -228,97 +292,9 @@ function useForm(initialValues, rules = {}) {
 	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;
+		const error = validateFieldValue(value, fieldRules, data);
+		errors[field] = error;
+		return error === null;
 	}
 	function validate() {
 		let isAllValid = true;
@@ -422,7 +398,7 @@ function isPlainRecord(value) {
 	return Object.prototype.toString.call(value) === "[object Object]";
 }
 //#endregion
-//#region src/composables/useFormBuilder.ts
+//#region src/composables/formBuilderSchema.ts
 /**
 * Evaluate a JSON-serializable field condition against the current form data.
 *
@@ -510,6 +486,8 @@ function replaceRecord(target, source) {
 function hasOwnKey(source, key) {
 	return Object.prototype.hasOwnProperty.call(source, key);
 }
+//#endregion
+//#region src/composables/useFormBuilder.ts
 /**
 * Drive a `FormSchema` as reactive form state.
 *
@@ -2098,6 +2076,788 @@ function useWellPlateEditor(initialState, options = {}) {
 	};
 }
 //#endregion
+//#region src/composables/autoGroup/tokenize.ts
+var DELIMITER_CANDIDATES = [
+	"_",
+	"-",
+	"."
+];
+/** Pick the delimiter whose split produces the most consistent field count across `lines`. */
+function pickPrimaryDelimiter(lines) {
+	if (lines.length === 0) return "_";
+	let best = "_";
+	let bestScore = -1;
+	for (const candidate of DELIMITER_CANDIDATES) {
+		const counts = lines.map((l) => l.split(candidate).length);
+		const frequency = /* @__PURE__ */ new Map();
+		for (const c of counts) frequency.set(c, (frequency.get(c) ?? 0) + 1);
+		let mode = 1;
+		let modeFreq = 0;
+		for (const [c, f] of frequency) if (f > modeFreq || f === modeFreq && c > mode) {
+			mode = c;
+			modeFreq = f;
+		}
+		const score = mode > 1 ? modeFreq / lines.length : 0;
+		if (score > bestScore) {
+			best = candidate;
+			bestScore = score;
+		}
+	}
+	return best;
+}
+/** Split a single sample name on `delimiter`. Empty input returns `['']` so callers
+*  always receive at least one token. */
+function splitMulti(name, delimiter) {
+	return name.split(delimiter);
+}
+//#endregion
+//#region src/composables/autoGroup/classKey.ts
+function classKey(c) {
+	return c.subKind ? `${c.kind}:${c.subKind}` : c.kind;
+}
+var vocab_default = {
+	$schema: "./vocab.schema.json",
+	_doc: {
+		"purpose": "Sample-name classification vocabulary for the auto-group pipeline. Edit this file to teach the classifier new sample types or matrices without changing TypeScript. All matching is case-insensitive unless a pattern's regex flags say otherwise.",
+		"patterns": "Regex source strings (no surrounding slashes). Compiled with the `i` flag at load time.",
+		"standardAllow": "Tokens that should be classified as Standard even when they don't match `patterns.standard`. Case-sensitive — use the exact spelling that appears in your filenames.",
+		"matrixVocab": "Lowercase token → canonical display name. Tokens are normalised to lowercase before lookup, so adding 'tissues' handles 'Tissues' / 'TISSUES' / 'tissues' uniformly. Multiple aliases map to one canonical (e.g. cell + cells → Cells).",
+		"ionizationModes": "Lowercase polarity tokens (pos / positive / neg / negative). Suffixed to the subKind so POS and NEG acquisitions get independent schemas.",
+		"tissueParentTokens": "Tokens that flag the immediately-following token as the organ subKind (so `tissues / kidney` becomes Biological/Tissues, tagging both positions).",
+		"replicateStripPatterns": "Regex sources stripped from each sample name during the replicate pre-grouping pass. Samples whose stripped (base) names match are treated as replicates of one another and grouped together before tokenisation. Default set covers: trailing run-order numbers, _T<n>, _B<n>, and _Rep<n> markers."
+	},
+	patterns: {
+		"blank": "^(blank|blk|solv?blank|matrix.?blank)$",
+		"iqc": "^iqc$",
+		"eqc": "^eqc$",
+		"standard": "^(standard|std\\d*|cal(?:ibrator)?\\d*|.+standard)$",
+		"spikeIn": "spike.?in",
+		"stock": "^stock$"
+	},
+	standardAllow: [
+		"ExtractionS",
+		"IS",
+		"internal.standard",
+		"PQC",
+		"pooledQC"
+	],
+	matrixVocab: {
+		"plasma": "Plasma",
+		"serum": "Serum",
+		"tissue": "Tissue",
+		"tissues": "Tissues",
+		"kidney": "Kidney",
+		"liver": "Liver",
+		"tumor": "Tumor",
+		"urine": "Urine",
+		"brain": "Brain",
+		"muscle": "Muscle",
+		"adipose": "Adipose",
+		"csf": "CSF",
+		"feces": "Feces",
+		"faeces": "Faeces",
+		"cells": "Cells",
+		"cell": "Cells",
+		"media": "Media",
+		"medium": "Medium",
+		"extract": "Extract"
+	},
+	ionizationModes: {
+		"pos": "POS",
+		"positive": "POS",
+		"neg": "NEG",
+		"negative": "NEG"
+	},
+	tissueParentTokens: ["tissue", "tissues"],
+	replicateStripPatterns: [
+		"[_-]\\d{2,4}[A-Za-z]?$",
+		"[_-]T\\d+(?=[_-]|$)",
+		"[_-]B\\d+(?=[_-]|$)",
+		"[_-](?:rep(?:licate)?)\\d+(?=[_-]|$)"
+	]
+};
+//#endregion
+//#region src/composables/autoGroup/classify.ts
+function compileVocab(data) {
+	return {
+		blankPattern: new RegExp(data.patterns.blank, "i"),
+		iqcPattern: new RegExp(data.patterns.iqc, "i"),
+		eqcPattern: new RegExp(data.patterns.eqc, "i"),
+		standardPattern: new RegExp(data.patterns.standard, "i"),
+		spikeInPattern: new RegExp(data.patterns.spikeIn, "i"),
+		stockPattern: new RegExp(data.patterns.stock, "i"),
+		standardAllow: new Set(data.standardAllow),
+		matrixVocab: new Map(Object.entries(data.matrixVocab)),
+		ionizationModes: new Map(Object.entries(data.ionizationModes).map(([k, v]) => [k, v])),
+		tissueParentTokens: new Set(data.tissueParentTokens)
+	};
+}
+var classVocab = compileVocab(vocab_default);
+function matrixCanonical(token, vocab) {
+	return vocab.matrixVocab.get(token.toLowerCase());
+}
+function isTissueParentToken(token, vocab) {
+	return vocab.tissueParentTokens.has(token.toLowerCase());
+}
+var DEFAULT_DISPOSITION = {
+	biological: "group",
+	iqc: "overlay",
+	eqc: "overlay",
+	standard: "overlay",
+	"spike-in": "overlay",
+	stock: "overlay",
+	blank: "overlay",
+	unknown: "group"
+};
+function classifyTokens(tokens, vocab) {
+	for (let i = 0; i < tokens.length; i++) if (vocab.blankPattern.test(tokens[i])) return {
+		kind: "blank",
+		tagPositions: [i]
+	};
+	for (let i = 0; i < tokens.length; i++) if (vocab.iqcPattern.test(tokens[i])) return {
+		kind: "iqc",
+		tagPositions: [i]
+	};
+	for (let i = 0; i < tokens.length; i++) if (vocab.eqcPattern.test(tokens[i])) return {
+		kind: "eqc",
+		tagPositions: [i]
+	};
+	for (let i = 0; i < tokens.length; i++) if (vocab.standardPattern.test(tokens[i]) || vocab.standardAllow.has(tokens[i])) return {
+		kind: "standard",
+		tagPositions: [i]
+	};
+	for (let i = 0; i < tokens.length; i++) if (vocab.spikeInPattern.test(tokens[i])) return {
+		kind: "spike-in",
+		tagPositions: [i]
+	};
+	for (let i = 0; i < tokens.length; i++) if (vocab.stockPattern.test(tokens[i])) return {
+		kind: "stock",
+		tagPositions: [i]
+	};
+	for (let i = 0; i < tokens.length; i++) {
+		const canonical = matrixCanonical(tokens[i], vocab);
+		if (canonical) {
+			const isTissueParent = isTissueParentToken(tokens[i], vocab);
+			const tagPositions = [i];
+			if (isTissueParent) {
+				if (i + 1 < tokens.length) tagPositions.push(i + 1);
+				return {
+					kind: "biological",
+					subKind: "Tissues",
+					tagPositions
+				};
+			}
+			if (i > 0 && isTissueParentToken(tokens[i - 1], vocab)) {
+				tagPositions.unshift(i - 1);
+				return {
+					kind: "biological",
+					subKind: "Tissues",
+					tagPositions
+				};
+			}
+			return {
+				kind: "biological",
+				subKind: canonical,
+				tagPositions
+			};
+		}
+	}
+	return {
+		kind: "unknown",
+		tagPositions: []
+	};
+}
+/**
+* LC-MS batches run positive- and negative-ion-mode acquisitions separately,
+* and the two produce different feature tables that should never be grouped
+* together. When a POS / NEG / positive / negative token is present we suffix
+* it to the class label so the schema builder treats each mode as its own class.
+*/
+function ionizationModeFor(tokens, vocab) {
+	for (let i = 0; i < tokens.length; i++) {
+		const mode = vocab.ionizationModes.get(tokens[i].toLowerCase());
+		if (mode) return {
+			mode,
+			position: i
+		};
+	}
+}
+function labelFor(kind, subKind) {
+	const base = {
+		biological: "Biological",
+		iqc: "IQC",
+		eqc: "EQC",
+		standard: "Standard",
+		"spike-in": "SpikeIn",
+		stock: "Stock",
+		blank: "Blank",
+		unknown: "Unknown"
+	};
+	return subKind ? `${base[kind]} / ${subKind}` : base[kind];
+}
+/** Classify each tokenized sample into a SampleClass. */
+function detectClass(tokenizedSamples, options) {
+	const vocab = {
+		...classVocab,
+		...options.vocab ?? {}
+	};
+	const hints = options.sampleTypeHints ?? [];
+	const buckets = /* @__PURE__ */ new Map();
+	for (let i = 0; i < tokenizedSamples.length; i++) {
+		const hint = hints[i]?.toLowerCase();
+		let kind;
+		let subKind;
+		let tagPositions;
+		if (hint === "qc") {
+			kind = "iqc";
+			tagPositions = [];
+		} else if (hint === "blank") {
+			kind = "blank";
+			tagPositions = [];
+		} else {
+			const r = classifyTokens(tokenizedSamples[i], vocab);
+			kind = r.kind;
+			subKind = r.subKind;
+			tagPositions = r.tagPositions;
+		}
+		const mode = ionizationModeFor(tokenizedSamples[i], vocab);
+		if (mode) {
+			subKind = subKind ? `${subKind} / ${mode.mode}` : mode.mode;
+			if (!tagPositions.includes(mode.position)) tagPositions.push(mode.position);
+		}
+		const key = classKey({
+			kind,
+			subKind
+		});
+		const bucket = buckets.get(key);
+		if (bucket) {
+			bucket.members.push(i);
+			for (const p of tagPositions) if (!bucket.classTagPositions.includes(p)) bucket.classTagPositions.push(p);
+		} else buckets.set(key, {
+			kind,
+			subKind,
+			label: labelFor(kind, subKind),
+			members: [i],
+			classTagPositions: [...tagPositions],
+			disposition: DEFAULT_DISPOSITION[kind]
+		});
+	}
+	return [...buckets.values()];
+}
+//#endregion
+//#region src/composables/autoGroup/columns.ts
+var NUMERIC_VALUE_UNIT = /^(\d+(?:dot\d+)?)([A-Za-z%/μ]+)$/;
+var RATIO = /^(\d+)to(\d+)$/;
+var RUN_ORDER_PATTERN = /^\d{2,4}[A-Z]?$/;
+var REPLICATE_TOKEN_PATTERN = /^(?:rep(?:licate)?|r)\d+$/i;
+var DEFAULT_FACTOR_CARDINALITY_MAX = 50;
+var LOW_CARDINALITY_NUMERIC_AS_FACTOR_MAX = 5;
+function parseNumeric(token) {
+	const ratio = RATIO.exec(token);
+	if (ratio) {
+		const num = Number(ratio[1]);
+		const den = Number(ratio[2]);
+		if (den === 0) return null;
+		return {
+			value: num / den,
+			unit: "ratio",
+			raw: token
+		};
+	}
+	const m = NUMERIC_VALUE_UNIT.exec(token);
+	if (!m) return null;
+	const valueStr = m[1].replace(/dot/g, ".");
+	const value = Number(valueStr);
+	if (Number.isNaN(value)) return null;
+	return {
+		value,
+		unit: m[2],
+		raw: token
+	};
+}
+function inferRole(input) {
+	const { values, position, totalPositions, classSize } = input;
+	const cardinality = new Set(values).size;
+	if (cardinality === 1) return "constant";
+	if (position === totalPositions - 1) {
+		if (values.every((v) => RUN_ORDER_PATTERN.test(v)) && cardinality >= classSize * .5) return "run-order";
+	}
+	if (values.every((v) => parseNumeric(v) !== null)) {
+		if (cardinality <= LOW_CARDINALITY_NUMERIC_AS_FACTOR_MAX) return "factor";
+		return "numeric";
+	}
+	if (values.every((v) => REPLICATE_TOKEN_PATTERN.test(v))) return "replicate";
+	if (cardinality <= DEFAULT_FACTOR_CARDINALITY_MAX) return "factor";
+	return "ignore";
+}
+/**
+* Auto-detect a friendlier column name from the column's values + role.
+* Returns null when nothing matches, so callers can fall back to "Token N".
+*
+* Heuristics are content-derived and deterministic. They cover the common
+* LC-MS / proteomics naming conventions; users can override anything via
+* the column popover (rename input).
+*/
+function inferColumnName(values, uniqueValues, role) {
+	if (uniqueValues.length === 0) return null;
+	if ((role === "numeric" || role === "factor") && values.every((v) => parseNumeric(v) !== null)) {
+		const categoryFor = (u) => {
+			const ul = u.toLowerCase();
+			if ([
+				"min",
+				"sec",
+				"s",
+				"hr",
+				"h",
+				"d",
+				"day",
+				"days",
+				"wk",
+				"week",
+				"hour",
+				"hours"
+			].includes(ul)) return "Timepoint";
+			if ([
+				"nm",
+				"um",
+				"mm",
+				"m",
+				"molar",
+				"mol"
+			].includes(ul)) return "Concentration";
+			if ([
+				"mg",
+				"g",
+				"kg",
+				"ng",
+				"ug",
+				"pg"
+			].includes(ul)) return "Mass";
+			if ([
+				"ml",
+				"l",
+				"ul",
+				"nl",
+				"pl"
+			].includes(ul)) return "Volume";
+			if (ul === "%") return "Percentage";
+			if ([
+				"c",
+				"k",
+				"celsius",
+				"kelvin"
+			].includes(ul)) return "Temperature";
+			return null;
+		};
+		const tally = /* @__PURE__ */ new Map();
+		for (const v of values) {
+			const p = parseNumeric(v);
+			const cat = p ? categoryFor(p.unit) : null;
+			if (cat) tally.set(cat, (tally.get(cat) ?? 0) + 1);
+		}
+		let best = null;
+		for (const [cat, count] of tally) if (!best || count > best.count) best = {
+			cat,
+			count
+		};
+		if (best && best.count >= values.length / 2) return best.cat;
+	}
+	if (values.every((v) => /^\d{6}$/.test(v) || /^\d{8}$/.test(v))) return "Date";
+	if (role === "run-order") return "Run Order";
+	if (values.every((v) => /^(pos|neg|positive|negative)$/i.test(v))) return "Polarity";
+	if (values.every((v) => /^(plasma|serum|tissue|tissues|kidney|liver|tumor|urine|brain|muscle|adipose|csf|feces|faeces|cells?|media|medium|extract)$/i.test(v))) return "Matrix";
+	if (values.every((v) => /^(exp|expt|study)\d+$/i.test(v))) return "Experiment";
+	if (uniqueValues.length <= 4 && values.every((v) => /^[A-Z]{2,3}$/.test(v))) return "Username";
+	return null;
+}
+function buildClassSchema(tokenizedMembers, classKind, subKind, classTagPositions) {
+	const totalPositions = tokenizedMembers[0]?.length ?? 0;
+	const classSize = tokenizedMembers.length;
+	const columns = [];
+	const tagSet = new Set(classTagPositions);
+	for (let pos = 0; pos < totalPositions; pos++) {
+		const values = tokenizedMembers.map((t) => t[pos] ?? "");
+		const uniqueValues = [...new Set(values)];
+		let role;
+		if (tagSet.has(pos) && uniqueValues.length === 1) role = "class-tag";
+		else role = inferRole({
+			values,
+			position: pos,
+			totalPositions,
+			classSize
+		});
+		const numeric = role === "numeric" ? { byValue: Object.fromEntries(uniqueValues.map((v) => [v, parseNumeric(v)]).filter((e) => e[1] !== null)) } : void 0;
+		const inferredName = inferColumnName(values, uniqueValues, role);
+		columns.push({
+			index: pos,
+			name: inferredName ?? `Token ${pos + 1}`,
+			sourceIndices: [pos],
+			uniqueValues,
+			cardinality: uniqueValues.length,
+			role,
+			numeric,
+			type: pos === 0 ? "prefix" : "suffix"
+		});
+	}
+	let usernameAssigned = false;
+	for (const c of columns) if (c.name === "Username") if (usernameAssigned) c.name = "Project";
+	else usernameAssigned = true;
+	return {
+		classKind,
+		subKind,
+		columns,
+		groupBy: columns.filter((c) => c.role === "factor").map((c) => c.index)
+	};
+}
+//#endregion
+//#region src/composables/autoGroup/cooccurrence.ts
+var THRESHOLD = .95;
+var MIN_CLASS_SIZE = 4;
+function functionalDependency(rows, srcIdx, dstIdx) {
+	const map = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const a = row[srcIdx] ?? "";
+		const b = row[dstIdx] ?? "";
+		const set = map.get(a);
+		if (set) set.add(b);
+		else map.set(a, new Set([b]));
+	}
+	if (map.size === 0) return 0;
+	let functional = 0;
+	for (const set of map.values()) if (set.size === 1) functional++;
+	return functional / map.size;
+}
+function findMerges(schema, rows) {
+	if (rows.length < MIN_CLASS_SIZE) return [];
+	const out = [];
+	for (let i = 0; i < schema.columns.length - 1; i++) {
+		const a = schema.columns[i];
+		const b = schema.columns[i + 1];
+		if (a.role !== "factor" && b.role !== "factor") continue;
+		const forward = functionalDependency(rows, a.index, b.index);
+		const backward = functionalDependency(rows, b.index, a.index);
+		if (forward < THRESHOLD || backward < THRESHOLD) continue;
+		if (new Set(rows.map((r) => `${r[a.index] ?? ""}_${r[b.index] ?? ""}`)).size < 2) continue;
+		out.push({
+			classKind: schema.classKind,
+			subKind: schema.subKind,
+			columnIndices: [a.index, b.index],
+			proposedName: `Column ${a.index + 1}–${b.index + 1}`,
+			confidence: Math.min(forward, backward)
+		});
+	}
+	return out;
+}
+//#endregion
+//#region src/composables/autoGroup/colors.ts
+var DEFAULT_COLORS = [
+	"#3B82F6",
+	"#10B981",
+	"#F59E0B",
+	"#EF4444",
+	"#8B5CF6",
+	"#EC4899",
+	"#06B6D4",
+	"#84CC16",
+	"#F97316",
+	"#6366F1"
+];
+var QC_OVERLAY_COLOR = "#6B7280";
+//#endregion
+//#region src/composables/autoGroup/compose.ts
+/** Apply the operation pipeline to a single raw token value:
+*   numeric-parse → alias → exclude → bin
+*  Returns null if the row is excluded.
+*/
+function applyOps(col, raw) {
+	let value = raw;
+	if (col.ops?.alias && raw in col.ops.alias) value = col.ops.alias[raw];
+	if (col.ops?.exclude?.includes(raw) || col.ops?.exclude?.includes(value)) return null;
+	if (col.role === "numeric" && col.binning?.mode === "binned") {
+		const parsed = col.numeric?.byValue[raw];
+		if (parsed && col.binning.edges) {
+			const bin = pickBin(parsed.value, col.binning);
+			if (bin !== null) value = bin;
+		}
+	}
+	return value;
+}
+function pickBin(value, b) {
+	if (!b.edges || b.edges.length === 0) return null;
+	for (let i = 0; i < b.edges.length; i++) if (value < b.edges[i]) return b.labels?.[i] ?? `< ${b.edges[i]}`;
+	const last = b.edges[b.edges.length - 1];
+	return b.labels?.[b.edges.length] ?? `> ${last}`;
+}
+function composeGroups(input) {
+	const experimentalGroups = [];
+	const qcGroups = [];
+	const excludedSamples = [];
+	const metadata = [];
+	let colorIdx = 0;
+	for (const cls of input.classes) {
+		const schema = input.schemas[classKey(cls)];
+		if (!schema) continue;
+		if (cls.disposition === "exclude") {
+			for (const m of cls.members) excludedSamples.push(input.sampleNames[m]);
+			continue;
+		}
+		const groupMap = /* @__PURE__ */ new Map();
+		const colByIdx = new Map(schema.columns.map((c) => [c.index, c]));
+		for (const m of cls.members) {
+			const tokens = input.tokenizedSamples[m];
+			const rowName = input.sampleNames[m];
+			let excluded = false;
+			const fieldValues = {};
+			for (const col of schema.columns) {
+				const display = applyOps(col, col.sourceIndices.map((idx) => tokens[idx] ?? "").join("_"));
+				if (display === null) {
+					excluded = true;
+					break;
+				}
+				fieldValues[col.displayName ?? col.name] = display;
+			}
+			if (excluded) {
+				excludedSamples.push(rowName);
+				continue;
+			}
+			const keyParts = cls.disposition === "group" ? schema.groupBy.map((idx) => {
+				const col = colByIdx.get(idx);
+				return fieldValues[col.displayName ?? col.name];
+			}) : [cls.label];
+			const groupKey = cls.disposition === "group" && cls.kind !== "unknown" && keyParts.length > 0 ? `${cls.label} / ${keyParts.join(" / ")}` : keyParts.length > 0 ? keyParts.join(" / ") : cls.label;
+			const bucket = groupMap.get(groupKey);
+			if (bucket) bucket.samples.push(rowName);
+			else groupMap.set(groupKey, {
+				name: groupKey,
+				samples: [rowName]
+			});
+			metadata.push({
+				sampleName: rowName,
+				fields: fieldValues,
+				group: groupKey
+			});
+		}
+		for (const { name, samples } of groupMap.values()) {
+			const g = {
+				name,
+				color: cls.disposition === "overlay" ? QC_OVERLAY_COLOR : DEFAULT_COLORS[colorIdx++ % DEFAULT_COLORS.length],
+				samples
+			};
+			if (cls.disposition === "overlay") qcGroups.push(g);
+			else experimentalGroups.push(g);
+		}
+	}
+	return {
+		groups: [...experimentalGroups, ...qcGroups],
+		experimentalGroups,
+		qcGroups,
+		metadata,
+		excludedSamples,
+		schemas: Object.values(input.schemas)
+	};
+}
+//#endregion
+//#region src/composables/autoGroup/fingerprint.ts
+function serializeFingerprint(schemas) {
+	return {
+		version: 1,
+		classes: schemas.map((s) => ({
+			kind: s.classKind,
+			subKind: s.subKind,
+			columns: s.columns.map((c) => ({
+				name: c.displayName ?? c.name,
+				role: c.role ?? "factor",
+				sourceIndices: c.sourceIndices,
+				binning: c.binning,
+				ops: c.ops
+			})),
+			groupBy: s.groupBy
+		}))
+	};
+}
+function restoreFingerprint(fp, current) {
+	return fp.classes.map((snap) => {
+		const target = current.find((c) => c.classKind === snap.kind && c.subKind === snap.subKind);
+		if (!target) throw new Error(`Fingerprint class not present in current input: ${snap.kind}${snap.subKind ? "/" + snap.subKind : ""}`);
+		if (target.columns.length !== snap.columns.length) throw new Error(`Saved schema expects ${snap.columns.length} columns, current data has ${target.columns.length} for class ${snap.kind}${snap.subKind ? "/" + snap.subKind : ""}. column count mismatch`);
+		return {
+			...target,
+			groupBy: snap.groupBy,
+			columns: target.columns.map((col, i) => ({
+				...col,
+				displayName: snap.columns[i].name,
+				role: snap.columns[i].role,
+				binning: snap.columns[i].binning,
+				ops: snap.columns[i].ops
+			}))
+		};
+	});
+}
+//#endregion
+//#region src/composables/autoGroup/template.ts
+var DEFAULT_BLANK_HEADERS = [
+	"group",
+	"class",
+	"replicate",
+	"notes"
+];
+function rfc4180Quote(cell) {
+	if (/[",\n]/.test(cell)) return `"${cell.replace(/"/g, "\"\"")}"`;
+	return cell;
+}
+function joinRow(cells, sep) {
+	return sep === "," ? cells.map(rfc4180Quote).join(",") : cells.join("	");
+}
+function today() {
+	return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function composeTemplate(samples, schemas, classes, options) {
+	const sep = options.format === "tsv" ? "	" : ",";
+	const ext = options.format === "tsv" ? "tsv" : "csv";
+	const filename = `${options.experimentCode ? `${options.experimentCode}_metadata` : "sample_metadata"}_${today()}.${ext}`;
+	if (options.mode === "blank" || !schemas || !classes) {
+		const headers = ["sample_name", ...options.suggestedColumns ?? DEFAULT_BLANK_HEADERS];
+		const rows = samples.map((s) => {
+			return joinRow([s, ...Array(headers.length - 1).fill("")], sep);
+		});
+		return {
+			content: [joinRow(headers, sep), ...rows].join("\n"),
+			filename
+		};
+	}
+	const tokenized = options.tokenizedSamples ?? [];
+	const allColumns = [];
+	const sampleToClass = /* @__PURE__ */ new Map();
+	for (const cls of classes) for (const m of cls.members) sampleToClass.set(m, cls);
+	const schemaByKey = /* @__PURE__ */ new Map();
+	for (const s of schemas) {
+		const k = s.subKind ? `${s.classKind}:${s.subKind}` : s.classKind;
+		schemaByKey.set(k, s);
+	}
+	const colByNameByKey = /* @__PURE__ */ new Map();
+	const groupBySetByKey = /* @__PURE__ */ new Map();
+	for (const s of schemas) {
+		const k = s.subKind ? `${s.classKind}:${s.subKind}` : s.classKind;
+		const m = /* @__PURE__ */ new Map();
+		for (const c of s.columns) m.set(c.displayName ?? c.name, c);
+		colByNameByKey.set(k, m);
+		groupBySetByKey.set(k, new Set(s.groupBy));
+		const seenColNames = /* @__PURE__ */ new Set();
+		for (const c of s.columns) {
+			const name = c.displayName ?? c.name;
+			if (!seenColNames.has(name)) {
+				seenColNames.add(name);
+				if (!allColumns.some((x) => x.colName === name)) allColumns.push({
+					schemaKey: k,
+					colName: name
+				});
+			}
+		}
+	}
+	const headers = [
+		"sample_name",
+		"class",
+		...allColumns.map((c) => c.colName),
+		"group",
+		"notes"
+	];
+	const rows = [];
+	for (let i = 0; i < samples.length; i++) {
+		const cls = sampleToClass.get(i);
+		const classLabel = cls?.label ?? "";
+		const tokens = tokenized[i] ?? [];
+		const cells = [samples[i], classLabel];
+		if (cls) {
+			const k = classKey(cls);
+			const groupBySet = groupBySetByKey.get(k);
+			const colByName = colByNameByKey.get(k);
+			const keyParts = [];
+			for (const col of allColumns) if (col.schemaKey === k && colByName) {
+				const schemaCol = colByName.get(col.colName);
+				const raw = schemaCol?.sourceIndices.map((idx) => tokens[idx] ?? "").join("_") ?? "";
+				cells.push(raw);
+				if (schemaCol && groupBySet?.has(schemaCol.index)) keyParts.push(raw);
+			} else cells.push("");
+			cells.push(keyParts.join(" / "));
+		} else {
+			for (const _ of allColumns) cells.push("");
+			cells.push("");
+		}
+		cells.push("");
+		rows.push(joinRow(cells, sep));
+	}
+	return {
+		content: [joinRow(headers, sep), ...rows].join("\n"),
+		filename
+	};
+}
+//#endregion
+//#region src/composables/autoGroup/replicatePreGroup.ts
+/**
+* Replicate pre-grouping.
+*
+* Strip the replicate / injection-number markers from each sample's name, then
+* collapse samples that share a base name. Those samples ARE replicates of one
+* another by definition; the remaining unique base names are what the rest of
+* the pipeline (tokenize → classify → schema → compose) should operate on.
+*
+* This pre-pass replaces the older "treat every sample as independent, then
+* infer replicate columns" approach. Identifying replicate-equivalence by name
+* before tokenisation removes a class of fragile cardinality heuristics.
+*/
+var STRIP_PATTERNS = vocab_default.replicateStripPatterns.map((src) => new RegExp(src, "gi"));
+/**
+* Iteratively strip every replicate / injection-number marker from `name`.
+* Each pattern is applied repeatedly until it stops matching, so a sample like
+* `study_T1_Rep2_004` collapses to `study` in one call.
+*/
+function stripReplicateTokens(name) {
+	let base = name;
+	for (const re of STRIP_PATTERNS) {
+		let prev;
+		do {
+			prev = base;
+			base = base.replace(re, "");
+			re.lastIndex = 0;
+		} while (base !== prev);
+	}
+	return base;
+}
+function preGroupReplicates(samples) {
+	const map = /* @__PURE__ */ new Map();
+	const baseOrder = [];
+	for (let i = 0; i < samples.length; i++) {
+		const base = stripReplicateTokens(samples[i]);
+		const bucket = map.get(base);
+		if (bucket) bucket.push(i);
+		else {
+			map.set(base, [i]);
+			baseOrder.push(base);
+		}
+	}
+	return {
+		baseNames: baseOrder,
+		membersByBase: baseOrder.map((b) => map.get(b)),
+		originalSamples: samples
+	};
+}
+/**
+* Expand groups produced over base names back to groups of original sample
+* names. Each entry in `group.samples` is treated as a base name and replaced
+* by the list of original samples that collapsed onto it.
+*/
+function expandGroupsWithReplicates(groups, preGrouping) {
+	const baseToMembers = /* @__PURE__ */ new Map();
+	for (let i = 0; i < preGrouping.baseNames.length; i++) baseToMembers.set(preGrouping.baseNames[i], preGrouping.membersByBase[i]);
+	return groups.map((g) => ({
+		...g,
+		samples: g.samples.flatMap((baseName) => {
+			const indices = baseToMembers.get(baseName);
+			return indices ? indices.map((i) => preGrouping.originalSamples[i]) : [baseName];
+		})
+	}));
+}
+//#endregion
 //#region src/composables/experimentDesignData.ts
 function isRecord(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -2200,119 +2960,17 @@ function extractSampleNamesFromDesignData(rawData, options = {}) {
 	return extractSampleOptionsFromDesignData(rawData, options).map((sample) => sample.value);
 }
 //#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;
-}
+//#region src/composables/autoGroup/csv-shim.ts
 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;
+		if (char === "\"") if (inQuotes && line[i + 1] === "\"") {
+			current += "\"";
+			i++;
+		} else inQuotes = !inQuotes;
 		else if (char === delimiter && !inQuotes) {
 			result.push(current.trim());
 			current = "";
@@ -2332,8 +2990,8 @@ function parseCSV(text) {
 		const values = parseCSVLine(lines[i], csvDelimiter);
 		if (values.length !== headers.length) continue;
 		const row = {};
-		headers.forEach((header, idx) => {
-			row[header] = values[idx];
+		headers.forEach((h, idx) => {
+			row[h] = values[idx];
 		});
 		rows.push(row);
 	}
@@ -2354,301 +3012,407 @@ function parseCSV(text) {
 		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(" / ");
-		const group = groupMap.get(groupKey);
-		if (group) group.push(sample);
-		else groupMap.set(groupKey, [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
-		});
+//#endregion
+//#region src/composables/useAutoGroup.ts
+var deprecationWarned = false;
+var outlierDeprecationWarned = false;
+function warnDeprecated(api) {
+	if (deprecationWarned) return;
+	if (typeof process !== "undefined" && process.env.NODE_ENV === "production") return;
+	console.warn(`[useAutoGroup] ${api} is deprecated; use the new class-first API (setClassDisposition / toggleGroupBy / setValueOps).`);
+	deprecationWarned = true;
+}
+function useAutoGroup() {
+	const inputMode = ref("paste");
+	const rawText = ref("");
+	const csvData = ref(null);
+	const sampleTypeHints = ref([]);
+	const classes = ref([]);
+	const schemas = ref({});
+	const activeClassKey = ref("");
+	const samples = computed(() => {
+		if (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 tokenized = ref([]);
+	const delimiter = ref("_");
+	const preGrouping = ref(null);
+	function parseInput() {
+		if ((inputMode.value === "csv" || inputMode.value === "experiment") && csvData.value) {
+			parseInputFromCsv();
+			return;
+		}
+		parseInputFromPaste();
 	}
-	const groups = [];
-	let colorIdx = 0;
-	for (const [name, samples] of groupMap) {
-		groups.push({
-			name,
-			color: DEFAULT_COLORS[colorIdx % DEFAULT_COLORS.length],
-			samples
-		});
-		colorIdx++;
+	function parseInputFromCsv() {
+		preGrouping.value = null;
+		const csv = csvData.value;
+		const nonSampleCols = csv.columns.filter((c) => c !== csv.sampleColumn && c !== "sample_type");
+		if (nonSampleCols.length === 0) {
+			tokenized.value = csv.rows.map(() => []);
+			classes.value = [{
+				kind: "unknown",
+				label: "Unknown",
+				members: csv.rows.map((_, i) => i),
+				classTagPositions: [],
+				disposition: "group"
+			}];
+			schemas.value = { unknown: {
+				classKind: "unknown",
+				columns: [],
+				groupBy: []
+			} };
+			activeClassKey.value = "unknown";
+			return;
+		}
+		const tokens = csv.rows.map((r) => nonSampleCols.map((col) => r[col] ?? ""));
+		tokenized.value = tokens;
+		const detected = detectClass(tokens, { sampleTypeHints: csv.rows.map((r) => {
+			const t = String(r["sample_type"] ?? "").toLowerCase();
+			if (t === "qc") return "qc";
+			if (t === "blank") return "blank";
+		}) });
+		classes.value = detected;
+		const newSchemas = {};
+		for (const cls of detected) {
+			const schema = buildClassSchema(cls.members.map((i) => tokens[i]), cls.kind, cls.subKind, cls.classTagPositions);
+			schema.columns = schema.columns.map((c, i) => ({
+				...c,
+				name: nonSampleCols[i] ?? c.name,
+				originalName: nonSampleCols[i]
+			}));
+			newSchemas[classKey(cls)] = schema;
+		}
+		schemas.value = newSchemas;
+		if (detected.length > 0) activeClassKey.value = classKey(detected[0]);
 	}
-	if (qcSamples.length > 0) {
-		groups.push({
-			name: "QC",
-			color: "#6B7280",
-			samples: qcSamples
+	function parseInputFromPaste() {
+		const lines = samples.value;
+		if (lines.length === 0) {
+			classes.value = [];
+			schemas.value = {};
+			preGrouping.value = null;
+			return;
+		}
+		const pre = preGroupReplicates(lines);
+		preGrouping.value = pre;
+		const d = pickPrimaryDelimiter(pre.baseNames);
+		delimiter.value = d;
+		tokenized.value = pre.baseNames.map((l) => splitMulti(l, d));
+		const hints = pre.membersByBase.map((members) => sampleTypeHints.value[members[0]]);
+		const detected = detectClass(tokenized.value, { sampleTypeHints: hints });
+		classes.value = detected;
+		const newSchemas = {};
+		for (const cls of detected) {
+			const memberTokens = cls.members.map((i) => tokenized.value[i]);
+			newSchemas[classKey(cls)] = buildClassSchema(memberTokens, cls.kind, cls.subKind, cls.classTagPositions);
+		}
+		schemas.value = newSchemas;
+		if (detected.length > 0) activeClassKey.value = classKey(detected[0]);
+	}
+	const activeSchema = computed(() => schemas.value[activeClassKey.value] ?? null);
+	const suggestions = computed(() => {
+		const schema = activeSchema.value;
+		if (!schema) return [];
+		const activeClass = classes.value.find((c) => classKey(c) === activeClassKey.value);
+		if (!activeClass) return [];
+		return findMerges(schema, activeClass.members.map((i) => tokenized.value[i]));
+	});
+	const result = computed(() => {
+		const pre = preGrouping.value;
+		const composed = composeGroups({
+			tokenizedSamples: tokenized.value,
+			sampleNames: pre ? pre.baseNames : samples.value,
+			schemas: schemas.value,
+			classes: classes.value
 		});
-		for (const sample of qcSamples) metadata.push({
-			sampleName: sample,
-			fields: {},
-			group: "QC"
+		if (!pre) return composed;
+		return {
+			...composed,
+			groups: expandGroupsWithReplicates(composed.groups, pre),
+			experimentalGroups: composed.experimentalGroups ? expandGroupsWithReplicates(composed.experimentalGroups, pre) : void 0,
+			qcGroups: composed.qcGroups ? expandGroupsWithReplicates(composed.qcGroups, pre) : void 0
+		};
+	});
+	const fingerprint = computed(() => serializeFingerprint(result.value.schemas ?? []));
+	const groups = computed(() => result.value.groups);
+	const qcGroups = computed(() => result.value.qcGroups ?? []);
+	const metadata = computed(() => result.value.metadata);
+	const excludedSamples = computed(() => result.value.excludedSamples);
+	function setClassDisposition(key, disposition) {
+		const target = classes.value.find((c) => classKey(c) === key);
+		if (!target || target.disposition === disposition) return;
+		classes.value = classes.value.map((c) => classKey(c) === key ? {
+			...c,
+			disposition
+		} : c);
+	}
+	function setClassDispositions(predicate, disposition) {
+		let changed = false;
+		const next = classes.value.map((c) => {
+			if (predicate(c) && c.disposition !== disposition) {
+				changed = true;
+				return {
+					...c,
+					disposition
+				};
+			}
+			return c;
 		});
-	}
-	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 designData = unwrapExperimentDesignData(rawData);
-	if (!designData) return null;
-	const samples = designData.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 (changed) classes.value = next;
+	}
+	function toggleGroupBy(key, idx) {
+		const schema = schemas.value[key];
+		if (!schema) return;
+		const set = new Set(schema.groupBy);
+		if (set.has(idx)) set.delete(idx);
+		else set.add(idx);
+		schemas.value = {
+			...schemas.value,
+			[key]: {
+				...schema,
+				groupBy: [...set].sort((a, b) => a - b)
 			}
+		};
+	}
+	function updateColumn(key, idx, patch) {
+		const schema = schemas.value[key];
+		if (!schema) return;
+		const col = schema.columns.find((c) => c.index === idx);
+		if (!col) return;
+		let changed = false;
+		for (const k of Object.keys(patch)) if (col[k] !== patch[k]) {
+			changed = true;
+			break;
 		}
+		if (!changed) return;
+		schemas.value = {
+			...schemas.value,
+			[key]: {
+				...schema,
+				columns: schema.columns.map((c) => c.index === idx ? {
+					...c,
+					...patch
+				} : c)
+			}
+		};
 	}
-	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(" / ");
-		const group = groupMap.get(groupKey);
-		if (group) group.push(sampleName);
-		else groupMap.set(groupKey, [sampleName]);
-		const fields = {};
-		for (const col of columns) fields[col.name] = row[col.originalName ?? col.name];
-		metadata.push({
-			sampleName,
-			fields,
-			group: groupKey
-		});
+	function setRole(key, idx, role) {
+		updateColumn(key, idx, { role });
 	}
-	const groups = [];
-	let colorIdx = 0;
-	for (const [name, samples] of groupMap) {
-		groups.push({
-			name,
-			color: DEFAULT_COLORS[colorIdx % DEFAULT_COLORS.length],
-			samples
+	function setColumnName(key, idx, name) {
+		updateColumn(key, idx, { displayName: name });
+	}
+	function setValueOps(key, idx, ops) {
+		updateColumn(key, idx, { ops });
+	}
+	function setBinning(key, idx, binning) {
+		updateColumn(key, idx, { binning });
+	}
+	function mergeColumns(key, indices) {
+		const schema = schemas.value[key];
+		if (!schema || indices.length < 2) return;
+		const sorted = [...indices].sort((a, b) => a - b);
+		const start = sorted[0];
+		const merged = {
+			index: start,
+			name: `Column ${sorted.map((i) => i + 1).join("–")}`,
+			sourceIndices: sorted.flatMap((i) => schema.columns.find((c) => c.index === i)?.sourceIndices ?? [i]),
+			uniqueValues: [],
+			cardinality: 0,
+			role: "factor"
+		};
+		const dropped = new Set(sorted);
+		schemas.value = {
+			...schemas.value,
+			[key]: {
+				...schema,
+				columns: [merged, ...schema.columns.filter((c) => !dropped.has(c.index))].sort((a, b) => a.index - b.index),
+				groupBy: schema.groupBy.filter((i) => !dropped.has(i) || i === start)
+			}
+		};
+	}
+	function loadFingerprint(fp) {
+		const restored = restoreFingerprint(fp, Object.values(schemas.value));
+		const next = {};
+		for (const s of restored) next[classKey({
+			kind: s.classKind,
+			subKind: s.subKind
+		})] = s;
+		schemas.value = next;
+	}
+	const canDownloadTemplate = computed(() => samples.value.length > 0);
+	function downloadTemplate(mode = "prefilled", format = "csv") {
+		const { content, filename } = composeTemplate(samples.value, mode === "prefilled" ? Object.values(schemas.value) : null, mode === "prefilled" ? classes.value : null, {
+			mode,
+			format,
+			tokenizedSamples: tokenized.value
+		});
+		const blob = new Blob([content], { type: format === "tsv" ? "text/tab-separated-values" : "text/csv" });
+		const url = URL.createObjectURL(blob);
+		const a = document.createElement("a");
+		a.href = url;
+		a.download = filename;
+		document.body.appendChild(a);
+		a.click();
+		document.body.removeChild(a);
+		URL.revokeObjectURL(url);
+	}
+	/** Test seam — exposes the template content/filename without triggering a browser download. */
+	function composeTemplateForTest(opts) {
+		return composeTemplate(samples.value, opts.mode === "prefilled" ? Object.values(schemas.value) : null, opts.mode === "prefilled" ? classes.value : null, {
+			...opts,
+			tokenizedSamples: tokenized.value
 		});
-		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(() => {
-		const data = csvData.value;
-		if (isTabularMode.value && data) return data.rows.map((r) => r[data.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 conformingSamples = computed(() => samples.value);
+	const dominantFieldCount = computed(() => tokenized.value[0]?.length ?? 0);
+	const minFieldCount = computed(() => {
+		if (tokenized.value.length === 0) return 0;
+		return Math.min(...tokenized.value.map((t) => t.length));
 	});
-	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 fields = computed(() => activeSchema.value?.columns ?? []);
+	const fieldNames = computed(() => {
+		const out = {};
+		for (const c of fields.value) out[c.index] = c.displayName ?? c.name;
+		return out;
 	});
-	const groups = computed(() => _computedResult.value.groups);
-	const metadata = computed(() => _computedResult.value.metadata);
-	const excludedSamples = computed(() => _computedResult.value.excludedSamples);
+	const enabledFields = computed(() => activeSchema.value ? new Set(activeSchema.value.groupBy) : /* @__PURE__ */ new Set());
+	const effectiveColumns = fields;
 	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 setOutlierAction(_, __) {
+		if (!outlierDeprecationWarned) {
+			if (typeof process === "undefined" || process.env.NODE_ENV !== "production") {
+				console.warn("[useAutoGroup] setOutlierAction is deprecated AND inactive in the class-first redesign. Use setClassDisposition('iqc' | 'eqc' | …, 'group' | 'overlay' | 'exclude') instead.");
+				outlierDeprecationWarned = true;
+			}
 		}
 	}
-	function setAllOutlierActions(action) {
-		for (const outlier of outliers.value) outlier.action = action;
-		outliers.value = [...outliers.value];
+	function setAllOutlierActions(__) {
+		if (!outlierDeprecationWarned) {
+			if (typeof process === "undefined" || process.env.NODE_ENV !== "production") {
+				console.warn("[useAutoGroup] setAllOutlierActions is deprecated AND inactive in the class-first redesign. Use setClassDisposition('iqc' | 'eqc' | …, 'group' | 'overlay' | 'exclude') instead.");
+				outlierDeprecationWarned = true;
+			}
+		}
 	}
 	function toggleField(index) {
-		const newSet = new Set(enabledFields.value);
-		if (newSet.has(index)) newSet.delete(index);
-		else newSet.add(index);
-		enabledFields.value = newSet;
+		warnDeprecated("toggleField");
+		if (activeClassKey.value) toggleGroupBy(activeClassKey.value, index);
 	}
 	function renameField(index, name) {
-		fieldNames.value = {
-			...fieldNames.value,
-			[index]: name
-		};
+		warnDeprecated("renameField");
+		if (activeClassKey.value) setColumnName(activeClassKey.value, index, name);
 	}
 	function loadExperimentData(rawData) {
 		const parsed = extractSamplesFromDesignData(rawData);
 		if (!parsed) return false;
 		inputMode.value = "experiment";
 		csvData.value = parsed;
-		parseCsvInput();
+		sampleTypeHints.value = parsed.sampleTypeHints;
+		parseInput();
 		return true;
 	}
 	function reset() {
 		rawText.value = "";
 		csvData.value = null;
-		delimiter.value = "_";
-		dominantFieldCount.value = 1;
-		minFieldCount.value = 1;
+		classes.value = [];
+		schemas.value = {};
+		activeClassKey.value = "";
+		tokenized.value = [];
 		outliers.value = [];
-		fields.value = [];
-		fieldNames.value = {};
-		enabledFields.value = /* @__PURE__ */ new Set();
+		sampleTypeHints.value = [];
 	}
 	return {
 		inputMode,
 		rawText,
 		csvData,
+		sampleTypeHints,
+		classes,
+		schemas,
+		activeClassKey,
 		delimiter,
 		dominantFieldCount,
 		minFieldCount,
-		outliers,
-		fields,
-		fieldNames,
-		enabledFields,
 		samples,
-		hasOutliers,
-		conformingSamples,
+		tokenized,
+		activeSchema,
+		suggestions,
 		groups,
+		qcGroups,
 		metadata,
 		excludedSamples,
-		allSingletons,
 		result,
+		fingerprint,
+		fields,
+		fieldNames,
+		enabledFields,
 		effectiveColumns,
+		hasOutliers,
+		outliers,
+		conformingSamples,
+		allSingletons,
+		canDownloadTemplate,
+		setClassDisposition,
+		setClassDispositions,
+		toggleGroupBy,
+		setRole,
+		setColumnName,
+		setValueOps,
+		setBinning,
+		mergeColumns,
+		loadFingerprint,
 		parseInput,
+		downloadTemplate,
+		composeTemplateForTest,
 		loadExperimentData,
+		reset,
 		setOutlierAction,
 		setAllOutlierActions,
 		toggleField,
-		renameField,
-		reset
+		renameField
+	};
+}
+function extractSamplesFromDesignData(rawData) {
+	const designData = unwrapExperimentDesignData(rawData);
+	if (!designData) return null;
+	const samples = designData.samples;
+	if (!Array.isArray(samples) || samples.length === 0) return null;
+	const allConditionKeys = [];
+	const keySet = /* @__PURE__ */ new Set();
+	const sampleTypeHints = [];
+	for (const sample of samples) {
+		const rawType = sample.sample_type;
+		sampleTypeHints.push(typeof rawType === "string" ? rawType.toLowerCase() : void 0);
+		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 (allConditionKeys.length === 0) return null;
+	return {
+		columns: [
+			"sample_name",
+			...allConditionKeys,
+			"sample_type"
+		],
+		rows: samples.map((s) => {
+			const conditions = s.conditions ?? {};
+			const row = {
+				sample_name: String(s.sample_name ?? ""),
+				sample_type: String(s.sample_type ?? "sample")
+			};
+			for (const key of allConditionKeys) row[key] = conditions[key] ?? "";
+			return row;
+		}),
+		sampleColumn: "sample_name",
+		delimiter: ",",
+		sampleTypeHints
 	};
 }
 //#endregion
@@ -4196,8 +4960,8 @@ function useReagentSeries() {
 	};
 }
 //#endregion
-//#region src/composables/useProtocolTemplates.ts
-var BUILT_IN_TEMPLATES = [
+//#region src/composables/protocolTemplateCatalog.ts
+var BUILT_IN_PROTOCOL_TEMPLATES = [
 	{
 		id: "builtin-incubation",
 		type: "incubation",
@@ -4537,6 +5301,8 @@ var BUILT_IN_TEMPLATES = [
 		}]
 	}
 ];
+//#endregion
+//#region src/composables/useProtocolTemplates.ts
 var STORAGE_KEY = "mint-custom-protocol-templates";
 function isStepTemplate(value) {
 	if (!value || typeof value !== "object") return false;
@@ -4562,13 +5328,13 @@ function saveCustomTemplatesToStorage(templates) {
 function useProtocolTemplates() {
 	const customTemplates = ref(loadCustomTemplates());
 	const allTemplates = computed(() => {
-		return [...BUILT_IN_TEMPLATES, ...customTemplates.value];
+		return [...BUILT_IN_PROTOCOL_TEMPLATES, ...customTemplates.value];
 	});
 	function getTemplateByType(type) {
-		return customTemplates.value.find((t) => t.type === type) || BUILT_IN_TEMPLATES.find((t) => t.type === type);
+		return customTemplates.value.find((t) => t.type === type) || BUILT_IN_PROTOCOL_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);
+		return customTemplates.value.find((t) => t.id === id) || BUILT_IN_PROTOCOL_TEMPLATES.find((t) => t.id === id);
 	}
 	function saveCustomTemplate(template) {
 		const newTemplate = {
@@ -4643,7 +5409,7 @@ function useProtocolTemplates() {
 		return strValue;
 	}
 	return {
-		builtInTemplates: BUILT_IN_TEMPLATES,
+		builtInTemplates: BUILT_IN_PROTOCOL_TEMPLATES,
 		customTemplates,
 		allTemplates,
 		getTemplateByType,
@@ -4656,6 +5422,6 @@ function useProtocolTemplates() {
 	};
 }
 //#endregion
-export { usePlatformContext as $, parseCSV as A, useRequestSyncState as B, useExpansionSet as C, hslToHex as D, hexToHsl as E, useWellPlateEditor as F, EXPERIMENT_STATUS_OPTIONS as G, useApi as H, useDoseCalculator as I, datePresetToISO as J, EXPERIMENT_STATUS_VARIANT_MAP as K, APP_EXPERIMENT_KEY as L, extractSampleNamesFromDesignData as M, extractSampleOptionsFromDesignData as N, DEFAULT_COLORS as O, unwrapExperimentDesignData as P, resolveExperimentCode as Q, useAppExperiment as R, resolveCurrentExperimentId as S, deriveShade as T, DATE_PRESET_OPTIONS as U, useDebouncedWatch as V, EXPERIMENT_STATUS_LABELS as W, formatExperimentStatus as X, formatExperimentDate as Y, getExperimentStatusVariant as Z, useScheduleDrag as _, useReagentSeries as a, candidateMatchesSearch as at, currentExperimentFromContext as b, useBioTemplatePresetWorkspace as c, compareSortValues as ct, getBioTemplateComponentProps as d, evaluateCondition as et, toBioTemplateComponentPropsByComponent as f, useExperimentSave as g, useTemplateCollection as h, generateDilutionSeries as i, useToast as it, useAutoGroup as j, extractSamplesFromDesignData as k, useBioTemplatePackWorkspace as l, useSortedItems as lt, useBioTemplateControls as m, DEFAULT_PRESETS as n, useForm as nt, useGroupAssignment as o, normalizeSearchQuery as ot, useBioTemplateComponents as p, SORT_OPTIONS as q, DEFAULT_UNITS as r, useTheme as rt, useRackEditor as s, useTextSearch as st, useProtocolTemplates as t, useFormBuilder as tt, useBioTemplateWorkspace as u, useExperimentSamples as v, useSampleGroups as w, getInjectedPlatformContext as x, useExperimentData as y, useExperimentSelector as z };
+export { resolveExperimentCode as $, parseCSV as A, useExperimentSelector as B, useExpansionSet as C, hslToHex as D, hexToHsl as E, classKey as F, EXPERIMENT_STATUS_LABELS as G, useDebouncedWatch as H, useWellPlateEditor as I, SORT_OPTIONS as J, EXPERIMENT_STATUS_OPTIONS as K, useDoseCalculator as L, extractSampleOptionsFromDesignData as M, unwrapExperimentDesignData as N, extractSamplesFromDesignData as O, DEFAULT_COLORS as P, getExperimentStatusVariant as Q, APP_EXPERIMENT_KEY as R, resolveCurrentExperimentId as S, deriveShade as T, useApi as U, useRequestSyncState as V, DATE_PRESET_OPTIONS as W, formatExperimentDate as X, datePresetToISO as Y, formatExperimentStatus as Z, useScheduleDrag as _, useReagentSeries as a, useToast as at, currentExperimentFromContext as b, useBioTemplatePresetWorkspace as c, useTextSearch as ct, getBioTemplateComponentProps as d, usePlatformContext as et, toBioTemplateComponentPropsByComponent as f, useExperimentSave as g, useTemplateCollection as h, generateDilutionSeries as i, useTheme as it, extractSampleNamesFromDesignData as j, useAutoGroup as k, useBioTemplatePackWorkspace as l, compareSortValues as lt, useBioTemplateControls as m, DEFAULT_PRESETS as n, evaluateCondition as nt, useGroupAssignment as o, candidateMatchesSearch as ot, useBioTemplateComponents as p, EXPERIMENT_STATUS_VARIANT_MAP as q, DEFAULT_UNITS as r, useForm as rt, useRackEditor as s, normalizeSearchQuery as st, useProtocolTemplates as t, useFormBuilder as tt, useBioTemplateWorkspace as u, useSortedItems as ut, useExperimentSamples as v, useSampleGroups as w, getInjectedPlatformContext as x, useExperimentData as y, useAppExperiment as z };
 
-//# sourceMappingURL=useProtocolTemplates-n6AJqSqv.js.map
+//# sourceMappingURL=useProtocolTemplates-Bm5vyH4_.js.map