@morscherlab/mint-sdk 1.2.10 → 1.3.0-beta.10

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

@@ -1,9 +1,7 @@
-import { d as useSettingsStore, i as useApi, t as readErrorMessage } from "./errors-BLuqMee5.js";
-import { d as resolveExperimentCode } from "./experiment-utils-CV2Wza3z.js";
-import { n as useRequestSyncState } from "./Skeleton-jhF9wUkU.js";
-import { A as useConcentrationUnits, H as parseExperimentId, J as isActiveJobStatus, Q as normalizeJobState, T as getDefaultControlView, U as resolveCurrentExperimentId, V as getInjectedPlatformContext, f as resolveControlModel, g as mergeControlWorkspaceOptions, h as controlValuesToComponentProps, m as controlValuesToComponentBindingsById, p as controlValuesToComponentBindings, r as getControlDefaults, rt as isRecord, u as useControlWorkspace, w as controlsToViewItems } from "./useControlSchema-vLiRPUmj.js";
-import { t as useExperimentStore } from "./experiment-CVDRAnqp.js";
-import { B as toBioTemplateComponentProps, F as getBioTemplateComponentProps$1, H as toBioTemplateComponentPropsById, Jt as getBioTemplatePresetInfo, L as toBioTemplateComponentBindings, P as getBioTemplateComponentBindings, Qt as getBioTemplatePackInfo, R as toBioTemplateComponentBindingsById, U as toBioTemplateComponentSnippets, V as toBioTemplateComponentPropsByComponent$1, W as toBioTemplateComponentUsage, bn as rowLabel, d as createBioTemplatePresetCollectionFromControls, dn as extractTemplateCollection, i as createBioTemplateControlToolkit, p as createBioTemplatePackCollection, pn as PLATE_CONFIGS, sn as createTemplateCollection, u as createBioTemplatePresetCollection, un as ensureTemplateFromCollection, wn as deriveShade, xn as SAMPLE_COLOR_SCALE, z as toBioTemplateComponentImports } from "./templates-NuaNHohp.js";
+import { o as useSettingsStore } from "./settings-BLr8lzw6.js";
+import { d as resolveExperimentCode, o as datePresetToISO } from "./experiment-utils-DTANyVKV.js";
+import { $t as getBioTemplatePackInfo, An as getControlDefaults, B as toBioTemplateComponentProps, Bn as getDefaultControlView, Er as PLUGIN_SECRET_FORMAT_KEY, F as getBioTemplateComponentProps$1, Gn as getFieldRegistryEntry, H as toBioTemplateComponentPropsById, Hn as omitUndefined, Kn as getTypeDefault, L as toBioTemplateComponentBindings, P as getBioTemplateComponentBindings, R as toBioTemplateComponentBindingsById, Tn as deriveShade, U as toBioTemplateComponentSnippets, Un as recordValue, V as toBioTemplateComponentPropsByComponent$1, Vn as normalizeControlDefinition, W as toBioTemplateComponentUsage, Wn as replaceRecord$1, Yn as useConcentrationUnits, Yt as getBioTemplatePresetInfo, ar as getInjectedPlatformContext, bn as rowIndex, br as isRecord, cn as createTemplateCollection, d as createBioTemplatePresetCollectionFromControls, dn as ensureTemplateFromCollection, fn as extractTemplateCollection, fr as isActiveJobStatus, gr as normalizeJobState, i as createBioTemplateControlToolkit, ir as currentExperimentFromContext, jn as useControlSchema, mn as PLATE_CONFIGS, or as parseExperimentId, p as createBioTemplatePackCollection, sr as resolveCurrentExperimentId, u as createBioTemplatePresetCollection, vr as useEventStream, xn as rowLabel, z as toBioTemplateComponentImports, zn as controlsToViewItems } from "./templates-BU1pet28.js";
+import { a as useApi, i as authenticationRequiredError, n as readErrorMessage, o as useAuthStore, r as AuthenticationRequiredError, t as useExperimentStore } from "./experiment-DgllIc3I.js";
 import { computed, effectScope, getCurrentScope, inject, nextTick, onMounted, onScopeDispose, onUnmounted, provide, reactive, readonly, ref, shallowRef, toRaw, toValue, unref, watch } from "vue";
 //#region src/composables/useRovingFocus.ts
 /**
@@ -49,66 +47,6 @@ function useRovingFocus(options) {
 	return { handleKeydown };
 }
 //#endregion
-//#region src/composables/useMenuKeyboard.ts
-/**
-* Shared keyboard contract for menu- and listbox-style disclosure panels (the
-* WAI-ARIA menu button pattern). Used by ActionMenu, AppAvatarMenu and DropdownButton,
-* each pairing it with `useDropdownState` for the disclosure state itself.
-*/
-function useMenuKeyboard(options) {
-	function focusItem(position) {
-		nextTick(() => {
-			const items = options.items();
-			(position === "first" ? items[0] : items[items.length - 1])?.focus();
-		});
-	}
-	function handleTriggerKeydown(event) {
-		if (options.isOpen()) return;
-		if (event.key === "ArrowDown" || event.key === "Enter" || event.key === " ") {
-			event.preventDefault();
-			options.open();
-			focusItem("first");
-			return;
-		}
-		if (event.key === "ArrowUp") {
-			event.preventDefault();
-			options.open();
-			focusItem("last");
-		}
-	}
-	function handlePanelKeydown(event) {
-		const items = options.items();
-		const currentIndex = items.indexOf(document.activeElement);
-		if (event.key === "Escape") {
-			event.preventDefault();
-			options.close(true);
-			return;
-		}
-		if (event.key === "Tab") {
-			options.close();
-			return;
-		}
-		if (event.key === "Home") {
-			event.preventDefault();
-			items[0]?.focus();
-			return;
-		}
-		if (event.key === "End") {
-			event.preventDefault();
-			items[items.length - 1]?.focus();
-			return;
-		}
-		if (event.key !== "ArrowDown" && event.key !== "ArrowUp") return;
-		event.preventDefault();
-		const direction = event.key === "ArrowDown" ? 1 : -1;
-		items[(Math.max(currentIndex, 0) + direction + items.length) % items.length]?.focus();
-	}
-	return {
-		handleTriggerKeydown,
-		handlePanelKeydown
-	};
-}
-//#endregion
 //#region src/composables/useSortedItems.ts
 /** Shared sorting for SDK tables and lists with stable empty-value handling. */
 function useSortedItems(options) {
@@ -264,6 +202,221 @@ function useTheme() {
 	};
 }
 //#endregion
+//#region src/composables/usePlatformContext.ts
+var DEFAULT_CONTEXT = {
+	isIntegrated: false,
+	theme: "system"
+};
+var platformContext = ref({ ...DEFAULT_CONTEXT });
+var inferredOrigins = /* @__PURE__ */ new Set();
+var allowedOrigins = /* @__PURE__ */ new Set();
+var allowAnyOrigin = false;
+var initialized = false;
+var listenerCount = 0;
+var nextConsumerId = 0;
+var currentHandler = null;
+var consumerOrigins = /* @__PURE__ */ new Map();
+var allowAnyOriginConsumers = /* @__PURE__ */ new Set();
+/**
+* Derive origin from URL (protocol + host)
+*/
+function getOriginFromUrl(url) {
+	try {
+		return new URL(url).origin;
+	} catch {
+		return null;
+	}
+}
+function normalizeAllowedOrigins(origins) {
+	const normalized = /* @__PURE__ */ new Set();
+	if (!origins) return normalized;
+	for (const origin of origins) normalized.add(getOriginFromUrl(origin) || origin);
+	return normalized;
+}
+function recomputeOriginPolicy() {
+	allowedOrigins = new Set(inferredOrigins);
+	for (const origins of consumerOrigins.values()) for (const origin of origins) allowedOrigins.add(origin);
+	allowAnyOrigin = allowAnyOriginConsumers.size > 0;
+}
+function resetPlatformContextState() {
+	inferredOrigins = /* @__PURE__ */ new Set();
+	allowedOrigins = /* @__PURE__ */ new Set();
+	allowAnyOrigin = false;
+	initialized = false;
+	listenerCount = 0;
+	currentHandler = null;
+	consumerOrigins.clear();
+	allowAnyOriginConsumers.clear();
+	platformContext.value = { ...DEFAULT_CONTEXT };
+}
+/**
+* Check if an origin is allowed for postMessage communication
+*/
+function isOriginAllowed(origin) {
+	if (allowAnyOrigin) {
+		console.warn("[MINT SDK] postMessage origin validation disabled - only use in development");
+		return true;
+	}
+	if (origin === window.location.origin) return true;
+	return allowedOrigins.has(origin);
+}
+/**
+* Platform context composable for plugin integration with MINT Platform.
+*
+* Provides secure communication with the parent platform via postMessage.
+*
+* @param options - Configuration options
+* @param options.allowedOrigins - List of allowed origins for postMessage
+* @param options.allowAnyOrigin - Allow any origin (UNSAFE, development only)
+*
+* @example
+* ```typescript
+* // Basic usage - derives origin from platform injection
+* const { isIntegrated, user, theme } = usePlatformContext()
+*
+* // With explicit allowed origins
+* const { isIntegrated } = usePlatformContext({
+*   allowedOrigins: ['https://mint.example.com']
+* })
+*
+* // Development mode (UNSAFE)
+* const { isIntegrated } = usePlatformContext({
+*   allowAnyOrigin: import.meta.env.DEV
+* })
+* ```
+*/
+/** Connects a plugin to the MINT platform via postMessage, exposing user, theme, and experiment context. */
+function usePlatformContext(options = {}) {
+	const consumerId = ++nextConsumerId;
+	const instanceOrigins = normalizeAllowedOrigins(options.allowedOrigins);
+	const instanceAllowAnyOrigin = options.allowAnyOrigin === true;
+	function detectPlatform() {
+		const detectedOrigins = /* @__PURE__ */ new Set();
+		const platformData = window.__MINT_PLATFORM__;
+		if (platformData) {
+			platformContext.value = {
+				...platformData,
+				isIntegrated: true
+			};
+			if (platformData.platformOrigin) detectedOrigins.add(platformData.platformOrigin);
+			else if (platformData.platformApiUrl) {
+				const origin = getOriginFromUrl(platformData.platformApiUrl);
+				if (origin) detectedOrigins.add(origin);
+			}
+		} else {
+			const urlParams = new URLSearchParams(window.location.search);
+			const hasPluginParam = urlParams.has("mint-plugin");
+			const platformOrigin = urlParams.get("mint-origin");
+			if (platformOrigin) {
+				const origin = getOriginFromUrl(platformOrigin);
+				if (origin) detectedOrigins.add(origin);
+			}
+			platformContext.value = {
+				isIntegrated: hasPluginParam,
+				theme: (() => {
+					try {
+						const s = localStorage.getItem("mint-settings");
+						if (s) return JSON.parse(s).theme || "system";
+					} catch {}
+					return "system";
+				})(),
+				platformOrigin: platformOrigin || void 0
+			};
+		}
+		inferredOrigins = detectedOrigins;
+	}
+	function handlePlatformMessage(event) {
+		if (event.source !== window.parent) return;
+		if (!isOriginAllowed(event.origin)) {
+			console.warn(`[MINT SDK] Rejected postMessage from untrusted origin: ${event.origin}`);
+			return;
+		}
+		try {
+			const platformEvent = event.data;
+			if (!platformEvent.type?.startsWith("mint:")) return;
+			switch (platformEvent.type) {
+				case "mint:theme-changed":
+					platformContext.value.theme = platformEvent.payload;
+					break;
+				case "mint:user-changed": platformContext.value.user = platformEvent.payload;
+			}
+		} catch {}
+	}
+	/**
+	* Send a message to the parent platform.
+	* Uses validated target origin for security.
+	*/
+	function sendToPlatform(event) {
+		if (!platformContext.value.isIntegrated || window.parent === window) return;
+		let targetOrigin;
+		if (platformContext.value.platformOrigin) targetOrigin = platformContext.value.platformOrigin;
+		else if (allowedOrigins.size > 0) targetOrigin = allowedOrigins.values().next().value;
+		else if (allowAnyOrigin) {
+			targetOrigin = "*";
+			console.warn("[MINT SDK] Using wildcard origin for postMessage - only use in development");
+		} else {
+			console.warn("[MINT SDK] Cannot send postMessage: no platform origin configured");
+			return;
+		}
+		window.parent.postMessage(event, targetOrigin);
+	}
+	/**
+	* Request navigation to a path in the platform.
+	*/
+	function navigate(path) {
+		sendToPlatform({
+			type: "mint:navigate",
+			payload: path
+		});
+	}
+	/**
+	* Show a notification in the platform.
+	*/
+	function notify(message, type = "info") {
+		sendToPlatform({
+			type: "mint:notification",
+			payload: {
+				message,
+				type
+			}
+		});
+	}
+	onMounted(() => {
+		consumerOrigins.set(consumerId, instanceOrigins);
+		if (instanceAllowAnyOrigin) allowAnyOriginConsumers.add(consumerId);
+		if (!initialized) {
+			detectPlatform();
+			currentHandler = handlePlatformMessage;
+			window.addEventListener("message", handlePlatformMessage);
+			initialized = true;
+		}
+		listenerCount++;
+		recomputeOriginPolicy();
+	});
+	onUnmounted(() => {
+		consumerOrigins.delete(consumerId);
+		allowAnyOriginConsumers.delete(consumerId);
+		listenerCount = Math.max(0, listenerCount - 1);
+		if (listenerCount === 0) {
+			if (currentHandler) window.removeEventListener("message", currentHandler);
+			resetPlatformContextState();
+			return;
+		}
+		recomputeOriginPolicy();
+	});
+	return {
+		context: platformContext,
+		isIntegrated: computed(() => platformContext.value.isIntegrated),
+		plugin: computed(() => platformContext.value.plugin),
+		user: computed(() => platformContext.value.user),
+		theme: computed(() => platformContext.value.theme),
+		features: computed(() => platformContext.value.features),
+		navigate,
+		notify,
+		sendToPlatform
+	};
+}
+//#endregion
 //#region src/composables/usePresenceHeartbeat.ts
 var PRESENCE_CLIENT_ID_KEY = "mint:presence:client-id";
 var DEFAULT_HEARTBEAT_INTERVAL_MS = 3e4;
@@ -595,137 +748,1082 @@ function useAppExperiment(options = {}) {
 	};
 }
 //#endregion
