@morscherlab/mint-sdk 1.3.11 → 1.4.0-beta.10

package/dist/data-CgILxDLW.js

@@ -0,0 +1,3865 @@
+import { a as BaseButton_default, n as BaseModal_default, o as __exportAll } from "./useDropdownState-8yWMu-7_.js";
+import { o as useApi, p as MintApiError, t as useExperimentStore } from "./experiment-43OJtH7R.js";
+import { A as formatRelativeTime, C as formatExperimentDate, G as BaseInput_default, I as FormField_default, S as experimentIdFromRoute, T as FileUploader_default, V as BaseSelect_default, _ as APP_EXPERIMENT_KEY, b as SORT_OPTIONS, g as pluginSecrets_exports, i as getInjectedPlatformContext, m as SecretInput_default, n as ResourcePickerListInternal_default, p as TagsInput_default, r as Skeleton_default, v as useAppExperiment, w as resolveExperimentCode, x as datePresetToISO, y as DATE_PRESET_OPTIONS, z as BaseCheckbox_default } from "./records-B6gpM_3e.js";
+import { t as SegmentedControl_default } from "./SegmentedControl-BtnnjWzs.js";
+import { a as normalizeSearchQuery, i as candidateMatchesSearch, n as DataStateInternal_default, o as useTextSearch, t as AlertBox_default } from "./AlertBox-B2Bgr3ei.js";
+import { n as ActionMenu_default, t as useRequest } from "./useRequest-D506eHi8.js";
+import { hasAllPermissions } from "./permissions.js";
+import { r as useExperimentSelector, t as ExperimentSelectorModal_default } from "./ExperimentSelectorModal-65peG4Up.js";
+import { t as experimentStatus_exports } from "./experimentStatus-Cqp6qNrR.js";
+import { t as ANALYSIS_FILE_ARTIFACT_SCHEMA } from "./analysisArtifactTypes-Cy3D0Ipg.js";
+import { t as ExperimentPopover_default } from "./ExperimentPopover-5T1fAq2L.js";
+import { i as JobsStatusTray_default, r as useRealtime } from "./useRealtime-C3iy9QkU.js";
+import { a as useFileImport, c as extractSampleNamesFromDesignData, i as readFileAsText, l as extractSampleOptionsFromDesignData, n as detectDelimiter, o as validateImportFile, r as parseDelimitedText, s as useExperimentData, t as useExperimentSamples, u as unwrapExperimentDesignData } from "./useExperimentSamples-DHnxKFAF.js";
+import { Fragment, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createSlots, createTextVNode, createVNode, defineComponent, getCurrentInstance, getCurrentScope, h, isRef, nextTick, normalizeClass, normalizeStyle, onBeforeUnmount, onScopeDispose, openBlock, readonly, ref, renderList, renderSlot, resolveDynamicComponent, shallowRef, toDisplayString, toRaw, toValue, unref, useTemplateRef, watch, withCtx, withModifiers } from "vue";
+import { CircleCheck, CircleDashed, CircleMinus, CircleX, CloudUpload, File, Loader, RefreshCw, TriangleAlert, X } from "lucide-vue-next";
+//#region src/composables/useArtifacts.ts
+/**
+* Lists and manages analysis artifacts through the user-facing platform API.
+*
+* @example Recommended
+* ```ts
+* const artifacts = useArtifacts({ pluginId: 'LEAF' })
+* await artifacts.list()
+* ```
+*/
+function useArtifacts(options = {}) {
+	const injectedContext = getInjectedPlatformContext();
+	const api = useApi({ baseUrl: options.apiBaseUrl ?? injectedContext?.platformApiUrl });
+	const experimentStore = useExperimentStore();
+	const currentExperimentId = computed(() => toValue(options.experimentId) ?? experimentStore.currentId ?? void 0);
+	const hasCurrentExperiment = computed(() => currentExperimentId.value !== void 0);
+	const scopePluginId = computed(() => toValue(options.pluginId) ?? null);
+	const request = useRequest("Analysis artifact request failed.");
+	const lastLoadedAt = ref(null);
+	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 ?? []];
+			lastLoadedAt.value = /* @__PURE__ */ new Date();
+			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;
+			lastLoadedAt.value = /* @__PURE__ */ new Date();
+			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);
+			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,
+		search,
+		statusFilter,
+		pluginFilter,
+		list,
+		refresh: list,
+		getDetail,
+		resolveTarget,
+		updateMetadata,
+		archive,
+		restore,
+		hasArtifactKey,
+		clear
+	};
+}
+//#endregion
+//#region src/components/ArtifactSelectorModal.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1$9 = { class: "mint-artifact-selector__filter-select" };
+var _hoisted_2$8 = {
+	key: 0,
+	class: "mint-artifact-selector__filter-select"
+};
+//#endregion
+//#region src/components/ArtifactSelectorModal.vue
+var ArtifactSelectorModal_default = /* @__PURE__ */ defineComponent({
+	__name: "ArtifactSelectorModal",
+	props: {
+		open: { type: Boolean },
+		experimentId: { default: null },
+		pluginId: { default: null },
+		currentArtifactId: { default: null },
+		includeArchived: {
+			type: Boolean,
+			default: false
+		},
+		fetchDetailOnSelect: {
+			type: Boolean,
+			default: false
+		},
+		title: { default: "Select Analysis Artifact" },
+		size: { default: "full" }
+	},
+	emits: [
+		"update:open",
+		"select",
+		"selectDetail",
+		"archive",
+		"restore"
+	],
+	setup(__props, { emit: __emit }) {
+		/**
+		* Modal for browsing and selecting an analysis artifact of an experiment, with filters and keyboard nav.
+		*
+		* @example Recommended
+		* ```vue
+		* <ArtifactSelectorModal v-model:open="open" :experiment-id="experimentId" @select="selectArtifact" />
+		* ```
+		*/
+		const props = __props;
+		const emit = __emit;
+		const { artifacts, visibleArtifacts, isLoading, isMutating, error, search, statusFilter, pluginFilter, list, getDetail, archive, restore } = useArtifacts({
+			experimentId: () => props.experimentId ?? void 0,
+			pluginId: () => props.pluginId,
+			includeArchived: () => props.includeArchived
+		});
+		const injectedContext = getInjectedPlatformContext();
+		const canManage = computed(() => {
+			const user = injectedContext?.user;
+			return user ? hasAllPermissions(user, ["experiments.edit"]) : true;
+		});
+		const STATUS_FILTER_OPTIONS = [
+			{
+				value: "active",
+				label: "Active"
+			},
+			{
+				value: "archived",
+				label: "Archived"
+			},
+			{
+				value: "all",
+				label: "All statuses"
+			}
+		];
+		const pluginFilterOptions = computed(() => [{
+			value: "",
+			label: "All plugins"
+		}, ...[...new Set(artifacts.value.map((artifact) => artifact.plugin_id))].sort().map((pluginId) => ({
+			value: pluginId,
+			label: pluginId
+		}))]);
+		const canChoosePlugin = computed(() => !props.pluginId && pluginFilterOptions.value.length > 2);
+		const openCount = ref(0);
+		function describe(artifact) {
+			const results = artifact.result_keys.length;
+			return {
+				code: artifact.artifact_key,
+				title: artifact.display_name,
+				meta: [
+					artifact.plugin_id,
+					`${results} result${results === 1 ? "" : "s"}`,
+					...artifact.status === "archived" ? ["Archived"] : []
+				],
+				date: formatArtifactDate(artifact)
+			};
+		}
+		function formatArtifactDate(artifact) {
+			const date = artifact.updated_at ?? artifact.created_at;
+			return date ? formatExperimentDate(date) : "";
+		}
+		async function handleSelect(artifact) {
+			if (props.fetchDetailOnSelect) {
+				const detail = await getDetail(artifact.id);
+				if (!detail) return;
+				emit("selectDetail", detail);
+			}
+			emit("select", artifact);
+			emit("update:open", false);
+		}
+		async function handleArchive(artifact) {
+			const archived = await archive(artifact.id);
+			if (archived) emit("archive", archived);
+		}
+		async function handleRestore(artifact) {
+			const restored = await restore(artifact.id);
+			if (restored) emit("restore", restored);
+		}
+		watch(() => props.open, (isOpen) => {
+			if (isOpen) {
+				openCount.value++;
+				statusFilter.value = props.includeArchived ? "all" : "active";
+				list();
+			}
+		}, { immediate: true });
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(BaseModal_default, {
+				open: __props.open,
+				title: __props.title,
+				size: __props.size,
+				"onUpdate:open": _cache[3] || (_cache[3] = ($event) => emit("update:open", $event))
+			}, {
+				default: withCtx(() => [(openBlock(), createBlock(ResourcePickerListInternal_default, {
+					key: openCount.value,
+					search: unref(search),
+					"onUpdate:search": _cache[2] || (_cache[2] = ($event) => isRef(search) ? search.value = $event : null),
+					class: "mint-artifact-selector",
+					label: "Analysis artifacts",
+					placeholder: "Search artifacts…",
+					items: unref(visibleArtifacts),
+					"item-key": (artifact) => artifact.id,
+					describe,
+					"selected-key": __props.currentArtifactId,
+					loading: unref(isLoading),
+					error: unref(error),
+					"empty-title": "No analysis artifacts found",
+					"empty-description": "Artifacts appear here once an analysis saves results for this experiment.",
+					onSelect: handleSelect
+				}, createSlots({
+					filters: withCtx(() => [createElementVNode("div", _hoisted_1$9, [createVNode(BaseSelect_default, {
+						"model-value": unref(statusFilter),
+						options: STATUS_FILTER_OPTIONS,
+						size: "sm",
+						"aria-label": "Filter by status",
+						"onUpdate:modelValue": _cache[0] || (_cache[0] = (v) => statusFilter.value = v)
+					}, null, 8, ["model-value"])]), canChoosePlugin.value ? (openBlock(), createElementBlock("div", _hoisted_2$8, [createVNode(BaseSelect_default, {
+						"model-value": unref(pluginFilter) ?? "",
+						options: pluginFilterOptions.value,
+						size: "sm",
+						"aria-label": "Filter by plugin",
+						"onUpdate:modelValue": _cache[1] || (_cache[1] = (v) => pluginFilter.value = String(v) || null)
+					}, null, 8, ["model-value", "options"])])) : createCommentVNode("", true)]),
+					_: 2
+				}, [canManage.value ? {
+					name: "actions",
+					fn: withCtx(({ item }) => [createVNode(BaseButton_default, {
+						variant: "ghost",
+						size: "sm",
+						class: "mint-artifact-selector__action",
+						disabled: unref(isMutating),
+						onClick: ($event) => item.status === "archived" ? handleRestore(item) : handleArchive(item)
+					}, {
+						default: withCtx(() => [createTextVNode(toDisplayString(item.status === "archived" ? "Restore" : "Archive"), 1)]),
+						_: 2
+					}, 1032, ["disabled", "onClick"])]),
+					key: "0"
+				} : void 0]), 1032, [
+					"search",
+					"items",
+					"item-key",
+					"selected-key",
+					"loading",
+					"error"
+				]))]),
+				_: 1
+			}, 8, [
+				"open",
+				"title",
+				"size"
+			]);
+		};
+	}
+});
+//#endregion
+//#region src/components/ArtifactSaveDialog.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1$8 = { class: "mint-artifact-save-dialog" };
+var _hoisted_2$7 = {
+	key: 0,
+	class: "mint-artifact-save-dialog__experiment"
+};
+var _hoisted_3$6 = {
+	key: 0,
+	class: "mint-exp-code mint-exp-code--sm"
+};
+var _hoisted_4$6 = { class: "mint-artifact-save-dialog__experiment-name" };
+var _hoisted_5$5 = {
+	key: 1,
+	class: "mint-artifact-save-dialog__modes",
+	role: "radiogroup",
+	"aria-label": "Save mode"
+};
+var _hoisted_6$5 = ["aria-checked", "onClick"];
+var _hoisted_7$5 = { class: "mint-artifact-save-dialog__mode-text" };
+var _hoisted_8$5 = {
+	key: 2,
+	class: "mint-artifact-save-dialog__list"
+};
+var _hoisted_9$5 = { class: "mint-artifact-save-dialog__row mint-artifact-save-dialog__row--selected" };
+var _hoisted_10$5 = { class: "mint-artifact-save-dialog__row-name" };
+var _hoisted_11$5 = {
+	key: 0,
+	class: "mint-artifact-save-dialog__row-meta"
+};
+var _hoisted_12$5 = {
+	key: 1,
+	class: "mint-artifact-save-dialog__immutable"
+};
+//#endregion
+//#region src/components/ArtifactSaveDialog.vue
+var ArtifactSaveDialog_default = /* @__PURE__ */ defineComponent({
+	__name: "ArtifactSaveDialog",
+	props: {
+		open: { type: Boolean },
+		saveHandler: {},
+		mode: { default: "file" },
+		fileSource: { default: "upload" },
+		result: {},
+		experimentId: { default: null },
+		experiment: { default: null },
+		existingArtifact: { default: null },
+		existingArtifactKeys: {},
+		title: {},
+		size: { default: "md" },
+		defaultArtifactKey: { default: "default" },
+		defaultDisplayName: {},
+		defaultFileKind: { default: "file" },
+		accept: {},
+		maxFileSize: {},
+		metadata: {}
+	},
+	emits: [
+		"update:open",
+		"saved",
+		"error",
+		"cancel",
+		"change-experiment"
+	],
+	setup(__props, { emit: __emit }) {
+		/** Save/update dialog for analysis artifacts; delegates the write to a plugin-supplied handler. */
+		const props = __props;
+		const emit = __emit;
+		const canChangeExperiment = Boolean(getCurrentInstance()?.vnode.props?.onChangeExperiment);
+		const ARTIFACT_KEY_PATTERN = /^[a-z0-9][a-z0-9._-]*$/;
+		const experimentStore = useExperimentStore();
+		const request = useRequest("Failed to save analysis artifact.");
+		/** With an existing artifact the user picks: replace it, or save a separate one. */
+		const saveMode = ref("replace");
+		const isUpdate = computed(() => props.existingArtifact !== null && saveMode.value === "replace");
+		const SAVE_MODES = [{
+			value: "replace",
+			label: "Replace an existing result",
+			description: "Keeps the key; collaborators see the new version."
+		}, {
+			value: "new",
+			label: "Save as a new result",
+			description: "Adds a separate artifact next to the others."
+		}];
+		const existingResult = computed(() => props.existingArtifact?.result ?? {});
+		const existingIsFile = computed(() => existingResult.value.schema_version === ANALYSIS_FILE_ARTIFACT_SCHEMA);
+		const existingFileKind = computed(() => typeof existingResult.value.kind === "string" ? existingResult.value.kind : void 0);
+		const existingFilename = computed(() => typeof existingResult.value.filename === "string" ? existingResult.value.filename : void 0);
+		const existingMetadata = computed(() => {
+			const value = existingResult.value.metadata;
+			return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+		});
+		const activeKind = ref("file");
+		const keyInput = ref("");
+		const displayNameInput = ref("");
+		const noteInput = ref("");
+		const selectedFile = shallowRef(null);
+		let initialNote = "";
+		function resetForm() {
+			saveMode.value = "replace";
+			syncFields();
+		}
+		/** Fills the fields for the current save mode; a mode switch calls only this. */
+		function syncFields() {
+			const existing = isUpdate.value ? props.existingArtifact : null;
+			activeKind.value = existing ? existingIsFile.value ? "file" : "json" : props.mode === "json" ? "json" : "file";
+			keyInput.value = existing?.artifact_key ?? props.defaultArtifactKey;
+			displayNameInput.value = existing?.display_name ?? props.defaultDisplayName ?? "";
+			initialNote = existing?.note ?? "";
+			noteInput.value = initialNote;
+			selectedFile.value = null;
+			request.clearError();
+		}
+		resetForm();
+		watch(() => props.open, (open) => {
+			if (open) resetForm();
+		});
+		watch(saveMode, syncFields);
+		watch(() => props.existingArtifact ? `${props.existingArtifact.id}:${props.existingArtifact.artifact_key}` : null, resetForm);
+		const resolvedTitle = computed(() => props.title ?? "Save to experiment");
+		const stripExperiment = computed(() => {
+			if (props.experiment) return props.experiment;
+			const current = experimentStore.current;
+			return current && current.id === resolveExperimentId() ? current : null;
+		});
+		const existingUpdated = computed(() => {
+			const date = props.existingArtifact?.updated_at ?? props.existingArtifact?.created_at;
+			return date ? formatExperimentDate(date) : "";
+		});
+		const showKindToggle = computed(() => !isUpdate.value && props.mode === "both");
+		const showFileUploader = computed(() => activeKind.value === "file" && props.fileSource === "upload");
+		const showNoteField = computed(() => !isUpdate.value || existingIsFile.value);
+		const effectiveKey = computed(() => {
+			if (isUpdate.value) return props.existingArtifact?.artifact_key ?? "";
+			return keyInput.value.trim() || props.defaultArtifactKey;
+		});
+		const keyValid = computed(() => ARTIFACT_KEY_PATTERN.test(effectiveKey.value));
+		const keyExists = computed(() => {
+			if (isUpdate.value) return false;
+			return [...props.existingArtifactKeys ?? [], props.existingArtifact?.artifact_key].includes(effectiveKey.value);
+		});
+		const keyBlocked = computed(() => keyExists.value && (activeKind.value === "file" || props.existingArtifact !== null && saveMode.value === "new"));
+		const keyError = computed(() => {
+			if (!keyValid.value) return "Use lowercase letters, digits, dots, dashes, or underscores.";
+			if (keyBlocked.value) return "This key is already used. Choose another, or replace the existing artifact.";
+		});
+		const canSubmit = computed(() => {
+			if (request.isLoading.value || !keyValid.value || keyBlocked.value) return false;
+			if (activeKind.value === "file") return props.fileSource === "handler" || selectedFile.value !== null;
+			return props.result !== void 0;
+		});
+		function resolveExperimentId() {
+			return props.experimentId ?? experimentStore.currentId ?? void 0;
+		}
+		/** Set-only note for creates and JSON upserts: an empty field just sends nothing. */
+		function createNotePayload() {
+			const value = noteInput.value.trim();
+			return showNoteField.value && value ? { note: value } : {};
+		}
+		/**
+		* Three-state note, honoured only by update_analysis_file_artifact:
+		* omitted = preserve, null = clear, string = set.
+		*/
+		function updateNotePayload() {
+			if (noteInput.value === initialNote) return {};
+			const value = noteInput.value.trim();
+			return value ? { note: value } : { note: null };
+		}
+		function buildPayload(experimentId) {
+			const base = {
+				experimentId,
+				artifactKey: effectiveKey.value
+			};
+			if (activeKind.value === "json") {
+				if (props.result === void 0) return null;
+				const displayName = isUpdate.value ? props.existingArtifact?.display_name : displayNameInput.value.trim() || void 0;
+				return {
+					kind: "json",
+					mode: isUpdate.value || keyExists.value ? "upsert" : "create",
+					...base,
+					...createNotePayload(),
+					...displayName ? { displayName } : {},
+					result: props.result
+				};
+			}
+			if (isUpdate.value) {
+				const metadata = props.metadata ?? existingMetadata.value;
+				if (props.fileSource === "handler") return {
+					kind: "file",
+					source: "handler",
+					mode: "update",
+					...base,
+					...updateNotePayload(),
+					fileKind: existingFileKind.value ?? props.defaultFileKind,
+					...metadata ? { metadata } : {}
+				};
+				const file = selectedFile.value;
+				if (!file) return null;
+				return {
+					kind: "file",
+					mode: "update",
+					...base,
+					...updateNotePayload(),
+					file,
+					fileKind: existingFileKind.value ?? props.defaultFileKind,
+					...metadata ? { metadata } : {},
+					...file.type ? { contentType: file.type } : {}
+				};
+			}
+			const displayName = displayNameInput.value.trim();
+			if (props.fileSource === "handler") return {
+				kind: "file",
+				source: "handler",
+				mode: "create",
+				...base,
+				...createNotePayload(),
+				fileKind: props.defaultFileKind,
+				...displayName ? { displayName } : {},
+				...props.metadata ? { metadata: props.metadata } : {}
+			};
+			const file = selectedFile.value;
+			if (!file) return null;
+			return {
+				kind: "file",
+				mode: "create",
+				...base,
+				...createNotePayload(),
+				file,
+				fileKind: props.defaultFileKind,
+				filename: file.name,
+				...displayName ? { displayName } : {},
+				...props.metadata ? { metadata: props.metadata } : {},
+				...file.type ? { contentType: file.type } : {}
+			};
+		}
+		function runSaveHandler(payload) {
+			if (props.fileSource === "handler") {
+				if (payload.kind === "file" && !("source" in payload)) throw new Error("ArtifactSaveDialog built an upload payload for a handler-owned file.");
+				return props.saveHandler(payload);
+			}
+			if (payload.kind === "file" && "source" in payload) throw new Error("ArtifactSaveDialog built a handler-owned payload for an uploaded file.");
+			return props.saveHandler(payload);
+		}
+		function handleFileUpload(files) {
+			selectedFile.value = files[0] ?? null;
+		}
+		function handleFileError(message) {
+			request.setError(message);
+		}
+		async function handleSubmit() {
+			if (!canSubmit.value) return;
+			const experimentId = resolveExperimentId();
+			if (experimentId === void 0) {
+				const message = request.setError("No experiment is available for saving an artifact.");
+				emit("error", message);
+				return;
+			}
+			const payload = buildPayload(experimentId);
+			if (!payload) return;
+			try {
+				const result = await request.run(() => runSaveHandler(payload), {
+					kind: "save",
+					errorMessage: "Failed to save analysis artifact."
+				});
+				emit("saved", {
+					...result ?? {},
+					payload
+				});
+				emit("update:open", false);
+				resetForm();
+			} catch {
+				emit("error", request.error.value ?? "Failed to save analysis artifact.");
+			}
+		}
+		function handleCancel() {
+			emit("cancel");
+			emit("update:open", false);
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(BaseModal_default, {
+				open: __props.open,
+				title: resolvedTitle.value,
+				size: __props.size,
+				closable: !unref(request).isLoading.value,
+				"onUpdate:open": _cache[5] || (_cache[5] = ($event) => emit("update:open", $event)),
+				onClose: _cache[6] || (_cache[6] = ($event) => emit("cancel"))
+			}, {
+				footer: withCtx(() => [createVNode(BaseButton_default, {
+					variant: "secondary",
+					disabled: unref(request).isLoading.value,
+					onClick: handleCancel
+				}, {
+					default: withCtx(() => [..._cache[11] || (_cache[11] = [createTextVNode(" Cancel ", -1)])]),
+					_: 1
+				}, 8, ["disabled"]), createVNode(BaseButton_default, {
+					class: "mint-artifact-save-dialog__submit",
+					icon: unref(CloudUpload),
+					loading: unref(request).isLoading.value,
+					disabled: !canSubmit.value,
+					onClick: handleSubmit
+				}, {
+					default: withCtx(() => [createTextVNode(toDisplayString(isUpdate.value ? "Replace result" : "Save result"), 1)]),
+					_: 1
+				}, 8, [
+					"icon",
+					"loading",
+					"disabled"
+				])]),
+				default: withCtx(() => [createElementVNode("div", _hoisted_1$8, [
+					stripExperiment.value ? (openBlock(), createElementBlock("div", _hoisted_2$7, [
+						stripExperiment.value.experiment_code ? (openBlock(), createElementBlock("span", _hoisted_3$6, toDisplayString(stripExperiment.value.experiment_code), 1)) : createCommentVNode("", true),
+						createElementVNode("span", _hoisted_4$6, toDisplayString(stripExperiment.value.name), 1),
+						unref(canChangeExperiment) ? (openBlock(), createElementBlock("button", {
+							key: 1,
+							type: "button",
+							class: "mint-artifact-save-dialog__change",
+							onClick: _cache[0] || (_cache[0] = ($event) => emit("change-experiment"))
+						}, " Change ")) : createCommentVNode("", true)
+					])) : createCommentVNode("", true),
+					__props.existingArtifact ? (openBlock(), createElementBlock("div", _hoisted_5$5, [(openBlock(), createElementBlock(Fragment, null, renderList(SAVE_MODES, (option) => {
+						return createElementVNode("button", {
+							key: option.value,
+							type: "button",
+							role: "radio",
+							"aria-checked": saveMode.value === option.value,
+							class: "mint-artifact-save-dialog__mode",
+							onClick: ($event) => saveMode.value = option.value
+						}, [_cache[7] || (_cache[7] = createElementVNode("span", {
+							class: "mint-artifact-save-dialog__mode-dot",
+							"aria-hidden": "true"
+						}, null, -1)), createElementVNode("span", _hoisted_7$5, [createElementVNode("b", null, toDisplayString(option.label), 1), createElementVNode("span", null, toDisplayString(option.description), 1)])], 8, _hoisted_6$5);
+					}), 64))])) : createCommentVNode("", true),
+					isUpdate.value && __props.existingArtifact ? (openBlock(), createElementBlock("div", _hoisted_8$5, [createElementVNode("div", _hoisted_9$5, [
+						createVNode(unref(File), {
+							class: "mint-artifact-save-dialog__row-icon",
+							size: 15,
+							"aria-hidden": "true"
+						}),
+						createElementVNode("span", _hoisted_10$5, [createTextVNode(toDisplayString(__props.existingArtifact.display_name) + " ", 1), createElementVNode("span", null, toDisplayString(__props.existingArtifact.artifact_key), 1)]),
+						existingUpdated.value ? (openBlock(), createElementBlock("span", _hoisted_11$5, toDisplayString(existingUpdated.value), 1)) : createCommentVNode("", true)
+					])])) : createCommentVNode("", true),
+					showKindToggle.value ? (openBlock(), createBlock(SegmentedControl_default, {
+						key: 3,
+						modelValue: activeKind.value,
+						"onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => activeKind.value = $event),
+						class: "mint-artifact-save-dialog__kind-toggle",
+						options: [{
+							value: "file",
+							label: "File"
+						}, {
+							value: "json",
+							label: "JSON"
+						}],
+						"full-width": ""
+					}, null, 8, ["modelValue"])) : createCommentVNode("", true),
+					keyExists.value && !keyBlocked.value ? (openBlock(), createBlock(AlertBox_default, {
+						key: 4,
+						tone: "warning",
+						class: "mint-artifact-save-dialog__warning"
+					}, {
+						default: withCtx(() => [createTextVNode(" An artifact with key \"" + toDisplayString(effectiveKey.value) + "\" already exists. Its results will be replaced; its name and note are kept unless you set new ones. ", 1)]),
+						_: 1
+					})) : createCommentVNode("", true),
+					createVNode(FormField_default, {
+						label: "Artifact key",
+						class: "mint-artifact-save-dialog__key",
+						error: keyError.value,
+						hint: isUpdate.value ? "Keys are fixed once an artifact exists." : void 0
+					}, {
+						default: withCtx(() => [createVNode(BaseInput_default, {
+							modelValue: keyInput.value,
+							"onUpdate:modelValue": _cache[2] || (_cache[2] = ($event) => keyInput.value = $event),
+							readonly: isUpdate.value,
+							invalid: Boolean(keyError.value),
+							placeholder: __props.defaultArtifactKey
+						}, null, 8, [
+							"modelValue",
+							"readonly",
+							"invalid",
+							"placeholder"
+						])]),
+						_: 1
+					}, 8, ["error", "hint"]),
+					!isUpdate.value ? (openBlock(), createBlock(FormField_default, {
+						key: 5,
+						label: "Display name",
+						class: "mint-artifact-save-dialog__name"
+					}, {
+						default: withCtx(() => [createVNode(BaseInput_default, {
+							modelValue: displayNameInput.value,
+							"onUpdate:modelValue": _cache[3] || (_cache[3] = ($event) => displayNameInput.value = $event),
+							placeholder: "Shown in artifact lists"
+						}, null, 8, ["modelValue"])]),
+						_: 1
+					})) : createCommentVNode("", true),
+					showNoteField.value ? (openBlock(), createBlock(FormField_default, {
+						key: 6,
+						label: "Note",
+						class: "mint-artifact-save-dialog__note"
+					}, {
+						default: withCtx(() => [createVNode(BaseInput_default, {
+							type: "textarea",
+							modelValue: noteInput.value,
+							"onUpdate:modelValue": _cache[4] || (_cache[4] = ($event) => noteInput.value = $event),
+							placeholder: "Optional context for this artifact"
+						}, null, 8, ["modelValue"])]),
+						_: 1
+					})) : createCommentVNode("", true),
+					activeKind.value === "file" ? (openBlock(), createElementBlock(Fragment, { key: 7 }, [showFileUploader.value ? (openBlock(), createBlock(FileUploader_default, {
+						key: 0,
+						class: "mint-artifact-save-dialog__file",
+						accept: __props.accept,
+						"max-size": __props.maxFileSize,
+						multiple: false,
+						onUpload: handleFileUpload,
+						onError: handleFileError
+					}, null, 8, ["accept", "max-size"])) : createCommentVNode("", true), isUpdate.value && existingFilename.value ? (openBlock(), createElementBlock("p", _hoisted_12$5, [
+						_cache[8] || (_cache[8] = createTextVNode(" Replaces the content of ", -1)),
+						createElementVNode("code", null, toDisplayString(existingFilename.value), 1),
+						_cache[9] || (_cache[9] = createTextVNode(" (kind ", -1)),
+						createElementVNode("code", null, toDisplayString(existingFileKind.value ?? __props.defaultFileKind), 1),
+						_cache[10] || (_cache[10] = createTextVNode("); filename and kind stay unchanged. ", -1))
+					])) : createCommentVNode("", true)], 64)) : createCommentVNode("", true),
+					unref(request).error.value ? (openBlock(), createBlock(AlertBox_default, {
+						key: 8,
+						tone: "error",
+						class: "mint-artifact-save-dialog__error",
+						role: "alert"
+					}, {
+						default: withCtx(() => [createTextVNode(toDisplayString(unref(request).error.value), 1)]),
+						_: 1
+					})) : createCommentVNode("", true)
+				])]),
+				_: 1
+			}, 8, [
+				"open",
+				"title",
+				"size",
+				"closable"
+			]);
+		};
+	}
+});
+//#endregion
+//#region src/components/ExperimentCodeBadge.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1$7 = [
+	"role",
+	"tabindex",
+	"title"
+];
+//#endregion
+//#region src/components/ExperimentCodeBadge.vue
+var ExperimentCodeBadge_default = /* @__PURE__ */ defineComponent({
+	__name: "ExperimentCodeBadge",
+	props: {
+		code: {},
+		size: { default: "md" },
+		copyable: {
+			type: Boolean,
+			default: true
+		}
+	},
+	emits: ["copy"],
+	setup(__props, { emit: __emit }) {
+		/** Inline badge that displays an experiment code and copies it to the clipboard on click. */
+		const props = __props;
+		const emit = __emit;
+		const copied = ref(false);
+		let copyTimeout = null;
+		async function handleCopy() {
+			if (!props.copyable) return;
+			try {
+				await navigator.clipboard.writeText(props.code);
+				copied.value = true;
+				emit("copy", props.code);
+				if (copyTimeout) clearTimeout(copyTimeout);
+				copyTimeout = setTimeout(() => {
+					copied.value = false;
+				}, 1500);
+			} catch {}
+		}
+		function handleKeydown(event) {
+			if (!props.copyable) return;
+			if (event.key === "Enter" || event.key === " ") {
+				event.preventDefault();
+				handleCopy();
+			}
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("span", {
+				class: normalizeClass([
+					"mint-exp-code",
+					`mint-exp-code--${__props.size}`,
+					{
+						"mint-exp-code--copyable": __props.copyable,
+						"mint-exp-code--copied": copied.value
+					}
+				]),
+				role: __props.copyable ? "button" : void 0,
+				tabindex: __props.copyable ? 0 : void 0,
+				title: __props.copyable ? copied.value ? "Copied!" : "Click to copy" : void 0,
+				onClick: handleCopy,
+				onKeydown: handleKeydown
+			}, toDisplayString(copied.value ? "Copied!" : __props.code), 43, _hoisted_1$7);
+		};
+	}
+});
+//#endregion
+//#region src/components/internal/filePickerPresentation.ts
+var FILE_PICKER_ICONS = {
+	folder: "M4 7h6l2 2h8v10H4z",
+	file: "M14 3v5h5M14 3H7a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h10a2 2 0 0 0 2-2V8z",
+	lock: "M7 11V8a5 5 0 0 1 10 0v3M5 11h14v10H5z"
+};
+function formatBytes(bytes) {
+	if (bytes === null) return "—";
+	const units = [
+		"B",
+		"KB",
+		"MB",
+		"GB",
+		"TB"
+	];
+	let value = bytes;
+	let unit = 0;
+	while (value >= 1024 && unit < units.length - 1) {
+		value /= 1024;
+		unit += 1;
+	}
+	return `${value >= 100 || unit === 0 ? Math.round(value) : Number(value.toFixed(1))} ${units[unit]}`;
+}
+var pad = (value) => String(value).padStart(2, "0");
+/** Compact local timestamp for a fixed-width mono column: `MM-DD HH:mm`, or `YYYY-MM-DD` outside this year. */
+function formatModified(value, now = /* @__PURE__ */ new Date()) {
+	const date = value ? new Date(value) : null;
+	if (!date || Number.isNaN(date.getTime())) return "";
+	const day = `${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+	return date.getFullYear() === now.getFullYear() ? `${day} ${pad(date.getHours())}:${pad(date.getMinutes())}` : `${date.getFullYear()}-${day}`;
+}
+//#endregion
+//#region src/composables/filePicker/validation.ts
+function normalizePickerFormat(format) {
+	return format.trim().replace(/^\./, "").toLowerCase();
+}
+function pickerExclusion(node, capability, skipBlanks = false) {
+	const base = {
+		path: node.path,
+		name: node.name
+	};
+	if (node.unavailableReason) return {
+		...base,
+		reason: "unreadable"
+	};
+	if (skipBlanks && capability?.isBlank?.(node)) return {
+		...base,
+		reason: "blank"
+	};
+	if (node.kind === "folder") return null;
+	const formats = capability?.formats.map(normalizePickerFormat) ?? [];
+	if (formats.length && !formats.some((format) => node.name.toLowerCase().endsWith(`.${format}`))) return {
+		...base,
+		reason: "unsupported"
+	};
+	if (capability?.maxBytes != null && node.bytes != null && node.bytes > capability.maxBytes) return {
+		...base,
+		reason: "tooLarge"
+	};
+	return null;
+}
+function pickerReason(excluded, node) {
+	if (!excluded) return "";
+	return {
+		unsupported: "This format is not supported by this source.",
+		tooLarge: "This file exceeds the size limit for this source.",
+		blank: "Skipped by the blank-file rule.",
+		unreadable: node?.unavailableReason || "This item cannot be read.",
+		deselected: "Removed from the selection.",
+		forbidden: "This item is not permitted by the system filter."
+	}[excluded.reason];
+}
+function pickerFormat(name) {
+	const compound = /\.(mzml|mzxml)\.gz$/i.exec(name);
+	return compound ? `${compound[1]}.gz` : name.includes(".") ? name.split(".").pop() : "";
+}
+//#endregion
+//#region src/components/internal/FilePickerListInternal.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1$6 = [
+	"role",
+	"aria-multiselectable",
+	"aria-busy"
+];
+var _hoisted_2$6 = {
+	key: 0,
+	class: "mint-picker__truncated",
+	role: "status"
+};
+var _hoisted_3$5 = {
+	key: 1,
+	class: "mint-picker__skeleton"
+};
+var _hoisted_4$5 = {
+	key: 2,
+	role: "alert",
+	class: "mint-picker__empty"
+};
+var _hoisted_5$4 = {
+	key: 3,
+	class: "mint-picker__empty",
+	role: "status"
+};
+var _hoisted_6$4 = [
+	"role",
+	"data-path",
+	"aria-level",
+	"aria-selected",
+	"aria-disabled",
+	"aria-expanded",
+	"tabindex",
+	"title",
+	"onClick",
+	"onDblclick",
+	"onKeydown"
+];
+var _hoisted_7$4 = { class: "mint-picker__cell mint-picker__cell--check" };
+var _hoisted_8$4 = {
+	key: 0,
+	class: "mint-picker__lock",
+	viewBox: "0 0 24 24",
+	fill: "none",
+	stroke: "currentColor",
+	"stroke-width": "1.8",
+	"aria-hidden": "true"
+};
+var _hoisted_9$4 = ["d"];
+var _hoisted_10$4 = { class: "mint-picker__cell mint-picker__cell--name" };
+var _hoisted_11$4 = {
+	key: 1,
+	class: "mint-picker__disclosure"
+};
+var _hoisted_12$4 = {
+	class: "mint-picker__node-icon",
+	viewBox: "0 0 24 24",
+	fill: "none",
+	stroke: "currentColor",
+	"stroke-width": "1.7",
+	"aria-hidden": "true"
+};
+var _hoisted_13$4 = ["d"];
+var _hoisted_14$4 = { class: "mint-picker__name" };
+var _hoisted_15$4 = { key: 0 };
+var _hoisted_16$2 = {
+	key: 1,
+	class: "mint-picker__reason"
+};
+var _hoisted_17$2 = {
+	key: 2,
+	class: "mint-picker__parent-name"
+};
+var _hoisted_18$2 = { class: "mint-picker__cell mint-picker__cell--time" };
+var _hoisted_19$2 = {
+	key: 0,
+	class: "mint-picker__branch-error",
+	role: "alert"
+};
+//#endregion
+//#region src/components/internal/FilePickerListInternal.vue
+var FilePickerListInternal_default = /* @__PURE__ */ defineComponent({
+	__name: "FilePickerListInternal",
+	props: {
+		emptyTitle: {},
+		view: {},
+		rows: {},
+		loading: { type: Boolean },
+		error: {},
+		query: {},
+		truncated: { type: Boolean },
+		mode: {},
+		selected: { type: Function },
+		selectable: { type: Function },
+		exclusion: { type: Function },
+		progress: { type: Function },
+		focusPath: {}
+	},
+	emits: [
+		"select",
+		"enter",
+		"expand",
+		"up",
+		"retry",
+		"parent"
+	],
+	setup(__props, { emit: __emit }) {
+		const DisclosureTriangle = () => h("svg", {
+			viewBox: "0 0 16 16",
+			fill: "currentColor"
+		}, [h("path", { d: "m6 3 5 5-5 5z" })]);
+		const props = __props;
+		const emit = __emit;
+		const SHORT_REASON = {
+			unsupported: "Unsupported format",
+			tooLarge: "Over the size limit",
+			blank: "Blank",
+			unreadable: "No read permission",
+			forbidden: "No read permission",
+			deselected: ""
+		};
+		const tree = computed(() => props.view === "tree");
+		const multi = computed(() => props.mode === "multi-file" || props.mode === "folder+files");
+		const list = ref(null);
+		function reason(node) {
+			return pickerReason(props.exclusion(node), node);
+		}
+		function shortReason(node) {
+			const excluded = props.exclusion(node);
+			if (!excluded) return "";
+			return excluded.reason === "unreadable" && node.unavailableReason || SHORT_REASON[excluded.reason];
+		}
+		function locked(node) {
+			const excluded = props.exclusion(node)?.reason;
+			return excluded === "unreadable" || excluded === "forbidden";
+		}
+		function partial(node) {
+			const progress = props.progress(node);
+			return node.kind === "folder" && props.selected(node) && !!progress && progress.split(" / ")[0] !== String(node.fileCount);
+		}
+		function size(node) {
+			if (node.kind === "folder" && props.selected(node) && props.progress(node)) return props.progress(node);
+			return node.bytes == null ? "" : formatBytes(node.bytes);
+		}
+		const focusablePath = computed(() => {
+			const available = props.rows.filter((row) => !reason(row.node));
+			return available.find((row) => row.node.path === props.focusPath)?.node.path ?? available[0]?.node.path;
+		});
+		function focusRow(path) {
+			nextTick(() => {
+				const target = [...list.value?.querySelectorAll("[data-path]") ?? []].find((el) => el.dataset.path === path);
+				target?.focus();
+				target?.scrollIntoView({ block: "nearest" });
+			});
+		}
+		function keydown(event, row) {
+			if (reason(row.node)) return;
+			const available = props.rows.filter((item) => !reason(item.node));
+			const index = available.findIndex((item) => item.node.path === row.node.path);
+			if ([
+				"ArrowUp",
+				"ArrowDown",
+				"Home",
+				"End"
+			].includes(event.key)) {
+				event.preventDefault();
+				const target = event.key === "Home" ? available[0] : event.key === "End" ? available[available.length - 1] : available[Math.max(0, Math.min(available.length - 1, index + (event.key === "ArrowDown" ? 1 : -1)))];
+				if (target) {
+					emit("select", target.node, event);
+					focusRow(target.node.path);
+				}
+			} else if (event.key === "ArrowRight") {
+				event.preventDefault();
+				if (!tree.value) {
+					if (row.node.kind === "folder") emit("enter", row.node);
+				} else if (row.node.kind === "folder" && !row.expanded) emit("expand", row.node);
+				else if (row.expanded) {
+					const next = available[index + 1];
+					if (next && next.depth > row.depth) {
+						emit("select", next.node, event);
+						focusRow(next.node.path);
+					}
+				}
+			} else if (event.key === "ArrowLeft") {
+				event.preventDefault();
+				if (row.expanded) emit("expand", row.node);
+				else {
+					const parent = props.rows.slice(0, props.rows.indexOf(row)).reverse().find((item) => item.depth < row.depth);
+					if (parent) {
+						emit("select", parent.node, event);
+						focusRow(parent.node.path);
+					} else emit("up");
+				}
+			} else if (event.key === "Enter") {
+				event.preventDefault();
+				emit("enter", row.node);
+			} else if (event.key === " ") {
+				event.preventDefault();
+				emit("select", row.node, event);
+			}
+		}
+		function parts(name) {
+			const index = props.query ? name.toLowerCase().indexOf(props.query.toLowerCase()) : -1;
+			return index < 0 ? [
+				name,
+				"",
+				""
+			] : [
+				name.slice(0, index),
+				name.slice(index, index + props.query.length),
+				name.slice(index + props.query.length)
+			];
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", {
+				ref_key: "list",
+				ref: list,
+				class: "mint-picker__list",
+				role: tree.value ? "tree" : "listbox",
+				"aria-label": "Folders and files",
+				"aria-multiselectable": multi.value,
+				"aria-busy": __props.loading
+			}, [
+				_cache[5] || (_cache[5] = createElementVNode("div", {
+					class: "mint-picker__list-head",
+					"aria-hidden": "true"
+				}, [
+					createElementVNode("span"),
+					createElementVNode("span", null, "Name"),
+					createElementVNode("span", null, "Size"),
+					createElementVNode("span", null, "Modified")
+				], -1)),
+				__props.truncated && !__props.loading && !__props.error && __props.rows.length ? (openBlock(), createElementBlock("p", _hoisted_2$6, " Showing the first " + toDisplayString(__props.rows.length) + " matches. Search a smaller folder or use a more specific search to see the rest. ", 1)) : createCommentVNode("", true),
+				__props.loading ? (openBlock(), createElementBlock("div", _hoisted_3$5, [(openBlock(), createElementBlock(Fragment, null, renderList(6, (n) => {
+					return createVNode(Skeleton_default, {
+						key: n,
+						width: "100%",
+						height: "1.25rem"
+					});
+				}), 64))])) : __props.error ? (openBlock(), createElementBlock("div", _hoisted_4$5, [createElementVNode("span", null, toDisplayString(__props.error), 1), createVNode(BaseButton_default, {
+					variant: "secondary",
+					size: "sm",
+					onClick: _cache[0] || (_cache[0] = ($event) => emit("retry"))
+				}, {
+					default: withCtx(() => [..._cache[2] || (_cache[2] = [createTextVNode("Try again", -1)])]),
+					_: 1
+				})])) : !__props.rows.length ? (openBlock(), createElementBlock("div", _hoisted_5$4, [createElementVNode("strong", null, toDisplayString(__props.truncated ? "Search stopped before finding a match" : __props.query ? "No matching folders or files" : __props.emptyTitle || "No readable files"), 1), createElementVNode("span", null, toDisplayString(__props.truncated ? "Search a smaller folder or use a more specific search." : __props.query ? "Try a different search or include subfolders." : "Choose another location."), 1)])) : (openBlock(true), createElementBlock(Fragment, { key: 4 }, renderList(__props.rows, (row) => {
+					return openBlock(), createElementBlock(Fragment, { key: row.node.path }, [createElementVNode("div", {
+						role: tree.value ? "treeitem" : "option",
+						"data-path": row.node.path,
+						"aria-level": tree.value ? row.depth + 1 : void 0,
+						"aria-selected": __props.selected(row.node),
+						"aria-disabled": !!reason(row.node),
+						"aria-expanded": tree.value && row.node.kind === "folder" && !reason(row.node) ? row.expanded : void 0,
+						tabindex: !reason(row.node) && row.node.path === focusablePath.value ? 0 : -1,
+						class: normalizeClass(["mint-picker__row", {
+							"mint-picker__row--selected": __props.selected(row.node),
+							"mint-picker__row--unreadable": !!reason(row.node)
+						}]),
+						style: normalizeStyle({ "--picker-depth": row.depth }),
+						title: reason(row.node) || row.node.name,
+						onClick: ($event) => !reason(row.node) && emit("select", row.node, $event),
+						onDblclick: ($event) => !reason(row.node) && emit("enter", row.node),
+						onKeydown: ($event) => keydown($event, row)
+					}, [
+						createElementVNode("span", _hoisted_7$4, [locked(row.node) ? (openBlock(), createElementBlock("svg", _hoisted_8$4, [createElementVNode("path", { d: unref(FILE_PICKER_ICONS).lock }, null, 8, _hoisted_9$4)])) : multi.value && __props.selectable(row.node) ? (openBlock(), createBlock(BaseCheckbox_default, {
+							key: 1,
+							size: "sm",
+							inert: "",
+							"aria-hidden": "true",
+							"model-value": __props.selected(row.node),
+							indeterminate: partial(row.node)
+						}, null, 8, ["model-value", "indeterminate"])) : createCommentVNode("", true)]),
+						createElementVNode("span", _hoisted_10$4, [
+							tree.value ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [row.node.kind === "folder" && row.node.hasChildren !== false && !reason(row.node) ? (openBlock(), createBlock(BaseButton_default, {
+								key: 0,
+								size: "sm",
+								variant: "ghost",
+								class: normalizeClass(["mint-picker__disclosure", { "mint-picker__chevron--open": row.expanded }]),
+								icon: DisclosureTriangle,
+								label: `${row.expanded ? "Collapse" : "Expand"} ${row.node.name}`,
+								tabindex: "-1",
+								loading: row.loading,
+								onClick: withModifiers(($event) => emit("expand", row.node), ["stop"]),
+								onDblclick: _cache[1] || (_cache[1] = withModifiers(() => {}, ["stop"]))
+							}, null, 8, [
+								"class",
+								"label",
+								"loading",
+								"onClick"
+							])) : (openBlock(), createElementBlock("span", _hoisted_11$4))], 64)) : createCommentVNode("", true),
+							(openBlock(), createElementBlock("svg", _hoisted_12$4, [createElementVNode("path", { d: row.node.kind === "folder" ? unref(FILE_PICKER_ICONS).folder : unref(FILE_PICKER_ICONS).file }, null, 8, _hoisted_13$4)])),
+							createElementVNode("span", _hoisted_14$4, [
+								createTextVNode(toDisplayString(parts(row.node.name)[0]), 1),
+								parts(row.node.name)[1] ? (openBlock(), createElementBlock("mark", _hoisted_15$4, toDisplayString(parts(row.node.name)[1]), 1)) : createCommentVNode("", true),
+								createTextVNode(toDisplayString(parts(row.node.name)[2]), 1)
+							]),
+							reason(row.node) ? (openBlock(), createElementBlock("span", _hoisted_16$2, toDisplayString(shortReason(row.node)), 1)) : __props.query && row.node.parentName ? (openBlock(), createElementBlock("span", _hoisted_17$2, toDisplayString(row.node.parentName), 1)) : createCommentVNode("", true),
+							__props.query && __props.mode === "folder" && row.node.kind === "file" && row.node.parentPath && !reason(row.node) ? (openBlock(), createBlock(BaseButton_default, {
+								key: 3,
+								variant: "ghost",
+								size: "sm",
+								onClick: withModifiers(($event) => emit("parent", row.node), ["stop"])
+							}, {
+								default: withCtx(() => [..._cache[3] || (_cache[3] = [createTextVNode("Select its folder", -1)])]),
+								_: 1
+							}, 8, ["onClick"])) : createCommentVNode("", true)
+						]),
+						createElementVNode("span", { class: normalizeClass(["mint-picker__cell mint-picker__cell--size", { "mint-picker__partial": partial(row.node) }]) }, toDisplayString(size(row.node)), 3),
+						createElementVNode("span", _hoisted_18$2, toDisplayString(unref(formatModified)(row.node.modifiedAt)), 1)
+					], 46, _hoisted_6$4), row.error ? (openBlock(), createElementBlock("div", _hoisted_19$2, [createTextVNode(toDisplayString(row.error), 1), createVNode(BaseButton_default, {
+						variant: "ghost",
+						size: "sm",
+						onClick: ($event) => emit("expand", row.node)
+					}, {
+						default: withCtx(() => [..._cache[4] || (_cache[4] = [createTextVNode("Close branch", -1)])]),
+						_: 1
+					}, 8, ["onClick"])])) : createCommentVNode("", true)], 64);
+				}), 128))
+			], 8, _hoisted_1$6);
+		};
+	}
+});
+//#endregion
+//#region src/components/internal/FilePickerPreviewInternal.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1$5 = {
+	class: "mint-picker__preview",
+	"aria-label": "Selection preview"
+};
+var _hoisted_2$5 = { class: "mint-picker__preview-heading" };
+var _hoisted_3$4 = ["title"];
+var _hoisted_4$4 = { class: "mint-picker__preview-head" };
+var _hoisted_5$3 = { class: "mint-picker__preview-icon" };
+var _hoisted_6$3 = {
+	viewBox: "0 0 24 24",
+	fill: "none",
+	stroke: "currentColor",
+	"stroke-width": "1.7",
+	"aria-hidden": "true"
+};
+var _hoisted_7$3 = ["d"];
+var _hoisted_8$3 = { class: "mint-picker__preview-title" };
+var _hoisted_9$3 = { class: "mint-picker__preview-name" };
+var _hoisted_10$3 = { class: "mint-picker__preview-kind" };
+var _hoisted_11$3 = { class: "mint-picker__metadata" };
+var _hoisted_12$3 = ["title"];
+var _hoisted_13$3 = {
+	key: 1,
+	class: "mint-picker__preview-error",
+	role: "alert"
+};
+var _hoisted_14$3 = {
+	key: 2,
+	class: "mint-picker__preview-status",
+	role: "status"
+};
+var _hoisted_15$3 = {
+	key: 2,
+	class: "mint-picker__preview-empty"
+};
+//#endregion
+//#region src/components/internal/FilePickerPreviewInternal.vue
+var FilePickerPreviewInternal_default = /* @__PURE__ */ defineComponent({
+	__name: "FilePickerPreviewInternal",
+	props: {
+		totalCount: {},
+		node: {},
+		sourceLabel: {},
+		exclusions: {},
+		busy: { type: Boolean },
+		error: {},
+		reviewing: { type: Boolean }
+	},
+	emits: ["review", "retry"],
+	setup(__props, { emit: __emit }) {
+		const emit = __emit;
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("aside", _hoisted_1$5, [__props.reviewing ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [createElementVNode("div", _hoisted_2$5, [_cache[4] || (_cache[4] = createTextVNode(" Skipped files ", -1)), createVNode(BaseButton_default, {
+				variant: "ghost",
+				size: "sm",
+				onClick: _cache[0] || (_cache[0] = ($event) => emit("review"))
+			}, {
+				default: withCtx(() => [..._cache[3] || (_cache[3] = [createTextVNode("Back", -1)])]),
+				_: 1
+			})]), (openBlock(true), createElementBlock(Fragment, null, renderList(__props.exclusions, (item) => {
+				return openBlock(), createElementBlock("div", {
+					key: item.path,
+					class: "mint-picker__exclusion",
+					title: item.path
+				}, [createElementVNode("strong", null, toDisplayString(item.name), 1), createElementVNode("span", null, toDisplayString(unref(pickerReason)(item)), 1)], 8, _hoisted_3$4);
+			}), 128))], 64)) : __props.node ? (openBlock(), createElementBlock(Fragment, { key: 1 }, [
+				createElementVNode("div", _hoisted_4$4, [createElementVNode("span", _hoisted_5$3, [(openBlock(), createElementBlock("svg", _hoisted_6$3, [createElementVNode("path", { d: __props.node.kind === "folder" ? unref(FILE_PICKER_ICONS).folder : unref(FILE_PICKER_ICONS).file }, null, 8, _hoisted_7$3)]))]), createElementVNode("span", _hoisted_8$3, [createElementVNode("strong", _hoisted_9$3, toDisplayString(__props.node.name), 1), createElementVNode("span", _hoisted_10$3, toDisplayString(__props.node.kind === "folder" ? "Folder" : __props.node.format ? `${__props.node.format.toUpperCase()} file` : "File"), 1)])]),
+				createElementVNode("dl", _hoisted_11$3, [
+					_cache[9] || (_cache[9] = createElementVNode("dt", null, "Size", -1)),
+					createElementVNode("dd", null, toDisplayString(__props.node.bytes == null ? "—" : unref(formatBytes)(__props.node.bytes)), 1),
+					__props.node.modifiedAt ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [_cache[5] || (_cache[5] = createElementVNode("dt", null, "Modified", -1)), createElementVNode("dd", null, toDisplayString(unref(formatModified)(__props.node.modifiedAt)), 1)], 64)) : createCommentVNode("", true),
+					__props.node.kind === "folder" ? (openBlock(), createElementBlock(Fragment, { key: 1 }, [
+						_cache[8] || (_cache[8] = createElementVNode("dt", null, "Files", -1)),
+						createElementVNode("dd", null, [createTextVNode(toDisplayString(__props.node.fileCount ?? "—"), 1), __props.totalCount != null && __props.totalCount !== __props.node.fileCount ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [createTextVNode(" of " + toDisplayString(__props.totalCount), 1)], 64)) : createCommentVNode("", true)]),
+						__props.node.formats ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [_cache[7] || (_cache[7] = createElementVNode("dt", null, "Formats", -1)), createElementVNode("dd", null, [(openBlock(true), createElementBlock(Fragment, null, renderList(__props.node.formats, (count, format) => {
+							return openBlock(), createElementBlock("span", { key: format }, [createTextVNode(toDisplayString(format.toUpperCase()) + " ×" + toDisplayString(count), 1), _cache[6] || (_cache[6] = createElementVNode("br", null, null, -1))]);
+						}), 128))])], 64)) : createCommentVNode("", true)
+					], 64)) : createCommentVNode("", true),
+					_cache[10] || (_cache[10] = createElementVNode("dt", null, "Location", -1)),
+					createElementVNode("dd", { title: __props.node.parentName || __props.node.path }, toDisplayString(__props.node.parentName || __props.node.path), 9, _hoisted_12$3),
+					_cache[11] || (_cache[11] = createElementVNode("dt", null, "Source", -1)),
+					createElementVNode("dd", null, toDisplayString(__props.sourceLabel), 1)
+				]),
+				__props.exclusions.length ? (openBlock(), createBlock(BaseButton_default, {
+					key: 0,
+					variant: "ghost",
+					size: "sm",
+					class: "mint-picker__skipped",
+					onClick: _cache[1] || (_cache[1] = ($event) => emit("review"))
+				}, {
+					default: withCtx(() => [createTextVNode(toDisplayString(__props.exclusions.length) + " skipped · Review", 1)]),
+					_: 1
+				})) : createCommentVNode("", true),
+				__props.error ? (openBlock(), createElementBlock("div", _hoisted_13$3, [createTextVNode(toDisplayString(__props.error), 1), createVNode(BaseButton_default, {
+					variant: "secondary",
+					size: "sm",
+					onClick: _cache[2] || (_cache[2] = ($event) => emit("retry"))
+				}, {
+					default: withCtx(() => [..._cache[12] || (_cache[12] = [createTextVNode("Try again", -1)])]),
+					_: 1
+				})])) : __props.busy ? (openBlock(), createElementBlock("span", _hoisted_14$3, "Checking selection…")) : createCommentVNode("", true)
+			], 64)) : (openBlock(), createElementBlock("p", _hoisted_15$3, "Select a file to see its details."))]);
+		};
+	}
+});
+//#endregion
+//#region src/composables/filePicker/usePickerNavigation.ts
+var byName = new Intl.Collator(void 0, {
+	numeric: true,
+	sensitivity: "base"
+}).compare;
+/** Folders first; undated rows go last in either time order. */
+function ordered(items, sort) {
+	if (!sort) return items;
+	const times = new Map(items.map((node) => [node, node.modifiedAt ? Date.parse(node.modifiedAt) : NaN]));
+	const time = (node) => times.get(node);
+	return [...items].sort((a, b) => {
+		if (a.kind !== b.kind) return a.kind === "folder" ? -1 : 1;
+		if (sort === "name") return byName(a.name, b.name);
+		if (sort === "name-desc") return byName(b.name, a.name);
+		const [ta, tb] = [time(a), time(b)];
+		if (Number.isNaN(ta) || Number.isNaN(tb)) return Number.isNaN(ta) === Number.isNaN(tb) ? byName(a.name, b.name) : Number.isNaN(ta) ? 1 : -1;
+		return (sort === "newest" ? tb - ta : ta - tb) || byName(a.name, b.name);
+	});
+}
+function usePickerNavigation(adapter, request, systemFilter = () => true, sort = () => void 0) {
+	const path = shallowRef("");
+	const trail = ref([]);
+	const entries = shallowRef([]);
+	const nodes = ref(/* @__PURE__ */ new Map());
+	const children = shallowRef(/* @__PURE__ */ new Map());
+	const expanded = ref(/* @__PURE__ */ new Set());
+	const expanding = ref(/* @__PURE__ */ new Set());
+	const expansionErrors = ref(/* @__PURE__ */ new Map());
+	const loading = shallowRef(false);
+	const error = shallowRef("");
+	/** True when the current search results stopped at an adapter limit. */
+	const truncated = shallowRef(false);
+	let epoch = 0;
+	let navigation = 0;
+	let controller;
+	const pending = /* @__PURE__ */ new Map();
+	const childControllers = /* @__PURE__ */ new Set();
+	let prefetchTimer;
+	let prefetchQueue = [];
+	let prefetchActive = 0;
+	function stopPrefetch() {
+		clearTimeout(prefetchTimer);
+		prefetchQueue = [];
+	}
+	function drainPrefetch() {
+		while (prefetchActive < 2 && prefetchQueue.length) {
+			const node = prefetchQueue.shift();
+			if (!isAllowed(node) || children.value.has(node.path) || pending.has(node.path)) continue;
+			prefetchActive++;
+			const token = epoch;
+			loadChildren(node.path).catch(() => {}).finally(() => {
+				if (token !== epoch) return;
+				prefetchActive--;
+				drainPrefetch();
+			});
+		}
+	}
+	function prefetch(items) {
+		stopPrefetch();
+		const candidates = items.filter((node) => node.kind === "folder" && !node.unavailableReason && node.hasChildren !== false && isAllowed(node)).slice(0, 20);
+		prefetchTimer = setTimeout(() => {
+			prefetchQueue = candidates;
+			drainPrefetch();
+		}, 100);
+	}
+	function isAllowed(node) {
+		const seen = /* @__PURE__ */ new Set();
+		let current = nodes.value.get(node.path) ?? node;
+		while (current && !seen.has(current.path)) {
+			if (!systemFilter(current)) return false;
+			seen.add(current.path);
+			current = current.parentPath ? nodes.value.get(current.parentPath) : void 0;
+		}
+		return true;
+	}
+	function register(items, parent) {
+		for (const item of items) nodes.value.set(item.path, {
+			...item,
+			parentPath: item.parentPath !== void 0 ? item.parentPath : parent !== void 0 ? parent || null : nodes.value.get(item.path)?.parentPath ?? null
+		});
+	}
+	function invalidate() {
+		adapter().invalidate?.();
+		stopPrefetch();
+		prefetchActive = 0;
+		++epoch;
+		++navigation;
+		controller?.abort();
+		childControllers.forEach((item) => item.abort());
+		childControllers.clear();
+		pending.clear();
+		children.value = /* @__PURE__ */ new Map();
+		expanding.value.clear();
+		expansionErrors.value.clear();
+	}
+	function clear() {
+		invalidate();
+		nodes.value.clear();
+		expanded.value.clear();
+		expanding.value.clear();
+		expansionErrors.value.clear();
+		entries.value = [];
+		loading.value = false;
+		error.value = "";
+	}
+	async function loadChildren(folder, ancestors = [], refresh = false) {
+		if (ancestors.includes(folder)) throw new Error("The adapter returned a circular folder tree.");
+		const cached = children.value.get(folder);
+		if (cached) return cached;
+		const existing = pending.get(folder);
+		if (existing) return existing;
+		const token = epoch;
+		const abort = new AbortController();
+		childControllers.add(abort);
+		const task = adapter().listChildren(folder, {
+			...request(),
+			...refresh && { refresh },
+			signal: abort.signal
+		}).then((items) => {
+			if (token !== epoch) throw new DOMException("Cancelled", "AbortError");
+			const retained = new Set(items.map((item) => item.path));
+			function remove(path, seen = /* @__PURE__ */ new Set()) {
+				if (seen.has(path) || path === folder) return;
+				seen.add(path);
+				for (const node of nodes.value.values()) if (node.parentPath === path) remove(node.path, seen);
+				nodes.value.delete(path);
+				children.value.delete(path);
+			}
+			for (const node of nodes.value.values()) if (node.parentPath === folder && !retained.has(node.path)) remove(node.path);
+			register(items, folder);
+			children.value = new Map(children.value).set(folder, items);
+			return items;
+		}).finally(() => {
+			childControllers.delete(abort);
+			if (token === epoch) pending.delete(folder);
+		});
+		pending.set(folder, task);
+		return task;
+	}
+	async function load(query = "", recursive = false, refresh = false) {
+		stopPrefetch();
+		const token = ++navigation;
+		controller?.abort();
+		controller = new AbortController();
+		const options = {
+			...request(),
+			...refresh && { refresh },
+			signal: controller.signal
+		};
+		loading.value = true;
+		error.value = "";
+		truncated.value = false;
+		entries.value = [];
+		try {
+			const found = query.trim() ? await adapter().search(query.trim(), {
+				path: path.value,
+				recursive
+			}, options) : path.value ? await loadChildren(path.value, [], refresh) : await adapter().listRoot(options);
+			if (token !== navigation) return;
+			const items = Array.isArray(found) ? found : found.nodes;
+			truncated.value = !Array.isArray(found) && found.truncated;
+			register(items, query.trim() ? void 0 : path.value);
+			entries.value = items;
+			if (!query.trim()) prefetch(items);
+		} catch (cause) {
+			if (token === navigation) error.value = cause instanceof Error ? cause.message : "Could not read this location.";
+		} finally {
+			if (token === navigation) loading.value = false;
+		}
+	}
+	async function expand(node) {
+		if (node.kind !== "folder" || node.unavailableReason || !isAllowed(node)) return;
+		if (expanded.value.has(node.path)) {
+			expanded.value.delete(node.path);
+			return;
+		}
+		expanded.value.add(node.path);
+		expanding.value.add(node.path);
+		expansionErrors.value.delete(node.path);
+		const token = epoch;
+		const view = navigation;
+		try {
+			const items = await loadChildren(node.path);
+			if (token === epoch && view === navigation && expanded.value.has(node.path)) prefetch(items);
+		} catch (cause) {
+			if (token === epoch) expansionErrors.value.set(node.path, cause instanceof Error ? cause.message : "Could not read this folder.");
+		} finally {
+			if (token === epoch) expanding.value.delete(node.path);
+		}
+	}
+	function enter(node) {
+		if (node.kind !== "folder" || node.unavailableReason || !isAllowed(node)) return;
+		const index = trail.value.findIndex((crumb) => crumb.path === node.path);
+		trail.value = index >= 0 ? trail.value.slice(0, index + 1) : [...trail.value, {
+			path: node.path,
+			label: node.name
+		}];
+		path.value = node.path;
+	}
+	function up(target) {
+		const index = target !== void 0 ? trail.value.findIndex((crumb) => crumb.path === target) : trail.value.length - 2;
+		trail.value = index < 0 ? [] : trail.value.slice(0, index + 1);
+		path.value = trail.value[trail.value.length - 1]?.path ?? "";
+	}
+	const rows = computed(() => {
+		const result = [];
+		const order = sort();
+		function visit(items, depth, ancestors) {
+			for (const item of ordered(items, order)) {
+				if (ancestors.has(item.path) || depth > 30) continue;
+				const node = nodes.value.get(item.path) ?? item;
+				if (!isAllowed(node)) continue;
+				result.push({
+					node,
+					depth,
+					expanded: expanded.value.has(item.path),
+					loading: expanding.value.has(item.path),
+					error: expansionErrors.value.get(item.path)
+				});
+				if (expanded.value.has(item.path)) visit(children.value.get(item.path) ?? [], depth + 1, /* @__PURE__ */ new Set([...ancestors, item.path]));
+			}
+		}
+		visit(entries.value, 0, /* @__PURE__ */ new Set());
+		return result;
+	});
+	onScopeDispose(clear);
+	return {
+		path,
+		trail,
+		entries,
+		nodes,
+		children,
+		expanded,
+		expanding,
+		expansionErrors,
+		loading,
+		error,
+		truncated,
+		rows,
+		isAllowed,
+		clear,
+		invalidate,
+		register,
+		loadChildren,
+		load,
+		expand,
+		enter,
+		up
+	};
+}
+//#endregion
+//#region src/composables/filePicker/usePickerSelection.ts
+function usePickerSelection(nav, mode, capability, skipBlanks) {
+	const keys = ref(/* @__PURE__ */ new Set());
+	const dropped = ref(/* @__PURE__ */ new Set());
+	const focusPath = shallowRef("");
+	const resolving = shallowRef(false);
+	const resolutionError = shallowRef("");
+	let anchor = "";
+	let generation = 0;
+	function ancestorSelected(node, candidates = keys.value) {
+		const seen = /* @__PURE__ */ new Set();
+		let parent = node.parentPath;
+		while (parent && !seen.has(parent)) {
+			if (candidates.has(parent)) return true;
+			seen.add(parent);
+			parent = nav.nodes.value.get(parent)?.parentPath;
+		}
+		return false;
+	}
+	function exclusion(node) {
+		if (!nav.isAllowed(node)) return {
+			path: node.path,
+			name: node.name,
+			reason: "forbidden"
+		};
+		const own = pickerExclusion(node, capability(), skipBlanks());
+		if (own) return own;
+		const seen = /* @__PURE__ */ new Set();
+		let parent = node.parentPath;
+		while (parent && !seen.has(parent)) {
+			seen.add(parent);
+			const folder = nav.nodes.value.get(parent);
+			if (!folder) break;
+			const inherited = pickerExclusion(folder, capability(), skipBlanks());
+			if (inherited) return {
+				...inherited,
+				path: node.path,
+				name: node.name
+			};
+			parent = folder.parentPath;
+		}
+		return null;
+	}
+	function selected(node) {
+		return !exclusion(node) && !dropped.value.has(node.path) && !ancestorSelected(node, dropped.value) && (keys.value.has(node.path) || mode() === "folder+files" && ancestorSelected(node));
+	}
+	function selectable(node) {
+		if (exclusion(node)) return false;
+		return node.kind === "folder" ? mode() === "folder" || mode() === "folder+files" : mode() !== "folder";
+	}
+	function select(node, modifiers = {}) {
+		if (exclusion(node)) return;
+		focusPath.value = node.path;
+		if (!selectable(node)) return;
+		const multi = mode() === "multi-file" || mode() === "folder+files";
+		const additive = multi && (modifiers.metaKey || modifiers.ctrlKey || modifiers.toggle);
+		if (multi && modifiers.shiftKey && anchor) {
+			const rows = nav.rows.value.map((row) => row.node);
+			const from = rows.findIndex((item) => item.path === anchor);
+			const to = rows.findIndex((item) => item.path === node.path);
+			if (from >= 0 && to >= 0) {
+				keys.value = /* @__PURE__ */ new Set([...additive ? keys.value : [], ...rows.slice(Math.min(from, to), Math.max(from, to) + 1).filter(selectable).map((item) => item.path)]);
+				dropped.value.clear();
+				return;
+			}
+		}
+		if (additive || modifiers.toggle && (selected(node) || dropped.value.has(node.path))) {
+			if (mode() === "folder+files" && ancestorSelected(node)) {
+				if (dropped.value.has(node.path)) dropped.value.delete(node.path);
+				else dropped.value.add(node.path);
+			} else if (keys.value.has(node.path)) keys.value.delete(node.path);
+			else {
+				keys.value.add(node.path);
+				dropped.value.delete(node.path);
+			}
+		} else {
+			keys.value = /* @__PURE__ */ new Set([node.path]);
+			dropped.value.clear();
+		}
+		anchor = node.path;
+	}
+	function reset(selection) {
+		++generation;
+		keys.value.clear();
+		dropped.value.clear();
+		resolving.value = false;
+		resolutionError.value = "";
+		focusPath.value = "";
+		if (selection?.source === "server") {
+			const files = mode() === "folder" ? [] : mode() === "single-file" ? selection.files.slice(0, 1) : selection.files;
+			const folders = mode() === "folder" ? selection.folders.slice(0, 1) : mode() === "folder+files" ? selection.folders : [];
+			nav.register(files);
+			folders.forEach((path) => {
+				if (!nav.nodes.value.has(path)) nav.register([{
+					kind: "folder",
+					path,
+					name: "Selected folder",
+					parentName: "Selected location"
+				}]);
+				keys.value.add(path);
+			});
+			files.forEach((file) => keys.value.add(file.path));
+			selection.excluded.filter((item) => item.reason === "deselected").forEach((item) => dropped.value.add(item.path));
+		}
+	}
+	const roots = computed(() => [...keys.value].map((key) => nav.nodes.value.get(key)).filter((node) => !!node && !ancestorSelected(node) && nav.isAllowed(node)));
+	const chosen = computed(() => {
+		const files = [];
+		const excluded = [];
+		for (const node of nav.nodes.value.values()) {
+			if (!nav.isAllowed(node)) continue;
+			if (!keys.value.has(node.path) && !ancestorSelected(node)) continue;
+			const reason = exclusion(node) ?? (dropped.value.has(node.path) ? {
+				path: node.path,
+				name: node.name,
+				reason: "deselected"
+			} : null);
+			const droppedByParent = ancestorSelected(node, dropped.value);
+			if (reason || droppedByParent) {
+				if (node.kind === "file" || reason?.reason === "unreadable") excluded.push(reason ?? {
+					path: node.path,
+					name: node.name,
+					reason: "deselected"
+				});
+			} else if (node.kind === "file") files.push(node);
+		}
+		return {
+			files,
+			excluded,
+			bytes: files.reduce((total, node) => total + (node.bytes ?? 0), 0)
+		};
+	});
+	async function resolve() {
+		const token = ++generation;
+		resolving.value = true;
+		resolutionError.value = "";
+		let count = 0;
+		const seen = /* @__PURE__ */ new Set();
+		async function walk(node, ancestors = []) {
+			if (token !== generation) throw new DOMException("Cancelled", "AbortError");
+			if (!nav.isAllowed(node)) return [];
+			if (node.kind === "file") return [node];
+			if (node.unavailableReason) return [];
+			if (ancestors.includes(node.path)) throw new Error("The adapter returned a circular folder tree.");
+			if (seen.has(node.path)) return [];
+			seen.add(node.path);
+			if (++count > 500 || ancestors.length > 30) throw new Error("This selection is too large to validate. Choose a smaller folder.");
+			const children = await nav.loadChildren(node.path, ancestors);
+			const files = [];
+			for (const child of children) files.push(...await walk(child, [...ancestors, node.path]));
+			if (token !== generation) throw new DOMException("Cancelled", "AbortError");
+			const formats = {};
+			files.forEach((file) => {
+				formats[file.format] = (formats[file.format] ?? 0) + 1;
+			});
+			nav.register([{
+				...node,
+				fileCount: files.length,
+				bytes: files.reduce((sum, file) => sum + (file.bytes ?? 0), 0),
+				formats
+			}]);
+			return files;
+		}
+		try {
+			for (const node of roots.value) await walk(node);
+			if (token === generation) for (const key of [...keys.value]) {
+				const node = nav.nodes.value.get(key);
+				if (node && ancestorSelected(node)) keys.value.delete(key);
+			}
+		} catch (cause) {
+			if (token === generation) resolutionError.value = cause instanceof Error ? cause.message : "Could not validate the selection.";
+		} finally {
+			if (token === generation) resolving.value = false;
+		}
+	}
+	const focused = computed(() => {
+		const node = nav.nodes.value.get(focusPath.value);
+		return node && nav.isAllowed(node) ? node : roots.value[roots.value.length - 1] ?? null;
+	});
+	watch(() => new Map([...nav.nodes.value].map(([path, node]) => [path, nav.isAllowed(node)])), (allowed, previous) => {
+		if (keys.value.size && [...allowed].some(([path, value]) => previous.has(path) && value !== previous.get(path))) resolve();
+	});
+	const selectedFileCounts = computed(() => {
+		const counts = /* @__PURE__ */ new Map();
+		for (const file of chosen.value.files) {
+			const seen = /* @__PURE__ */ new Set();
+			let parent = file.parentPath;
+			while (parent && !seen.has(parent)) {
+				seen.add(parent);
+				counts.set(parent, (counts.get(parent) ?? 0) + 1);
+				parent = nav.nodes.value.get(parent)?.parentPath;
+			}
+		}
+		return counts;
+	});
+	function folderProgress(node) {
+		if (node.kind !== "folder" || node.fileCount == null) return "";
+		return `${selected(node) ? selectedFileCounts.value.get(node.path) ?? 0 : 0} / ${node.fileCount}`;
+	}
+	return {
+		keys,
+		dropped,
+		focusPath,
+		resolving,
+		resolutionError,
+		roots,
+		chosen,
+		focused,
+		select,
+		selected,
+		selectable,
+		exclusion,
+		reset,
+		resolve,
+		folderProgress,
+		ancestorSelected
+	};
+}
+//#endregion
+//#region src/composables/filePicker/localFiles.ts
+/** Construct metadata only: no FileReader, arrayBuffer or upload. */
+function localFilesAdapter(files, relativePaths) {
+	const nodes = /* @__PURE__ */ new Map();
+	for (const [index, file] of files.entries()) {
+		const relative = relativePaths?.[index] || file.webkitRelativePath || file.name;
+		const parts = relative.split("/");
+		let parent = null;
+		for (let i = 0; i < parts.length - 1; i++) {
+			const path = parts.slice(0, i + 1).join("/");
+			if (!nodes.has(path)) nodes.set(path, {
+				kind: "folder",
+				name: parts[i],
+				path,
+				parentPath: parent,
+				fileCount: 0,
+				bytes: 0,
+				formats: {}
+			});
+			parent = path;
+		}
+		let path = relative;
+		for (let n = 2; nodes.has(path); n++) path = `${relative} (${n})`;
+		nodes.set(path, {
+			kind: "file",
+			name: file.name,
+			path,
+			parentPath: parent,
+			bytes: file.size,
+			modifiedAt: new Date(file.lastModified).toISOString(),
+			format: pickerFormat(file.name),
+			file
+		});
+	}
+	const children = /* @__PURE__ */ new Map();
+	for (const node of nodes.values()) {
+		const parent = node.parentPath ?? "";
+		const siblings = children.get(parent);
+		if (siblings) siblings.push(node);
+		else children.set(parent, [node]);
+		if (node.kind !== "file") continue;
+		for (let slash = node.path.indexOf("/"); slash >= 0; slash = node.path.indexOf("/", slash + 1)) {
+			const folder = nodes.get(node.path.slice(0, slash));
+			if (folder?.kind !== "folder") continue;
+			folder.fileCount = (folder.fileCount ?? 0) + 1;
+			folder.bytes = (folder.bytes ?? 0) + (node.bytes ?? 0);
+			folder.formats[node.format] = (folder.formats[node.format] ?? 0) + 1;
+		}
+	}
+	const list = (path) => [...children.get(path) ?? []];
+	return {
+		listRoot: async () => list(""),
+		listChildren: async (path) => list(path),
+		search: async (query, scope) => [...nodes.values()].filter((node) => {
+			return (scope.recursive ? !scope.path || node.path.startsWith(`${scope.path}/`) : (node.parentPath ?? "") === scope.path) && node.name.toLowerCase().includes(query.toLowerCase());
+		})
+	};
+}
+//#endregion
+//#region src/composables/useFilePicker.ts
+/** Internal orchestration; public consumers use FilePicker's props and events. */
+function useFilePicker(props, emit, searchArea) {
+	const sourceNames = {
+		server: "Server",
+		localFile: "Local files"
+	};
+	const allowedSources = computed(() => [...new Set(props.sources)]);
+	const SOURCE = "source:";
+	const MOUNT = "mount:";
+	const mounts = shallowRef([]);
+	const source = shallowRef(allowedSources.value.includes(props.initialSelection?.source) ? props.initialSelection.source : allowedSources.value[0] ?? "server");
+	const query = shallowRef("");
+	const recursive = shallowRef(false);
+	const sort = shallowRef(props.defaultSort);
+	const skipBlanks = shallowRef(false);
+	const reviewing = shallowRef(false);
+	const localFiles = shallowRef([]);
+	const localPaths = /* @__PURE__ */ new WeakMap();
+	const localAdapter = computed(() => localFilesAdapter(localFiles.value, localFiles.value.map((file) => localPaths.get(toRaw(file)))));
+	const nav = usePickerNavigation(() => source.value === "localFile" ? localAdapter.value : props.adapter, () => ({ source: source.value }), (node) => props.systemFilter?.(node, source.value) !== false, () => sort.value);
+	const capability = computed(() => props.capabilities[source.value]);
+	const selection = usePickerSelection(nav, () => props.selectionMode, () => capability.value, () => skipBlanks.value);
+	const { path, trail, loading, error, rows } = nav;
+	/** A mount-rooted adapter lists its mounts as header sources; the listing starts inside one. */
+	const mountView = computed(() => source.value === "server" && !!props.adapter.mounts && mounts.value.length > 0);
+	const segments = computed(() => allowedSources.value.flatMap((item) => item === "server" && props.adapter.mounts && mounts.value.length ? mounts.value.map((mount) => ({
+		value: MOUNT + mount.path,
+		label: mount.name,
+		disabled: !!mount.unavailableReason
+	})) : [{
+		value: SOURCE + item,
+		label: sourceNames[item]
+	}]));
+	const activeSegment = computed(() => mountView.value ? MOUNT + (trail.value[0]?.path ?? "") : SOURCE + source.value);
+	const { roots, chosen, focused, resolving, resolutionError } = selection;
+	const previewNode = computed(() => {
+		const node = focused.value;
+		if (!node || node.kind !== "folder" || !selection.selected(node) || resolving.value) return node;
+		const files = chosen.value.files.filter((file) => selection.ancestorSelected(file, /* @__PURE__ */ new Set([node.path])));
+		const formats = {};
+		files.forEach((file) => {
+			formats[file.format] = (formats[file.format] ?? 0) + 1;
+		});
+		return {
+			...node,
+			bytes: files.reduce((sum, file) => sum + (file.bytes ?? 0), 0),
+			fileCount: files.length,
+			formats
+		};
+	});
+	const confirmLabel = computed(() => ({
+		"single-file": "Use file",
+		"multi-file": "Use files",
+		folder: "Use folder",
+		"folder+files": "Use selection"
+	})[props.selectionMode]);
+	const folderCount = computed(() => roots.value.filter((node) => node.kind === "folder").length);
+	const canConfirm = computed(() => allowedSources.value.includes(source.value) && roots.value.length > 0 && chosen.value.files.length > 0 && !resolving.value && !loading.value && !error.value && !resolutionError.value);
+	let lastConfirmed = null;
+	let initialized = false;
+	let timer;
+	let openGeneration = 0;
+	const remembered = /* @__PURE__ */ new Map();
+	const knownFolders = /* @__PURE__ */ new Map();
+	function rememberFolders() {
+		knownFolders.set(source.value, [...nav.nodes.value.values()].filter((node) => node.kind === "folder"));
+	}
+	function currentSeed() {
+		return props.initialSelection ?? lastConfirmed;
+	}
+	async function restore() {
+		const token = ++openGeneration;
+		const seed = currentSeed();
+		nav.register(knownFolders.get(source.value) ?? []);
+		selection.reset(seed?.source === source.value ? seed : null);
+		reviewing.value = false;
+		if (!allowedSources.value.includes(source.value)) return;
+		if (seed?.source === "localFile" && source.value === "localFile") {
+			seed.files.forEach((file, index) => {
+				if (seed.relativePaths?.[index]) localPaths.set(toRaw(file), seed.relativePaths[index]);
+			});
+			localFiles.value = seed.files;
+		}
+		if (source.value === "server" && props.adapter.mounts) {
+			await loadMounts();
+			if (token !== openGeneration || !props.open) return;
+			const first = mounts.value.find((mount) => !mount.unavailableReason);
+			if (!path.value && first) openMount(first);
+			const holder = mounts.value.find((mount) => mount.path === props.adapter.mountOf?.(path.value));
+			if (holder && trail.value[0]?.path !== holder.path) trail.value = [{
+				path: holder.path,
+				label: holder.name
+			}, ...trail.value];
+		}
+		await nav.load(query.value, recursive.value);
+		if (token !== openGeneration || !props.open) return;
+		if (seed?.source === "localFile" && source.value === "localFile") await selectLocalFiles();
+		if (selection.keys.value.size) await selection.resolve();
+	}
+	watch(() => props.open, (open) => {
+		clearTimeout(timer);
+		if (open) {
+			sort.value = props.defaultSort;
+			if (!initialized) {
+				path.value = props.initialPath;
+				if (path.value) trail.value = [{
+					path: path.value,
+					label: "Current folder"
+				}];
+				initialized = true;
+			}
+			const seed = currentSeed();
+			if (seed && allowedSources.value.includes(seed.source) && seed.source !== source.value) switchSource(seed.source);
+			else restore();
+		} else {
+			++openGeneration;
+			rememberFolders();
+			selection.reset();
+			nav.clear();
+		}
+	}, { immediate: true });
+	watch([query, recursive], () => {
+		clearTimeout(timer);
+		if (props.open) timer = setTimeout(() => {
+			nav.load(query.value, recursive.value);
+		}, 200);
+	});
+	watch(() => [...selection.keys.value], () => {
+		if (props.open) selection.resolve();
+	});
+	watch(() => props.selectionMode, () => {
+		if (props.open) restore();
+	});
+	watch(allowedSources, (sources) => {
+		if (!sources.includes(source.value) && sources[0]) switchSource(sources[0]);
+	});
+	onScopeDispose(() => {
+		++openGeneration;
+		clearTimeout(timer);
+		selection.reset();
+	});
+	async function loadMounts() {
+		try {
+			mounts.value = (await props.adapter.listRoot({ source: "server" })).filter((node) => node.kind === "folder" && props.systemFilter?.(node, "server") !== false);
+		} catch {
+			mounts.value = [];
+		}
+		nav.register(mounts.value, "");
+	}
+	function openMount(mount) {
+		trail.value = [{
+			path: mount.path,
+			label: mount.name
+		}];
+		path.value = mount.path;
+	}
+	async function chooseSegment(value) {
+		const key = String(value);
+		if (key.startsWith(SOURCE)) return switchSource(key.slice(7));
+		const mount = mounts.value.find((item) => MOUNT + item.path === key);
+		if (!mount || mount.unavailableReason) return;
+		if (source.value !== "server") {
+			remembered.set("server", {
+				path: mount.path,
+				trail: [{
+					path: mount.path,
+					label: mount.name
+				}]
+			});
+			return switchSource("server");
+		}
+		clearTimeout(timer);
+		query.value = "";
+		openMount(mount);
+		await nav.load();
+	}
+	function clearSelection() {
+		selection.reset();
+		reviewing.value = false;
+	}
+	async function switchSource(next) {
+		if (next === source.value || !allowedSources.value.includes(next)) return;
+		rememberFolders();
+		remembered.set(source.value, {
+			path: path.value,
+			trail: [...trail.value]
+		});
+		clearTimeout(timer);
+		nav.clear();
+		source.value = next;
+		query.value = "";
+		path.value = remembered.get(next)?.path ?? "";
+		trail.value = remembered.get(next)?.trail ?? [];
+		await restore();
+	}
+	function selectNode(node, event) {
+		const opensFolder = node.kind === "folder" && props.selectionMode === "folder+files";
+		if (event.type === "click" && event.detail > 1 && !opensFolder) return;
+		selection.select(node, {
+			metaKey: event.metaKey,
+			ctrlKey: event.ctrlKey,
+			shiftKey: event.shiftKey,
+			toggle: event.type === "click" || event instanceof KeyboardEvent && event.key === " "
+		});
+	}
+	async function enter(node) {
+		const token = openGeneration;
+		if (selection.exclusion(node)) return;
+		if (node.kind === "file") {
+			if (props.selectionMode === "single-file") {
+				selection.select(node);
+				await nextTick();
+				await selection.resolve();
+				if (token === openGeneration && props.open) confirm();
+			}
+			return;
+		}
+		clearTimeout(timer);
+		query.value = "";
+		nav.enter(node);
+		await nav.load();
+	}
+	async function up(target) {
+		const atMountRoot = mounts.value.some((mount) => mount.path === trail.value[0]?.path);
+		if (mountView.value && (target === "" || target === void 0 && trail.value.length <= 1 && atMountRoot)) return;
+		query.value = "";
+		clearTimeout(timer);
+		nav.up(target);
+		await nav.load();
+	}
+	async function refresh() {
+		nav.invalidate();
+		await nav.load(query.value, recursive.value, true);
+		if (selection.keys.value.size) await selection.resolve();
+	}
+	function selectParent(node) {
+		if (!node.parentPath) return;
+		const parent = nav.nodes.value.get(node.parentPath) ?? {
+			kind: "folder",
+			path: node.parentPath,
+			name: node.parentName ?? "Containing folder"
+		};
+		nav.register([parent]);
+		selection.select(parent);
+	}
+	async function chooseLocal(files, _rootName, relativePaths) {
+		const token = openGeneration;
+		if (!files.length || !props.open || source.value !== "localFile") return;
+		files.forEach((file, index) => {
+			if (relativePaths?.[index]) localPaths.set(toRaw(file), relativePaths[index]);
+		});
+		localFiles.value = files;
+		clearTimeout(timer);
+		nav.clear();
+		selection.reset();
+		path.value = "";
+		trail.value = [];
+		query.value = "";
+		await nav.load();
+		if (token !== openGeneration || !props.open || source.value !== "localFile") return;
+		await selectLocalFiles();
+	}
+	async function selectLocalFiles() {
+		const token = openGeneration;
+		const found = props.selectionMode === "single-file" || props.selectionMode === "multi-file" ? await localAdapter.value.search("", {
+			path: "",
+			recursive: true
+		}) : nav.entries.value;
+		const items = Array.isArray(found) ? found : found.nodes;
+		if (token !== openGeneration || !props.open || source.value !== "localFile") return;
+		nav.register(items);
+		const candidates = items.filter((node) => selection.selectable(node));
+		for (const node of props.selectionMode === "single-file" || props.selectionMode === "folder" ? candidates.slice(0, 1) : candidates) selection.select(node, { ctrlKey: true });
+	}
+	function cancel() {
+		emit("cancel");
+		emit("update:open", false);
+	}
+	function confirm() {
+		if (!canConfirm.value) return;
+		const result = source.value === "localFile" ? {
+			source: "localFile",
+			files: chosen.value.files.flatMap((node) => node.file ? [toRaw(node.file)] : [])
+		} : {
+			source: "server",
+			folders: roots.value.filter((node) => node.kind === "folder").map((node) => node.path),
+			files: [...chosen.value.files],
+			excluded: [...chosen.value.excluded]
+		};
+		if (result.source === "localFile") {
+			const relativePaths = result.files.map((file) => localPaths.get(file) || file.webkitRelativePath || file.name);
+			if (relativePaths.some((path, index) => path !== (result.files[index].webkitRelativePath || result.files[index].name))) result.relativePaths = relativePaths;
+		}
+		lastConfirmed = result;
+		emit("select", result);
+		emit("update:open", false);
+	}
+	function keyboard(event) {
+		if (event.key !== "/" || event.target instanceof HTMLInputElement || event.target instanceof HTMLTextAreaElement) return;
+		event.preventDefault();
+		searchArea.value?.querySelector("input")?.focus();
+	}
+	return {
+		previewNode,
+		sourceNames,
+		segments,
+		activeSegment,
+		mounts,
+		mountView,
+		allowedSources,
+		source,
+		query,
+		recursive,
+		sort,
+		skipBlanks,
+		reviewing,
+		nav,
+		selection,
+		capability,
+		path,
+		trail,
+		loading,
+		error,
+		rows,
+		roots,
+		chosen,
+		focused,
+		resolving,
+		resolutionError,
+		confirmLabel,
+		folderCount,
+		canConfirm,
+		chooseSegment,
+		clearSelection,
+		selectNode,
+		enter,
+		up,
+		refresh,
+		selectParent,
+		chooseLocal,
+		cancel,
+		confirm,
+		keyboard
+	};
+}
+//#endregion
+//#region src/components/FilePicker.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1$4 = { class: "mint-picker__title" };
+var _hoisted_2$4 = {
+	key: 1,
+	ref: "searchArea",
+	class: "mint-picker__search"
+};
+var _hoisted_3$3 = {
+	key: 0,
+	class: "mint-picker__pathbar"
+};
+var _hoisted_4$3 = {
+	"aria-label": "Breadcrumb",
+	class: "mint-picker__breadcrumbs"
+};
+var _hoisted_5$2 = ["aria-current"];
+var _hoisted_6$2 = {
+	key: 0,
+	class: "mint-picker__crumb-separator",
+	viewBox: "0 0 16 16",
+	fill: "none",
+	stroke: "currentColor",
+	"stroke-width": "1.5",
+	"aria-hidden": "true"
+};
+var _hoisted_7$2 = ["aria-current", "onClick"];
+var _hoisted_8$2 = {
+	key: 0,
+	class: "mint-picker__accepts"
+};
+var _hoisted_9$2 = [
+	"aria-expanded",
+	"aria-label",
+	"onClick",
+	"onKeydown"
+];
+var _hoisted_10$2 = ["aria-pressed"];
+var _hoisted_11$2 = ["disabled"];
+var _hoisted_12$2 = {
+	key: 1,
+	class: "mint-picker__empty"
+};
+var _hoisted_13$2 = {
+	key: 0,
+	class: "mint-picker__local-upload"
+};
+var _hoisted_14$2 = {
+	key: 0,
+	role: "alert"
+};
+var _hoisted_15$2 = {
+	key: 1,
+	class: "mint-picker__workspace"
+};
+var _hoisted_16$1 = { class: "mint-picker__footer" };
+var _hoisted_17$1 = {
+	class: "mint-picker__receipt",
+	role: "status"
+};
+var _hoisted_18$1 = { class: "mint-picker__summary" };
+var _hoisted_19$1 = { key: 2 };
+var _hoisted_20$1 = { class: "mint-picker__actions" };
+//#endregion
+//#region src/components/FilePicker.vue
+var FilePicker_default = /* @__PURE__ */ defineComponent({
+	__name: "FilePicker",
+	props: {
+		open: { type: Boolean },
+		adapter: {},
+		selectionMode: { default: "folder+files" },
+		sources: { default: () => ["server"] },
+		capabilities: { default: () => ({}) },
+		initialPath: { default: "" },
+		initialSelection: { default: null },
+		title: { default: "Choose data" },
+		view: { default: "list" },
+		defaultSort: { default: "newest" },
+		systemFilter: {}
+	},
+	emits: [
+		"update:open",
+		"select",
+		"cancel"
+	],
+	setup(__props, { emit: __emit }) {
+		/**
+		* Adapter-driven file picker: mounts and local files as header sources, a flat
+		* (or tree) listing with multi-select, a metadata preview and a selection receipt.
+		*
+		* @example Recommended
+		* ```vue
+		* <FilePicker v-model:open="open" :adapter="usePlatformFilePickerAdapter()" @select="use" />
+		* ```
+		*/
+		const props = __props;
+		const emit = __emit;
+		const uploadError = ref("");
+		const { previewNode, sourceNames, mounts, segments, activeSegment, mountView, allowedSources, source, query, recursive, sort, skipBlanks, reviewing, nav, selection, capability, path, trail, loading, error, rows, roots, chosen, focused, resolving, resolutionError, confirmLabel, folderCount, canConfirm, chooseSegment, clearSelection, selectNode, enter, up, refresh, selectParent, chooseLocal, cancel, confirm, keyboard } = useFilePicker(props, emit, useTemplateRef("searchArea"));
+		const sourceLabel = computed(() => {
+			const node = previewNode.value;
+			if (!mountView.value || !node) return sourceNames[source.value];
+			for (let at = node.path; at; at = nav.nodes.value.get(at)?.parentPath) {
+				const mount = mounts.value.find((item) => item.path === at);
+				if (mount) return mount.name;
+			}
+			return mounts.value.find((item) => item.path === props.adapter.mountOf?.(node.path))?.name ?? sourceNames.server;
+		});
+		const SORT_LABELS = {
+			newest: "Newest first",
+			oldest: "Oldest first",
+			name: "Name A–Z",
+			"name-desc": "Name Z–A"
+		};
+		const sortItems = computed(() => Object.keys(SORT_LABELS).map((id) => ({
+			id,
+			label: SORT_LABELS[id],
+			checked: sort.value === id
+		})));
+		const accepts = computed(() => (capability.value?.formats ?? []).map((format) => `.${format.replace(/^\./, "")}`).join(" "));
+		const summary = computed(() => {
+			if (!roots.value.length) return "No selection";
+			const files = chosen.value.files.length;
+			return [
+				...folderCount.value ? [`${folderCount.value} folder${folderCount.value === 1 ? "" : "s"}`] : [],
+				`${files} file${files === 1 ? "" : "s"} selected`,
+				resolving.value ? "Checking…" : formatBytes(chosen.value.bytes)
+			].join(" · ");
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(BaseModal_default, {
+				open: __props.open,
+				size: "xl",
+				layout: "plain",
+				onClose: unref(cancel)
+			}, {
+				header: withCtx(() => [createElementVNode("div", {
+					class: "mint-picker__head",
+					onKeydown: _cache[1] || (_cache[1] = (...args) => unref(keyboard) && unref(keyboard)(...args))
+				}, [
+					createElementVNode("h2", _hoisted_1$4, toDisplayString(__props.title), 1),
+					unref(segments).length > 1 ? (openBlock(), createBlock(SegmentedControl_default, {
+						key: 0,
+						class: "mint-picker__sources",
+						"aria-label": "Data source",
+						size: "sm",
+						options: unref(segments),
+						"model-value": unref(activeSegment),
+						"onUpdate:modelValue": unref(chooseSegment)
+					}, null, 8, [
+						"options",
+						"model-value",
+						"onUpdate:modelValue"
+					])) : createCommentVNode("", true),
+					unref(source) === "server" ? (openBlock(), createElementBlock("div", _hoisted_2$4, [createVNode(BaseInput_default, {
+						modelValue: unref(query),
+						"onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isRef(query) ? query.value = $event : null),
+						size: "sm",
+						"aria-label": "Search folders and files",
+						placeholder: "Search this source"
+					}, {
+						prefix: withCtx(() => [..._cache[13] || (_cache[13] = [createElementVNode("svg", {
+							viewBox: "0 0 24 24",
+							fill: "none",
+							stroke: "currentColor",
+							"stroke-width": "1.8",
+							"aria-hidden": "true"
+						}, [createElementVNode("circle", {
+							cx: "10.5",
+							cy: "10.5",
+							r: "7"
+						}), createElementVNode("path", { d: "m16 16 5 5" })], -1)])]),
+						suffix: withCtx(() => [..._cache[14] || (_cache[14] = [createElementVNode("kbd", null, "/", -1)])]),
+						_: 1
+					}, 8, ["modelValue"])], 512)) : createCommentVNode("", true)
+				], 32)]),
+				footer: withCtx(() => [createElementVNode("div", _hoisted_16$1, [createElementVNode("div", _hoisted_17$1, [
+					createElementVNode("span", _hoisted_18$1, toDisplayString(summary.value), 1),
+					unref(roots).length ? (openBlock(), createElementBlock("button", {
+						key: 0,
+						type: "button",
+						class: "mint-picker__link mint-picker__clear",
+						onClick: _cache[10] || (_cache[10] = (...args) => unref(clearSelection) && unref(clearSelection)(...args))
+					}, " Clear ")) : createCommentVNode("", true),
+					unref(chosen).excluded.length && unref(source) === "server" ? (openBlock(), createElementBlock("button", {
+						key: 1,
+						type: "button",
+						class: "mint-picker__link",
+						onClick: _cache[11] || (_cache[11] = ($event) => reviewing.value = !unref(reviewing))
+					}, toDisplayString(unref(chosen).excluded.length) + " skipped ", 1)) : unref(chosen).excluded.length ? (openBlock(), createElementBlock("span", _hoisted_19$1, toDisplayString(unref(chosen).excluded.length) + " skipped", 1)) : createCommentVNode("", true),
+					unref(capability)?.isBlank ? (openBlock(), createBlock(BaseButton_default, {
+						key: 3,
+						size: "sm",
+						variant: "ghost",
+						"aria-pressed": unref(skipBlanks),
+						onClick: _cache[12] || (_cache[12] = ($event) => skipBlanks.value = !unref(skipBlanks))
+					}, {
+						default: withCtx(() => [createTextVNode("Skip blanks " + toDisplayString(unref(skipBlanks) ? "on" : "off"), 1)]),
+						_: 1
+					}, 8, ["aria-pressed"])) : createCommentVNode("", true)
+				]), createElementVNode("div", _hoisted_20$1, [createVNode(BaseButton_default, {
+					variant: "ghost",
+					size: "sm",
+					onClick: unref(cancel)
+				}, {
+					default: withCtx(() => [..._cache[18] || (_cache[18] = [createTextVNode("Cancel", -1)])]),
+					_: 1
+				}, 8, ["onClick"]), createVNode(BaseButton_default, {
+					size: "sm",
+					disabled: !unref(canConfirm),
+					onClick: unref(confirm)
+				}, {
+					default: withCtx(() => [createTextVNode(toDisplayString(unref(confirmLabel)), 1)]),
+					_: 1
+				}, 8, ["disabled", "onClick"])])])]),
+				default: withCtx(() => [(openBlock(), createElementBlock("div", {
+					key: unref(source),
+					class: "mint-picker mint-picker__source-panel",
+					onKeydown: _cache[9] || (_cache[9] = (...args) => unref(keyboard) && unref(keyboard)(...args))
+				}, [unref(source) === "server" ? (openBlock(), createElementBlock("div", _hoisted_3$3, [
+					createElementVNode("nav", _hoisted_4$3, [!unref(mountView) ? (openBlock(), createElementBlock("button", {
+						key: 0,
+						type: "button",
+						class: "mint-picker__crumb",
+						"aria-current": unref(trail).length ? void 0 : "location",
+						onClick: _cache[2] || (_cache[2] = ($event) => unref(up)(""))
+					}, toDisplayString(unref(sourceNames)[unref(source)]), 9, _hoisted_5$2)) : createCommentVNode("", true), (openBlock(true), createElementBlock(Fragment, null, renderList(unref(trail), (crumb, index) => {
+						return openBlock(), createElementBlock(Fragment, { key: crumb.path }, [index > 0 || !unref(mountView) ? (openBlock(), createElementBlock("svg", _hoisted_6$2, [..._cache[15] || (_cache[15] = [createElementVNode("path", { d: "M6 4l4 4-4 4" }, null, -1)])])) : createCommentVNode("", true), createElementVNode("button", {
+							type: "button",
+							class: "mint-picker__crumb",
+							"aria-current": index === unref(trail).length - 1 ? "location" : void 0,
+							onClick: ($event) => unref(up)(crumb.path)
+						}, toDisplayString(crumb.label), 9, _hoisted_7$2)], 64);
+					}), 128))]),
+					accepts.value ? (openBlock(), createElementBlock("span", _hoisted_8$2, "Accepts " + toDisplayString(accepts.value), 1)) : createCommentVNode("", true),
+					createVNode(ActionMenu_default, {
+						label: "Sort",
+						items: sortItems.value,
+						onSelect: _cache[3] || (_cache[3] = ($event) => sort.value = $event.id)
+					}, {
+						trigger: withCtx(({ open: menuOpen, toggle, keydown }) => [createElementVNode("button", {
+							type: "button",
+							class: "mint-picker__sort",
+							"aria-haspopup": "menu",
+							"aria-expanded": menuOpen,
+							"aria-label": `Sort: ${SORT_LABELS[unref(sort)]}`,
+							onClick: toggle,
+							onKeydown: keydown
+						}, [createTextVNode(toDisplayString(SORT_LABELS[unref(sort)]) + " ", 1), _cache[16] || (_cache[16] = createElementVNode("svg", {
+							viewBox: "0 0 16 16",
+							fill: "none",
+							stroke: "currentColor",
+							"stroke-width": "1.5",
+							"aria-hidden": "true"
+						}, [createElementVNode("path", { d: "M4 6l4 4 4-4" })], -1))], 40, _hoisted_9$2)]),
+						_: 1
+					}, 8, ["items"]),
+					createElementVNode("button", {
+						type: "button",
+						class: "mint-picker__scope",
+						"aria-pressed": unref(recursive),
+						onClick: _cache[4] || (_cache[4] = ($event) => recursive.value = !unref(recursive))
+					}, toDisplayString(unref(recursive) ? "Subfolders" : "This folder"), 9, _hoisted_10$2),
+					createElementVNode("button", {
+						type: "button",
+						class: "mint-picker__scope mint-picker__refresh",
+						"aria-label": "Refresh location",
+						title: "Refresh location",
+						disabled: unref(loading),
+						onClick: _cache[5] || (_cache[5] = ($event) => unref(refresh)())
+					}, [..._cache[17] || (_cache[17] = [createElementVNode("svg", {
+						viewBox: "0 0 24 24",
+						fill: "none",
+						stroke: "currentColor",
+						"stroke-width": "1.8",
+						"aria-hidden": "true"
+					}, [createElementVNode("path", { d: "M20 7v5h-5M4 17v-5h5M6 8a7 7 0 0 1 12-2l2 3M4 15l2 3a7 7 0 0 0 12-2" })], -1)])], 8, _hoisted_11$2)
+				])) : createCommentVNode("", true), !unref(allowedSources).length ? (openBlock(), createElementBlock("div", _hoisted_12$2, " No data sources are enabled. ")) : (openBlock(), createElementBlock(Fragment, { key: 2 }, [unref(source) === "localFile" ? (openBlock(), createElementBlock("div", _hoisted_13$2, [createVNode(FileUploader_default, {
+					size: "lg",
+					mode: __props.selectionMode === "folder" ? "folder" : __props.selectionMode === "single-file" ? "file" : "file+folder",
+					multiple: __props.selectionMode !== "single-file",
+					"show-files": false,
+					onUpload: _cache[6] || (_cache[6] = (...args) => {
+						uploadError.value = "";
+						unref(chooseLocal)(...args);
+					}),
+					onError: _cache[7] || (_cache[7] = ($event) => uploadError.value = $event)
+				}, null, 8, ["mode", "multiple"]), uploadError.value || unref(error) || unref(resolutionError) ? (openBlock(), createElementBlock("p", _hoisted_14$2, toDisplayString(uploadError.value || unref(error) || unref(resolutionError)), 1)) : createCommentVNode("", true)])) : (openBlock(), createElementBlock("div", _hoisted_15$2, [createVNode(FilePickerListInternal_default, {
+					"empty-title": unref(path) ? "No readable files" : "No server locations configured",
+					view: __props.view,
+					rows: unref(rows),
+					loading: unref(loading),
+					error: unref(error),
+					query: unref(query),
+					truncated: unref(nav).truncated.value,
+					mode: __props.selectionMode,
+					selected: unref(selection).selected,
+					selectable: unref(selection).selectable,
+					exclusion: unref(selection).exclusion,
+					progress: unref(selection).folderProgress,
+					"focus-path": unref(selection).focusPath.value,
+					onSelect: unref(selectNode),
+					onEnter: unref(enter),
+					onExpand: unref(nav).expand,
+					onUp: unref(up),
+					onRetry: unref(refresh),
+					onParent: unref(selectParent)
+				}, null, 8, [
+					"empty-title",
+					"view",
+					"rows",
+					"loading",
+					"error",
+					"query",
+					"truncated",
+					"mode",
+					"selected",
+					"selectable",
+					"exclusion",
+					"progress",
+					"focus-path",
+					"onSelect",
+					"onEnter",
+					"onExpand",
+					"onUp",
+					"onRetry",
+					"onParent"
+				]), createVNode(FilePickerPreviewInternal_default, {
+					node: unref(previewNode),
+					"total-count": unref(focused)?.kind === "folder" ? unref(focused).fileCount : void 0,
+					"source-label": sourceLabel.value,
+					exclusions: unref(chosen).excluded,
+					busy: unref(resolving),
+					error: unref(resolutionError),
+					reviewing: unref(reviewing),
+					onReview: _cache[8] || (_cache[8] = ($event) => reviewing.value = !unref(reviewing)),
+					onRetry: unref(selection).resolve
+				}, null, 8, [
+					"node",
+					"total-count",
+					"source-label",
+					"exclusions",
+					"busy",
+					"error",
+					"reviewing",
+					"onRetry"
+				])]))], 64))], 32))]),
+				_: 1
+			}, 8, ["open", "onClose"]);
+		};
+	}
+});
+//#endregion
+//#region src/components/AuditTrail.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1$3 = {
+	key: 0,
+	class: "mint-audit-trail__filters"
+};
+var _hoisted_2$3 = ["onClick"];
+var _hoisted_3$2 = { class: "mint-audit-trail__content" };
+var _hoisted_4$2 = { class: "mint-audit-trail__header" };
+var _hoisted_5$1 = {
+	key: 0,
+	class: "mint-audit-trail__avatar"
+};
+var _hoisted_6$1 = { class: "mint-audit-trail__sentence" };
+var _hoisted_7$1 = {
+	key: 0,
+	class: "mint-audit-trail__user"
+};
+var _hoisted_8$1 = { class: "mint-audit-trail__action" };
+var _hoisted_9$1 = { class: "mint-audit-trail__timestamp" };
+var _hoisted_10$1 = {
+	key: 0,
+	class: "mint-audit-trail__detail"
+};
+var _hoisted_11$1 = {
+	key: 1,
+	class: "mint-audit-trail__metadata"
+};
+var _hoisted_12$1 = { class: "mint-audit-trail__metadata-key" };
+var _hoisted_13$1 = {
+	key: 2,
+	class: "mint-audit-trail__state"
+};
+var _hoisted_14$1 = {
+	key: 3,
+	class: "mint-audit-trail__state"
+};
+var _hoisted_15$1 = {
+	key: 4,
+	class: "mint-audit-trail__state"
+};
+//#endregion
+//#region src/components/AuditTrail.vue
+var AuditTrail_default = /* @__PURE__ */ defineComponent({
+	__name: "AuditTrail",
+	props: {
+		entries: {},
+		maxHeight: {},
+		showFilters: {
+			type: Boolean,
+			default: false
+		},
+		emptyText: { default: "No activity yet" },
+		order: { default: "newest" },
+		size: { default: "md" },
+		loading: {
+			type: Boolean,
+			default: false
+		},
+		error: { default: null }
+	},
+	emits: ["entry-click"],
+	setup(__props, { emit: __emit }) {
+		/** Filterable, sortable timeline of audit entries for tracking experiment or resource history. */
+		const props = __props;
+		const emit = __emit;
+		const filterType = ref("");
+		const filterUser = ref("");
+		const uniqueTypes = computed(() => {
+			const types = new Set(props.entries.map((e) => e.type));
+			return Array.from(types);
+		});
+		const uniqueUsers = computed(() => {
+			const users = new Set(props.entries.flatMap((e) => e.user ? [e.user] : []));
+			return Array.from(users);
+		});
+		const typeOptions = computed(() => [{
+			value: "",
+			label: "All types"
+		}, ...uniqueTypes.value]);
+		const userOptions = computed(() => [{
+			value: "",
+			label: "All users"
+		}, ...uniqueUsers.value]);
+		const filteredEntries = computed(() => {
+			let result = props.entries;
+			if (filterType.value) result = result.filter((e) => e.type === filterType.value);
+			if (filterUser.value) result = result.filter((e) => e.user === filterUser.value);
+			return result;
+		});
+		const sortedEntries = computed(() => {
+			const entries = [...filteredEntries.value];
+			entries.sort((a, b) => {
+				const timeA = new Date(a.timestamp).getTime();
+				const timeB = new Date(b.timestamp).getTime();
+				return props.order === "newest" ? timeB - timeA : timeA - timeB;
+			});
+			return entries;
+		});
+		function getInitials(name) {
+			const words = name.trim().split(/\s+/);
+			if (words.length >= 2) return (words[0][0] + words[1][0]).toUpperCase();
+			return (words[0]?.[0] ?? "").toUpperCase();
+		}
+		function handleEntryClick(entry) {
+			emit("entry-click", entry);
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", { class: normalizeClass(["mint-audit-trail", `mint-audit-trail--${__props.size}`]) }, [
+				__props.showFilters ? (openBlock(), createElementBlock("div", _hoisted_1$3, [createVNode(BaseSelect_default, {
+					"model-value": filterType.value,
+					options: typeOptions.value,
+					size: "sm",
+					class: "mint-audit-trail__filter-select",
+					"aria-label": "Filter by type",
+					"onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => filterType.value = String($event))
+				}, null, 8, ["model-value", "options"]), createVNode(BaseSelect_default, {
+					"model-value": filterUser.value,
+					options: userOptions.value,
+					size: "sm",
+					class: "mint-audit-trail__filter-select",
+					"aria-label": "Filter by user",
+					"onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => filterUser.value = String($event))
+				}, null, 8, ["model-value", "options"])])) : createCommentVNode("", true),
+				!__props.loading && !__props.error && sortedEntries.value.length ? (openBlock(), createElementBlock("div", {
+					key: 1,
+					class: "mint-audit-trail__list",
+					style: normalizeStyle(__props.maxHeight ? {
+						maxHeight: __props.maxHeight,
+						overflowY: "auto"
+					} : {})
+				}, [_cache[4] || (_cache[4] = createElementVNode("div", { class: "mint-audit-trail__line" }, null, -1)), (openBlock(true), createElementBlock(Fragment, null, renderList(sortedEntries.value, (entry) => {
+					return openBlock(), createElementBlock("div", {
+						key: entry.id,
+						class: normalizeClass(["mint-audit-trail__entry", `mint-audit-trail__entry--${entry.type}`]),
+						onClick: ($event) => handleEntryClick(entry)
+					}, [renderSlot(_ctx.$slots, "entry", { entry }, () => [_cache[3] || (_cache[3] = createElementVNode("div", { class: "mint-audit-trail__dot" }, null, -1)), createElementVNode("div", _hoisted_3$2, [
+						createElementVNode("div", _hoisted_4$2, [
+							entry.user ? (openBlock(), createElementBlock("div", _hoisted_5$1, toDisplayString(getInitials(entry.user)), 1)) : createCommentVNode("", true),
+							createElementVNode("span", _hoisted_6$1, [
+								entry.user ? (openBlock(), createElementBlock("span", _hoisted_7$1, toDisplayString(entry.user), 1)) : createCommentVNode("", true),
+								_cache[2] || (_cache[2] = createTextVNode()),
+								createElementVNode("span", _hoisted_8$1, toDisplayString(entry.action), 1)
+							]),
+							createElementVNode("span", _hoisted_9$1, toDisplayString(unref(formatRelativeTime)(entry.timestamp, { weeks: true })), 1)
+						]),
+						entry.detail ? (openBlock(), createElementBlock("div", _hoisted_10$1, toDisplayString(entry.detail), 1)) : createCommentVNode("", true),
+						entry.metadata && Object.keys(entry.metadata).length ? (openBlock(), createElementBlock("div", _hoisted_11$1, [(openBlock(true), createElementBlock(Fragment, null, renderList(entry.metadata, (value, key) => {
+							return openBlock(), createElementBlock("span", {
+								key: String(key),
+								class: "mint-audit-trail__metadata-item"
+							}, [createElementVNode("span", _hoisted_12$1, toDisplayString(key) + ":", 1), createTextVNode(" " + toDisplayString(value), 1)]);
+						}), 128))])) : createCommentVNode("", true)
+					])])], 10, _hoisted_2$3);
+				}), 128))], 4)) : createCommentVNode("", true),
+				__props.error ? (openBlock(), createElementBlock("div", _hoisted_13$1, [renderSlot(_ctx.$slots, "error", { error: __props.error }, () => [createVNode(DataStateInternal_default, {
+					state: "error",
+					size: "sm",
+					title: __props.error
+				}, null, 8, ["title"])])])) : __props.loading ? (openBlock(), createElementBlock("div", _hoisted_14$1, [renderSlot(_ctx.$slots, "loading", {}, () => [createVNode(DataStateInternal_default, {
+					state: "loading",
+					size: "sm",
+					"loading-label": "Loading activity"
+				})])])) : !sortedEntries.value.length ? (openBlock(), createElementBlock("div", _hoisted_15$1, [renderSlot(_ctx.$slots, "empty", {}, () => [createVNode(DataStateInternal_default, {
+					state: "empty",
+					size: "sm",
+					title: __props.emptyText
+				}, null, 8, ["title"])])])) : createCommentVNode("", true)
+			], 2);
+		};
+	}
+});
+//#endregion
+//#region src/components/BatchProgressList.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1$2 = { class: "mint-batch-progress" };
+var _hoisted_2$2 = {
+	key: 0,
+	class: "mint-batch-progress__header"
+};
+var _hoisted_3$1 = { class: "mint-batch-progress__title" };
+var _hoisted_4$1 = { class: "mint-batch-progress__count" };
+var _hoisted_5 = { class: "mint-batch-progress__percent" };
+var _hoisted_6 = { class: "mint-batch-progress__overall" };
+var _hoisted_7 = { class: "mint-batch-progress__summary" };
+var _hoisted_8 = {
+	key: 0,
+	class: "mint-batch-progress__summary-item mint-batch-progress__summary-item--completed"
+};
+var _hoisted_9 = { class: "mint-batch-progress__summary-count" };
+var _hoisted_10 = {
+	key: 1,
+	class: "mint-batch-progress__summary-item mint-batch-progress__summary-item--processing"
+};
+var _hoisted_11 = { class: "mint-batch-progress__summary-count" };
+var _hoisted_12 = {
+	key: 2,
+	class: "mint-batch-progress__summary-item mint-batch-progress__summary-item--error"
+};
+var _hoisted_13 = { class: "mint-batch-progress__summary-count" };
+var _hoisted_14 = {
+	key: 3,
+	class: "mint-batch-progress__summary-item mint-batch-progress__summary-item--pending"
+};
+var _hoisted_15 = { class: "mint-batch-progress__summary-count" };
+var _hoisted_16 = {
+	key: 4,
+	class: "mint-batch-progress__summary-item mint-batch-progress__summary-item--skipped"
+};
+var _hoisted_17 = { class: "mint-batch-progress__summary-count" };
+var _hoisted_18 = {
+	key: 2,
+	class: "mint-batch-progress__state"
+};
+var _hoisted_19 = {
+	key: 3,
+	class: "mint-batch-progress__state"
+};
+var _hoisted_20 = {
+	key: 4,
+	class: "mint-batch-progress__state"
+};
+var _hoisted_21 = ["data-item-id"];
+var _hoisted_22 = { class: "mint-batch-progress__item-row" };
+var _hoisted_23 = { class: "mint-batch-progress__item-label" };
+var _hoisted_24 = { class: "mint-batch-progress__item-meta" };
+var _hoisted_25 = { class: "mint-batch-progress__item-status" };
+var _hoisted_26 = ["onClick"];
+var _hoisted_27 = ["onClick"];
+var _hoisted_28 = {
+	class: "mint-batch-progress__item-progress",
+	"aria-hidden": "true"
+};
+var _hoisted_29 = {
+	key: 0,
+	class: "mint-batch-progress__item-message"
+};
+//#endregion
+//#region src/components/BatchProgressList.vue
+var BatchProgressList_default = /* @__PURE__ */ defineComponent({
+	__name: "BatchProgressList",
+	props: {
+		items: {},
+		showSummary: {
+			type: Boolean,
+			default: true
+		},
+		title: {},
+		maxHeight: {},
+		autoScroll: {
+			type: Boolean,
+			default: true
+		},
+		loading: {
+			type: Boolean,
+			default: false
+		},
+		error: { default: null },
+		emptyText: { default: "No items in this batch" }
+	},
+	emits: ["retry", "cancel"],
+	setup(__props, { emit: __emit }) {
+		/** Scrollable list tracking per-item status for a batch operation with overall progress summary. */
+		const props = __props;
+		const emit = __emit;
+		const STATUS_ICONS = {
+			completed: CircleCheck,
+			processing: Loader,
+			pending: CircleDashed,
+			error: CircleX,
+			skipped: CircleMinus
+		};
+		const STATUS_TEXT = {
+			pending: "Queued",
+			error: "Failed",
+			skipped: "Skipped"
+		};
+		function itemPercent(item) {
+			return item.status === "completed" ? 100 : item.progress ?? 0;
+		}
+		function statusText(item) {
+			return STATUS_TEXT[item.status] ?? `${itemPercent(item)}%`;
+		}
+		const listRef = ref(null);
+		const showCompleted = ref(false);
+		const visibleItems = computed(() => showCompleted.value ? props.items : props.items.filter((i) => i.status !== "completed"));
+		const summary = computed(() => {
+			const total = props.items.length;
+			const completed = props.items.filter((i) => i.status === "completed").length;
+			const processing = props.items.filter((i) => i.status === "processing").length;
+			const error = props.items.filter((i) => i.status === "error").length;
+			const pending = props.items.filter((i) => i.status === "pending").length;
+			const skipped = props.items.filter((i) => i.status === "skipped").length;
+			return {
+				total,
+				completed,
+				processing,
+				error,
+				pending,
+				skipped,
+				percent: total > 0 ? Math.round((completed + skipped) / total * 100) : 0
+			};
+		});
+		watch(() => props.items.map((i) => i.status), (newStatuses, oldStatuses) => {
+			if (!props.autoScroll || !listRef.value) return;
+			for (let i = 0; i < newStatuses.length; i++) if (newStatuses[i] === "processing" && oldStatuses?.[i] !== "processing") {
+				nextTick(() => {
+					(listRef.value?.querySelector(`[data-item-id="${props.items[i].id}"]`))?.scrollIntoView({
+						behavior: "smooth",
+						block: "center"
+					});
+				});
+				break;
+			}
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", _hoisted_1$2, [
+				__props.title ? (openBlock(), createElementBlock("div", _hoisted_2$2, [
+					createElementVNode("span", _hoisted_3$1, toDisplayString(__props.title), 1),
+					createElementVNode("span", _hoisted_4$1, toDisplayString(summary.value.completed) + " / " + toDisplayString(summary.value.total), 1),
+					createElementVNode("span", _hoisted_5, toDisplayString(summary.value.percent) + "%", 1)
+				])) : createCommentVNode("", true),
+				createElementVNode("div", _hoisted_6, [createElementVNode("div", {
+					class: "mint-batch-progress__overall-bar",
+					style: normalizeStyle({ width: `${summary.value.percent}%` })
+				}, null, 4)]),
+				__props.showSummary ? renderSlot(_ctx.$slots, "summary", { summary: summary.value }, () => [createElementVNode("div", _hoisted_7, [
+					summary.value.completed ? (openBlock(), createElementBlock("span", _hoisted_8, [
+						_cache[1] || (_cache[1] = createElementVNode("svg", {
+							class: "mint-batch-progress__shape",
+							viewBox: "0 0 16 16",
+							fill: "none",
+							"aria-hidden": "true"
+						}, [createElementVNode("path", {
+							class: "mint-batch-progress__check",
+							d: "M3.5 8.5l3 3 6-7"
+						})], -1)),
+						createElementVNode("span", _hoisted_9, toDisplayString(summary.value.completed), 1),
+						_cache[2] || (_cache[2] = createTextVNode(" completed ", -1))
+					])) : createCommentVNode("", true),
+					summary.value.processing ? (openBlock(), createElementBlock("span", _hoisted_10, [
+						_cache[3] || (_cache[3] = createElementVNode("span", {
+							class: "mint-batch-progress__running-dot",
+							"aria-hidden": "true"
+						}, null, -1)),
+						createElementVNode("span", _hoisted_11, toDisplayString(summary.value.processing), 1),
+						_cache[4] || (_cache[4] = createTextVNode(" processing ", -1))
+					])) : createCommentVNode("", true),
+					summary.value.error ? (openBlock(), createElementBlock("span", _hoisted_12, [
+						_cache[5] || (_cache[5] = createElementVNode("svg", {
+							class: "mint-batch-progress__shape",
+							viewBox: "0 0 16 16",
+							"aria-hidden": "true"
+						}, [createElementVNode("circle", {
+							class: "mint-batch-progress__error-disc",
+							cx: "8",
+							cy: "8",
+							r: "7"
+						}), createElementVNode("path", {
+							class: "mint-batch-progress__error-mark",
+							d: "M8 4.5v4M8 11v.01"
+						})], -1)),
+						createElementVNode("span", _hoisted_13, toDisplayString(summary.value.error), 1),
+						_cache[6] || (_cache[6] = createTextVNode(" failed ", -1))
+					])) : createCommentVNode("", true),
+					summary.value.pending ? (openBlock(), createElementBlock("span", _hoisted_14, [
+						_cache[7] || (_cache[7] = createElementVNode("span", {
+							class: "mint-batch-progress__pending-ring",
+							"aria-hidden": "true"
+						}, null, -1)),
+						createElementVNode("span", _hoisted_15, toDisplayString(summary.value.pending), 1),
+						_cache[8] || (_cache[8] = createTextVNode(" pending ", -1))
+					])) : createCommentVNode("", true),
+					summary.value.skipped ? (openBlock(), createElementBlock("span", _hoisted_16, [
+						_cache[9] || (_cache[9] = createElementVNode("svg", {
+							class: "mint-batch-progress__shape",
+							viewBox: "0 0 16 16",
+							fill: "none",
+							"aria-hidden": "true"
+						}, [createElementVNode("path", {
+							class: "mint-batch-progress__dash",
+							d: "M4 8h8"
+						})], -1)),
+						createElementVNode("span", _hoisted_17, toDisplayString(summary.value.skipped), 1),
+						_cache[10] || (_cache[10] = createTextVNode(" skipped ", -1))
+					])) : createCommentVNode("", true)
+				])], void 0, 1) : createCommentVNode("", true),
+				__props.error ? (openBlock(), createElementBlock("div", _hoisted_18, [renderSlot(_ctx.$slots, "error", { error: __props.error }, () => [createVNode(DataStateInternal_default, {
+					state: "error",
+					size: "sm",
+					title: __props.error
+				}, null, 8, ["title"])])])) : __props.loading ? (openBlock(), createElementBlock("div", _hoisted_19, [renderSlot(_ctx.$slots, "loading", {}, () => [createVNode(DataStateInternal_default, {
+					state: "loading",
+					size: "sm",
+					"loading-label": "Loading batch"
+				})])])) : __props.items.length === 0 ? (openBlock(), createElementBlock("div", _hoisted_20, [renderSlot(_ctx.$slots, "empty", {}, () => [createVNode(DataStateInternal_default, {
+					state: "empty",
+					size: "sm",
+					title: __props.emptyText
+				}, null, 8, ["title"])])])) : (openBlock(), createElementBlock("div", {
+					key: 5,
+					ref_key: "listRef",
+					ref: listRef,
+					class: "mint-batch-progress__list",
+					style: normalizeStyle(__props.maxHeight ? {
+						maxHeight: __props.maxHeight,
+						overflowY: "auto"
+					} : {})
+				}, [(openBlock(true), createElementBlock(Fragment, null, renderList(visibleItems.value, (item) => {
+					return openBlock(), createElementBlock("div", {
+						key: item.id,
+						"data-item-id": item.id,
+						class: normalizeClass(["mint-batch-progress__item", `mint-batch-progress__item--${item.status}`])
+					}, [renderSlot(_ctx.$slots, "item", { item }, () => [createElementVNode("div", _hoisted_22, [
+						(openBlock(), createBlock(resolveDynamicComponent(STATUS_ICONS[item.status]), {
+							class: normalizeClass(["mint-batch-progress__item-icon", `mint-batch-progress__item-icon--${item.status}`]),
+							size: 16,
+							"aria-hidden": "true"
+						}, null, 8, ["class"])),
+						createElementVNode("span", _hoisted_23, toDisplayString(item.label), 1),
+						createElementVNode("span", _hoisted_24, [
+							createElementVNode("span", _hoisted_25, toDisplayString(statusText(item)), 1),
+							item.status === "error" ? (openBlock(), createElementBlock("button", {
+								key: 0,
+								type: "button",
+								class: "mint-batch-progress__retry-btn",
+								onClick: withModifiers(($event) => emit("retry", item.id), ["stop"])
+							}, " Retry ", 8, _hoisted_26)) : createCommentVNode("", true),
+							item.status === "processing" ? (openBlock(), createElementBlock("button", {
+								key: 1,
+								type: "button",
+								class: "mint-batch-progress__cancel-btn",
+								onClick: withModifiers(($event) => emit("cancel", item.id), ["stop"])
+							}, " Cancel ", 8, _hoisted_27)) : createCommentVNode("", true)
+						]),
+						createElementVNode("span", _hoisted_28, [createElementVNode("span", {
+							class: "mint-batch-progress__item-progress-bar",
+							style: normalizeStyle({ width: `${itemPercent(item)}%` })
+						}, null, 4)])
+					]), item.status === "error" && item.message ? (openBlock(), createElementBlock("div", _hoisted_29, toDisplayString(item.message), 1)) : createCommentVNode("", true)])], 10, _hoisted_21);
+				}), 128)), summary.value.completed ? (openBlock(), createElementBlock("button", {
+					key: 0,
+					type: "button",
+					class: "mint-batch-progress__completed-toggle",
+					onClick: _cache[0] || (_cache[0] = ($event) => showCompleted.value = !showCompleted.value)
+				}, toDisplayString(showCompleted.value ? "Hide completed" : `Show ${summary.value.completed} completed`), 1)) : createCommentVNode("", true)], 4))
+			]);
+		};
+	}
+});
+//#endregion
+//#region src/components/VersionConflictDialog.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1$1 = { class: "mint-version-conflict__message" };
+var _hoisted_2$1 = { class: "mint-version-conflict__footer" };
+//#endregion
+//#region src/components/VersionConflictDialog.vue
+var VersionConflictDialog_default = /* @__PURE__ */ defineComponent({
+	__name: "VersionConflictDialog",
+	props: {
+		open: { type: Boolean },
+		entity: { default: "" },
+		changes: { default: () => [] },
+		loading: {
+			type: Boolean,
+			default: false
+		}
+	},
+	emits: [
+		"update:open",
+		"reload",
+		"overwrite"
+	],
+	setup(__props, { emit: __emit }) {
+		/**
+		* The dialog for a save refused with 412 `<entity>.version_conflict` (RFC #439).
+		* Show it while `useVersionedSave().conflict` is set: Reload discards the
+		* user's edits and refetches, Overwrite saves them on top of the newer version.
+		*/
+		const props = __props;
+		const emit = __emit;
+		const message = computed(() => {
+			const count = props.changes.length;
+			if (count === 0) return "Your changes are not saved. Pick what to keep.";
+			const [noun, verb] = count === 1 ? ["change", "is"] : ["changes", "are"];
+			return `Your ${count} ${noun} (${props.changes.join(", ")}) ${verb} not saved. Pick what to keep.`;
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(BaseModal_default, {
+				open: __props.open,
+				title: "Changed by someone else",
+				subtitle: __props.entity || void 0,
+				size: "md",
+				closable: !__props.loading,
+				"close-on-escape": !__props.loading,
+				"onUpdate:open": _cache[2] || (_cache[2] = ($event) => emit("update:open", $event))
+			}, {
+				footer: withCtx(() => [createElementVNode("div", _hoisted_2$1, [createVNode(BaseButton_default, {
+					type: "button",
+					variant: "secondary",
+					size: "sm",
+					class: "mint-version-conflict__overwrite",
+					loading: __props.loading,
+					onClick: _cache[0] || (_cache[0] = ($event) => emit("overwrite"))
+				}, {
+					default: withCtx(() => [..._cache[3] || (_cache[3] = [createTextVNode(" Overwrite ", -1)])]),
+					_: 1
+				}, 8, ["loading"]), createVNode(BaseButton_default, {
+					type: "button",
+					variant: "primary",
+					size: "sm",
+					icon: unref(RefreshCw),
+					disabled: __props.loading,
+					onClick: _cache[1] || (_cache[1] = ($event) => emit("reload"))
+				}, {
+					default: withCtx(() => [..._cache[4] || (_cache[4] = [createTextVNode(" Reload and discard mine ", -1)])]),
+					_: 1
+				}, 8, ["icon", "disabled"])])]),
+				default: withCtx(() => [createElementVNode("p", _hoisted_1$1, toDisplayString(message.value), 1)]),
+				_: 1
+			}, 8, [
+				"open",
+				"subtitle",
+				"closable",
+				"close-on-escape"
+			]);
+		};
+	}
+});
+//#endregion
+//#region src/components/StaleFormBanner.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = {
+	class: "mint-stale-banner",
+	role: "status"
+};
+var _hoisted_2 = { class: "mint-stale-banner__text" };
+var _hoisted_3 = ["datetime"];
+var _hoisted_4 = ["href"];
+//#endregion
+//#region src/components/StaleFormBanner.vue
+var StaleFormBanner_default = /* @__PURE__ */ defineComponent({
+	__name: "StaleFormBanner",
+	props: {
+		change: {},
+		reviewHref: { default: "" },
+		entityNoun: { default: "this record" }
+	},
+	emits: ["reload", "dismiss"],
+	setup(__props, { emit: __emit }) {
+		/**
+		* The strip at the top of a form whose entity someone else changed while the
+		* form held unsaved edits (RFC #439). Show it while `useVersionedSave().stale`
+		* is set. It offers Reload and Review, not Overwrite: a save that would
+		* overwrite gets the 412 dialog.
+		*/
+		const props = __props;
+		const emit = __emit;
+		/** "A", "A and B", "A, B and C". */
+		function list(items) {
+			if (items.length <= 1) return items[0] ?? "";
+			return `${items.slice(0, -1).join(", ")} and ${items[items.length - 1]}`;
+		}
+		const summary = computed(() => {
+			const { actors, fields } = props.change;
+			const what = fields.length === 0 ? props.entityNoun : fields.length <= 2 ? list(fields) : `${fields.length} fields`;
+			return `${list(actors)} changed ${what}`;
+		});
+		const now = ref(Date.now());
+		const timer = setInterval(() => {
+			now.value = Date.now();
+		}, 5e3);
+		onBeforeUnmount(() => clearInterval(timer));
+		const ago = computed(() => {
+			const seconds = Math.max(0, Math.round((now.value - Date.parse(props.change.at)) / 1e3));
+			if (seconds < 60) return `${seconds} s ago`;
+			const minutes = Math.round(seconds / 60);
+			if (minutes < 60) return `${minutes} min ago`;
+			return `${Math.round(minutes / 60)} h ago`;
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", _hoisted_1, [
+				createVNode(unref(TriangleAlert), {
+					class: "mint-stale-banner__icon",
+					"aria-hidden": "true"
+				}),
+				createElementVNode("p", _hoisted_2, [
+					createElementVNode("strong", null, toDisplayString(summary.value), 1),
+					_cache[2] || (_cache[2] = createTextVNode(" " + toDisplayString(" "), -1)),
+					createElementVNode("time", {
+						class: "mint-stale-banner__time",
+						datetime: __props.change.at
+					}, toDisplayString(ago.value), 9, _hoisted_3),
+					_cache[3] || (_cache[3] = createTextVNode(". This form shows the older version. ", -1))
+				]),
+				__props.reviewHref ? (openBlock(), createElementBlock("a", {
+					key: 0,
+					class: "mint-stale-banner__action",
+					href: __props.reviewHref,
+					target: "_blank",
+					rel: "noopener"
+				}, "Review", 8, _hoisted_4)) : createCommentVNode("", true),
+				createElementVNode("button", {
+					type: "button",
+					class: "mint-stale-banner__action",
+					onClick: _cache[0] || (_cache[0] = ($event) => emit("reload"))
+				}, "Reload form"),
+				createElementVNode("button", {
+					type: "button",
+					class: "mint-stale-banner__dismiss",
+					"aria-label": "Dismiss until the next change",
+					onClick: _cache[1] || (_cache[1] = ($event) => emit("dismiss"))
+				}, [createVNode(unref(X), { "aria-hidden": "true" })])
+			]);
+		};
+	}
+});
+//#endregion
+//#region src/composables/useVersionedSave.ts
+/** `end_date` → "End date". */
+function fieldNameLabel(field) {
+	const words = field.replace(/_/g, " ").trim();
+	return words.charAt(0).toUpperCase() + words.slice(1);
+}
+function conflictVersion(cause) {
+	if (!(cause instanceof MintApiError) || cause.status !== 412) return null;
+	const version = cause.details?.version;
+	return { version: typeof version === "number" ? version : null };
+}
+function union(list, items) {
+	return [.../* @__PURE__ */ new Set([...list, ...items])];
+}
+/**
+* Optimistic-concurrency save for a form on a versioned entity (RFC #439).
+*
+* `save()` sends `If-Match` with the loaded version. A 412 sets `conflict`;
+* show `VersionConflictDialog` for it, whose Reload calls `reload()` and
+* whose Overwrite calls `overwrite()` (the same save, with the version from
+* the 412). With a `topic`, a realtime write by someone else on the entity
+* sets `stale` while the form is dirty (show `StaleFormBanner`); on a clean
+* form it runs the `reload` option instead. Several writes merge into one
+* `stale`.
+*
+* @example
+* const versioned = useVersionedSave({
+*   version: () => experiment.value?.version,
+*   save: headers => api.patch(`/experiments/${id}`, payload(), { headers }),
+*   reload: () => refetchAndResetForm(),
+*   topic: () => (realtime && open.value ? `experiment:${id}` : null),
+*   dirty: () => changeCount.value > 0,
+* })
+*/
+function useVersionedSave(options) {
+	const saving = ref(false);
+	const conflict = ref(null);
+	const stale = ref(null);
+	const fieldLabel = options.fieldLabel ?? fieldNameLabel;
+	async function send(version) {
+		saving.value = true;
+		try {
+			const headers = version == null ? {} : { "If-Match": `"v${version}"` };
+			const result = await options.save(headers);
+			conflict.value = null;
+			stale.value = null;
+			return result;
+		} catch (cause) {
+			const refused = conflictVersion(cause);
+			if (!refused) throw cause;
+			conflict.value = refused;
+			return;
+		} finally {
+			saving.value = false;
+		}
+	}
+	async function reload() {
+		await options.reload();
+		conflict.value = null;
+		stale.value = null;
+	}
+	function onEvent(event) {
+		if (event.type === "resync" || saving.value || event.topic !== toValue(options.topic)) return;
+		if (!toValue(options.dirty)) {
+			reload().catch(() => {});
+			return;
+		}
+		const actor = event.actor_id && options.userName?.(event.actor_id) || "Someone";
+		const previous = stale.value;
+		stale.value = {
+			actors: union(previous?.actors ?? [], [actor]),
+			fields: union(previous?.fields ?? [], (event.fields ?? []).map(fieldLabel)),
+			at: event.at ?? (/* @__PURE__ */ new Date()).toISOString()
+		};
+	}
+	useRealtime(() => {
+		const topic = toValue(options.topic);
+		return topic ? [topic] : [];
+	}, onEvent);
+	watch(() => toValue(options.topic), () => {
+		conflict.value = null;
+		stale.value = null;
+	});
+	return {
+		save: () => send(toValue(options.version)),
+		overwrite: () => send(conflict.value?.version),
+		reload,
+		dismissConflict: () => {
+			conflict.value = null;
+		},
+		dismissStale: () => {
+			stale.value = null;
+		},
+		saving: readonly(saving),
+		conflict: readonly(conflict),
+		stale: readonly(stale)
+	};
+}
+//#endregion
+//#region src/composables/createFilePickerAdapter.ts
+/** Opaque picker identity; decode before passing a selection to a mount-scoped API. */
+function encodePlatformPickerPath(mountId, path = "") {
+	return JSON.stringify([mountId, path]);
+}
+function decodePlatformPickerPath(path) {
+	const decoded = JSON.parse(path);
+	if (!Array.isArray(decoded) || decoded.length !== 2 || !decoded.every((item) => typeof item === "string") || !decoded[0]) throw new Error("Invalid platform picker path.");
+	return {
+		mountId: decoded[0],
+		path: decoded[1]
+	};
+}
+function isRelativePath(path) {
+	return path === "" || !/^[a-z]:/i.test(path) && !/[\\\x00-\x1f\x7f]/.test(path) && path.split("/").every((part) => part !== "" && part !== "." && part !== "..");
+}
+/** Mount browsing and search shared by platform and generated plugin clients. */
+function createFilePickerAdapter(transport, options = {}) {
+	const root = options.rootLocation && { ...options.rootLocation };
+	const mountLabels = /* @__PURE__ */ new Map();
+	const listings = /* @__PURE__ */ new Map();
+	let generation = 0;
+	function invalidate() {
+		generation++;
+		listings.clear();
+		mountLabels.clear();
+	}
+	function validateLocation(location) {
+		if (!location.mount_id || !isRelativePath(location.path) || root && (location.mount_id !== root.mount_id || root.path !== "" && location.path !== root.path && !location.path.startsWith(`${root.path}/`))) throw new Error("Invalid file picker location.");
+	}
+	if (root) validateLocation(root);
+	function begin(request) {
+		request?.signal?.throwIfAborted();
+		if (request?.refresh) invalidate();
+		return generation;
+	}
+	function check(request, token) {
+		request?.signal?.throwIfAborted();
+		if (token !== generation) throw new DOMException("Cancelled", "AbortError");
+	}
+	async function read(path, request, token) {
+		check(request, token);
+		const decoded = path ? decodePlatformPickerPath(path) : void 0;
+		const location = decoded ? {
+			mount_id: decoded.mountId,
+			path: decoded.path
+		} : root;
+		if (location) validateLocation(location);
+		const key = location ? encodePlatformPickerPath(location.mount_id, location.path) : "";
+		const cached = listings.get(key);
+		if (cached) return cached;
+		let nodes;
+		if (!location) {
+			const mounts = await transport.listMounts(request);
+			check(request, token);
+			nodes = mounts.map((mount) => {
+				mountLabels.set(mount.id, mount.label);
+				return {
+					kind: "folder",
+					path: encodePlatformPickerPath(mount.id),
+					name: mount.label,
+					parentPath: null,
+					parentName: "Server mounts",
+					unavailableReason: mount.available === false ? "This mount is offline." : void 0
+				};
+			});
+		} else if (transport.tree) {
+			const tree = await transport.tree(location, request);
+			check(request, token);
+			for (const listing of tree.listings ?? []) {
+				const at = {
+					mount_id: listing.mount_id,
+					path: listing.path
+				};
+				validateLocation(at);
+				if (at.mount_id !== location.mount_id) throw new Error("Invalid file picker directory entry.");
+				if (!listing.truncated) listings.set(encodePlatformPickerPath(at.mount_id, at.path), toNodes(at, listing));
+			}
+			const cached = listings.get(key);
+			if (!cached) throw new Error("This directory exceeds the server listing limit. Choose a smaller data directory.");
+			return cached;
+		} else {
+			const listing = await transport.browse(location, request);
+			check(request, token);
+			if (listing.truncated) throw new Error("This directory exceeds the server listing limit. Choose a smaller data directory.");
+			nodes = toNodes(location, listing);
+		}
+		listings.set(key, nodes);
+		return nodes;
+	}
+	function toNodes(location, listing) {
+		return (listing.entries ?? []).map((entry) => {
+			if (entry.path !== `${location.path ? `${location.path}/` : ""}${entry.name}`) throw new Error("Invalid file picker directory entry.");
+			return toNode(location.mount_id, entry);
+		});
+	}
+	/** One entry, parented on the folder its mount-relative path names. */
+	function toNode(mountId, entry) {
+		if (!isRelativePath(entry.path) || !entry.name || entry.name.includes("/") || entry.path !== entry.name && !entry.path.endsWith(`/${entry.name}`)) throw new Error("Invalid file picker directory entry.");
+		const parent = entry.path.slice(0, Math.max(0, entry.path.length - entry.name.length - 1));
+		const atRoot = root && mountId === root.mount_id && parent === root.path;
+		const common = {
+			path: encodePlatformPickerPath(mountId, entry.path),
+			parentPath: atRoot ? null : encodePlatformPickerPath(mountId, parent),
+			parentName: `${mountLabels.get(mountId) ?? mountId}${parent ? ` / ${parent}` : ""}`,
+			name: entry.name,
+			bytes: entry.size_bytes,
+			modifiedAt: entry.modified_at
+		};
+		return entry.kind === "directory" ? {
+			...common,
+			kind: "folder"
+		} : {
+			...common,
+			kind: "file",
+			format: pickerFormat(entry.name)
+		};
+	}
+	async function serverSearch(query, scope, request) {
+		const token = begin(request);
+		const decoded = scope.path ? decodePlatformPickerPath(scope.path) : void 0;
+		const location = decoded ? {
+			mount_id: decoded.mountId,
+			path: decoded.path
+		} : root;
+		validateLocation(location);
+		const result = await transport.search(location, query, scope.recursive, request);
+		check(request, token);
+		const prefix = location.path ? `${location.path}/` : "";
+		const nodes = (result.entries ?? []).map((entry) => {
+			if (!entry.path.startsWith(prefix) || !scope.recursive && entry.path.slice(prefix.length).includes("/")) throw new Error("Invalid file picker directory entry.");
+			return toNode(location.mount_id, entry);
+		});
+		return result.truncated ? {
+			nodes,
+			truncated: true
+		} : nodes;
+	}
+	return {
+		mounts: !root,
+		mountOf(path) {
+			try {
+				return encodePlatformPickerPath(decodePlatformPickerPath(path).mountId);
+			} catch {
+				return;
+			}
+		},
+		invalidate,
+		listRoot: async (request) => read("", request, begin(request)),
+		listChildren: async (path, request) => read(path, request, begin(request)),
+		async search(query, scope, request) {
+			if (transport.search && (scope.path || root)) return serverSearch(query, scope, request);
+			const token = begin(request);
+			const matches = [];
+			const queue = [scope.path];
+			const visited = /* @__PURE__ */ new Set();
+			const needle = query.toLowerCase();
+			let currentRequest = request;
+			while (queue.length) {
+				check(request, token);
+				const path = queue.shift();
+				if (visited.has(path)) continue;
+				visited.add(path);
+				if (visited.size > 500) return {
+					nodes: matches,
+					truncated: true
+				};
+				const nodes = await read(path, currentRequest, token);
+				check(request, token);
+				if (currentRequest?.refresh) {
+					currentRequest = { ...currentRequest };
+					delete currentRequest.refresh;
+				}
+				for (const node of nodes) {
+					if (node.name.toLowerCase().includes(needle)) matches.push(node);
+					if (scope.recursive && node.kind === "folder" && !node.unavailableReason) queue.push(node.path);
+				}
+				if (matches.length > 1e4) return {
+					nodes: matches.slice(0, 1e4),
+					truncated: true
+				};
+			}
+			return matches;
+		}
+	};
+}
+//#endregion
+//#region src/composables/usePlatformFilePickerAdapter.ts
+function query(location, request) {
+	const params = new URLSearchParams({
+		mount_id: location.mount_id,
+		path: location.path
+	});
+	if (request?.refresh) params.set("refresh", "true");
+	return params;
+}
+/** Adapt the authenticated MINT mount API without exposing absolute host paths. */
+function usePlatformFilePickerAdapter(options = {}) {
+	const api = useApi({ baseUrl: options.apiBaseUrl ?? getInjectedPlatformContext()?.platformApiUrl });
+	return createFilePickerAdapter({
+		async listMounts(request) {
+			try {
+				const url = `/filesystem/mounts${request?.refresh ? "?refresh=true" : ""}`;
+				const { mounts } = await api.get(url, { signal: request?.signal });
+				return mounts;
+			} catch (cause) {
+				if (cause instanceof MintApiError && cause.status === 404) return [];
+				throw cause;
+			}
+		},
+		browse(location, request) {
+			return api.get(`/filesystem/browse?${query(location, request)}`, { signal: request?.signal });
+		},
+		tree(location, request) {
+			return api.get(`/filesystem/tree?${query(location, request)}`, { signal: request?.signal });
+		},
+		search(location, text, recursive, request) {
+			const params = query(location, request);
+			params.set("q", text);
+			params.set("recursive", String(recursive));
+			return api.get(`/filesystem/search?${params}`, { signal: request?.signal });
+		}
+	}, options);
+}
+//#endregion
+//#region src/composables/useFileBrowser.ts
+/**
+* Browses the platform's `/api/filesystem` routes for a custom file UI. For the
+* ready-made dialog, use `FilePicker` with `usePlatformFilePickerAdapter()`.
+*
+* Requires the `filesystem.browse` permission and a deployment that declares
+* mounts; with none configured the routes are absent and `mounts` stays empty.
+*/
+function useFileBrowser(options = {}) {
+	const injectedContext = getInjectedPlatformContext();
+	const api = useApi({ baseUrl: options.apiBaseUrl ?? injectedContext?.platformApiUrl });
+	const sync = useRequest("Could not read the server mounts.");
+	const mounts = ref([]);
+	const mountId = shallowRef("");
+	const path = shallowRef("");
+	const parent = ref(null);
+	const entries = ref([]);
+	const breadcrumbs = ref([]);
+	const totalCount = ref(null);
+	const matchCount = ref(null);
+	const shownCount = ref(null);
+	const truncated = ref(false);
+	const search = shallowRef("");
+	const sort = shallowRef("name");
+	const selected = ref([]);
+	const mountsLoading = shallowRef(false);
+	const listingLoading = shallowRef(false);
+	const listingReady = shallowRef(false);
+	const isLoading = computed(() => mountsLoading.value || listingLoading.value);
+	let listToken = 0;
+	let mountsToken = 0;
+	let disposed = false;
+	let listingController;
+	let mountsController;
+	let searchTimer;
+	function resetListing() {
+		listingReady.value = false;
+		entries.value = [];
+		breadcrumbs.value = [];
+		parent.value = null;
+		totalCount.value = null;
+		matchCount.value = null;
+		shownCount.value = null;
+		truncated.value = false;
+	}
+	function typeRuleParams() {
+		return (toValue(options.typeRules) ?? []).map((rule) => `&type_rules=${encodeURIComponent(rule)}`).join("");
+	}
+	function fail(cause, fallback) {
+		sync.setError(new Error(sync.readErrorMessage(cause, fallback)), fallback);
+	}
+	function statusOf(cause) {
+		return cause instanceof MintApiError ? cause.status : void 0;
+	}
+	async function loadMounts() {
+		const token = ++mountsToken;
+		mountsController?.abort();
+		mountsController = new AbortController();
+		mountsLoading.value = true;
+		try {
+			const data = await api.get("/filesystem/mounts", { signal: mountsController.signal });
+			if (disposed || token !== mountsToken) return false;
+			mounts.value = data.mounts ?? [];
+			sync.clearError();
+			return true;
+		} catch (cause) {
+			if (disposed || token !== mountsToken) return false;
+			if (statusOf(cause) === 404) {
+				mounts.value = [];
+				sync.clearError();
+				return true;
+			}
+			mounts.value = [];
+			fail(cause, "Could not read the server mounts.");
+			return false;
+		} finally {
+			if (token === mountsToken) mountsLoading.value = false;
+		}
+	}
+	async function navigate(location, refresh = false) {
+		if (disposed || !location.mount_id) return;
+		clearTimeout(searchTimer);
+		const token = ++listToken;
+		listingController?.abort();
+		listingController = new AbortController();
+		listingLoading.value = true;
+		mountId.value = location.mount_id;
+		path.value = location.path;
+		resetListing();
+		sync.clearError();
+		try {
+			const query = `mount_id=${encodeURIComponent(location.mount_id)}&path=${encodeURIComponent(location.path)}&sort=${sort.value}` + (refresh ? "&refresh=true" : "") + (search.value ? `&search=${encodeURIComponent(search.value)}` : "") + typeRuleParams();
+			const listing = await api.get(`/filesystem/browse?${query}`, { signal: listingController.signal });
+			if (disposed || token !== listToken) return;
+			mountId.value = listing.mount_id;
+			path.value = listing.path;
+			parent.value = listing.parent ?? null;
+			entries.value = listing.entries ?? [];
+			breadcrumbs.value = listing.breadcrumbs ?? [];
+			totalCount.value = listing.total_count ?? null;
+			matchCount.value = listing.match_count ?? null;
+			shownCount.value = listing.shown_count ?? listing.entries?.length ?? null;
+			truncated.value = listing.truncated ?? false;
+			listingReady.value = true;
+			sync.clearError();
+		} catch (cause) {
+			if (disposed || token !== listToken) return;
+			entries.value = [];
+			fail(cause, "Could not read that folder.");
+		} finally {
+			if (token === listToken) listingLoading.value = false;
+		}
+	}
+	async function init() {
+		if (disposed) return;
+		const navigationToken = listToken;
+		if (!await loadMounts() || disposed || navigationToken !== listToken) return;
+		const preferred = toValue(options.initialMountId);
+		const reachable = (mount) => mount.available !== false;
+		const target = mounts.value.find((mount) => mount.id === preferred && reachable(mount)) ?? mounts.value.find(reachable);
+		if (target) await navigate({
+			mount_id: target.id,
+			path: ""
+		});
+		else {
+			mountId.value = "";
+			path.value = "";
+			resetListing();
+		}
+	}
+	async function refresh() {
+		if (disposed) return;
+		if (mountId.value) await navigate({
+			mount_id: mountId.value,
+			path: path.value
+		}, true);
+		else await init();
+	}
+	function selectCurrentFolder() {
+		if (!mountId.value || !listingReady.value || isLoading.value || sync.error.value) return;
+		const crumb = breadcrumbs.value[breadcrumbs.value.length - 1];
+		const key = JSON.stringify([mountId.value, path.value]);
+		if (selected.value.some((item) => JSON.stringify([item.mount_id, item.path]) === key)) return;
+		selected.value = [...selected.value, {
+			mount_id: mountId.value,
+			path: path.value,
+			name: crumb?.label ?? path.value,
+			kind: "directory",
+			child_count: totalCount.value
+		}];
+	}
+	function clear() {
+		selected.value = [];
+	}
+	watch(search, () => {
+		if (!mountId.value) return;
+		clearTimeout(searchTimer);
+		searchTimer = setTimeout(() => {
+			navigate({
+				mount_id: mountId.value,
+				path: path.value
+			});
+		}, 250);
+	});
+	watch(sort, () => {
+		if (mountId.value) navigate({
+			mount_id: mountId.value,
+			path: path.value
+		});
+	});
+	watch(() => toValue(options.typeRules), () => {
+		if (mountId.value) navigate({
+			mount_id: mountId.value,
+			path: path.value
+		});
+	}, { deep: true });
+	if (getCurrentScope()) onScopeDispose(() => {
+		disposed = true;
+		++listToken;
+		++mountsToken;
+		clearTimeout(searchTimer);
+		listingController?.abort();
+		mountsController?.abort();
+	});
+	return {
+		mounts,
+		mountId,
+		path,
+		parent,
+		entries,
+		breadcrumbs,
+		totalCount,
+		matchCount,
+		shownCount,
+		truncated,
+		search,
+		sort,
+		selected,
+		isLoading,
+		error: sync.error,
+		init,
+		navigate,
+		refresh,
+		selectCurrentFolder,
+		clear
+	};
+}
+//#endregion
+//#region src/composables/analysisArtifactTarget.ts
+var EXPERIMENT_ID = "experiment_id";
+var ARTIFACT_PLUGIN_ID = "artifact_plugin_id";
+var ARTIFACT_KEY = "artifact_key";
+var ARTIFACT_ID = "artifact_id";
+function parsePositiveInteger(value) {
+	if (value === null || !/^\d+$/.test(value)) return void 0;
+	const parsed = Number(value);
+	return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : void 0;
+}
+/** Build the canonical query used to open one analysis artifact in a plugin. */
+function buildAnalysisArtifactTargetQuery(target) {
+	const query = new URLSearchParams();
+	query.set(EXPERIMENT_ID, String(target.experimentId));
+	query.set(ARTIFACT_PLUGIN_ID, target.artifactPluginId);
+	query.set(ARTIFACT_KEY, target.artifactKey);
+	if (target.artifactId !== void 0) query.set(ARTIFACT_ID, String(target.artifactId));
+	return query;
+}
+/** Parse a complete canonical target. Incomplete or invalid input is not guessed. */
+function parseAnalysisArtifactTarget(query) {
+	const experimentId = parsePositiveInteger(query.get(EXPERIMENT_ID));
+	const artifactPluginId = query.get(ARTIFACT_PLUGIN_ID)?.trim();
+	const artifactKey = query.get(ARTIFACT_KEY)?.trim();
+	const rawArtifactId = query.get(ARTIFACT_ID);
+	const artifactId = parsePositiveInteger(rawArtifactId);
+	if (experimentId === void 0 || !artifactPluginId || !artifactKey || rawArtifactId !== null && artifactId === void 0) return null;
+	return {
+		experimentId,
+		artifactPluginId,
+		artifactKey,
+		...artifactId === void 0 ? {} : { artifactId }
+	};
+}
+//#endregion
+//#region src/data.ts
+var data_exports = /* @__PURE__ */ __exportAll({
+	ANALYSIS_FILE_ARTIFACT_SCHEMA: () => ANALYSIS_FILE_ARTIFACT_SCHEMA,
+	APP_EXPERIMENT_KEY: () => APP_EXPERIMENT_KEY,
+	ArtifactSaveDialog: () => ArtifactSaveDialog_default,
+	ArtifactSelectorModal: () => ArtifactSelectorModal_default,
+	AuditTrail: () => AuditTrail_default,
+	BatchProgressList: () => BatchProgressList_default,
+	DATE_PRESET_OPTIONS: () => DATE_PRESET_OPTIONS,
+	ExperimentCodeBadge: () => ExperimentCodeBadge_default,
+	ExperimentPopover: () => ExperimentPopover_default,
+	ExperimentSelectorModal: () => ExperimentSelectorModal_default,
+	FilePicker: () => FilePicker_default,
+	JobsStatusTray: () => JobsStatusTray_default,
+	SORT_OPTIONS: () => SORT_OPTIONS,
+	SecretInput: () => SecretInput_default,
+	StaleFormBanner: () => StaleFormBanner_default,
+	TagsInput: () => TagsInput_default,
+	VersionConflictDialog: () => VersionConflictDialog_default,
+	buildAnalysisArtifactTargetQuery: () => buildAnalysisArtifactTargetQuery,
+	candidateMatchesSearch: () => candidateMatchesSearch,
+	createFilePickerAdapter: () => createFilePickerAdapter,
+	datePresetToISO: () => datePresetToISO,
+	decodePlatformPickerPath: () => decodePlatformPickerPath,
+	detectDelimiter: () => detectDelimiter,
+	encodePlatformPickerPath: () => encodePlatformPickerPath,
+	experimentIdFromRoute: () => experimentIdFromRoute,
+	experimentStatus: () => experimentStatus_exports,
+	extractSampleNamesFromDesignData: () => extractSampleNamesFromDesignData,
+	extractSampleOptionsFromDesignData: () => extractSampleOptionsFromDesignData,
+	fieldNameLabel: () => fieldNameLabel,
+	formatExperimentDate: () => formatExperimentDate,
+	normalizeSearchQuery: () => normalizeSearchQuery,
+	parseAnalysisArtifactTarget: () => parseAnalysisArtifactTarget,
+	parseDelimitedText: () => parseDelimitedText,
+	pluginSecret: () => pluginSecrets_exports,
+	readFileAsText: () => readFileAsText,
+	resolveExperimentCode: () => resolveExperimentCode,
+	unwrapExperimentDesignData: () => unwrapExperimentDesignData,
+	useAppExperiment: () => useAppExperiment,
+	useArtifacts: () => useArtifacts,
+	useExperimentData: () => useExperimentData,
+	useExperimentSamples: () => useExperimentSamples,
+	useExperimentSelector: () => useExperimentSelector,
+	useFileBrowser: () => useFileBrowser,
+	useFileImport: () => useFileImport,
+	usePlatformFilePickerAdapter: () => usePlatformFilePickerAdapter,
+	useTextSearch: () => useTextSearch,
+	useVersionedSave: () => useVersionedSave,
+	validateImportFile: () => validateImportFile
+});
+//#endregion
+export { ArtifactSaveDialog_default as _, usePlatformFilePickerAdapter as a, encodePlatformPickerPath as c, StaleFormBanner_default as d, VersionConflictDialog_default as f, ExperimentCodeBadge_default as g, FilePicker_default as h, useFileBrowser as i, fieldNameLabel as l, AuditTrail_default as m, buildAnalysisArtifactTargetQuery as n, createFilePickerAdapter as o, BatchProgressList_default as p, parseAnalysisArtifactTarget as r, decodePlatformPickerPath as s, data_exports as t, useVersionedSave as u, ArtifactSelectorModal_default as v, useArtifacts as y };
+
+//# sourceMappingURL=data-CgILxDLW.js.map