@attraccess/plugin-wago 0.1.0-nightly.925.2

package/frontend/__federation_expose_Plugin-CXB18jsp.js

@@ -0,0 +1,1489 @@
+import { r as importShared } from "./_virtual___federation_fn_import-BXODRNto.js";
+import { t as require_jsx_runtime } from "./jsx-runtime-B9Qmn8k7.js";
+//#region ../../../node_modules/.pnpm/@tanstack+query-core@5.101.4/node_modules/@tanstack/query-core/build/modern/subscribable.js
+var Subscribable = class {
+	constructor() {
+		this.listeners = /* @__PURE__ */ new Set();
+		this.subscribe = this.subscribe.bind(this);
+	}
+	subscribe(listener) {
+		this.listeners.add(listener);
+		this.onSubscribe();
+		return () => {
+			this.listeners.delete(listener);
+			this.onUnsubscribe();
+		};
+	}
+	hasListeners() {
+		return this.listeners.size > 0;
+	}
+	onSubscribe() {}
+	onUnsubscribe() {}
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/@tanstack+query-core@5.101.4/node_modules/@tanstack/query-core/build/modern/focusManager.js
+var FocusManager = class extends Subscribable {
+	#focused;
+	#cleanup;
+	#setup;
+	constructor() {
+		super();
+		this.#setup = (onFocus) => {
+			if (typeof window !== "undefined" && window.addEventListener) {
+				const listener = () => onFocus();
+				window.addEventListener("visibilitychange", listener, false);
+				return () => {
+					window.removeEventListener("visibilitychange", listener);
+				};
+			}
+		};
+	}
+	onSubscribe() {
+		if (!this.#cleanup) this.setEventListener(this.#setup);
+	}
+	onUnsubscribe() {
+		if (!this.hasListeners()) {
+			this.#cleanup?.();
+			this.#cleanup = void 0;
+		}
+	}
+	setEventListener(setup) {
+		this.#setup = setup;
+		this.#cleanup?.();
+		this.#cleanup = setup((focused) => {
+			if (typeof focused === "boolean") this.setFocused(focused);
+			else this.onFocus();
+		});
+	}
+	setFocused(focused) {
+		if (this.#focused !== focused) {
+			this.#focused = focused;
+			this.onFocus();
+		}
+	}
+	onFocus() {
+		const isFocused = this.isFocused();
+		this.listeners.forEach((listener) => {
+			listener(isFocused);
+		});
+	}
+	isFocused() {
+		if (typeof this.#focused === "boolean") return this.#focused;
+		return globalThis.document?.visibilityState !== "hidden";
+	}
+};
+var focusManager = new FocusManager();
+//#endregion
+//#region ../../../node_modules/.pnpm/@tanstack+query-core@5.101.4/node_modules/@tanstack/query-core/build/modern/timeoutManager.js
+var defaultTimeoutProvider = {
+	setTimeout: (callback, delay) => setTimeout(callback, delay),
+	clearTimeout: (timeoutId) => clearTimeout(timeoutId),
+	setInterval: (callback, delay) => setInterval(callback, delay),
+	clearInterval: (intervalId) => clearInterval(intervalId)
+};
+var TimeoutManager = class {
+	#provider = defaultTimeoutProvider;
+	#providerCalled = false;
+	setTimeoutProvider(provider) {
+		this.#provider = provider;
+	}
+	setTimeout(callback, delay) {
+		return this.#provider.setTimeout(callback, delay);
+	}
+	clearTimeout(timeoutId) {
+		this.#provider.clearTimeout(timeoutId);
+	}
+	setInterval(callback, delay) {
+		return this.#provider.setInterval(callback, delay);
+	}
+	clearInterval(intervalId) {
+		this.#provider.clearInterval(intervalId);
+	}
+};
+var timeoutManager = new TimeoutManager();
+function systemSetTimeoutZero(callback) {
+	setTimeout(callback, 0);
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/@tanstack+query-core@5.101.4/node_modules/@tanstack/query-core/build/modern/utils.js
+var isServer = typeof window === "undefined" || "Deno" in globalThis;
+function noop() {}
+function isValidTimeout(value) {
+	return typeof value === "number" && value >= 0 && value !== Infinity;
+}
+function timeUntilStale(updatedAt, staleTime) {
+	return Math.max(updatedAt + (staleTime || 0) - Date.now(), 0);
+}
+function resolveStaleTime(staleTime, query) {
+	return typeof staleTime === "function" ? staleTime(query) : staleTime;
+}
+function resolveQueryBoolean(option, query) {
+	return typeof option === "function" ? option(query) : option;
+}
+function hashKey(queryKey) {
+	return JSON.stringify(queryKey, (_, val) => isPlainObject(val) ? Object.keys(val).sort().reduce((result, key) => {
+		result[key] = val[key];
+		return result;
+	}, {}) : val);
+}
+var hasOwn = Object.prototype.hasOwnProperty;
+function replaceEqualDeep(a, b, depth = 0) {
+	if (a === b) return a;
+	if (depth > 500) return b;
+	const array = isPlainArray(a) && isPlainArray(b);
+	if (!array && !(isPlainObject(a) && isPlainObject(b))) return b;
+	const aSize = (array ? a : Object.keys(a)).length;
+	const bItems = array ? b : Object.keys(b);
+	const bSize = bItems.length;
+	const copy = array ? new Array(bSize) : {};
+	let equalItems = 0;
+	for (let i = 0; i < bSize; i++) {
+		const key = array ? i : bItems[i];
+		const aItem = a[key];
+		const bItem = b[key];
+		if (aItem === bItem) {
+			copy[key] = aItem;
+			if (array ? i < aSize : hasOwn.call(a, key)) equalItems++;
+			continue;
+		}
+		if (aItem === null || bItem === null || typeof aItem !== "object" || typeof bItem !== "object") {
+			copy[key] = bItem;
+			continue;
+		}
+		const v = replaceEqualDeep(aItem, bItem, depth + 1);
+		copy[key] = v;
+		if (v === aItem) equalItems++;
+	}
+	return aSize === bSize && equalItems === aSize ? a : copy;
+}
+function shallowEqualObjects(a, b) {
+	if (!b || Object.keys(a).length !== Object.keys(b).length) return false;
+	for (const key in a) if (a[key] !== b[key]) return false;
+	return true;
+}
+function isPlainArray(value) {
+	return Array.isArray(value) && value.length === Object.keys(value).length;
+}
+function isPlainObject(o) {
+	if (!hasObjectPrototype(o)) return false;
+	const ctor = o.constructor;
+	if (ctor === void 0) return true;
+	const prot = ctor.prototype;
+	if (!hasObjectPrototype(prot)) return false;
+	if (!prot.hasOwnProperty("isPrototypeOf")) return false;
+	if (Object.getPrototypeOf(o) !== Object.prototype) return false;
+	return true;
+}
+function hasObjectPrototype(o) {
+	return Object.prototype.toString.call(o) === "[object Object]";
+}
+function replaceData(prevData, data, options) {
+	if (typeof options.structuralSharing === "function") return options.structuralSharing(prevData, data);
+	else if (options.structuralSharing !== false) return replaceEqualDeep(prevData, data);
+	return data;
+}
+function shouldThrowError(throwOnError, params) {
+	if (typeof throwOnError === "function") return throwOnError(...params);
+	return !!throwOnError;
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/@tanstack+query-core@5.101.4/node_modules/@tanstack/query-core/build/modern/environmentManager.js
+var environmentManager = /* @__PURE__ */ (() => {
+	let isServerFn = () => isServer;
+	return {
+		/**
+		* Returns whether the current runtime should be treated as a server environment.
+		*/
+		isServer() {
+			return isServerFn();
+		},
+		/**
+		* Overrides the server check globally.
+		*/
+		setIsServer(isServerValue) {
+			isServerFn = isServerValue;
+		}
+	};
+})();
+//#endregion
+//#region ../../../node_modules/.pnpm/@tanstack+query-core@5.101.4/node_modules/@tanstack/query-core/build/modern/thenable.js
+function pendingThenable() {
+	let resolve;
+	let reject;
+	const thenable = new Promise((_resolve, _reject) => {
+		resolve = _resolve;
+		reject = _reject;
+	});
+	thenable.status = "pending";
+	thenable.catch(() => {});
+	function finalize(data) {
+		Object.assign(thenable, data);
+		delete thenable.resolve;
+		delete thenable.reject;
+	}
+	thenable.resolve = (value) => {
+		finalize({
+			status: "fulfilled",
+			value
+		});
+		resolve(value);
+	};
+	thenable.reject = (reason) => {
+		finalize({
+			status: "rejected",
+			reason
+		});
+		reject(reason);
+	};
+	return thenable;
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/@tanstack+query-core@5.101.4/node_modules/@tanstack/query-core/build/modern/notifyManager.js
+var defaultScheduler = systemSetTimeoutZero;
+function createNotifyManager() {
+	let queue = [];
+	let transactions = 0;
+	let notifyFn = (callback) => {
+		callback();
+	};
+	let batchNotifyFn = (callback) => {
+		callback();
+	};
+	let scheduleFn = defaultScheduler;
+	const schedule = (callback) => {
+		if (transactions) queue.push(callback);
+		else scheduleFn(() => {
+			notifyFn(callback);
+		});
+	};
+	const flush = () => {
+		const originalQueue = queue;
+		queue = [];
+		if (originalQueue.length) scheduleFn(() => {
+			batchNotifyFn(() => {
+				originalQueue.forEach((callback) => {
+					notifyFn(callback);
+				});
+			});
+		});
+	};
+	return {
+		batch: (callback) => {
+			let result;
+			transactions++;
+			try {
+				result = callback();
+			} finally {
+				transactions--;
+				if (!transactions) flush();
+			}
+			return result;
+		},
+		/**
+		* All calls to the wrapped function will be batched.
+		*/
+		batchCalls: (callback) => {
+			return (...args) => {
+				schedule(() => {
+					callback(...args);
+				});
+			};
+		},
+		schedule,
+		/**
+		* Use this method to set a custom notify function.
+		* This can be used to for example wrap notifications with `React.act` while running tests.
+		*/
+		setNotifyFunction: (fn) => {
+			notifyFn = fn;
+		},
+		/**
+		* Use this method to set a custom function to batch notifications together into a single tick.
+		* By default React Query will use the batch function provided by ReactDOM or React Native.
+		*/
+		setBatchNotifyFunction: (fn) => {
+			batchNotifyFn = fn;
+		},
+		setScheduler: (fn) => {
+			scheduleFn = fn;
+		}
+	};
+}
+var notifyManager = createNotifyManager();
+//#endregion
+//#region ../../../node_modules/.pnpm/@tanstack+query-core@5.101.4/node_modules/@tanstack/query-core/build/modern/onlineManager.js
+var OnlineManager = class extends Subscribable {
+	#online = true;
+	#cleanup;
+	#setup;
+	constructor() {
+		super();
+		this.#setup = (onOnline) => {
+			if (typeof window !== "undefined" && window.addEventListener) {
+				const onlineListener = () => onOnline(true);
+				const offlineListener = () => onOnline(false);
+				window.addEventListener("online", onlineListener, false);
+				window.addEventListener("offline", offlineListener, false);
+				return () => {
+					window.removeEventListener("online", onlineListener);
+					window.removeEventListener("offline", offlineListener);
+				};
+			}
+		};
+	}
+	onSubscribe() {
+		if (!this.#cleanup) this.setEventListener(this.#setup);
+	}
+	onUnsubscribe() {
+		if (!this.hasListeners()) {
+			this.#cleanup?.();
+			this.#cleanup = void 0;
+		}
+	}
+	setEventListener(setup) {
+		this.#setup = setup;
+		this.#cleanup?.();
+		this.#cleanup = setup(this.setOnline.bind(this));
+	}
+	setOnline(online) {
+		if (this.#online !== online) {
+			this.#online = online;
+			this.listeners.forEach((listener) => {
+				listener(online);
+			});
+		}
+	}
+	isOnline() {
+		return this.#online;
+	}
+};
+var onlineManager = new OnlineManager();
+//#endregion
+//#region ../../../node_modules/.pnpm/@tanstack+query-core@5.101.4/node_modules/@tanstack/query-core/build/modern/retryer.js
+function canFetch(networkMode) {
+	return (networkMode ?? "online") === "online" ? onlineManager.isOnline() : true;
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/@tanstack+query-core@5.101.4/node_modules/@tanstack/query-core/build/modern/query.js
+function fetchState(data, options) {
+	return {
+		fetchFailureCount: 0,
+		fetchFailureReason: null,
+		fetchStatus: canFetch(options.networkMode) ? "fetching" : "paused",
+		...data === void 0 && {
+			error: null,
+			status: "pending"
+		}
+	};
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/@tanstack+query-core@5.101.4/node_modules/@tanstack/query-core/build/modern/queryObserver.js
+var QueryObserver = class extends Subscribable {
+	constructor(client, options) {
+		super();
+		this.options = options;
+		this.#client = client;
+		this.#selectError = null;
+		this.#currentThenable = pendingThenable();
+		this.bindMethods();
+		this.setOptions(options);
+	}
+	#client;
+	#currentQuery = void 0;
+	#currentQueryInitialState = void 0;
+	#currentResult = void 0;
+	#currentResultState;
+	#currentResultOptions;
+	#currentThenable;
+	#selectError;
+	#selectFn;
+	#selectResult;
+	#lastQueryWithDefinedData;
+	#staleTimeoutId;
+	#refetchIntervalId;
+	#currentRefetchInterval;
+	#trackedProps = /* @__PURE__ */ new Set();
+	bindMethods() {
+		this.refetch = this.refetch.bind(this);
+	}
+	onSubscribe() {
+		if (this.listeners.size === 1) {
+			this.#currentQuery.addObserver(this);
+			if (shouldFetchOnMount(this.#currentQuery, this.options)) this.#executeFetch();
+			else this.updateResult();
+			this.#updateTimers();
+		}
+	}
+	onUnsubscribe() {
+		if (!this.hasListeners()) this.destroy();
+	}
+	shouldFetchOnReconnect() {
+		return shouldFetchOn(this.#currentQuery, this.options, this.options.refetchOnReconnect);
+	}
+	shouldFetchOnWindowFocus() {
+		return shouldFetchOn(this.#currentQuery, this.options, this.options.refetchOnWindowFocus);
+	}
+	destroy() {
+		this.listeners = /* @__PURE__ */ new Set();
+		this.#clearStaleTimeout();
+		this.#clearRefetchInterval();
+		this.#currentQuery.removeObserver(this);
+	}
+	setOptions(options) {
+		const prevOptions = this.options;
+		const prevQuery = this.#currentQuery;
+		this.options = this.#client.defaultQueryOptions(options);
+		if (this.options.enabled !== void 0 && typeof this.options.enabled !== "boolean" && typeof this.options.enabled !== "function" && typeof resolveQueryBoolean(this.options.enabled, this.#currentQuery) !== "boolean") throw new Error("Expected enabled to be a boolean or a callback that returns a boolean");
+		this.#updateQuery();
+		this.#currentQuery.setOptions(this.options);
+		if (prevOptions._defaulted && !shallowEqualObjects(this.options, prevOptions)) this.#client.getQueryCache().notify({
+			type: "observerOptionsUpdated",
+			query: this.#currentQuery,
+			observer: this
+		});
+		const mounted = this.hasListeners();
+		if (mounted && shouldFetchOptionally(this.#currentQuery, prevQuery, this.options, prevOptions)) this.#executeFetch();
+		this.updateResult();
+		if (mounted && (this.#currentQuery !== prevQuery || resolveQueryBoolean(this.options.enabled, this.#currentQuery) !== resolveQueryBoolean(prevOptions.enabled, this.#currentQuery) || resolveStaleTime(this.options.staleTime, this.#currentQuery) !== resolveStaleTime(prevOptions.staleTime, this.#currentQuery))) this.#updateStaleTimeout();
+		const nextRefetchInterval = this.#computeRefetchInterval();
+		if (mounted && (this.#currentQuery !== prevQuery || resolveQueryBoolean(this.options.enabled, this.#currentQuery) !== resolveQueryBoolean(prevOptions.enabled, this.#currentQuery) || nextRefetchInterval !== this.#currentRefetchInterval)) this.#updateRefetchInterval(nextRefetchInterval);
+	}
+	getOptimisticResult(options) {
+		const query = this.#client.getQueryCache().build(this.#client, options);
+		const result = this.createResult(query, options);
+		if (shouldAssignObserverCurrentProperties(this, result)) {
+			this.#currentResult = result;
+			this.#currentResultOptions = this.options;
+			this.#currentResultState = this.#currentQuery.state;
+		}
+		return result;
+	}
+	getCurrentResult() {
+		return this.#currentResult;
+	}
+	trackResult(result, onPropTracked) {
+		return new Proxy(result, { get: (target, key) => {
+			this.trackProp(key);
+			onPropTracked?.(key);
+			if (key === "promise") {
+				this.trackProp("data");
+				if (!this.options.experimental_prefetchInRender && this.#currentThenable.status === "pending") this.#currentThenable.reject(/* @__PURE__ */ new Error("experimental_prefetchInRender feature flag is not enabled"));
+			}
+			return Reflect.get(target, key);
+		} });
+	}
+	trackProp(key) {
+		this.#trackedProps.add(key);
+	}
+	getCurrentQuery() {
+		return this.#currentQuery;
+	}
+	refetch({ ...options } = {}) {
+		return this.fetch({ ...options });
+	}
+	fetchOptimistic(options) {
+		const defaultedOptions = this.#client.defaultQueryOptions(options);
+		const query = this.#client.getQueryCache().build(this.#client, defaultedOptions);
+		return query.fetch().then(() => this.createResult(query, defaultedOptions));
+	}
+	fetch(fetchOptions) {
+		return this.#executeFetch({
+			...fetchOptions,
+			cancelRefetch: fetchOptions.cancelRefetch ?? true
+		}).then(() => {
+			this.updateResult();
+			return this.#currentResult;
+		});
+	}
+	#executeFetch(fetchOptions) {
+		this.#updateQuery();
+		let promise = this.#currentQuery.fetch(this.options, fetchOptions);
+		if (!fetchOptions?.throwOnError) promise = promise.catch(noop);
+		return promise;
+	}
+	#updateStaleTimeout() {
+		this.#clearStaleTimeout();
+		const staleTime = resolveStaleTime(this.options.staleTime, this.#currentQuery);
+		if (environmentManager.isServer() || this.#currentResult.isStale || !isValidTimeout(staleTime)) return;
+		const timeout = timeUntilStale(this.#currentResult.dataUpdatedAt, staleTime) + 1;
+		this.#staleTimeoutId = timeoutManager.setTimeout(() => {
+			if (!this.#currentResult.isStale) this.updateResult();
+		}, timeout);
+	}
+	#computeRefetchInterval() {
+		return (typeof this.options.refetchInterval === "function" ? this.options.refetchInterval(this.#currentQuery) : this.options.refetchInterval) ?? false;
+	}
+	#updateRefetchInterval(nextInterval) {
+		this.#clearRefetchInterval();
+		this.#currentRefetchInterval = nextInterval;
+		if (environmentManager.isServer() || resolveQueryBoolean(this.options.enabled, this.#currentQuery) === false || !isValidTimeout(this.#currentRefetchInterval) || this.#currentRefetchInterval === 0) return;
+		this.#refetchIntervalId = timeoutManager.setInterval(() => {
+			if (this.options.refetchIntervalInBackground || focusManager.isFocused()) this.#executeFetch();
+		}, this.#currentRefetchInterval);
+	}
+	#updateTimers() {
+		this.#updateStaleTimeout();
+		this.#updateRefetchInterval(this.#computeRefetchInterval());
+	}
+	#clearStaleTimeout() {
+		if (this.#staleTimeoutId !== void 0) {
+			timeoutManager.clearTimeout(this.#staleTimeoutId);
+			this.#staleTimeoutId = void 0;
+		}
+	}
+	#clearRefetchInterval() {
+		if (this.#refetchIntervalId !== void 0) {
+			timeoutManager.clearInterval(this.#refetchIntervalId);
+			this.#refetchIntervalId = void 0;
+		}
+	}
+	createResult(query, options) {
+		const prevQuery = this.#currentQuery;
+		const prevOptions = this.options;
+		const prevResult = this.#currentResult;
+		const prevResultState = this.#currentResultState;
+		const prevResultOptions = this.#currentResultOptions;
+		const queryInitialState = query !== prevQuery ? query.state : this.#currentQueryInitialState;
+		const { state } = query;
+		let newState = { ...state };
+		let isPlaceholderData = false;
+		let data;
+		if (options._optimisticResults) {
+			const mounted = this.hasListeners();
+			const fetchOnMount = !mounted && shouldFetchOnMount(query, options);
+			const fetchOptionally = mounted && shouldFetchOptionally(query, prevQuery, options, prevOptions);
+			if (fetchOnMount || fetchOptionally) newState = {
+				...newState,
+				...fetchState(state.data, query.options)
+			};
+			if (options._optimisticResults === "isRestoring") newState.fetchStatus = "idle";
+		}
+		let { error, errorUpdatedAt, status } = newState;
+		data = newState.data;
+		let skipSelect = false;
+		if (options.placeholderData !== void 0 && data === void 0 && status === "pending") {
+			let placeholderData;
+			if (prevResult?.isPlaceholderData && options.placeholderData === prevResultOptions?.placeholderData) {
+				placeholderData = prevResult.data;
+				skipSelect = true;
+			} else placeholderData = typeof options.placeholderData === "function" ? options.placeholderData(this.#lastQueryWithDefinedData?.state.data, this.#lastQueryWithDefinedData) : options.placeholderData;
+			if (placeholderData !== void 0) {
+				status = "success";
+				data = replaceData(prevResult?.data, placeholderData, options);
+				isPlaceholderData = true;
+			}
+		}
+		if (options.select && data !== void 0 && !skipSelect) {
+			if (prevResult && data === prevResultState?.data && options.select === this.#selectFn) data = this.#selectResult;
+			else try {
+				this.#selectFn = options.select;
+				data = options.select(data);
+				data = replaceData(prevResult?.data, data, options);
+				this.#selectResult = data;
+				this.#selectError = null;
+			} catch (selectError) {
+				this.#selectError = selectError;
+			}
+		}
+		if (this.#selectError) {
+			error = this.#selectError;
+			data = this.#selectResult;
+			errorUpdatedAt = Date.now();
+			status = "error";
+		}
+		const isFetching = newState.fetchStatus === "fetching";
+		const isPending = status === "pending";
+		const isError = status === "error";
+		const isLoading = isPending && isFetching;
+		const hasData = data !== void 0;
+		const nextResult = {
+			status,
+			fetchStatus: newState.fetchStatus,
+			isPending,
+			isSuccess: status === "success",
+			isError,
+			isInitialLoading: isLoading,
+			isLoading,
+			data,
+			dataUpdatedAt: newState.dataUpdatedAt,
+			error,
+			errorUpdatedAt,
+			failureCount: newState.fetchFailureCount,
+			failureReason: newState.fetchFailureReason,
+			errorUpdateCount: newState.errorUpdateCount,
+			isFetched: query.isFetched(),
+			isFetchedAfterMount: newState.dataUpdateCount > queryInitialState.dataUpdateCount || newState.errorUpdateCount > queryInitialState.errorUpdateCount,
+			isFetching,
+			isRefetching: isFetching && !isPending,
+			isLoadingError: isError && !hasData,
+			isPaused: newState.fetchStatus === "paused",
+			isPlaceholderData,
+			isRefetchError: isError && hasData,
+			isStale: isStale(query, options),
+			refetch: this.refetch,
+			promise: this.#currentThenable,
+			isEnabled: resolveQueryBoolean(options.enabled, query) !== false
+		};
+		if (this.options.experimental_prefetchInRender) {
+			const hasResultData = nextResult.data !== void 0;
+			const isErrorWithoutData = nextResult.status === "error" && !hasResultData;
+			const finalizeThenableIfPossible = (thenable) => {
+				if (isErrorWithoutData) thenable.reject(nextResult.error);
+				else if (hasResultData) thenable.resolve(nextResult.data);
+			};
+			const recreateThenable = () => {
+				const pending = this.#currentThenable = nextResult.promise = pendingThenable();
+				finalizeThenableIfPossible(pending);
+			};
+			const prevThenable = this.#currentThenable;
+			switch (prevThenable.status) {
+				case "pending":
+					if (query.queryHash === prevQuery.queryHash) finalizeThenableIfPossible(prevThenable);
+					break;
+				case "fulfilled":
+					if (isErrorWithoutData || nextResult.data !== prevThenable.value) recreateThenable();
+					break;
+				case "rejected": if (!isErrorWithoutData || nextResult.error !== prevThenable.reason) recreateThenable();
+			}
+		}
+		return nextResult;
+	}
+	updateResult() {
+		const prevResult = this.#currentResult;
+		const nextResult = this.createResult(this.#currentQuery, this.options);
+		this.#currentResultState = this.#currentQuery.state;
+		this.#currentResultOptions = this.options;
+		if (this.#currentResultState.data !== void 0) this.#lastQueryWithDefinedData = this.#currentQuery;
+		if (shallowEqualObjects(nextResult, prevResult)) return;
+		this.#currentResult = nextResult;
+		const shouldNotifyListeners = () => {
+			if (!prevResult) return true;
+			const { notifyOnChangeProps } = this.options;
+			const notifyOnChangePropsValue = typeof notifyOnChangeProps === "function" ? notifyOnChangeProps() : notifyOnChangeProps;
+			if (notifyOnChangePropsValue === "all" || !notifyOnChangePropsValue && !this.#trackedProps.size) return true;
+			const includedProps = new Set(notifyOnChangePropsValue ?? this.#trackedProps);
+			if (this.options.throwOnError) includedProps.add("error");
+			return Object.keys(this.#currentResult).some((key) => {
+				const typedKey = key;
+				return this.#currentResult[typedKey] !== prevResult[typedKey] && includedProps.has(typedKey);
+			});
+		};
+		this.#notify({ listeners: shouldNotifyListeners() });
+	}
+	#updateQuery() {
+		const query = this.#client.getQueryCache().build(this.#client, this.options);
+		if (query === this.#currentQuery) return;
+		const prevQuery = this.#currentQuery;
+		this.#currentQuery = query;
+		this.#currentQueryInitialState = query.state;
+		if (this.hasListeners()) {
+			prevQuery?.removeObserver(this);
+			query.addObserver(this);
+		}
+	}
+	onQueryUpdate() {
+		this.updateResult();
+		if (this.hasListeners()) this.#updateTimers();
+	}
+	#notify(notifyOptions) {
+		notifyManager.batch(() => {
+			if (notifyOptions.listeners) this.listeners.forEach((listener) => {
+				listener(this.#currentResult);
+			});
+			this.#client.getQueryCache().notify({
+				query: this.#currentQuery,
+				type: "observerResultsUpdated"
+			});
+		});
+	}
+};
+function shouldLoadOnMount(query, options) {
+	return resolveQueryBoolean(options.enabled, query) !== false && query.state.data === void 0 && !(query.state.status === "error" && resolveQueryBoolean(options.retryOnMount, query) === false);
+}
+function shouldFetchOnMount(query, options) {
+	return shouldLoadOnMount(query, options) || query.state.data !== void 0 && shouldFetchOn(query, options, options.refetchOnMount);
+}
+function shouldFetchOn(query, options, field) {
+	if (resolveQueryBoolean(options.enabled, query) !== false && resolveStaleTime(options.staleTime, query) !== "static") {
+		const value = typeof field === "function" ? field(query) : field;
+		return value === "always" || value !== false && isStale(query, options);
+	}
+	return false;
+}
+function shouldFetchOptionally(query, prevQuery, options, prevOptions) {
+	return (query !== prevQuery || resolveQueryBoolean(prevOptions.enabled, query) === false) && (!options.suspense || query.state.status !== "error") && isStale(query, options);
+}
+function isStale(query, options) {
+	return resolveQueryBoolean(options.enabled, query) !== false && query.isStaleByTime(resolveStaleTime(options.staleTime, query));
+}
+function shouldAssignObserverCurrentProperties(observer, optimisticResult) {
+	if (!shallowEqualObjects(observer.getCurrentResult(), optimisticResult)) return true;
+	return false;
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/@tanstack+query-core@5.101.4/node_modules/@tanstack/query-core/build/modern/mutation.js
+function getDefaultState() {
+	return {
+		context: void 0,
+		data: void 0,
+		error: null,
+		failureCount: 0,
+		failureReason: null,
+		isPaused: false,
+		status: "idle",
+		variables: void 0,
+		submittedAt: 0
+	};
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/@tanstack+query-core@5.101.4/node_modules/@tanstack/query-core/build/modern/mutationObserver.js
+var MutationObserver = class extends Subscribable {
+	#client;
+	#currentResult = void 0;
+	#currentMutation;
+	#mutateOptions;
+	constructor(client, options) {
+		super();
+		this.#client = client;
+		this.setOptions(options);
+		this.bindMethods();
+		this.#updateResult();
+	}
+	bindMethods() {
+		this.mutate = this.mutate.bind(this);
+		this.reset = this.reset.bind(this);
+	}
+	setOptions(options) {
+		const prevOptions = this.options;
+		this.options = this.#client.defaultMutationOptions(options);
+		if (!shallowEqualObjects(this.options, prevOptions)) this.#client.getMutationCache().notify({
+			type: "observerOptionsUpdated",
+			mutation: this.#currentMutation,
+			observer: this
+		});
+		if (prevOptions?.mutationKey && this.options.mutationKey && hashKey(prevOptions.mutationKey) !== hashKey(this.options.mutationKey)) this.reset();
+		else if (this.#currentMutation?.state.status === "pending") this.#currentMutation.setOptions(this.options);
+	}
+	onUnsubscribe() {
+		if (!this.hasListeners()) this.#currentMutation?.removeObserver(this);
+	}
+	onMutationUpdate(action) {
+		this.#updateResult();
+		this.#notify(action);
+	}
+	getCurrentResult() {
+		return this.#currentResult;
+	}
+	reset() {
+		this.#currentMutation?.removeObserver(this);
+		this.#currentMutation = void 0;
+		this.#updateResult();
+		this.#notify();
+	}
+	mutate(variables, options) {
+		this.#mutateOptions = options;
+		this.#currentMutation?.removeObserver(this);
+		this.#currentMutation = this.#client.getMutationCache().build(this.#client, this.options);
+		this.#currentMutation.addObserver(this);
+		return this.#currentMutation.execute(variables);
+	}
+	#updateResult() {
+		const state = this.#currentMutation?.state ?? getDefaultState();
+		this.#currentResult = {
+			...state,
+			isPending: state.status === "pending",
+			isSuccess: state.status === "success",
+			isError: state.status === "error",
+			isIdle: state.status === "idle",
+			mutate: this.mutate,
+			reset: this.reset
+		};
+	}
+	#notify(action) {
+		notifyManager.batch(() => {
+			if (this.#mutateOptions && this.hasListeners()) {
+				const variables = this.#currentResult.variables;
+				const onMutateResult = this.#currentResult.context;
+				const context = {
+					client: this.#client,
+					meta: this.options.meta,
+					mutationKey: this.options.mutationKey
+				};
+				if (action?.type === "success") {
+					try {
+						this.#mutateOptions.onSuccess?.(action.data, variables, onMutateResult, context);
+					} catch (e) {
+						Promise.reject(e);
+					}
+					try {
+						this.#mutateOptions.onSettled?.(action.data, null, variables, onMutateResult, context);
+					} catch (e) {
+						Promise.reject(e);
+					}
+				} else if (action?.type === "error") {
+					try {
+						this.#mutateOptions.onError?.(action.error, variables, onMutateResult, context);
+					} catch (e) {
+						Promise.reject(e);
+					}
+					try {
+						this.#mutateOptions.onSettled?.(void 0, action.error, variables, onMutateResult, context);
+					} catch (e) {
+						Promise.reject(e);
+					}
+				}
+			}
+			this.listeners.forEach((listener) => {
+				listener(this.#currentResult);
+			});
+		});
+	}
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/@tanstack+react-query@5.101.4_react@19.2.8/node_modules/@tanstack/react-query/build/modern/QueryClientProvider.js
+var import_jsx_runtime = require_jsx_runtime();
+var React$5 = await importShared("react");
+var QueryClientContext = React$5.createContext(void 0);
+var useQueryClient = (queryClient) => {
+	const client = React$5.useContext(QueryClientContext);
+	if (queryClient) return queryClient;
+	if (!client) throw new Error("No QueryClient set, use QueryClientProvider to set one");
+	return client;
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/@tanstack+react-query@5.101.4_react@19.2.8/node_modules/@tanstack/react-query/build/modern/IsRestoringProvider.js
+var React$4 = await importShared("react");
+var IsRestoringContext = React$4.createContext(false);
+var useIsRestoring = () => React$4.useContext(IsRestoringContext);
+IsRestoringContext.Provider;
+//#endregion
+//#region ../../../node_modules/.pnpm/@tanstack+react-query@5.101.4_react@19.2.8/node_modules/@tanstack/react-query/build/modern/QueryErrorResetBoundary.js
+var React$3 = await importShared("react");
+function createValue() {
+	let isReset = false;
+	return {
+		clearReset: () => {
+			isReset = false;
+		},
+		reset: () => {
+			isReset = true;
+		},
+		isReset: () => {
+			return isReset;
+		}
+	};
+}
+var QueryErrorResetBoundaryContext = React$3.createContext(createValue());
+var useQueryErrorResetBoundary = () => React$3.useContext(QueryErrorResetBoundaryContext);
+//#endregion
+//#region ../../../node_modules/.pnpm/@tanstack+react-query@5.101.4_react@19.2.8/node_modules/@tanstack/react-query/build/modern/errorBoundaryUtils.js
+var React$2 = await importShared("react");
+var ensurePreventErrorBoundaryRetry = (options, errorResetBoundary, query) => {
+	const throwOnError = query?.state.error && typeof options.throwOnError === "function" ? shouldThrowError(options.throwOnError, [query.state.error, query]) : options.throwOnError;
+	if (options.suspense || options.experimental_prefetchInRender || throwOnError) {
+		if (!errorResetBoundary.isReset()) options.retryOnMount = false;
+	}
+};
+var useClearResetErrorBoundary = (errorResetBoundary) => {
+	React$2.useEffect(() => {
+		errorResetBoundary.clearReset();
+	}, [errorResetBoundary]);
+};
+var getHasError = ({ result, errorResetBoundary, throwOnError, query, suspense }) => {
+	return result.isError && !errorResetBoundary.isReset() && !result.isFetching && query && (suspense && result.data === void 0 || shouldThrowError(throwOnError, [result.error, query]));
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/@tanstack+react-query@5.101.4_react@19.2.8/node_modules/@tanstack/react-query/build/modern/suspense.js
+var ensureSuspenseTimers = (defaultedOptions) => {
+	if (defaultedOptions.suspense) {
+		const MIN_SUSPENSE_TIME_MS = 1e3;
+		const clamp = (value) => value === "static" ? value : Math.max(value ?? MIN_SUSPENSE_TIME_MS, MIN_SUSPENSE_TIME_MS);
+		const originalStaleTime = defaultedOptions.staleTime;
+		defaultedOptions.staleTime = typeof originalStaleTime === "function" ? (...args) => clamp(originalStaleTime(...args)) : clamp(originalStaleTime);
+		if (typeof defaultedOptions.gcTime === "number") defaultedOptions.gcTime = Math.max(defaultedOptions.gcTime, MIN_SUSPENSE_TIME_MS);
+	}
+};
+var willFetch = (result, isRestoring) => result.isLoading && result.isFetching && !isRestoring;
+var shouldSuspend = (defaultedOptions, result) => defaultedOptions?.suspense && result.isPending;
+var fetchOptimistic = (defaultedOptions, observer, errorResetBoundary) => observer.fetchOptimistic(defaultedOptions).catch(() => {
+	errorResetBoundary.clearReset();
+});
+//#endregion
+//#region ../../../node_modules/.pnpm/@tanstack+react-query@5.101.4_react@19.2.8/node_modules/@tanstack/react-query/build/modern/useBaseQuery.js
+var React$1 = await importShared("react");
+function useBaseQuery(options, Observer, queryClient) {
+	const isRestoring = useIsRestoring();
+	const errorResetBoundary = useQueryErrorResetBoundary();
+	const client = useQueryClient(queryClient);
+	const defaultedOptions = client.defaultQueryOptions(options);
+	client.getDefaultOptions().queries?._experimental_beforeQuery?.(defaultedOptions);
+	const query = client.getQueryCache().get(defaultedOptions.queryHash);
+	const subscribed = options.subscribed !== false;
+	defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : subscribed ? "optimistic" : void 0;
+	ensureSuspenseTimers(defaultedOptions);
+	ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary, query);
+	useClearResetErrorBoundary(errorResetBoundary);
+	const isNewCacheEntry = !client.getQueryCache().get(defaultedOptions.queryHash);
+	const [observer] = React$1.useState(() => new Observer(client, defaultedOptions));
+	const result = observer.getOptimisticResult(defaultedOptions);
+	const shouldSubscribe = !isRestoring && subscribed;
+	React$1.useSyncExternalStore(React$1.useCallback((onStoreChange) => {
+		const unsubscribe = shouldSubscribe ? observer.subscribe(notifyManager.batchCalls(onStoreChange)) : noop;
+		observer.updateResult();
+		return unsubscribe;
+	}, [observer, shouldSubscribe]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
+	React$1.useEffect(() => {
+		observer.setOptions(defaultedOptions);
+	}, [defaultedOptions, observer]);
+	if (shouldSuspend(defaultedOptions, result)) throw fetchOptimistic(defaultedOptions, observer, errorResetBoundary);
+	if (getHasError({
+		result,
+		errorResetBoundary,
+		throwOnError: defaultedOptions.throwOnError,
+		query,
+		suspense: defaultedOptions.suspense
+	})) throw result.error;
+	client.getDefaultOptions().queries?._experimental_afterQuery?.(defaultedOptions, result);
+	if (defaultedOptions.experimental_prefetchInRender && !environmentManager.isServer() && willFetch(result, isRestoring)) (isNewCacheEntry ? fetchOptimistic(defaultedOptions, observer, errorResetBoundary) : query?.promise)?.catch(noop).finally(() => {
+		observer.updateResult();
+	});
+	return !defaultedOptions.notifyOnChangeProps ? observer.trackResult(result) : result;
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/@tanstack+react-query@5.101.4_react@19.2.8/node_modules/@tanstack/react-query/build/modern/useQuery.js
+function useQuery(options, queryClient) {
+	return useBaseQuery(options, QueryObserver, queryClient);
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/@tanstack+react-query@5.101.4_react@19.2.8/node_modules/@tanstack/react-query/build/modern/useMutation.js
+var React = await importShared("react");
+function useMutation(options, queryClient) {
+	const client = useQueryClient(queryClient);
+	const [observer] = React.useState(() => new MutationObserver(client, options));
+	React.useEffect(() => {
+		observer.setOptions(options);
+	}, [observer, options]);
+	const result = React.useSyncExternalStore(React.useCallback((onStoreChange) => observer.subscribe(notifyManager.batchCalls(onStoreChange)), [observer]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
+	const mutate = React.useCallback((variables, mutateOptions) => {
+		observer.mutate(variables, mutateOptions).catch(noop);
+	}, [observer]);
+	if (result.error && shouldThrowError(observer.options.throwOnError, [result.error])) throw result.error;
+	return {
+		...result,
+		mutate,
+		mutateAsync: result.mutate
+	};
+}
+//#endregion
+//#region ../../../libs/plugins-frontend-sdk/src/lib/frontend.api-client.ts
+var BASE_URL_GLOBAL = "__ATTRACCESS_API_BASE_URL__";
+/** The API origin the host is talking to. Falls back to the current origin. */
+function getApiBaseUrl() {
+	return window[BASE_URL_GLOBAL] ?? window.location.origin;
+}
+/** Thrown for any non-2xx response, carrying the status for callers that branch on it. */
+var PluginApiError = class extends Error {
+	constructor(message, status) {
+		super(message);
+		this.status = status;
+		this.name = "PluginApiError";
+	}
+};
+async function toError(res) {
+	try {
+		const body = await res.json();
+		const message = Array.isArray(body.message) ? body.message.join(", ") : body.message;
+		if (message) return new PluginApiError(message, res.status);
+	} catch {}
+	return new PluginApiError(`Request failed (HTTP ${res.status}).`, res.status);
+}
+/**
+* Creates a client bound to `basePath`, which is resolved against the host's
+* API origin. Plugin routes are mounted under `/api/<plugin-name>`, so that is
+* the usual argument; pass nothing to address the host API directly.
+*/
+function createPluginApiClient(basePath = "") {
+	const url = (path, query) => {
+		const target = new URL(`${basePath}${path}`, getApiBaseUrl());
+		Object.entries(query ?? {}).forEach(([key, value]) => {
+			if (value !== void 0 && value !== null) target.searchParams.set(key, String(value));
+		});
+		return target.toString();
+	};
+	const doFetch = (path, init) => fetch(url(path), {
+		credentials: "include",
+		...init
+	});
+	return {
+		url,
+		fetch: doFetch,
+		async request(path, options = {}) {
+			const { body, query, headers, ...init } = options;
+			const res = await fetch(url(path, query), {
+				credentials: "include",
+				...init,
+				headers: body === void 0 ? headers : {
+					"Content-Type": "application/json",
+					...headers
+				},
+				body: body === void 0 ? void 0 : JSON.stringify(body)
+			});
+			if (!res.ok) throw await toError(res);
+			const text = await res.text();
+			return text.length > 0 ? JSON.parse(text) : null;
+		}
+	};
+}
+//#endregion
+//#region frontend/src/api.ts
+var api = createPluginApiClient("/api/wago");
+var listControllers = () => api.request("/controllers");
+var getSettings = () => api.request("/settings");
+var setSettings = (defaultMqttServerId) => api.request("/settings", {
+	method: "POST",
+	body: { defaultMqttServerId }
+});
+var claimController = (id, input) => api.request(`/controllers/${id}/claim`, {
+	method: "POST",
+	body: input
+});
+var createEnrollment = (input) => api.request("/enrollments", {
+	method: "POST",
+	body: input
+});
+//#endregion
+//#region frontend/src/queries.ts
+var queryKeys = {
+	controllers: ["wago", "controllers"],
+	settings: ["wago", "settings"]
+};
+function useControllersQuery() {
+	return useQuery({
+		queryKey: queryKeys.controllers,
+		queryFn: listControllers,
+		refetchInterval: 1e4
+	});
+}
+function useSettingsQuery() {
+	return useQuery({
+		queryKey: queryKeys.settings,
+		queryFn: getSettings
+	});
+}
+function useUpdateSettingsMutation() {
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: setSettings,
+		onSuccess: async () => {
+			await queryClient.invalidateQueries({ queryKey: queryKeys.settings });
+		}
+	});
+}
+function useClaimControllerMutation() {
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: ({ id, input }) => claimController(id, input),
+		onSuccess: async () => {
+			await queryClient.invalidateQueries({ queryKey: queryKeys.controllers });
+		}
+	});
+}
+function useCreateEnrollmentMutation() {
+	return useMutation({ mutationFn: (input) => createEnrollment(input) });
+}
+//#endregion
+//#region frontend/src/ClaimControllerModal.tsx
+var { Alert: Alert$3, Button: Button$4, Form: Form$2, Input: Input$2, Label: Label$2, Modal, ModalBackdrop, ModalBody, ModalContainer, ModalDialog, ModalFooter, ModalHeader, ModalHeading, TextField: TextField$2 } = await importShared("@heroui/react");
+var { useEffectEvent, useState: useState$3 } = await importShared("react");
+function ClaimControllerModal({ controllerId, onOpenChange }) {
+	const claimMutation = useClaimControllerMutation();
+	const [name, setName] = useState$3("");
+	const [verifier, setVerifier] = useState$3("");
+	function close() {
+		setName("");
+		setVerifier("");
+		claimMutation.reset();
+		onOpenChange(false);
+	}
+	const closeClaimedController = useEffectEvent((claimedControllerId) => {
+		if (controllerId === claimedControllerId) close();
+	});
+	function submitClaim() {
+		if (controllerId === null) return;
+		const claimedControllerId = controllerId;
+		claimMutation.mutate({
+			id: claimedControllerId,
+			input: {
+				name,
+				verifier
+			}
+		}, { onSuccess: () => closeClaimedController(claimedControllerId) });
+	}
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Modal, {
+		isOpen: controllerId !== null,
+		onOpenChange: (isOpen) => {
+			if (!isOpen) close();
+		},
+		children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ModalBackdrop, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ModalContainer, {
+			size: "sm",
+			children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(ModalDialog, { children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)(ModalHeader, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ModalHeading, { children: "Claim controller" }) }), /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Form$2, {
+				onSubmit: (event) => {
+					event.preventDefault();
+					submitClaim();
+				},
+				children: [/* @__PURE__ */ (0, import_jsx_runtime.jsxs)(ModalBody, { children: [
+					/* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", {
+						className: "wg:text-sm wg:text-muted",
+						children: "Verify physical access to this controller before it can receive commands."
+					}),
+					/* @__PURE__ */ (0, import_jsx_runtime.jsxs)(TextField$2, {
+						isRequired: true,
+						name: "name",
+						children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Label$2, { children: "Controller name" }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Input$2, {
+							value: name,
+							onChange: (event) => setName(event.target.value)
+						})]
+					}),
+					/* @__PURE__ */ (0, import_jsx_runtime.jsxs)(TextField$2, {
+						isRequired: true,
+						name: "verifier",
+						children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Label$2, { children: "Physical pairing code or fingerprint" }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Input$2, {
+							value: verifier,
+							onChange: (event) => setVerifier(event.target.value)
+						})]
+					}),
+					claimMutation.isError && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Alert$3, {
+						status: "danger",
+						children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Alert$3.Indicator, {}), /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Alert$3.Content, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Alert$3.Description, { children: getErrorMessage$3(claimMutation.error) }) })]
+					})
+				] }), /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(ModalFooter, { children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Button$4, {
+					variant: "secondary",
+					onPress: close,
+					children: "Cancel"
+				}), /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Button$4, {
+					type: "submit",
+					isPending: claimMutation.isPending,
+					children: "Verify and claim"
+				})] })]
+			})] })
+		}) })
+	});
+}
+function getErrorMessage$3(error) {
+	return error instanceof Error ? error.message : "Please try again.";
+}
+//#endregion
+//#region frontend/src/CreateEnrollmentCard.tsx
+var { Alert: Alert$2, Button: Button$3, Form: Form$1, Input: Input$1, Label: Label$1, TextField: TextField$1 } = await importShared("@heroui/react");
+var { useState: useState$2 } = await importShared("react");
+function CreateEnrollmentCard() {
+	const createEnrollmentMutation = useCreateEnrollmentMutation();
+	const [hardwareId, setHardwareId] = useState$2("");
+	const [manualUsername, setManualUsername] = useState$2("");
+	const [manualPassword, setManualPassword] = useState$2("");
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("section", {
+		className: "wg:max-w-xl",
+		children: [
+			/* @__PURE__ */ (0, import_jsx_runtime.jsxs)("header", {
+				className: "wg:mb-4",
+				children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)("h2", {
+					className: "wg:text-lg wg:font-semibold",
+					children: "Enrollment package"
+				}), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", {
+					className: "wg:mt-1 wg:text-sm wg:text-muted",
+					children: "Manual credentials must be restricted to this controller's discovery and claim topics."
+				})]
+			}),
+			/* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Form$1, {
+				onSubmit: (event) => {
+					event.preventDefault();
+					createEnrollmentMutation.mutate({
+						hardwareId,
+						manualUsername: manualUsername || void 0,
+						manualPassword: manualPassword || void 0
+					});
+				},
+				children: [
+					/* @__PURE__ */ (0, import_jsx_runtime.jsxs)(TextField$1, {
+						name: "hardwareId",
+						isRequired: true,
+						children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Label$1, { children: "Controller hardware ID" }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Input$1, {
+							value: hardwareId,
+							onChange: (event) => setHardwareId(event.target.value)
+						})]
+					}),
+					/* @__PURE__ */ (0, import_jsx_runtime.jsxs)(TextField$1, {
+						name: "manualUsername",
+						children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Label$1, { children: "Manual discovery username (fallback)" }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Input$1, {
+							value: manualUsername,
+							onChange: (event) => setManualUsername(event.target.value)
+						})]
+					}),
+					/* @__PURE__ */ (0, import_jsx_runtime.jsxs)(TextField$1, {
+						name: "manualPassword",
+						type: "password",
+						children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Label$1, { children: "Manual discovery password (fallback)" }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Input$1, {
+							value: manualPassword,
+							onChange: (event) => setManualPassword(event.target.value)
+						})]
+					}),
+					/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Button$3, {
+						type: "submit",
+						isPending: createEnrollmentMutation.isPending,
+						children: "Create package"
+					})
+				]
+			}),
+			createEnrollmentMutation.isError && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Alert$2, {
+				className: "wg:mt-4",
+				status: "danger",
+				children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Alert$2.Indicator, {}), /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Alert$2.Content, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Alert$2.Description, { children: getErrorMessage$2(createEnrollmentMutation.error) }) })]
+			}),
+			createEnrollmentMutation.data && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("pre", {
+				className: "wg:mt-4 wg:overflow-x-auto wg:rounded-medium wg:bg-default-100 wg:p-4 wg:text-xs",
+				children: JSON.stringify(createEnrollmentMutation.data, null, 2)
+			})
+		]
+	});
+}
+function getErrorMessage$2(error) {
+	return error instanceof Error ? error.message : "Please try again.";
+}
+//#endregion
+//#region frontend/src/ControllersTable.tsx
+var { Button: Button$2, Chip, Table, TableBody, TableCell, TableColumn, TableContent, TableHeader, TableRow, TableScrollContainer } = await importShared("@heroui/react");
+function ControllersTable({ controllers, onClaim }) {
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Table, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(TableScrollContainer, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(TableContent, {
+		"aria-label": "WAGO controllers",
+		children: [/* @__PURE__ */ (0, import_jsx_runtime.jsxs)(TableHeader, { children: [
+			/* @__PURE__ */ (0, import_jsx_runtime.jsx)(TableColumn, {
+				isRowHeader: true,
+				children: "Controller"
+			}),
+			/* @__PURE__ */ (0, import_jsx_runtime.jsx)(TableColumn, { children: "Trust" }),
+			/* @__PURE__ */ (0, import_jsx_runtime.jsx)(TableColumn, { children: "Connection" }),
+			/* @__PURE__ */ (0, import_jsx_runtime.jsx)(TableColumn, {
+				className: "wg:hidden wg:md:table-cell",
+				children: "Runtime"
+			}),
+			/* @__PURE__ */ (0, import_jsx_runtime.jsx)(TableColumn, {
+				className: "wg:hidden wg:lg:table-cell",
+				children: "Last heartbeat"
+			}),
+			/* @__PURE__ */ (0, import_jsx_runtime.jsx)(TableColumn, {
+				className: "wg:text-end",
+				children: "Actions"
+			})
+		] }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)(TableBody, {
+			items: controllers,
+			renderEmptyState: EmptyControllers,
+			children: (controller) => /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(TableRow, {
+				id: controller.id,
+				children: [
+					/* @__PURE__ */ (0, import_jsx_runtime.jsx)(TableCell, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", {
+						className: "wg:flex wg:flex-col",
+						children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", {
+							className: "wg:font-medium",
+							children: controller.name ?? controller.hardwareId
+						}), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", {
+							className: "wg:text-xs wg:text-muted",
+							children: controller.hardwareId
+						})]
+					}) }),
+					/* @__PURE__ */ (0, import_jsx_runtime.jsx)(TableCell, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(TrustChip, { trustState: controller.trustState }) }),
+					/* @__PURE__ */ (0, import_jsx_runtime.jsx)(TableCell, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ConnectivityChip, { connectivity: controller.connectivity }) }),
+					/* @__PURE__ */ (0, import_jsx_runtime.jsxs)(TableCell, {
+						className: "wg:hidden wg:md:table-cell",
+						children: [/* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { children: [
+							controller.protocolVersion,
+							" / ",
+							controller.runtimeVersion
+						] }), controller.compatibilityError && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", {
+							className: "wg:mt-1 wg:text-xs wg:text-danger",
+							children: controller.compatibilityError
+						})]
+					}),
+					/* @__PURE__ */ (0, import_jsx_runtime.jsx)(TableCell, {
+						className: "wg:hidden wg:lg:table-cell",
+						children: formatHeartbeat(controller.lastHeartbeatAt)
+					}),
+					/* @__PURE__ */ (0, import_jsx_runtime.jsx)(TableCell, { children: controller.trustState === "untrusted" && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Button$2, {
+						size: "sm",
+						onPress: () => onClaim(controller.id),
+						children: "Claim"
+					}) })
+				]
+			}, controller.id)
+		})]
+	}) }) });
+}
+function EmptyControllers() {
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
+		className: "wg:px-4 wg:py-12 wg:text-center wg:text-sm wg:text-muted",
+		children: "No candidates yet. Configure a default MQTT server, then start the enrolled controller."
+	});
+}
+function TrustChip({ trustState }) {
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Chip, {
+		color: trustState === "claimed" ? "success" : "warning",
+		size: "sm",
+		variant: "soft",
+		children: trustState
+	});
+}
+function ConnectivityChip({ connectivity }) {
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Chip, {
+		color: connectivity === "online" ? "success" : connectivity === "stale" ? "warning" : "default",
+		size: "sm",
+		variant: "soft",
+		children: connectivity
+	});
+}
+function formatHeartbeat(lastHeartbeatAt) {
+	return lastHeartbeatAt ? new Date(lastHeartbeatAt).toLocaleString() : "Never";
+}
+//#endregion
+//#region frontend/src/MqttSettingsCard.tsx
+var { Alert: Alert$1, Button: Button$1, Form, Input, Label, Spinner: Spinner$1, TextField } = await importShared("@heroui/react");
+var { useEffect, useState: useState$1 } = await importShared("react");
+function MqttSettingsCard() {
+	const settingsQuery = useSettingsQuery();
+	const updateSettingsMutation = useUpdateSettingsMutation();
+	const [defaultServerId, setDefaultServerId] = useState$1("");
+	useEffect(() => {
+		setDefaultServerId(settingsQuery.data?.defaultMqttServerId?.toString() ?? "");
+	}, [settingsQuery.data]);
+	if (settingsQuery.isPending) return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Spinner$1, {
+		color: "accent",
+		size: "sm"
+	});
+	if (settingsQuery.isError) return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Alert$1, {
+		status: "danger",
+		children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Alert$1.Indicator, {}), /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Alert$1.Content, { children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Alert$1.Title, { children: "Could not load MQTT settings" }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Alert$1.Description, { children: getErrorMessage$1(settingsQuery.error) })] })]
+	});
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("section", {
+		className: "wg:max-w-xl",
+		children: [/* @__PURE__ */ (0, import_jsx_runtime.jsxs)("header", {
+			className: "wg:mb-4",
+			children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)("h2", {
+				className: "wg:text-lg wg:font-semibold",
+				children: "MQTT settings"
+			}), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", {
+				className: "wg:mt-1 wg:text-sm wg:text-muted",
+				children: "Select the MQTT server used when claiming controllers."
+			})]
+		}), /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Form, {
+			onSubmit: (event) => {
+				event.preventDefault();
+				updateSettingsMutation.mutate(defaultServerId ? Number(defaultServerId) : null);
+			},
+			children: [
+				/* @__PURE__ */ (0, import_jsx_runtime.jsxs)(TextField, {
+					name: "defaultMqttServerId",
+					type: "number",
+					children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Label, { children: "Default MQTT server ID" }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Input, {
+						min: "1",
+						value: defaultServerId,
+						onChange: (event) => setDefaultServerId(event.target.value)
+					})]
+				}),
+				updateSettingsMutation.isError && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Alert$1, {
+					className: "wg:mt-4",
+					status: "danger",
+					children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Alert$1.Indicator, {}), /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Alert$1.Content, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Alert$1.Description, { children: getErrorMessage$1(updateSettingsMutation.error) }) })]
+				}),
+				/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Button$1, {
+					type: "submit",
+					isPending: updateSettingsMutation.isPending,
+					children: "Save"
+				})
+			]
+		})]
+	});
+}
+function getErrorMessage$1(error) {
+	return error instanceof Error ? error.message : "Please try again.";
+}
+//#endregion
+//#region frontend/src/ControllersPage.tsx
+var { Alert, Button, Spinner } = await importShared("@heroui/react");
+var { RefreshCwIcon } = await importShared("lucide-react");
+var { useState } = await importShared("react");
+function ControllersPage() {
+	const controllersQuery = useControllersQuery();
+	const [claimControllerId, setClaimControllerId] = useState(null);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("main", {
+		className: "wg:mx-auto wg:flex wg:w-full wg:max-w-6xl wg:flex-col wg:gap-6 wg:p-4 wg:md:p-6",
+		children: [
+			/* @__PURE__ */ (0, import_jsx_runtime.jsxs)("header", {
+				className: "wg:flex wg:flex-wrap wg:items-center wg:justify-between wg:gap-4",
+				children: [/* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)("h1", {
+					className: "wg:text-2xl wg:font-semibold",
+					children: "WAGO controllers"
+				}), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", {
+					className: "wg:mt-1 wg:text-sm wg:text-muted",
+					children: "Discovery candidates cannot receive commands until physically claimed."
+				})] }), /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Button, {
+					variant: "secondary",
+					isPending: controllersQuery.isFetching,
+					onPress: () => void controllersQuery.refetch(),
+					children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)(RefreshCwIcon, { className: "wg:h-4 wg:w-4" }), " Refresh"]
+				})]
+			}),
+			/* @__PURE__ */ (0, import_jsx_runtime.jsx)(MqttSettingsCard, {}),
+			/* @__PURE__ */ (0, import_jsx_runtime.jsx)(CreateEnrollmentCard, {}),
+			controllersQuery.isError && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Alert, {
+				status: "danger",
+				children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Alert.Indicator, {}), /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Alert.Content, { children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Alert.Title, { children: "Could not load WAGO controllers" }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Alert.Description, { children: getErrorMessage(controllersQuery.error) })] })]
+			}),
+			controllersQuery.isPending ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
+				className: "wg:flex wg:justify-center wg:p-6",
+				children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Spinner, { color: "accent" })
+			}) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ControllersTable, {
+				controllers: controllersQuery.data ?? [],
+				onClaim: setClaimControllerId
+			}),
+			/* @__PURE__ */ (0, import_jsx_runtime.jsx)(ClaimControllerModal, {
+				controllerId: claimControllerId,
+				onOpenChange: (isOpen) => {
+					if (!isOpen) setClaimControllerId(null);
+				}
+			})
+		]
+	});
+}
+function getErrorMessage(error) {
+	return error instanceof Error ? error.message : "Please try again.";
+}
+//#endregion
+//#region frontend/src/plugin.tsx
+var { CpuIcon } = await importShared("lucide-react");
+var WagoPlugin = class {
+	getPluginName() {
+		return "wago-plugin@0.1.0";
+	}
+	getDependencies() {
+		return [];
+	}
+	init(store) {}
+	activate() {}
+	deactivate() {}
+	onApiAuthStateChange(authData) {}
+	onApiEndpointChange(endpoint) {}
+	getRoutes() {
+		return [{
+			path: "/wago",
+			authRequired: "resources.update",
+			element: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ControllersPage, {})
+		}];
+	}
+	getSidebarItems() {
+		return [{
+			label: "WAGO",
+			path: "/wago",
+			icon: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(CpuIcon, { className: "wg:w-5 wg:h-5" })
+		}];
+	}
+};
+//#endregion
+export { WagoPlugin as default };