@morscherlab/mint-sdk 1.3.8 → 1.4.0-beta.1

package/dist/experiment-43OJtH7R.js

@@ -0,0 +1,673 @@
+import { r as useAuthStore } from "./auth-SliLnFre.js";
+import { ref, watch } from "vue";
+import { defineStore, getActivePinia } from "pinia";
+import axios from "axios";
+//#region src/apiErrors.ts
+var STATUS_MESSAGES = {
+	400: "Bad request",
+	401: "Authentication required",
+	403: "Permission denied",
+	404: "Resource not found",
+	405: "Method not allowed",
+	409: "Conflict",
+	413: "Payload too large",
+	415: "Unsupported media type",
+	422: "Validation error",
+	429: "Rate limit exceeded",
+	500: "Internal server error",
+	502: "Bad gateway",
+	503: "Service unavailable"
+};
+function asRecord(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	return value;
+}
+/** Public error thrown by typed MINT SDK requests. */
+var MintApiError = class extends Error {
+	code;
+	status;
+	requestId;
+	details;
+	detail;
+	body;
+	cause;
+	name = "MintApiError";
+	constructor(message, code, status, requestId, details, detail, body, cause) {
+		super(message);
+		this.code = code;
+		this.status = status;
+		this.requestId = requestId;
+		this.details = details;
+		this.detail = detail;
+		this.body = body;
+		this.cause = cause;
+	}
+};
+/** Normalize current typed envelopes and the previous FastAPI detail shape. */
+function mintApiErrorFromResponse(status, payload, options = {}) {
+	const body = asRecord(payload);
+	const legacyDetail = body?.detail;
+	const inner = asRecord(legacyDetail) ?? body;
+	const text = (value) => typeof value === "string" && value ? value : void 0;
+	const canonical = typeof body?.status === "number" && text(body.code) && text(body.message);
+	const code = (canonical ? text(body.code) : text(inner?.error) ?? text(inner?.code)) ?? text(body?.code) ?? "unknown";
+	const message = (canonical ? text(body.message) : text(inner?.message)) ?? text(body?.message) ?? text(legacyDetail) ?? STATUS_MESSAGES[status] ?? `HTTP ${status}`;
+	const details = body?.details ?? inner?.details ?? null;
+	return new MintApiError(message, code, status, text(body?.request_id) ?? text(inner?.request_id) ?? options.requestId ?? null, details, legacyDetail, payload, options.cause);
+}
+//#endregion
+//#region src/stores/settings.ts
+var STORAGE_KEY = "mint-settings";
+var LEGACY_STORAGE_KEY = "mld-settings";
+function getDefaultServerHost() {
+	if (typeof window !== "undefined" && window.location.hostname !== "localhost") return window.location.hostname;
+	return "localhost";
+}
+function getDefaultServerPort() {
+	if (typeof window !== "undefined") {
+		if (window.location.port) return parseInt(window.location.port, 10);
+		return window.location.protocol === "https:" ? 443 : 80;
+	}
+	return 8e3;
+}
+var defaultSettings = {
+	serverHost: getDefaultServerHost(),
+	serverPort: getDefaultServerPort(),
+	requestTimeout: 12e4,
+	wsAutoReconnect: true,
+	wsReconnectInterval: 5e3,
+	theme: "system",
+	colorPalette: "default",
+	tableDensity: "normal"
+};
+var colorPalettes = {
+	default: {
+		name: "Default (Cyan-Pink)",
+		hues: [180, 320]
+	},
+	colorblind: {
+		name: "Colorblind-friendly",
+		hues: [45, 260]
+	},
+	viridis: {
+		name: "Viridis",
+		hues: [280, 80]
+	},
+	pastel: {
+		name: "Pastel",
+		hues: [200, 340]
+	}
+};
+/**
+* Custom properties a non-default palette overrides on `<html>`.
+*
+* The saturation/lightness pairs are lifted from the original indigo/orange
+* tokens in `styles/variables.css` so only the hue moves; the `default`
+* palette writes nothing at all and the stylesheet values stand.
+*/
+var PALETTE_CSS_VARIABLES = [
+	"--color-primary",
+	"--color-primary-hover",
+	"--color-primary-soft",
+	"--color-cta",
+	"--color-cta-hover"
+];
+/** Build the `<html>` custom-property overrides for a palette. */
+function paletteCssVariables(palette) {
+	if (palette === "default") return {};
+	const [primaryHue, accentHue] = colorPalettes[palette].hues;
+	return {
+		"--color-primary": `hsl(${primaryHue} 84% 67%)`,
+		"--color-primary-hover": `hsl(${primaryHue} 75% 59%)`,
+		"--color-primary-soft": `hsl(${primaryHue} 84% 67% / 0.12)`,
+		"--color-cta": `hsl(${accentHue} 95% 53%)`,
+		"--color-cta-hover": `hsl(${accentHue} 90% 48%)`
+	};
+}
+/** `DataFrame`-style size that each table density maps onto. */
+var DENSITY_TABLE_SIZE = {
+	compact: "sm",
+	normal: "md",
+	comfortable: "lg"
+};
+/** Map a table density onto the `size` prop shared by the SDK table components. */
+function tableDensityToSize(density) {
+	return DENSITY_TABLE_SIZE[density];
+}
+function loadSettings() {
+	try {
+		const stored = localStorage.getItem(STORAGE_KEY);
+		if (stored) {
+			const parsed = JSON.parse(stored);
+			return {
+				...defaultSettings,
+				...parsed
+			};
+		}
+		const legacyStored = localStorage.getItem(LEGACY_STORAGE_KEY);
+		if (legacyStored) {
+			const parsed = JSON.parse(legacyStored);
+			const migrated = {
+				...defaultSettings,
+				...parsed
+			};
+			localStorage.setItem(STORAGE_KEY, JSON.stringify(migrated));
+			localStorage.removeItem(LEGACY_STORAGE_KEY);
+			return migrated;
+		}
+	} catch (e) {
+		console.warn("Failed to load settings from localStorage:", e);
+	}
+	return { ...defaultSettings };
+}
+function saveSettings(settings) {
+	try {
+		localStorage.setItem(STORAGE_KEY, JSON.stringify(settings));
+	} catch (e) {
+		console.warn("Failed to save settings to localStorage:", e);
+	}
+}
+function getSystemPrefersDark() {
+	if (typeof window === "undefined" || typeof window.matchMedia !== "function") return false;
+	return window.matchMedia("(prefers-color-scheme: dark)").matches;
+}
+var useSettingsStore = defineStore("mint-settings", () => {
+	const serverHost = ref(defaultSettings.serverHost);
+	const serverPort = ref(defaultSettings.serverPort);
+	const requestTimeout = ref(defaultSettings.requestTimeout);
+	const wsAutoReconnect = ref(defaultSettings.wsAutoReconnect);
+	const wsReconnectInterval = ref(defaultSettings.wsReconnectInterval);
+	const theme = ref(defaultSettings.theme);
+	const systemPrefersDark = ref(getSystemPrefersDark());
+	const colorPalette = ref(defaultSettings.colorPalette);
+	const tableDensity = ref(defaultSettings.tableDensity);
+	const apiPrefix = "/api";
+	function _isSameOrigin() {
+		const currentHost = typeof window !== "undefined" ? window.location.hostname : "localhost";
+		const currentPort = typeof window !== "undefined" ? window.location.port : "8000";
+		const effectivePort = currentPort || (window.location.protocol === "https:" ? "443" : "80");
+		return {
+			same: serverHost.value === currentHost && String(serverPort.value) === effectivePort || serverHost.value === "localhost" && currentHost !== "localhost",
+			currentHost,
+			currentPort
+		};
+	}
+	function getApiBaseUrl() {
+		const { same } = _isSameOrigin();
+		if (same) return apiPrefix;
+		return `http://${serverHost.value}:${serverPort.value}${apiPrefix}`;
+	}
+	function getWsBaseUrl() {
+		const { same, currentHost, currentPort } = _isSameOrigin();
+		const protocol = typeof window !== "undefined" && window.location.protocol === "https:" ? "wss:" : "ws:";
+		if (same) return `${protocol}//${currentHost}${currentPort ? ":" + currentPort : ""}${apiPrefix}`;
+		return `ws://${serverHost.value}:${serverPort.value}${apiPrefix}`;
+	}
+	let _initialized = false;
+	function initialize() {
+		if (_initialized) return;
+		_initialized = true;
+		const loaded = loadSettings();
+		serverHost.value = loaded.serverHost;
+		serverPort.value = loaded.serverPort;
+		requestTimeout.value = loaded.requestTimeout;
+		wsAutoReconnect.value = loaded.wsAutoReconnect;
+		wsReconnectInterval.value = loaded.wsReconnectInterval;
+		theme.value = loaded.theme;
+		colorPalette.value = loaded.colorPalette;
+		tableDensity.value = loaded.tableDensity;
+		applyTheme();
+		applyPalette();
+		applyDensity();
+	}
+	function applyTheme() {
+		if (typeof document === "undefined") return;
+		const dark = theme.value === "system" ? systemPrefersDark.value : theme.value === "dark";
+		document.documentElement.classList.toggle("dark", dark);
+	}
+	/**
+	* Write the selected palette's hues onto `<html>` as custom-property
+	* overrides. The `default` palette clears them so `styles/variables.css`
+	* keeps ownership of the brand colors.
+	*/
+	function applyPalette() {
+		if (typeof document === "undefined") return;
+		const style = document.documentElement.style;
+		const overrides = paletteCssVariables(colorPalette.value);
+		for (const name of PALETTE_CSS_VARIABLES) {
+			const value = overrides[name];
+			if (value) style.setProperty(name, value);
+			else style.removeProperty(name);
+		}
+	}
+	/** Mirror the table density onto `<html data-density>` for CSS consumers. */
+	function applyDensity() {
+		if (typeof document === "undefined") return;
+		document.documentElement.dataset.density = tableDensity.value;
+	}
+	watch(theme, () => {
+		applyTheme();
+		persistSettings();
+	});
+	watch(colorPalette, applyPalette);
+	watch(tableDensity, applyDensity);
+	if (typeof window !== "undefined" && typeof window.matchMedia === "function") window.matchMedia("(prefers-color-scheme: dark)").addEventListener("change", (event) => {
+		systemPrefersDark.value = event.matches;
+		if (theme.value === "system") applyTheme();
+	});
+	function persistSettings() {
+		saveSettings({
+			serverHost: serverHost.value,
+			serverPort: serverPort.value,
+			requestTimeout: requestTimeout.value,
+			wsAutoReconnect: wsAutoReconnect.value,
+			wsReconnectInterval: wsReconnectInterval.value,
+			theme: theme.value,
+			colorPalette: colorPalette.value,
+			tableDensity: tableDensity.value
+		});
+	}
+	watch([
+		serverHost,
+		serverPort,
+		requestTimeout,
+		wsAutoReconnect,
+		wsReconnectInterval,
+		colorPalette,
+		tableDensity
+	], () => {
+		persistSettings();
+	});
+	function resetToDefaults() {
+		serverHost.value = defaultSettings.serverHost;
+		serverPort.value = defaultSettings.serverPort;
+		requestTimeout.value = defaultSettings.requestTimeout;
+		wsAutoReconnect.value = defaultSettings.wsAutoReconnect;
+		wsReconnectInterval.value = defaultSettings.wsReconnectInterval;
+		theme.value = defaultSettings.theme;
+		colorPalette.value = defaultSettings.colorPalette;
+		tableDensity.value = defaultSettings.tableDensity;
+	}
+	function getPaletteHues() {
+		return colorPalettes[colorPalette.value].hues;
+	}
+	/** The `size` the SDK table components default to for the current density. */
+	function getTableSize() {
+		return tableDensityToSize(tableDensity.value);
+	}
+	function isDark() {
+		return theme.value === "system" ? systemPrefersDark.value : theme.value === "dark";
+	}
+	return {
+		serverHost,
+		serverPort,
+		requestTimeout,
+		wsAutoReconnect,
+		wsReconnectInterval,
+		theme,
+		systemPrefersDark,
+		colorPalette,
+		tableDensity,
+		initialize,
+		applyTheme,
+		applyPalette,
+		applyDensity,
+		persistSettings,
+		resetToDefaults,
+		getPaletteHues,
+		getTableSize,
+		isDark,
+		getApiBaseUrl,
+		getWsBaseUrl
+	};
+});
+/**
+* Read the settings store without requiring Pinia to be installed.
+*
+* SDK components are mounted standalone (unit tests, Histoire stories, plugin
+* previews) where no Pinia instance exists. They use this to pick up a user's
+* preferences when the platform is running and fall back to their own defaults
+* otherwise, instead of throwing.
+*/
+function tryUseSettingsStore() {
+	if (!getActivePinia()) return null;
+	try {
+		return useSettingsStore();
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/composables/useApi.ts
+var apiClientInstance = null;
+var interceptorAttached = false;
+function joinUrlPath(baseUrl, path) {
+	if (/^https?:\/\//i.test(path)) return path;
+	if (!path) return baseUrl;
+	if (path.startsWith("?") || path.startsWith("#")) return `${baseUrl.replace(/\/+$/, "")}${path}`;
+	const normalizedBase = baseUrl.replace(/\/+$/, "");
+	const normalizedPath = path.replace(/^\/+/, "/");
+	return `${normalizedBase}${normalizedPath.startsWith("/") ? normalizedPath : `/${normalizedPath}`}`;
+}
+function getBasePath(baseUrl) {
+	if (!baseUrl) return "/";
+	try {
+		const origin = typeof window !== "undefined" ? window.location.origin : "http://localhost";
+		return new URL(baseUrl, origin).pathname.replace(/\/+$/, "") || "/";
+	} catch {
+		return baseUrl.replace(/^https?:\/\/[^/]+/i, "").replace(/\/+$/, "") || "/";
+	}
+}
+function normalizeRequestUrl(baseUrl, url) {
+	if (!url || /^https?:\/\//.test(url)) return url;
+	const basePath = getBasePath(baseUrl);
+	if (basePath === "/") return url;
+	const normalizedUrl = url.startsWith("/") ? url : `/${url}`;
+	if (normalizedUrl === basePath || normalizedUrl.startsWith(`${basePath}?`) || normalizedUrl.startsWith(`${basePath}#`)) return normalizedUrl.slice(basePath.length);
+	if (normalizedUrl.startsWith(`${basePath}/`)) return normalizedUrl.slice(basePath.length) || "";
+	return url;
+}
+function asMutableHeaders(headers) {
+	return headers ? headers : null;
+}
+function hasAuthorizationHeader(headers) {
+	const bag = asMutableHeaders(headers);
+	if (!bag) return false;
+	if (typeof bag.has === "function") return bag.has("Authorization");
+	return Object.keys(bag).some((key) => key.toLowerCase() === "authorization");
+}
+function setAuthorizationHeader(headers, value) {
+	const bag = asMutableHeaders(headers);
+	if (!bag) return;
+	if (typeof bag.set === "function") {
+		bag.set("Authorization", value);
+		return;
+	}
+	bag.Authorization = value;
+}
+function deleteAuthorizationHeader(headers) {
+	const bag = asMutableHeaders(headers);
+	if (!bag) return;
+	if (typeof bag.delete === "function") {
+		bag.delete("Authorization");
+		return;
+	}
+	for (const key of Object.keys(bag)) if (key.toLowerCase() === "authorization") delete bag[key];
+}
+function getAuthorizationHeader(headers) {
+	const bag = asMutableHeaders(headers);
+	if (!bag) return void 0;
+	if (typeof bag.get === "function") return bag.get("Authorization");
+	const key = Object.keys(bag).find((candidate) => candidate.toLowerCase() === "authorization");
+	return key ? bag[key] : void 0;
+}
+/**
+* Raised when an authenticated SDK request is rejected because the login is no
+* longer valid. It is also a `MintApiError` (status 401), so typed-error callers
+* and `instanceof AuthenticationRequiredError` callers both recognise it.
+*/
+var AuthenticationRequiredError = class extends MintApiError {
+	name = "AuthenticationRequiredError";
+	constructor(cause, envelope) {
+		super("Authentication required. Please sign in again.", "AUTHENTICATION_REQUIRED", 401, envelope?.requestId ?? null, envelope?.details ?? null, envelope?.detail, envelope?.body ?? null, cause);
+	}
+};
+/** @internal Convert a rejected authenticated request into the SDK's public auth error. */
+function authenticationRequiredError(cause, rejectedToken, envelope) {
+	const currentAuthStore = useAuthStore();
+	if (rejectedToken && currentAuthStore.token === rejectedToken) currentAuthStore.clearToken();
+	return new AuthenticationRequiredError(cause, envelope);
+}
+function getApiClient() {
+	if (!apiClientInstance) apiClientInstance = axios.create({ headers: { "Content-Type": "application/json" } });
+	return apiClientInstance;
+}
+/** Axios-based API client that injects the plugin base URL and JWT auth header on every request. A failed response rejects with a `MintApiError`. */
+function useApi(options = {}) {
+	const settingsStore = useSettingsStore();
+	const authStore = useAuthStore();
+	const apiClient = getApiClient();
+	if (!authStore.isInitialized) authStore.initialize();
+	if (!interceptorAttached) {
+		apiClient.interceptors.request.use((config) => {
+			const request = config;
+			if (request._mintSkipAuth) {
+				deleteAuthorizationHeader(request.headers);
+				return request;
+			}
+			const currentAuthStore = useAuthStore();
+			if (currentAuthStore.token && config.headers && !hasAuthorizationHeader(config.headers)) setAuthorizationHeader(config.headers, `Bearer ${currentAuthStore.token}`);
+			if (getAuthorizationHeader(config.headers) === `Bearer ${currentAuthStore.token}`) request._mintAuthToken = currentAuthStore.token ?? void 0;
+			return config;
+		});
+		apiClient.interceptors.response.use((response) => response, async (error) => {
+			if (axios.isAxiosError(error) && error.response) {
+				const request = error.config;
+				let payload = error.response.data;
+				if (payload instanceof Blob) try {
+					payload = JSON.parse(await payload.text());
+				} catch {}
+				const typed = mintApiErrorFromResponse(error.response.status, payload, {
+					requestId: String(error.response.headers?.["x-request-id"] ?? "") || null,
+					cause: error
+				});
+				if (error.response.status === 401 && request?._mintSkipAuth !== true) return Promise.reject(authenticationRequiredError(error, request?._mintAuthToken, typed));
+				return Promise.reject(typed);
+			}
+			return Promise.reject(error);
+		});
+		interceptorAttached = true;
+	}
+	function getBaseUrl() {
+		return options.baseUrl ?? settingsStore.getApiBaseUrl();
+	}
+	function normalizeUrl(url) {
+		return normalizeRequestUrl(getBaseUrl(), url);
+	}
+	function requestConfig(config) {
+		const base = {
+			baseURL: getBaseUrl(),
+			timeout: options.timeout ?? settingsStore.requestTimeout,
+			...config
+		};
+		if (options.withAuth === false) {
+			base._mintSkipAuth = true;
+			deleteAuthorizationHeader(base.headers);
+		}
+		return base;
+	}
+	async function get(url, config) {
+		return (await apiClient.get(normalizeUrl(url), requestConfig(config))).data;
+	}
+	async function post(url, data, config) {
+		return (await apiClient.post(normalizeUrl(url), data, requestConfig(config))).data;
+	}
+	async function put(url, data, config) {
+		return (await apiClient.put(normalizeUrl(url), data, requestConfig(config))).data;
+	}
+	async function patch(url, data, config) {
+		return (await apiClient.patch(normalizeUrl(url), data, requestConfig(config))).data;
+	}
+	async function del(url, config) {
+		return (await apiClient.delete(normalizeUrl(url), requestConfig(config))).data;
+	}
+	async function upload(url, file, fieldName = "file", additionalData) {
+		const formData = new FormData();
+		formData.append(fieldName, file);
+		if (additionalData) Object.entries(additionalData).forEach(([key, value]) => {
+			if (value !== void 0 && value !== null) formData.append(key, typeof value === "object" ? JSON.stringify(value) : String(value));
+		});
+		return (await apiClient.post(normalizeUrl(url), formData, requestConfig({ headers: { "Content-Type": void 0 } }))).data;
+	}
+	async function download(url, filename) {
+		const response = await apiClient.get(normalizeUrl(url), requestConfig({ responseType: "blob" }));
+		const blob = new Blob([response.data]);
+		const blobUrl = URL.createObjectURL(blob);
+		if (filename) {
+			const link = document.createElement("a");
+			link.href = blobUrl;
+			link.download = filename;
+			document.body.appendChild(link);
+			link.click();
+			document.body.removeChild(link);
+			setTimeout(() => URL.revokeObjectURL(blobUrl), 100);
+			return "";
+		}
+		return blobUrl;
+	}
+	function buildUrl(path) {
+		const baseUrl = getBaseUrl();
+		return joinUrlPath(baseUrl, normalizeRequestUrl(baseUrl, path));
+	}
+	function buildWsUrl(path) {
+		return joinUrlPath(settingsStore.getWsBaseUrl(), path);
+	}
+	return {
+		client: apiClient,
+		get,
+		post,
+		put,
+		patch,
+		delete: del,
+		upload,
+		download,
+		buildUrl,
+		buildWsUrl
+	};
+}
+//#endregion
+//#region src/utils/errors.ts
+/**
+* The one place a thrown value is turned into a developer-facing message.
+*
+* Five copies of this logic drifted apart across the composables and stores
+* (some checked a bare `{ message }` object, some did not); this export is the
+* union of what they all accepted, so every caller now reads the same message
+* from the same value.
+*/
+function readErrorMessage(value, fallback = "Request failed.") {
+	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 fallback;
+}
+//#endregion
+//#region src/utils/integrationHost.ts
+/** The integration host of this page, or `undefined` outside a platform-served plugin page. */
+function integrationHost() {
+	if (typeof window === "undefined") return void 0;
+	return window.__MINT_INTEGRATION__;
+}
+//#endregion
+//#region src/stores/experiment.ts
+function getPlatformApiUrl() {
+	if (typeof window === "undefined") return void 0;
+	return window.__MINT_PLATFORM__?.platformApiUrl;
+}
+/**
+* The single source of truth for the experiment a plugin is currently working on.
+*
+* Both entry points land here: `ExperimentSelectorModal` calls `select()` with a
+* record the platform already returned, and deep links call `selectById()` with
+* nothing but an id. Because a name can only ever arrive from the platform,
+* there is no code path in which a caller can invent one.
+*
+* In a platform-served plugin page the platform integration script keeps the
+* store and the `experiment_id` URL parameter in step.
+*/
+var useExperimentStore = defineStore("mint-experiment", () => {
+	const current = ref(null);
+	const currentId = ref(null);
+	const isResolving = ref(false);
+	const error = ref(null);
+	const inFlight = /* @__PURE__ */ new Map();
+	let selectionToken = 0;
+	function fetchExperiment(id) {
+		const pending = inFlight.get(id);
+		if (pending) return pending;
+		const base = getPlatformApiUrl() ?? "";
+		const request = useApi().get(`${base}/experiments/${id}`).finally(() => {
+			inFlight.delete(id);
+		});
+		inFlight.set(id, request);
+		return request;
+	}
+	/** Adopt a record the platform already returned, without a further request. */
+	function select(experiment) {
+		selectionToken += 1;
+		current.value = experiment;
+		currentId.value = experiment.id;
+		error.value = null;
+		isResolving.value = false;
+	}
+	/**
+	* Bind to an experiment known only by id, resolving its record from the
+	* platform. On failure the binding is remembered but `current` stays null, so
+	* callers can distinguish "not resolved yet" from "nothing selected".
+	*/
+	async function selectById(id) {
+		const joinsCurrentResolution = isResolving.value && currentId.value === id;
+		const token = joinsCurrentResolution ? selectionToken : selectionToken += 1;
+		if (!joinsCurrentResolution) {
+			current.value = null;
+			currentId.value = id;
+			error.value = null;
+			isResolving.value = true;
+		}
+		try {
+			const experiment = await fetchExperiment(id);
+			if (token !== selectionToken) return null;
+			current.value = experiment;
+			return experiment;
+		} catch (err) {
+			if (token !== selectionToken) return null;
+			current.value = null;
+			error.value = readErrorMessage(err, "Failed to load experiment");
+			return null;
+		} finally {
+			if (token === selectionToken) isResolving.value = false;
+		}
+	}
+	/** Read the selected experiment again. The selection and its record stay in place. */
+	async function refresh() {
+		const id = currentId.value;
+		if (id === null) return;
+		const token = selectionToken;
+		try {
+			const experiment = await fetchExperiment(id);
+			if (token !== selectionToken) return;
+			current.value = experiment;
+			error.value = null;
+		} catch (err) {
+			if (token === selectionToken) error.value = readErrorMessage(err, "Failed to load experiment");
+		}
+	}
+	function clear() {
+		selectionToken += 1;
+		current.value = null;
+		currentId.value = null;
+		error.value = null;
+		isResolving.value = false;
+	}
+	integrationHost()?.bindExperimentStore({
+		currentId: () => currentId.value,
+		selectById,
+		onChange: (listener) => {
+			watch(currentId, listener);
+		}
+	});
+	return {
+		current,
+		currentId,
+		isResolving,
+		error,
+		select,
+		selectById,
+		refresh,
+		clear
+	};
+});
+//#endregion
+export { authenticationRequiredError as a, colorPalettes as c, tryUseSettingsStore as d, useSettingsStore as f, AuthenticationRequiredError as i, paletteCssVariables as l, mintApiErrorFromResponse as m, integrationHost as n, useApi as o, MintApiError as p, readErrorMessage as r, PALETTE_CSS_VARIABLES as s, useExperimentStore as t, tableDensityToSize as u };
+
+//# sourceMappingURL=experiment-43OJtH7R.js.map