@attraccess/plugin-wago 0.1.0-nightly.1059.1 → 0.1.0-nightly.1064.1

package/dist/index.js

@@ -5346,6 +5346,7 @@ var WagoService = class {
     if (canonical && (admitted || !canTrackDiagnostics) && typeof rawHeartbeat.streamId === "string" && typeof rawHeartbeat.timestamp === "string") {
       this.runtimeStatusHandler?.(controller.id, {
         imageId: heartbeat.runtimeImageId ?? "",
+        runtimeVersion: heartbeat.runtimeVersion,
         streamId: rawHeartbeat.streamId,
         timestamp: Date.parse(rawHeartbeat.timestamp),
         receivedAt: Date.now(),
@@ -9345,15 +9346,40 @@ require_transaction
 case "$(cat "$tx/phase")" in
   accepted|accepted-cleaning)
     owned_new_container || fail 'Foreign runtime container'
+    test "$(docker inspect --format '{{.Image}}' attraccess-wago)" = "$(cat "$tx/image-id")" || fail 'Accepted runtime image changed'
     phase accepted-cleaning
     previous=$(docker container ls -a --no-trunc --filter 'name=^/attraccess-wago.previous$' --format '{{.ID}}')
     if test -n "$previous"; then
       test "$previous" = "$(cat "$tx/previous-id")" || fail 'Foreign previous runtime'
       docker rm "$previous" >/dev/null
-    fi ;;
-  restored) ;;
+    fi
+    retired_image=$(cat "$tx/previous-image-id") ;;
+  restored)
+    test "$(docker inspect --format '{{.Image}}' attraccess-wago)" = "$(cat "$tx/previous-image-id")" || fail 'Restored runtime image changed'
+    retired_image=$(cat "$tx/image-id") ;;
   *) fail 'Update has not been accepted or restored' ;;
 esac
+# Keep the receipt until image cleanup succeeds. A crash after image removal is
+# harmless: a successful inventory distinguishes an absent image from a failed
+# Docker query. Never force removal or prune images outside this transaction.
+retired_digest=\${retired_image#sha256:}
+test "$retired_image" != "$retired_digest" && test "\${#retired_digest}" = 64 || fail 'Invalid retired image identity'
+case "$retired_digest" in *[!a-f0-9]*) fail 'Invalid retired image identity' ;; esac
+images=$(docker image ls --no-trunc --quiet) || fail 'Cannot inventory runtime images'
+printf '%s\\n' "$images" | awk 'NF && ($0 !~ /^sha256:[a-f0-9]+$/ || length($0)!=71) {bad=1} END {exit bad}' || fail 'Invalid runtime image inventory'
+if printf '%s\\n' "$images" | grep -Fxq "$retired_image"; then
+  containers=$(docker container ls -a --no-trunc --format '{{.ID}}') || fail 'Cannot inventory runtime containers'
+  referenced=0
+  for container in $containers; do
+    container_image=$(docker inspect --format '{{.Image}}' "$container") || fail 'Cannot inspect runtime image references'
+    if test "$container_image" = "$retired_image"; then referenced=1; fi
+  done
+  # Stopped containers also retain their images. Docker enforces this again if
+  # an unrelated workload appears after the reference inventory.
+  if test "$referenced" = 0; then
+    docker image rm "$retired_image" >/dev/null || fail 'Retired runtime image cleanup failed'
+  fi
+fi
 mv "$tx" "$cleanup"
 sync
 rm -rf "$cleanup"
@@ -10182,6 +10208,9 @@ var import_node_stream2 = require("node:stream");
 
 // backend/wago-runtime-update.ts
 var import_node_crypto14 = require("node:crypto");
