@morscherlab/mint-sdk 1.2.0-beta.3 → 1.2.0-beta.5

package/dist/{composables-yz8bTkEV.js → composables-C8mmD5ta.js}

@@ -1,7 +1,7 @@
-import { r as useRequestSyncState } from "./EmptyState-p90quq8Z.js";
-import { B as currentExperimentFromContext, J as useEventStream, U as resolveCurrentExperimentId, V as getInjectedPlatformContext } from "./useControlSchema-Ds4VeFxt.js";
-import { i as useAuthStore, n as authenticationRequiredError, o as useSettingsStore, r as useApi, t as AuthenticationRequiredError } from "./useApi-yE0re8k-.js";
-import { i as usePlatformContext } from "./useFormBuilder-1so6QSQL.js";
+import { r as useRequestSyncState } from "./EmptyState-NBqf2_8z.js";
+import { B as currentExperimentFromContext, U as resolveCurrentExperimentId, V as getInjectedPlatformContext, et as useEventStream, lt as PLUGIN_SECRET_FORMAT_KEY } from "./useControlSchema-_OVhavKq.js";
+import { i as useAuthStore, n as authenticationRequiredError, o as useSettingsStore, r as useApi, t as AuthenticationRequiredError } from "./useApi-CDBq6z23.js";
+import { i as usePlatformContext } from "./useFormBuilder-Bd714C7y.js";
 import { computed, getCurrentInstance, onMounted, onUnmounted, ref, shallowRef, toValue, watch } from "vue";
 import axios from "axios";
 //#region src/composables/useAuth.ts
@@ -26,6 +26,7 @@ function useAuth() {
 				passkeyEnabled: response.data.passkey_enabled,
 				passkeyRegistered: response.data.passkey_registered ?? false,
 				registrationEnabled: response.data.registration_enabled ?? false,
+				databaseMode: response.data.database_mode ?? "none",
 				experimentVisibilityMode: response.data.access?.experiment_visibility_mode ?? response.data.access?.experimentVisibilityMode ?? "open"
 			};
 			authStore.setAuthConfig(config);
@@ -37,6 +38,7 @@ function useAuth() {
 				passkeyEnabled: false,
 				passkeyRegistered: false,
 				registrationEnabled: false,
+				databaseMode: "none",
 				experimentVisibilityMode: "open"
 			};
 		}
@@ -411,65 +413,336 @@ function resolvePluginFrontendBase(fallbackBase = "/") {
 	return normalizePluginRoutePrefix(context.plugin?.route_prefix) ?? fallbackBase;
 }
 //#endregion
