@morscherlab/mint-sdk 1.0.0-alpha.2

package/dist/composables-D0QfFzq1.js

@@ -0,0 +1,805 @@
+import { M as usePlatformContext, V as useApi } from "./useScheduleDrag-DAJueTbK.js";
+import { r as useSettingsStore, t as useAuthStore } from "./auth-BYmxZdJl.js";
+import { computed, getCurrentInstance, onMounted, onUnmounted, ref, watch } from "vue";
+import axios from "axios";
+//#region src/composables/useAuth.ts
+var TOKEN_REFRESH_MARGIN_MS = 300 * 1e3;
+var TOKEN_REFRESH_CHECK_INTERVAL_MS = 60 * 1e3;
+var _refreshPromise = null;
+var _refreshTimerId = null;
+var _mountedConsumerCount = 0;
+/** Manages authentication state with login/logout/register and automatic JWT token refresh. */
+function useAuth() {
+	const authStore = useAuthStore();
+	const settingsStore = useSettingsStore();
+	const isRefreshing = ref(false);
+	function getApiBaseUrl() {
+		return settingsStore.getApiBaseUrl();
+	}
+	async function fetchAuthConfig() {
+		try {
+			const response = await axios.get(`${getApiBaseUrl()}/setup/config/public`);
+			const config = {
+				authRequired: response.data.auth_required,
+				passkeyEnabled: response.data.passkey_enabled,
+				passkeyRegistered: response.data.passkey_registered ?? false,
+				registrationEnabled: response.data.registration_enabled ?? false,
+				databaseMode: response.data.database_mode ?? "none"
+			};
+			authStore.setAuthConfig(config);
+			return config;
+		} catch (error) {
+			console.error("Failed to fetch auth config:", error);
+			return {
+				authRequired: false,
+				passkeyEnabled: false,
+				passkeyRegistered: false,
+				registrationEnabled: false,
+				databaseMode: "none"
+			};
+		}
+	}
+	async function login(username, password) {
+		authStore.setLoading(true);
+		authStore.setError(null);
+		try {
+			const response = await axios.post(`${getApiBaseUrl()}/auth/login`, {
+				username,
+				password
+			});
+			authStore.setToken(response.data.access_token, response.data.expires_in);
+			authStore.setUsername(username);
+			await getCurrentUser();
+			scheduleTokenRefresh();
+			return true;
+		} catch (error) {
+			if (axios.isAxiosError(error) && error.response) authStore.setError(error.response.data.detail || "Login failed");
+			else authStore.setError("Network error. Please try again.");
+			return false;
+		} finally {
+			authStore.setLoading(false);
+		}
+	}
+	async function register(username, password, email) {
+		authStore.setLoading(true);
+		authStore.setError(null);
+		try {
+			await axios.post(`${getApiBaseUrl()}/users/register`, {
+				username,
+				password,
+				email
+			});
+			return await login(username, password);
+		} catch (error) {
+			if (axios.isAxiosError(error) && error.response) authStore.setError(error.response.data.detail || "Registration failed");
+			else authStore.setError("Network error. Please try again.");
+			return false;
+		} finally {
+			authStore.setLoading(false);
+		}
+	}
+	async function getCurrentUser() {
+		if (!authStore.token) return null;
+		try {
+			const response = await axios.get(`${getApiBaseUrl()}/users/me`, { headers: getAuthHeader() });
+			const userInfo = {
+				id: response.data.id,
+				username: response.data.username,
+				shortname: response.data.shortname,
+				email: response.data.email,
+				role: response.data.role,
+				isActive: response.data.is_active
+			};
+			authStore.setUserInfo(userInfo);
+			return userInfo;
+		} catch {
+			return null;
+		}
+	}
+	async function verifyToken() {
+		if (!authStore.token) return false;
+		try {
+			const response = await axios.get(`${getApiBaseUrl()}/auth/verify`, { headers: { Authorization: `Bearer ${authStore.token}` } });
+			if (response.data.valid && response.data.username) {
+				authStore.setUsername(response.data.username);
+				return true;
+			}
+			authStore.clearToken();
+			return false;
+		} catch {
+			authStore.clearToken();
+			return false;
+		}
+	}
+	/**
+	* Refresh the authentication token.
+	* Called automatically before token expiration.
+	* Uses promise caching to prevent concurrent refresh requests.
+	*/
+	async function refreshToken() {
+		if (!authStore.token) return false;
+		if (_refreshPromise) return _refreshPromise;
+		_refreshPromise = (async () => {
+			isRefreshing.value = true;
+			try {
+				const response = await axios.post(`${getApiBaseUrl()}/auth/refresh`, {}, { headers: getAuthHeader() });
+				authStore.setToken(response.data.access_token, response.data.expires_in);
+				scheduleTokenRefresh();
+				return true;
+			} catch (error) {
+				if (axios.isAxiosError(error) && error.response?.status === 401) {
+					console.warn("[Auth] Token refresh failed - session expired");
+					authStore.clearToken();
+					stopTokenRefresh();
+				}
+				return false;
+			} finally {
+				isRefreshing.value = false;
+				_refreshPromise = null;
+			}
+		})();
+		return _refreshPromise;
+	}
+	/**
+	* Schedule automatic token refresh before expiration.
+	*/
+	function scheduleTokenRefresh() {
+		stopTokenRefresh();
+		if (!authStore.tokenExpires) return;
+		const refreshAt = authStore.tokenExpires.getTime() - TOKEN_REFRESH_MARGIN_MS;
+		const now = Date.now();
+		if (refreshAt <= now) {
+			refreshToken();
+			return;
+		}
+		const delay = refreshAt - now;
+		_refreshTimerId = window.setTimeout(() => {
+			refreshToken();
+		}, delay);
+	}
+	/**
+	* Stop automatic token refresh.
+	*/
+	function stopTokenRefresh() {
+		if (_refreshTimerId !== null) {
+			window.clearTimeout(_refreshTimerId);
+			_refreshTimerId = null;
+		}
+	}
+	/**
+	* Check if token needs refresh and refresh if necessary.
+	* Called periodically as a safety net.
+	*/
+	function checkAndRefreshIfNeeded() {
+		if (!authStore.token || !authStore.tokenExpires) return;
+		const refreshAt = authStore.tokenExpires.getTime() - TOKEN_REFRESH_MARGIN_MS;
+		if (Date.now() >= refreshAt) refreshToken();
+	}
+	async function initializeAuth() {
+		authStore.initialize();
+		await fetchAuthConfig();
+		if (authStore.token) {
+			if (await verifyToken()) {
+				await getCurrentUser();
+				scheduleTokenRefresh();
+			}
+		}
+	}
+	function logout() {
+		stopTokenRefresh();
+		authStore.logout();
+	}
+	function getAuthHeader() {
+		if (authStore.token) return { Authorization: `Bearer ${authStore.token}` };
+		return {};
+	}
+	async function updateProfile(data) {
+		if (!authStore.token) return {
+			success: false,
+			error: "Not authenticated"
+		};
+		try {
+			const requestData = {};
+			if (data.email !== void 0) requestData.email = data.email;
+			if (data.shortname !== void 0) requestData.shortname = data.shortname;
+			if (data.currentPassword) requestData.current_password = data.currentPassword;
+			if (data.newPassword) requestData.new_password = data.newPassword;
+			const response = await axios.put(`${getApiBaseUrl()}/users/me`, requestData, { headers: getAuthHeader() });
+			const userInfo = {
+				id: response.data.id,
+				username: response.data.username,
+				shortname: response.data.shortname,
+				email: response.data.email,
+				role: response.data.role,
+				isActive: response.data.is_active
+			};
+			authStore.setUserInfo(userInfo);
+			return { success: true };
+		} catch (error) {
+			if (axios.isAxiosError(error) && error.response) return {
+				success: false,
+				error: error.response.data.detail || "Update failed"
+			};
+			return {
+				success: false,
+				error: "Network error. Please try again."
+			};
+		}
+	}
+	let checkInterval = null;
+	if (getCurrentInstance()) {
+		onMounted(() => {
+			_mountedConsumerCount += 1;
+			checkInterval = window.setInterval(checkAndRefreshIfNeeded, TOKEN_REFRESH_CHECK_INTERVAL_MS);
+		});
+		onUnmounted(() => {
+			if (checkInterval !== null) {
+				window.clearInterval(checkInterval);
+				checkInterval = null;
+			}
+			_mountedConsumerCount = Math.max(0, _mountedConsumerCount - 1);
+			if (_mountedConsumerCount === 0) stopTokenRefresh();
+		});
+		watch(() => authStore.tokenExpires, (newExpires) => {
+			if (newExpires) scheduleTokenRefresh();
+			else stopTokenRefresh();
+		});
+	}
+	return {
+		login,
+		logout,
+		register,
+		verifyToken,
+		fetchAuthConfig,
+		initializeAuth,
+		getCurrentUser,
+		getAuthHeader,
+		updateProfile,
+		refreshToken,
+		isRefreshing
+	};
+}
+//#endregion
+//#region src/composables/usePasskey.ts
+async function loadWebAuthn() {
+	try {
+		return await import("@simplewebauthn/browser");
+	} catch {
+		throw new Error("@simplewebauthn/browser is required for passkey support. Install it: bun add @simplewebauthn/browser");
+	}
+}
+/** Registers and authenticates passkeys using WebAuthn, lazily loading the browser dependency. */
+function usePasskey() {
+	const authStore = useAuthStore();
+	const settingsStore = useSettingsStore();
+	function getApiBaseUrl() {
+		return settingsStore.getApiBaseUrl();
+	}
+	async function isSupported() {
+		try {
+			const { browserSupportsWebAuthn } = await loadWebAuthn();
+			return browserSupportsWebAuthn();
+		} catch {
+			return false;
+		}
+	}
+	async function registerPasskey(deviceName) {
+		const webauthn = await loadWebAuthn();
+		if (!webauthn.browserSupportsWebAuthn()) {
+			authStore.setError("WebAuthn is not supported in this browser");
+			return false;
+		}
+		authStore.setLoading(true);
+		authStore.setError(null);
+		try {
+			const optionsResponse = await axios.get(`${getApiBaseUrl()}/auth/passkey/register/options`, {
+				headers: { Authorization: `Bearer ${authStore.token}` },
+				withCredentials: true
+			});
+			const options = JSON.parse(optionsResponse.data.options);
+			const credential = await webauthn.startRegistration(options);
+			await axios.post(`${getApiBaseUrl()}/auth/passkey/register/verify`, {
+				credential: JSON.stringify(credential),
+				device_name: deviceName
+			}, {
+				headers: { Authorization: `Bearer ${authStore.token}` },
+				withCredentials: true
+			});
+			authStore.setAuthConfig({
+				...authStore.authConfig,
+				passkeyRegistered: true
+			});
+			return true;
+		} catch (error) {
+			if (axios.isAxiosError(error) && error.response) authStore.setError(error.response.data.detail || "Passkey registration failed");
+			else if (error instanceof Error) if (error.name === "NotAllowedError") authStore.setError("Registration was cancelled or timed out");
+			else if (error.name === "InvalidStateError") authStore.setError("This authenticator is already registered");
+			else authStore.setError(error.message);
+			else authStore.setError("Passkey registration failed");
+			return false;
+		} finally {
+			authStore.setLoading(false);
+		}
+	}
+	async function loginWithPasskey() {
+		const webauthn = await loadWebAuthn();
+		if (!webauthn.browserSupportsWebAuthn()) {
+			authStore.setError("WebAuthn is not supported in this browser");
+			return false;
+		}
+		authStore.setLoading(true);
+		authStore.setError(null);
+		try {
+			const optionsResponse = await axios.get(`${getApiBaseUrl()}/auth/passkey/login/options`, { withCredentials: true });
+			const options = JSON.parse(optionsResponse.data.options);
+			const credential = await webauthn.startAuthentication(options);
+			const response = await axios.post(`${getApiBaseUrl()}/auth/passkey/login/verify`, { credential: JSON.stringify(credential) }, { withCredentials: true });
+			authStore.setToken(response.data.access_token, response.data.expires_in);
+			return true;
+		} catch (error) {
+			if (axios.isAxiosError(error) && error.response) if (error.response.status === 404) authStore.setError("No passkeys registered. Please login with password first.");
+			else authStore.setError(error.response.data.detail || "Passkey login failed");
+			else if (error instanceof Error) if (error.name === "NotAllowedError") authStore.setError("Authentication was cancelled or timed out");
+			else authStore.setError(error.message);
+			else authStore.setError("Passkey login failed");
+			return false;
+		} finally {
+			authStore.setLoading(false);
+		}
+	}
+	async function listCredentials() {
+		try {
+			return (await axios.get(`${getApiBaseUrl()}/auth/passkey/credentials`, { headers: { Authorization: `Bearer ${authStore.token}` } })).data.credentials;
+		} catch {
+			return [];
+		}
+	}
+	async function deleteCredential(credentialId) {
+		try {
+			await axios.delete(`${getApiBaseUrl()}/auth/passkey/credentials/${encodeURIComponent(credentialId)}`, { headers: { Authorization: `Bearer ${authStore.token}` } });
+			if ((await listCredentials()).length === 0) authStore.setAuthConfig({
+				...authStore.authConfig,
+				passkeyRegistered: false
+			});
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	async function deleteAllCredentials() {
+		try {
+			await axios.delete(`${getApiBaseUrl()}/auth/passkey/credentials`, { headers: { Authorization: `Bearer ${authStore.token}` } });
+			authStore.setAuthConfig({
+				...authStore.authConfig,
+				passkeyRegistered: false
+			});
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	return {
+		isSupported,
+		registerPasskey,
+		loginWithPasskey,
+		listCredentials,
+		deleteCredential,
+		deleteAllCredentials
+	};
+}
+//#endregion
+//#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. */
+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
+/** Loads, saves, and tracks dirty state for a plugin's persistent configuration via the platform API. */
+function usePluginConfig(pluginName) {
+	const api = useApi();
+	const { plugin } = usePlatformContext();
+	const resolvedName = computed(() => pluginName ?? plugin.value?.name ?? "");
+	const config = ref({});
+	const savedConfig = ref({});
+	const isLoading = ref(false);
+	const isSaving = ref(false);
+	const error = ref(null);
+	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;
+		error.value = null;
+		try {
+			const response = await api.get(`/plugins/${encodeURIComponent(name)}/config`);
+			config.value = { ...response.config };
+			savedConfig.value = { ...response.config };
+		} catch (e) {
+			error.value = e instanceof Error ? e.message : "Failed to load plugin config";
+		} finally {
+			isLoading.value = false;
+		}
+	}
+	async function save() {
+		const name = resolvedName.value;
+		if (!name) return false;
+		isSaving.value = true;
+		error.value = null;
+		try {
+			const response = await api.patch(`/plugins/${encodeURIComponent(name)}/config`, { config: config.value });
+			config.value = { ...response.config };
+			savedConfig.value = { ...response.config };
+			return true;
+		} catch (e) {
+			error.value = e instanceof Error ? e.message : "Failed to save plugin config";
+			return false;
+		} finally {
+			isSaving.value = false;
+		}
+	}
+	function reset() {
+		config.value = { ...savedConfig.value };
+		error.value = null;
+	}
+	onMounted(() => {
+		load();
+	});
+	return {
+		config,
+		isLoading,
+		isSaving,
+		error,
+		isDirty,
+		load,
+		save,
+		reset
+	};
+}
+//#endregion
+//#region src/composables/useExperimentSave.ts
+/** Persists and loads experiment design and analysis data via the plugin's API endpoint. */
+function useExperimentSave(options = {}) {
+	const api = useApi({ baseUrl: options.apiBaseUrl });
+	const pluginId = options.pluginId;
+	const schemaVersion = options.schemaVersion ?? "1.0";
+	const isSaving = ref(false);
+	const error = ref(null);
+	const lastSavedAt = ref(null);
+	function setError(e) {
+		error.value = e instanceof Error ? e.message : "Unknown error";
+	}
+	async function saveDesign(experimentId, data) {
+		if (!pluginId) {
+			error.value = "pluginId is required for saveDesign";
+			return false;
+		}
+		isSaving.value = true;
+		error.value = null;
+		try {
+			await api.put(`/experiments/${experimentId}/data`, {
+				plugin_id: pluginId,
+				data,
+				schema_version: schemaVersion
+			});
+			lastSavedAt.value = /* @__PURE__ */ new Date();
+			return true;
+		} catch (e) {
+			setError(e);
+			return false;
+		} finally {
+			isSaving.value = false;
+		}
+	}
+	async function saveAnalysis(experimentId, result) {
+		if (!pluginId) {
+			error.value = "pluginId is required for saveAnalysis";
+			return false;
+		}
+		isSaving.value = true;
+		error.value = null;
+		try {
+			await api.put(`/experiments/${experimentId}/results/${pluginId}`, { result });
+			lastSavedAt.value = /* @__PURE__ */ new Date();
+			return true;
+		} catch (e) {
+			setError(e);
+			return false;
+		} finally {
+			isSaving.value = false;
+		}
+	}
+	async function save(experimentId, opts) {
+		if ((opts.design || opts.analysis) && !pluginId) {
+			error.value = "pluginId is required for save";
+			return false;
+		}
+		isSaving.value = true;
+		error.value = null;
+		try {
+			if (opts.design) await api.put(`/experiments/${experimentId}/data`, {
+				plugin_id: pluginId,
+				data: opts.design,
+				schema_version: schemaVersion
+			});
+			if (opts.analysis) await api.put(`/experiments/${experimentId}/results/${pluginId}`, { result: opts.analysis });
+			lastSavedAt.value = /* @__PURE__ */ new Date();
+			return true;
+		} catch (e) {
+			setError(e);
+			return false;
+		} finally {
+			isSaving.value = false;
+		}
+	}
+	async function loadDesign(experimentId) {
+		try {
+			return await api.get(`/experiments/${experimentId}/data`);
+		} catch {
+			return null;
+		}
+	}
+	async function loadAnalysis(experimentId) {
+		if (!pluginId) return null;
+		try {
+			return await api.get(`/experiments/${experimentId}/results/${pluginId}`);
+		} catch {
+			return null;
+		}
+	}
+	async function deleteDesign(experimentId) {
+		try {
+			await api.delete(`/experiments/${experimentId}/data`);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	async function deleteAnalysis(experimentId) {
+		if (!pluginId) return false;
+		try {
+			await api.delete(`/experiments/${experimentId}/results/${pluginId}`);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	return {
+		isSaving,
+		error,
+		lastSavedAt,
+		saveDesign,
+		saveAnalysis,
+		save,
+		loadDesign,
+		loadAnalysis,
+		deleteDesign,
+		deleteAnalysis
+	};
+}
+//#endregion
+//#region src/composables/usePluginApi.ts
+/**
+* Pre-configured API client for plugins.
+*
+* Resolves the base URL in priority order:
+* 1. `import.meta.env.VITE_API_PREFIX` (build-time env override)
+* 2. `fallbackPrefix` option (plugin's route prefix)
+* 3. `'/api'` (default)
+*
+* Eliminates the repeated pattern across plugins:
+* ```ts
+* const API_BASE = import.meta.env.VITE_API_PREFIX || '/api/my-plugin'
+* const api = useApi({ baseUrl: API_BASE })
+* ```
+*
+* @example
+* ```ts
+* const api = usePluginApi({ fallbackPrefix: '/api/drp' })
+* const data = await api.get('/sessions')
+* ```
+*/
+/** Pre-configured API client resolving the plugin base URL from VITE_API_PREFIX or a fallback prefix. */
+function usePluginApi(options = {}) {
+	return useApi({ baseUrl: options.fallbackPrefix || "/api" });
+}
+//#endregion
+export { useAsyncBatch as a, useAsync as i, useExperimentSave as n, usePasskey as o, usePluginConfig as r, useAuth as s, usePluginApi as t };
+
+//# sourceMappingURL=composables-D0QfFzq1.js.map