@attraccess/plugin-wago 0.1.0-nightly.950.1 → 0.1.0-nightly.951.1

package/dist/index.js

@@ -51749,7 +51749,7 @@ function parseOperationalMessage(prefix, topic, payload) {
   const value = parseObject(payload, "operational message");
   const timestamp = requiredTimestamp(value.timestamp);
   const sequence = requiredSequence(value.sequence);
-  if (value.streamId !== void 0 && (typeof value.streamId !== "string" || !value.streamId.trim() || value.streamId.length > 128))
+  if (typeof value.streamId !== "string" || !value.streamId.trim() || value.streamId.length > 128)
     throw new Error("operational streamId is invalid");
   const streamId = value.streamId;
   if (suffix === "state") {
@@ -51760,7 +51760,7 @@ function parseOperationalMessage(prefix, topic, payload) {
       message: {
         category: "state",
         timestamp,
-        ...streamId !== void 0 ? { streamId } : {},
+        streamId,
         sequence,
         connected: value.connected,
         revision: value.revision,
@@ -51772,7 +51772,6 @@ function parseOperationalMessage(prefix, topic, payload) {
     };
   }
   if (suffix === "measurements") {
-    if (streamId === void 0) throw new Error("operational streamId is required for measurements");
     return {
       hardwareId,
       message: {
@@ -51792,7 +51791,7 @@ function parseOperationalMessage(prefix, topic, payload) {
       message: {
         category: "fault",
         timestamp,
-        ...streamId !== void 0 ? { streamId } : {},
+        streamId,
         sequence,
         channelId: value.channelId,
         code: value.code,
@@ -51807,7 +51806,7 @@ function parseOperationalMessage(prefix, topic, payload) {
     message: {
       category: "acknowledgement",
       timestamp,
-      ...streamId !== void 0 ? { streamId } : {},
+      streamId,
       sequence,
       id: value.id,
       status: value.status,
@@ -58179,6 +58178,7 @@ var MAX_CACHE_ENTRIES = 2e3;
 var MAX_PENDING_DISPATCHES = 100;
 var MAX_CONCURRENT_DISPATCHES = 10;
 var MAX_TIMEOUT_MS = 2147483647;
+var MAX_RETIRED_STREAMS = 128;
 var WagoFlowService = class {
   constructor(context) {
     __publicField(this, "context", context);
@@ -58187,8 +58187,12 @@ var WagoFlowService = class {
     __publicField(this, "settings");
     __publicField(this, "cache", /* @__PURE__ */ new Map());
     __publicField(this, "controllerByHardwareId", /* @__PURE__ */ new Map());
-    __publicField(this, "sequences", /* @__PURE__ */ new Map());
-    __publicField(this, "sequenceTimestamps", /* @__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, "processingByController", /* @__PURE__ */ new Map());
     __publicField(this, "channelCache", /* @__PURE__ */ new Map());
     __publicField(this, "waiters", /* @__PURE__ */ new Set());
     __publicField(this, "waitersByKey", /* @__PURE__ */ new Map());
@@ -58221,6 +58225,14 @@ var WagoFlowService = class {
     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);
@@ -58295,7 +58307,7 @@ var WagoFlowService = class {
       };
       properties.minimumIntervalMs = { type: "number", title: "Minimum interval (ms)", minimum: 0 };
       if (channel?.capabilities.includes("measurement"))
-        properties.minimumChange = { type: "number", title: "Minimum change", minimum: 0 };
+        properties.minimumChange = { type: "number", title: "Minimum change (wire units)", minimum: 0 };
     }
     if (kind !== "event")
       properties.category = {
@@ -58305,7 +58317,10 @@ var WagoFlowService = class {
         oneOf: this.readCategories(channel).map((category) => ({ const: category, title: category }))
       };
     if (kind === "wait") {
-      properties.equals = { type: config.category === "measurement" ? "number" : "boolean", title: "Equals" };
+      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 };
     }
     return { dynamic: true, type: "object", properties, required: ["controllerId", "channelId", "category"] };
@@ -58317,7 +58332,7 @@ var WagoFlowService = class {
     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.sequence - left.sequence)[0] ?? null;
+    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")
@@ -58325,8 +58340,8 @@ var WagoFlowService = class {
     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 waiterKey = this.cacheKey(config.controllerId, config.channelId, config.category);
       const cleanup = () => {
         clearTimeout(timer);
         this.waiters.delete(wake);
@@ -58362,29 +58377,90 @@ var WagoFlowService = class {
     const entry = this.controllerByHardwareId.get(hardwareId);
     if (!entry || entry.serverId !== serverId) return;
     const { controller } = entry;
-    const previous = this.sequences.get(controller.id);
     const eventTime = Date.parse(event.timestamp);
-    const previousTime = this.sequenceTimestamps.get(controller.id);
-    if (previous !== void 0 && event.sequence <= previous && (!previousTime || eventTime <= previousTime)) {
+    if (eventTime > Date.now()) {
+      this.context.logger.warn(`Ignoring future-dated WAGO event for ${controller.hardwareId}`);
+      return;
+    }
+    const previous = this.processingByController.get(controller.id) ?? Promise.resolve();
+    const processing = previous.catch(() => void 0).then(() => this.processMessage(controller, event, eventTime));
+    this.processingByController.set(controller.id, processing);
+    try {
+      await processing;
+    } finally {
+      if (this.processingByController.get(controller.id) === processing)
+        this.processingByController.delete(controller.id);
+    }
+  }
+  async processMessage(controller, event, eventTime) {
+    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)
-      this.context.logger.warn(`Resetting WAGO event sequence after controller reconnect for ${controller.hardwareId}`);
     if (previous !== void 0 && event.sequence > previous + 1)
       this.context.logger.warn(
         `WAGO event sequence gap for ${controller.hardwareId}: ${previous} to ${event.sequence}`
       );
-    this.sequences.set(controller.id, event.sequence);
-    this.sequenceTimestamps.set(controller.id, eventTime);
-    const channelId = event.category === "state" ? null : "channelId" in event ? event.channelId : null;
-    if (event.category === "state")
-      for (const [id, value] of Object.entries(event.outputs)) await this.store(controller, id, event, value);
-    else if (channelId)
-      await this.store(controller, channelId, event, event.category === "measurement" ? event.value : event);
-  }
-  async store(controller, channelId, event, value) {
-    if (!(await this.channels(controller.id)).some((channel) => channel.id === channelId)) return;
+    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,
@@ -58393,7 +58469,12 @@ var WagoFlowService = class {
       value,
       timestamp: event.timestamp,
       sequence: event.sequence,
-      receivedAt: Date.now()
+      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);
@@ -58435,6 +58516,16 @@ var WagoFlowService = class {
   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 {
@@ -58447,21 +58538,21 @@ var WagoFlowService = class {
   }
   categories(channel) {
     return [
-      ...channel?.capabilities.includes("output") ? ["state"] : [],
+      ...channel?.capabilities.some((capability) => capability === "input" || capability === "output") ? ["state"] : [],
       ...channel?.capabilities.includes("measurement") ? ["measurement"] : [],
       "fault"
     ];
   }
   readCategories(channel) {
     return [
-      ...channel?.capabilities.includes("output") ? ["state"] : [],
+      ...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" && Math.abs(state.value - previous.value) < config.minimumChange)
+    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);
@@ -58471,10 +58562,26 @@ var WagoFlowService = class {
     return true;
   }
   matchesCondition(state, config) {
-    return config.equals === void 0 || state.value === config.equals;
+    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) {
-    return { ...state, stale: Date.now() - Date.parse(state.timestamp) > STALE_AFTER_MS2 };
+    const payload = { ...state };
+    delete payload.invalidated;
+    return { ...payload, ...this.freshness(state) };
   }
   dispatch() {
     while (this.activeDispatches < MAX_CONCURRENT_DISPATCHES && this.dispatches.length) {
@@ -58488,6 +58595,8 @@ var WagoFlowService = class {
     }
   }
   async trigger({ state, previous }) {
+    const stream = this.streams.get(state.controllerId);
+    if (stream?.active !== state.streamId || stream.exhausted) return;
     try {
       await this.context.flows.trigger(
         "plugin.wago.event-received",

package/package.json

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