+function runtimeTargetImageId(desired, installed) {
+  return installed.imageId && installed.runtimeVersion === desired.manifest.runtimeVersion ? installed.imageId : desired.imageId;
+}
 var RuntimeUpdateError = class extends Error {
   constructor(failure, storageDiagnostics) {
     super(
@@ -10297,7 +10326,7 @@ var WagoRuntimeUpdateCoordinator = class {
       }
       const desired = await this.desired();
       assertOwned();
-      const contradictedCurrent = record2?.phase === "current" && observedImageId !== void 0 && observedImageId !== desired.imageId;
+      const contradictedCurrent = record2?.phase === "current" && observedImageId !== void 0 && observedImageId !== (record2.currentImageId ?? record2.desiredImageId);
       if (record2 && !contradictedCurrent && record2.desiredImageId === desired.imageId && record2.retryAt > this.now())
         return "deferred";
       const attempt = (record2?.desiredImageId === desired.imageId ? record2.attempt : 0) + 1;
@@ -10368,11 +10397,12 @@ var WagoRuntimeUpdateCoordinator = class {
           return "settled";
         }
       }
-      if (inspection.imageId === desired.imageId) {
+      const targetImageId = runtimeTargetImageId(desired, inspection);
+      if (inspection.imageId === targetImageId) {
         const since = record2.startedAt;
         try {
-          const proof = await this.host.verify(controllerId, null, desired.imageId, since, operation.signal);
-          if (!proof.permanent || !proof.ready || proof.imageId !== desired.imageId || !Number.isSafeInteger(proof.observedAt) || proof.observedAt <= since || proof.observedAt > this.now())
+          const proof = await this.host.verify(controllerId, null, targetImageId, since, operation.signal);
+          if (!proof.permanent || !proof.ready || proof.imageId !== targetImageId || !Number.isSafeInteger(proof.observedAt) || proof.observedAt <= since || proof.observedAt > this.now())
             throw new RuntimeUpdateError("readiness");
           await this.assertCurrent(desired.imageId);
         } catch (error) {
@@ -10384,6 +10414,7 @@ var WagoRuntimeUpdateCoordinator = class {
           return "settled";
         }
         record2.phase = "current";
+        record2.currentImageId = targetImageId;
         record2.attempt = 0;
         record2.retryAt = this.now() + CURRENT_RECHECK_MS;
         await persist(record2);
@@ -10417,6 +10448,7 @@ var WagoRuntimeUpdateCoordinator = class {
         await persist(record2);
         await this.host.accept(controllerId, record2.token, operation.signal);
         record2.phase = "current";
+        record2.currentImageId = desired.imageId;
         record2.attempt = 0;
         record2.retryAt = this.now() + CURRENT_RECHECK_MS;
         await persist(record2);
@@ -10842,7 +10874,7 @@ var WagoManagedRuntimeService = class {
     __publicField(this, "coordinator");
     __publicField(this, "heartbeats", /* @__PURE__ */ new Map());
     __publicField(this, "heartbeatStreams", /* @__PURE__ */ new Map());
-    __publicField(this, "previousBoots", /* @__PURE__ */ new Map());
+    __publicField(this, "runtimeActivations", /* @__PURE__ */ new Map());
     __publicField(this, "verifyingControllers", /* @__PURE__ */ new Set());
     __publicField(this, "connectingControllers", /* @__PURE__ */ new Set());
     __publicField(this, "reconciliationFailures", /* @__PURE__ */ new Map());
@@ -10888,7 +10920,7 @@ var WagoManagedRuntimeService = class {
           this.heartbeatStreams.delete(oldest);
         }
       }
-      if (!previous || previous.runtimePolicyToken !== heartbeat.runtimePolicyToken || previous.streamId !== heartbeat.streamId || previous.imageId !== heartbeat.imageId || heartbeat.receivedAt - previous.receivedAt > 9e4) {
+      if (!previous || previous.runtimePolicyToken !== heartbeat.runtimePolicyToken || previous.streamId !== heartbeat.streamId || previous.imageId !== heartbeat.imageId || previous.runtimeVersion !== heartbeat.runtimeVersion || heartbeat.receivedAt - previous.receivedAt > 9e4) {
         this.wago.blockRuntime?.(id);
         if (!this.connectingControllers.has(id) && this.connectingControllers.size < 200) {
           this.connectingControllers.add(id);
@@ -11039,7 +11071,10 @@ var WagoManagedRuntimeService = class {
           runningVersion: controller.runtimeVersion,
           runningImageId: this.heartbeats.get(controller.id)?.imageId || null,
           desiredVersion: desired?.manifest.runtimeVersion ?? null,
-          desiredImageId: desired && "imageId" in desired ? desired.imageId : null
+          desiredImageId: desired && "imageId" in desired ? runtimeTargetImageId(desired, {
+            imageId: this.heartbeats.get(controller.id)?.imageId ?? "",
+            runtimeVersion: this.heartbeats.get(controller.id)?.runtimeVersion ?? controller.runtimeVersion
+          }) : null
         }
       } : {},
       ...access?.controllerId && this.wago.isRuntimeUpdateRequired ? { runtimeUpdateRequired: this.wago.isRuntimeUpdateRequired(access.controllerId) } : {},
@@ -11330,9 +11365,13 @@ var WagoManagedRuntimeService = class {
     if (!heartbeat || this.destroyed) return;
     const access = await this.access.findOne({ where: { controllerId: id }, order: { sessionId: "DESC" } });
     const enrolling = access?.state === "verified" || access?.state === "recovery_required";
+    const controller = await this.controllers.findOneBy({ id, trustState: "claimed" });
     await this.wago.setRuntimePolicy?.(
       id,
-      enrolling ? heartbeat.imageId : desired.imageId,
+      enrolling ? heartbeat.imageId : runtimeTargetImageId(desired, {
+        imageId: heartbeat.imageId,
+        runtimeVersion: heartbeat.runtimeVersion ?? controller?.runtimeVersion
+      }),
       heartbeat.imageId,
       heartbeat.runtimePolicyToken
     );
@@ -11631,7 +11670,7 @@ var WagoManagedRuntimeService = class {
         if (!match) throw new RuntimeUpdateError("incompatible");
         return {
           imageId: match[2],
-          runtimeVersion: controller?.runtimeVersion,
+          runtimeVersion: this.heartbeats.get(id)?.runtimeVersion ?? controller?.runtimeVersion,
           claimed: !!controller,
           managed: true,
           compatible: true,
@@ -11678,10 +11717,13 @@ var WagoManagedRuntimeService = class {
           await bundle.cleanup();
         }
       },
-      activate: async (id, token, _artifact, signal) => {
+      activate: async (id, token, artifact, signal) => {
         const heartbeat = this.heartbeats.get(id);
-        if (!heartbeat || Date.now() - heartbeat.receivedAt > 9e4) throw new RuntimeUpdateError("offline");
-        this.previousBoots.set(token, heartbeat.streamId);
+        this.runtimeActivations.set(token, {
+          imageId: artifact.imageId,
+          startedAt: Date.now(),
+          previousStreamId: heartbeat?.streamId
+        });
         this.verifyingControllers.add(id);
         await command(id, "activate", token, signal);
       },
@@ -11689,11 +11731,13 @@ var WagoManagedRuntimeService = class {
         const controller = await this.controllers.findOneByOrFail({ id, trustState: "claimed" });
         if (!controller.mqttServerId) throw new RuntimeUpdateError("offline");
         const prefix = (await this.wago.getSettings()).operationalPrefix;
+        const activation = _token === null ? void 0 : this.runtimeActivations.get(_token);
+        const freshSince = Math.max(since, activation?.startedAt ?? since);
         for (let attempt = 0; attempt < 120; attempt++) {
           signal.throwIfAborted();
           const heartbeat = this.heartbeats.get(id);
           const state = this.readiness.observe(controller.mqttServerId, controller.hardwareId, prefix);
-          if (heartbeat?.imageId === imageId && (_token === null || this.previousBoots.has(_token) && heartbeat.streamId !== this.previousBoots.get(_token)) && heartbeat.timestamp > since && heartbeat.receivedAt > since && Date.now() - heartbeat.receivedAt < 9e4 && state?.timestamp > since && Date.now() - state.timestamp < 9e4 && state.streamId === heartbeat.streamId && state.ready)
+          if (heartbeat?.imageId === imageId && (_token === null || activation?.imageId === imageId && heartbeat.streamId !== activation.previousStreamId) && heartbeat.timestamp > freshSince && heartbeat.receivedAt > freshSince && Date.now() - heartbeat.receivedAt < 9e4 && state?.timestamp > freshSince && Date.now() - state.timestamp < 9e4 && state.streamId === heartbeat.streamId && state.ready)
             return { imageId, observedAt: heartbeat.receivedAt, permanent: true, ready: true };
           await new Promise((resolve2) => setTimeout(resolve2, 1e3));
         }
@@ -11706,7 +11750,7 @@ var WagoManagedRuntimeService = class {
         try {
           await command(id, "acknowledge", token, signal);
         } finally {
-          this.previousBoots.delete(token);
+          this.runtimeActivations.delete(token);
           this.verifyingControllers.delete(id);
         }
       },
@@ -11714,7 +11758,7 @@ var WagoManagedRuntimeService = class {
         try {
           await command(id, "recover", token, signal, previous);
         } finally {
-          this.previousBoots.delete(token);
+          this.runtimeActivations.delete(token);
           this.verifyingControllers.delete(id);
         }
       }
@@ -11750,7 +11794,7 @@ var WagoManagedRuntimeService = class {
     await stopped;
     this.heartbeats.clear();
     this.heartbeatStreams.clear();
-    this.previousBoots.clear();
+    this.runtimeActivations.clear();
     this.verifyingControllers.clear();
     this.enrolmentProgress.clear();
   }
@@ -15777,6 +15821,81 @@ WagoUpdatesController = __decorateClass([
   __decorateParam(1, (0, import_common17.Inject)(WagoNetworkChangeService))
 ], WagoUpdatesController);
 
+// backend/wago-live-updates.service.ts
+var import_common18 = require("@nestjs/common");
+var import_plugins_backend_sdk21 = require("@attraccess/plugins-backend-sdk");
+var WagoLiveUpdatesService = class {
+  constructor(context, wago, commissioning, diagnostics, managed, network) {
+    __publicField(this, "context", context);
+    __publicField(this, "wago", wago);
+    __publicField(this, "commissioning", commissioning);
+    __publicField(this, "diagnostics", diagnostics);
+    __publicField(this, "managed", managed);
+    __publicField(this, "network", network);
+    __publicField(this, "sample", (0, import_plugins_backend_sdk21.createSharedLiveSampler)());
+  }
+  onModuleInit() {
+    const live = this.context.liveUpdates;
+    if (!live) throw new Error("WAGO live updates require a host with plugin live-update support");
+    const register = (topic, interval, permission, kind, read) => {
+      live.register({
+        topic,
+        identifier: kind === "none" ? "none" : "required",
+        authorize: async ({ identifier: identifier3 }, user) => {
+          if (!user.effectivePermissions?.has(permission)) throw new import_common18.ForbiddenException();
+          if (kind === "none") return;
+          const pattern = kind === "revisions" ? /^[1-9]\d*:(0|[1-9]\d*)$/ : /^[1-9]\d*$/;
+          if (!pattern.test(identifier3 ?? "")) throw new import_common18.NotFoundException();
+          const [id, offset = 0] = identifier3.split(":").map(Number);
+          if (!Number.isSafeInteger(id) || !Number.isSafeInteger(offset)) throw new import_common18.NotFoundException();
+          const exists = kind === "session" ? await this.context.getRepository(WagoCommissioningSession).existsBy({ id }) : await this.context.getRepository(WagoController).existsBy({ id });
+          if (!exists) throw new import_common18.NotFoundException();
+        },
+        source: ({ identifier: identifier3 }) => this.sample(`${topic}:${identifier3 ?? ""}`, interval, () => {
+          const [id = 0, offset = 0] = (identifier3 ?? "").split(":").map(Number);
+          return read(id, offset);
+        })
+      });
+    };
+    register("controllers", 1e4, "resources.update", "none", () => this.wago.list());
+    register("commissioning-sessions", 2e3, "system.settings.manage", "none", () => this.commissioning.list(100, 0));
+    register("diagnostics", 2e3, "resources.update", "controller", (id) => this.diagnostics.get(id));
+    register(
+      "configuration-baseline",
+      2e3,
+      "resources.update",
+      "controller",
+      (id) => this.wago.getConfigurationBaseline(id)
+    );
+    register(
+      "configuration-revisions",
+      2e3,
+      "resources.update",
+      "revisions",
+      (id, offset) => this.wago.revisionsFor(id, offset)
+    );
+    register(
+      "commissioning-verification",
+      5e3,
+      "system.settings.manage",
+      "session",
+      (id) => this.commissioning.verification(id)
+    );
+    register("runtime-update", 5e3, "system.settings.manage", "controller", (id) => this.managed.status(id));
+    register("managed-access", 5e3, "system.settings.manage", "session", (id) => this.managed.sessionStatus(id));
+    register("network-change", 2e3, "system.settings.manage", "controller", (id) => this.network.status(id));
+  }
+};
+WagoLiveUpdatesService = __decorateClass([
+  (0, import_common18.Injectable)(),
+  __decorateParam(0, (0, import_common18.Inject)(/* @__PURE__ */ Symbol.for("attraccess.plugin.context"))),
+  __decorateParam(1, (0, import_common18.Inject)(WagoService)),
+  __decorateParam(2, (0, import_common18.Inject)(WagoCommissioningService)),
+  __decorateParam(3, (0, import_common18.Inject)(WagoDiagnosticsService)),
+  __decorateParam(4, (0, import_common18.Inject)(WagoManagedRuntimeService)),
+  __decorateParam(5, (0, import_common18.Inject)(WagoNetworkChangeService))
+], WagoLiveUpdatesService);
+
 // backend/plugin.ts
 var PLUGIN_CONTEXT6 = /* @__PURE__ */ Symbol.for("attraccess.plugin.context");
 var WagoPluginModule = class {
@@ -15835,7 +15954,8 @@ var plugin = {
         WagoManagedRuntimeService,
         WagoCommissioningService,
         WagoCredentialRotationService,
-        WagoNetworkChangeService
+        WagoNetworkChangeService,
+        WagoLiveUpdatesService
       ]
     };
   }

package/frontend/{__federation_expose_Plugin-BQawMHeJ.js → __federation_expose_Plugin-KY-OYpkJ.js}

@@ -61,9 +61,6 @@ function createPluginApiClient(basePath = "") {
 	};
 }
 //#endregion
-//#region ../../../libs/plugins-frontend-sdk/src/lib/frontend.slots.ts
-var RESOURCE_OVERVIEW_SLOT = "resource.overview";
-//#endregion
 //#region ../../../node_modules/.pnpm/react@19.2.8/node_modules/react/cjs/react-jsx-runtime.production.js
 /**
 * @license React
@@ -99,10 +96,64 @@ var require_react_jsx_runtime_production = /* @__PURE__ */ __commonJSMin(((expor
 	exports.jsxs = jsxProd;
 }));
 //#endregion
-//#region ../../../libs/plugins-frontend-sdk/src/lib/frontend.standard-drawer.tsx
+//#region ../../../libs/plugins-frontend-sdk/src/lib/frontend.live-updates.tsx
 var import_jsx_runtime = (/* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = require_react_jsx_runtime_production();
 })))();
+var { createContext, useCallback, useContext, useEffect: useEffect$12, useRef: useRef$5 } = await importShared("react");
+var contextKey = Symbol.for("attraccess.plugin.live-updates.context");
+var contexts = globalThis;
+var LiveContext = contexts[contextKey] ??= createContext(null);
+function usePluginLiveUpdates(props) {
+	const client = useContext(LiveContext);
+	const latest = useRef$5({
+		props,
+		client
+	});
+	latest.current = {
+		props,
+		client
+	};
+	const unsubscribe = useRef$5(null);
+	const { plugin, topic, identifier, enabled = true } = props;
+	useEffect$12(() => {
+		if (!client || !enabled) return;
+		let active = true;
+		const matches = () => active && latest.current.client === client && latest.current.props.enabled !== false && latest.current.props.plugin === plugin && latest.current.props.topic === topic && latest.current.props.identifier === identifier;
+		const remove = client.subscribe({
+			topic: `plugin:${encodeURIComponent(plugin)}:${topic}`,
+			...identifier !== void 0 ? { identifier } : {}
+		}, (payload) => {
+			if (matches()) return latest.current.props.onUpdate(payload);
+		}, () => {
+			if (matches()) return latest.current.props.onReconnect?.();
+		}, () => {
+			if (matches()) return latest.current.props.onUnavailable?.();
+		});
+		const cleanup = () => {
+			if (!active) return;
+			active = false;
+			remove();
+		};
+		unsubscribe.current = cleanup;
+		return () => {
+			cleanup();
+			if (unsubscribe.current === cleanup) unsubscribe.current = null;
+		};
+	}, [
+		client,
+		plugin,
+		topic,
+		identifier,
+		enabled
+	]);
+	return { abort: useCallback(() => unsubscribe.current?.(), []) };
+}
+//#endregion
+//#region ../../../libs/plugins-frontend-sdk/src/lib/frontend.slots.ts
+var RESOURCE_OVERVIEW_SLOT = "resource.overview";
+//#endregion
+//#region ../../../libs/plugins-frontend-sdk/src/lib/frontend.standard-drawer.tsx
 var { DrawerBackdrop: DrawerBackdrop$1, DrawerContent: DrawerContent$1, DrawerDialog: DrawerDialog$1 } = await importShared("@heroui/react");
 //#endregion
 //#region ../../../libs/plugins-frontend-sdk/src/lib/frontend.standard-modal.tsx
@@ -112,6 +163,69 @@ var { Modal: Modal$3, ModalBackdrop: ModalBackdrop$2, ModalContainer: ModalConta
 /** Invalidate this prefix after plugin configuration changes to refresh canvas summaries. */
 var FLOW_NODE_PREVIEW_QUERY_KEY = ["flow-node-preview"];
 //#endregion
+//#region frontend/src/live-updates.ts
+var { useQueryClient: useQueryClient$4 } = await importShared("@tanstack/react-query");
+var liveStates = /* @__PURE__ */ new WeakMap();
+/** Initial reads/mutations remain REST; the host stream owns snapshots and reconnect refresh. */
+function useWagoLiveQuery(queryKey, topic, identifier, enabled = true) {
+	const client = useQueryClient$4();
+	const onUpdate = (event) => {
+		const existingQuery = client.getQueryCache().find({
+			queryKey,
+			exact: true
+		});
+		const previous = existingQuery && liveStates.get(existingQuery);
+		const cancellation = client.cancelQueries({
+			queryKey,
+			exact: true
+		});
+		if (event.eventType === "snapshot") client.setQueryData(queryKey, event.value);
+		else {
+			const query = client.getQueryCache().find({
+				queryKey,
+				exact: true
+			});
+			query?.setState({
+				...existingQuery === query && previous?.pendingRead === query.promise ? previous?.state : void 0,
+				status: "error",
+				error: /* @__PURE__ */ new Error("Live updates are temporarily unavailable."),
+				errorUpdatedAt: Date.now()
+			});
+		}
+		const query = client.getQueryCache().find({
+			queryKey,
+			exact: true
+		});
+		if (!query) return;
+		const state = query.state;
+		const pendingRead = query.promise;
+		liveStates.set(query, {
+			state,
+			pendingRead
+		});
+		return cancellation.then(() => {
+			if (liveStates.get(query)?.state === state && query.promise === pendingRead && client.getQueryCache().find({
+				queryKey,
+				exact: true
+			}) === query) {
+				liveStates.delete(query);
+				if (query.state !== state || query.state.fetchStatus !== "idle") query.setState({
+					...state,
+					fetchStatus: "idle"
+				});
+			}
+		});
+	};
+	return usePluginLiveUpdates({
+		plugin: "wago",
+		topic,
+		identifier,
+		enabled,
+		onUpdate,
+		onUnavailable: () => onUpdate({ eventType: "unavailable" })
+	});
+}
+//#endregion
 //#region frontend/src/api.ts
 var api$5 = createPluginApiClient("/api/wago");
 var hostApi = createPluginApiClient("/api");
@@ -234,18 +348,17 @@ var queryKeys = {
 	commissioningSessions: ["wago", "commissioning-sessions"]
 };
 function useControllersQuery() {
+	useWagoLiveQuery(queryKeys.controllers, "controllers");
 	return useQuery$6({
 		queryKey: queryKeys.controllers,
-		queryFn: listControllers,
-		refetchInterval: 1e4
+		queryFn: listControllers
 	});
 }
 function useCommissioningSessionsQuery() {
+	useWagoLiveQuery(queryKeys.commissioningSessions, "commissioning-sessions");
 	return useQuery$6({
 		queryKey: queryKeys.commissioningSessions,
-		queryFn: ({ signal }) => listCommissioningSessions(100, 0, signal),
-		refetchInterval: 2e3,
-		refetchIntervalInBackground: true
+		queryFn: ({ signal }) => listCommissioningSessions(100, 0, signal)
 	});
 }
 function useSettingsQuery() {
@@ -350,10 +463,10 @@ function useDraftQuery(controllerId) {
 	});
 }
 function useConfigurationRevisionsQuery(controllerId, offset) {
+	useWagoLiveQuery([...queryKeys.revisions(controllerId), offset], "configuration-revisions", `${controllerId}:${offset}`);
 	return useQuery$6({
 		queryKey: [...queryKeys.revisions(controllerId), offset],
-		queryFn: () => listConfigurationRevisions(controllerId, offset),
-		refetchInterval: 2e3
+		queryFn: () => listConfigurationRevisions(controllerId, offset)
 	});
 }
 function useConfigurationRevisionPreviewQuery(controllerId, revision, enabled) {
@@ -3382,16 +3495,23 @@ function ClaimControllerModal({ controllerId, onOpenChange }) {
 //#region frontend/src/useRuntimeStatus.ts
 var { useQuery: useQuery$5 } = await importShared("@tanstack/react-query");
 function useRuntimeStatus(target) {
+	const controllerId = target && "controller" in target ? target.controller.id : null;
+	const sessionId = target && "session" in target ? target.session.id : null;
+	useWagoLiveQuery([
+		"wago",
+		"runtime-update",
+		controllerId,
+		sessionId
+	], controllerId !== null ? "runtime-update" : "managed-access", String(controllerId ?? sessionId), !!target);
 	return useQuery$5({
 		queryKey: [
 			"wago",
 			"runtime-update",
-			target && "controller" in target ? target.controller.id : null,
-			target && "session" in target ? target.session.id : null
+			controllerId,
+			sessionId
 		],
 		queryFn: () => target && "controller" in target ? getRuntimeUpdateStatus(target.controller.id) : target && "session" in target ? getManagedAccessStatus(target.session.id) : Promise.reject(/* @__PURE__ */ new Error("No controller selected")),
 		enabled: !!target,
-		refetchInterval: 5e3,
 		staleTime: 4e3,
 		retry: false
 	});
@@ -3692,6 +3812,11 @@ var { useEffect: useEffect$10, useState: useState$17 } = await importShared("rea
 /** Enrollment evidence is independent of configuration and physical qualification. */
 function useCommissioningVerification(session) {
 	const enabled = ["awaiting_verification", "completed"].includes(session.state);
+	useWagoLiveQuery([
+		"wago",
+		"commissioning-verification",
+		session.id
+	], "commissioning-verification", String(session.id), enabled);
 	const query = useQuery$4({
 		queryKey: [
 			"wago",
@@ -3699,9 +3824,7 @@ function useCommissioningVerification(session) {
 			session.id
 		],
 		queryFn: () => getCommissioningVerification(session.id),
-		enabled,
-		refetchInterval: 5e3,
-		refetchIntervalInBackground: true
+		enabled
 	});
 	const [now, setNow] = useState$17(Date.now);
 	useEffect$10(() => {
@@ -3740,10 +3863,10 @@ function NetworkChangeForm({ controllerId }) {
 		"network-change",
 		controllerId
 	];
+	useWagoLiveQuery(queryKey, "network-change", String(controllerId));
 	const statusQuery = useQuery$3({
 		queryKey,
 		queryFn: () => getNetworkChangeStatus(controllerId),
-		refetchInterval: 2e3,
 		retry: false
 	});
 	const servers = useQuery$3({
@@ -9258,7 +9381,12 @@ function DeviceSettings({ configuration, device: original, onChange, onClose, is
 //#region frontend/src/diagnostics.ts
 var { useQuery: useQuery$2 } = await importShared("@tanstack/react-query");
 var api$1 = createPluginApiClient("/api/wago");
-function useWagoDiagnostics(controllerId, refetchInterval = 5e3) {
+function useWagoDiagnostics(controllerId) {
+	useWagoLiveQuery([
+		"wago",
+		"diagnostics",
+		controllerId
+	], "diagnostics", String(controllerId), controllerId !== null);
 	return useQuery$2({
 		queryKey: [
 			"wago",
@@ -9267,7 +9395,6 @@ function useWagoDiagnostics(controllerId, refetchInterval = 5e3) {
 		],
 		queryFn: () => api$1.request(`/controllers/${controllerId}/diagnostics`),
 		enabled: controllerId !== null,
-		refetchInterval,
 		retry: 1
 	});
 }
@@ -9300,16 +9427,20 @@ function useFrontPanel(controllerId) {
 	];
 	const [restored] = useState$4(() => client.getQueryData(key));
 	const draft = useDraftQuery(controllerId);
+	useWagoLiveQuery([
+		"wago",
+		"configuration-baseline",
+		controllerId
+	], "configuration-baseline", String(controllerId));
 	const baseline = useQuery$1({
 		queryKey: [
 			"wago",
 			"configuration-baseline",
 			controllerId
 		],
-		queryFn: () => getConfigurationBaseline(controllerId),
-		refetchInterval: 2e3
+		queryFn: () => getConfigurationBaseline(controllerId)
 	});
-	const diagnostics = useWagoDiagnostics(controllerId, 2e3);
+	const diagnostics = useWagoDiagnostics(controllerId);
 	const [configuration, setConfiguration] = useState$4(restored?.configuration ?? null);
 	const loadedDraft = useRef(restored?.loadedDraft ?? null);
 	const [editing, setEditing] = useState$4(Boolean(restored));

package/frontend/remoteEntry.js

@@ -75,7 +75,7 @@ var exportSet = /* @__PURE__ */ new Set([
 ]);
 var moduleMap = { "./plugin": () => {
 	dynamicLoadingCss(["style.css"], false, "./plugin");
-	return __federation_import("./__federation_expose_Plugin-BQawMHeJ.js").then((module) => Object.keys(module).every((item) => exportSet.has(item)) ? () => module.default : () => module);
+	return __federation_import("./__federation_expose_Plugin-KY-OYpkJ.js").then((module) => Object.keys(module).every((item) => exportSet.has(item)) ? () => module.default : () => module);
 } };
 var seen = {};
 var dynamicLoadingCss = (cssFilePaths, dontAppendStylesToHead, exposeItemName) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@attraccess/plugin-wago",
-  "version": "0.1.0-nightly.1059.1",
+  "version": "0.1.0-nightly.1064.1",
   "description": "Official Attraccess integration for WAGO CC100 controllers.",
   "keywords": [
     "attraccess-plugin",