@morscherlab/mint-sdk 1.3.0-beta.9 → 1.3.1

package/dist/{validation-Dmp9Q5W0.js → validation-CukfLjy-.js}

@@ -3743,41 +3743,6 @@ function useRackEditor(initialRacks, 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) {
 	const base = c.subKind ? `${c.kind}:${c.subKind}` : c.kind;
@@ -3792,22 +3757,20 @@ var vocab_default = {
 		"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 _T<n>, _B<n>, and _Rep<n> markers. The trailing injection / run-order number is intentionally NOT stripped here — it survives tokenisation and is surfaced as a 'run-order' column (named 'Injection #'), then excluded from the default group key so replicates still collapse."
+		"replicateToken": "Regex source for a token that names a replicate: rep1, Rep2, replicate3, R1, T1 (technical replicate). A column whose values all match is a replicate column: it stays a visible field and is left out of the default group key. B<n> is not in the pattern: on the lab share B13 / S13 are label tokens."
 	},
 	patterns: {
 		"blank": "^(blank|blk|solv?blank|matrix.?blank)$",
-		"iqc": "^iqc$",
+		"iqc": "^(iqc|qc|pqc|pooled.?qc)$",
 		"eqc": "^eqc$",
-		"standard": "^(standard|std\\d*|cal(?:ibrator)?\\d*|.+standard)$",
+		"standard": "^(standards?|stds?\\d*|istd|cal(?:ibrator)?\\d*|.+standard)$",
 		"spikeIn": "spike.?in",
 		"stock": "^stock$"
 	},
 	standardAllow: [
 		"ExtractionS",
 		"IS",
-		"internal.standard",
-		"PQC",
-		"pooledQC"
+		"internal.standard"
 	],
 	matrixVocab: {
 		"plasma": "Plasma",
@@ -3837,11 +3800,7 @@ var vocab_default = {
 		"negative": "NEG"
 	},
 	tissueParentTokens: ["tissue", "tissues"],
-	replicateStripPatterns: [
-		"[_-]T\\d+(?=[_-]|$)",
-		"[_-]B\\d+(?=[_-]|$)",
-		"[_-](?:rep(?:licate)?)\\d+(?=[_-]|$)"
-	]
+	replicateToken: "^(?:rep(?:licate)?|r|t)\\d+$"
 };
 //#endregion
 //#region src/composables/autoGroup/classify.ts
@@ -3866,6 +3825,14 @@ function matrixCanonical(token, vocab) {
 function isTissueParentToken(token, vocab) {
 	return vocab.tissueParentTokens.has(token.toLowerCase());
 }
+/** A token that names a QC-type class (blank, QC, standard, spike-in, stock). */
+function isClassMarker(token, vocab = classVocab) {
+	return vocab.blankPattern.test(token) || vocab.iqcPattern.test(token) || vocab.eqcPattern.test(token) || vocab.standardPattern.test(token) || vocab.standardAllow.has(token) || vocab.spikeInPattern.test(token) || vocab.stockPattern.test(token);
+}
+/** Kinds that form experimental groups; all other kinds are QC-type overlay classes. */
+function isExperimentalKind(kind) {
+	return kind === "biological" || kind === "unknown";
+}
 var DEFAULT_DISPOSITION = {
 	biological: "group",
 	iqc: "overlay",
@@ -3876,28 +3843,28 @@ var DEFAULT_DISPOSITION = {
 	blank: "overlay",
 	unknown: "group"
 };
-function classifyTokens(tokens, vocab) {
-	for (let i = 0; i < tokens.length; i++) if (vocab.blankPattern.test(tokens[i])) return {
+function classifyTokens(tokens, vocab, qcFrom) {
+	for (let i = qcFrom; 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 {
+	for (let i = qcFrom; 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 {
+	for (let i = qcFrom; 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 {
+	for (let i = qcFrom; 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 {
+	for (let i = qcFrom; 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 {
+	for (let i = qcFrom; i < tokens.length; i++) if (vocab.stockPattern.test(tokens[i])) return {
 		kind: "stock",
 		tagPositions: [i]
 	};
@@ -3982,7 +3949,7 @@ function detectClass(tokenizedSamples, options) {
 			kind = "blank";
 			tagPositions = [];
 		} else {
-			const r = classifyTokens(tokenizedSamples[i], vocab);
+			const r = classifyTokens(tokenizedSamples[i], vocab, options.sharedPrefix ?? 0);
 			kind = r.kind;
 			subKind = r.subKind;
 			tagPositions = r.tagPositions;
@@ -4012,11 +3979,174 @@ function detectClass(tokenizedSamples, options) {
 	return [...buckets.values()];
 }
 //#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;
+}
+var HEADER_FIELDS = [
+	"code",
+	"date",
+	"operator"
+];
+var OPERATOR_AGREEMENT = .9;
+var FIRST_PLAUSIBLE_YEAR = 2015;
+function isoDate(year, month, day) {
+	const lastYear = (/* @__PURE__ */ new Date()).getFullYear() + 1;
+	if (year < FIRST_PLAUSIBLE_YEAR || year > lastYear) return void 0;
+	const date = new Date(Date.UTC(year, month - 1, day));
+	if (date.getUTCMonth() !== month - 1 || date.getUTCDate() !== day) return void 0;
+	return date.toISOString().slice(0, 10);
+}
+/** Read a 6- or 8-digit date token; year-first is tried before day-first. */
+function parseDateToken(token) {
+	const n = (from, to) => Number(token.slice(from, to));
+	if (/^\d{8}$/.test(token)) return isoDate(n(0, 4), n(4, 6), n(6, 8)) ?? isoDate(n(4, 8), n(2, 4), n(0, 2));
+	if (/^\d{6}$/.test(token)) return isoDate(2e3 + n(0, 2), n(2, 4), n(4, 6)) ?? isoDate(2e3 + n(4, 6), n(2, 4), n(0, 2));
+}
+/**
+* Read the experiment code, date and operator from the left of a name, in any
+* order. `position` holds the token index of each field. A name with no code
+* and no date has no header, so `WT_Ctrl_1` keeps `WT` as a sample token.
+*/
+function readHeader(tokens) {
+	const fields = {};
+	const position = {};
+	let i = 0;
+	if (tokens.length > 1 && /^exp\d+$/i.test(tokens[0])) {
+		fields.code = tokens[0].toLowerCase();
+		position.code = i++;
+	}
+	for (; i < tokens.length - 1; i++) {
+		const date = fields.date ? void 0 : parseDateToken(tokens[i]);
+		if (date) {
+			fields.date = date;
+			position.date = i;
+		} else if (!fields.operator && /^[A-Z]{2,3}$/.test(tokens[i]) && !isClassMarker(tokens[i])) {
+			fields.operator = tokens[i];
+			position.operator = i;
+		} else break;
+	}
+	if (!fields.code && !fields.date) return {
+		fields: {},
+		position: {}
+	};
+	return {
+		fields,
+		position
+	};
+}
+var MS_FILE_EXTENSION = /\.(raw|mzml|mzxml|mzdata|wiff2?|d|mgf|csv|tsv|txt)$/i;
+/** Drop a mass-spec file extension from each name, and any other extension that all names share. */
+function stripExtensions(names) {
+	const bare = names.map((name) => name.replace(MS_FILE_EXTENSION, ""));
+	const ext = /\.[A-Za-z][A-Za-z0-9]{0,4}$/.exec(bare[0] ?? "")?.[0];
+	return ext && bare.every((name) => name.endsWith(ext)) ? bare.map((name) => name.slice(0, -ext.length)) : bare;
+}
+/**
+* Sample names → token rows.
+*
+*   1. Trim; drop a file extension that all names share.
+*   2. Split on runs of the primary delimiter.
+*   3. Drop a trailing 14-digit acquisition stamp.
+*   4. Read the experiment header. A field moves to `experiment` when the batch
+*      has one value for it. Any other field stays in the rows as written, so
+*      `QC` or `WT` after the date in some names is not taken for operator
+*      initials.
+*   5. Count the tokens that all names share after the header (the experiment
+*      title), so a title word such as `std` cannot classify the batch as QC.
+*/
+function tokenizeBatch(names) {
+	const cleaned = stripExtensions(names.map((name) => name.trim()));
+	const delimiter = pickPrimaryDelimiter(cleaned);
+	const parsed = cleaned.map((name) => {
+		const split = name.split(delimiter).filter(Boolean);
+		if (split.length > 1 && /^\d{14}$/.test(split[split.length - 1])) split.pop();
+		const tokens = split.length > 0 ? split : [name];
+		return {
+			tokens,
+			...readHeader(tokens)
+		};
+	});
+	const experiment = {};
+	for (const field of ["code", "date"]) {
+		const values = new Set(parsed.map(({ fields }) => fields[field]).filter(Boolean));
+		if (values.size === 1) experiment[field] = [...values][0];
+	}
+	const dated = parsed.filter(({ fields }) => fields.date);
+	const complete = dated.length > 0 ? dated : parsed.filter(({ fields }) => fields.code);
+	const operatorCounts = /* @__PURE__ */ new Map();
+	for (const { fields } of complete) if (fields.operator) operatorCounts.set(fields.operator, (operatorCounts.get(fields.operator) ?? 0) + 1);
+	const [operator, count] = [...operatorCounts].sort((a, b) => b[1] - a[1])[0] ?? [];
+	if (operator && count >= complete.length * OPERATOR_AGREEMENT) experiment.operator = operator;
+	const rows = parsed.map(({ tokens, fields, position }) => {
+		const moved = new Set(HEADER_FIELDS.filter((field) => experiment[field] && fields[field] === experiment[field]).map((field) => position[field]));
+		return tokens.filter((_, index) => !moved.has(index));
+	});
+	let sharedPrefix = 0;
+	if (rows.length > 1 && Object.keys(experiment).length > 0) {
+		while (rows.every((row) => row.length > sharedPrefix + 1 && row[sharedPrefix] === rows[0][sharedPrefix])) sharedPrefix++;
+		if (rows.every((row) => row.slice(sharedPrefix).every((token) => /^\d+[A-Za-z]?$/.test(token)))) sharedPrefix = 0;
+	}
+	return {
+		delimiter,
+		experiment,
+		rows,
+		sharedPrefix
+	};
+}
+//#endregion
 //#region src/composables/autoGroup/columns.ts
-var NUMERIC_VALUE_UNIT = /^(\d+(?:dot\d+)?)([A-Za-z%/μ]+)$/;
+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 REPLICATE_TOKEN_PATTERN = new RegExp(vocab_default.replicateToken, "i");
+/**
+* A replicate counter is a dense run of small numbers or letters: `1, 2, 3`,
+* `01, 02, 03` or `A, B, C`. A quarter of the run can be missing (a failed
+* sample). `1, 5, 10` is a dose and `1, 2, 6, 7` an animal number: too sparse.
+*/
+function isCounterRun(values) {
+	if (!values.every((value) => /^(\d{1,2}|[A-Za-z])$/.test(value))) return false;
+	const ranks = [...new Set(values.map((value) => /\d/.test(value) ? Number(value) : value.toUpperCase().charCodeAt(0) - 64))];
+	const allowedGaps = Math.max(1, Math.floor(ranks.length / 4));
+	return Math.min(...ranks) >= 1 && Math.max(...ranks) <= ranks.length + allowedGaps;
+}
+var STEM_COUNTER_PATTERN = /^([A-Za-z]+)(\d{1,2})$/;
+var COLUMN_AGREEMENT = .9;
+var ID_MIN_CLASS_SIZE = 4;
+/** Roles the Field Recipe offers as grouping fields. `replicate` and `id` are off by default. */
+var GROUPING_FIELD_ROLES = /* @__PURE__ */ new Set([
+	"factor",
+	"numeric",
+	"replicate",
+	"id"
+]);
 var DEFAULT_FACTOR_CARDINALITY_MAX = 50;
 var LOW_CARDINALITY_NUMERIC_AS_FACTOR_MAX = 5;
 function parseNumeric(token) {
@@ -4044,8 +4174,12 @@ function parseNumeric(token) {
 }
 function inferRole(input) {
 	const { values, position, totalPositions, classSize } = input;
+	const tail = input.tail ?? position === totalPositions - 1;
 	const cardinality = new Set(values).size;
 	if (cardinality === 1) return "constant";
+	const present = values.filter(Boolean);
+	if (present.every((v) => REPLICATE_TOKEN_PATTERN.test(v))) return "replicate";
+	if (tail && cardinality * 2 <= values.length && isCounterRun(present)) return "replicate";
 	if (position === totalPositions - 1) {
 		if (values.every((v) => RUN_ORDER_PATTERN.test(v)) && cardinality >= classSize * .5) return "run-order";
 	}
@@ -4053,13 +4187,56 @@ function inferRole(input) {
 		if (cardinality <= LOW_CARDINALITY_NUMERIC_AS_FACTOR_MAX) return "factor";
 		return "numeric";
 	}
-	if (values.every((v) => REPLICATE_TOKEN_PATTERN.test(v))) return "replicate";
+	if (values.length >= ID_MIN_CLASS_SIZE && cardinality >= values.length * COLUMN_AGREEMENT && values.filter((v) => /\d/.test(v)).length >= values.length * COLUMN_AGREEMENT) return "id";
 	if (cardinality <= DEFAULT_FACTOR_CARDINALITY_MAX) return "factor";
 	return "ignore";
 }
 /**
+* How a column splits when most of its values agree: on `-` into equal parts
+* (`2-1` → `2`, `1`), or into stem + counter (`C1` → `C`, `1`) when two or more
+* stems repeat with different counters. `D1`/`D3` (one stem) and `B13`/`S13`
+* (one counter for each stem) stay whole.
+*/
+function columnSplitter(values) {
+	const agree = (test) => values.filter(test).length >= values.length * COLUMN_AGREEMENT;
+	const partCounts = /* @__PURE__ */ new Map();
+	for (const value of values) {
+		const parts = value.split("-").length;
+		partCounts.set(parts, (partCounts.get(parts) ?? 0) + 1);
+	}
+	const parts = [...partCounts].sort((a, b) => b[1] - a[1])[0]?.[0] ?? 1;
+	if (parts > 1 && agree((value) => value.split("-").length === parts)) return (value) => {
+		const pieces = value.split("-");
+		return pieces.length === parts ? pieces : [value, ...Array(parts - 1).fill("")];
+	};
+	const countersByStem = /* @__PURE__ */ new Map();
+	for (const value of values) {
+		const match = STEM_COUNTER_PATTERN.exec(value);
+		if (match) countersByStem.set(match[1], (countersByStem.get(match[1]) ?? /* @__PURE__ */ new Set()).add(match[2]));
+	}
+	const repeated = [...countersByStem.values()].filter((counters) => counters.size > 1).length;
+	if (countersByStem.size > 1 && repeated * 2 >= countersByStem.size && agree((value) => STEM_COUNTER_PATTERN.test(value))) return (value) => STEM_COUNTER_PATTERN.exec(value)?.slice(1) ?? [value, ""];
+}
+/** Split the columns of one class (rows of equal length) that hold two fields in one token. */
+function splitColumns(rows) {
+	const width = rows[0]?.length ?? 0;
+	const splitters = Array.from({ length: width }, (_, col) => columnSplitter(rows.map((row) => row[col] ?? "")));
+	const origin = [];
+	const tail = [];
+	splitters.forEach((splitter, col) => {
+		const parts = splitter ? splitter(rows[0][col]).length : 1;
+		for (let part = 0; part < parts; part++) origin.push(col);
+		if (parts > 1) tail.push(origin.length - 1);
+	});
+	return {
+		rows: rows.map((row) => row.flatMap((token, col) => splitters[col]?.(token) ?? [token])),
+		origin,
+		tail
+	};
+}
+/**
 * 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".
+* Returns null when nothing matches, so callers can fall back to "Field N".
 *
 * Heuristics are content-derived and deterministic. They cover the common
 * LC-MS / proteomics naming conventions; users can override anything via
@@ -4134,15 +4311,18 @@ function inferColumnName(values, uniqueValues, role) {
 	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";
+	if (uniqueValues.length === 1 && /^[A-Z]{2,3}$/.test(uniqueValues[0])) return "Username";
+	if (role === "replicate") return "Replicate";
+	if (role === "id") return "Sample ID";
 	return null;
 }
-function buildClassSchema(tokenizedMembers, classKind, subKind, classTagPositions) {
+function buildClassSchema(tokenizedMembers, classKind, subKind, classTagPositions, tailPositions = []) {
 	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 tailSet = /* @__PURE__ */ new Set([...tailPositions, totalPositions - 1]);
+	for (let pos = totalPositions - 1; pos >= 0; pos--) {
 		const values = tokenizedMembers.map((t) => t[pos] ?? "");
 		const uniqueValues = [...new Set(values)];
 		let role;
@@ -4151,13 +4331,16 @@ function buildClassSchema(tokenizedMembers, classKind, subKind, classTagPosition
 			values,
 			position: pos,
 			totalPositions,
-			classSize
+			classSize,
+			tail: tailSet.has(pos)
 		});
+		const lastPosition = pos === totalPositions - 1;
+		if (role === "run-order" || lastPosition && role === "id") tailSet.add(pos - 1);
 		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({
+		columns.unshift({
 			index: pos,
-			name: inferredName ?? `Token ${pos + 1}`,
+			name: inferredName ?? `Field ${pos + 1}`,
 			sourceIndices: [pos],
 			uniqueValues,
 			cardinality: uniqueValues.length,
@@ -4166,16 +4349,18 @@ function buildClassSchema(tokenizedMembers, classKind, subKind, classTagPosition
 			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;
+	const nameCounts = /* @__PURE__ */ new Map();
+	const isField = (c) => GROUPING_FIELD_ROLES.has(c.role);
+	for (const c of [...columns.filter(isField), ...columns.filter((c) => !isField(c))]) {
+		const count = (nameCounts.get(c.name) ?? 0) + 1;
+		nameCounts.set(c.name, count);
+		if (count > 1) c.name = `${c.name} ${count}`;
 	}
 	return {
 		classKind,
 		subKind,
 		columns,
-		groupBy: columns.filter((c) => c.role === "factor").map((c) => c.index)
+		groupBy: columns.filter((c) => c.role === "factor" || c.role === "numeric").map((c) => c.index)
 	};
 }
 //#endregion
@@ -4315,8 +4500,8 @@ function composeGroups(input) {
 				return fieldValues[col.displayName ?? col.name];
 			}) : [cls.label];
 			const hasMissingGroupPart = input.missingGroupName && cls.disposition === "group" && keyParts.some((part) => part.trim().length === 0);
-			const prefix = cls.kind !== "unknown" && keyParts.length > 0 ? classPrefix.get(cls) : void 0;
-			const groupKey = hasMissingGroupPart ? input.missingGroupName : prefix ? `${prefix} / ${keyParts.join(" / ")}` : keyParts.length > 0 ? keyParts.join(" / ") : cls.label;
+			const prefix = cls.kind !== "unknown" ? classPrefix.get(cls) : void 0;
+			const groupKey = hasMissingGroupPart ? input.missingGroupName : [...prefix ? [prefix] : [], ...keyParts].join(" / ") || cls.label;
 			const bucket = groupMap.get(groupKey);
 			if (bucket) bucket.samples.push(rowName);
 			else groupMap.set(groupKey, {
@@ -4414,7 +4599,7 @@ function serializeFingerprint(schemas) {
 }
 function restoreFingerprint(fp, current) {
 	return fp.classes.map((snap) => {
-		const candidates = current.filter((c) => c.classKind === snap.kind && c.subKind === snap.subKind && (snap.tokenLength == null || c.tokenLength === snap.tokenLength));
+		const candidates = current.filter((c) => c.classKind === snap.kind && c.subKind === snap.subKind && (snap.tokenLength == null || c.tokenLength == null || c.tokenLength === snap.tokenLength));
 		const target = candidates.find((c) => c.columns.length === snap.columns.length) ?? candidates[0];
 		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`);
@@ -4538,91 +4723,6 @@ function composeTemplate(samples, schemas, classes, options) {
 	};
 }
 //#endregion
-//#region src/composables/autoGroup/replicatePreGroup.ts
-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];
-		})
-	}));
-}
-/**
-* Expand a group hierarchy (built over base names) back to original samples.
-* Each leaf node's `label` is a base name; it is replaced by one leaf per
-* original sample that collapsed onto it (sharing the leaf's injection badge,
-* since collapsed replicates have identical base tokens). Every ancestor's
-* `badge` (sample count) is recomputed from the expanded leaf count so the tree
-* agrees with the flat groups produced by `expandGroupsWithReplicates`.
-*/
-function expandTreeWithReplicates(nodes, preGrouping) {
-	const baseToOriginals = /* @__PURE__ */ new Map();
-	for (let i = 0; i < preGrouping.baseNames.length; i++) baseToOriginals.set(preGrouping.baseNames[i], preGrouping.membersByBase[i].map((m) => preGrouping.originalSamples[m]));
-	const leafCount = (n) => n.children && n.children.length ? n.children.reduce((acc, c) => acc + leafCount(c), 0) : 1;
-	const expand = (node) => {
-		if (node.children && node.children.length) {
-			const children = node.children.flatMap(expand);
-			return [{
-				...node,
-				children,
-				badge: children.reduce((acc, c) => acc + leafCount(c), 0)
-			}];
-		}
-		const originals = baseToOriginals.get(node.label);
-		if (!originals || originals.length === 0) return [node];
-		return originals.map((name, k) => ({
-			...node,
-			id: `${node.id}
${k}`,
-			label: name
-		}));
-	};
-	return nodes.flatMap(expand);
-}
-//#endregion
 //#region src/composables/autoGroup/tokenLength.ts
 /**
 * Token-length pre-grouping.
@@ -4642,6 +4742,10 @@ function expandTreeWithReplicates(nodes, preGrouping) {
 function splitByTokenLength(classes, tokenized) {
 	const out = [];
 	for (const cls of classes) {
+		if (!isExperimentalKind(cls.kind)) {
+			out.push(cls);
+			continue;
+		}
 		const byLength = /* @__PURE__ */ new Map();
 		const lengthOrder = [];
 		for (const m of cls.members) {
@@ -4793,7 +4897,7 @@ function useAutoGroup() {
 	});
 	const tokenized = ref([]);
 	const delimiter = ref("_");
-	const preGrouping = ref(null);
+	const experiment = ref({});
 	function parseInput() {
 		if ((inputMode.value === "csv" || inputMode.value === "experiment") && csvData.value) {
 			parseInputFromCsv();
@@ -4802,7 +4906,7 @@ function useAutoGroup() {
 		parseInputFromPaste();
 	}
 	function parseInputFromCsv() {
-		preGrouping.value = null;
+		experiment.value = {};
 		const csv = csvData.value;
 		const nonSampleCols = csv.columns.filter((c) => c !== csv.sampleColumn && c !== "sample_type");
 		if (nonSampleCols.length === 0) {
@@ -4847,25 +4951,40 @@ function useAutoGroup() {
 		if (lines.length === 0) {
 			classes.value = [];
 			schemas.value = {};
-			preGrouping.value = null;
+			experiment.value = {};
 			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 = splitByTokenLength(detectClass(tokenized.value, { sampleTypeHints: hints }), tokenized.value);
-		classes.value = detected;
+		const batch = tokenizeBatch(lines);
+		delimiter.value = batch.delimiter;
+		experiment.value = batch.experiment;
+		const tokens = batch.rows;
+		const detected = splitByTokenLength(detectClass(tokens, {
+			sampleTypeHints: sampleTypeHints.value,
+			sharedPrefix: batch.sharedPrefix
+		}), tokens);
 		const newSchemas = {};
 		for (const cls of detected) {
-			const memberTokens = cls.members.map((i) => tokenized.value[i]);
+			let memberTokens = cls.members.map((i) => tokens[i]);
+			let tailPositions = [];
+			const experimental = isExperimentalKind(cls.kind);
+			if (experimental) {
+				const split = splitColumns(memberTokens);
+				cls.members.forEach((member, row) => {
+					tokens[member] = split.rows[row];
+				});
+				cls.classTagPositions = split.origin.flatMap((source, index) => cls.classTagPositions.includes(source) ? [index] : []);
+				memberTokens = split.rows;
+				tailPositions = split.tail;
+			}
+			const schema = buildClassSchema(memberTokens, cls.kind, cls.subKind, cls.classTagPositions, tailPositions);
+			if (!experimental) schema.groupBy = [];
 			newSchemas[classKey(cls)] = {
-				...buildClassSchema(memberTokens, cls.kind, cls.subKind, cls.classTagPositions),
+				...schema,
 				tokenLength: cls.tokenLength
 			};
 		}
+		tokenized.value = tokens;
+		classes.value = detected;
 		schemas.value = newSchemas;
 		if (detected.length > 0) activeClassKey.value = classKey(detected[0]);
 	}
@@ -4877,25 +4996,17 @@ function useAutoGroup() {
 		if (!activeClass) return [];
 		return findMerges(schema, activeClass.members.map((i) => tokenized.value[i]));
 	});
-	const result = computed(() => {
-		const pre = preGrouping.value;
-		const composed = composeGroups({
+	function composeWith(withSchemas) {
+		return composeGroups({
 			tokenizedSamples: tokenized.value,
-			sampleNames: pre ? pre.baseNames : samples.value,
-			schemas: schemas.value,
+			sampleNames: samples.value,
+			schemas: withSchemas,
 			classes: classes.value,
 			prefixClassLabels: !(csvData.value && (inputMode.value === "csv" || inputMode.value === "experiment")),
 			missingGroupName: csvData.value && (inputMode.value === "csv" || inputMode.value === "experiment") ? STRUCTURED_MISSING_GROUP : void 0
 		});
-		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,
-			groupTree: composed.groupTree ? expandTreeWithReplicates(composed.groupTree, pre) : composed.groupTree
-		};
-	});
+	}
+	const result = computed(() => composeWith(schemas.value));
 	const fingerprint = computed(() => serializeFingerprint(result.value.schemas ?? []));
 	const groups = computed(() => result.value.groups);
 	const qcGroups = computed(() => result.value.qcGroups ?? []);
@@ -4955,7 +5066,8 @@ function useAutoGroup() {
 	}
 	function schemasExposing(fieldKey) {
 		return Object.entries(schemas.value).flatMap(([key, schema]) => {
-			const col = schema.columns.find((c) => (c.displayName ?? c.name) === fieldKey && (c.role === "factor" || c.role === "replicate" || schema.groupBy.includes(c.index)));
+			if (!isExperimentalKind(schema.classKind)) return [];
+			const col = schema.columns.find((c) => (c.displayName ?? c.name) === fieldKey && (GROUPING_FIELD_ROLES.has(c.role) || schema.groupBy.includes(c.index)));
 			return col ? [{
 				key,
 				index: col.index
@@ -4982,6 +5094,26 @@ function useAutoGroup() {
 		}
 	}
 	/**
+	* Rename a grouping field in every class exposing it. A blank name, or a
+	* name that a column of any experimental class has, changes nothing: the
+	* name is the field's identity across classes, and the cards merge by it.
+	*/
+	function renameGroupByField(fieldKey, name) {
+		const next = name.trim();
+		const targets = schemasExposing(fieldKey);
+		if (!next || next === fieldKey || targets.length === 0) return;
+		if (Object.values(schemas.value).some((schema) => isExperimentalKind(schema.classKind) && schema.columns.some((c) => (c.displayName ?? c.name) === next))) return;
+		for (const { key, index } of targets) setColumnName(key, index, next);
+	}
+	/** Number of experimental groups that remain when the field is switched off in every class. */
+	function groupCountWithout(fieldKey) {
+		const targets = new Map(schemasExposing(fieldKey).map(({ key, index }) => [key, index]));
+		return composeWith(Object.fromEntries(Object.entries(schemas.value).map(([key, schema]) => [key, targets.has(key) ? {
+			...schema,
+			groupBy: schema.groupBy.filter((i) => i !== targets.get(key))
+		} : schema]))).experimentalGroups?.length ?? 0;
+	}
+	/**
 	* Move a grouping field in the active schema, then project that visible field
 	* order across every class. Class-only fields keep their relative order after
 	* the shared fields because the Field Recipe has no card with which to place
@@ -5176,6 +5308,7 @@ function useAutoGroup() {
 		schemas.value = {};
 		activeClassKey.value = "";
 		tokenized.value = [];
+		experiment.value = {};
 		outliers.value = [];
 		sampleTypeHints.value = [];
 	}
@@ -5188,6 +5321,7 @@ function useAutoGroup() {
 		schemas,
 		activeClassKey,
 		delimiter,
+		experiment,
 		dominantFieldCount,
 		minFieldCount,
 		samples,
@@ -5215,6 +5349,8 @@ function useAutoGroup() {
 		moveGroupBy,
 		toggleGroupByField,
 		moveGroupByField,
+		renameGroupByField,
+		groupCountWithout,
 		setRole,
 		setColumnName,
 		setValueOps,
@@ -7858,6 +7994,6 @@ function pickerFormat(name) {
 	return compound ? `${compound[1]}.gz` : name.includes(".") ? name.split(".").pop() : "";
 }
 //#endregion
-export { pluginFormDataFromPayload as $, parseDelimitedText as A, getPresenceClientId as At, useRackEditor as B, useRovingFocus as Bt, useExperimentSamples as C, controlValuesToComponentBindingsById as Ct, getSampleGroupMajorPrefix as D, useAppExperiment as Dt, useSampleGroups as E, APP_EXPERIMENT_KEY as Et, useAutoGroup as F, candidateMatchesSearch as Ft, useDoseCalculator as G, reorderList as H, extractSampleNamesFromDesignData as I, normalizeSearchQuery as It, usePluginJobCenter as J, combinePluginJobSources as K, extractSampleOptionsFromDesignData as L, useTextSearch as Lt, useFileImport as M, usePlatformContext as Mt, validateImportFile as N, useTheme as Nt, getSampleGroupParentPath as O, getInjectedFrontendRevision as Ot, extractSamplesFromDesignData as P, useToast as Pt, getPluginPageSelectorItems as Q, unwrapExperimentDesignData as R, compareSortValues as Rt, useScheduleDrag as S, controlValuesToComponentBindings as St, useExpansionSet as T, mergeControlWorkspaceOptions as Tt, useListReorder as U, REORDER_ANNOUNCER_STYLE as V, useReorderAnnouncer as W, downloadBlob as X, createPluginClient as Y, downloadPluginEndpoint as Z, toBioTemplateComponentPropsByComponent as _, defineWellPlateDoseComponentBindings as _t, useExperimentSelector as a, buildPluginEndpointUrl as at, useTemplateCollection as b, defineControlModel as bt, DEFAULT_PRESETS as c, usePluginWorkspace as ct, useReagentSeries as d, useFormBuilder as dt, uploadPluginEndpoint as et, useGroupAssignment as f, evaluateCondition as ft, getBioTemplateComponentProps as g, defineWellPlateControlProps as gt, useBioTemplateWorkspace as h, defineDoseDesignControlModel as ht, useAnalysisArtifacts as i, usePluginSettings as it, readFileAsText as j, usePresenceHeartbeat as jt, detectDelimiter as k, useRuntimeAlignment as kt, DEFAULT_UNITS as l, DEFAULT_MOBILE_VIEWPORT_QUERY as lt, useBioTemplatePackWorkspace as m, defineDoseCalculatorControlProps as mt, pickerFormat as n, usePluginClient as nt, useDebouncedWatch as o, resolvePluginBaseUrl as ot, useBioTemplatePresetWorkspace as p, useForm as pt, useJobsStatusTray as q, pickerReason as r, usePluginEventStream as rt, useProtocolTemplates as s, useRequestSyncState as st, pickerExclusion as t, useCurrentExperiment as tt, generateDilutionSeries as u, useMobileSupportGate as ut, useBioTemplateComponents as v, defineWellPlateDoseControlProps as vt, useExperimentData as w, controlValuesToComponentProps as wt, useExperimentSave as x, resolveControlModel as xt, useBioTemplateControls as y, useControlWorkspace as yt, DEFAULT_COLORS as z, useSortedItems as zt };
+export { downloadBlob as $, parseDelimitedText as A, useAppExperiment as At, GROUPING_FIELD_ROLES as B, useTextSearch as Bt, useExperimentSamples as C, defineControlModel as Ct, getSampleGroupMajorPrefix as D, controlValuesToComponentProps as Dt, useSampleGroups as E, controlValuesToComponentBindingsById as Et, useAutoGroup as F, usePlatformContext as Ft, reorderList as G, classKey as H, useSortedItems as Ht, extractSampleNamesFromDesignData as I, useTheme as It, useDoseCalculator as J, useListReorder as K, extractSampleOptionsFromDesignData as L, useToast as Lt, useFileImport as M, useRuntimeAlignment as Mt, validateImportFile as N, getPresenceClientId as Nt, getSampleGroupParentPath as O, mergeControlWorkspaceOptions as Ot, extractSamplesFromDesignData as P, usePresenceHeartbeat as Pt, createPluginClient as Q, unwrapExperimentDesignData as R, candidateMatchesSearch as Rt, useScheduleDrag as S, useControlWorkspace as St, useExpansionSet as T, controlValuesToComponentBindings as Tt, useRackEditor as U, useRovingFocus as Ut, isExperimentalKind as V, compareSortValues as Vt, REORDER_ANNOUNCER_STYLE as W, useJobsStatusTray as X, combinePluginJobSources as Y, usePluginJobCenter as Z, toBioTemplateComponentPropsByComponent as _, defineDoseCalculatorControlProps as _t, useExperimentSelector as a, usePluginClient as at, useTemplateCollection as b, defineWellPlateDoseComponentBindings as bt, DEFAULT_PRESETS as c, buildPluginEndpointUrl as ct, useReagentSeries as d, usePluginWorkspace as dt, downloadPluginEndpoint as et, useGroupAssignment as f, DEFAULT_MOBILE_VIEWPORT_QUERY as ft, getBioTemplateComponentProps as g, useForm as gt, useBioTemplateWorkspace as h, evaluateCondition as ht, useAnalysisArtifacts as i, useCurrentExperiment as it, readFileAsText as j, getInjectedFrontendRevision as jt, detectDelimiter as k, APP_EXPERIMENT_KEY as kt, DEFAULT_UNITS as l, resolvePluginBaseUrl as lt, useBioTemplatePackWorkspace as m, useFormBuilder as mt, pickerFormat as n, pluginFormDataFromPayload as nt, useDebouncedWatch as o, usePluginEventStream as ot, useBioTemplatePresetWorkspace as p, useMobileSupportGate as pt, useReorderAnnouncer as q, pickerReason as r, uploadPluginEndpoint as rt, useProtocolTemplates as s, usePluginSettings as st, pickerExclusion as t, getPluginPageSelectorItems as tt, generateDilutionSeries as u, useRequestSyncState as ut, useBioTemplateComponents as v, defineDoseDesignControlModel as vt, useExperimentData as w, resolveControlModel as wt, useExperimentSave as x, defineWellPlateDoseControlProps as xt, useBioTemplateControls as y, defineWellPlateControlProps as yt, DEFAULT_COLORS as z, normalizeSearchQuery as zt };
 
-//# sourceMappingURL=validation-Dmp9Q5W0.js.map
+//# sourceMappingURL=validation-CukfLjy-.js.map