@attraccess/plugin-wago 0.1.0-nightly.966.1 → 0.1.0-nightly.970.1

package/dist/index.js

@@ -52485,6 +52485,23 @@ async function auditCommissioning(context, principal, id, action, operation, suc
 var import_node_crypto3 = require("node:crypto");
 var import_common2 = require("@nestjs/common");
 
+// channel-behavior.ts
+function outputBehavior(channel) {
+  if (!channel.capabilities.includes("output")) return null;
+  return channel.capabilities.includes("pulse") || channel.pulse !== void 0 ? "pulsed" : "switched";
+}
+function supportsOutputAction(channel, action) {
+  const behavior = outputBehavior(channel);
+  return behavior === "switched" ? action === "set" : behavior === "pulsed" && action === "pulse" && !pulseBehaviorError(channel.capabilities, channel.pulse);
+}
+function pulseBehaviorError(capabilities, pulse) {
+  if (!capabilities.includes("pulse") && pulse === void 0) return void 0;
+  const duration = pulse && typeof pulse === "object" && !Array.isArray(pulse) ? pulse.durationMs : void 0;
+  if (!capabilities.includes("output") || !capabilities.includes("pulse") || typeof duration !== "number" || !Number.isSafeInteger(duration) || duration <= 0)
+    return "Pulsed behavior requires output and pulse capabilities and a positive integer durationMs.";
+  return void 0;
+}
+
 // backend/configuration.ts
 var import_node_crypto2 = require("node:crypto");
 
@@ -52579,6 +52596,9 @@ function commandTopic(prefix, hardwareId) {
 function configurationReportedWildcardTopic(prefix) {
   return configurationReportedTopic(prefix, "+");
 }
+function operationalWildcardTopic(prefix) {
+  return `${normalizeOperationalPrefix(prefix)}/v${CONFIGURATION_PROTOCOL_VERSION}/controllers/+/#`;
+}
 function parseOperationalMessage(prefix, topic, payload) {
   const root = `${normalizeOperationalPrefix(prefix)}/v${CONFIGURATION_PROTOCOL_VERSION}/controllers/`;
   if (!topic.startsWith(root)) return null;
@@ -53117,7 +53137,6 @@ function validateSnapshot(snapshot) {
     validateGuard(channel.guard, `${path}.guard`, capabilities, channelIds, errors);
     validateFeedback(channel.feedback, `${path}.feedback`, capabilities, channel.id, channelsById, errors);
     validateMeasurement(channel.measurement, `${path}.measurement`, capabilities, errors);
-    validateProfile(channel.profile, capabilities, path, errors);
   });
   return errors;
 }
@@ -53239,17 +53258,11 @@ function validateRange(value, path, capabilities, errors) {
     errors.push({ path, code: "unsupported_field", message: "range requires input or measurement capability" });
 }
 function validatePulse(value, path, capabilities, errors) {
+  const message = pulseBehaviorError([...capabilities], value);
+  if (message) errors.push({ path, code: "invalid_pulse", message });
   if (value === void 0) return;
   if (!record(value, path, errors)) return;
   exactKeys(value, path, ["durationMs"], errors);
-  if (!Number.isSafeInteger(value.durationMs) || value.durationMs <= 0)
-    errors.push({
-      path: `${path}.durationMs`,
-      code: "invalid_duration",
-      message: "durationMs must be a positive integer"
-    });
-  if (!capabilities.has("pulse"))
-    errors.push({ path, code: "unsupported_field", message: "pulse requires pulse capability" });
 }
 function validateGuard(value, path, capabilities, channelIds, errors) {
   if (value === void 0) return;
@@ -53297,22 +53310,6 @@ function validateFeedback(value, path, capabilities, currentChannelId, channelsB
   if (!capabilities.has("feedback"))
     errors.push({ path, code: "unsupported_field", message: "feedback requires feedback capability" });
 }
-function validateProfile(value, capabilities, path, errors) {
-  const required = {
-    "metered-switched-load": ["output", "measurement"],
-    "pulsed-lock-bank": ["output", "pulse"],
-    "guarded-enable-request": ["output", "guard"],
-    "generic-digital-output": ["output"],
-    "generic-monitored-input": ["input"]
-  };
-  required[value]?.filter((capability) => !capabilities.has(capability)).forEach(
-    (capability) => errors.push({
-      path: `${path}.capabilities`,
-      code: "missing_capability",
-      message: `${value} requires ${capability} capability`
-    })
-  );
-}
 function presetChannel(application) {
   const base2 = {
     id: application.channelId,
@@ -53944,12 +53941,18 @@ var WagoCommandHandler = class {
       };
     }
     if (channel) {
-      const actions = channel.capabilities.includes("output") ? [
-        { const: "set", title: "Set state" },
-        ...channel.capabilities.includes("pulse") ? [{ const: "pulse", title: "Pulse" }] : []
-      ] : [];
-      properties.action = { type: "string", title: "Operation", oneOf: actions, refreshesSchema: true };
-      if (config.action === "set") properties.value = { type: "boolean", title: "State", default: false };
+      const pulsed = outputBehavior(channel) === "pulsed";
+      const action = pulsed ? "pulse" : "set";
+      properties.action = {
+        type: "string",
+        title: "Operation",
+        oneOf: [{ const: action, title: pulsed ? "Trigger pulse" : "Turn on / turn off" }],
+        // Never silently reinterpret an existing incompatible flow action.
+        ...config.action === void 0 ? { default: action } : {},
+        refreshesSchema: true,
+        description: pulsed ? channel.pulse ? `Turns on for ${channel.pulse.durationMs} ms, then off automatically. Change the duration in the controller configuration.` : "This pulsed channel is missing its duration. Correct and publish its controller configuration." : "Stays on or off until another command or the configured disconnect policy changes it."
+      };
+      if (!pulsed) properties.value = { type: "boolean", title: "Output on", default: false };
       properties.expectedConfigurationRevision = {
         type: "number",
         title: "Configuration revision",
@@ -54030,8 +54033,13 @@ var WagoCommandHandler = class {
     if (!channel) return [{ field: "channelId", message: "The selected Logical Channel no longer exists." }];
     if (!channel.capabilities.includes("output"))
       return [{ field: "channelId", message: "The selected Logical Channel no longer supports output commands." }];
-    if (action === "pulse" && !channel.capabilities.includes("pulse"))
-      return [{ field: "action", message: "The selected Logical Channel no longer supports pulses." }];
+    if (!supportsOutputAction(channel, action))
+      return [
+        {
+          field: "action",
+          message: outputBehavior(channel) === "pulsed" ? action === "set" ? "This channel is configured as pulsed. Reopen this node and explicitly select Trigger pulse, or change the channel to switched behavior and publish it." : "This pulsed channel has invalid pulse settings. Correct and publish its controller configuration." : "This channel is configured as switched. Reopen this node and explicitly select Turn on / turn off, or change the channel to pulsed behavior and publish it."
+        }
+      ];
     return [];
   }
   async execute(config, commandId = (0, import_node_crypto4.randomUUID)()) {
@@ -54744,9 +54752,21 @@ var WagoService = class {
     await this.claimedController(controllerId);
     return this.drafts.findOneBy({ controllerId });
   }
-  async saveDraft(controllerId, snapshot, metadata2, principal) {
+  async getConfigurationBaseline(controllerId) {
+    await this.claimedController(controllerId);
+    const [revision] = await this.revisions.find({
+      where: { controllerId, state: "applied" },
+      order: { revision: "DESC" },
+      take: 1
+    });
+    return revision ?? null;
+  }
+  async saveDraft(controllerId, snapshot, metadata2, principal, expectedDraft) {
     return this.withConfigurationLock(controllerId, async () => {
       const previous = await this.getDraft(controllerId);
+      if (expectedDraft !== void 0 && (expectedDraft === null ? previous !== null : !previous || expectedDraft.snapshot !== previous.snapshot || expectedDraft.updatedAt !== previous.updatedAt || expectedDraft.presetProvenance !== previous.presetProvenance)) {
+        throw new import_common3.ConflictException("Saved draft changed. Reload it before saving your edits.");
+      }
       const validatedMetadata = metadata2 === void 0 ? void 0 : editorMetadata(metadata2);
       const previousMetadata = this.metadataFromProvenance(previous?.presetProvenance);
       const before = previous ? JSON.parse(previous.snapshot) : null;
@@ -61908,6 +61928,9 @@ var WagoControllerApi = class {
   draft(id) {
     return this.wago.getDraft(id);
   }
+  baseline(id) {
+    return this.wago.getConfigurationBaseline(id);
+  }
   presets() {
     return this.wago.presets();
   }
@@ -61927,7 +61950,7 @@ var WagoControllerApi = class {
     );
   }
   saveDraft(id, body, request) {
-    return this.wago.saveDraft(id, body?.snapshot, body?.metadata, wagoAuditPrincipal(request));
+    return this.wago.saveDraft(id, body?.snapshot, body?.metadata, wagoAuditPrincipal(request), body?.expectedDraft);
   }
   validateDraft(id, body) {
     return this.wago.validateDraft(id, body?.snapshot);
@@ -62096,6 +62119,10 @@ __decorateClass([
   (0, import_common9.Get)("controllers/:id/configuration/draft"),
   __decorateParam(0, (0, import_common9.Param)("id", import_common9.ParseIntPipe))
 ], WagoControllerApi.prototype, "draft", 1);
+__decorateClass([
+  (0, import_common9.Get)("controllers/:id/configuration/baseline"),
+  __decorateParam(0, (0, import_common9.Param)("id", import_common9.ParseIntPipe))
+], WagoControllerApi.prototype, "baseline", 1);
 __decorateClass([
   (0, import_common9.Get)("configuration/presets")
 ], WagoControllerApi.prototype, "presets", 1);
@@ -62641,8 +62668,7 @@ WagoDiagnosticsController = __decorateClass([
 
 // backend/wago-command-node.ts
 var WAGO_COMMAND_NODE_TYPE = "plugin.wago.command";
-function createWagoCommandNode(context) {
-  const service = () => context.get(WagoService);
+function createWagoCommandNode(service) {
   return {
     type: WAGO_COMMAND_NODE_TYPE,
     label: "WAGO command",
@@ -62661,10 +62687,559 @@ function createWagoCommandNode(context) {
   };
 }
 
-// backend/plugin.ts
+// backend/wago-flow.service.ts
+var import_common13 = require("@nestjs/common");
+
+// backend/wago-state-nodes.ts
+var WAGO_EVENT_NODE_TYPE = "plugin.wago.event-received";
+function createWagoStateNodes(service) {
+  return [
+    {
+      type: WAGO_EVENT_NODE_TYPE,
+      label: "WAGO event received",
+      description: "Start a flow when a channel reports state, a measurement, or a fault. Data is available in wago.",
+      isInput: true,
+      inputs: [],
+      outputs: ["output"],
+      resolveConfigSchema: (config) => service().resolveConfigSchema(config, "event"),
+      validateConfig: (config, context) => service().validateConfig(config, "event", context)
+    },
+    {
+      type: "plugin.wago.read-state",
+      label: "WAGO read state",
+      description: "Read the latest channel state or measurement into wago. Unavailable data uses the unavailable output.",
+      inputs: ["input"],
+      outputs: ["output", "unavailable"],
+      resolveConfigSchema: (config) => service().resolveConfigSchema(config, "read"),
+      validateConfig: (config, context) => service().validateConfig(config, "read", context),
+      execute: async (node, input) => {
+        const state = service().read(node.data);
+        const wago = state ? service().payload(state) : { available: false };
+        return { payload: { ...input, wago }, outputHandle: wago.available ? "output" : "unavailable" };
+      }
+    },
+    {
+      type: "plugin.wago.wait-for-state",
+      label: "WAGO wait for state",
+      description: "Wait for an available channel value to match, then continue with the value in wago.",
+      inputs: ["input"],
+      outputs: ["output", "timeout"],
+      resolveConfigSchema: (config) => service().resolveConfigSchema(config, "wait"),
+      validateConfig: (config, context) => service().validateConfig(config, "wait", context),
+      execute: async (node, input) => {
+        const state = await service().wait(node.data);
+        return {
+          payload: { ...input, wago: state ? service().payload(state) : { available: false } },
+          outputHandle: state ? "output" : "timeout"
+        };
+      }
+    }
+  ];
+}
+
+// backend/wago-flow.service.ts
 var PLUGIN_CONTEXT5 = /* @__PURE__ */ Symbol.for("attraccess.plugin.context");
+var STALE_AFTER_MS2 = 9e4;
+var MAX_CACHE_ENTRIES = 2e3;
+var MAX_PENDING_DISPATCHES = 100;
+var MAX_TIMEOUT_MS = 2147483647;
+var MAX_RETIRED_STREAMS = 128;
+var WagoFlowService = class {
+  constructor(context) {
+    __publicField(this, "context", context);
+    __publicField(this, "cache", /* @__PURE__ */ new Map());
+    __publicField(this, "controllerByHardwareId", /* @__PURE__ */ new Map());
+    __publicField(this, "streams", /* @__PURE__ */ new Map());
+    __publicField(this, "offlineControllers", /* @__PURE__ */ new Set());
+    __publicField(this, "unavailableHardware", /* @__PURE__ */ new Set());
+    __publicField(this, "unavailableConfiguration", /* @__PURE__ */ new Set());
+    __publicField(this, "appliedConfigurations", /* @__PURE__ */ new Map());
+    __publicField(this, "channelCache", /* @__PURE__ */ new Map());
+    __publicField(this, "waiters", /* @__PURE__ */ new Set());
+    __publicField(this, "waitersByKey", /* @__PURE__ */ new Map());
+    __publicField(this, "subscriptions", []);
+    __publicField(this, "dispatches", []);
+    __publicField(this, "lastDispatchAtByNode", /* @__PURE__ */ new Map());
+    __publicField(this, "dispatching", false);
+    __publicField(this, "messageQueue", Promise.resolve());
+    __publicField(this, "refreshTimer", null);
+  }
+  // Plugin registration precedes the host datasource; resolve repositories only when used.
+  get controllers() {
+    return this.context.getRepository(WagoController);
+  }
+  get revisions() {
+    return this.context.getRepository(WagoConfigurationRevision);
+  }
+  get settings() {
+    return this.context.getRepository(WagoSettings);
+  }
+  async onModuleInit() {
+    await this.refresh();
+    this.refreshTimer = setInterval(
+      () => void this.refresh().catch(
+        (error) => this.context.logger.warn(`Could not refresh WAGO flow subscriptions: ${String(error)}`)
+      ),
+      6e4
+    );
+  }
+  onModuleDestroy() {
+    if (this.refreshTimer) clearInterval(this.refreshTimer);
+    this.subscriptions.splice(0).forEach((subscription) => subscription.unsubscribe());
+    this.waiters.forEach((wake) => wake(void 0, true));
+    this.waiters.clear();
+    this.waitersByKey.clear();
+  }
+  async refresh() {
+    const settings = await this.settings.findOneBy({ id: 1 });
+    if (!settings) return;
+    const controllers = await this.controllers.find({ where: { trustState: "claimed" } });
+    const controllerIds = new Set(controllers.map((controller) => controller.id));
+    for (const id of this.offlineControllers) if (!controllerIds.has(id)) this.offlineControllers.delete(id);
+    for (const id of this.unavailableHardware) if (!controllerIds.has(id)) this.unavailableHardware.delete(id);
+    for (const id of this.unavailableConfiguration)
+      if (!controllerIds.has(id)) this.unavailableConfiguration.delete(id);
+    for (const id of this.appliedConfigurations.keys())
+      if (!controllerIds.has(id)) this.appliedConfigurations.delete(id);
+    for (const id of this.streams.keys()) if (!controllerIds.has(id)) this.streams.delete(id);
+    this.channelCache.clear();
+    const revisions = await this.loadLatestAppliedRevisions(controllers.map((controller) => controller.id));
+    for (const revision of revisions) this.cacheChannels(revision);
+    for (const controller of controllers)
+      if (!this.channelCache.has(controller.id)) this.channelCache.set(controller.id, []);
+    const validChannels = new Map(
+      controllers.map((controller) => [
+        controller.id,
+        new Set((this.channelCache.get(controller.id) ?? []).map((channel) => channel.id))
+      ])
+    );
+    for (const [key, state] of this.cache)
+      if (!validChannels.get(state.controllerId)?.has(state.channelId)) this.cache.delete(key);
+    const serverIds = new Set(
+      controllers.map((controller) => controller.mqttServerId ?? settings.defaultMqttServerId).filter(Boolean)
+    );
+    const controllerByHardwareId = new Map(
+      controllers.map(
+        (controller) => [
+          controller.hardwareId,
+          { controller, serverId: controller.mqttServerId ?? settings.defaultMqttServerId }
+        ]
+      ).filter(([, entry]) => Boolean(entry.serverId))
+    );
+    const replacements = [];
+    try {
+      for (const serverId of serverIds)
+        replacements.push(
+          await this.context.mqtt.subscribe(
+            serverId,
+            operationalWildcardTopic(settings.operationalPrefix),
+            (message) => this.onMessage(serverId, settings.operationalPrefix, message.topic, message.payload)
+          )
+        );
+    } catch (error) {
+      replacements.forEach((subscription) => subscription.unsubscribe());
+      throw error;
+    }
+    this.subscriptions.splice(0).forEach((subscription) => subscription.unsubscribe());
+    this.subscriptions.push(...replacements);
+    this.controllerByHardwareId = controllerByHardwareId;
+  }
+  async resolveConfigSchema(config, kind, validationContext = /* @__PURE__ */ new Map()) {
+    const controllers = await this.cached(
+      validationContext,
+      "wago-flow-controllers",
+      () => this.controllers.find({ where: { trustState: "claimed" }, order: { name: "ASC" } })
+    );
+    const selected = typeof config.controllerId === "number" ? controllers.find((controller) => controller.id === config.controllerId) : void 0;
+    const revision = selected ? await this.cached(validationContext, `wago-applied-revision:${selected.id}`, async () => {
+      const [latest] = await this.revisions.find({
+        where: { controllerId: selected.id, state: "applied" },
+        order: { revision: "DESC" },
+        take: 1
+      });
+      return latest ?? null;
+    }) : null;
+    const channels = revision ? JSON.parse(revision.snapshot).logicalChannels : [];
+    let names = {};
+    try {
+      names = JSON.parse(revision?.presetProvenance ?? "null")?.editor?.names ?? {};
+    } catch {
+    }
+    const channel = channels.find((item) => item.id === config.channelId);
+    const properties = {
+      controllerId: {
+        type: "number",
+        title: "Controller",
+        refreshesSchema: true,
+        oneOf: controllers.map((controller) => ({
+          const: controller.id,
+          title: controller.name ?? controller.hardwareId
+        })),
+        description: selected && !revision ? "Publish a configuration and wait for the controller to apply it first." : void 0
+      },
+      channelId: {
+        type: "string",
+        title: "Logical Channel",
+        refreshesSchema: true,
+        oneOf: channels.map((channel2) => ({
+          const: channel2.id,
+          title: typeof names[channel2.id] === "string" ? names[channel2.id] : channel2.id
+        }))
+      }
+    };
+    if (kind === "event") {
+      properties.category = {
+        type: "string",
+        title: "Event category",
+        oneOf: this.categories(channel).map((category) => ({ const: category, title: category }))
+      };
+      properties.minimumIntervalMs = { type: "number", title: "Minimum interval (ms)", minimum: 0, default: 0 };
+      if (channel?.capabilities.includes("measurement"))
+        properties.minimumChange = { type: "number", title: "Minimum change (wire units)", minimum: 0 };
+    }
+    if (kind !== "event")
+      properties.category = {
+        type: "string",
+        title: "State category",
+        refreshesSchema: true,
+        oneOf: this.readCategories(channel).map((category) => ({ const: category, title: category }))
+      };
+    if (kind === "wait") {
+      properties.equals = {
+        type: config.category === "measurement" ? "number" : "boolean",
+        title: config.category === "measurement" ? "Equals (wire value)" : "Equals"
+      };
+      properties.timeoutMs = {
+        type: "number",
+        title: "Timeout (ms)",
+        minimum: 1,
+        maximum: MAX_TIMEOUT_MS,
+        default: 3e4
+      };
+    }
+    return {
+      dynamic: true,
+      type: "object",
+      properties,
+      required: ["controllerId", "channelId", "category", ...kind === "wait" ? ["equals", "timeoutMs"] : []]
+    };
+  }
+  cached(context, key, load) {
+    if (!context.has(key)) context.set(key, load());
+    return context.get(key);
+  }
+  async validateConfig(config, kind, context = /* @__PURE__ */ new Map()) {
+    const schema = await this.resolveConfigSchema(config, kind, context);
+    const properties = schema.properties;
+    const errors = [];
+    for (const [field2, message] of [
+      ["controllerId", "Select a claimed WAGO controller."],
+      ["channelId", "Select a channel from the applied controller configuration."],
+      ["category", "Select a category supported by this channel."]
+    ]) {
+      if (!properties[field2]?.oneOf?.some((choice) => choice.const === config[field2])) errors.push({ field: field2, message });
+    }
+    const numericFields = kind === "event" ? ["minimumIntervalMs", "minimumChange"] : kind === "wait" ? ["timeoutMs"] : [];
+    for (const field2 of numericFields) {
+      const value = config[field2];
+      if (value !== void 0 && (typeof value !== "number" || !Number.isFinite(value) || value < (field2 === "timeoutMs" ? 1 : 0) || field2 === "timeoutMs" && value > MAX_TIMEOUT_MS))
+        errors.push({
+          field: field2,
+          message: field2 === "timeoutMs" ? "Enter a valid positive timeout." : "Enter a non-negative number."
+        });
+    }
+    if (kind === "wait" && (config.category === "measurement" ? typeof config.equals !== "number" || !Number.isFinite(config.equals) : typeof config.equals !== "boolean"))
+      errors.push({ field: "equals", message: "Enter a matching value for the selected state category." });
+    return errors;
+  }
+  read(config) {
+    if (typeof config.controllerId !== "number" || typeof config.channelId !== "string") return null;
+    if (typeof config.category === "string")
+      return this.cache.get(this.cacheKey(config.controllerId, config.channelId, config.category)) ?? null;
+    const entries = [...this.cache.values()].filter(
+      (state) => state.controllerId === config.controllerId && state.channelId === config.channelId && (!config.category || state.category === config.category)
+    );
+    return entries.sort((left, right) => right.receivedAt - left.receivedAt)[0] ?? null;
+  }
+  async wait(config) {
+    if (typeof config.controllerId !== "number" || typeof config.channelId !== "string" || typeof config.category !== "string")
+      return null;
+    const current = this.read(config);
+    if (current && this.matchesCondition(current, config)) return current;
+    const timeoutMs = typeof config.timeoutMs === "number" && Number.isFinite(config.timeoutMs) && config.timeoutMs > 0 ? Math.min(config.timeoutMs, MAX_TIMEOUT_MS) : 3e4;
+    const waiterKey = this.cacheKey(config.controllerId, config.channelId, config.category);
+    return new Promise((resolve2) => {
+      const cleanup = () => {
+        clearTimeout(timer);
+        this.waiters.delete(wake);
+        const waiters2 = this.waitersByKey.get(waiterKey);
+        waiters2?.delete(wake);
+        if (!waiters2?.size) this.waitersByKey.delete(waiterKey);
+      };
+      const wake = (state, cancel = false) => {
+        if (!cancel && (!state || !this.matchesCondition(state, config))) return;
+        cleanup();
+        resolve2(cancel ? null : state);
+      };
+      const timer = setTimeout(() => {
+        cleanup();
+        resolve2(null);
+      }, timeoutMs);
+      this.waiters.add(wake);
+      const waiters = this.waitersByKey.get(waiterKey) ?? /* @__PURE__ */ new Set();
+      waiters.add(wake);
+      this.waitersByKey.set(waiterKey, waiters);
+    });
+  }
+  onMessage(serverId, prefix, topic, payload) {
+    const queued = this.messageQueue.catch(() => void 0).then(() => this.processMessage(serverId, prefix, topic, payload));
+    this.messageQueue = queued;
+    return queued;
+  }
+  async processMessage(serverId, prefix, topic, payload) {
+    let parsed;
+    try {
+      parsed = parseOperationalMessage(prefix, topic, payload);
+    } catch (error) {
+      this.context.logger.warn(`Ignoring invalid WAGO event: ${String(error)}`);
+      return;
+    }
+    if (!parsed) return;
+    const { hardwareId, message: event } = parsed;
+    const entry = this.controllerByHardwareId.get(hardwareId);
+    if (!entry || entry.serverId !== serverId) return;
+    const { controller } = entry;
+    const eventTime = Date.parse(event.timestamp);
+    if (eventTime > Date.now()) {
+      this.context.logger.warn(`Ignoring future-dated WAGO event for ${controller.hardwareId}`);
+      return;
+    }
+    const channels = await this.channels(controller.id);
+    let stream = this.streams.get(controller.id);
+    if (stream?.exhausted) return;
+    if (!stream || stream.active !== event.streamId) {
+      if (event.category !== "state" || stream?.retired.has(event.streamId) || stream && (!event.connected || Date.now() - eventTime > STALE_AFTER_MS2 || eventTime <= stream.latestSourceTime)) {
+        this.context.logger.warn(`Ignoring unestablished or retired WAGO stream for ${controller.hardwareId}`);
+        return;
+      }
+      if (stream && stream.retired.size >= MAX_RETIRED_STREAMS) {
+        stream.exhausted = true;
+        for (const state of this.cache.values()) if (state.controllerId === controller.id) state.invalidated = true;
+        this.context.logger.warn(
+          `WAGO stream history exhausted for ${controller.hardwareId}; refusing further samples`
+        );
+        return;
+      }
+      const retired = stream?.retired ?? /* @__PURE__ */ new Set();
+      if (stream) retired.add(stream.active);
+      stream = {
+        active: event.streamId,
+        latestSourceTime: eventTime,
+        sampleNotBefore: eventTime,
+        retired,
+        sequences: /* @__PURE__ */ new Map()
+      };
+      this.streams.set(controller.id, stream);
+      for (const state of this.cache.values()) if (state.controllerId === controller.id) state.invalidated = true;
+    }
+    const previous = stream.sequences.get(event.category);
+    if (previous !== void 0 && event.sequence <= previous) {
+      this.context.logger.warn(`Ignoring duplicate or out-of-order WAGO event for ${controller.hardwareId}`);
+      return;
+    }
+    if (previous !== void 0 && event.sequence > previous + 1)
+      this.context.logger.warn(
+        `WAGO event sequence gap for ${controller.hardwareId}: ${previous} to ${event.sequence}`
+      );
+    stream.sequences.set(event.category, event.sequence);
+    stream.latestSourceTime = Math.max(stream.latestSourceTime, eventTime);
+    if (event.category === "state") {
+      const wasUnavailable = this.offlineControllers.has(controller.id) || this.unavailableHardware.has(controller.id) || this.unavailableConfiguration.has(controller.id) || stream.stateTimestamp !== void 0 && Date.now() - stream.stateTimestamp > STALE_AFTER_MS2;
+      stream.stateTimestamp = eventTime;
+      if (event.connected) this.offlineControllers.delete(controller.id);
+      else this.offlineControllers.add(controller.id);
+      if (event.readiness?.hardwareAvailable === false) this.unavailableHardware.add(controller.id);
+      else if (event.readiness?.hardwareAvailable === true) this.unavailableHardware.delete(controller.id);
+      const applied = this.appliedConfigurations.get(controller.id);
+      if (applied && event.revision === applied.revision && event.contentHash === applied.contentHash)
+        this.unavailableConfiguration.delete(controller.id);
+      else this.unavailableConfiguration.add(controller.id);
+      if (wasUnavailable || !event.connected || this.unavailableHardware.has(controller.id) || this.unavailableConfiguration.has(controller.id))
+        stream.sampleNotBefore = Math.max(stream.sampleNotBefore, eventTime);
+      for (const state of this.cache.values()) {
+        if (state.controllerId !== controller.id) continue;
+        if (wasUnavailable || !event.connected || this.unavailableHardware.has(controller.id) || this.unavailableConfiguration.has(controller.id) || state.category === "state")
+          state.invalidated = true;
+      }
+      for (const channel of channels) {
+        const value = channel.capabilities.includes("input") && Object.hasOwn(event.inputs ?? {}, channel.id) ? event.inputs[channel.id] : channel.capabilities.includes("output") && Object.hasOwn(event.outputs, channel.id) ? event.outputs[channel.id] : void 0;
+        if (typeof value === "boolean") this.store(controller, channel.id, event, value);
+      }
+    } else if ("channelId" in event) {
+      const channel = channels.find((channel2) => channel2.id === event.channelId);
+      if (!channel || event.category === "measurement" && !channel.capabilities.includes("measurement")) return;
+      this.store(controller, event.channelId, event, event.category === "measurement" ? event.value : event);
+    }
+  }
+  store(controller, channelId, event, value) {
+    const state = {
+      controllerId: controller.id,
+      hardwareId: controller.hardwareId,
+      channelId,
+      category: event.category,
+      value,
+      timestamp: event.timestamp,
+      sequence: event.sequence,
+      streamId: event.streamId,
+      ...event.category === "measurement" ? { unit: event.unit, kind: event.kind } : {},
+      ...event.category === "state" ? { revision: event.revision, contentHash: event.contentHash } : {},
+      receivedAt: Date.now(),
+      offline: this.offlineControllers.has(controller.id),
+      invalidated: this.unavailableHardware.has(controller.id) || this.unavailableConfiguration.has(controller.id) || Date.parse(event.timestamp) < (this.streams.get(controller.id)?.sampleNotBefore ?? 0)
+    };
+    const cacheKey = this.cacheKey(controller.id, channelId, event.category);
+    const previous = this.cache.get(cacheKey);
+    this.cache.set(cacheKey, state);
+    if (this.cache.size > MAX_CACHE_ENTRIES) {
+      const oldest = this.cache.keys().next().value;
+      if (oldest) this.cache.delete(oldest);
+    }
+    this.waitersByKey.get(cacheKey)?.forEach((wake) => wake(state));
+    if (this.dispatches.length >= MAX_PENDING_DISPATCHES) {
+      this.context.logger.warn(`Dropping excess WAGO flow dispatch for ${controller.hardwareId}`);
+      return;
+    }
+    this.dispatches.push({ state, previous });
+    if (!this.dispatching) void this.dispatch();
+  }
+  async channels(controllerId) {
+    const cached = this.channelCache.get(controllerId);
+    if (cached) return cached;
+    const [revision] = await this.revisions.find({
+      where: { controllerId, state: "applied" },
+      order: { revision: "DESC" },
+      take: 1
+    });
+    if (!revision) {
+      this.channelCache.set(controllerId, []);
+      return [];
+    }
+    return this.cacheChannels(revision);
+  }
+  async loadLatestAppliedRevisions(controllerIds) {
+    if (!controllerIds.length) return [];
+    return this.revisions.createQueryBuilder("revision").innerJoin(
+      (query) => query.subQuery().select("latest.controllerId", "controllerId").addSelect("MAX(latest.revision)", "revision").from(WagoConfigurationRevision, "latest").where("latest.controllerId IN (:...controllerIds)", { controllerIds }).andWhere("latest.state = :state", { state: "applied" }).groupBy("latest.controllerId"),
+      "latest",
+      "latest.controllerId = revision.controllerId AND latest.revision = revision.revision"
+    ).where("revision.state = :state", { state: "applied" }).getMany();
+  }
+  cacheChannels(revision) {
+    try {
+      const channels = JSON.parse(revision.snapshot).logicalChannels;
+      const previous = this.appliedConfigurations.get(revision.controllerId);
+      if (previous?.revision !== revision.revision || previous?.contentHash !== revision.contentHash) {
+        this.unavailableConfiguration.add(revision.controllerId);
+        for (const state of this.cache.values())
+          if (state.controllerId === revision.controllerId) state.invalidated = true;
+      }
+      this.appliedConfigurations.set(revision.controllerId, {
+        revision: revision.revision,
+        contentHash: revision.contentHash
+      });
+      this.channelCache.set(revision.controllerId, channels);
+      return channels;
+    } catch {
+      this.channelCache.set(revision.controllerId, []);
+      return [];
+    }
+  }
+  cacheKey(controllerId, channelId, category) {
+    return `${controllerId}:${channelId}:${category}`;
+  }
+  categories(channel) {
+    return [
+      ...channel?.capabilities.some((capability) => capability === "input" || capability === "output") ? ["state"] : [],
+      ...channel?.capabilities.includes("measurement") ? ["measurement"] : [],
+      "fault"
+    ];
+  }
+  readCategories(channel) {
+    return [
+      ...channel?.capabilities.some((capability) => capability === "input" || capability === "output") ? ["state"] : [],
+      ...channel?.capabilities.includes("measurement") ? ["measurement"] : []
+    ];
+  }
+  matchesEvent(config, nodeId, state, previous) {
+    if (config.controllerId !== state.controllerId || config.channelId !== state.channelId || config.category !== state.category)
+      return false;
+    if (typeof config.minimumChange === "number" && typeof state.value === "number" && typeof previous?.value === "number" && previous.streamId === state.streamId && previous.unit === state.unit && previous.kind === state.kind && Math.abs(state.value - previous.value) < config.minimumChange)
+      return false;
+    if (typeof config.minimumIntervalMs === "number") {
+      const lastDispatchAt = this.lastDispatchAtByNode.get(nodeId);
+      if (lastDispatchAt !== void 0 && state.receivedAt - lastDispatchAt < config.minimumIntervalMs) return false;
+      this.lastDispatchAtByNode.set(nodeId, state.receivedAt);
+    }
+    return true;
+  }
+  matchesCondition(state, config) {
+    return this.freshness(state).available && (config.equals === void 0 || state.value === config.equals);
+  }
+  freshness(state) {
+    const age = Date.now() - Date.parse(state.timestamp);
+    const stale = !Number.isFinite(age) || age < 0 || age > STALE_AFTER_MS2;
+    const offline = state.offline === true || this.offlineControllers.has(state.controllerId);
+    const stream = this.streams.get(state.controllerId);
+    const stateTimestamp = stream?.stateTimestamp;
+    const connectionStale = stateTimestamp === void 0 || Date.now() - stateTimestamp > STALE_AFTER_MS2;
+    return {
+      stale,
+      offline,
+      connectionStale,
+      available: !stale && !offline && !connectionStale && stream?.active === state.streamId && !stream.exhausted && Date.parse(state.timestamp) >= stream.sampleNotBefore && !state.invalidated && !this.unavailableHardware.has(state.controllerId) && !this.unavailableConfiguration.has(state.controllerId)
+    };
+  }
+  payload(state) {
+    const payload = { ...state };
+    delete payload.invalidated;
+    return { ...payload, ...this.freshness(state) };
+  }
+  async dispatch() {
+    this.dispatching = true;
+    while (this.dispatches.length) {
+      const dispatch = this.dispatches.shift();
+      if (!dispatch) continue;
+      const { state, previous } = dispatch;
+      const stream = this.streams.get(state.controllerId);
+      if (stream?.active !== state.streamId || stream.exhausted) continue;
+      try {
+        await this.context.flows.trigger(
+          WAGO_EVENT_NODE_TYPE,
+          (config, nodeId) => this.matchesEvent(config, nodeId, state, previous),
+          { wago: this.payload(state) }
+        );
+      } catch (error) {
+        this.context.logger.warn(`Could not trigger WAGO flows: ${String(error)}`);
+      }
+    }
+    this.dispatching = false;
+  }
+};
+WagoFlowService = __decorateClass([
+  (0, import_common13.Injectable)(),
+  __decorateParam(0, (0, import_common13.Inject)(PLUGIN_CONTEXT5))
+], WagoFlowService);
+
+// backend/plugin.ts
+var PLUGIN_CONTEXT6 = /* @__PURE__ */ Symbol.for("attraccess.plugin.context");
 var WagoPluginModule = class {
 };
+var flowServices = /* @__PURE__ */ new WeakMap();
+function services(context) {
+  const result = flowServices.get(context);
+  if (!result) throw new Error("WAGO flow services are not initialized.");
+  return result;
+}
 var plugin = {
   entities: [
     WagoController,
@@ -62677,14 +63252,31 @@ var plugin = {
     WagoManagementEntity,
     WagoCommissioningLeaseEntity
   ],
-  flowNodes: (context) => [createWagoCommandNode(context)],
+  flowNodes: (context) => [
+    createWagoCommandNode(() => services(context).command),
+    ...createWagoStateNodes(() => services(context).state)
+  ],
   register(context) {
     return {
       module: WagoPluginModule,
       controllers: [WagoControllerApi, WagoArtifactsController, WagoDiagnosticsController],
       providers: [
-        { provide: PLUGIN_CONTEXT5, useValue: context },
+        { provide: PLUGIN_CONTEXT6, useValue: context },
         WagoService,
+        WagoFlowService,
+        {
+          provide: "wago-flow-services",
+          inject: [WagoService, WagoFlowService],
+          useFactory: (command, state) => {
+            const bound = { command, state };
+            flowServices.set(context, bound);
+            return {
+              onModuleDestroy: () => {
+                if (flowServices.get(context) === bound) flowServices.delete(context);
+              }
+            };
+          }
+        },
         WagoRuntimeArtifactsService,
         WagoArtifactUploadInterceptor,
         WagoCommissioningReadiness,