-//#region src/composables/useMobileSupportGate.ts
-var DEFAULT_MOBILE_VIEWPORT_QUERY = "(max-width: 767px)";
-function useMobileSupportGate(options = {}) {
-	const isMobileViewport = ref(false);
-	const mediaQuery = computed(() => {
-		return unref(options.mediaQuery)?.trim() || "(max-width: 767px)";
-	});
-	const isSupported = computed(() => {
-		if (options.supported === void 0) return true;
-		return Boolean(unref(options.supported));
-	});
-	const shouldShowUnsupported = computed(() => isMobileViewport.value && !isSupported.value);
-	let mediaQueryList = null;
-	let removeMediaListener;
-	const syncMobileState = (event) => {
-		isMobileViewport.value = Boolean(event?.matches ?? mediaQueryList?.matches);
-	};
-	const unbindMediaQuery = () => {
-		removeMediaListener?.();
-		removeMediaListener = void 0;
-		mediaQueryList = null;
+//#region src/composables/controlWorkspaceOptions.ts
+function mergeControlWorkspaceOptions(base, override) {
+	return {
+		...base ?? {},
+		...override ?? {},
+		initialValues: {
+			...base?.initialValues ?? {},
+			...override?.initialValues ?? {}
+		},
+		topBarSettings: {
+			...base?.topBarSettings ?? {},
+			...override?.topBarSettings ?? {}
+		}
 	};
-	const bindMediaQuery = () => {
-		unbindMediaQuery();
-		if (typeof window === "undefined" || typeof window.matchMedia !== "function") {
-			isMobileViewport.value = false;
-			return;
+}
+//#endregion
+//#region src/composables/controlComponentBindings.ts
+/** Map control workspace values into component props for direct `v-bind` usage. */
+function controlValuesToComponentProps(values, mapping) {
+	if (mapping === void 0) return { ...values };
+	if (Array.isArray(mapping)) {
+		const props = {};
+		for (const key of mapping) props[key] = values[key];
+		return props;
+	}
+	const props = {};
+	for (const [prop, source] of Object.entries(mapping)) props[prop] = typeof source === "function" ? source(values) : values[source];
+	return props;
+}
+/** Map control workspace values into named SDK component bindings for direct slot rendering. */
+function controlValuesToComponentBindings(values, bindings) {
+	if (bindings === void 0) return [];
+	return normalizeControlComponentBindingConfigs(bindings).map((binding) => ({
+		id: binding.id,
+		component: binding.component,
+		props: controlValuesToComponentProps(values, binding.props)
+	}));
+}
+/** Map control workspace values into SDK component bindings keyed by binding id. */
+function controlValuesToComponentBindingsById(values, bindings) {
+	return Object.fromEntries(controlValuesToComponentBindings(values, bindings).map((binding) => [binding.id, binding]));
+}
+function normalizeControlComponentBindingConfigs(bindings) {
+	if (Array.isArray(bindings)) {
+		const usedIds = /* @__PURE__ */ new Map();
+		return bindings.map((binding) => ({
+			id: uniqueComponentBindingId(binding.id ?? binding.component, usedIds),
+			component: binding.component,
+			props: binding.props
+		}));
+	}
+	return Object.entries(bindings).map(([id, binding]) => ({
+		id,
+		component: binding.component,
+		props: binding.props
+	}));
+}
+function uniqueComponentBindingId(id, usedIds) {
+	const count = usedIds.get(id) ?? 0;
+	usedIds.set(id, count + 1);
+	return count === 0 ? id : `${id}-${count + 1}`;
+}
+//#endregion
+//#region src/composables/controlSchemaModel.ts
+function isControlModelBinding(model) {
+	return typeof model === "object" && model !== null && "controls" in model && "controlOptions" in model;
+}
+function resolveControlModel(model) {
+	if (model === void 0) return void 0;
+	return isControlModelBinding(model) ? model : defineControlModel(model);
+}
+/**
+* Create a complete workspace component binding from a simple controls data model for ControlWorkspaceView, generated forms, and sidebars.
+*
+* @example Recommended
+* ```ts
+* const workspaceModel = defineControlModel({
+*   controls: { threshold: { type: 'number', default: 0.05 } },
+* })
+* ```
+*/
+function defineControlModel(model) {
+	const { controls: rootControls, sections: rootSections, views: modelViews, components, componentBindings, componentProps, componentPropsById, ...baseOptions } = model;
+	const resolvedComponentBindings = componentBindings ?? components;
+	const controls = {};
+	const views = {};
+	const sections = {};
+	const defaultViewId = model.view ?? "default";
+	const defaultSectionId = model.section ?? "controls";
+	if (rootControls) {
+		registerSectionOptions(sections, defaultSectionId, {
+			id: defaultSectionId,
+			label: model.sectionLabel,
+			title: model.sectionLabel,
+			columns: model.columns
+		});
+		appendModelControls(controls, rootControls, defaultViewId, defaultSectionId);
+	}
+	for (const [sectionId, section] of Object.entries(rootSections ?? {})) {
+		registerSectionOptions(sections, sectionId, controlModelSectionOptions(section));
+		appendModelControls(controls, section.controls, defaultViewId, sectionId, section.sidebar);
+	}
+	for (const [viewId, view] of Object.entries(modelViews ?? {})) {
+		const { controls: viewControls, sections: viewSections, section, sectionLabel, sectionDescription, ...viewConfig } = view;
+		views[viewId] = omitUndefined(viewConfig);
+		if (viewControls) {
+			const sectionId = section ?? `${viewId}-controls`;
+			const label = sectionLabel ?? view.label;
+			registerSectionOptions(sections, sectionId, {
+				id: sectionId,
+				label,
+				title: label,
+				description: sectionDescription,
+				columns: model.columns
+			});
+			appendModelControls(controls, viewControls, viewId, sectionId);
 		}
-		const queryList = window.matchMedia(mediaQuery.value);
-		mediaQueryList = queryList;
-		syncMobileState(queryList);
-		const handleChange = (event) => syncMobileState(event);
-		if (typeof queryList.addEventListener === "function") {
-			queryList.addEventListener("change", handleChange);
-			removeMediaListener = () => queryList.removeEventListener("change", handleChange);
-			return;
+		for (const [sectionKey, sectionConfig] of Object.entries(viewSections ?? {})) {
+			const sectionId = sectionConfig.id ?? `${viewId}-${sectionKey}`;
+			registerSectionOptions(sections, sectionId, controlModelSectionOptions(sectionConfig));
+			appendModelControls(controls, sectionConfig.controls, viewId, sectionId, sectionConfig.sidebar);
 		}
-		queryList.addListener(handleChange);
-		removeMediaListener = () => queryList.removeListener(handleChange);
-	};
-	onMounted(bindMediaQuery);
-	watch(mediaQuery, bindMediaQuery, { flush: "post" });
-	onUnmounted(unbindMediaQuery);
+	}
+	const controlOptions = { ...baseOptions };
+	if (Object.keys(views).length > 0) controlOptions.views = views;
+	if (Object.keys(sections).length > 0) controlOptions.sections = sections;
 	return {
-		isMobileViewport,
-		isSupported,
-		shouldShowUnsupported
+		controls,
+		controlOptions,
+		...resolvedComponentBindings === void 0 ? {} : { componentBindings: resolvedComponentBindings },
+		...componentProps === void 0 ? {} : { componentProps },
+		...componentPropsById === void 0 ? {} : { componentPropsById }
 	};
 }
+function appendModelControls(target, source, viewId, sectionId, sidebar) {
+	for (const [name, input] of Object.entries(source)) {
+		if (Object.prototype.hasOwnProperty.call(target, name)) throw new Error(`Duplicate control "${name}" in defineControlModel(). Control names must be unique across views and sections.`);
+		const definition = normalizeControlDefinition(input);
+		target[name] = omitUndefined({
+			...definition,
+			view: definition.view ?? viewId,
+			section: definition.section ?? sectionId,
+			sidebar: definition.sidebar ?? sidebar
+		});
+	}
+}
+function controlModelSectionOptions(section) {
+	const { controls: _controls, sidebar: _sidebar, ...options } = section;
+	return omitUndefined(options);
+}
+function registerSectionOptions(target, sectionId, options) {
+	target[sectionId] = omitUndefined({
+		...target[sectionId] ?? {},
+		...options,
+		id: sectionId
+	});
+}
 //#endregion
-//#region src/components/PluginWorkspaceView.controls.ts
-function usePluginWorkspaceControls(options) {
-	const resolvedModel = computed(() => resolveControlModel(options.model()));
-	const resolvedControls = computed(() => options.controls() ?? resolvedModel.value?.controls);
-	const resolvedControlOptions = computed(() => mergeControlWorkspaceOptions(resolvedModel.value?.controlOptions ?? {}, options.controlOptions()));
-	const externalControlValues = computed(() => options.modelValue() ?? options.values());
-	const internalControlValues = reactive({});
-	let syncingControlValues = false;
-	const generatedControlDefaults = computed(() => {
-		if (!resolvedControls.value) return {};
-		return {
-			...getControlDefaults(resolvedControls.value),
-			...resolvedControlOptions.value.initialValues ?? {}
-		};
+//#region src/composables/useControlWorkspace.ts
+/**
+* Prepare shared reactive values plus AppTopBar/AppSidebar/FormBuilder bindings from one simple controls data model.
+*
+* @example Recommended
+* ```ts
+* const workspace = useControlWorkspace(workspaceModel)
+* const { form, sidebar, topBar } = workspace.bindings
+* ```
+*/
+function useControlWorkspace(controlsOrModel, options = {}) {
+	const model = isControlModelBinding(controlsOrModel) ? controlsOrModel : void 0;
+	const controls = model ? model.controls : controlsOrModel;
+	const { initialValues, topBarSettings, ...schemaOptions } = model ? mergeControlWorkspaceOptions(model.controlOptions, options) : options;
+	const schema = useControlSchema(controls, schemaOptions);
+	const activeView = ref(schema.defaultView);
+	const values = reactive({
+		...schema.initialValues,
+		...initialValues ?? {}
 	});
-	function replaceControlValues(values) {
-		for (const key of Object.keys(internalControlValues)) if (!(key in values)) delete internalControlValues[key];
-		Object.assign(internalControlValues, values);
+	function setActiveView(viewId) {
+		syncActiveView(viewId);
 	}
-	function emitControlValues() {
-		options.emitValues({ ...internalControlValues });
+	function syncActiveView(viewId) {
+		if (!schema.viewIds.includes(viewId)) return;
+		if (activeView.value !== viewId) activeView.value = viewId;
+		if (sidebar.activeView !== viewId) sidebar.activeView = viewId;
+		if (pillNav.currentItemId !== viewId) pillNav.currentItemId = viewId;
 	}
-	function syncResolvedControlValues() {
-		syncingControlValues = true;
-		replaceControlValues({
-			...generatedControlDefaults.value,
-			...externalControlValues.value === void 0 ? internalControlValues : externalControlValues.value
-		});
-		syncingControlValues = false;
+	function setValues(nextValues) {
+		Object.assign(values, nextValues);
 	}
-	function handleControlValuesUpdate(values) {
-		syncingControlValues = true;
-		replaceControlValues({
-			...generatedControlDefaults.value,
-			...values
+	function resetValues(nextValues = {}) {
+		replaceRecord$1(values, {
+			...schema.initialValues,
+			...nextValues
 		});
-		syncingControlValues = false;
-		emitControlValues();
 	}
-	const resolvedComponentBindings = computed(() => controlValuesToComponentBindings(internalControlValues, options.componentBindings() ?? resolvedModel.value?.componentBindings));
-	const resolvedComponentBindingsById = computed(() => controlValuesToComponentBindingsById(internalControlValues, options.componentBindings() ?? resolvedModel.value?.componentBindings));
-	const resolvedComponentProps = computed(() => {
-		const mapping = options.componentProps() ?? resolvedModel.value?.componentProps;
-		return mapping === void 0 ? {} : controlValuesToComponentProps(internalControlValues, mapping);
-	});
-	const resolvedComponentPropsById = computed(() => {
-		const mappings = options.componentPropsById() ?? resolvedModel.value?.componentPropsById;
+	function getComponentProps(mapping) {
+		return controlValuesToComponentProps(values, mapping);
+	}
+	function getComponentPropsById(mappings) {
 		if (mappings === void 0) return {};
-		return Object.fromEntries(Object.entries(mappings).map(([id, mapping]) => [id, controlValuesToComponentProps(internalControlValues, mapping)]));
-	});
-	const generatedPillNav = computed(() => {
-		if (!resolvedControls.value) return [];
-		return controlsToViewItems(resolvedControls.value, resolvedControlOptions.value);
-	});
-	const generatedDefaultView = computed(() => {
-		if (!resolvedControls.value) return "";
-		return getDefaultControlView(resolvedControls.value, resolvedControlOptions.value);
+		return Object.fromEntries(Object.entries(mappings).map(([id, mapping]) => [id, controlValuesToComponentProps(values, mapping)]));
+	}
+	function getComponentBindings(bindings) {
+		return controlValuesToComponentBindings(values, bindings);
+	}
+	function getComponentBindingsById(bindings) {
+		return controlValuesToComponentBindingsById(values, bindings);
+	}
+	const componentProps = computed(() => model?.componentProps === void 0 ? {} : getComponentProps(model.componentProps));
+	const componentPropsById = computed(() => getComponentPropsById(model?.componentPropsById));
+	const componentBindings = computed(() => getComponentBindings(model?.componentBindings));
+	const componentBindingsById = computed(() => getComponentBindingsById(model?.componentBindings));
+	const form = {
+		...schema.form,
+		modelValue: values,
+		"onUpdate:modelValue": setValues
+	};
+	const topBarSettingsConfig = {
+		...schema.topBarSettingsConfig,
+		...topBarSettings ?? {},
+		values
+	};
+	const sidebar = reactive({
+		...schema.sidebar,
+		activeView: activeView.value,
+		modelValue: values,
+		"onUpdate:modelValue": setValues,
+		values,
+		"onUpdate:values": setValues
 	});
-	syncResolvedControlValues();
-	watch([generatedControlDefaults, externalControlValues], syncResolvedControlValues, { deep: true });
-	watch(internalControlValues, () => {
-		if (syncingControlValues) return;
-		emitControlValues();
-	}, {
-		deep: true,
-		flush: "sync"
+	const pillNav = reactive({
+		items: schema.viewItems,
+		currentItemId: activeView.value,
+		onSelect: (item) => setActiveView(item.id)
 	});
-	return {
-		resolvedModel,
-		resolvedControls,
-		resolvedControlOptions,
-		generatedPillNav,
-		generatedDefaultView,
-		internalControlValues,
-		resolvedComponentBindings,
-		resolvedComponentBindingsById,
-		resolvedComponentProps,
-		resolvedComponentPropsById,
-		handleControlValuesUpdate
+	const topBarSettingsBinding = {
+		showSettings: true,
+		settingsConfig: topBarSettingsConfig,
+		onSettingsValuesChange: setValues
 	};
-}
+	const topBarProps = computed(() => ({
+		pillNav: pillNav.items,
+		currentPillId: pillNav.currentItemId,
+		onPillSelect: pillNav.onSelect,
+		...topBarSettingsBinding
+	}));
+	const bindings = {
+		form,
+		sidebar,
+		topBar: topBarProps,
+		topBarSettings: topBarSettingsBinding,
+		pillNav,
+		componentBindings,
+		componentBindingsById,
+		componentProps,
+		componentPropsById
+	};
+	watch(activeView, syncActiveView, { flush: "sync" });
+	watch(() => sidebar.activeView, syncActiveView, { flush: "sync" });
+	watch(() => pillNav.currentItemId, syncActiveView, { flush: "sync" });
+	return {
+		...schema,
+		schema,
+		values,
+		activeView,
+		topBarSettingsConfig,
+		form,
+		sidebar,
+		topBar: topBarProps,
+		pillNav,
+		topBarSettings: topBarSettingsBinding,
+		bindings,
+		componentBindings,
+		componentBindingsById,
+		componentProps,
+		componentPropsById,
+		setActiveView,
+		setValues,
+		resetValues,
+		getComponentProps,
+		getComponentPropsById,
+		getComponentBindings,
+		getComponentBindingsById
+	};
+}
+//#endregion
+//#region src/composables/controlSchemaDoseDesign.ts
+/** Return a default WellPlate prop mapping for generated control workspaces. */
+function defineWellPlateControlProps(options = {}) {
+	const selectedWells = options.selectedWells ?? sourceKey("selectedWells");
+	return compactComponentPropsMap({
+		modelValue: selectedWells,
+		"onUpdate:modelValue": options.onUpdateModelValue === false ? void 0 : options.onUpdateModelValue ?? updateControlValueSource(selectedWells),
+		format: options.format ?? sourceKey("plateFormat"),
+		wells: options.wells ?? sourceKey("wells"),
+		disabled: options.disabled ?? sourceKey("disabled"),
+		readonly: options.readonly ?? sourceKey("readonly"),
+		showLegend: options.showLegend,
+		showSampleTypeIndicator: options.showSampleTypeIndicator
+	});
+}
+/** Return a default DoseCalculator prop mapping for generated control workspaces. */
+function defineDoseCalculatorControlProps(options = {}) {
+	const targetWells = options.targetWells ?? sourceKey("selectedWells");
+	const wells = options.wells ?? sourceKey("wells");
+	const onApplyToWells = options.onApplyToWells === false ? void 0 : options.onApplyToWells ?? defaultDoseApplyHandler(wells, targetWells);
+	return compactComponentPropsMap({
+		mode: options.mode ?? sourceKey("doseMode"),
+		targetWells,
+		disabled: options.disabled ?? sourceKey("disabled"),
+		molecularWeight: options.molecularWeight,
+		onApplyToWells
+	});
+}
+/** Return named WellPlate + DoseCalculator prop mappings for one dose-design control model. */
+function defineWellPlateDoseControlProps(options = {}) {
+	return {
+		[options.plateId ?? "plate"]: defineWellPlateControlProps(options.plate),
+		[options.doseId ?? "dose"]: defineDoseCalculatorControlProps(options.dose)
+	};
+}
+/** Return named WellPlate + DoseCalculator component bindings for one dose-design control model. */
+function defineWellPlateDoseComponentBindings(options = {}) {
+	return [{
+		id: options.plateId ?? "plate",
+		component: "WellPlate",
+		props: defineWellPlateControlProps(options.plate)
+	}, {
+		id: options.doseId ?? "dose",
+		component: "DoseCalculator",
+		props: defineDoseCalculatorControlProps(options.dose)
+	}];
+}
+/**
+* Return a complete ControlWorkspaceView model for WellPlate + DoseCalculator dose design.
+*
+* @example Recommended
+* ```ts
+* const workspaceModel = defineDoseDesignControlModel({ selectedWells: ['A1', 'A2'] })
+* ```
+*/
+function defineDoseDesignControlModel(options = {}) {
+	const viewId = options.viewId ?? "design";
+	const sectionId = options.sectionId ?? "dose";
+	const doseControls = {
+		selectedWells: {
+			type: "tags",
+			label: "Selected wells",
+			default: [...options.selectedWells ?? ["A1", "A2"]]
+		},
+		plateFormat: {
+			label: "Plate format",
+			default: options.plateFormat ?? 96,
+			options: options.plateFormats ?? [96, 384]
+		},
+		doseMode: {
+			label: "Dose mode",
+			default: options.doseMode ?? "serial",
+			options: options.doseModes ?? [
+				"serial",
+				"dilution",
+				"conversion"
+			]
+		},
+		disabled: {
+			label: "Disable tools",
+			default: options.disabled ?? false
+		}
+	};
+	if (options.includeMolecularWeight) doseControls.molecularWeight = {
+		type: "number",
+		label: "Molecular weight",
+		default: options.molecularWeight ?? 300,
+		min: 0
+	};
+	const componentProps = {
+		...options.componentProps,
+		dose: {
+			...options.componentProps?.dose ?? {},
+			...options.includeMolecularWeight && options.componentProps?.dose?.molecularWeight === void 0 ? { molecularWeight: "molecularWeight" } : {}
+		}
+	};
+	return defineControlModel({
+		componentBindings: defineWellPlateDoseComponentBindings(componentProps),
+		componentPropsById: defineWellPlateDoseControlProps(componentProps),
+		views: { [viewId]: {
+			label: options.viewLabel ?? "Design",
+			sections: { [sectionId]: {
+				label: options.sectionLabel ?? "Dose design",
+				description: options.sectionDescription ?? "Well selection and dose calculator controls",
+				controls: doseControls
+			} }
+		} }
+	});
+}
+function compactComponentPropsMap(mapping) {
+	return Object.fromEntries(Object.entries(mapping).filter((entry) => entry[1] !== void 0));
+}
+function sourceKey(key) {
+	return key;
+}
+function updateControlValueSource(source) {
+	if (typeof source !== "string") return void 0;
+	return (values) => (value) => {
+		const writableValues = values;
+		writableValues[source] = value;
+	};
+}
+function defaultDoseApplyHandler(wells, targetWells) {
+	if (wells === targetWells) return void 0;
+	return updateWellsFromDoseResults(wells);
+}
+function updateWellsFromDoseResults(source) {
+	if (typeof source !== "string") return void 0;
+	return (values) => (results) => {
+		const writableValues = values;
+		const currentWells = recordValue(writableValues[source]);
+		const nextWells = {};
+		for (const [wellId, well] of Object.entries(currentWells)) nextWells[wellId] = recordValue(well);
+		for (const result of results) {
+			const existing = recordValue(nextWells[result.wellId]);
+			const metadata = recordValue(existing.metadata);
+			nextWells[result.wellId] = {
+				...existing,
+				state: "filled",
+				value: result.concentration.value,
+				metadata: {
+					...metadata,
+					concentration: result.concentration,
+					...result.volume === void 0 ? {} : { volume: result.volume }
+				}
+			};
+		}
+		writableValues[source] = nextWells;
+	};
+}
+//#endregion
+//#region src/composables/useFormValidation.ts
+var validators = {
+	required: (value, message = "This field is required") => {
+		if (value === null || value === void 0 || value === "") return message;
+		if (Array.isArray(value) && value.length === 0) return message;
+		return null;
+	},
+	minLength: (value, min, message) => {
+		if (typeof value !== "string") return null;
+		if (value.length < min) return message || `Must be at least ${min} characters`;
+		return null;
+	},
+	maxLength: (value, max, message) => {
+		if (typeof value !== "string") return null;
+		if (value.length > max) return message || `Must be at most ${max} characters`;
+		return null;
+	},
+	min: (value, min, message) => {
+		if (typeof value !== "number") return null;
+		if (value < min) return message || `Must be at least ${min}`;
+		return null;
+	},
+	max: (value, max, message) => {
+		if (typeof value !== "number") return null;
+		if (value > max) return message || `Must be at most ${max}`;
+		return null;
+	},
+	pattern: (value, pattern, message) => {
+		if (typeof value !== "string") return null;
+		if (!pattern.test(value)) return message || "Invalid format";
+		return null;
+	},
+	email: (value, message = "Invalid email address") => {
+		if (typeof value !== "string" || !value) return null;
+		if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) return message;
+		return null;
+	}
+};
+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.
+*
+* @param initialValues - Initial form values
+* @param rules - Validation rules for each field
+*
+* @example
+* ```typescript
+* const { data, errors, isValid, handleSubmit, getFieldProps } = useForm(
+*   { email: '', password: '' },
+*   {
+*     email: { required: true, email: true },
+*     password: { required: true, minLength: 8 },
+*   }
+* )
+*
+* // In template
+* <BaseInput v-bind="getFieldProps('email')" label="Email" />
+* <BaseInput v-bind="getFieldProps('password')" type="password" label="Password" />
+* <BaseButton @click="handleSubmit(onSubmit)" :disabled="!isValid">Submit</BaseButton>
+* ```
+*/
+/** Reactive form state with field-level validation, dirty tracking, and submit handling. */
+function useForm(initialValues, rules = {}) {
+	const cloneableInitialValues = deepToRaw(initialValues);
+	let _initialValues = structuredClone(cloneableInitialValues);
+	const data = reactive(structuredClone(cloneableInitialValues));
+	const errors = reactive(Object.keys(initialValues).reduce((acc, key) => {
+		acc[key] = null;
+		return acc;
+	}, {}));
+	const touched = reactive(Object.keys(initialValues).reduce((acc, key) => {
+		acc[key] = false;
+		return acc;
+	}, {}));
+	const dirty = reactive(Object.keys(initialValues).reduce((acc, key) => {
+		acc[key] = false;
+		return acc;
+	}, {}));
+	const isSubmitting = ref(false);
+	watch(() => ({ ...data }), (newData) => {
+		for (const key of Object.keys(newData)) dirty[key] = newData[key] !== _initialValues[key];
+	}, { deep: true });
+	function validateField(field) {
+		const value = data[field];
+		const fieldRules = rules[field];
+		const error = validateFieldValue(value, fieldRules, data);
+		errors[field] = error;
+		return error === null;
+	}
+	function validate() {
+		let isAllValid = true;
+		for (const field of Object.keys(data)) if (!validateField(field)) isAllValid = false;
+		return isAllValid;
+	}
+	const isValid = computed(() => {
+		return Object.values(errors).every((error) => error === null);
+	});
+	const isDirty = computed(() => {
+		return Object.values(dirty).some((d) => d);
+	});
+	function setFieldValue(field, value) {
+		data[field] = value;
+		if (touched[field]) validateField(field);
+	}
+	function setFieldError(field, error) {
+		errors[field] = error;
+	}
+	function setFieldTouched(field, isTouched = true) {
+		touched[field] = isTouched;
+		if (isTouched) validateField(field);
+	}
+	function reset(values) {
+		const resetValues = values ? {
+			..._initialValues,
+			...values
+		} : _initialValues;
+		for (const key of Object.keys(data)) {
+			data[key] = structuredClone(deepToRaw(resetValues[key]));
+			errors[key] = null;
+			touched[key] = false;
+			dirty[key] = false;
+		}
+	}
+	function replaceState(values) {
+		const nextValues = structuredClone(deepToRaw(values));
+		_initialValues = structuredClone(nextValues);
+		for (const key of Object.keys(data)) {
+			if (key in nextValues) continue;
+			delete data[key];
+			delete errors[key];
+			delete touched[key];
+			delete dirty[key];
+		}
+		for (const key of Object.keys(nextValues)) {
+			data[key] = structuredClone(deepToRaw(nextValues[key]));
+			errors[key] = null;
+			touched[key] = false;
+			dirty[key] = false;
+		}
+	}
+	function handleSubmit(onSubmit) {
+		return async (e) => {
+			e?.preventDefault();
+			for (const field of Object.keys(data)) touched[field] = true;
+			if (!validate()) return;
+			isSubmitting.value = true;
+			try {
+				await onSubmit(data);
+			} finally {
+				isSubmitting.value = false;
+			}
+		};
+	}
+	function getFieldProps(field) {
+		const fieldStr = field;
+		return {
+			modelValue: data[field],
+			"onUpdate:modelValue": (value) => setFieldValue(field, value),
+			onBlur: () => setFieldTouched(fieldStr),
+			error: touched[fieldStr] ? errors[fieldStr] : null
+		};
+	}
+	return {
+		data,
+		errors,
+		touched,
+		dirty,
+		isValid,
+		isDirty,
+		isSubmitting,
+		setFieldValue,
+		setFieldError,
+		setFieldTouched,
+		validateField,
+		validate,
+		reset,
+		replaceState,
+		handleSubmit,
+		getFieldProps
+	};
+}
+function deepToRaw(value) {
+	const raw = toRaw(value);
+	if (Array.isArray(raw)) return raw.map((item) => deepToRaw(item));
+	if (isPlainRecord(raw)) return Object.fromEntries(Object.entries(raw).map(([key, item]) => [key, deepToRaw(item)]));
+	return raw;
+}
+function isPlainRecord(value) {
+	return Object.prototype.toString.call(value) === "[object Object]";
+}
+//#endregion
+//#region src/composables/formBuilderSchema.ts
+/**
+* Evaluate a JSON-serializable field condition against the current form data.
+*
+* Supports logical operators (`and`, `or`, `not`) and comparison operators
+* (`eq`, `neq`, `gt`, `lt`, `gte`, `lte`, `in`, `notIn`, `truthy`, `falsy`,
+* `contains`). Returns `true` if the condition passes.
+*/
+function evaluateCondition(condition, data) {
+	if ("and" in condition) return condition.and.every((c) => evaluateCondition(c, data));
+	if ("or" in condition) return condition.or.some((c) => evaluateCondition(c, data));
+	if ("not" in condition) return !evaluateCondition(condition.not, data);
+	const value = data[condition.field];
+	if ("eq" in condition) return value === condition.eq;
+	if ("neq" in condition) return value !== condition.neq;
+	if ("gt" in condition) return typeof value === "number" && value > condition.gt;
+	if ("lt" in condition) return typeof value === "number" && value < condition.lt;
+	if ("gte" in condition) return typeof value === "number" && value >= condition.gte;
+	if ("lte" in condition) return typeof value === "number" && value <= condition.lte;
+	if ("in" in condition) return condition.in.includes(value);
+	if ("notIn" in condition) return !condition.notIn.includes(value);
+	if ("truthy" in condition) return !!value;
+	if ("falsy" in condition) return !value;
+	if ("contains" in condition) {
+		if (typeof value === "string") return value.includes(condition.contains);
+		if (Array.isArray(value)) return value.includes(condition.contains);
+		return false;
+	}
+	return true;
+}
+/** Return all sections across steps (wizard) or directly from a flat schema. */
+function collectSections(schema) {
+	return schema.steps ? schema.steps.flatMap((step) => step.sections) : schema.sections;
+}
+/** Return all field schemas in schema order, flattening sections and steps. */
+function flattenFields(schema) {
+	return collectSections(schema).flatMap((section) => section.fields);
+}
+/** Convert a JSON-safe `FieldValidation` descriptor to a runtime `FieldRules` object. */
+function convertValidation(v) {
+	const rules = {};
+	if (v.required !== void 0) rules.required = v.required;
+	if (v.minLength !== void 0) rules.minLength = v.minLength;
+	if (v.maxLength !== void 0) rules.maxLength = v.maxLength;
+	if (v.min !== void 0) rules.min = v.min;
+	if (v.max !== void 0) rules.max = v.max;
+	if (v.email !== void 0) rules.email = v.email;
+	if (v.pattern !== void 0) rules.pattern = typeof v.pattern === "string" ? new RegExp(v.pattern) : {
+		value: new RegExp(v.pattern.value),
+		message: v.pattern.message
+	};
+	return rules;
+}
+function buildInitialValues(fields, initialData) {
+	const initialValues = {};
+	for (const field of fields) {
+		const key = field.name;
+		if (initialData && hasOwnKey(initialData, key)) initialValues[key] = initialData[key];
+		else if (field.defaultValue !== void 0) initialValues[key] = field.defaultValue;
+		else initialValues[key] = getTypeDefault(field.type);
+	}
+	return initialValues;
+}
+function buildRules(fields, enhancements) {
+	const rules = {};
+	for (const field of fields) {
+		const base = field.validation ? convertValidation(field.validation) : {};
+		const enhancement = enhancements?.fields?.[field.name];
+		const customValidators = [];
+		if (enhancement?.validate) {
+			const fn = enhancement.validate;
+			customValidators.push((value, formData) => fn(value, formData));
+		}
+		if (customValidators.length > 0) base.custom = customValidators;
+		if (Object.keys(base).length > 0) rules[field.name] = base;
+	}
+	return rules;
+}
+function replaceArray(target, values) {
+	target.splice(0, target.length, ...values);
+}
+function replaceRecord(target, source) {
+	for (const key of Object.keys(target)) delete target[key];
+	Object.assign(target, source);
+}
+function hasOwnKey(source, key) {
+	return Object.prototype.hasOwnProperty.call(source, key);
+}
+//#endregion
+//#region src/composables/useFormBuilder.ts
+/**
+* Drive a `FormSchema` as reactive form state.
+*
+* Builds initial values from schema defaults and `initialData`, derives
+* validation rules from `FieldValidation` descriptors and enhancement
+* validators, evaluates `FieldCondition` expressions for field/section
+* visibility, and wires wizard step navigation when `schema.steps` is set.
+*
+* @param schema - Declarative form or wizard schema.
+* @param initialData - Values that override schema defaults.
+* @param enhancements - TypeScript-only callbacks (dynamic options, validators,
+*   submit handler, transform, field-change watcher).
+*/
+/** Drives a declarative FormSchema as reactive state with conditional fields, wizard steps, and validation. */
+function useFormBuilder(schema, initialData, enhancements) {
+	const currentSchema = shallowRef(schema);
+	const fields = reactive(flattenFields(schema));
+	const sections = reactive(collectSections(schema));
+	const rules = reactive(buildRules(fields, enhancements));
+	const form = useForm(buildInitialValues(fields, initialData), rules);
+	function isFieldVisible(name) {
+		const enhancement = enhancements?.fields?.[name];
+		if (enhancement?.visible) return enhancement.visible(form.data);
+		const field = fields.find((f) => f.name === name);
+		if (field?.condition) return evaluateCondition(field.condition, form.data);
+		return true;
+	}
+	function isSectionVisible(id) {
+		const section = sections.find((s) => s.id === id);
+		if (section?.condition) return evaluateCondition(section.condition, form.data);
+		return true;
+	}
+	function getResolvedFieldProps(field) {
+		const entry = getFieldRegistryEntry(field.type);
+		const formProps = form.getFieldProps(field.name);
+		const merged = {
+			...entry.defaults,
+			...field.props ?? {}
+		};
+		const enhancement = enhancements?.fields?.[field.name];
+		if (enhancement?.props) Object.assign(merged, enhancement.props(form.data));
+		const options = getFieldOptions(field.name);
+		if (options) merged.options = options;
+		if (entry.vModel) {
+			merged.modelValue = formProps.modelValue;
+			merged["onUpdate:modelValue"] = formProps["onUpdate:modelValue"];
+		}
+		merged.onBlur = formProps.onBlur;
+		if (formProps.error) merged.error = true;
+		if (field.placeholder) merged.placeholder = field.placeholder;
+		if (field.size) merged.size = field.size;
+		if (field.disabled) merged.disabled = true;
+		if (field.readonly) merged.readonly = true;
+		if (field.type === "radio" && !merged.name) merged.name = field.name;
+		return merged;
+	}
+	function getFieldOptions(name) {
+		const enhancement = enhancements?.fields?.[name];
+		if (enhancement?.options) return enhancement.options(form.data);
+		const field = fields.find((f) => f.name === name);
+		if (field?.props?.options) return field.props.options;
+	}
+	const currentStep = ref(0);
+	const isCurrentStepValid = computed(() => {
+		if (!currentSchema.value.steps) return form.isValid.value;
+		const step = currentSchema.value.steps[currentStep.value];
+		if (!step) return true;
+		for (const section of step.sections) {
+			if (!isSectionVisible(section.id)) continue;
+			for (const field of section.fields) {
+				if (!isFieldVisible(field.name)) continue;
+				if (!form.validateField(field.name)) return false;
+			}
+		}
+		return true;
+	});
+	function goNext() {
+		if (!currentSchema.value.steps) return false;
+		const step = currentSchema.value.steps[currentStep.value];
+		if (!step) return false;
+		let valid = true;
+		for (const section of step.sections) {
+			if (!isSectionVisible(section.id)) continue;
+			for (const field of section.fields) {
+				if (!isFieldVisible(field.name)) continue;
+				form.setFieldTouched(field.name, true);
+				if (!form.validateField(field.name)) valid = false;
+			}
+		}
+		if (!valid) return false;
+		if (currentStep.value < currentSchema.value.steps.length - 1) currentStep.value++;
+		return true;
+	}
+	function goBack() {
+		if (currentStep.value > 0) currentStep.value--;
+	}
+	function goToStep(index) {
+		if (!currentSchema.value.steps) return;
+		if (index >= 0 && index < currentSchema.value.steps.length) currentStep.value = index;
+	}
+	function validate() {
+		let allValid = true;
+		for (const field of fields) {
+			if (!isFieldVisible(field.name)) continue;
+			form.setFieldTouched(field.name, true);
+			if (!form.validateField(field.name)) allValid = false;
+		}
+		return allValid;
+	}
+	async function submit() {
+		if (!validate()) return;
+		let submitData = {};
+		for (const field of fields) if (isFieldVisible(field.name)) submitData[field.name] = form.data[field.name];
+		if (enhancements?.transform) submitData = enhancements.transform(submitData);
+		if (enhancements?.onSubmit) {
+			form.isSubmitting.value = true;
+			try {
+				await enhancements.onSubmit(submitData);
+			} finally {
+				form.isSubmitting.value = false;
+			}
+		}
+	}
+	function reset(values) {
+		form.reset(values);
+		currentStep.value = 0;
+	}
+	function updateSchema(nextSchema, nextData) {
+		currentSchema.value = nextSchema;
+		const nextFields = flattenFields(nextSchema);
+		replaceArray(fields, nextFields);
+		replaceArray(sections, collectSections(nextSchema));
+		replaceRecord(rules, buildRules(nextFields, enhancements));
+		form.replaceState(buildInitialValues(nextFields, nextData));
+		currentStep.value = 0;
+	}
+	if (enhancements?.onFieldChange) {
+		const callback = enhancements.onFieldChange;
+		watch(() => ({ ...form.data }), (newData, oldData) => {
+			if (!oldData) return;
+			for (const key of Object.keys(newData)) if (newData[key] !== oldData[key]) callback(key, newData[key], newData);
+		}, { deep: true });
+	}
+	return {
+		form,
+		rules,
+		isFieldVisible,
+		isSectionVisible,
+		fields,
+		getResolvedFieldProps,
+		getFieldOptions,
+		currentStep,
+		isCurrentStepValid,
+		goNext,
+		goBack,
+		goToStep,
+		validate,
+		reset,
+		submit,
+		updateSchema
+	};
+}
+//#endregion
+//#region src/composables/useMobileSupportGate.ts
+var DEFAULT_MOBILE_VIEWPORT_QUERY = "(max-width: 767px)";
+function useMobileSupportGate(options = {}) {
+	const isMobileViewport = ref(false);
+	const mediaQuery = computed(() => {
+		return unref(options.mediaQuery)?.trim() || "(max-width: 767px)";
+	});
+	const isSupported = computed(() => {
+		if (options.supported === void 0) return true;
+		return Boolean(unref(options.supported));
+	});
+	const shouldShowUnsupported = computed(() => isMobileViewport.value && !isSupported.value);
+	let mediaQueryList = null;
+	let removeMediaListener;
+	const syncMobileState = (event) => {
+		isMobileViewport.value = Boolean(event?.matches ?? mediaQueryList?.matches);
+	};
+	const unbindMediaQuery = () => {
+		removeMediaListener?.();
+		removeMediaListener = void 0;
+		mediaQueryList = null;
+	};
+	const bindMediaQuery = () => {
+		unbindMediaQuery();
+		if (typeof window === "undefined" || typeof window.matchMedia !== "function") {
+			isMobileViewport.value = false;
+			return;
+		}
+		const queryList = window.matchMedia(mediaQuery.value);
+		mediaQueryList = queryList;
+		syncMobileState(queryList);
+		const handleChange = (event) => syncMobileState(event);
+		if (typeof queryList.addEventListener === "function") {
+			queryList.addEventListener("change", handleChange);
+			removeMediaListener = () => queryList.removeEventListener("change", handleChange);
+			return;
+		}
+		queryList.addListener(handleChange);
+		removeMediaListener = () => queryList.removeListener(handleChange);
+	};
+	onMounted(bindMediaQuery);
+	watch(mediaQuery, bindMediaQuery, { flush: "post" });
+	onUnmounted(unbindMediaQuery);
+	return {
+		isMobileViewport,
+		isSupported,
+		shouldShowUnsupported
+	};
+}
+//#endregion
+//#region src/components/PluginWorkspaceView.controls.ts
+function usePluginWorkspaceControls(options) {
+	const resolvedModel = computed(() => resolveControlModel(options.model()));
+	const resolvedControls = computed(() => options.controls() ?? resolvedModel.value?.controls);
+	const resolvedControlOptions = computed(() => mergeControlWorkspaceOptions(resolvedModel.value?.controlOptions ?? {}, options.controlOptions()));
+	const externalControlValues = computed(() => options.modelValue() ?? options.values());
+	const internalControlValues = reactive({});
+	let syncingControlValues = false;
+	const generatedControlDefaults = computed(() => {
+		if (!resolvedControls.value) return {};
+		return {
+			...getControlDefaults(resolvedControls.value),
+			...resolvedControlOptions.value.initialValues ?? {}
+		};
+	});
+	function replaceControlValues(values) {
+		for (const key of Object.keys(internalControlValues)) if (!(key in values)) delete internalControlValues[key];
+		Object.assign(internalControlValues, values);
+	}
+	function emitControlValues() {
+		options.emitValues({ ...internalControlValues });
+	}
+	function syncResolvedControlValues() {
+		syncingControlValues = true;
+		replaceControlValues({
+			...generatedControlDefaults.value,
+			...externalControlValues.value === void 0 ? internalControlValues : externalControlValues.value
+		});
+		syncingControlValues = false;
+	}
+	function handleControlValuesUpdate(values) {
+		syncingControlValues = true;
+		replaceControlValues({
+			...generatedControlDefaults.value,
+			...values
+		});
+		syncingControlValues = false;
+		emitControlValues();
+	}
+	const resolvedComponentBindings = computed(() => controlValuesToComponentBindings(internalControlValues, options.componentBindings() ?? resolvedModel.value?.componentBindings));
+	const resolvedComponentBindingsById = computed(() => controlValuesToComponentBindingsById(internalControlValues, options.componentBindings() ?? resolvedModel.value?.componentBindings));
+	const resolvedComponentProps = computed(() => {
+		const mapping = options.componentProps() ?? resolvedModel.value?.componentProps;
+		return mapping === void 0 ? {} : controlValuesToComponentProps(internalControlValues, mapping);
+	});
+	const resolvedComponentPropsById = computed(() => {
+		const mappings = options.componentPropsById() ?? resolvedModel.value?.componentPropsById;
+		if (mappings === void 0) return {};
+		return Object.fromEntries(Object.entries(mappings).map(([id, mapping]) => [id, controlValuesToComponentProps(internalControlValues, mapping)]));
+	});
+	const generatedPillNav = computed(() => {
+		if (!resolvedControls.value) return [];
+		return controlsToViewItems(resolvedControls.value, resolvedControlOptions.value);
+	});
+	const generatedDefaultView = computed(() => {
+		if (!resolvedControls.value) return "";
+		return getDefaultControlView(resolvedControls.value, resolvedControlOptions.value);
+	});
+	syncResolvedControlValues();
+	watch([generatedControlDefaults, externalControlValues], syncResolvedControlValues, { deep: true });
+	watch(internalControlValues, () => {
+		if (syncingControlValues) return;
+		emitControlValues();
+	}, {
+		deep: true,
+		flush: "sync"
+	});
+	return {
+		resolvedModel,
+		resolvedControls,
+		resolvedControlOptions,
+		generatedPillNav,
+		generatedDefaultView,
+		internalControlValues,
+		resolvedComponentBindings,
+		resolvedComponentBindingsById,
+		resolvedComponentProps,
+		resolvedComponentPropsById,
+		handleControlValuesUpdate
+	};
+}
 //#endregion
 //#region src/components/PluginWorkspaceView.navigation.ts
 function usePluginWorkspaceNavigation(options) {
@@ -773,7 +1871,7 @@ function firstItemId(items) {
 }
 //#endregion
 //#region src/components/PluginWorkspaceView.shell.ts
-var topBarForwardedSlots = new Set([
+var topBarForwardedSlots = /* @__PURE__ */ new Set([
 	"icon",
 	"logo",
 	"page-selector-icon",
@@ -785,7 +1883,7 @@ var topBarForwardedSlots = new Set([
 	"account-menu-item-icon",
 	"settings-appearance"
 ]);
-var sidebarForwardedSlots = new Set([
+var sidebarForwardedSlots = /* @__PURE__ */ new Set([
 	"header",
 	"collapsed",
 	"collapsed-footer",
@@ -835,116 +1933,818 @@ function usePluginWorkspace(options) {
 			emit("update:values", values);
 		}
 	});
-	const navigationState = usePluginWorkspaceNavigation({
-		activeView: () => props.activeView,
-		defaultActiveView: () => props.defaultActiveView,
-		currentPillId: () => props.currentPillId,
-		currentPageSelectorId: () => props.currentPageSelectorId,
-		pillNav: () => props.pillNav,
-		pageSelector: () => props.pageSelector,
-		panelIds: () => Object.keys(props.panels ?? {}),
-		generatedPillNav: controlsState.generatedPillNav,
-		generatedDefaultView: controlsState.generatedDefaultView,
-		emitActiveView: (viewId) => emit("update:activeView", viewId),
-		emitPageSelectorSelect: (page) => emit("page-selector-select", page),
-		emitPillSelect: (item) => emit("pill-select", item)
+	const navigationState = usePluginWorkspaceNavigation({
+		activeView: () => props.activeView,
+		defaultActiveView: () => props.defaultActiveView,
+		currentPillId: () => props.currentPillId,
+		currentPageSelectorId: () => props.currentPageSelectorId,
+		pillNav: () => props.pillNav,
+		pageSelector: () => props.pageSelector,
+		panelIds: () => Object.keys(props.panels ?? {}),
+		generatedPillNav: controlsState.generatedPillNav,
+		generatedDefaultView: controlsState.generatedDefaultView,
+		emitActiveView: (viewId) => emit("update:activeView", viewId),
+		emitPageSelectorSelect: (page) => emit("page-selector-select", page),
+		emitPillSelect: (item) => emit("pill-select", item)
+	});
+	const topBarSlotNames = computed(() => getPluginWorkspaceTopBarSlotNames(slots));
+	const sidebarSlotNames = computed(() => getPluginWorkspaceSidebarSlotNames(slots));
+	const hasSidebarSurface = computed(() => hasPluginWorkspaceSidebarSurface({
+		showSidebar: props.showSidebar ?? true,
+		panels: props.panels ?? {},
+		forms: props.forms ?? {},
+		model: props.model,
+		controls: props.controls,
+		showSidebarWhenEmpty: props.showSidebarWhenEmpty ?? false,
+		sidebarContentId: props.sidebarContentId,
+		sidebarTitle: props.sidebarTitle,
+		sidebarSubtitle: props.sidebarSubtitle,
+		sidebarBadge: props.sidebarBadge,
+		hasSidebarSlot: Boolean(slots.sidebar),
+		sidebarSlotCount: sidebarSlotNames.value.length
+	}));
+	const controls = computed(() => ({
+		activeView: navigationState.resolvedActiveView.value,
+		setActiveView: navigationState.setActiveView,
+		values: controlsState.internalControlValues,
+		componentBindings: controlsState.resolvedComponentBindings.value,
+		componentBindingsById: controlsState.resolvedComponentBindingsById.value,
+		componentProps: controlsState.resolvedComponentProps.value,
+		componentPropsById: controlsState.resolvedComponentPropsById.value
+	}));
+	return {
+		shell: computed(() => ({
+			sidebarPosition: props.sidebarPosition ?? "left",
+			sidebarWidth: props.sidebarWidth,
+			floating: props.floating ?? true,
+			responsiveSidebar: props.responsiveSidebar ?? true,
+			sidebarToggleLabel: props.sidebarToggleLabel ?? "Open workspace sidebar",
+			sidebarCloseLabel: props.sidebarCloseLabel ?? "Close workspace sidebar",
+			hasSidebarSurface: hasSidebarSurface.value,
+			title: props.title ?? "Workspace",
+			subtitle: props.subtitle,
+			topBarVariant: props.topBarVariant ?? "card",
+			homePath: props.homePath ?? "/",
+			showLogo: props.showLogo ?? true,
+			pageSelector: props.pageSelector,
+			currentPageSelectorId: navigationState.resolvedCurrentPageSelectorId.value,
+			pillNav: navigationState.resolvedPillNav.value,
+			currentPillId: navigationState.resolvedCurrentPillId.value,
+			showThemeToggle: props.showThemeToggle ?? true,
+			showSettings: props.showSettings ?? true,
+			settingsConfig: props.settingsConfig,
+			showStandaloneLabel: props.showStandaloneLabel ?? false,
+			standaloneLabel: props.standaloneLabel ?? "Standalone",
+			accountMenu: props.accountMenu,
+			showNotifications: props.showNotifications ?? false,
+			hasNotificationDot: props.hasNotificationDot ?? false,
+			showAdmin: props.showAdmin ?? false,
+			adminPath: props.adminPath ?? "/admin",
+			userName: props.userName,
+			userInitial: props.userInitial,
+			userEmail: props.userEmail,
+			topBarSlotNames: topBarSlotNames.value,
+			controls: controls.value
+		})),
+		sidebar: computed(() => ({
+			title: props.sidebarTitle,
+			subtitle: props.sidebarSubtitle,
+			badge: props.sidebarBadge,
+			panels: props.panels ?? {},
+			activeView: navigationState.resolvedActiveView.value,
+			floating: false,
+			dense: props.dense ?? true,
+			width: props.sidebarWidth,
+			side: props.sidebarPosition ?? "left",
+			forms: props.forms ?? {},
+			contentId: props.sidebarContentId,
+			showWhenEmpty: (props.showSidebarWhenEmpty ?? false) || props.sidebarContentId !== void 0,
+			model: props.model,
+			controlSchema: props.controls,
+			controlOptions: props.controlOptions ?? {},
+			values: controlsState.internalControlValues,
+			formEnhancements: props.formEnhancements,
+			showFormActions: props.showFormActions ?? false,
+			formLoading: props.formLoading ?? false,
+			formDisabled: props.formDisabled ?? false,
+			formReadonly: props.formReadonly ?? false,
+			formSize: props.formSize ?? "sm",
+			collapsible: props.sidebarCollapsible ?? true,
+			collapsed: props.sidebarCollapsed,
+			defaultCollapsed: props.defaultSidebarCollapsed ?? false,
+			collapsedWidth: props.sidebarCollapsedWidth ?? "3rem",
+			collapseButtonLabel: props.sidebarCollapseButtonLabel ?? "Collapse sidebar",
+			expandButtonLabel: props.sidebarExpandButtonLabel ?? "Expand sidebar",
+			slotNames: sidebarSlotNames.value
+		})),
+		controls,
+		hasSidebarSurface,
+		handleControlValuesUpdate: controlsState.handleControlValuesUpdate,
+		handlePageSelectorSelect: navigationState.handlePageSelectorSelect,
+		handlePillSelect: navigationState.handlePillSelect
+	};
+}
+//#endregion
+//#region src/composables/useRequestSyncState.ts
+/** Shared loading/error/timestamp state for generated plugin request helpers. */
+function useRequestSyncState(defaultErrorMessage = "Request failed.") {
+	const loading = ref(false);
+	const error = ref(null);
+	const lastLoadedAt = ref(null);
+	const lastSavedAt = ref(null);
+	const lastRunAt = ref(null);
+	function clearError() {
+		error.value = null;
+	}
+	function readErrorMessage$1(value, fallback = defaultErrorMessage) {
+		return readErrorMessage(value, fallback);
+	}
+	function setError(value, fallback) {
+		const message = readErrorMessage$1(value, fallback);
+		error.value = message;
+		return message;
+	}
+	function markLoaded(date = /* @__PURE__ */ new Date()) {
+		lastLoadedAt.value = date;
+	}
+	function markSaved(date = /* @__PURE__ */ new Date()) {
+		lastSavedAt.value = date;
+	}
+	function markRun(date = /* @__PURE__ */ new Date()) {
+		lastRunAt.value = date;
+	}
+	let runToken = 0;
+	let activeController = null;
+	function cancel() {
+		runToken += 1;
+		activeController?.abort();
+		activeController = null;
+		loading.value = false;
+	}
+	async function run(operation, options = {}) {
+		if (options.abortPrevious !== false) activeController?.abort();
+		const token = runToken += 1;
+		const controller = new AbortController();
+		activeController = controller;
+		const callerSignal = options.signal;
+		if (callerSignal) {
+			if (callerSignal.aborted) controller.abort(callerSignal.reason);
+			else callerSignal.addEventListener("abort", () => controller.abort(callerSignal.reason), { once: true });
+		}
+		const isCurrent = () => token === runToken;
+		loading.value = true;
+		clearError();
+		try {
+			const response = await operation(controller.signal);
+			if (isCurrent()) {
+				if (options.success === "load") markLoaded();
+				else if (options.success === "save") markSaved();
+				else if (options.success === "run") markRun();
+			}
+			return response;
+		} catch (err) {
+			if (isCurrent()) setError(err, options.errorMessage);
+			throw err;
+		} finally {
+			if (isCurrent()) loading.value = false;
+			if (activeController === controller) activeController = null;
+		}
+	}
+	return {
+		loading,
+		error,
+		lastLoadedAt,
+		lastSavedAt,
+		lastRunAt,
+		clearError,
+		readErrorMessage: readErrorMessage$1,
+		setError,
+		markLoaded,
+		markSaved,
+		markRun,
+		run,
+		cancel
+	};
+}
+//#endregion
+//#region src/composables/pluginEndpointBuilder.ts
+function normalizeApiBaseUrl(baseUrl) {
+	if (!baseUrl) return void 0;
+	return baseUrl.length > 1 ? baseUrl.replace(/\/+$/, "") : baseUrl;
+}
+function normalizeApiPrefix(prefix) {
+	if (!prefix) return void 0;
+	if (prefix.startsWith("/api/")) return normalizeApiBaseUrl(prefix);
+	if (prefix === "/api") return prefix;
+	if (prefix.startsWith("/")) return normalizeApiBaseUrl(`/api${prefix}`);
+	return normalizeApiBaseUrl(`/api/${prefix}`);
+}
+function endpointParamName(param) {
+	return typeof param === "string" ? param : param.name;
+}
+function endpointParamFieldName(param) {
+	return typeof param === "string" ? param : param.fieldName ?? param.name;
+}
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function replacePathParam(path, name, encoded) {
+	const escapedName = escapeRegExp(name);
+	return path.replace(new RegExp(`\\{${escapedName}(?::[^{}]+)?\\}`, "g"), () => encoded).replace(new RegExp(`:${escapedName}(?=/|$)`, "g"), () => encoded);
+}
+/** Resolve the runtime plugin API base URL from env, explicit options, platform injection, or contract metadata. */
+function resolvePluginBaseUrl(contract, explicitBaseUrl) {
+	if (explicitBaseUrl) return normalizeApiBaseUrl(explicitBaseUrl) ?? explicitBaseUrl;
+	const injected = getInjectedPlatformContext();
+	const platformPrefix = normalizeApiBaseUrl(injected?.plugin?.api_prefix) || normalizeApiPrefix(injected?.plugin?.route_prefix);
+	if (platformPrefix) return platformPrefix;
+	return normalizeApiBaseUrl(contract.plugin.apiPrefix) || "/api";
+}
+function encodePath(path, payload, pathParams) {
+	let nextPath = path;
+	for (const param of pathParams) {
+		const name = endpointParamName(param);
+		const fieldName = endpointParamFieldName(param);
+		const value = payload[fieldName] ?? payload[name];
+		if (value === void 0 || value === null) throw new Error(`[MINT SDK] Missing path parameter '${fieldName}' for plugin endpoint ${path}`);
+		const encoded = encodeURIComponent(String(value));
+		nextPath = replacePathParam(nextPath, name, encoded);
+		if (fieldName !== name) nextPath = replacePathParam(nextPath, fieldName, encoded);
+	}
+	return nextPath;
+}
+function withDefaultPathParams(payload, pathParams) {
+	if (!pathParams.length) return payload;
+	const nextPayload = { ...payload };
+	for (const param of pathParams) {
+		const name = endpointParamName(param);
+		const fieldName = endpointParamFieldName(param);
+		if (nextPayload[fieldName] !== void 0 && nextPayload[fieldName] !== null || nextPayload[name] !== void 0 && nextPayload[name] !== null) continue;
+		if (isExperimentPathParam(fieldName) || isExperimentPathParam(name)) {
+			const experimentId = resolveCurrentExperimentId();
+			if (experimentId !== void 0) nextPayload[fieldName] = experimentId;
+		}
+	}
+	return nextPayload;
+}
+function isExperimentPathParam(param) {
+	return param === "experimentId" || param === "experiment_id";
+}
+function withoutPathParams(payload, pathParams) {
+	const copy = { ...payload };
+	for (const param of pathParams) {
+		delete copy[endpointParamFieldName(param)];
+		delete copy[endpointParamName(param)];
+	}
+	return copy;
+}
+function queryParamsFromPayload(payload, pathParams, queryParams, endpointPath, includeUnspecifiedParams = false) {
+	if (!queryParams?.length) return includeUnspecifiedParams ? withoutPathParams(payload, pathParams) : {};
+	const query = {};
+	for (const param of queryParams) {
+		const name = typeof param === "string" ? param : param.name;
+		const fieldName = typeof param === "string" ? param : param.fieldName ?? param.name;
+		const required = typeof param !== "string" && param.required === true;
+		const value = payload[fieldName];
+		if (value === void 0 || value === null) {
+			if (required) throw new Error(`[MINT SDK] Missing query parameter '${fieldName}' for plugin endpoint ${endpointPath ?? ""}`);
+			continue;
+		}
+		query[name] = value;
+	}
+	return query;
+}
+function hasKeys(value) {
+	return Object.keys(value).length > 0;
+}
+function isPlainPayloadObject(value) {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function hasOwn(value, key) {
+	return Object.prototype.hasOwnProperty.call(value, key);
+}
+function normalizeStructuredEndpointPayload(payload) {
+	const pathParamPayload = payload.pathParams;
+	const queryPayload = payload.query;
+	const hasStructuredPathParams = hasOwn(payload, "pathParams") && isPlainPayloadObject(pathParamPayload);
+	const hasStructuredQuery = hasOwn(payload, "query") && isPlainPayloadObject(queryPayload);
+	if (!hasStructuredPathParams && !hasStructuredQuery) return payload;
+	const nextPayload = { ...payload };
+	delete nextPayload.pathParams;
+	delete nextPayload.query;
+	if (hasStructuredPathParams) Object.assign(nextPayload, pathParamPayload);
+	if (hasStructuredQuery) Object.assign(nextPayload, queryPayload);
+	return nextPayload;
+}
+function requestBodyFromPayload(payload, requestPayload, endpoint) {
+	if (!endpoint.hasBody) return void 0;
+	const body = endpoint.pathParams?.length || endpoint.queryParams?.length ? requestPayload.body : payload;
+	if (body === void 0 || body === null) throw new Error(`[MINT SDK] Missing request body for plugin endpoint ${endpoint.path}`);
+	return body;
+}
+function pluginEndpointRequestParts(contract, endpoint, payload, explicitBaseUrl) {
+	const payloadObject = isPlainPayloadObject(payload) ? normalizeStructuredEndpointPayload(payload) : {};
+	const pathParams = endpoint.pathParams ?? [];
+	const requestPayload = withDefaultPathParams(payloadObject, pathParams);
+	const path = encodePath(endpoint.path, requestPayload, pathParams);
+	const query = queryParamsFromPayload(requestPayload, pathParams, endpoint.queryParams, endpoint.path, endpoint.method === "get");
+	return {
+		baseUrl: resolvePluginBaseUrl(contract, explicitBaseUrl),
+		path,
+		query,
+		requestPayload
+	};
+}
+function appendQueryValue(params, key, value) {
+	if (value === void 0 || value === null) return;
+	if (Array.isArray(value)) {
+		for (const item of value) appendQueryValue(params, key, item);
+		return;
+	}
+	if (typeof value === "object") {
+		params.append(key, JSON.stringify(value));
+		return;
+	}
+	params.append(key, String(value));
+}
+function queryString(query) {
+	const params = new URLSearchParams();
+	for (const [key, value] of Object.entries(query)) appendQueryValue(params, key, value);
+	const serialized = params.toString();
+	return serialized ? `?${serialized}` : "";
+}
+function joinBaseUrl(baseUrl, path) {
+	if (!baseUrl) return path;
+	return `${baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl}${path.startsWith("/") ? path : `/${path}`}`;
+}
+/** Build the concrete URL for a generated plugin endpoint without making a request. */
+function buildPluginEndpointUrl(contract, endpoint, payload, options = {}) {
+	const parts = pluginEndpointRequestParts(contract, endpoint, payload, options.baseUrl);
+	const pathWithQuery = `${parts.path}${queryString(parts.query)}`;
+	if (options.includeBaseUrl === false) return pathWithQuery;
+	return joinBaseUrl(parts.baseUrl, pathWithQuery);
+}
+//#endregion
+//#region src/composables/usePluginClient.ts
+function queryConfig(query) {
+	return hasKeys(query) ? { params: query } : void 0;
+}
+var OCTET_STREAM = "application/octet-stream";
+var MULTIPART_FORM_DATA = "multipart/form-data";
+function endpointRequestConfig(endpoint, query, options) {
+	const config = {};
+	if (hasKeys(query)) config.params = query;
+	if (endpoint.requestContentType === OCTET_STREAM) config.headers = { "Content-Type": OCTET_STREAM };
+	if (endpoint.requestContentType === MULTIPART_FORM_DATA) config.headers = { "Content-Type": void 0 };
+	if (endpoint.responseContentType === OCTET_STREAM) config.responseType = "blob";
+	if (options?.signal) config.signal = options.signal;
+	return hasKeys(config) ? config : void 0;
+}
+function isFormData(value) {
+	return typeof FormData !== "undefined" && value instanceof FormData;
+}
+function endpointRequestBody(endpoint, body) {
+	return endpoint.requestContentType === MULTIPART_FORM_DATA ? pluginFormDataFromPayload(body) : body;
+}
+function endpointHasPayload(endpoint) {
+	return Boolean(endpoint.hasBody || endpoint.pathParams?.length || endpoint.queryParams?.length);
+}
+function isBlob(value) {
+	return typeof Blob !== "undefined" && value instanceof Blob;
+}
+function appendFormDataValue(formData, key, value) {
+	if (value === void 0 || value === null) return;
+	if (Array.isArray(value)) {
+		for (const item of value) appendFormDataValue(formData, key, item);
+		return;
+	}
+	if (isBlob(value)) {
+		formData.append(key, value);
+		return;
+	}
+	if (typeof value === "object") {
+		formData.append(key, JSON.stringify(value));
+		return;
+	}
+	formData.append(key, String(value));
+}
+/** Convert plain upload payloads into FormData using the same encoding across generated plugin clients. */
+function pluginFormDataFromPayload(payload) {
+	if (isFormData(payload)) return payload;
+	if (!payload || typeof payload !== "object" || Array.isArray(payload)) throw new Error("[MINT SDK] Plugin upload endpoints require a FormData or plain object payload.");
+	const formData = new FormData();
+	for (const [key, value] of Object.entries(payload)) appendFormDataValue(formData, key, value);
+	return formData;
+}
+/** Trigger a browser download for an already-created Blob. */
+function downloadBlob(blob, filename, options = {}) {
+	if (typeof document === "undefined" || typeof URL === "undefined") throw new Error("[MINT SDK] Cannot trigger a file download outside a browser.");
+	const blobUrl = URL.createObjectURL(blob);
+	const link = document.createElement("a");
+	link.href = blobUrl;
+	link.download = filename;
+	document.body.appendChild(link);
+	link.click();
+	document.body.removeChild(link);
+	setTimeout(() => URL.revokeObjectURL(blobUrl), options.revokeObjectUrlDelayMs ?? 100);
+}
+function normalizePluginNavPath(path) {
+	const raw = path.trim() || "/";
+	return (raw.startsWith("/") ? raw : `/${raw}`).replace(/\/+$/, "") || "/";
+}
+function pluginPageIdFromPath(path, fallbackIndex) {
+	const normalizedPath = normalizePluginNavPath(path);
+	if (normalizedPath === "/") return "dashboard";
+	return normalizedPath.replace(/^\/+/, "").replace(/\/+/g, "-") || `page-${fallbackIndex + 1}`;
+}
+/** Convert resolved @mint_plugin nav_items into page selectors for the topbar and homepage PluginCards. */
+function getPluginPageSelectorItems(contract) {
+	const pluginIcon = contract.plugin.icon ?? "";
+	return (contract.plugin.navItems ?? []).map((item, index) => ({
+		id: item.id || pluginPageIdFromPath(item.path, index),
+		label: item.label,
+		to: normalizePluginNavPath(item.path),
+		icon: item.icon || pluginIcon || void 0
+	}));
+}
+/** Create a typed plugin API client from a generated MINT plugin contract. */
+function createPluginClient(contract, options) {
+	const client = {};
+	for (const [name, endpoint] of Object.entries(options.endpoints)) client[name] = async (payloadOrOptions, explicitOptions) => {
+		const hasPayload = endpointHasPayload(endpoint);
+		const payload = hasPayload ? payloadOrOptions : void 0;
+		const callOptions = hasPayload ? explicitOptions : payloadOrOptions ?? explicitOptions;
+		const parts = pluginEndpointRequestParts(contract, endpoint, payload, options.baseUrl);
+		const api = useApi({
+			baseUrl: parts.baseUrl,
+			withAuth: endpoint.requiresAuth !== false,
+			typedErrors: true
+		});
+		const config = endpointRequestConfig(endpoint, parts.query, callOptions);
+		if (endpoint.method === "get") return api.get(parts.path, config);
+		if (endpoint.method === "delete") {
+			const rawBody = requestBodyFromPayload(payload, parts.requestPayload, endpoint);
+			const body = rawBody === void 0 ? void 0 : endpointRequestBody(endpoint, rawBody);
+			const config = body === void 0 ? endpointRequestConfig(endpoint, parts.query, callOptions) : {
+				...endpointRequestConfig(endpoint, parts.query, callOptions),
+				data: body
+			};
+			return api.delete(parts.path, config);
+		}
+		const body = endpointRequestBody(endpoint, requestBodyFromPayload(payload, parts.requestPayload, endpoint));
+		if (endpoint.method === "post") return api.post(parts.path, body, config);
+		if (endpoint.method === "put") return api.put(parts.path, body, config);
+		if (endpoint.method === "patch") return api.patch(parts.path, body, config);
+		throw new Error(`[MINT SDK] Unsupported plugin endpoint method: ${endpoint.method}`);
+	};
+	return client;
+}
+/** Send multipart or raw binary data to a generated endpoint with contract URL, cancellation, and auth handling. */
+async function uploadPluginEndpoint(contract, endpoint, payload, options = {}) {
+	if (![
+		"post",
+		"put",
+		"patch"
+	].includes(endpoint.method)) throw new Error(`[MINT SDK] Plugin upload endpoints must use POST, PUT, or PATCH; got ${endpoint.method}`);
+	const parts = pluginEndpointRequestParts(contract, endpoint, payload, options.baseUrl);
+	const api = useApi({
+		baseUrl: parts.baseUrl,
+		withAuth: endpoint.requiresAuth !== false,
+		typedErrors: true
+	});
+	const body = endpoint.hasBody ? requestBodyFromPayload(payload, parts.requestPayload, endpoint) : payload;
+	if (endpoint.requestContentType === OCTET_STREAM) {
+		const config = endpointRequestConfig(endpoint, parts.query, { signal: options.signal });
+		if (endpoint.method === "post") return api.post(parts.path, body, config);
+		if (endpoint.method === "put") return api.put(parts.path, body, config);
+		return api.patch(parts.path, body, config);
+	}
+	const formData = pluginFormDataFromPayload(body);
+	const config = {
+		...queryConfig(parts.query) ?? {},
+		...options.signal ? { signal: options.signal } : {},
+		headers: { "Content-Type": void 0 }
+	};
+	if (endpoint.method === "post") return api.post(parts.path, formData, config);
+	if (endpoint.method === "put") return api.put(parts.path, formData, config);
+	return api.patch(parts.path, formData, config);
+}
+/** Fetch a generated plugin endpoint as a Blob and optionally trigger a browser download. */
+async function downloadPluginEndpoint(contract, endpoint, payload, options = {}) {
+	if (endpoint.requestContentType === MULTIPART_FORM_DATA) throw new Error("[MINT SDK] Plugin download endpoints do not support multipart request bodies");
+	const parts = pluginEndpointRequestParts(contract, endpoint, payload, options.baseUrl);
+	const api = useApi({
+		baseUrl: parts.baseUrl,
+		withAuth: endpoint.requiresAuth !== false,
+		typedErrors: true
+	});
+	const config = {
+		...endpointRequestConfig(endpoint, parts.query, { signal: options.signal }) ?? {},
+		responseType: "blob"
+	};
+	const rawBody = requestBodyFromPayload(payload, parts.requestPayload, endpoint);
+	const body = rawBody === void 0 ? void 0 : endpointRequestBody(endpoint, rawBody);
+	let blob;
+	if (endpoint.method === "get") blob = await api.get(parts.path, config);
+	else if (endpoint.method === "post") blob = await api.post(parts.path, body, config);
+	else if (endpoint.method === "put") blob = await api.put(parts.path, body, config);
+	else if (endpoint.method === "patch") blob = await api.patch(parts.path, body, config);
+	else if (endpoint.method === "delete") blob = await api.delete(parts.path, body === void 0 ? config : {
+		...config,
+		data: body
+	});
+	else throw new Error(`[MINT SDK] Unsupported plugin endpoint method: ${endpoint.method}`);
+	if (options.filename) downloadBlob(blob, options.filename, { revokeObjectUrlDelayMs: options.revokeObjectUrlDelayMs });
+	return blob;
+}
+function normalizePluginSettingsOptions(options = {}) {
+	return typeof options === "string" ? { pluginName: options } : options;
+}
+/** @deprecated Removed in MINT 1.4; use `useGeneratedPluginClient()` for generated clients. */
+function usePluginClient(client) {
+	return client;
+}
+var PLATFORM_OWNED_SETTINGS_KEY = "allowed_experiment_types";
+/**
+* Secret settings travel as `{ "$secret": "<id>" }` references, so an untouched
+* secret round-trips without ever exposing its value. Declaring the format on
+* every write keeps a `null` unambiguous: it clears the stored secret instead of
+* meaning "unchanged", which is what the deprecated placeholder form meant.
+*/
+function withSecretFormat(payload, secretFormat) {
+	if (!secretFormat) return payload;
+	return {
+		...payload,
+		[PLUGIN_SECRET_FORMAT_KEY]: secretFormat
+	};
+}
+function responseSecretFormat(response) {
+	if (!response || typeof response !== "object") return null;
+	const format = response[PLUGIN_SECRET_FORMAT_KEY];
+	return typeof format === "string" && format ? format : null;
+}
+function cloneRecord(value) {
+	return JSON.parse(JSON.stringify(value));
+}
+function hasOwnSetting(settings, key) {
+	return Object.prototype.hasOwnProperty.call(settings, key);
+}
+function responseSettingsPayload(response) {
+	if (!response || typeof response !== "object") return {};
+	const data = response;
+	if (data.config && typeof data.config === "object") return cloneRecord(data.config);
+	if (data.settings && typeof data.settings === "object") return cloneRecord(data.settings);
+	return {};
+}
+function responseSettingsRevision(response) {
+	if (!response || typeof response !== "object") return null;
+	const revision = response.revision;
+	return typeof revision === "string" && revision ? revision : null;
+}
+function topLevelSettingsPatch(current, keys) {
+	return Object.fromEntries([...keys].map((key) => [key, hasOwnSetting(current, key) ? current[key] : null]));
+}
+function changedTopLevelSettingKeys(current, saved) {
+	return new Set([.../* @__PURE__ */ new Set([...Object.keys(current), ...Object.keys(saved)])].filter((key) => JSON.stringify(current[key]) !== JSON.stringify(saved[key])));
+}
+function platformOwnedSettingsPatch(settings) {
+	return { [PLATFORM_OWNED_SETTINGS_KEY]: hasOwnSetting(settings, PLATFORM_OWNED_SETTINGS_KEY) ? settings[PLATFORM_OWNED_SETTINGS_KEY] : null };
+}
+/** Load, edit, and persist plugin settings from platform config or the plugin-local settings router. */
+function usePluginSettings(options = {}) {
+	const resolvedOptions = normalizePluginSettingsOptions(options);
+	const injectedContext = getInjectedPlatformContext();
+	const { plugin, isIntegrated } = usePlatformContext();
+	const platformApi = useApi({ baseUrl: resolvedOptions.platformApiBaseUrl ?? injectedContext?.platformApiUrl });
+	const pluginApi = useApi({ baseUrl: resolvedOptions.apiBaseUrl ?? injectedContext?.plugin?.api_prefix });
+	const values = ref({});
+	const savedValues = shallowRef({});
+	const revision = ref(null);
+	const secretFormat = ref(null);
+	const request = useRequestSyncState("Plugin settings request failed.");
+	const isLoading = ref(false);
+	const isSaving = ref(false);
+	const resolvedPluginName = computed(() => resolvedOptions.pluginName ?? plugin.value?.name ?? injectedContext?.plugin?.name ?? "");
+	const usesPluginSettingsApi = computed(() => {
+		const currentPlugin = injectedContext?.plugin ?? plugin.value;
+		return currentPlugin?.settings_api === "plugin" && resolvedPluginName.value === currentPlugin.name;
+	});
+	const usesPlatformConfig = computed(() => Boolean((isIntegrated.value || injectedContext?.isIntegrated) && resolvedPluginName.value && !usesPluginSettingsApi.value));
+	const settings = computed(() => values.value);
+	const isDirty = computed(() => JSON.stringify(values.value) !== JSON.stringify(savedValues.value));
+	const settingsConfig = computed(() => ({
+		title: resolvedOptions.title,
+		schema: resolvedOptions.schema ?? void 0,
+		showAppearance: resolvedOptions.showAppearance,
+		values: values.value
+	}));
+	function setValues(nextValues) {
+		values.value = cloneRecord(nextValues);
+	}
+	function applyLoaded(nextValues, nextRevision, nextSecretFormat = secretFormat.value) {
+		const cloned = cloneRecord(nextValues);
+		values.value = cloned;
+		savedValues.value = cloneRecord(cloned);
+		revision.value = nextRevision;
+		secretFormat.value = nextSecretFormat;
+	}
+	async function load() {
+		isLoading.value = true;
+		try {
+			const response = usesPlatformConfig.value ? await request.run(() => platformApi.get(`/plugins/${encodeURIComponent(resolvedPluginName.value)}/config`), {
+				success: "load",
+				errorMessage: "Failed to load plugin settings"
+			}) : await request.run(() => pluginApi.get("/settings"), {
+				success: "load",
+				errorMessage: "Failed to load plugin settings"
+			});
+			applyLoaded(responseSettingsPayload(response), responseSettingsRevision(response), responseSecretFormat(response));
+		} catch {} finally {
+			isLoading.value = false;
+		}
+	}
+	async function save(nextValues) {
+		if (nextValues) setValues(nextValues);
+		isSaving.value = true;
+		try {
+			const payload = cloneRecord(values.value);
+			let response;
+			if (usesPlatformConfig.value) {
+				const dirtyKeys = changedTopLevelSettingKeys(payload, savedValues.value);
+				const platformOwnedChanged = dirtyKeys.has(PLATFORM_OWNED_SETTINGS_KEY);
+				const typedKeys = [...dirtyKeys].filter((key) => key !== PLATFORM_OWNED_SETTINGS_KEY);
+				let nextRevision = revision.value;
+				if (typedKeys.length) {
+					response = await request.run(() => platformApi.patch(`/plugins/${encodeURIComponent(resolvedPluginName.value)}/config`, { config: withSecretFormat(topLevelSettingsPatch(payload, typedKeys), secretFormat.value) }), {
+						success: "save",
+						errorMessage: "Failed to save plugin settings"
+					});
+					nextRevision = responseSettingsRevision(response) ?? nextRevision;
+				}
+				if (platformOwnedChanged) {
+					response = await request.run(() => platformApi.patch(`/plugins/${encodeURIComponent(resolvedPluginName.value)}/config`, { config: platformOwnedSettingsPatch(payload) }), {
+						success: "save",
+						errorMessage: "Failed to save plugin settings"
+					});
+					nextRevision = responseSettingsRevision(response) ?? nextRevision;
+				}
+				if (!response) return true;
+				applyLoaded(responseSettingsPayload(response), nextRevision, responseSecretFormat(response) ?? secretFormat.value);
+				return true;
+			} else {
+				const ifMatch = revision.value ? { headers: { "If-Match": `"${revision.value}"` } } : void 0;
+				response = await request.run(() => pluginApi.put("/settings", withSecretFormat(payload, secretFormat.value), ifMatch), {
+					success: "save",
+					errorMessage: "Failed to save plugin settings"
+				});
+			}
+			applyLoaded(responseSettingsPayload(response), responseSettingsRevision(response) ?? revision.value, responseSecretFormat(response) ?? secretFormat.value);
+			return true;
+		} catch {
+			return false;
+		} finally {
+			isSaving.value = false;
+		}
+	}
+	function reset() {
+		values.value = cloneRecord(savedValues.value);
+		request.clearError();
+	}
+	onMounted(() => {
+		if (resolvedOptions.loadOnMount !== false) load();
+	});
+	return {
+		settings,
+		values,
+		config: values,
+		settingsConfig,
+		isLoading,
+		isSaving,
+		error: request.error,
+		lastLoadedAt: request.lastLoadedAt,
+		lastSavedAt: request.lastSavedAt,
+		isDirty,
+		setValues,
+		load,
+		save,
+		reset
+	};
+}
+function streamRequestAuth(requestHeaders, policy) {
+	const headers = new Headers(requestHeaders);
+	const authStore = useAuthStore();
+	if (!authStore.isInitialized) authStore.initialize();
+	if (policy.requiresAuth && authStore.token && !headers.has("Authorization")) headers.set("Authorization", `Bearer ${authStore.token}`);
+	const token = policy.requiresAuth ? authStore.token : void 0;
+	return {
+		headers,
+		token: token && headers.get("Authorization") === `Bearer ${token}` ? token : void 0
+	};
+}
+function pluginEventStreamTransport(endpoint) {
+	return async (url, init = {}) => {
+		if (typeof fetch !== "function") throw new Error("[MINT SDK] fetch is required for plugin event streams.");
+		const requestAuth = streamRequestAuth(init.headers, { requiresAuth: endpoint.requiresAuth !== false });
+		const response = await fetch(url, {
+			...init,
+			headers: requestAuth.headers
+		});
+		if (response.status === 401) throw authenticationRequiredError(response, requestAuth.token);
+		return response;
+	};
+}
+function looksLikeEventStreamOptions(value) {
+	if (!value || typeof value !== "object") return false;
+	const candidate = value;
+	return [
+		"baseUrl",
+		"immediate",
+		"reconnect",
+		"reconnectDelayMs",
+		"parseJson",
+		"credentials",
+		"headers",
+		"onOpen",
+		"onMessage",
+		"onError"
+	].some((key) => key in candidate);
+}
+function usePluginEventStream(contract, endpoint, payloadOrOptions, maybeOptions) {
+	if (endpoint.method !== "get") throw new Error(`[MINT SDK] Plugin event streams must use GET; got ${endpoint.method}`);
+	const payload = maybeOptions === void 0 && looksLikeEventStreamOptions(payloadOrOptions) ? void 0 : payloadOrOptions;
+	const options = maybeOptions === void 0 && looksLikeEventStreamOptions(payloadOrOptions) ? payloadOrOptions : maybeOptions ?? {};
+	const responseType = endpoint.responseType?.trim();
+	const parseJson = options.parseJson ?? Boolean(responseType && responseType !== "string");
+	return useEventStream(() => buildPluginEndpointUrl(contract, endpoint, payload, { baseUrl: options.baseUrl }), {
+		transport: pluginEventStreamTransport(endpoint),
+		immediate: options.immediate,
+		reconnect: options.reconnect,
+		reconnectDelayMs: options.reconnectDelayMs,
+		parseJson,
+		credentials: options.credentials,
+		headers: options.headers,
+		shouldReconnect: (cause) => !(cause instanceof AuthenticationRequiredError),
+		onOpen: options.onOpen,
+		onMessage: options.onMessage,
+		onError: options.onError,
+		errorLabel: "Plugin event stream"
+	});
+}
+/** Read and optionally load the current platform experiment for integrated plugin views. */
+function useCurrentExperiment(options = {}) {
+	const api = useApi({ baseUrl: options.apiBaseUrl ?? getInjectedPlatformContext()?.platformApiUrl });
+	const experiment = shallowRef(currentExperimentFromContext());
+	const request = useRequestSyncState("Failed to load current experiment");
+	const isLoading = request.loading;
+	const error = request.error;
+	const lastLoadedAt = request.lastLoadedAt;
+	const experimentId = computed(() => {
+		return resolveCurrentExperimentId();
 	});
-	const topBarSlotNames = computed(() => getPluginWorkspaceTopBarSlotNames(slots));
-	const sidebarSlotNames = computed(() => getPluginWorkspaceSidebarSlotNames(slots));
-	const hasSidebarSurface = computed(() => hasPluginWorkspaceSidebarSurface({
-		showSidebar: props.showSidebar ?? true,
-		panels: props.panels ?? {},
-		forms: props.forms ?? {},
-		model: props.model,
-		controls: props.controls,
-		showSidebarWhenEmpty: props.showSidebarWhenEmpty ?? false,
-		sidebarContentId: props.sidebarContentId,
-		sidebarTitle: props.sidebarTitle,
-		sidebarSubtitle: props.sidebarSubtitle,
-		sidebarBadge: props.sidebarBadge,
-		hasSidebarSlot: Boolean(slots.sidebar),
-		sidebarSlotCount: sidebarSlotNames.value.length
-	}));
-	const controls = computed(() => ({
-		activeView: navigationState.resolvedActiveView.value,
-		setActiveView: navigationState.setActiveView,
-		values: controlsState.internalControlValues,
-		componentBindings: controlsState.resolvedComponentBindings.value,
-		componentBindingsById: controlsState.resolvedComponentBindingsById.value,
-		componentProps: controlsState.resolvedComponentProps.value,
-		componentPropsById: controlsState.resolvedComponentPropsById.value
-	}));
+	const hasExperiment = computed(() => experimentId.value !== void 0);
+	function requireExperimentId() {
+		const id = experimentId.value;
+		if (id === void 0) throw new Error("[MINT SDK] No current experiment is selected.");
+		return id;
+	}
+	async function fetchExperiment(id = experimentId.value) {
+		if (id === void 0) {
+			experiment.value = currentExperimentFromContext();
+			return experiment.value;
+		}
+		try {
+			const result = await request.run(() => api.get(`/experiments/${id}`), {
+				success: "load",
+				errorMessage: "Failed to load current experiment"
+			});
+			experiment.value = result;
+			return result;
+		} catch (e) {
+			experiment.value = void 0;
+			return;
+		}
+	}
+	async function refresh() {
+		return fetchExperiment();
+	}
+	watch(experimentId, (id) => {
+		if (options.immediate === false) return;
+		if (id === void 0) {
+			experiment.value = currentExperimentFromContext();
+			return;
+		}
+		fetchExperiment(id);
+	}, { immediate: options.immediate !== false });
 	return {
-		shell: computed(() => ({
-			sidebarPosition: props.sidebarPosition ?? "left",
-			sidebarWidth: props.sidebarWidth,
-			floating: props.floating ?? true,
-			responsiveSidebar: props.responsiveSidebar ?? true,
-			sidebarToggleLabel: props.sidebarToggleLabel ?? "Open workspace sidebar",
-			sidebarCloseLabel: props.sidebarCloseLabel ?? "Close workspace sidebar",
-			hasSidebarSurface: hasSidebarSurface.value,
-			title: props.title ?? "Workspace",
-			subtitle: props.subtitle,
-			topBarVariant: props.topBarVariant ?? "card",
-			homePath: props.homePath ?? "/",
-			showLogo: props.showLogo ?? true,
-			pageSelector: props.pageSelector,
-			currentPageSelectorId: navigationState.resolvedCurrentPageSelectorId.value,
-			pluginSwitcher: props.pluginSwitcher,
-			pillNav: navigationState.resolvedPillNav.value,
-			currentPillId: navigationState.resolvedCurrentPillId.value,
-			showThemeToggle: props.showThemeToggle ?? true,
-			showSettings: props.showSettings ?? true,
-			settingsConfig: props.settingsConfig,
-			showStandaloneLabel: props.showStandaloneLabel ?? false,
-			standaloneLabel: props.standaloneLabel ?? "Standalone",
-			accountMenu: props.accountMenu,
-			showNotifications: props.showNotifications ?? false,
-			hasNotificationDot: props.hasNotificationDot ?? false,
-			showAdmin: props.showAdmin ?? false,
-			adminPath: props.adminPath ?? "/admin",
-			userName: props.userName,
-			userInitial: props.userInitial,
-			userEmail: props.userEmail,
-			topBarSlotNames: topBarSlotNames.value,
-			controls: controls.value
-		})),
-		sidebar: computed(() => ({
-			title: props.sidebarTitle,
-			subtitle: props.sidebarSubtitle,
-			badge: props.sidebarBadge,
-			panels: props.panels ?? {},
-			activeView: navigationState.resolvedActiveView.value,
-			floating: false,
-			dense: props.dense ?? true,
-			width: props.sidebarWidth,
-			side: props.sidebarPosition ?? "left",
-			forms: props.forms ?? {},
-			contentId: props.sidebarContentId,
-			showWhenEmpty: (props.showSidebarWhenEmpty ?? false) || props.sidebarContentId !== void 0,
-			model: props.model,
-			controlSchema: props.controls,
-			controlOptions: props.controlOptions ?? {},
-			values: controlsState.internalControlValues,
-			formEnhancements: props.formEnhancements,
-			showFormActions: props.showFormActions ?? false,
-			formLoading: props.formLoading ?? false,
-			formDisabled: props.formDisabled ?? false,
-			formReadonly: props.formReadonly ?? false,
-			formSize: props.formSize ?? "sm",
-			collapsible: props.sidebarCollapsible ?? true,
-			collapsed: props.sidebarCollapsed,
-			defaultCollapsed: props.defaultSidebarCollapsed ?? false,
-			collapsedWidth: props.sidebarCollapsedWidth ?? "3rem",
-			collapseButtonLabel: props.sidebarCollapseButtonLabel ?? "Collapse sidebar",
-			expandButtonLabel: props.sidebarExpandButtonLabel ?? "Expand sidebar",
-			slotNames: sidebarSlotNames.value
-		})),
-		controls,
-		hasSidebarSurface,
-		handleControlValuesUpdate: controlsState.handleControlValuesUpdate,
-		handlePageSelectorSelect: navigationState.handlePageSelectorSelect,
-		handlePillSelect: navigationState.handlePillSelect
+		experimentId,
+		hasExperiment,
+		experiment,
+		isLoading,
+		error,
+		lastLoadedAt,
+		requireExperimentId,
+		fetch: fetchExperiment,
+		refresh
 	};
 }
 //#endregion
@@ -1070,7 +2870,7 @@ function usePluginJobCenter(options = {}) {
 	}
 	function replaceLegacyJobs(nextJobs) {
 		const normalized = nextJobs.map(normalizeJobState);
-		new Set([...jobs.value.map((job) => job.job_id), ...normalized.map((job) => job.job_id)]).forEach(bumpJobRevision);
+		(/* @__PURE__ */ new Set([...jobs.value.map((job) => job.job_id), ...normalized.map((job) => job.job_id)])).forEach(bumpJobRevision);
 		legacyOverride.value = {
 			input: toValue(options.jobs),
 			jobs: normalized
@@ -1142,8 +2942,10 @@ function usePluginJobCenter(options = {}) {
 		try {
 			const updated = sourceCancel ? await sourceCancel(job.job_id) : await adapterCancel(job);
 			if (!active) return false;
-			if (!sourceCancel && revision === (jobRevisions.get(job.job_id) ?? 0)) if (updated) upsertLegacyJob(updated);
-			else await refresh();
+			if (!sourceCancel && revision === (jobRevisions.get(job.job_id) ?? 0)) {
+				if (updated) upsertLegacyJob(updated);
+				else await refresh();
+			}
 			return true;
 		} catch (cause) {
 			if (active) error.value = errorMessage(cause, "Failed to cancel job");
@@ -1161,8 +2963,10 @@ function usePluginJobCenter(options = {}) {
 		try {
 			const deleted = sourceDelete ? await sourceDelete(job.job_id) : await adapterDelete(job);
 			if (!active) return false;
-			if (!sourceDelete) if (deleted === false) await refresh();
-			else removeLegacyJobs(new Set([job.job_id]));
+			if (!sourceDelete) {
+				if (deleted === false) await refresh();
+				else removeLegacyJobs(/* @__PURE__ */ new Set([job.job_id]));
+			}
 			return deleted !== false;
 		} catch (cause) {
 			if (active) error.value = errorMessage(cause, "Failed to delete job");
@@ -1243,7 +3047,7 @@ function usePluginJobCenter(options = {}) {
 		isPending: (job) => pendingJobIds.value.has(job.job_id)
 	};
 }
-/** @deprecated Use `usePluginJobCenter()` for the plugin job-center controller. */
+/** @deprecated Removed in MINT 1.4; use `usePluginJobCenter()` for the plugin job-center controller. */
 function useJobsStatusTray(options = {}) {
 	return usePluginJobCenter(options);
 }
@@ -1640,266 +3444,301 @@ function useListReorder(options) {
 	};
 }
 //#endregion
-//#region src/composables/useWellPlateEditor.ts
-var MAX_HISTORY = 50;
-function createEmptyPlate(name, format, id) {
+//#region src/composables/useRackEditor.ts
+var SLOT_CYCLE = [
+	"R",
+	"G",
+	"B",
+	"Y"
+];
+function wellFromEditData(data) {
+	return {
+		state: "filled",
+		sampleType: data.sampleType || void 0,
+		metadata: {
+			label: data.label,
+			injectionVolume: data.injectionVolume,
+			injectionCount: data.injectionCount,
+			customMethod: data.customMethod || null
+		}
+	};
+}
+function wellFromDrop(data, rack) {
+	const label = (data.label ?? data.sampleName ?? data.id ?? "").trim();
+	if (!label) return null;
 	return {
-		id: id || `plate-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
-		name,
-		format,
-		wells: {}
+		state: "filled",
+		sampleType: data.sampleType ?? "sample",
+		metadata: {
+			label,
+			injectionVolume: data.injectionVolume ?? rack.injectionVolume,
+			injectionCount: data.injectionCount ?? 1,
+			customMethod: data.customMethod ?? null
+		}
 	};
 }
-function generateSampleId() {
-	return `sample-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
-}
-function cloneValue(value) {
-	return structuredClone(toRaw(value));
-}
-/** Manages multi-plate well-plate state with sample assignment, selection, and undo/redo history. */
-function useWellPlateEditor(initialState, options = {}) {
-	const { maxHistory = MAX_HISTORY, defaultFormat = 96 } = options;
-	const defaultPlate = createEmptyPlate("Plate 1", defaultFormat);
-	const internalState = ref({
-		plates: initialState?.plates || [defaultPlate],
-		activePlateId: initialState?.activePlateId || defaultPlate.id,
-		samples: initialState?.samples || [],
-		selectedWells: initialState?.selectedWells || [],
-		activeSampleId: initialState?.activeSampleId
-	});
-	const history = ref([]);
-	const historyIndex = ref(-1);
-	const state = computed(() => internalState.value);
-	const plates = computed(() => internalState.value.plates);
-	const activePlate = computed(() => internalState.value.plates.find((p) => p.id === internalState.value.activePlateId));
-	const samples = computed(() => internalState.value.samples);
-	const selectedWells = computed(() => internalState.value.selectedWells);
-	const activeSampleId = computed(() => internalState.value.activeSampleId);
-	const canUndo = computed(() => historyIndex.value >= 0);
-	const canRedo = computed(() => historyIndex.value < history.value.length - 1);
-	function saveToHistory() {
-		const entry = {
-			plates: cloneValue(internalState.value.plates),
-			samples: cloneValue(internalState.value.samples)
+var globalIdCounter = 0;
+function generateId() {
+	globalIdCounter++;
+	return `rack-${Date.now()}-${globalIdCounter}`;
+}
+/** Manages a set of sample racks with well-level assignment, series fill, and multi-rack reordering. */
+function useRackEditor(initialRacks, options) {
+	const defaultFormat = options?.defaultFormat ?? 54;
+	const defaultInjVol = options?.defaultInjectionVolume ?? 5;
+	const maxRacks = options?.maxRacks ?? 10;
+	const minRacks = options?.minRacks ?? 1;
+	function createDefaultRack(name, slotIndex) {
+		const slot = SLOT_CYCLE[(slotIndex ?? 0) % SLOT_CYCLE.length];
+		return {
+			id: generateId(),
+			name: name ?? `Rack ${racks.value.length + 1}`,
+			format: defaultFormat,
+			slot,
+			injectionVolume: defaultInjVol,
+			wells: {}
 		};
-		if (historyIndex.value < history.value.length - 1) history.value = history.value.slice(0, historyIndex.value + 1);
-		history.value.push(entry);
-		if (history.value.length > maxHistory) history.value.shift();
-		else historyIndex.value++;
-	}
-	function setActivePlate(plateId) {
-		if (internalState.value.plates.some((p) => p.id === plateId)) {
-			internalState.value.activePlateId = plateId;
-			internalState.value.selectedWells = [];
-		}
-	}
-	function setActiveSample(sampleId) {
-		internalState.value.activeSampleId = sampleId;
-	}
-	function setSelectedWells(wellIds) {
-		internalState.value.selectedWells = wellIds;
-	}
-	function addPlate(name, format) {
-		saveToHistory();
-		const plateNumber = internalState.value.plates.length + 1;
-		const plate = createEmptyPlate(name || `Plate ${plateNumber}`, format || defaultFormat);
-		internalState.value.plates.push(plate);
-		internalState.value.activePlateId = plate.id;
-		internalState.value.selectedWells = [];
-		return plate;
-	}
-	function removePlate(plateId) {
-		if (internalState.value.plates.length <= 1) return;
-		saveToHistory();
-		const index = internalState.value.plates.findIndex((p) => p.id === plateId);
+	}
+	const racks = ref(initialRacks && initialRacks.length > 0 ? initialRacks.map((r) => ({
+		...r,
+		wells: { ...r.wells }
+	})) : [createDefaultRack("Rack 1", 0)]);
+	const activeRackId = ref(racks.value[0]?.id ?? "");
+	const activeRack = computed(() => racks.value.find((r) => r.id === activeRackId.value) ?? racks.value[0]);
+	function addRack(name) {
+		if (racks.value.length >= maxRacks) return racks.value[racks.value.length - 1];
+		const rack = createDefaultRack(name, racks.value.length);
+		racks.value.push(rack);
+		activeRackId.value = rack.id;
+		return rack;
+	}
+	function removeRack(rackId) {
+		if (racks.value.length <= minRacks) return;
+		const index = racks.value.findIndex((r) => r.id === rackId);
 		if (index === -1) return;
-		internalState.value.plates.splice(index, 1);
-		if (internalState.value.activePlateId === plateId) {
-			internalState.value.activePlateId = internalState.value.plates[0].id;
-			internalState.value.selectedWells = [];
-		}
-	}
-	function addSample(name, color) {
-		saveToHistory();
-		const sample = {
-			id: generateSampleId(),
-			name,
-			color: color || SAMPLE_COLOR_SCALE[internalState.value.samples.length % SAMPLE_COLOR_SCALE.length],
-			count: 0
+		racks.value.splice(index, 1);
+		if (activeRackId.value === rackId && racks.value[0]) activeRackId.value = racks.value[0].id;
+	}
+	function reorderRacks(fromIndex, toIndex) {
+		if (fromIndex < 0 || fromIndex >= racks.value.length) return;
+		if (toIndex < 0 || toIndex >= racks.value.length) return;
+		if (fromIndex === toIndex) return;
+		const [moved] = racks.value.splice(fromIndex, 1);
+		if (moved) racks.value.splice(toIndex, 0, moved);
+	}
+	function updateRack(rackId, data) {
+		const rack = racks.value.find((r) => r.id === rackId);
+		if (!rack) return;
+		if (data.name !== void 0) rack.name = data.name;
+		if (data.format !== void 0) rack.format = data.format;
+		if (data.slot !== void 0) rack.slot = data.slot;
+		if (data.injectionVolume !== void 0) rack.injectionVolume = data.injectionVolume;
+		if (data.wells !== void 0) rack.wells = data.wells;
+	}
+	function setActiveRack(rackId) {
+		if (racks.value.some((r) => r.id === rackId)) activeRackId.value = rackId;
+	}
+	function setWellData(rackId, wellId, data) {
+		const rack = racks.value.find((r) => r.id === rackId);
+		if (!rack) return;
+		rack.wells[wellId] = {
+			...rack.wells[wellId],
+			...data
 		};
-		internalState.value.samples.push(sample);
-		return sample;
 	}
-	function removeSample(sampleId) {
-		saveToHistory();
-		const index = internalState.value.samples.findIndex((s) => s.id === sampleId);
-		if (index === -1) return;
-		internalState.value.samples.splice(index, 1);
-		for (const plate of internalState.value.plates) for (const well of Object.values(plate.wells)) if (well.sampleType === sampleId) {
-			delete well.sampleType;
-			well.state = "empty";
-		}
-		if (internalState.value.activeSampleId === sampleId) internalState.value.activeSampleId = void 0;
-		updateSampleCounts();
-	}
-	function assignSample(wellIds, sampleId) {
-		if (wellIds.length === 0) return;
-		saveToHistory();
-		const plate = activePlate.value;
-		if (!plate) return;
-		for (const wellId of wellIds) {
-			const well = plate.wells[wellId] || {
-				id: wellId,
-				row: wellId.charCodeAt(0) - 65,
-				col: parseInt(wellId.slice(1)) - 1,
-				state: "empty"
-			};
-			if (sampleId) {
-				well.sampleType = sampleId;
-				well.state = "filled";
-			} else {
-				delete well.sampleType;
-				well.state = "empty";
-			}
-			plate.wells[wellId] = well;
-		}
-		updateSampleCounts();
-	}
-	function clearWells(wellIds) {
-		assignSample(wellIds, void 0);
-	}
-	function updateSampleCounts() {
-		const counts = {};
-		for (const plate of internalState.value.plates) for (const well of Object.values(plate.wells)) if (well.sampleType) counts[well.sampleType] = (counts[well.sampleType] || 0) + 1;
-		for (const sample of internalState.value.samples) sample.count = counts[sample.id] || 0;
-	}
-	function undo() {
-		if (!canUndo.value) return;
-		const entry = history.value[historyIndex.value];
-		historyIndex.value--;
-		internalState.value.plates = cloneValue(entry.plates);
-		internalState.value.samples = cloneValue(entry.samples);
-		if (!internalState.value.plates.some((p) => p.id === internalState.value.activePlateId)) internalState.value.activePlateId = internalState.value.plates[0]?.id || "";
-		internalState.value.selectedWells = [];
-	}
-	function redo() {
-		if (!canRedo.value) return;
-		historyIndex.value++;
-		const entry = history.value[historyIndex.value];
-		internalState.value.plates = cloneValue(entry.plates);
-		internalState.value.samples = cloneValue(entry.samples);
-		internalState.value.selectedWells = [];
-	}
-	function exportData(format) {
-		if (format === "json") return JSON.stringify({
-			plates: internalState.value.plates,
-			samples: internalState.value.samples
-		}, null, 2);
-		const sampleMap = new Map(internalState.value.samples.map((s) => [s.id, s.name]));
-		const rows = ["Plate,Well,Sample Type,Sample Name"];
-		for (const plate of internalState.value.plates) for (const [wellId, well] of Object.entries(plate.wells)) if (well.sampleType) {
-			const sampleName = sampleMap.get(well.sampleType) || "";
-			rows.push(`"${plate.name}","${wellId}","${well.sampleType}","${sampleName}"`);
-		}
-		return rows.join("\n");
-	}
-	function importData(data, format) {
-		try {
-			saveToHistory();
-			if (format === "json") {
-				const parsed = JSON.parse(data);
-				if (parsed.plates && Array.isArray(parsed.plates)) {
-					internalState.value.plates = parsed.plates;
-					internalState.value.activePlateId = parsed.plates[0]?.id || "";
-				}
-				if (parsed.samples && Array.isArray(parsed.samples)) internalState.value.samples = parsed.samples;
-				internalState.value.selectedWells = [];
-				updateSampleCounts();
-				return true;
-			}
-			const lines = data.trim().split("\n");
-			if (lines.length < 2) return false;
-			const plateMap = /* @__PURE__ */ new Map();
-			const sampleMap = /* @__PURE__ */ new Map();
-			for (let i = 1; i < lines.length; i++) {
-				const parts = lines[i].match(/(?:[^",]+|"[^"]*")+/g);
-				if (!parts || parts.length < 4) continue;
-				const plateName = parts[0].replace(/^"|"$/g, "");
-				const wellId = parts[1].replace(/^"|"$/g, "");
-				const sampleId = parts[2].replace(/^"|"$/g, "");
-				const sampleName = parts[3].replace(/^"|"$/g, "");
-				if (!plateMap.has(plateName)) plateMap.set(plateName, createEmptyPlate(plateName, defaultFormat));
-				if (sampleId && !sampleMap.has(sampleId)) sampleMap.set(sampleId, {
-					id: sampleId,
-					name: sampleName || sampleId,
-					color: SAMPLE_COLOR_SCALE[sampleMap.size % SAMPLE_COLOR_SCALE.length],
-					count: 0
-				});
-				const plate = plateMap.get(plateName);
-				plate.wells[wellId] = {
+	function clearWell(rackId, wellId) {
+		const rack = racks.value.find((r) => r.id === rackId);
+		if (!rack) return;
+		delete rack.wells[wellId];
+	}
+	function clearAllWells(rackId) {
+		const rack = racks.value.find((r) => r.id === rackId);
+		if (!rack) return;
+		rack.wells = {};
+	}
+	function fillSeries(rackId, prefix = "S") {
+		const rack = racks.value.find((r) => r.id === rackId);
+		if (!rack) return;
+		const config = PLATE_CONFIGS[rack.format];
+		if (!config) return;
+		let counter = 1;
+		for (let row = 0; row < config.rows; row++) for (let col = 0; col < config.cols; col++) {
+			const wellId = `${rowLabel(row)}${col + 1}`;
+			if (!rack.wells[wellId]?.sampleType) {
+				const paddedNum = String(counter).padStart(3, "0");
+				rack.wells[wellId] = {
 					id: wellId,
-					row: wellId.charCodeAt(0) - 65,
-					col: parseInt(wellId.slice(1)) - 1,
-					state: sampleId ? "filled" : "empty",
-					sampleType: sampleId || void 0
+					row,
+					col,
+					state: "filled",
+					sampleType: "sample",
+					metadata: {
+						label: `${prefix}${paddedNum}`,
+						injectionVolume: rack.injectionVolume,
+						injectionCount: 1
+					}
 				};
 			}
-			internalState.value.plates = Array.from(plateMap.values());
-			internalState.value.samples = Array.from(sampleMap.values());
-			internalState.value.activePlateId = internalState.value.plates[0]?.id || "";
-			internalState.value.selectedWells = [];
-			updateSampleCounts();
-			return true;
-		} catch {
-			return false;
+			counter++;
 		}
 	}
-	function loadState(state) {
-		saveToHistory();
-		if (state.plates && state.plates.length > 0) {
-			internalState.value.plates = cloneValue(state.plates);
-			internalState.value.activePlateId = state.activePlateId ?? state.plates[0].id;
+	function moveWell(rackId, sourceWellId, targetWellId) {
+		const rack = racks.value.find((r) => r.id === rackId);
+		if (!rack) return;
+		const { [sourceWellId]: source, [targetWellId]: target } = rack.wells;
+		delete rack.wells[sourceWellId];
+		delete rack.wells[targetWellId];
+		if (target) rack.wells[sourceWellId] = placed(target, sourceWellId);
+		if (source) rack.wells[targetWellId] = placed(source, targetWellId);
+	}
+	/** A moved well keeps its position fields in step with its new key. */
+	function placed(well, wellId) {
+		if (well.id === void 0) return well;
+		const [, row = "", col = ""] = /^([A-Z]+)(\d+)$/.exec(wellId) ?? [];
+		return {
+			...well,
+			id: wellId,
+			row: rowIndex(row),
+			col: Number(col) - 1
+		};
+	}
+	function assignWells(rackId, wellIds, groupId) {
+		const rack = racks.value.find((r) => r.id === rackId);
+		for (const wellId of wellIds) {
+			const sampleType = rack?.wells[wellId]?.sampleType ?? "sample";
+			if (groupId) setWellData(rackId, wellId, {
+				state: "filled",
+				sampleType,
+				group: groupId
+			});
+			else clearWell(rackId, wellId);
 		}
-		if (state.samples) internalState.value.samples = cloneValue(state.samples);
-		internalState.value.selectedWells = state.selectedWells ?? [];
-		internalState.value.activeSampleId = state.activeSampleId;
-		updateSampleCounts();
 	}
-	function reset() {
-		const plate = createEmptyPlate("Plate 1", defaultFormat);
-		internalState.value = {
-			plates: [plate],
-			activePlateId: plate.id,
-			samples: [],
-			selectedWells: [],
-			activeSampleId: void 0
+	const undoStack = ref([]);
+	const redoStack = ref([]);
+	const canUndo = computed(() => undoStack.value.length > 0);
+	const canRedo = computed(() => redoStack.value.length > 0);
+	/** The racks as the history last saw them. */
+	let known = JSON.stringify(racks.value);
+	function pushUndo(snapshot) {
+		undoStack.value = [...undoStack.value, snapshot].slice(-50);
+		redoStack.value = [];
+	}
+	/** Records a change made since the history last looked, as its own step. */
+	function absorb() {
+		const now = JSON.stringify(racks.value);
+		if (now === known) return;
+		pushUndo({
+			racks: known,
+			activeRackId: activeRackId.value
+		});
+		known = now;
+	}
+	watch(racks, absorb, { deep: true });
+	function step(from, to) {
+		absorb();
+		const snapshot = from.value.pop();
+		if (snapshot === void 0) return;
+		to.value.push({
+			racks: known,
+			activeRackId: activeRackId.value
+		});
+		racks.value = JSON.parse(snapshot.racks);
+		known = snapshot.racks;
+		activeRackId.value = racks.value.some((rack) => rack.id === snapshot.activeRackId) ? snapshot.activeRackId : racks.value[0]?.id ?? "";
+	}
+	const undo = () => step(undoStack, redoStack);
+	const redo = () => step(redoStack, undoStack);
+	function clearHistory() {
+		undoStack.value = [];
+		redoStack.value = [];
+		known = JSON.stringify(racks.value);
+	}
+	/** Runs `apply` and records the prior state when it changed anything. */
+	function recorded(apply) {
+		return (...args) => {
+			absorb();
+			const before = {
+				racks: known,
+				activeRackId: activeRackId.value
+			};
+			const result = apply(...args);
+			const after = JSON.stringify(racks.value);
+			if (after !== known) {
+				pushUndo(before);
+				known = after;
+			}
+			return result;
 		};
-		history.value = [];
-		historyIndex.value = -1;
+	}
+	const plateEditorListeners = {
+		"update:activeRackId": setActiveRack,
+		"rack-add": recorded(() => {
+			addRack();
+		}),
+		"rack-remove": recorded(removeRack),
+		"rack-reorder": recorded((rackIds) => {
+			racks.value = rackIds.flatMap((id) => racks.value.filter((rack) => rack.id === id));
+		}),
+		"update:format": recorded((rackId, format) => updateRack(rackId, { format })),
+		"update:slot": recorded((rackId, slot) => updateRack(rackId, { slot })),
+		"well-edit": recorded((rackId, wellId, data) => setWellData(rackId, wellId, wellFromEditData(data))),
+		"well-clear": recorded(clearWell),
+		"well-move": recorded(moveWell),
+		"sample-drop": recorded((rackId, wellId, data) => {
+			const rack = racks.value.find((r) => r.id === rackId);
+			const well = rack && wellFromDrop(data, rack);
+			if (well) setWellData(rackId, wellId, well);
+		}),
+		"assign": recorded(assignWells),
+		"clear": recorded(clearAllWells),
+		"fill-series": recorded((rackId) => fillSeries(rackId)),
+		"undo": undo,
+		"redo": redo
+	};
+	function getAllWells() {
+		const result = [];
+		for (const rack of racks.value) for (const [wellId, well] of Object.entries(rack.wells)) result.push({
+			rackId: rack.id,
+			wellId,
+			well
+		});
+		return result;
+	}
+	const totalSampleCount = computed(() => {
+		let count = 0;
+		for (const rack of racks.value) count += Object.keys(rack.wells).length;
+		return count;
+	});
+	function reset() {
+		const rack = createDefaultRack("Rack 1", 0);
+		racks.value = [rack];
+		activeRackId.value = rack.id;
+		clearHistory();
 	}
 	return {
-		state,
-		plates,
-		activePlate,
-		samples,
-		selectedWells,
-		activeSampleId,
-		canUndo,
-		canRedo,
-		setActivePlate,
-		setActiveSample,
-		setSelectedWells,
-		addPlate,
-		removePlate,
-		addSample,
-		removeSample,
-		assignSample,
-		clearWells,
+		racks,
+		activeRack,
+		activeRackId,
+		addRack: recorded(addRack),
+		removeRack: recorded(removeRack),
+		reorderRacks: recorded(reorderRacks),
+		updateRack: recorded(updateRack),
+		setActiveRack,
+		setWellData: recorded(setWellData),
+		clearWell: recorded(clearWell),
+		clearAllWells: recorded(clearAllWells),
+		fillSeries: recorded(fillSeries),
+		moveWell: recorded(moveWell),
+		assignWells: recorded(assignWells),
+		plateEditorListeners,
 		undo,
 		redo,
-		exportData,
-		importData,
-		loadState,
+		canUndo,
+		canRedo,
+		clearHistory,
+		getAllWells,
+		totalSampleCount,
 		reset
 	};
 }
@@ -2328,8 +4167,10 @@ function buildClassSchema(tokenizedMembers, classKind, subKind, classTagPosition
 		});
 	}
 	let usernameAssigned = false;
-	for (const c of columns) if (c.name === "Username") if (usernameAssigned) c.name = "Project";
-	else usernameAssigned = true;
+	for (const c of columns) if (c.name === "Username") {
+		if (usernameAssigned) c.name = "Project";
+		else usernameAssigned = true;
+	}
 	return {
 		classKind,
 		subKind,
@@ -2348,7 +4189,7 @@ function functionalDependency(rows, srcIdx, dstIdx) {
 		const b = row[dstIdx] ?? "";
 		const set = map.get(a);
 		if (set) set.add(b);
-		else map.set(a, new Set([b]));
+		else map.set(a, /* @__PURE__ */ new Set([b]));
 	}
 	if (map.size === 0) return 0;
 	let functional = 0;
@@ -2923,59 +4764,6 @@ function extractSampleNamesFromDesignData(rawData, options = {}) {
 	return extractSampleOptionsFromDesignData(rawData, options).map((sample) => sample.value);
 }
 //#endregion
-//#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 === "\"") if (inQuotes && line[i + 1] === "\"") {
-			current += "\"";
-			i++;
-		} else inQuotes = !inQuotes;
-		else if (char === delimiter && !inQuotes) {
-			result.push(current.trim());
-			current = "";
-		} else current += char;
-	}
-	result.push(current.trim());
-	return result;
-}
-function parseCSV(text) {
-	const lines = text.trim().split("\n");
-	if (lines.length < 2) throw new Error("CSV must have at least a header and one data row");
-	const firstLine = lines[0];
-	const csvDelimiter = firstLine.includes("	") ? "	" : ",";
-	const headers = parseCSVLine(firstLine, csvDelimiter);
-	const rows = [];
-	for (let i = 1; i < lines.length; i++) {
-		const values = parseCSVLine(lines[i], csvDelimiter);
-		if (values.length !== headers.length) continue;
-		const row = {};
-		headers.forEach((h, idx) => {
-			row[h] = values[idx];
-		});
-		rows.push(row);
-	}
-	const sampleKeywords = [
-		"sample",
-		"name",
-		"id",
-		"sample_name",
-		"samplename",
-		"file name",
-		"filename",
-		"file_name"
-	];
-	return {
-		columns: headers,
-		rows,
-		sampleColumn: headers.find((h) => sampleKeywords.includes(h.toLowerCase())) ?? headers[0],
-		delimiter: csvDelimiter
-	};
-}
-//#endregion
 //#region src/composables/useAutoGroup.ts
 var STRUCTURED_MISSING_GROUP = "Outlier";
 var deprecationWarned = false;
@@ -2986,6 +4774,11 @@ function warnDeprecated(api) {
 	console.warn(`[useAutoGroup] ${api} is deprecated; use the new class-first API (setClassDisposition / toggleGroupBy / setValueOps).`);
 	deprecationWarned = true;
 }
+/**
+* Sample-grouping engine behind `AutoGroupModal`.
+*
+* @deprecated Scheduled for removal in MINT 1.4; no SDK replacement.
+*/
 function useAutoGroup() {
 	const inputMode = ref("paste");
 	const rawText = ref("");
@@ -3031,13 +4824,14 @@ function useAutoGroup() {
 		}
 		const tokens = csv.rows.map((r) => nonSampleCols.map((col) => r[col] ?? ""));
 		tokenized.value = tokens;
-		classes.value = [{
+		const structuredClass = {
 			kind: "unknown",
 			label: "Unknown",
 			members: csv.rows.map((_, i) => i),
 			classTagPositions: [],
 			disposition: "group"
-		}];
+		};
+		classes.value = [structuredClass];
 		const schema = buildClassSchema(tokens, "unknown", void 0, []);
 		schema.columns = schema.columns.map((c, i) => ({
 			...c,
@@ -3438,6 +5232,11 @@ function useAutoGroup() {
 		renameField
 	};
 }
+/**
+* Reads experiment `design_data` samples into the `useAutoGroup` CSV shape.
+*
+* @deprecated Scheduled for removal in MINT 1.4 together with `useAutoGroup`.
+*/
 function extractSamplesFromDesignData(rawData, options = {}) {
 	const designData = unwrapExperimentDesignData(rawData);
 	if (!designData) return null;
@@ -3538,7 +5337,8 @@ function useFileImport(options = {}) {
 			result.value = parsed;
 			return parsed;
 		} catch (err) {
-			error.value = readErrorMessage(err, "Failed to import file.");
+			const message = readErrorMessage(err, "Failed to import file.");
+			error.value = message;
 			throw err;
 		} finally {
 			loading.value = false;
@@ -3645,8 +5445,8 @@ function countChar(value, char) {
 }
 function formatBytes(bytes) {
 	if (bytes < 1024) return `${bytes} B`;
-	if (bytes < 1024 * 1024) return `${Math.round(bytes / 1024)} KB`;
-	return `${Math.round(bytes / (1024 * 1024))} MB`;
+	if (bytes < 1048576) return `${Math.round(bytes / 1024)} KB`;
+	return `${Math.round(bytes / 1048576)} MB`;
 }
 //#endregion
 //#region src/utils/sampleGroupPath.ts
@@ -3797,7 +5597,7 @@ function useExpansionSet(options = {}) {
 	}
 	function expand(id) {
 		if (expandedIds.value.has(id)) return;
-		expandedIds.value = new Set([...expandedIds.value, id]);
+		expandedIds.value = /* @__PURE__ */ new Set([...expandedIds.value, id]);
 	}
 	function collapse(id) {
 		if (!expandedIds.value.has(id)) return;
@@ -3814,7 +5614,7 @@ function useExpansionSet(options = {}) {
 		return true;
 	}
 	function expandMany(ids) {
-		expandedIds.value = new Set([...expandedIds.value, ...normalizeIds(ids)]);
+		expandedIds.value = /* @__PURE__ */ new Set([...expandedIds.value, ...normalizeIds(ids)]);
 	}
 	function setExpanded(ids) {
 		expandedIds.value = new Set(normalizeIds(ids));
@@ -4165,15 +5965,18 @@ function minutesToDate(baseDate, minutes) {
 }
 function clampRange(start, end, min, max) {
 	const s = Math.max(start, min);
-	const e = Math.min(end, max);
 	return {
 		start: s,
-		end: Math.max(e, s)
+		end: Math.max(Math.min(end, max), s)
 	};
 }
 //#endregion
 //#region src/composables/useExperimentSave.ts
-/** Persists experiment design, analysis, and built-in template preset data through the platform API. */
+/**
+* Persists experiment design, analysis, and built-in template preset data through the platform API.
+*
+* @deprecated Scheduled for removal in MINT 1.4; no SDK replacement.
+*/
 function useExperimentSave(options = {}) {
 	const injectedContext = getInjectedPlatformContext();
 	const api = useApi({ baseUrl: options.apiBaseUrl ?? injectedContext?.platformApiUrl });
@@ -4371,7 +6174,11 @@ function useExperimentSave(options = {}) {
 }
 //#endregion
 //#region src/composables/useTemplateCollection.ts
-/** Manages a biology template collection in the current experiment's design_data. */
+/**
+* Manages a biology template collection in the current experiment's design_data.
+*
+* @deprecated Scheduled for removal in MINT 1.4; no SDK replacement.
+*/
 function useTemplateCollection(options = {}) {
 	const experimentSave = useExperimentSave(options);
 	const templateCollection = ref(createInitialCollection(options));
@@ -4467,7 +6274,11 @@ function readCollectionMetadata(value) {
 }
 //#endregion
 //#region src/composables/useBioTemplateControls.ts
-/** Build FormBuilder schema, AppSidebar panels, and defaults for a built-in biology template or preset. */
+/**
+* Build FormBuilder schema, AppSidebar panels, and defaults for a built-in biology template or preset.
+*
+* @deprecated Scheduled for removal in MINT 1.4; no SDK replacement.
+*/
 function useBioTemplateControls(target, options = {}) {
 	const { initialValues, topBarSettings: _topBarSettings, ...schemaOptions } = options;
 	const controls = createBioTemplateControlToolkit(target, schemaOptions);
@@ -4482,15 +6293,27 @@ function useBioTemplateControls(target, options = {}) {
 }
 //#endregion
 //#region src/composables/useBioTemplateComponents.ts
-/** Return component props grouped by SDK component name for direct WellPlate/DoseCalculator binding. */
+/**
+* Return component props grouped by SDK component name for direct WellPlate/DoseCalculator binding.
+*
+* @deprecated Scheduled for removal in MINT 1.4; no SDK replacement.
+*/
 function toBioTemplateComponentPropsByComponent(target) {
 	return toBioTemplateComponentPropsByComponent$1(target);
 }
-/** Return the first props object for an SDK component, optionally restricted by template id or binding id. */
+/**
+* Return the first props object for an SDK component, optionally restricted by template id or binding id.
+*
+* @deprecated Scheduled for removal in MINT 1.4; no SDK replacement.
+*/
 function getBioTemplateComponentProps(target, component, options = {}) {
 	return getBioTemplateComponentProps$1(target, component, options);
 }
-/** Map built-in biology templates to SDK components such as WellPlate, DataFrame, DoseCalculator, and PlateMapEditor. */
+/**
+* Map built-in biology templates to SDK components such as WellPlate, DataFrame, DoseCalculator, and PlateEditor.
+*
+* @deprecated Scheduled for removal in MINT 1.4; no SDK replacement.
+*/
 function useBioTemplateComponents(target) {
 	return {
 		bindings: getBioTemplateComponentBindings(target),
@@ -4558,7 +6381,11 @@ function liftWorkspaceComponentBindings(workspace) {
 }
 //#endregion
 //#region src/composables/useBioTemplateWorkspace.ts
-/** One-stop wiring for BioTemplateRenderer, FormBuilder, AppSidebar, and template-aware SDK components. */
+/**
+* One-stop wiring for BioTemplateRenderer, FormBuilder, AppSidebar, and template-aware SDK components.
+*
+* @deprecated Scheduled for removal in MINT 1.4; no SDK replacement.
+*/
 function useBioTemplateWorkspace(target, options = {}) {
 	const controls = useBioTemplateControls(target, options);
 	const workspace = useControlWorkspace(controls.controls, options);
@@ -4615,6 +6442,8 @@ function isTemplateObjectTarget(target) {
 * const pack = useBioTemplatePackWorkspace('cell-culture-screen')
 * await pack.loadCurrent()
 * ```
+*
+* @deprecated Scheduled for removal in MINT 1.4; no SDK replacement.
 */
 function useBioTemplatePackWorkspace(packId, options = {}) {
 	const pack = getBioTemplatePackInfo(packId);
@@ -4695,7 +6524,11 @@ function useBioTemplatePackWorkspace(packId, options = {}) {
 }
 //#endregion
 //#region src/composables/useBioTemplatePresetWorkspace.ts
-/** Create a complete editable WellPlate/DoseCalculator workspace for dose design from a built-in biology template preset with current-experiment save wiring. */
+/**
+* Create a complete editable WellPlate/DoseCalculator workspace for dose design from a built-in biology template preset with current-experiment save wiring.
+*
+* @deprecated Scheduled for removal in MINT 1.4; no SDK replacement.
+*/
 function useBioTemplatePresetWorkspace(presetId, options = {}) {
 	const { controlOptions, initialValues, ...collectionOptions } = options;
 	const resolvedControlOptions = mergeInitialValues(controlOptions, initialValues);
@@ -4779,241 +6612,98 @@ function useBioTemplatePresetWorkspace(presetId, options = {}) {
 	function applyCollection(value) {
 		return templateCollection.apply(value);
 	}
-	function setActiveControlView(viewId) {
-		if (!controlViewIds.value.includes(viewId)) return;
-		activeControlView.value = viewId;
-	}
-	function setControlValues(values) {
-		const nextValues = { ...values };
-		controlValues.value = nextValues;
-		syncControlValueBindings(nextValues);
-		return templateCollection.apply(createBioTemplatePresetCollectionFromControls(presetId, nextValues));
-	}
-	function updateControlValues(values) {
-		return setControlValues({
-			...controlValues.value,
-			...values
-		});
-	}
-	function resetToDefaultCollection() {
-		return setControlValues({ ...controls.initialValues });
-	}
-	function syncControlValueBindings(values) {
-		form.modelValue = values;
-		sidebar.modelValue = values;
-		sidebar.values = values;
-		topBarSettings.settingsConfig = {
-			...topBarSettings.settingsConfig,
-			values
-		};
-	}
-	return {
-		presetId,
-		presetInfo,
-		presetLabel,
-		collection,
-		templates: templateCollection.templates,
-		templateIds: templateCollection.templateIds,
-		currentExperimentId: templateCollection.currentExperimentId,
-		hasCurrentExperiment: templateCollection.hasCurrentExperiment,
-		saving: templateCollection.isSaving,
-		error: templateCollection.error,
-		lastSavedAt: templateCollection.lastSavedAt,
-		controls,
-		controlSchema: controls.controls,
-		controlValues,
-		controlViewIds,
-		controlViewItems,
-		activeControlView,
-		form,
-		sidebar,
-		topBar: topBarProps,
-		pillNav,
-		topBarSettings,
-		bindings,
-		renderer,
-		workspace,
-		componentBindings,
-		componentBindingsById,
-		componentImports,
-		componentProps,
-		componentPropsById,
-		componentPropsByComponent,
-		componentSnippets,
-		componentUsage,
-		getComponentProps,
-		setActiveControlView,
-		setControlValues,
-		updateControlValues,
-		applyCollection,
-		resetToDefaultCollection,
-		save: templateCollection.save,
-		saveCurrent: templateCollection.saveCurrent
-	};
-}
-function humanizePresetId(value) {
-	return value.replace(/[-_]+/g, " ").replace(/\b\w/g, (match) => match.toUpperCase());
-}
-function mergeInitialValues(controlOptions, initialValues) {
-	if (initialValues === void 0) return controlOptions;
-	return {
-		...controlOptions ?? {},
-		initialValues: {
-			...controlOptions?.initialValues ?? {},
-			...initialValues
-		}
-	};
-}
-//#endregion
-//#region src/composables/useRackEditor.ts
-var SLOT_CYCLE = [
-	"R",
-	"G",
-	"B",
-	"Y"
-];
-var globalIdCounter = 0;
-function generateId() {
-	globalIdCounter++;
-	return `rack-${Date.now()}-${globalIdCounter}`;
-}
-/** Manages a set of sample racks with well-level assignment, series fill, and multi-rack reordering. */
-function useRackEditor(initialRacks, options) {
-	const defaultFormat = options?.defaultFormat ?? 54;
-	const defaultInjVol = options?.defaultInjectionVolume ?? 5;
-	const maxRacks = options?.maxRacks ?? 10;
-	const minRacks = options?.minRacks ?? 1;
-	function createDefaultRack(name, slotIndex) {
-		const slot = SLOT_CYCLE[(slotIndex ?? 0) % SLOT_CYCLE.length];
-		return {
-			id: generateId(),
-			name: name ?? `Rack ${racks.value.length + 1}`,
-			format: defaultFormat,
-			slot,
-			injectionVolume: defaultInjVol,
-			wells: {}
-		};
-	}
-	const racks = ref(initialRacks && initialRacks.length > 0 ? initialRacks.map((r) => ({ ...r })) : [createDefaultRack("Rack 1", 0)]);
-	const activeRackId = ref(racks.value[0]?.id ?? "");
-	const activeRack = computed(() => racks.value.find((r) => r.id === activeRackId.value) ?? racks.value[0]);
-	function addRack(name) {
-		if (racks.value.length >= maxRacks) return racks.value[racks.value.length - 1];
-		const rack = createDefaultRack(name, racks.value.length);
-		racks.value.push(rack);
-		activeRackId.value = rack.id;
-		return rack;
-	}
-	function removeRack(rackId) {
-		if (racks.value.length <= minRacks) return;
-		const index = racks.value.findIndex((r) => r.id === rackId);
-		if (index === -1) return;
-		racks.value.splice(index, 1);
-		if (activeRackId.value === rackId && racks.value[0]) activeRackId.value = racks.value[0].id;
-	}
-	function reorderRacks(fromIndex, toIndex) {
-		if (fromIndex < 0 || fromIndex >= racks.value.length) return;
-		if (toIndex < 0 || toIndex >= racks.value.length) return;
-		if (fromIndex === toIndex) return;
-		const [moved] = racks.value.splice(fromIndex, 1);
-		if (moved) racks.value.splice(toIndex, 0, moved);
-	}
-	function updateRack(rackId, data) {
-		const rack = racks.value.find((r) => r.id === rackId);
-		if (!rack) return;
-		if (data.name !== void 0) rack.name = data.name;
-		if (data.format !== void 0) rack.format = data.format;
-		if (data.slot !== void 0) rack.slot = data.slot;
-		if (data.injectionVolume !== void 0) rack.injectionVolume = data.injectionVolume;
-		if (data.wells !== void 0) rack.wells = data.wells;
-	}
-	function setActiveRack(rackId) {
-		if (racks.value.some((r) => r.id === rackId)) activeRackId.value = rackId;
-	}
-	function setWellData(rackId, wellId, data) {
-		const rack = racks.value.find((r) => r.id === rackId);
-		if (!rack) return;
-		rack.wells[wellId] = {
-			...rack.wells[wellId],
-			...data
-		};
-	}
-	function clearWell(rackId, wellId) {
-		const rack = racks.value.find((r) => r.id === rackId);
-		if (!rack) return;
-		delete rack.wells[wellId];
-	}
-	function clearAllWells(rackId) {
-		const rack = racks.value.find((r) => r.id === rackId);
-		if (!rack) return;
-		rack.wells = {};
-	}
-	function fillSeries(rackId, prefix = "S") {
-		const rack = racks.value.find((r) => r.id === rackId);
-		if (!rack) return;
-		const config = PLATE_CONFIGS[rack.format];
-		if (!config) return;
-		let counter = 1;
-		for (let row = 0; row < config.rows; row++) for (let col = 0; col < config.cols; col++) {
-			const wellId = `${rowLabel(row)}${col + 1}`;
-			if (!rack.wells[wellId]?.sampleType) {
-				const paddedNum = String(counter).padStart(3, "0");
-				rack.wells[wellId] = {
-					id: wellId,
-					row,
-					col,
-					state: "filled",
-					sampleType: "sample",
-					metadata: {
-						label: `${prefix}${paddedNum}`,
-						injectionVolume: rack.injectionVolume,
-						injectionCount: 1
-					}
-				};
-			}
-			counter++;
-		}
+	function setActiveControlView(viewId) {
+		if (!controlViewIds.value.includes(viewId)) return;
+		activeControlView.value = viewId;
 	}
-	function getAllWells() {
-		const result = [];
-		for (const rack of racks.value) for (const [wellId, well] of Object.entries(rack.wells)) result.push({
-			rackId: rack.id,
-			wellId,
-			well
+	function setControlValues(values) {
+		const nextValues = { ...values };
+		controlValues.value = nextValues;
+		syncControlValueBindings(nextValues);
+		return templateCollection.apply(createBioTemplatePresetCollectionFromControls(presetId, nextValues));
+	}
+	function updateControlValues(values) {
+		return setControlValues({
+			...controlValues.value,
+			...values
 		});
-		return result;
 	}
-	const totalSampleCount = computed(() => {
-		let count = 0;
-		for (const rack of racks.value) count += Object.keys(rack.wells).length;
-		return count;
-	});
-	function reset() {
-		const rack = createDefaultRack("Rack 1", 0);
-		racks.value = [rack];
-		activeRackId.value = rack.id;
+	function resetToDefaultCollection() {
+		return setControlValues({ ...controls.initialValues });
+	}
+	function syncControlValueBindings(values) {
+		form.modelValue = values;
+		sidebar.modelValue = values;
+		sidebar.values = values;
+		topBarSettings.settingsConfig = {
+			...topBarSettings.settingsConfig,
+			values
+		};
 	}
 	return {
-		racks,
-		activeRack,
-		activeRackId,
-		addRack,
-		removeRack,
-		reorderRacks,
-		updateRack,
-		setActiveRack,
-		setWellData,
-		clearWell,
-		clearAllWells,
-		fillSeries,
-		getAllWells,
-		totalSampleCount,
-		reset
+		presetId,
+		presetInfo,
+		presetLabel,
+		collection,
+		templates: templateCollection.templates,
+		templateIds: templateCollection.templateIds,
+		currentExperimentId: templateCollection.currentExperimentId,
+		hasCurrentExperiment: templateCollection.hasCurrentExperiment,
+		saving: templateCollection.isSaving,
+		error: templateCollection.error,
+		lastSavedAt: templateCollection.lastSavedAt,
+		controls,
+		controlSchema: controls.controls,
+		controlValues,
+		controlViewIds,
+		controlViewItems,
+		activeControlView,
+		form,
+		sidebar,
+		topBar: topBarProps,
+		pillNav,
+		topBarSettings,
+		bindings,
+		renderer,
+		workspace,
+		componentBindings,
+		componentBindingsById,
+		componentImports,
+		componentProps,
+		componentPropsById,
+		componentPropsByComponent,
+		componentSnippets,
+		componentUsage,
+		getComponentProps,
+		setActiveControlView,
+		setControlValues,
+		updateControlValues,
+		applyCollection,
+		resetToDefaultCollection,
+		save: templateCollection.save,
+		saveCurrent: templateCollection.saveCurrent
+	};
+}
+function humanizePresetId(value) {
+	return value.replace(/[-_]+/g, " ").replace(/\b\w/g, (match) => match.toUpperCase());
+}
+function mergeInitialValues(controlOptions, initialValues) {
+	if (initialValues === void 0) return controlOptions;
+	return {
+		...controlOptions ?? {},
+		initialValues: {
+			...controlOptions?.initialValues ?? {},
+			...initialValues
+		}
 	};
 }
 //#endregion
 //#region src/composables/useGroupAssignment.ts
-/** Shared two-zone group assignment model for control/treatment style workflows. */
+/**
+* Shared two-zone group assignment model for control/treatment style workflows.
+*
+* @deprecated Scheduled for removal in MINT 1.4; no SDK replacement.
+*/
 function useGroupAssignment(options) {
 	const groups = computed(() => [...toValue(options.groups)]);
 	const group1 = computed(() => [...toValue(options.group1)]);
@@ -5619,6 +7309,510 @@ function useProtocolTemplates() {
 	};
 }
 //#endregion
+//#region src/composables/useDebouncedWatch.ts
+/** Watch a Vue source with debounced callback execution and explicit cancel/flush controls. */
+function useDebouncedWatch(source, callback, options = {}) {
+	const { delay = 300, ...watchOptions } = options;
+	const isPending = ref(false);
+	let timer = null;
+	let hasLatestValue = false;
+	let latestValue;
+	let latestOldValue;
+	let callbackCleanup = null;
+	let stopped = false;
+	function clearTimer() {
+		if (timer) {
+			clearTimeout(timer);
+			timer = null;
+		}
+		isPending.value = false;
+	}
+	function runCallbackCleanup() {
+		if (!callbackCleanup) return;
+		callbackCleanup();
+		callbackCleanup = null;
+	}
+	function cancel() {
+		clearTimer();
+		hasLatestValue = false;
+		latestOldValue = void 0;
+	}
+	function flush() {
+		if (!hasLatestValue) return;
+		const value = latestValue;
+		const oldValue = latestOldValue;
+		cancel();
+		runCallbackCleanup();
+		callback(value, oldValue, (cleanup) => {
+			callbackCleanup = cleanup;
+		});
+	}
+	function schedule(value, oldValue) {
+		cancel();
+		hasLatestValue = true;
+		latestValue = value;
+		latestOldValue = oldValue;
+		isPending.value = true;
+		timer = setTimeout(flush, delay);
+	}
+	const stopWatch = watch(source, (value, oldValue, onCleanup) => {
+		schedule(value, oldValue);
+		onCleanup(() => {
+			cancel();
+			runCallbackCleanup();
+		});
+	}, watchOptions);
+	function stop() {
+		if (stopped) return;
+		stopped = true;
+		stopWatch();
+		cancel();
+		runCallbackCleanup();
+	}
+	onScopeDispose(stop);
+	return {
+		isPending,
+		cancel,
+		flush,
+		stop
+	};
+}
+//#endregion
+//#region src/composables/useExperimentSelector.ts
+function getPlatformContext() {
+	if (typeof window === "undefined") return void 0;
+	return window.__MINT_PLATFORM__;
+}
+function getPlatformApiUrl() {
+	return getPlatformContext()?.platformApiUrl;
+}
+/** Fetches a paginated, filtered experiment list from the platform API for picker and selector UIs. */
+function useExperimentSelector(options = {}) {
+	const { limit = 100, immediate = false, experimentType, allowedExperimentTypes: optionAllowedExperimentTypes, apiBaseUrl } = options;
+	const platformBase = apiBaseUrl ?? getPlatformApiUrl();
+	const api = useApi();
+	const experiments = ref([]);
+	const total = ref(0);
+	const selectedExperiment = ref(null);
+	const request = useRequestSyncState("Failed to fetch experiments");
+	const isLoading = request.loading;
+	const error = request.error;
+	const lastLoadedAt = request.lastLoadedAt;
+	const page = ref(0);
+	let fetchGeneration = 0;
+	const sortKey = ref("created_at:desc");
+	const experimentTypes = ref([]);
+	const projects = ref([]);
+	let filterOptionsFetched = false;
+	const hasMore = computed(() => experiments.value.length < total.value);
+	const filters = reactive({
+		search: void 0,
+		status: void 0,
+		project: void 0,
+		experimentType: void 0,
+		datePreset: void 0
+	});
+	function normalizeExperimentTypes(values) {
+		if (values == null) return null;
+		return [...new Set(values.filter((value) => typeof value === "string" && value.length > 0))];
+	}
+	function currentAllowedExperimentTypes() {
+		if (optionAllowedExperimentTypes !== void 0) return normalizeExperimentTypes(optionAllowedExperimentTypes);
+		return normalizeExperimentTypes(getPlatformContext()?.allowedExperimentTypes);
+	}
+	function parseSortKey() {
+		const [field, order] = sortKey.value.split(":");
+		return {
+			sortBy: field || "created_at",
+			sortOrder: order || "desc"
+		};
+	}
+	function resolveExperimentTypeScope() {
+		const allowedTypes = currentAllowedExperimentTypes();
+		const selectedType = experimentType ?? filters.experimentType ?? void 0;
+		if (selectedType) {
+			if (allowedTypes && !allowedTypes.includes(selectedType)) return { kind: "blocked" };
+			return {
+				kind: "single",
+				experimentType: selectedType
+			};
+		}
+		if (allowedTypes) {
+			if (allowedTypes.length === 0) return { kind: "blocked" };
+			if (allowedTypes.length === 1) return {
+				kind: "single",
+				experimentType: allowedTypes[0]
+			};
+			return {
+				kind: "multi",
+				experimentTypes: allowedTypes
+			};
+		}
+		return { kind: "all" };
+	}
+	function buildExperimentListUrl(typeFilter, skip, pageLimit) {
+		const params = new URLSearchParams();
+		if (typeFilter) params.set("experiment_type", typeFilter);
+		if (filters.status) params.set("status", filters.status);
+		if (filters.search) params.set("search", filters.search);
+		if (filters.project) params.set("project", filters.project);
+		const { sortBy, sortOrder } = parseSortKey();
+		params.set("sort_by", sortBy);
+		params.set("sort_order", sortOrder);
+		if (filters.datePreset) params.set("created_after", datePresetToISO(filters.datePreset));
+		params.set("limit", String(pageLimit));
+		params.set("skip", String(skip));
+		const query = params.toString();
+		return `${platformBase ?? ""}/experiments${query ? `?${query}` : ""}`;
+	}
+	function sortExperiments(items) {
+		const { sortBy, sortOrder } = parseSortKey();
+		const direction = sortOrder === "desc" ? -1 : 1;
+		return [...items].sort((a, b) => {
+			const aValue = a[sortBy] ?? "";
+			const bValue = b[sortBy] ?? "";
+			if (aValue < bValue) return -1 * direction;
+			if (aValue > bValue) return 1 * direction;
+			return 0;
+		});
+	}
+	async function fetchExperimentList(typeFilter, skip, pageLimit) {
+		return await api.get(buildExperimentListUrl(typeFilter, skip, pageLimit));
+	}
+	async function fetchScopedExperimentPage(requestedPage) {
+		const scope = resolveExperimentTypeScope();
+		const pageSkip = requestedPage * limit;
+		if (scope.kind === "blocked") return {
+			experiments: [],
+			total: 0
+		};
+		if (scope.kind === "multi") {
+			const perTypeLimit = pageSkip + limit;
+			const responses = await Promise.all(scope.experimentTypes.map((type) => fetchExperimentList(type, 0, perTypeLimit)));
+			return {
+				experiments: sortExperiments(responses.flatMap((response) => response.experiments)).slice(pageSkip, pageSkip + limit),
+				total: responses.reduce((sum, response) => sum + response.total, 0)
+			};
+		}
+		return await fetchExperimentList(scope.kind === "single" ? scope.experimentType : void 0, pageSkip, limit);
+	}
+	async function fetchExperiments() {
+		const generation = ++fetchGeneration;
+		const requestedPage = page.value;
+		isLoading.value = true;
+		request.clearError();
+		try {
+			const data = await fetchScopedExperimentPage(requestedPage);
+			if (generation !== fetchGeneration) return;
+			if (requestedPage === 0) experiments.value = data.experiments;
+			else experiments.value = [...experiments.value, ...data.experiments];
+			total.value = data.total;
+			request.markLoaded();
+		} catch (err) {
+			if (generation !== fetchGeneration) return;
+			request.setError(err, "Failed to fetch experiments");
+			if (requestedPage === 0) {
+				experiments.value = [];
+				total.value = 0;
+			}
+		} finally {
+			if (generation === fetchGeneration) isLoading.value = false;
+		}
+	}
+	function invalidateFetch() {
+		fetchGeneration += 1;
+		isLoading.value = false;
+	}
+	async function fetchFilterOptions() {
+		if (filterOptionsFetched) return;
+		filterOptionsFetched = true;
+		const base = platformBase ?? "";
+		const [typesRes, projectsRes] = await Promise.allSettled([api.get(`${base}/experiments/experiment-types`), api.get(`${base}/projects`)]);
+		if (typesRes.status === "fulfilled" && Array.isArray(typesRes.value)) {
+			const allowedTypes = currentAllowedExperimentTypes();
+			const allowedSet = allowedTypes ? new Set(allowedTypes) : null;
+			experimentTypes.value = typesRes.value.filter((t) => !allowedSet || allowedSet.has(t.value)).map((t) => ({
+				value: t.value,
+				label: t.label,
+				color: t.color
+			}));
+			if (filters.experimentType && allowedSet && !allowedSet.has(filters.experimentType)) filters.experimentType = void 0;
+		}
+		if (projectsRes.status === "fulfilled" && projectsRes.value?.projects && Array.isArray(projectsRes.value.projects)) projects.value = projectsRes.value.projects.map((p) => ({
+			value: p.name,
+			label: p.name
+		}));
+	}
+	async function loadMore() {
+		if (!hasMore.value || isLoading.value) return;
+		page.value++;
+		await fetchExperiments();
+	}
+	function reset() {
+		page.value = 0;
+		experiments.value = [];
+		total.value = 0;
+		fetchExperiments();
+	}
+	function select(experiment) {
+		selectedExperiment.value = experiment;
+	}
+	function clear() {
+		invalidateFetch();
+		selectedExperiment.value = null;
+		filters.search = void 0;
+		filters.status = void 0;
+		filters.project = void 0;
+		filters.experimentType = void 0;
+		filters.datePreset = void 0;
+		sortKey.value = "created_at:desc";
+		page.value = 0;
+		request.clearError();
+	}
+	const groupedByProject = computed(() => {
+		const groups = /* @__PURE__ */ new Map();
+		for (const exp of experiments.value) {
+			const key = exp.project_name ?? exp.project ?? "No project";
+			const list = groups.get(key);
+			if (list) list.push(exp);
+			else groups.set(key, [exp]);
+		}
+		return [...groups.entries()].sort(([a], [b]) => {
+			if (a === "No project") return 1;
+			if (b === "No project") return -1;
+			return a.localeCompare(b);
+		});
+	});
+	watch(() => [
+		filters.search,
+		filters.status,
+		filters.project,
+		filters.experimentType,
+		filters.datePreset,
+		sortKey.value
+	], () => invalidateFetch(), { flush: "sync" });
+	const searchWatch = useDebouncedWatch(() => filters.search, () => {
+		page.value = 0;
+		fetchExperiments();
+	}, { delay: 300 });
+	watch(() => [
+		filters.status,
+		filters.project,
+		filters.experimentType,
+		filters.datePreset,
+		sortKey.value
+	], () => {
+		searchWatch.cancel();
+		page.value = 0;
+		fetchExperiments();
+	});
+	if (immediate) fetchExperiments();
+	return {
+		experiments,
+		total,
+		selectedExperiment,
+		filters,
+		isLoading,
+		error,
+		lastLoadedAt,
+		page,
+		hasMore,
+		sortKey,
+		experimentTypes,
+		projects,
+		groupedByProject,
+		fetch: fetchExperiments,
+		loadMore,
+		reset,
+		select,
+		clear,
+		fetchFilterOptions
+	};
+}
+//#endregion
+//#region src/composables/useAnalysisArtifacts.ts
+/**
+* Lists and manages analysis artifacts through the user-facing platform API.
+*
+* @example Recommended
+* ```ts
+* const artifacts = useAnalysisArtifacts({ pluginId: 'LEAF' })
+* await artifacts.list()
+* ```
+*/
+function useAnalysisArtifacts(options = {}) {
+	const injectedContext = getInjectedPlatformContext();
+	const api = useApi({ baseUrl: options.apiBaseUrl ?? injectedContext?.platformApiUrl });
+	const currentExperimentId = computed(() => toValue(options.experimentId) ?? resolveCurrentExperimentId(injectedContext));
+	const hasCurrentExperiment = computed(() => currentExperimentId.value !== void 0);
+	const scopePluginId = computed(() => toValue(options.pluginId) ?? null);
+	const request = useRequestSyncState("Analysis artifact request failed.");
+	const fetchedArtifacts = ref([]);
+	const selectedDetail = ref(null);
+	const loadingCount = ref(0);
+	const mutatingCount = ref(0);
+	const isLoading = computed(() => loadingCount.value > 0);
+	const isMutating = computed(() => mutatingCount.value > 0);
+	const search = ref("");
+	const statusFilter = ref("active");
+	const pluginFilter = ref(null);
+	const needsArchived = computed(() => Boolean(toValue(options.includeArchived)) || statusFilter.value !== "active");
+	const artifacts = computed(() => scopePluginId.value ? fetchedArtifacts.value.filter((artifact) => artifact.plugin_id === scopePluginId.value) : fetchedArtifacts.value);
+	const visibleArtifacts = computed(() => {
+		const query = search.value.trim().toLowerCase();
+		return artifacts.value.filter((artifact) => {
+			if (statusFilter.value !== "all" && artifact.status !== statusFilter.value) return false;
+			if (pluginFilter.value && artifact.plugin_id !== pluginFilter.value) return false;
+			if (!query) return true;
+			return artifact.display_name.toLowerCase().includes(query) || artifact.artifact_key.toLowerCase().includes(query);
+		});
+	});
+	let listToken = 0;
+	let detailToken = 0;
+	const hasRequestedList = ref(false);
+	function currentExperimentIdOrError(action) {
+		const id = currentExperimentId.value;
+		if (id === void 0) {
+			request.setError(`No current experiment is selected for ${action}`);
+			return;
+		}
+		return id;
+	}
+	function replaceArtifact(summary) {
+		const index = fetchedArtifacts.value.findIndex((artifact) => artifact.id === summary.id);
+		if (index >= 0) fetchedArtifacts.value.splice(index, 1, summary);
+	}
+	async function list() {
+		const experimentId = currentExperimentIdOrError("listing analysis artifacts");
+		if (experimentId === void 0) {
+			fetchedArtifacts.value = [];
+			return [];
+		}
+		const token = ++listToken;
+		hasRequestedList.value = true;
+		loadingCount.value += 1;
+		request.clearError();
+		try {
+			const data = await api.get(`/experiments/${experimentId}/analysis-artifacts?include_archived=${needsArchived.value}`);
+			if (token !== listToken) return artifacts.value;
+			fetchedArtifacts.value = [...data?.artifacts ?? []];
+			request.markLoaded();
+			return artifacts.value;
+		} catch (err) {
+			if (token !== listToken) return [];
+			request.setError(err);
+			fetchedArtifacts.value = [];
+			return [];
+		} finally {
+			loadingCount.value -= 1;
+		}
+	}
+	async function getDetail(artifactId) {
+		const experimentId = currentExperimentIdOrError("loading an analysis artifact");
+		if (experimentId === void 0) return null;
+		const token = ++detailToken;
+		loadingCount.value += 1;
+		request.clearError();
+		try {
+			const detail = await api.get(`/experiments/${experimentId}/analysis-artifacts/${artifactId}`);
+			if (token !== detailToken) return null;
+			selectedDetail.value = detail;
+			request.markLoaded();
+			return detail;
+		} catch (err) {
+			if (token !== detailToken) return null;
+			request.setError(err);
+			return null;
+		} finally {
+			loadingCount.value -= 1;
+		}
+	}
+	async function resolveTarget(target) {
+		const experimentId = currentExperimentId.value;
+		if (experimentId !== target.experimentId) {
+			request.setError(`Analysis artifact target belongs to experiment ${target.experimentId}, not ${experimentId ?? "the current selection"}.`);
+			return null;
+		}
+		const summary = (await list()).find((artifact) => artifact.plugin_id === target.artifactPluginId && artifact.artifact_key === target.artifactKey && artifact.status === "active");
+		if (!summary) {
+			request.setError(`Analysis artifact ${target.artifactPluginId}/${target.artifactKey} is not available.`);
+			return null;
+		}
+		const detail = await getDetail(summary.id);
+		if (detail && (detail.experiment_id !== target.experimentId || detail.plugin_id !== target.artifactPluginId || detail.artifact_key !== target.artifactKey)) {
+			selectedDetail.value = null;
+			request.setError(`Analysis artifact ${target.artifactPluginId}/${target.artifactKey} did not match the requested identity.`);
+			return null;
+		}
+		return detail;
+	}
+	async function mutate(action, operation) {
+		const experimentId = currentExperimentIdOrError(action);
+		if (experimentId === void 0) return null;
+		mutatingCount.value += 1;
+		request.clearError();
+		try {
+			const summary = await operation(experimentId);
+			replaceArtifact(summary);
+			request.markSaved();
+			return summary;
+		} catch (err) {
+			request.setError(err);
+			return null;
+		} finally {
+			mutatingCount.value -= 1;
+		}
+	}
+	async function updateMetadata(artifactId, updates) {
+		return mutate("updating artifact metadata", (experimentId) => api.patch(`/experiments/${experimentId}/analysis-artifacts/${artifactId}`, updates));
+	}
+	async function archive(artifactId) {
+		return mutate("archiving an analysis artifact", (experimentId) => api.post(`/experiments/${experimentId}/analysis-artifacts/${artifactId}/archive`));
+	}
+	async function restore(artifactId) {
+		return mutate("restoring an analysis artifact", (experimentId) => api.post(`/experiments/${experimentId}/analysis-artifacts/${artifactId}/restore`));
+	}
+	function hasArtifactKey(artifactKey) {
+		return artifacts.value.some((artifact) => artifact.artifact_key === artifactKey);
+	}
+	/** Drop experiment-scoped state and orphan every in-flight response. */
+	function clear() {
+		listToken += 1;
+		detailToken += 1;
+		fetchedArtifacts.value = [];
+		selectedDetail.value = null;
+		request.clearError();
+	}
+	watch([currentExperimentId, needsArchived], ([experimentId], [previousExperimentId]) => {
+		if (experimentId !== previousExperimentId) clear();
+		if (experimentId === void 0) return;
+		if (options.immediate || hasRequestedList.value) list();
+	}, { immediate: options.immediate });
+	return {
+		artifacts,
+		visibleArtifacts,
+		selectedDetail,
+		currentExperimentId,
+		hasCurrentExperiment,
+		isLoading,
+		isMutating,
+		error: request.error,
+		lastLoadedAt: request.lastLoadedAt,
+		search,
+		statusFilter,
+		pluginFilter,
+		list,
+		refresh: list,
+		getDetail,
+		resolveTarget,
+		updateMetadata,
+		archive,
+		restore,
+		hasArtifactKey,
+		clear
+	};
+}
+//#endregion
 //#region src/composables/filePicker/validation.ts
 function normalizePickerFormat(format) {
 	return format.trim().replace(/^\./, "").toLowerCase();
@@ -5664,6 +7858,6 @@ function pickerFormat(name) {
 	return compound ? `${compound[1]}.gz` : name.includes(".") ? name.split(".").pop() : "";
 }
 //#endregion
-export { getInjectedFrontendRevision as $, useFileImport as A, REORDER_ANNOUNCER_STYLE as B, useExpansionSet as C, detectDelimiter as D, getSampleGroupParentPath as E, extractSampleNamesFromDesignData as F, combinePluginJobSources as G, useListReorder as H, extractSampleOptionsFromDesignData as I, usePluginWorkspace as J, useJobsStatusTray as K, unwrapExperimentDesignData as L, extractSamplesFromDesignData as M, useAutoGroup as N, parseDelimitedText as O, parseCSV as P, useAppExperiment as Q, DEFAULT_COLORS as R, useExperimentData as S, getSampleGroupMajorPrefix as T, useReorderAnnouncer as U, reorderList as V, useDoseCalculator as W, useMobileSupportGate as X, DEFAULT_MOBILE_VIEWPORT_QUERY as Y, APP_EXPERIMENT_KEY as Z, useBioTemplateControls as _, DEFAULT_PRESETS as a, candidateMatchesSearch as at, useScheduleDrag as b, useReagentSeries as c, compareSortValues as ct, useBioTemplatePresetWorkspace as d, useRovingFocus as dt, useRuntimeAlignment as et, useBioTemplatePackWorkspace as f, useBioTemplateComponents as g, toBioTemplateComponentPropsByComponent as h, useProtocolTemplates as i, useToast as it, validateImportFile as j, readFileAsText as k, useGroupAssignment as l, useSortedItems as lt, getBioTemplateComponentProps as m, pickerFormat as n, usePresenceHeartbeat as nt, DEFAULT_UNITS as o, normalizeSearchQuery as ot, useBioTemplateWorkspace as p, usePluginJobCenter as q, pickerReason as r, useTheme as rt, generateDilutionSeries as s, useTextSearch as st, pickerExclusion as t, getPresenceClientId as tt, useRackEditor as u, useMenuKeyboard as ut, useTemplateCollection as v, useSampleGroups as w, useExperimentSamples as x, useExperimentSave as y, useWellPlateEditor as z };
+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 };
 
-//# sourceMappingURL=validation-ChMyixAf.js.map
+//# sourceMappingURL=validation-Dmp9Q5W0.js.map