@attraccess/plugin-wago 0.1.0-nightly.954.1 → 0.1.0-nightly.957.1

package/dist/index.js

@@ -52015,7 +52015,242 @@ WagoEnrollment = __decorateClass([
 
 // backend/configuration.ts
 var import_node_crypto = require("node:crypto");
-var HARDWARE_PROFILES = ["751-9301", "879-3000", "879-1300"];
+
+// modbus/model.ts
+var registerCount = (format) => ["uint16", "int16"].includes(format.dataType) ? 1 : 2;
+var base = {
+  addressBase: 0,
+  byteOrder: "big",
+  wordOrder: "big",
+  offset: 0,
+  pollIntervalMs: 5e3,
+  functionCode: 3
+};
+var BUILTIN_MODBUS_PROFILES = ["879-3000", "879-1300"].map((model) => ({
+  id: `wago-${model}-unverified`,
+  name: `WAGO ${model} \u2014 UNQUALIFIED / map unverified`,
+  version: 1,
+  actions: [],
+  measurements: [
+    {
+      ...base,
+      id: "active-power",
+      name: "Active power",
+      address: 20498,
+      dataType: "float32",
+      scale: 1e3,
+      unit: "watt",
+      kind: "live"
+    },
+    ...[
+      { id: "import-energy", name: "Imported energy", address: 24588 },
+      { id: "export-energy", name: "Exported energy", address: 24600 }
+    ].map((entry) => ({
+      ...base,
+      ...entry,
+      dataType: model === "879-3000" ? "float32" : "uint32",
+      scale: model === "879-3000" ? 1e3 : 1,
+      unit: "watt-hour",
+      kind: "cumulative"
+    }))
+  ]
+}));
+function freeze(value) {
+  Object.values(value).forEach((child) => {
+    if (child && typeof child === "object") freeze(child);
+  });
+  Object.freeze(value);
+}
+freeze(BUILTIN_MODBUS_PROFILES);
+function findProfile(config, device) {
+  return [...BUILTIN_MODBUS_PROFILES, ...config.profiles].find(
+    (p) => p.id === device.profileId && p.version === device.profileVersion
+  );
+}
+function validateModbus(value) {
+  const errors = [];
+  const fail = (path, message) => errors.push({ path, code: "invalid_modbus", message });
+  const object = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+  const integer = (v, min, max) => Number.isSafeInteger(v) && Number(v) >= min && Number(v) <= max;
+  const name = (v) => typeof v === "string" && !!v.trim() && v.length <= 160;
+  const keys = (v, allowed, path) => {
+    for (const key of Object.keys(v)) if (!allowed.includes(key)) fail(`${path}.${key}`, "unknown field");
+  };
+  if (!object(value)) {
+    fail("modbus", "must be an object");
+    return errors;
+  }
+  keys(value, ["connections", "devices", "profiles"], "modbus");
+  const arrays = ["connections", "devices", "profiles"];
+  for (const key of arrays)
+    if (!Array.isArray(value[key]) || value[key].length > 64)
+      fail(`modbus.${key}`, "must be an array with at most 64 entries");
+  if (errors.length) return errors;
+  const config = value;
+  for (const key of arrays) {
+    const ids = /* @__PURE__ */ new Set();
+    config[key].forEach((entry, i) => {
+      if (!object(entry) || !name(entry.id) || ids.has(String(entry.id)))
+        fail(`modbus.${key}[${i}]`, "unique non-empty ID required");
+      if (entry && typeof entry.id === "string") ids.add(entry.id);
+    });
+  }
+  if (errors.length) return errors;
+  const endpoints = /* @__PURE__ */ new Set();
+  config.connections.forEach((c, i) => {
+    const path = `modbus.connections[${i}]`;
+    keys(
+      c,
+      [
+        "id",
+        "timeoutMs",
+        "reconnectMs",
+        "queueLimit",
+        ...c.transport === "tcp" ? ["transport", "host", "port"] : ["transport", "path", "baudRate", "parity", "stopBits"]
+      ],
+      path
+    );
+    if (!integer(c.timeoutMs, 10, 6e4) || !integer(c.reconnectMs, 0, 6e4) || !integer(c.queueLimit, 1, 128))
+      fail(path, "timeout 10..60000ms, reconnect 0..60000ms, queue limit 1..128 required");
+    let endpoint;
+    if (c.transport === "tcp") {
+      if (!name(c.host) || /[\s/]/.test(c.host) || !integer(c.port, 1, 65535))
+        return void fail(path, "TCP host and port 1..65535 required");
+      endpoint = `tcp:${c.host.toLowerCase()}:${c.port}`;
+    } else if (c.transport === "rtu") {
+      if (typeof c.path !== "string" || !/^\/dev\/[a-zA-Z0-9_./-]+$/.test(c.path) || c.path.includes("..") || c.path.split("/").slice(2).some((segment) => segment === "" || segment === ".") || ![1200, 2400, 4800, 9600, 19200, 38400, 57600, 115200].includes(c.baudRate) || !["none", "even", "odd"].includes(c.parity) || ![1, 2].includes(c.stopBits))
+        return void fail(path, "canonical serial device path, valid baud, parity and stop bits required");
+      endpoint = `rtu:${c.path}`;
+    } else return void fail(path, "transport must be tcp or rtu");
+    if (endpoints.has(endpoint)) fail(path, "share one connection for devices on the same endpoint");
+    endpoints.add(endpoint);
+  });
+  const format = (f, path) => {
+    if (![0, 1].includes(f.addressBase) || !Number.isSafeInteger(f.address) || !integer(f.address - f.addressBase, 0, 65536 - registerCount(f)) || !["uint16", "int16", "uint32", "int32", "float32"].includes(f.dataType) || !["big", "little"].includes(f.byteOrder) || !["big", "little"].includes(f.wordOrder) || !Number.isFinite(f.scale) || f.scale === 0 || !Number.isFinite(f.offset))
+      fail(path, "invalid address, dtype, order or transform");
+  };
+  config.profiles.forEach((p, i) => {
+    const path = `modbus.profiles[${i}]`;
+    keys(p, ["id", "name", "version", "measurements", "actions"], path);
+    if (BUILTIN_MODBUS_PROFILES.some((b) => b.id === p.id) || !name(p.name) || !integer(p.version, 1, 1e6))
+      fail(path, "custom ID, name and positive version required; built-ins are immutable");
+    if (!Array.isArray(p.measurements) || !Array.isArray(p.actions) || p.measurements.length + p.actions.length > 128) {
+      fail(path, "measurements/actions arrays required, maximum 128 entries");
+      return;
+    }
+    const ids = /* @__PURE__ */ new Set();
+    [...p.measurements, ...p.actions].forEach((f, j) => {
+      if (!object(f) || !name(f.id) || !name(f.name) || ids.has(f.id)) {
+        fail(`${path}[${j}]`, "unique named entry required");
+        return;
+      }
+      ids.add(f.id);
+      format(f, `${path}.${f.id}`);
+      keys(
+        f,
+        [
+          "id",
+          "name",
+          "address",
+          "addressBase",
+          "dataType",
+          "byteOrder",
+          "wordOrder",
+          "scale",
+          "offset",
+          "functionCode",
+          ...p.measurements.includes(f) ? ["unit", "kind", "pollIntervalMs", "rollover"] : ["onValue", "offValue"]
+        ],
+        `${path}.${f.id}`
+      );
+    });
+    p.measurements.forEach((m) => {
+      if (!m || ![3, 4].includes(m.functionCode) || !["ampere", "volt", "watt", "watt-hour", "percent"].includes(m.unit) || !["live", "cumulative"].includes(m.kind) || !integer(m.pollIntervalMs, 100, 36e5))
+        fail(path, "measurement requires FC03/04, physical unit, kind, poll interval 100..3600000ms");
+      if (m?.rollover !== void 0 && (m.kind !== "cumulative" || !Number.isFinite(m.rollover) || m.rollover <= 0))
+        fail(path, "rollover must be an explicit positive raw modulus on cumulative measurements");
+      if (m?.kind === "cumulative" && m.scale <= 0) fail(path, "cumulative measurements require a positive scale");
+    });
+    p.actions.forEach((a) => {
+      if (!a || ![5, 6, 16].includes(a.functionCode) || !Number.isFinite(a.onValue) || !Number.isFinite(a.offValue)) {
+        fail(path, "action requires FC05/06/16 and finite on/off values");
+        return;
+      }
+      if (a.functionCode === 5 && (a.dataType !== "uint16" || a.scale !== 1 || a.offset !== 0 || ![0, 1].includes(a.onValue) || ![0, 1].includes(a.offValue)))
+        fail(path, "coil action requires identity uint16 and values 0 or 1");
+      if (a.functionCode === 6 && registerCount(a) !== 1) fail(path, "FC06 requires a 16-bit dtype");
+      for (const value2 of [a.onValue, a.offValue]) {
+        const raw = (value2 - a.offset) / a.scale;
+        const limits2 = {
+          uint16: [0, 65535],
+          int16: [-32768, 32767],
+          uint32: [0, 4294967295],
+          int32: [-2147483648, 2147483647],
+          float32: [-34028234663852886e22, 34028234663852886e22]
+        }[a.dataType];
+        if (!limits2 || !Number.isFinite(raw) || raw < limits2[0] || raw > limits2[1] || a.dataType !== "float32" && !Number.isSafeInteger(raw))
+          fail(path, "action on/off value cannot be represented by dtype and transform");
+      }
+    });
+  });
+  config.devices.forEach((d, i) => {
+    keys(d, ["id", "name", "connectionId", "unitId", "profileId", "profileVersion"], `modbus.devices[${i}]`);
+    if (!name(d.name) || !integer(d.unitId, 1, 247) || !config.connections.some((c) => c.id === d.connectionId) || !findProfile(config, d))
+      fail(`modbus.devices[${i}]`, "device requires name, unit 1..247, existing connection and exact profile version");
+  });
+  return errors;
+}
+function validateModbusBindings(snapshot) {
+  const errors = [];
+  if (!Array.isArray(snapshot.physicalPoints)) return errors;
+  const config = snapshot.modbus;
+  const valid = config && validateModbus(config).length === 0;
+  for (const [i, point] of snapshot.physicalPoints.entries()) {
+    if (point?.modbus === void 0) {
+      if (point?.hardwareProfile === "modbus")
+        errors.push({
+          path: `physicalPoints[${i}].modbus`,
+          code: "invalid_modbus_binding",
+          message: "Modbus points require a device binding"
+        });
+      continue;
+    }
+    const path = `physicalPoints[${i}].modbus`;
+    const fail = (message) => errors.push({ path, code: "invalid_modbus_binding", message });
+    if (!point.modbus || typeof point.modbus !== "object" || Array.isArray(point.modbus)) {
+      fail("binding must be an object");
+      continue;
+    }
+    const binding = point.modbus;
+    if (!valid) {
+      fail("valid Modbus configuration required");
+      continue;
+    }
+    const device = config.devices.find((d) => d.id === binding.deviceId);
+    const profile = device && findProfile(config, device);
+    if (!profile || Object.keys(binding).some((key) => !["deviceId", "measurementId", "actionId"].includes(key)) || !binding.measurementId && !binding.actionId) {
+      fail("existing device and named measurement/action required");
+      continue;
+    }
+    const measurement = profile.measurements.find((m) => m.id === binding.measurementId);
+    const action = profile.actions.find((a) => a.id === binding.actionId);
+    if (binding.measurementId && !measurement) fail("unknown profile measurement");
+    if (binding.actionId && !action) fail("unknown profile action (built-in meters are read-only)");
+    if (Array.isArray(snapshot.logicalChannels))
+      for (const channel of snapshot.logicalChannels) {
+        if (channel?.physicalPointId !== point.id) continue;
+        const capabilities = Array.isArray(channel.capabilities) ? channel.capabilities : [];
+        if (capabilities.includes("output") && !action) fail("output requires named action");
+        if (capabilities.includes("input") && !measurement) fail("input requires named measurement");
+        if (capabilities.includes("measurement") && (!measurement || channel.measurement?.unit !== measurement.unit || (channel.measurement?.kind ?? "live") !== measurement.kind || channel.measurement?.scale !== 1 || channel.measurement?.offset !== 0))
+          fail("measurement channel must match profile unit/kind with identity transform");
+      }
+  }
+  return errors;
+}
+
+// backend/configuration.ts
+var HARDWARE_PROFILES = ["751-9301", "879-3000", "879-1300", "modbus"];
 var CHANNEL_PROFILES = [
   "metered-switched-load",
   "pulsed-lock-bank",
@@ -52089,7 +52324,9 @@ function validateSnapshot(snapshot) {
     ];
   }
   const errors = [];
-  exactKeys(value, "$", ["version", "physicalPoints", "logicalChannels"], errors);
+  exactKeys(value, "$", ["version", "physicalPoints", "logicalChannels", "modbus"], errors, ["modbus"]);
+  if (value.modbus !== void 0) errors.push(...validateModbus(value.modbus));
+  errors.push(...validateModbusBindings(value));
   if (value.version !== CONFIGURATION_PROTOCOL_VERSION)
     errors.push({
       path: "version",
@@ -52104,7 +52341,7 @@ function validateSnapshot(snapshot) {
   points.forEach((point, index) => {
     const path = `physicalPoints[${index}]`;
     if (!record(point, path, errors)) return;
-    exactKeys(point, path, ["id", "hardwareProfile", "channel"], errors);
+    exactKeys(point, path, ["id", "hardwareProfile", "channel", "modbus"], errors, ["modbus"]);
     addId(point.id, `${path}.id`, pointIds, errors);
     enumValue(point.hardwareProfile, `${path}.hardwareProfile`, HARDWARE_PROFILES, errors);
     if (typeof point.channel !== "number" || !Number.isSafeInteger(point.channel) || point.channel < 0)
@@ -52348,7 +52585,7 @@ function validateProfile(value, capabilities, path, errors) {
   );
 }
 function presetChannel(application) {
-  const base = {
+  const base2 = {
     id: application.channelId,
     physicalPointId: application.physicalPointId,
     profile: application.presetId,
@@ -52356,21 +52593,21 @@ function presetChannel(application) {
   };
   switch (application.presetId) {
     case "metered-switched-load":
-      return { ...base, capabilities: ["output", "measurement"], measurement: { unit: "watt", scale: 1, offset: 0 } };
+      return { ...base2, capabilities: ["output", "measurement"], measurement: { unit: "watt", scale: 1, offset: 0 } };
     case "pulsed-lock-bank":
-      return { ...base, capabilities: ["output", "pulse"], pulse: { durationMs: 500 } };
+      return { ...base2, capabilities: ["output", "pulse"], pulse: { durationMs: 500 } };
     case "guarded-enable-request":
       if (!application.guardChannelId) throw new Error("guarded enable requests require a guard channel");
       return {
-        ...base,
+        ...base2,
         capabilities: ["output", "guard"],
         guard: { channelId: application.guardChannelId, when: "on" }
       };
     case "generic-monitored-input":
-      return { ...base, capabilities: ["input"] };
+      return { ...base2, capabilities: ["input"] };
     case "generic-digital-output":
       return {
-        ...base,
+        ...base2,
         capabilities: application.feedbackChannelId ? ["output", "feedback"] : ["output"],
         ...application.feedbackChannelId ? { feedback: { channelId: application.feedbackChannelId, expected: "match", timeoutMs: 1e3 } } : {}
       };
@@ -52997,10 +53234,10 @@ function canonicalEnvelope(data, category) {
 }
 function validEnvelope(data, now) {
   const time = sourceTime(data.timestamp);
-  return time !== null && time <= now && typeof data.streamId === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(data.streamId) && Number.isSafeInteger(data.sequence) && data.sequence >= 1;
+  return time !== null && time <= now && typeof data.streamId === "string" && data.streamId.trim().length > 0 && data.streamId.length <= 128 && Number.isSafeInteger(data.sequence) && data.sequence >= 1;
 }
 function admitEnvelope(state, data, category, now) {
-  const stream = data.streamId.toLowerCase();
+  const stream = data.streamId;
   const timestamp = sourceTime(data.timestamp);
   const sequence = data.sequence;
   if (state.retiredStreams.includes(stream) || state.trackingExhausted) return "rejected";
@@ -53166,7 +53403,7 @@ var WagoDiagnosticsStore = class {
     const canonical = canonicalEnvelope(data, kind);
     if (canonical && !validEnvelope(data, this.now())) return false;
     const isObject = (value) => !!value && typeof value === "object" && !Array.isArray(value);
-    if (canonical && kind === "state" && data.readiness !== void 0 && (!isObject(data.readiness) || data.readiness.hardwareAvailable !== void 0 && typeof data.readiness.hardwareAvailable !== "boolean"))
+    if (canonical && kind === "state" && data.readiness !== void 0 && (!isObject(data.readiness) || typeof data.readiness.hardwareAvailable !== "boolean"))
       return false;
     if (canonical && kind === "state" && !(data.contentHash === null || typeof data.contentHash === "string" && /^[0-9a-f]{64}$/i.test(data.contentHash)))
       return false;
@@ -59411,7 +59648,7 @@ function diagnosticReferences(nodes, channelIds, revision, capabilities) {
       resourceId: node.resourceId,
       channelId,
       control,
-      href: `/resources/${node.resourceId}/flows`,
+      href: `/resources/${node.resourceId}/flows?node=${encodeURIComponent(node.id)}`,
       invalid: !channelIds.includes(channelId) || control && (node.data.expectedConfigurationRevision !== revision || capabilities && (!own(capabilities, channelId)?.includes("output") || node.data.action === "pulse" && !own(capabilities, channelId)?.includes("pulse"))),
       conflict: control && nodes.some(
         (other) => other.type === "plugin.wago.command" && other.resourceId !== node.resourceId && other.data.channelId === channelId
@@ -59424,6 +59661,90 @@ var WagoDiagnosticsService = class {
     __publicField(this, "context", context);
     __publicField(this, "wago", wago);
   }
+  async getResource(resourceId) {
+    const nodes = await this.context.dataSource.getRepository(import_plugins_backend_sdk15.ResourceFlowNode).createQueryBuilder("node").where("node.resourceId = :resourceId", { resourceId }).andWhere("node.type LIKE :type", { type: "plugin.wago.%" }).orderBy("node.id", "ASC").take(1001).getMany();
+    const controllerIds = /* @__PURE__ */ new Set();
+    let invalidControllerReferences = 0;
+    for (const node of nodes.slice(0, 1e3)) {
+      const id = node.data.controllerId;
+      if (typeof id !== "number" || !Number.isSafeInteger(id) || id <= 0) {
+        invalidControllerReferences++;
+      } else {
+        controllerIds.add(id);
+      }
+    }
+    const selectedControllerIds = [...controllerIds].slice(0, 20);
+    if (!selectedControllerIds.length)
+      return { resourceId, controllers: [], invalidControllerReferences, truncated: nodes.length > 1e3 };
+    const localNodes = nodes.slice(0, 1e3);
+    const localChannelIds = [
+      ...new Set(
+        localNodes.map((node) => node.data.channelId).filter((channelId) => typeof channelId === "string")
+      )
+    ];
+    const controllerIdsForQuery = selectedControllerIds.map(String);
+    const [controllers, appliedRevisions, conflictNodes] = await Promise.all([
+      this.context.getRepository(WagoController).createQueryBuilder("controller").select(["controller.id", "controller.name", "controller.hardwareId"]).where("controller.id IN (:...controllerIds)", { controllerIds: selectedControllerIds }).getMany(),
+      this.context.getRepository(WagoConfigurationRevision).createQueryBuilder("revision").select(["revision.controllerId", "revision.revision", "revision.snapshot"]).distinctOn(["revision.controllerId"]).where("revision.controllerId IN (:...controllerIds)", { controllerIds: selectedControllerIds }).andWhere("revision.state = :state", { state: "applied" }).orderBy("revision.controllerId", "ASC").addOrderBy("revision.revision", "DESC").getMany(),
+      localChannelIds.length ? this.context.dataSource.getRepository(import_plugins_backend_sdk15.ResourceFlowNode).createQueryBuilder("node").where("node.data ->> 'controllerId' IN (:...controllerIds)", { controllerIds: controllerIdsForQuery }).andWhere("node.data ->> 'channelId' IN (:...channelIds)", { channelIds: localChannelIds }).andWhere("node.type = :type", { type: "plugin.wago.command" }).take(1001).getMany() : Promise.resolve([])
+    ]);
+    const controllersById = new Map(controllers.map((controller) => [controller.id, controller]));
+    const appliedByControllerId = new Map(appliedRevisions.map((revision) => [revision.controllerId, revision]));
+    const referencesTruncated = conflictNodes.length > 1e3;
+    const conflictNodesByControllerId = /* @__PURE__ */ new Map();
+    for (const node of conflictNodes.slice(0, 1e3)) {
+      const controllerId = node.data.controllerId;
+      if (typeof controllerId !== "number") continue;
+      const matchingNodes = conflictNodesByControllerId.get(controllerId) ?? [];
+      matchingNodes.push(node);
+      conflictNodesByControllerId.set(controllerId, matchingNodes);
+    }
+    const controllersResult = selectedControllerIds.map((controllerId) => {
+      const controller = controllersById.get(controllerId);
+      if (!controller)
+        return {
+          controllerId,
+          name: `Controller ${controllerId}`,
+          unavailable: true,
+          references: [],
+          referencesTruncated: false
+        };
+      try {
+        const applied = appliedByControllerId.get(controllerId);
+        const appliedSnapshot = applied ? JSON.parse(applied.snapshot) : null;
+        const controllerNodes = localNodes.filter((node) => node.data.controllerId === controllerId);
+        const references = diagnosticReferences(
+          [...controllerNodes, ...conflictNodesByControllerId.get(controllerId) ?? []],
+          appliedSnapshot?.logicalChannels.map((channel) => channel.id) ?? [],
+          applied?.revision ?? null,
+          Object.fromEntries(
+            appliedSnapshot?.logicalChannels.map((channel) => [channel.id, channel.capabilities]) ?? []
+          )
+        ).filter((reference) => reference.resourceId === resourceId);
+        return {
+          controllerId,
+          name: controller.name ?? controller.hardwareId,
+          unavailable: false,
+          references,
+          referencesTruncated
+        };
+      } catch {
+        return {
+          controllerId,
+          name: controller.name ?? controller.hardwareId,
+          unavailable: true,
+          references: [],
+          referencesTruncated: false
+        };
+      }
+    });
+    return {
+      resourceId,
+      controllers: controllersResult,
+      invalidControllerReferences,
+      truncated: nodes.length > 1e3 || controllerIds.size > 20
+    };
+  }
   async get(controllerId) {
     const controller = await this.context.getRepository(WagoController).findOneBy({ id: controllerId });
     if (!controller) throw new import_common11.NotFoundException("WAGO controller not found");
@@ -59464,7 +59785,7 @@ var WagoDiagnosticsService = class {
       stateConnected: runtime.connected ?? null,
       stateHardwareAvailable: runtime.hardwareAvailable ?? null,
       stateSourceAt: runtime.stateSourceAt ?? null,
-      sequenceExplanation: runtime.activeStream ? "Gaps are scoped to boot UUID and message category; duplicates and retired streams are ignored." : "Legacy payloads have no source envelope; sequence gaps and source freshness are unavailable.",
+      sequenceExplanation: runtime.activeStream ? "Gaps are scoped to boot stream ID and message category; duplicates and retired streams are ignored." : "Legacy payloads have no source envelope; sequence gaps and source freshness are unavailable.",
       configuration: {
         draftUpdatedAt: draft?.updatedAt ?? null,
         draftChanged: !!draft && (!latest || configurationHash(JSON.parse(draft.snapshot)) !== latest.contentHash || configurationHash(metadataFromProvenance(draft.presetProvenance)) !== configurationHash(metadataFromProvenance(latest.presetProvenance))),
@@ -59513,9 +59834,9 @@ var WagoDiagnosticsService = class {
       limitations: [
         "Hardware readiness remains unknown. Legacy samples have no source time and are never current.",
         "Diagnostics retain at most 256 channels, 50 recent events and 15 minutes in this process.",
-        "Resource-page slots are not integrated. Flow links open the affected resource flow; node IDs identify the exact nodes.",
+        "Flow links select the affected node. Diagnostics warnings do not block resource usage; required flow nodes determine gating.",
         "The MQTT SDK exposes neither retained-message flags nor broker connection events. Source age is bounded to 90 seconds; immediate broker-disconnect detection is unavailable.",
-        "Stream tracking keeps at most 16 retired boot UUIDs per controller and six category counters, and fails closed when exhausted. Replayed source times never become receipt times."
+        "Stream tracking keeps at most 16 retired boot stream IDs per controller and six category counters, and fails closed when exhausted. Replayed source times never become receipt times."
       ]
     };
   }
@@ -59531,10 +59852,17 @@ var WagoDiagnosticsController = class {
   constructor(diagnostics) {
     __publicField(this, "diagnostics", diagnostics);
   }
+  getResource(id) {
+    return this.diagnostics.getResource(id);
+  }
   get(id) {
     return this.diagnostics.get(id);
   }
 };
+__decorateClass([
+  (0, import_common12.Get)("resources/:id/diagnostics"),
+  __decorateParam(0, (0, import_common12.Param)("id", import_common12.ParseIntPipe))
+], WagoDiagnosticsController.prototype, "getResource", 1);
 __decorateClass([
   (0, import_common12.Get)("controllers/:id/diagnostics"),
   __decorateParam(0, (0, import_common12.Param)("id", import_common12.ParseIntPipe))