-//#region src/composables/useReagentSeries.ts
-var DEFAULT_PRESETS = [
-	{
-		label: "2x",
-		factor: 2
-	},
-	{
-		label: "3x",
-		factor: 3
-	},
-	{
-		label: "½ log",
-		factor: "half-log"
-	},
-	{
-		label: "10x",
-		factor: 10
-	}
-];
-var DEFAULT_UNITS = [
-	"µM",
-	"nM",
-	"mM",
-	"pM"
-];
-function resolveFactor(factor) {
-	return factor === "half-log" ? Math.sqrt(10) : factor;
-}
-function roundToSignificant(value, digits = 4) {
-	if (value === 0) return 0;
-	const magnitude = Math.floor(Math.log10(Math.abs(value))) + 1;
-	const factor = Math.pow(10, digits - magnitude);
-	return Math.round(value * factor) / factor;
-}
-function generateDilutionSeries(startConcentration, count, factor, defaultReplicates = 1) {
-	if (count < 1 || startConcentration <= 0) return [];
-	const divisor = resolveFactor(factor);
-	const levels = [];
-	for (let i = 0; i < count; i++) levels.push({
-		value: roundToSignificant(startConcentration / Math.pow(divisor, i)),
-		replicates: defaultReplicates
-	});
-	return levels;
+//#region src/composables/useAsync.ts
+/**
+* Default error transformer.
+*/
+function defaultTransformError(error) {
+	if (error instanceof Error) return {
+		message: error.message,
+		originalError: error
+	};
+	if (typeof error === "object" && error !== null) {
+		const errorObj = error;
+		if ("response" in errorObj && errorObj.response) {
+			const response = errorObj.response;
+			const data = response.data;
+			return {
+				message: data?.detail || data?.message || "Request failed",
+				code: String(response.status),
+				details: data,
+				originalError: error
+			};
+		}
+		return {
+			message: errorObj.message || "Unknown error",
+			code: errorObj.code,
+			details: errorObj,
+			originalError: error
+		};
+	}
+	return {
+		message: String(error),
+		originalError: error
+	};
+}
+/**
+* Composable for managing async operation state.
+*
+* Provides standardized loading, error, and success state management
+* for any async function.
+*
+* @param asyncFn - The async function to wrap
+* @param options - Configuration options
+*
+* @example
+* ```typescript
+* // Basic usage
+* const { data, isLoading, error, execute } = useAsync(
+*   async (id: string) => {
+*     const response = await api.get(`/users/${id}`)
+*     return response.data
+*   }
+* )
+*
+* // Execute the function
+* await execute('user-123')
+*
+* // In template
+* <div v-if="isLoading">Loading...</div>
+* <div v-else-if="error">{{ error.message }}</div>
+* <div v-else-if="data">{{ data.name }}</div>
+* ```
+*
+* @example
+* ```typescript
+* // With options
+* const { data, execute } = useAsync(
+*   fetchUser,
+*   {
+*     immediate: true,
+*     immediateArgs: ['default-user'],
+*     onSuccess: (user) => console.log('Fetched:', user.name),
+*     onError: (error) => toast.error(error.message),
+*   }
+* )
+* ```
+*
+* @example
+* ```typescript
+* // Form submission
+* const { isLoading, error, execute: submit } = useAsync(
+*   async (formData: FormData) => {
+*     await api.post('/submit', formData)
+*   },
+*   {
+*     onSuccess: () => {
+*       toast.success('Submitted!')
+*       router.push('/success')
+*     },
+*   }
+* )
+*
+* const handleSubmit = () => submit(new FormData(formRef.value))
+* ```
+*/
+/**
+* Wraps an async function with reactive loading, error, and success state plus optional auto-execute.
+*
+* @deprecated Unused by the MINT platform and scheduled for removal in MINT 1.3; use `useRequestSyncState()` instead.
+*/
+function useAsync(asyncFn, options = {}) {
+	const { initialData = null, immediate = false, immediateArgs = [], transformError = defaultTransformError, onSuccess, onError, resetOnExecute = false } = options;
+	const data = ref(initialData);
+	const error = ref(null);
+	const state = ref("idle");
+	const isIdle = computed(() => state.value === "idle");
+	const isLoading = computed(() => state.value === "loading");
+	const isSuccess = computed(() => state.value === "success");
+	const isError = computed(() => state.value === "error");
+	async function execute(...args) {
+		state.value = "loading";
+		error.value = null;
+		if (resetOnExecute) data.value = null;
+		try {
+			const result = await asyncFn(...args);
+			data.value = result;
+			state.value = "success";
+			onSuccess?.(result);
+			return result;
+		} catch (e) {
+			const asyncError = transformError(e);
+			error.value = asyncError;
+			state.value = "error";
+			onError?.(asyncError);
+			return null;
+		}
+	}
+	function reset() {
+		data.value = initialData;
+		error.value = null;
+		state.value = "idle";
+	}
+	function setData(newData) {
+		data.value = newData;
+		if (newData !== null) {
+			state.value = "success";
+			error.value = null;
+		}
+	}
+	function setError(newError) {
+		error.value = newError;
+		if (newError !== null) state.value = "error";
+	}
+	if (immediate) execute(...immediateArgs);
+	return {
+		data,
+		error,
+		state,
+		isIdle,
+		isLoading,
+		isSuccess,
+		isError,
+		execute,
+		reset,
+		setData,
+		setError
+	};
+}
+/**
+* Create a batch of async operations that can be executed in parallel.
+*
+* @example
+* ```typescript
+* const { results, isLoading, execute } = useAsyncBatch([
+*   () => fetchUser(userId),
+*   () => fetchPosts(userId),
+*   () => fetchComments(userId),
+* ])
+*
+* await execute()
+* // results.value = [user, posts, comments]
+* ```
+*/
+function useAsyncBatch(asyncFns) {
+	const results = ref(asyncFns.map(() => null));
+	const errors = ref(asyncFns.map(() => null));
+	const isLoading = ref(false);
+	async function execute() {
+		isLoading.value = true;
+		errors.value = asyncFns.map(() => null);
+		const promises = asyncFns.map(async (fn, index) => {
+			try {
+				const result = await fn();
+				results.value[index] = result;
+			} catch (e) {
+				errors.value[index] = defaultTransformError(e);
+				results.value[index] = null;
+			}
+		});
+		await Promise.all(promises);
+		isLoading.value = false;
+	}
+	function reset() {
+		results.value = asyncFns.map(() => null);
+		errors.value = asyncFns.map(() => null);
+		isLoading.value = false;
+	}
+	return {
+		results,
+		errors,
+		isLoading,
+		execute,
+		reset
+	};
+}
+//#endregion
+//#region src/composables/usePluginConfig.ts
+var PLATFORM_OWNED_SETTINGS_KEY$1 = "allowed_experiment_types";
+function cloneConfig(config) {
+	return JSON.parse(JSON.stringify(config));
 }
-/** Generates and sorts geometric dilution series (2x, 3x, ½ log, 10x) for plate-based experiments. */
-function useReagentSeries() {
-	function generateSeries(start, count, factor, defaultReplicates = 1) {
-		return generateDilutionSeries(start, count, factor, defaultReplicates);
+function hasOwnConfig(config, key) {
+	return Object.prototype.hasOwnProperty.call(config, key);
+}
+function changedTopLevelKeys(current, saved) {
+	return new Set([...new Set([...Object.keys(current), ...Object.keys(saved)])].filter((key) => JSON.stringify(current[key]) !== JSON.stringify(saved[key])));
+}
+function topLevelConfigPatch(current, keys) {
+	return Object.fromEntries([...keys].map((key) => [key, hasOwnConfig(current, key) ? current[key] : null]));
+}
+function platformOwnedConfigPatch(config) {
+	return { [PLATFORM_OWNED_SETTINGS_KEY$1]: hasOwnConfig(config, PLATFORM_OWNED_SETTINGS_KEY$1) ? config[PLATFORM_OWNED_SETTINGS_KEY$1] : null };
+}
+function responseConfigPayload(response) {
+	return response.config ?? response.settings ?? {};
+}
+/** @deprecated Use `usePluginSettings()` for typed plugin settings. */
+function usePluginConfig(pluginName) {
+	const injectedContext = getInjectedPlatformContext();
+	const { plugin } = usePlatformContext();
+	const platformApi = useApi();
+	const pluginApi = useApi({ baseUrl: injectedContext?.plugin?.api_prefix ?? plugin.value?.api_prefix });
+	const resolvedName = computed(() => pluginName ?? plugin.value?.name ?? injectedContext?.plugin?.name ?? "");
+	const usesPluginSettingsApi = computed(() => {
+		const currentPlugin = injectedContext?.plugin ?? plugin.value;
+		return currentPlugin?.settings_api === "plugin" && resolvedName.value === currentPlugin.name;
+	});
+	const config = ref({});
+	const savedConfig = ref({});
+	const revision = ref(null);
+	const request = useRequestSyncState("Plugin config request failed.");
+	const isLoading = ref(false);
+	const isSaving = ref(false);
+	const error = request.error;
+	const lastLoadedAt = request.lastLoadedAt;
+	const lastSavedAt = request.lastSavedAt;
+	const isDirty = computed(() => {
+		return JSON.stringify(config.value) !== JSON.stringify(savedConfig.value);
+	});
+	async function load() {
+		const name = resolvedName.value;
+		if (!name) return;
+		isLoading.value = true;
+		try {
+			const response = usesPluginSettingsApi.value ? await request.run(() => pluginApi.get("/settings"), {
+				success: "load",
+				errorMessage: "Failed to load plugin config"
+			}) : await request.run(() => platformApi.get(`/plugins/${encodeURIComponent(name)}/config`), {
+				success: "load",
+				errorMessage: "Failed to load plugin config"
+			});
+			const responseConfig = responseConfigPayload(response);
+			config.value = cloneConfig(responseConfig);
+			savedConfig.value = cloneConfig(responseConfig);
+			revision.value = response.revision ?? null;
+		} catch {} finally {
+			isLoading.value = false;
+		}
 	}
-	function sortLevels(levels, order = "desc") {
-		return [...levels].sort((a, b) => order === "desc" ? b.value - a.value : a.value - b.value);
+	async function save() {
+		const name = resolvedName.value;
+		if (!name) return false;
+		isSaving.value = true;
+		try {
+			const payload = cloneConfig(config.value);
+			let response;
+			let nextRevision = revision.value;
+			if (usesPluginSettingsApi.value) {
+				response = await request.run(() => pluginApi.put("/settings", payload, revision.value ? { headers: { "If-Match": `"${revision.value}"` } } : void 0), {
+					success: "save",
+					errorMessage: "Failed to save plugin config"
+				});
+				nextRevision = response.revision ?? nextRevision;
+			} else {
+				const dirtyKeys = changedTopLevelKeys(payload, savedConfig.value);
+				const platformOwnedChanged = dirtyKeys.has(PLATFORM_OWNED_SETTINGS_KEY$1);
+				const typedKeys = [...dirtyKeys].filter((key) => key !== PLATFORM_OWNED_SETTINGS_KEY$1);
+				if (typedKeys.length) {
+					response = await request.run(() => platformApi.patch(`/plugins/${encodeURIComponent(name)}/config`, { config: topLevelConfigPatch(payload, typedKeys) }), {
+						success: "save",
+						errorMessage: "Failed to save plugin config"
+					});
+					nextRevision = response.revision ?? nextRevision;
+				}
+				if (platformOwnedChanged) {
+					response = await request.run(() => platformApi.patch(`/plugins/${encodeURIComponent(name)}/config`, { config: platformOwnedConfigPatch(payload) }), {
+						success: "save",
+						errorMessage: "Failed to save plugin config"
+					});
+					nextRevision = response.revision ?? nextRevision;
+				}
+			}
+			if (!response) return true;
+			const responseConfig = responseConfigPayload(response);
+			config.value = cloneConfig(responseConfig);
+			savedConfig.value = cloneConfig(responseConfig);
+			revision.value = response.revision ?? nextRevision;
+			return true;
+		} catch {
+			return false;
+		} finally {
+			isSaving.value = false;
+		}
 	}
-	function totalPositions(levels) {
-		return levels.reduce((sum, l) => sum + l.replicates, 0);
+	function reset() {
+		config.value = cloneConfig(savedConfig.value);
+		request.clearError();
 	}
+	onMounted(() => {
+		load();
+	});
 	return {
-		generateSeries,
-		sortLevels,
-		totalPositions
+		config,
+		isLoading,
+		isSaving,
+		error,
+		lastLoadedAt,
+		lastSavedAt,
+		isDirty,
+		load,
+		save,
+		reset
 	};
 }
 //#endregion
@@ -508,8 +781,79 @@ function parseAnalysisArtifactTarget(query) {
 	};
 }
 //#endregion
+//#region src/composables/useCommandHistory.ts
+/**
+* Generic command-stack state for plugin editors with undo/redo controls.
+*
+* @deprecated Unused by the MINT platform and scheduled for removal in MINT 1.3; keep command stacks plugin-local.
+*/
+function useCommandHistory(options = {}) {
+	const maxDepth = Math.max(1, options.maxDepth ?? 50);
+	const undoStack = ref([]);
+	const redoStack = ref([]);
+	const canUndo = computed(() => undoStack.value.length > 0);
+	const canRedo = computed(() => redoStack.value.length > 0);
+	const undoDescription = computed(() => undoStack.value[undoStack.value.length - 1]?.description ?? "");
+	const redoDescription = computed(() => redoStack.value[redoStack.value.length - 1]?.description ?? "");
+	function push(command) {
+		undoStack.value = [...undoStack.value.slice(-(maxDepth - 1)), command];
+		redoStack.value = [];
+	}
+	function execute(command, executeOptions = {}) {
+		if (executeOptions.skipExecute) {
+			push(command);
+			return;
+		}
+		return afterMaybePromise(command.execute(), () => push(command));
+	}
+	function undo() {
+		const command = undoStack.value[undoStack.value.length - 1];
+		if (!command) return;
+		return afterMaybePromise(command.undo(), () => {
+			undoStack.value = undoStack.value.slice(0, -1);
+			redoStack.value = [...redoStack.value, command];
+		});
+	}
+	function redo() {
+		const command = redoStack.value[redoStack.value.length - 1];
+		if (!command) return;
+		return afterMaybePromise((command.redo ?? command.execute)(), () => {
+			redoStack.value = redoStack.value.slice(0, -1);
+			undoStack.value = [...undoStack.value.slice(-(maxDepth - 1)), command];
+		});
+	}
+	function clear() {
+		undoStack.value = [];
+		redoStack.value = [];
+	}
+	return {
+		undoStack,
+		redoStack,
+		canUndo,
+		canRedo,
+		undoDescription,
+		redoDescription,
+		execute,
+		push,
+		undo,
+		redo,
+		clear
+	};
+}
+function afterMaybePromise(result, callback) {
+	if (isPromiseLike(result)) return result.then(callback);
+	callback();
+}
+function isPromiseLike(value) {
+	return !!value && typeof value.then === "function";
+}
+//#endregion
 //#region src/composables/useOptimisticMutation.ts
-/** Run async mutations with optional optimistic local updates and rollback. */
+/**
+* Run async mutations with optional optimistic local updates and rollback.
+*
+* @deprecated Unused by the MINT platform and scheduled for removal in MINT 1.3; use `useRequestSyncState()` instead.
+*/
 function useOptimisticMutation(options) {
 	const loading = shallowRef(false);
 	const error = ref(null);
@@ -543,7 +887,7 @@ function useOptimisticMutation(options) {
 			return result;
 		} catch (err) {
 			options.rollback?.(snapshot, variables, err);
-			error.value = options.readErrorMessage?.(err) ?? readErrorMessage(err);
+			error.value = options.readErrorMessage?.(err) ?? readErrorMessage$1(err);
 			options.onError?.(err, context);
 			throw err;
 		} finally {
@@ -562,6 +906,146 @@ function useOptimisticMutation(options) {
 		reset
 	};
 }
+function readErrorMessage$1(value) {
+	if (value instanceof Error && value.message) return value.message;
+	if (typeof value === "string" && value.trim()) return value;
+	if (typeof value === "object" && value !== null && "message" in value && typeof value.message === "string" && value.message.trim()) return value.message;
+	return "Request failed.";
+}
+//#endregion
+//#region src/composables/useResourceCrud.ts
+/**
+* Common list/create/update/delete state wrapper for generated plugin clients.
+*
+* @deprecated Unused by the MINT platform and scheduled for removal in MINT 1.3; use `useGeneratedPluginClient()` instead.
+*/
+function useResourceCrud(options) {
+	const items = ref([...options.initialItems ?? []]);
+	const loading = shallowRef(false);
+	const saving = shallowRef(false);
+	const deleting = shallowRef(false);
+	const error = ref(null);
+	const isBusy = computed(() => loading.value || saving.value || deleting.value);
+	const readMessage = options.readErrorMessage ?? readErrorMessage;
+	const getKey = options.getKey ?? defaultGetKey;
+	function clearError() {
+		error.value = null;
+	}
+	function setError(err) {
+		error.value = readMessage(err);
+	}
+	function setItems(nextItems) {
+		items.value = [...nextItems];
+	}
+	function upsertLocal(item) {
+		const key = getKey(item);
+		const index = items.value.findIndex((existing) => getKey(existing) === key);
+		if (index === -1) {
+			items.value = [...items.value, item];
+			return;
+		}
+		items.value = [
+			...items.value.slice(0, index),
+			item,
+			...items.value.slice(index + 1)
+		];
+	}
+	function removeLocal(keyOrItem) {
+		const key = resolveKey(keyOrItem, getKey);
+		items.value = items.value.filter((item) => getKey(item) !== key);
+	}
+	async function load() {
+		loading.value = true;
+		clearError();
+		try {
+			const result = await options.adapter.list();
+			setItems(result);
+			return result;
+		} catch (err) {
+			setError(err);
+			throw err;
+		} finally {
+			loading.value = false;
+		}
+	}
+	async function createItem(payload) {
+		if (!options.adapter.create) throw new Error("[MINT SDK] Resource adapter does not implement create().");
+		saving.value = true;
+		clearError();
+		try {
+			const result = await options.adapter.create(payload);
+			upsertLocal(result);
+			return result;
+		} catch (err) {
+			setError(err);
+			throw err;
+		} finally {
+			saving.value = false;
+		}
+	}
+	async function updateItem(key, payload) {
+		if (!options.adapter.update) throw new Error("[MINT SDK] Resource adapter does not implement update().");
+		saving.value = true;
+		clearError();
+		try {
+			const result = await options.adapter.update(key, payload);
+			upsertLocal(result);
+			return result;
+		} catch (err) {
+			setError(err);
+			throw err;
+		} finally {
+			saving.value = false;
+		}
+	}
+	async function deleteItem(keyOrItem) {
+		if (!options.adapter.remove) throw new Error("[MINT SDK] Resource adapter does not implement remove().");
+		const key = resolveKey(keyOrItem, getKey);
+		deleting.value = true;
+		clearError();
+		try {
+			await options.adapter.remove(key);
+			removeLocal(key);
+		} catch (err) {
+			setError(err);
+			throw err;
+		} finally {
+			deleting.value = false;
+		}
+	}
+	return {
+		items,
+		loading,
+		saving,
+		deleting,
+		error,
+		isBusy,
+		load,
+		createItem,
+		updateItem,
+		deleteItem,
+		setItems,
+		upsertLocal,
+		removeLocal,
+		clearError
+	};
+}
+function createPluginResourceClient(options) {
+	return {
+		list: () => options.list(options.client),
+		create: options.create ? (payload) => options.create(options.client, payload) : void 0,
+		update: options.update ? (key, payload) => options.update(options.client, key, payload) : void 0,
+		remove: options.remove ? (key) => options.remove(options.client, key) : void 0
+	};
+}
+function defaultGetKey(item) {
+	if (item && typeof item === "object" && "id" in item) return item.id;
+	throw new Error("[MINT SDK] Resource items need an id field or a getKey option.");
+}
+function resolveKey(keyOrItem, getKey) {
+	if (typeof keyOrItem === "string" || typeof keyOrItem === "number") return keyOrItem;
+	return getKey(keyOrItem);
+}
 function readErrorMessage(value) {
 	if (value instanceof Error && value.message) return value.message;
 	if (typeof value === "string" && value.trim()) return value;
@@ -569,8 +1053,250 @@ function readErrorMessage(value) {
 	return "Request failed.";
 }
 //#endregion
+//#region src/composables/useWellPainting.ts
+var ROW_LABELS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+var PLATE_DIMENSIONS = {
+	6: {
+		rows: 2,
+		cols: 3
+	},
+	12: {
+		rows: 3,
+		cols: 4
+	},
+	24: {
+		rows: 4,
+		cols: 6
+	},
+	48: {
+		rows: 6,
+		cols: 8
+	},
+	54: {
+		rows: 6,
+		cols: 9
+	},
+	96: {
+		rows: 8,
+		cols: 12
+	},
+	384: {
+		rows: 16,
+		cols: 24
+	}
+};
+/**
+* Pointer painting/rectangle selection state for WellPlate-based editors.
+*
+* @deprecated Unused by the MINT platform and scheduled for removal in MINT 1.3; use `useWellPlateEditor()` instead.
+*/
+function useWellPainting(options) {
+	const activeMode = ref(options.initialMode ?? "select");
+	const activePayload = ref(options.initialPayload);
+	const isDragging = ref(false);
+	const dragStart = ref(null);
+	const dragEnd = ref(null);
+	const paintTrail = ref(/* @__PURE__ */ new Set());
+	const previewWellIds = computed(() => {
+		if (!isDragging.value) return [];
+		if (activeMode.value === "select") {
+			if (!dragStart.value || !dragEnd.value) return [];
+			return wellIdsInRectangle(dragStart.value, dragEnd.value, toValue(options.format));
+		}
+		return [...paintTrail.value];
+	});
+	function setMode(mode, payload) {
+		activeMode.value = mode;
+		activePayload.value = payload;
+	}
+	function setPayload(payload) {
+		activePayload.value = payload;
+	}
+	function onWellMouseDown(wellId) {
+		const coord = wellIdToCoordinate(wellId);
+		if (!coord) return;
+		isDragging.value = true;
+		dragStart.value = coord;
+		dragEnd.value = coord;
+		paintTrail.value = new Set([wellId]);
+	}
+	function onWellMouseMove(wellId) {
+		if (!isDragging.value) return;
+		const coord = wellIdToCoordinate(wellId);
+		if (!coord) return;
+		dragEnd.value = coord;
+		if (activeMode.value !== "select") paintTrail.value = new Set([...paintTrail.value, wellId]);
+	}
+	function onWellMouseUp() {
+		if (!isDragging.value) return;
+		const wellIds = previewWellIds.value;
+		isDragging.value = false;
+		if (wellIds.length > 0) options.onComplete?.({
+			wellIds,
+			mode: activeMode.value,
+			payload: activePayload.value
+		});
+		clearDragState();
+	}
+	function cancel() {
+		isDragging.value = false;
+		clearDragState();
+	}
+	function clearDragState() {
+		dragStart.value = null;
+		dragEnd.value = null;
+		paintTrail.value = /* @__PURE__ */ new Set();
+	}
+	return {
+		activeMode,
+		activePayload,
+		isDragging,
+		previewWellIds,
+		setMode,
+		setPayload,
+		onWellMouseDown,
+		onWellMouseMove,
+		onWellMouseUp,
+		cancel
+	};
+}
+function wellIdToCoordinate(wellId) {
+	const match = /^([A-Z]+)(\d+)$/i.exec(wellId.trim());
+	if (!match) return null;
+	return {
+		row: rowLabelToIndex$1(match[1].toUpperCase()),
+		col: Number(match[2]) - 1
+	};
+}
+function coordinateToWellId(coord) {
+	return `${indexToRowLabel$1(coord.row)}${coord.col + 1}`;
+}
+function wellIdsInRectangle(start, end, format) {
+	const dimensions = PLATE_DIMENSIONS[format];
+	const minRow = Math.max(0, Math.min(start.row, end.row));
+	const maxRow = Math.min(dimensions.rows - 1, Math.max(start.row, end.row));
+	const minCol = Math.max(0, Math.min(start.col, end.col));
+	const maxCol = Math.min(dimensions.cols - 1, Math.max(start.col, end.col));
+	const ids = [];
+	for (let row = minRow; row <= maxRow; row++) for (let col = minCol; col <= maxCol; col++) ids.push(coordinateToWellId({
+		row,
+		col
+	}));
+	return ids;
+}
+function rowLabelToIndex$1(label) {
+	let result = 0;
+	for (const char of label) result = result * 26 + (char.charCodeAt(0) - 64);
+	return result - 1;
+}
+function indexToRowLabel$1(index) {
+	if (index < 26) return ROW_LABELS[index];
+	let value = index + 1;
+	let label = "";
+	while (value > 0) {
+		value--;
+		label = ROW_LABELS[value % 26] + label;
+		value = Math.floor(value / 26);
+	}
+	return label;
+}
+//#endregion
+//#region src/composables/useWellPlateAdapter.ts
+/**
+* Convert domain rows into WellPlate's wells prop without hand-written adapters.
+*
+* @deprecated Unused by the MINT platform and scheduled for removal in MINT 1.3; use `useWellPlateEditor()` instead.
+*/
+function useWellPlateAdapter(options) {
+	return { wells: computed(() => createWellPlateWells(toValue(options.entries), options)) };
+}
+function createWellPlateWells(entries, options) {
+	return Object.fromEntries(entries.map((entry) => {
+		const wellId = options.getWellId(entry);
+		const coord = parseWellId(wellId);
+		return [wellId, {
+			id: wellId,
+			row: coord.row,
+			col: coord.col,
+			state: options.getState?.(entry) ?? "filled",
+			sampleType: options.getSampleType?.(entry),
+			value: options.getValue?.(entry),
+			metadata: options.getMetadata?.(entry)
+		}];
+	}));
+}
+function createColumnConditions(entries) {
+	return entries.map((entry) => {
+		const startCol = typeof entry.start === "number" ? entry.start : Number.parseInt(entry.start, 10);
+		const cols = [];
+		const concentrations = [];
+		for (const concentration of entry.concentrations) {
+			const replicates = concentration.replicates ?? 1;
+			for (let index = 0; index < replicates; index++) {
+				cols.push(startCol + cols.length);
+				concentrations.push(concentration.value);
+			}
+		}
+		return {
+			label: entry.label,
+			color: entry.color,
+			unit: entry.unit,
+			cols,
+			concentrations
+		};
+	});
+}
+function createRowConditions(entries) {
+	return entries.map((entry) => {
+		const startRow = typeof entry.start === "number" ? entry.start : rowLabelToIndex(entry.start);
+		const rows = [];
+		const concentrations = [];
+		for (const concentration of entry.concentrations) {
+			const replicates = concentration.replicates ?? 1;
+			for (let index = 0; index < replicates; index++) {
+				rows.push(indexToRowLabel(startRow + rows.length));
+				concentrations.push(concentration.value);
+			}
+		}
+		return {
+			label: entry.label,
+			color: entry.color,
+			unit: entry.unit,
+			rows,
+			concentrations
+		};
+	});
+}
+function parseWellId(wellId) {
+	const match = /^([A-Z]+)(\d+)$/i.exec(wellId.trim());
+	if (!match) throw new Error(`[MINT SDK] Invalid well id "${wellId}".`);
+	return {
+		row: rowLabelToIndex(match[1].toUpperCase()),
+		col: Number(match[2]) - 1
+	};
+}
+function rowLabelToIndex(label) {
+	let result = 0;
+	for (const char of label.toUpperCase()) result = result * 26 + (char.charCodeAt(0) - 64);
+	return result - 1;
+}
+function indexToRowLabel(index) {
+	let value = index + 1;
+	let label = "";
+	while (value > 0) {
+		value--;
+		label = String.fromCharCode(65 + value % 26) + label;
+		value = Math.floor(value / 26);
+	}
+	return label;
+}
+//#endregion
 //#region src/composables/useWellPlateValidation.ts
-/** Rule-driven validation state for WellPlate layout/design screens. */
+/**
+* Rule-driven validation state for WellPlate layout/design screens.
+*
+* @deprecated Unused by the MINT platform and scheduled for removal in MINT 1.3; use `useWellPlateEditor()` instead.
+*/
 function useWellPlateValidation(options) {
 	const warnings = computed(() => runWellPlateValidation(toValue(options.context), toValue(options.rules)));
 	return {
@@ -932,7 +1658,29 @@ async function downloadPluginEndpoint(contract, endpoint, payload, options = {})
 function normalizePluginSettingsOptions(options = {}) {
 	return typeof options === "string" ? { pluginName: options } : options;
 }
+/** @deprecated 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));
 }
@@ -970,6 +1718,7 @@ function usePluginSettings(options = {}) {
 	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);
@@ -990,11 +1739,12 @@ function usePluginSettings(options = {}) {
 	function setValues(nextValues) {
 		values.value = cloneRecord(nextValues);
 	}
-	function applyLoaded(nextValues, nextRevision) {
+	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;
@@ -1006,7 +1756,7 @@ function usePluginSettings(options = {}) {
 				success: "load",
 				errorMessage: "Failed to load plugin settings"
 			});
-			applyLoaded(responseSettingsPayload(response), responseSettingsRevision(response));
+			applyLoaded(responseSettingsPayload(response), responseSettingsRevision(response), responseSecretFormat(response));
 		} catch {} finally {
 			isLoading.value = false;
 		}
@@ -1023,7 +1773,7 @@ function usePluginSettings(options = {}) {
 				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: topLevelSettingsPatch(payload, typedKeys) }), {
+					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"
 					});
@@ -1037,16 +1787,16 @@ function usePluginSettings(options = {}) {
 					nextRevision = responseSettingsRevision(response) ?? nextRevision;
 				}
 				if (!response) return true;
-				applyLoaded(responseSettingsPayload(response), nextRevision);
+				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", payload, ifMatch), {
+				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);
+			applyLoaded(responseSettingsPayload(response), responseSettingsRevision(response) ?? revision.value, responseSecretFormat(response) ?? secretFormat.value);
 			return true;
 		} catch {
 			return false;
@@ -1064,6 +1814,7 @@ function usePluginSettings(options = {}) {
 	return {
 		settings,
 		values,
+		config: values,
 		settingsConfig,
 		isLoading,
 		isSaving,
@@ -1195,4 +1946,6 @@ function useCurrentExperiment(options = {}) {
 	};
 }
 //#endregion
-export { useAuth as C, usePasskey as S, DEFAULT_PRESETS as _, pluginFormDataFromPayload as a, useReagentSeries as b, usePluginEventStream as c, resolvePluginBaseUrl as d, runWellPlateValidation as f, parseAnalysisArtifactTarget as g, buildAnalysisArtifactTargetQuery as h, getPluginPageSelectorItems as i, usePluginSettings as l, useOptimisticMutation as m, downloadBlob as n, uploadPluginEndpoint as o, useWellPlateValidation as p, downloadPluginEndpoint as r, useCurrentExperiment as s, createPluginClient as t, buildPluginEndpointUrl as u, DEFAULT_UNITS as v, resolvePluginFrontendBase as x, generateDilutionSeries as y };
+export { useAsync as A, createPluginResourceClient as C, buildAnalysisArtifactTargetQuery as D, useCommandHistory as E, resolvePluginFrontendBase as M, usePasskey as N, parseAnalysisArtifactTarget as O, useAuth as P, wellIdsInRectangle as S, useOptimisticMutation as T, createWellPlateWells as _, pluginFormDataFromPayload as a, useWellPainting as b, usePluginClient as c, buildPluginEndpointUrl as d, resolvePluginBaseUrl as f, createRowConditions as g, createColumnConditions as h, getPluginPageSelectorItems as i, useAsyncBatch as j, usePluginConfig as k, usePluginEventStream as l, useWellPlateValidation as m, downloadBlob as n, uploadPluginEndpoint as o, runWellPlateValidation as p, downloadPluginEndpoint as r, useCurrentExperiment as s, createPluginClient as t, usePluginSettings as u, useWellPlateAdapter as v, useResourceCrud as w, wellIdToCoordinate as x, coordinateToWellId as y };
+
+//# sourceMappingURL=composables-C8mmD5ta.js.map