@attraccess/plugin-wago 0.1.0-nightly.925.2 → 0.1.0-nightly.926.1

package/dist/index.js

@@ -36,15 +36,17 @@ module.exports = __toCommonJS(plugin_exports);
 
 // backend/wago.controller.ts
 var import_common2 = require("@nestjs/common");
-var import_plugins_backend_sdk4 = require("@attraccess/plugins-backend-sdk");
+var import_plugins_backend_sdk6 = require("@attraccess/plugins-backend-sdk");
 
 // backend/wago.service.ts
-var import_node_crypto = require("node:crypto");
+var import_node_crypto2 = require("node:crypto");
 var import_common = require("@nestjs/common");
 
 // backend/protocol.ts
 var DISCOVERY_ROOT = "attraccess/wago/discovery";
-var REQUIRED_CAPABILITIES = ["claim", "heartbeat"];
+var CONFIGURATION_PROTOCOL_VERSION = 1;
+var CONFIGURATION_CAPABILITY = `configuration-v${CONFIGURATION_PROTOCOL_VERSION}`;
+var REQUIRED_CAPABILITIES = ["claim", "heartbeat", CONFIGURATION_CAPABILITY];
 var SUPPORTED_PROTOCOL_MAJOR = 1;
 function parseAnnouncement(payload) {
   let value;
@@ -85,8 +87,38 @@ function compatibilityError(announcement) {
 function discoveryTopic(hardwareId) {
   return `${DISCOVERY_ROOT}/${hardwareId}`;
 }
-function heartbeatTopic(hardwareId) {
-  return `attraccess/wago/controllers/${hardwareId}/heartbeat`;
+function heartbeatTopic(prefix, hardwareId) {
+  return `${normalizeOperationalPrefix(prefix)}/v${CONFIGURATION_PROTOCOL_VERSION}/controllers/${hardwareId}/heartbeat`;
+}
+function configurationDesiredTopic(prefix, hardwareId) {
+  return `${normalizeOperationalPrefix(prefix)}/v${CONFIGURATION_PROTOCOL_VERSION}/controllers/${hardwareId}/configuration/desired`;
+}
+function configurationReportedTopic(prefix, hardwareId) {
+  return `${normalizeOperationalPrefix(prefix)}/v${CONFIGURATION_PROTOCOL_VERSION}/controllers/${hardwareId}/configuration/reported`;
+}
+function commandTopic(prefix, hardwareId) {
+  return `${normalizeOperationalPrefix(prefix)}/v${CONFIGURATION_PROTOCOL_VERSION}/controllers/${hardwareId}/commands`;
+}
+function configurationReportedWildcardTopic(prefix) {
+  return configurationReportedTopic(prefix, "+");
+}
+function configurationReportedHardwareId(prefix, topic) {
+  const topicPrefix = `${normalizeOperationalPrefix(prefix)}/v${CONFIGURATION_PROTOCOL_VERSION}/controllers/`;
+  const topicSuffix = "/configuration/reported";
+  if (!topic.startsWith(topicPrefix) || !topic.endsWith(topicSuffix)) return null;
+  const hardwareId = topic.slice(topicPrefix.length, -topicSuffix.length);
+  return hardwareId && !/[+/]/.test(hardwareId) ? hardwareId : null;
+}
+function normalizeOperationalPrefix(prefix) {
+  const trimmed = prefix.trim();
+  let start = 0;
+  let end = trimmed.length;
+  while (trimmed[start] === "/") start += 1;
+  while (trimmed[end - 1] === "/") end -= 1;
+  const normalized = trimmed.slice(start, end);
+  if (!normalized || normalized.split("/").some((segment) => !segment || /[+#]/.test(segment)))
+    throw new Error("MQTT prefix must contain non-empty segments without wildcards");
+  return normalized;
 }
 
 // backend/wago-controller.entity.ts
@@ -173,6 +205,7 @@ var WagoSettings = class {
   constructor() {
     __publicField(this, "id");
     __publicField(this, "defaultMqttServerId");
+    __publicField(this, "operationalPrefix");
   }
 };
 __decorateClass([
@@ -181,6 +214,9 @@ __decorateClass([
 __decorateClass([
   (0, import_plugins_backend_sdk2.Column)({ type: "integer", name: "default_mqtt_server_id", nullable: true })
 ], WagoSettings.prototype, "defaultMqttServerId", 2);
+__decorateClass([
+  (0, import_plugins_backend_sdk2.Column)({ type: "varchar", name: "operational_prefix", default: "attraccess/wago" })
+], WagoSettings.prototype, "operationalPrefix", 2);
 WagoSettings = __decorateClass([
   (0, import_plugins_backend_sdk2.Entity)({ name: "plugin_wago_settings" })
 ], WagoSettings);
@@ -231,9 +267,365 @@ WagoEnrollment = __decorateClass([
   (0, import_plugins_backend_sdk3.Entity)({ name: "plugin_wago_enrollments" })
 ], WagoEnrollment);
 
+// backend/configuration.ts
+var import_node_crypto = require("node:crypto");
+var HARDWARE_PROFILES = ["751-9301", "879-3000", "879-1300"];
+var CHANNEL_PROFILES = [
+  "metered-switched-load",
+  "pulsed-lock-bank",
+  "guarded-enable-request",
+  "generic-digital-output",
+  "generic-monitored-input"
+];
+var CAPABILITIES = ["output", "input", "measurement", "pulse", "guard"];
+function canonicalSnapshot(snapshot) {
+  if (!snapshot || typeof snapshot !== "object" || Array.isArray(snapshot))
+    throw new Error("configuration snapshot must be an object");
+  return JSON.stringify(sortValue(snapshot));
+}
+function configurationHash(snapshot) {
+  return (0, import_node_crypto.createHash)("sha256").update(canonicalSnapshot(snapshot)).digest("hex");
+}
+function configurationDiff(previous, current) {
+  const changes = [];
+  diffValue("$", previous, current, changes);
+  return changes;
+}
+function parseConfigurationReport(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const report = value;
+  if (!Number.isSafeInteger(report.revision) || report.revision < 1 || typeof report.contentHash !== "string" || !report.contentHash.trim() || report.errors !== void 0 && !Array.isArray(report.errors))
+    return null;
+  const errors = report.errors ?? [];
+  if (!errors.every(isConfigurationValidationError)) return null;
+  return { revision: report.revision, contentHash: report.contentHash, errors };
+}
+function validateSnapshot(snapshot) {
+  let value;
+  try {
+    value = JSON.parse(canonicalSnapshot(snapshot));
+  } catch (error) {
+    return [
+      { path: "$", code: "invalid_snapshot", message: error instanceof Error ? error.message : "invalid snapshot" }
+    ];
+  }
+  const errors = [];
+  exactKeys(value, "$", ["version", "physicalPoints", "logicalChannels"], errors);
+  if (value.version !== CONFIGURATION_PROTOCOL_VERSION)
+    errors.push({
+      path: "version",
+      code: "unsupported_version",
+      message: `version must be ${CONFIGURATION_PROTOCOL_VERSION}`
+    });
+  const points = collection(value.physicalPoints, "physicalPoints", errors);
+  const channels = collection(value.logicalChannels, "logicalChannels", errors);
+  const pointIds = /* @__PURE__ */ new Set();
+  const channelIds = /* @__PURE__ */ new Set();
+  points.forEach((point, index) => {
+    const path = `physicalPoints[${index}]`;
+    if (!record(point, path, errors)) return;
+    exactKeys(point, path, ["id", "hardwareProfile", "channel"], errors);
+    addId(point.id, `${path}.id`, pointIds, errors);
+    enumValue(point.hardwareProfile, `${path}.hardwareProfile`, HARDWARE_PROFILES, errors);
+    if (!Number.isSafeInteger(point.channel) || point.channel < 0)
+      errors.push({
+        path: `${path}.channel`,
+        code: "invalid_channel",
+        message: "channel must be a non-negative integer"
+      });
+  });
+  channels.forEach((channel, index) => {
+    if (channel && typeof channel === "object" && !Array.isArray(channel))
+      addId(channel.id, `logicalChannels[${index}].id`, channelIds, errors);
+  });
+  channels.forEach((channel, index) => {
+    const path = `logicalChannels[${index}]`;
+    if (!record(channel, path, errors)) return;
+    exactKeys(
+      channel,
+      path,
+      [
+        "id",
+        "physicalPointId",
+        "profile",
+        "capabilities",
+        "disconnectPolicy",
+        "range",
+        "pulse",
+        "guard",
+        "measurement"
+      ],
+      errors
+    );
+    if (typeof channel.physicalPointId !== "string" || !pointIds.has(channel.physicalPointId))
+      errors.push(referenceError(`${path}.physicalPointId`, "physical point", channel.physicalPointId));
+    enumValue(channel.profile, `${path}.profile`, CHANNEL_PROFILES, errors);
+    const capabilities = capabilityList(channel.capabilities, `${path}.capabilities`, errors);
+    validateDisconnectPolicy(channel.disconnectPolicy, `${path}.disconnectPolicy`, errors);
+    validateRange(channel.range, `${path}.range`, capabilities, errors);
+    validatePulse(channel.pulse, `${path}.pulse`, capabilities, errors);
+    validateGuard(channel.guard, `${path}.guard`, capabilities, channelIds, errors);
+    validateMeasurement(channel.measurement, `${path}.measurement`, capabilities, errors);
+    validateProfile(channel.profile, capabilities, path, errors);
+  });
+  return errors;
+}
+function diffValue(path, previous, current, changes) {
+  if (Object.is(previous, current)) return;
+  if (Array.isArray(previous) && Array.isArray(current)) {
+    const length = Math.max(previous.length, current.length);
+    for (let index = 0; index < length; index += 1)
+      diffValue(`${path}[${index}]`, previous[index], current[index], changes);
+    return;
+  }
+  if (isRecord(previous) && isRecord(current)) {
+    const keys = /* @__PURE__ */ new Set([...Object.keys(previous), ...Object.keys(current)]);
+    for (const key of [...keys].sort()) diffValue(`${path}.${key}`, previous[key], current[key], changes);
+    return;
+  }
+  changes.push({ path, previous, current });
+}
+function isConfigurationValidationError(value) {
+  return isRecord(value) && typeof value.path === "string" && Boolean(value.path.trim()) && typeof value.code === "string" && Boolean(value.code.trim()) && typeof value.message === "string" && Boolean(value.message.trim());
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function collection(value, path, errors) {
+  if (!Array.isArray(value)) {
+    errors.push({ path, code: "invalid_collection", message: `${path} must be an array` });
+    return [];
+  }
+  return value;
+}
+function record(value, path, errors) {
+  if (value && typeof value === "object" && !Array.isArray(value)) return true;
+  errors.push({ path, code: "invalid_object", message: `${path} must be an object` });
+  return false;
+}
+function exactKeys(value, path, allowed, errors, optional = []) {
+  Object.keys(value).filter((key) => !allowed.includes(key)).forEach(
+    (key) => errors.push({
+      path: path === "$" ? key : `${path}.${key}`,
+      code: "unknown_field",
+      message: "field is not supported by configuration version 1"
+    })
+  );
+  allowed.filter((key) => !["range", "pulse", "guard", "measurement", ...optional].includes(key) && !(key in value)).forEach(
+    (key) => errors.push({
+      path: path === "$" ? key : `${path}.${key}`,
+      code: "required_field",
+      message: "field is required"
+    })
+  );
+}
+function addId(value, path, ids, errors) {
+  if (typeof value !== "string" || !value.trim()) {
+    errors.push({ path, code: "invalid_id", message: "id must be a non-empty string" });
+    return;
+  }
+  if (ids.has(value)) errors.push({ path, code: "duplicate_id", message: `duplicate id ${value}` });
+  ids.add(value);
+}
+function enumValue(value, path, options, errors) {
+  if (!options.includes(value))
+    errors.push({ path, code: "unsupported_value", message: `must be one of: ${options.join(", ")}` });
+}
+function capabilityList(value, path, errors) {
+  if (!Array.isArray(value) || !value.length) {
+    errors.push({ path, code: "invalid_capabilities", message: "capabilities must be a non-empty array" });
+    return /* @__PURE__ */ new Set();
+  }
+  const capabilities = /* @__PURE__ */ new Set();
+  value.forEach((item, index) => {
+    if (!CAPABILITIES.includes(item))
+      errors.push({
+        path: `${path}[${index}]`,
+        code: "unsupported_capability",
+        message: `must be one of: ${CAPABILITIES.join(", ")}`
+      });
+    else if (capabilities.has(item))
+      errors.push({ path: `${path}[${index}]`, code: "duplicate_capability", message: `duplicate capability ${item}` });
+    else capabilities.add(item);
+  });
+  return capabilities;
+}
+function validateDisconnectPolicy(value, path, errors) {
+  if (!record(value, path, errors)) return;
+  exactKeys(value, path, ["mode", "timeoutMs"], errors, ["timeoutMs"]);
+  if (!["hold", "immediate", "watchdog"].includes(value.mode))
+    errors.push({
+      path: `${path}.mode`,
+      code: "unsupported_value",
+      message: "mode must be hold, immediate, or watchdog"
+    });
+  if (value.mode === "watchdog" && (!Number.isSafeInteger(value.timeoutMs) || value.timeoutMs <= 0))
+    errors.push({
+      path: `${path}.timeoutMs`,
+      code: "required_field",
+      message: "watchdog timeoutMs must be a positive integer"
+    });
+  if (value.mode !== "watchdog" && value.timeoutMs !== void 0)
+    errors.push({
+      path: `${path}.timeoutMs`,
+      code: "unsupported_field",
+      message: "timeoutMs is only valid for watchdog policies"
+    });
+}
+function validateRange(value, path, capabilities, errors) {
+  if (value === void 0) return;
+  if (!record(value, path, errors)) return;
+  exactKeys(value, path, ["minimum", "maximum"], errors);
+  if (!Number.isFinite(value.minimum) || !Number.isFinite(value.maximum) || value.minimum >= value.maximum)
+    errors.push({
+      path,
+      code: "invalid_range",
+      message: "minimum and maximum must be finite numbers where minimum is less than maximum"
+    });
+  if (!capabilities.has("input") && !capabilities.has("measurement"))
+    errors.push({ path, code: "unsupported_field", message: "range requires input or measurement capability" });
+}
+function validatePulse(value, path, capabilities, errors) {
+  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;
+  if (!record(value, path, errors)) return;
+  exactKeys(value, path, ["channelId", "when"], errors);
+  if (typeof value.channelId !== "string" || !channelIds.has(value.channelId))
+    errors.push(referenceError(`${path}.channelId`, "logical channel", value.channelId));
+  if (!["on", "off"].includes(value.when))
+    errors.push({ path: `${path}.when`, code: "unsupported_value", message: "when must be on or off" });
+  if (!capabilities.has("guard"))
+    errors.push({ path, code: "unsupported_field", message: "guard requires guard capability" });
+}
+function validateMeasurement(value, path, capabilities, errors) {
+  if (value === void 0) return;
+  if (!record(value, path, errors)) return;
+  exactKeys(value, path, ["unit", "scale", "offset"], errors);
+  enumValue(value.unit, `${path}.unit`, ["ampere", "volt", "watt", "percent"], errors);
+  if (!Number.isFinite(value.scale) || !Number.isFinite(value.offset))
+    errors.push({ path, code: "invalid_measurement", message: "scale and offset must be finite numbers" });
+  if (!capabilities.has("measurement"))
+    errors.push({ path, code: "unsupported_field", message: "measurement requires measurement 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 referenceError(path, type, id) {
+  return { path, code: "missing_reference", message: `${type} ${String(id)} does not exist in this snapshot` };
+}
+function sortValue(value) {
+  if (Array.isArray(value)) return value.map(sortValue);
+  if (!value || typeof value !== "object") return value;
+  return Object.fromEntries(
+    Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, sortValue(item)])
+  );
+}
+
+// backend/wago-configuration-draft.entity.ts
+var import_plugins_backend_sdk4 = require("@attraccess/plugins-backend-sdk");
+var WagoConfigurationDraft = class {
+  constructor() {
+    __publicField(this, "id");
+    __publicField(this, "controllerId");
+    __publicField(this, "snapshot");
+    __publicField(this, "reviewedHash");
+    __publicField(this, "updatedAt");
+  }
+};
+__decorateClass([
+  (0, import_plugins_backend_sdk4.PrimaryGeneratedColumn)({ type: "integer" })
+], WagoConfigurationDraft.prototype, "id", 2);
+__decorateClass([
+  (0, import_plugins_backend_sdk4.Column)({ type: "integer", name: "controller_id", unique: true })
+], WagoConfigurationDraft.prototype, "controllerId", 2);
+__decorateClass([
+  (0, import_plugins_backend_sdk4.Column)({ type: "text" })
+], WagoConfigurationDraft.prototype, "snapshot", 2);
+__decorateClass([
+  (0, import_plugins_backend_sdk4.Column)({ type: "varchar", name: "reviewed_hash", nullable: true })
+], WagoConfigurationDraft.prototype, "reviewedHash", 2);
+__decorateClass([
+  (0, import_plugins_backend_sdk4.Column)({ type: "varchar", name: "updated_at" })
+], WagoConfigurationDraft.prototype, "updatedAt", 2);
+WagoConfigurationDraft = __decorateClass([
+  (0, import_plugins_backend_sdk4.Entity)({ name: "plugin_wago_configuration_drafts" })
+], WagoConfigurationDraft);
+
+// backend/wago-configuration-revision.entity.ts
+var import_plugins_backend_sdk5 = require("@attraccess/plugins-backend-sdk");
+var WagoConfigurationRevision = class {
+  constructor() {
+    __publicField(this, "id");
+    __publicField(this, "controllerId");
+    __publicField(this, "revision");
+    __publicField(this, "snapshot");
+    __publicField(this, "contentHash");
+    __publicField(this, "state");
+    __publicField(this, "rejectionErrors");
+    __publicField(this, "publishedAt");
+    __publicField(this, "reportedAt");
+  }
+};
+__decorateClass([
+  (0, import_plugins_backend_sdk5.PrimaryGeneratedColumn)({ type: "integer" })
+], WagoConfigurationRevision.prototype, "id", 2);
+__decorateClass([
+  (0, import_plugins_backend_sdk5.Column)({ type: "integer", name: "controller_id" })
+], WagoConfigurationRevision.prototype, "controllerId", 2);
+__decorateClass([
+  (0, import_plugins_backend_sdk5.Column)({ type: "integer" })
+], WagoConfigurationRevision.prototype, "revision", 2);
+__decorateClass([
+  (0, import_plugins_backend_sdk5.Column)({ type: "text" })
+], WagoConfigurationRevision.prototype, "snapshot", 2);
+__decorateClass([
+  (0, import_plugins_backend_sdk5.Column)({ type: "varchar", name: "content_hash" })
+], WagoConfigurationRevision.prototype, "contentHash", 2);
+__decorateClass([
+  (0, import_plugins_backend_sdk5.Column)({ type: "varchar" })
+], WagoConfigurationRevision.prototype, "state", 2);
+__decorateClass([
+  (0, import_plugins_backend_sdk5.Column)({ type: "text", name: "rejection_errors", nullable: true })
+], WagoConfigurationRevision.prototype, "rejectionErrors", 2);
+__decorateClass([
+  (0, import_plugins_backend_sdk5.Column)({ type: "varchar", name: "published_at" })
+], WagoConfigurationRevision.prototype, "publishedAt", 2);
+__decorateClass([
+  (0, import_plugins_backend_sdk5.Column)({ type: "varchar", name: "reported_at", nullable: true })
+], WagoConfigurationRevision.prototype, "reportedAt", 2);
+WagoConfigurationRevision = __decorateClass([
+  (0, import_plugins_backend_sdk5.Entity)({ name: "plugin_wago_configuration_revisions" })
+], WagoConfigurationRevision);
+
 // backend/wago.service.ts
 var PLUGIN_CONTEXT = /* @__PURE__ */ Symbol.for("attraccess.plugin.context");
 var STALE_AFTER_MS = 9e4;
+var MAX_PENDING_CONFIGURATION_REPORTS = 100;
 var ENROLLMENT_RETRY_MS = 6e4;
 var WagoService = class {
   constructor(context) {
@@ -241,9 +633,14 @@ var WagoService = class {
     __publicField(this, "controllers");
     __publicField(this, "settings");
     __publicField(this, "enrollments");
+    __publicField(this, "drafts");
+    __publicField(this, "revisions");
     __publicField(this, "subscriptions", []);
     __publicField(this, "enrollmentExpiryTimers", /* @__PURE__ */ new Map());
     __publicField(this, "claimLocks", /* @__PURE__ */ new Map());
+    __publicField(this, "configurationLocks", /* @__PURE__ */ new Map());
+    __publicField(this, "configurationReportQueues", /* @__PURE__ */ new Map());
+    __publicField(this, "claimConfigurationLock", Promise.resolve());
     __publicField(this, "subscriptionRebuild", Promise.resolve());
     __publicField(this, "subscriptionRetryTimer", null);
     __publicField(this, "activeSubscriptionGeneration", 0);
@@ -251,6 +648,8 @@ var WagoService = class {
     this.controllers = context.getRepository(WagoController);
     this.settings = context.getRepository(WagoSettings);
     this.enrollments = context.getRepository(WagoEnrollment);
+    this.drafts = context.getRepository(WagoConfigurationDraft);
+    this.revisions = context.getRepository(WagoConfigurationRevision);
   }
   async onModuleInit() {
     const enrollments = await this.enrollments.createQueryBuilder("enrollment").where("enrollment.consumedAt IS NULL").getMany();
@@ -288,18 +687,144 @@ var WagoService = class {
   async getSettings() {
     const settings = await this.settings.findOneBy({ id: 1 });
     if (settings) return settings;
-    await this.settings.createQueryBuilder().insert().values({ id: 1, defaultMqttServerId: null }).orIgnore().execute();
+    await this.settings.createQueryBuilder().insert().values({ id: 1, defaultMqttServerId: null, operationalPrefix: "attraccess/wago" }).orIgnore().execute();
     return this.settings.findOneByOrFail({ id: 1 });
   }
-  async setDefaultMqttServer(serverId) {
-    if (serverId !== null && !await this.context.getMqttServerConfig(serverId))
+  async setSettings(serverId, operationalPrefix) {
+    if (serverId !== void 0 && serverId !== null && !await this.context.getMqttServerConfig(serverId))
       throw new import_common.NotFoundException(`MQTT server ${serverId} not found`);
-    const settings = await this.getSettings();
-    settings.defaultMqttServerId = serverId;
-    await this.settings.save(settings);
+    const save = async () => {
+      const settings2 = await this.getSettings();
+      if (serverId !== void 0) settings2.defaultMqttServerId = serverId;
+      if (operationalPrefix !== void 0) {
+        const normalizedPrefix = normalizeOperationalPrefix(operationalPrefix);
+        if (normalizedPrefix !== settings2.operationalPrefix) {
+          const controllers = await this.controllers.find({ where: { trustState: "claimed" } });
+          if (controllers.length)
+            throw new import_common.ConflictException("operational MQTT prefix cannot change after a controller has been claimed");
+          settings2.operationalPrefix = normalizedPrefix;
+        }
+      }
+      await this.settings.save(settings2);
+      return settings2;
+    };
+    const settings = operationalPrefix === void 0 ? await save() : await this.withClaimConfigurationLock(save);
     await this.subscribeConfiguredServers();
     return settings;
   }
+  async setDefaultMqttServer(serverId) {
+    return this.setSettings(serverId);
+  }
+  async getDraft(controllerId) {
+    await this.claimedController(controllerId);
+    return this.drafts.findOneBy({ controllerId });
+  }
+  async saveDraft(controllerId, snapshot) {
+    return this.withConfigurationLock(controllerId, () => this.saveDraftWhileLocked(controllerId, snapshot));
+  }
+  async validateDraft(controllerId) {
+    const draft = await this.getDraft(controllerId);
+    if (!draft) throw new import_common.NotFoundException(`WAGO controller ${controllerId} has no configuration draft`);
+    const errors = validateSnapshot(JSON.parse(draft.snapshot));
+    return { valid: errors.length === 0, errors };
+  }
+  async revisionsFor(controllerId, offset = 0, limit = 20) {
+    await this.claimedController(controllerId);
+    const pageOffset = Number.isSafeInteger(offset) && offset > 0 ? offset : 0;
+    const pageLimit = Number.isSafeInteger(limit) && limit > 0 ? Math.min(limit, 100) : 20;
+    const revisions = await this.revisions.find({
+      where: { controllerId },
+      order: { revision: "DESC" },
+      select: [
+        "id",
+        "controllerId",
+        "revision",
+        "contentHash",
+        "state",
+        "rejectionErrors",
+        "publishedAt",
+        "reportedAt"
+      ],
+      skip: pageOffset,
+      take: pageLimit
+    });
+    return { revisions, offset: pageOffset, limit: pageLimit };
+  }
+  async reviewDraft(controllerId) {
+    return this.withConfigurationLock(controllerId, () => this.reviewDraftWhileLocked(controllerId));
+  }
+  async publishDraft(controllerId) {
+    return this.withConfigurationLock(controllerId, () => this.publishDraftWhileLocked(controllerId));
+  }
+  async rollback(controllerId, revision) {
+    return this.withConfigurationLock(controllerId, async () => {
+      const source = await this.revisions.findOneBy({ controllerId, revision });
+      if (!source) throw new import_common.NotFoundException(`WAGO configuration revision ${revision} not found`);
+      await this.saveDraftWhileLocked(controllerId, JSON.parse(source.snapshot));
+      await this.reviewDraftWhileLocked(controllerId);
+      return this.publishDraftWhileLocked(controllerId);
+    });
+  }
+  async previewRevision(controllerId, revision) {
+    await this.claimedController(controllerId);
+    const selected = await this.revisions.findOneBy({ controllerId, revision });
+    if (!selected) throw new import_common.NotFoundException(`WAGO configuration revision ${revision} not found`);
+    const [current] = await this.revisions.find({ where: { controllerId }, order: { revision: "DESC" }, take: 1 });
+    return {
+      revision: selected,
+      current: current ?? null,
+      diff: configurationDiff(current ? JSON.parse(current.snapshot) : null, JSON.parse(selected.snapshot))
+    };
+  }
+  async saveDraftWhileLocked(controllerId, snapshot) {
+    await this.claimedController(controllerId);
+    const serialized = canonicalSnapshot(snapshot);
+    const existing = await this.drafts.findOneBy({ controllerId });
+    const draft = existing ?? this.drafts.create({ controllerId, snapshot: serialized, reviewedHash: null, updatedAt: "" });
+    draft.snapshot = serialized;
+    draft.reviewedHash = null;
+    draft.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    return this.drafts.save(draft);
+  }
+  async reviewDraftWhileLocked(controllerId) {
+    await this.claimedController(controllerId);
+    const draft = await this.drafts.findOneBy({ controllerId });
+    if (!draft) throw new import_common.NotFoundException(`WAGO controller ${controllerId} has no configuration draft`);
+    const previous = await this.latestRevision(controllerId);
+    draft.reviewedHash = configurationHash(JSON.parse(draft.snapshot));
+    await this.drafts.save(draft);
+    const diff = configurationDiff(previous ? JSON.parse(previous.snapshot) : null, JSON.parse(draft.snapshot));
+    return { draft, previous, changed: diff.length > 0, diff };
+  }
+  async publishDraftWhileLocked(controllerId) {
+    const controller = await this.claimedController(controllerId);
+    const draft = await this.drafts.findOneBy({ controllerId });
+    if (!draft) throw new import_common.NotFoundException(`WAGO controller ${controllerId} has no configuration draft`);
+    const validation = validateSnapshot(JSON.parse(draft.snapshot));
+    if (validation.length)
+      throw new import_common.ConflictException({ message: "configuration draft is invalid", errors: validation });
+    const contentHash = configurationHash(JSON.parse(draft.snapshot));
+    if (draft.reviewedHash !== contentHash)
+      throw new import_common.ConflictException("review the current configuration draft before publishing it");
+    const previous = await this.latestRevision(controllerId);
+    if (previous?.state === "pending" && previous.contentHash === contentHash)
+      return this.publishRevision(controller, previous);
+    const revision = this.revisions.create({
+      controllerId,
+      revision: (previous?.revision ?? 0) + 1,
+      snapshot: draft.snapshot,
+      contentHash,
+      state: "pending",
+      rejectionErrors: null,
+      publishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      reportedAt: null
+    });
+    return this.publishRevision(controller, await this.revisions.save(revision));
+  }
+  async latestRevision(controllerId) {
+    const [revision] = await this.revisions.find({ where: { controllerId }, order: { revision: "DESC" }, take: 1 });
+    return revision ?? null;
+  }
   async createEnrollment(hardwareId, mqttServerId, manualCredentials) {
     const normalizedHardwareId = hardwareId.trim();
     if (!isValidHardwareId(normalizedHardwareId))
@@ -308,8 +833,8 @@ var WagoService = class {
     if (!selectedServerId) throw new import_common.ConflictException("select an MQTT server before creating an enrollment package");
     const server = await this.context.getMqttServerConfig(selectedServerId);
     if (!server) throw new import_common.NotFoundException(`MQTT server ${selectedServerId} not found`);
-    const claimSecret = (0, import_node_crypto.randomBytes)(24).toString("base64url");
-    const identity = `wago-enrollment-${(0, import_node_crypto.randomBytes)(8).toString("hex")}`;
+    const claimSecret = (0, import_node_crypto2.randomBytes)(24).toString("base64url");
+    const identity = `wago-enrollment-${(0, import_node_crypto2.randomBytes)(8).toString("hex")}`;
     const expiresAt = new Date(Date.now() + 15 * 6e4).toISOString();
     const provisionedCredential = await this.context.getMqttCredentialProvisioning().provision({
       mqttServerId: selectedServerId,
@@ -355,9 +880,37 @@ var WagoService = class {
     };
   }
   async claim(id, name, verifier, mqttServerId) {
-    return this.withClaimLock(id, () => this.claimController(id, name, verifier, mqttServerId));
+    return this.withClaimLock(id, async () => {
+      const prepared = await this.withClaimConfigurationLock(() => this.prepareClaim(id, name, verifier, mqttServerId));
+      try {
+        await this.context.mqtt.publish(
+          prepared.mqttServerId,
+          `${discoveryTopic(prepared.controller.hardwareId)}/claim`,
+          JSON.stringify({
+            username: prepared.credential.username,
+            password: prepared.credential.password,
+            configuration: prepared.configuration
+          }),
+          { qos: 1 }
+        );
+        prepared.credentialDelivered = true;
+        await this.context.mqtt.publish(prepared.mqttServerId, discoveryTopic(prepared.controller.hardwareId), "", {
+          qos: 1,
+          retain: true
+        });
+        return prepared.controller;
+      } catch (error) {
+        if (!prepared.credentialDelivered) await this.restoreUnclaimedController(prepared);
+        throw error;
+      } finally {
+        await this.subscribeConfiguredServers().catch((error) => {
+          this.context.logger.warn(`Could not refresh WAGO MQTT subscriptions after claim: ${String(error)}`);
+          this.scheduleSubscriptionRetry();
+        });
+      }
+    });
   }
-  async claimController(id, name, verifier, mqttServerId) {
+  async prepareClaim(id, name, verifier, mqttServerId) {
     const controller = await this.controllers.findOneBy({ id });
     if (!controller) throw new import_common.NotFoundException(`WAGO controller ${id} not found`);
     if (controller.trustState === "claimed") throw new import_common.ConflictException("controller has already been claimed");
@@ -377,20 +930,26 @@ var WagoService = class {
         "the controller enrollment package has expired or was already consumed; create a new one"
       );
     const identity = `wago-controller-${controller.hardwareId}`;
+    const settings = await this.getSettings();
+    const namespace = normalizeOperationalPrefix(settings.operationalPrefix);
     const credential = await this.context.getMqttCredentialProvisioning().provision({
       mqttServerId: selectedServerId,
       identity,
       username: identity,
       vhost: "/",
       topicPolicy: {
-        publish: [`attraccess/wago/controllers/${controller.hardwareId}/#`],
-        subscribe: [`attraccess/wago/controllers/${controller.hardwareId}/desired/#`]
+        publish: [
+          `${namespace}/v${CONFIGURATION_PROTOCOL_VERSION}/controllers/${controller.hardwareId}/#`
+        ],
+        subscribe: [
+          configurationDesiredTopic(namespace, controller.hardwareId),
+          commandTopic(namespace, controller.hardwareId)
+        ]
       }
     });
     if (!("password" in credential)) {
       throw new import_common.ConflictException(`Manual credential provisioning is required: ${credential.instructions.join(" ")}`);
     }
-    let credentialDelivered = false;
     const previousController = {
       trustState: controller.trustState,
       name: controller.name,
@@ -404,36 +963,59 @@ var WagoService = class {
       controller.mqttServerId = selectedServerId;
       controller.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
       await this.controllers.save(controller);
-      await this.context.mqtt.publish(
-        selectedServerId,
-        `${discoveryTopic(controller.hardwareId)}/claim`,
-        JSON.stringify({ username: credential.username, password: credential.password }),
-        { qos: 1 }
-      );
-      credentialDelivered = true;
-      await this.context.mqtt.publish(selectedServerId, discoveryTopic(controller.hardwareId), "", {
-        qos: 1,
-        retain: true
-      });
-      return controller;
+      return {
+        controller,
+        mqttServerId: selectedServerId,
+        credential,
+        configuration: {
+          protocolVersion: CONFIGURATION_PROTOCOL_VERSION,
+          namespace,
+          desiredTopic: configurationDesiredTopic(namespace, controller.hardwareId),
+          reportedTopic: configurationReportedTopic(namespace, controller.hardwareId)
+        },
+        identity,
+        previousController,
+        credentialDelivered: false
+      };
     } catch (error) {
-      if (!credentialDelivered) {
-        await this.context.getMqttCredentialProvisioning().revoke({ mqttServerId: selectedServerId, identity, username: identity, vhost: "/" }).catch(() => void 0);
-        Object.assign(controller, previousController);
-        await this.controllers.save(controller).catch((rollbackError) => {
-          this.context.logger.warn(
-            `Could not restore WAGO controller ${controller.id} after claim failure: ${String(rollbackError)}`
-          );
-        });
-      }
-      throw error;
-    } finally {
-      await this.subscribeConfiguredServers().catch((error) => {
-        this.context.logger.warn(`Could not refresh WAGO MQTT subscriptions after claim: ${String(error)}`);
-        this.scheduleSubscriptionRetry();
+      await this.restoreUnclaimedControllerWhileLocked({
+        controller,
+        mqttServerId: selectedServerId,
+        identity,
+        previousController
       });
+      throw error;
     }
   }
+  async restoreUnclaimedController({
+    controller,
+    mqttServerId,
+    identity,
+    previousController
+  }) {
+    await this.withClaimConfigurationLock(
+      () => this.restoreUnclaimedControllerWhileLocked({
+        controller,
+        mqttServerId,
+        identity,
+        previousController
+      })
+    );
+  }
+  async restoreUnclaimedControllerWhileLocked({
+    controller,
+    mqttServerId,
+    identity,
+    previousController
+  }) {
+    await this.context.getMqttCredentialProvisioning().revoke({ mqttServerId, identity, username: identity, vhost: "/" }).catch(() => void 0);
+    Object.assign(controller, previousController);
+    await this.controllers.save(controller).catch((rollbackError) => {
+      this.context.logger.warn(
+        `Could not restore WAGO controller ${controller.id} after claim failure: ${String(rollbackError)}`
+      );
+    });
+  }
   async subscribeConfiguredServers() {
     if (this.destroyed) return;
     const rebuild = this.subscriptionRebuild.then(() => this.rebuildSubscriptions());
@@ -463,15 +1045,47 @@ var WagoService = class {
             await this.onDiscovery(serverId, message.topic, message.payload);
           })
         );
-        for (const controller of controllers.filter(
+        if (this.destroyed) {
+          replacements.forEach((subscription) => subscription.unsubscribe());
+          return;
+        }
+        const claimedControllers = controllers.filter(
           (item) => item.trustState === "claimed" && (item.mqttServerId ?? settings.defaultMqttServerId) === serverId
-        )) {
-          replacements.push(
-            await this.context.mqtt.subscribe(serverId, heartbeatTopic(controller.hardwareId), async (message) => {
+        );
+        const controllersByHardwareId = new Map(
+          claimedControllers.map((controller) => [controller.hardwareId, controller])
+        );
+        replacements.push(
+          await this.context.mqtt.subscribe(
+            serverId,
+            configurationReportedWildcardTopic(settings.operationalPrefix),
+            (message) => {
               if (!this.isActiveSubscriptionGeneration(generation)) return;
-              await this.onHeartbeat(controller.hardwareId, message.payload);
-            })
+              const hardwareId = configurationReportedHardwareId(settings.operationalPrefix, message.topic);
+              const controller = hardwareId ? controllersByHardwareId.get(hardwareId) : void 0;
+              if (controller) this.enqueueConfigurationReport(controller.id, message.payload);
+            }
+          )
+        );
+        if (this.destroyed) {
+          replacements.forEach((subscription) => subscription.unsubscribe());
+          return;
+        }
+        for (const controller of claimedControllers) {
+          replacements.push(
+            await this.context.mqtt.subscribe(
+              serverId,
+              heartbeatTopic(settings.operationalPrefix, controller.hardwareId),
+              async (message) => {
+                if (!this.isActiveSubscriptionGeneration(generation)) return;
+                await this.onHeartbeat(controller.hardwareId, message.payload);
+              }
+            )
           );
+          if (this.destroyed) {
+            replacements.forEach((subscription) => subscription.unsubscribe());
+            return;
+          }
         }
       }
     } catch (error) {
@@ -572,6 +1186,91 @@ var WagoService = class {
     controller.updatedAt = now;
     await this.controllers.save(controller);
   }
+  async onConfigurationReported(controllerId, payload) {
+    let report;
+    try {
+      report = parseConfigurationReport(JSON.parse(payload.toString("utf8")));
+    } catch {
+      this.context.logger.warn(`Ignoring invalid WAGO configuration report for controller ${controllerId}`);
+      return;
+    }
+    if (!report) {
+      this.context.logger.warn(`Ignoring malformed WAGO configuration report for controller ${controllerId}`);
+      return;
+    }
+    await this.withConfigurationLock(controllerId, async () => {
+      const revision = await this.revisions.findOneBy({ controllerId, revision: report.revision });
+      if (!revision || revision.contentHash !== report.contentHash) return;
+      if (revision.state !== "published") return;
+      revision.state = report.errors.length ? "rejected" : "applied";
+      revision.rejectionErrors = report.errors.length ? JSON.stringify(report.errors) : null;
+      revision.reportedAt = (/* @__PURE__ */ new Date()).toISOString();
+      await this.revisions.save(revision);
+    });
+  }
+  enqueueConfigurationReport(controllerId, payload) {
+    const queue = this.configurationReportQueues.get(controllerId) ?? { pending: /* @__PURE__ */ new Map(), processing: false };
+    this.configurationReportQueues.set(controllerId, queue);
+    if (queue.processing) {
+      const revision = this.configurationReportRevision(payload);
+      const key = revision ?? Number.NaN;
+      if (queue.pending.has(key) || queue.pending.size < MAX_PENDING_CONFIGURATION_REPORTS)
+        queue.pending.set(key, payload);
+      else this.context.logger.warn(`Dropping excess WAGO configuration report for controller ${controllerId}`);
+      return;
+    }
+    queue.processing = true;
+    void this.processConfigurationReports(controllerId, payload, queue);
+  }
+  async processConfigurationReports(controllerId, payload, queue) {
+    let next = payload;
+    while (next) {
+      try {
+        await this.onConfigurationReported(controllerId, next);
+      } catch (error) {
+        this.context.logger.warn(`Could not process WAGO configuration report: ${String(error)}`);
+      }
+      const pending = queue.pending.entries().next();
+      if (pending.done) next = null;
+      else {
+        const [revision, report] = pending.value;
+        queue.pending.delete(revision);
+        next = report;
+      }
+    }
+    queue.processing = false;
+    if (this.configurationReportQueues.get(controllerId) === queue) this.configurationReportQueues.delete(controllerId);
+  }
+  configurationReportRevision(payload) {
+    try {
+      const report = JSON.parse(payload.toString("utf8"));
+      return Number.isSafeInteger(report.revision) && report.revision >= 1 ? report.revision : null;
+    } catch {
+      return null;
+    }
+  }
+  async publishRevision(controller, revision) {
+    if (!controller.mqttServerId) throw new import_common.ConflictException(`WAGO controller ${controller.id} has no MQTT server`);
+    const incompatibility = compatibilityError({
+      protocolVersion: controller.protocolVersion,
+      capabilities: JSON.parse(controller.capabilities)
+    });
+    if (incompatibility) throw new import_common.ConflictException(`Cannot publish configuration: ${incompatibility}`);
+    const settings = await this.getSettings();
+    await this.context.mqtt.publish(
+      controller.mqttServerId,
+      configurationDesiredTopic(settings.operationalPrefix ?? "attraccess/wago", controller.hardwareId),
+      JSON.stringify({
+        protocolVersion: CONFIGURATION_PROTOCOL_VERSION,
+        revision: revision.revision,
+        contentHash: revision.contentHash,
+        snapshot: JSON.parse(revision.snapshot)
+      }),
+      { qos: 1, retain: true }
+    );
+    revision.state = "published";
+    return this.revisions.save(revision);
+  }
   connectivity(controller) {
     if (controller.trustState === "untrusted") return "untrusted";
     return controller.lastHeartbeatAt && Date.now() - Date.parse(controller.lastHeartbeatAt) <= STALE_AFTER_MS ? "online" : "stale";
@@ -653,6 +1352,43 @@ var WagoService = class {
       if (this.claimLocks.get(id) === lock) this.claimLocks.delete(id);
     }
   }
+  async withClaimConfigurationLock(operation) {
+    const previous = this.claimConfigurationLock;
+    let release;
+    const lock = new Promise((resolve) => {
+      release = resolve;
+    });
+    this.claimConfigurationLock = lock;
+    await previous;
+    try {
+      return await operation();
+    } finally {
+      release();
+      if (this.claimConfigurationLock === lock) this.claimConfigurationLock = Promise.resolve();
+    }
+  }
+  async claimedController(id) {
+    const controller = await this.controllers.findOneBy({ id });
+    if (!controller || controller.trustState !== "claimed")
+      throw new import_common.NotFoundException(`claimed WAGO controller ${id} not found`);
+    if (!controller.mqttServerId) throw new import_common.ConflictException(`WAGO controller ${id} has no MQTT server`);
+    return controller;
+  }
+  async withConfigurationLock(id, operation) {
+    const previous = this.configurationLocks.get(id) ?? Promise.resolve();
+    let release;
+    const lock = new Promise((resolve) => {
+      release = resolve;
+    });
+    this.configurationLocks.set(id, lock);
+    await previous;
+    try {
+      return await operation();
+    } finally {
+      release();
+      if (this.configurationLocks.get(id) === lock) this.configurationLocks.delete(id);
+    }
+  }
   scheduleSubscriptionRetry() {
     if (this.destroyed || this.subscriptionRetryTimer) return;
     this.subscriptionRetryTimer = setTimeout(() => {
@@ -670,10 +1406,10 @@ WagoService = __decorateClass([
   __decorateParam(0, (0, import_common.Inject)(PLUGIN_CONTEXT))
 ], WagoService);
 function hash(value) {
-  return (0, import_node_crypto.createHash)("sha256").update(value).digest("hex");
+  return (0, import_node_crypto2.createHash)("sha256").update(value).digest("hex");
 }
 function safeEqual(left, right) {
-  return left.length === right.length && (0, import_node_crypto.timingSafeEqual)(Buffer.from(left), Buffer.from(right));
+  return left.length === right.length && (0, import_node_crypto2.timingSafeEqual)(Buffer.from(left), Buffer.from(right));
 }
 function isValidHardwareId(hardwareId) {
   return Boolean(hardwareId) && !/[/+#]/.test(hardwareId);
@@ -691,7 +1427,7 @@ var WagoControllerApi = class {
     return this.wago.getSettings();
   }
   setSettings(body) {
-    return this.wago.setDefaultMqttServer(body?.defaultMqttServerId ?? null);
+    return this.wago.setSettings(body?.defaultMqttServerId, body?.operationalPrefix);
   }
   enrollment(body) {
     const manualCredentials = body?.manualUsername || body?.manualPassword ? { username: body.manualUsername ?? "", password: body.manualPassword ?? "" } : void 0;
@@ -700,6 +1436,30 @@ var WagoControllerApi = class {
   claim(id, body) {
     return this.wago.claim(id, body?.name ?? "", body?.verifier ?? "", body?.mqttServerId);
   }
+  draft(id) {
+    return this.wago.getDraft(id);
+  }
+  saveDraft(id, body) {
+    return this.wago.saveDraft(id, body?.snapshot);
+  }
+  validateDraft(id) {
+    return this.wago.validateDraft(id);
+  }
+  reviewDraft(id) {
+    return this.wago.reviewDraft(id);
+  }
+  revisions(id, offset, limit) {
+    return this.wago.revisionsFor(id, Number(offset), Number(limit));
+  }
+  publishDraft(id) {
+    return this.wago.publishDraft(id);
+  }
+  rollback(id, revision) {
+    return this.wago.rollback(id, revision);
+  }
+  previewRevision(id, revision) {
+    return this.wago.previewRevision(id, revision);
+  }
 };
 __decorateClass([
   (0, import_common2.Get)("controllers")
@@ -720,8 +1480,45 @@ __decorateClass([
   __decorateParam(0, (0, import_common2.Param)("id", import_common2.ParseIntPipe)),
   __decorateParam(1, (0, import_common2.Body)())
 ], WagoControllerApi.prototype, "claim", 1);
+__decorateClass([
+  (0, import_common2.Get)("controllers/:id/configuration/draft"),
+  __decorateParam(0, (0, import_common2.Param)("id", import_common2.ParseIntPipe))
+], WagoControllerApi.prototype, "draft", 1);
+__decorateClass([
+  (0, import_common2.Post)("controllers/:id/configuration/draft"),
+  __decorateParam(0, (0, import_common2.Param)("id", import_common2.ParseIntPipe)),
+  __decorateParam(1, (0, import_common2.Body)())
+], WagoControllerApi.prototype, "saveDraft", 1);
+__decorateClass([
+  (0, import_common2.Post)("controllers/:id/configuration/validate"),
+  __decorateParam(0, (0, import_common2.Param)("id", import_common2.ParseIntPipe))
+], WagoControllerApi.prototype, "validateDraft", 1);
+__decorateClass([
+  (0, import_common2.Post)("controllers/:id/configuration/review"),
+  __decorateParam(0, (0, import_common2.Param)("id", import_common2.ParseIntPipe))
+], WagoControllerApi.prototype, "reviewDraft", 1);
+__decorateClass([
+  (0, import_common2.Get)("controllers/:id/configuration/revisions"),
+  __decorateParam(0, (0, import_common2.Param)("id", import_common2.ParseIntPipe)),
+  __decorateParam(1, (0, import_common2.Query)("offset")),
+  __decorateParam(2, (0, import_common2.Query)("limit"))
+], WagoControllerApi.prototype, "revisions", 1);
+__decorateClass([
+  (0, import_common2.Post)("controllers/:id/configuration/publish"),
+  __decorateParam(0, (0, import_common2.Param)("id", import_common2.ParseIntPipe))
+], WagoControllerApi.prototype, "publishDraft", 1);
+__decorateClass([
+  (0, import_common2.Post)("controllers/:id/configuration/rollback/:revision"),
+  __decorateParam(0, (0, import_common2.Param)("id", import_common2.ParseIntPipe)),
+  __decorateParam(1, (0, import_common2.Param)("revision", import_common2.ParseIntPipe))
+], WagoControllerApi.prototype, "rollback", 1);
+__decorateClass([
+  (0, import_common2.Get)("controllers/:id/configuration/revisions/:revision/preview"),
+  __decorateParam(0, (0, import_common2.Param)("id", import_common2.ParseIntPipe)),
+  __decorateParam(1, (0, import_common2.Param)("revision", import_common2.ParseIntPipe))
+], WagoControllerApi.prototype, "previewRevision", 1);
 WagoControllerApi = __decorateClass([
-  (0, import_plugins_backend_sdk4.Auth)("resources.update"),
+  (0, import_plugins_backend_sdk6.Auth)("resources.update"),
   (0, import_common2.Controller)("wago"),
   __decorateParam(0, (0, import_common2.Inject)(WagoService))
 ], WagoControllerApi);
@@ -731,7 +1528,7 @@ var PLUGIN_CONTEXT2 = /* @__PURE__ */ Symbol.for("attraccess.plugin.context");
 var WagoPluginModule = class {
 };
 var plugin = {
-  entities: [WagoController, WagoSettings, WagoEnrollment],
+  entities: [WagoController, WagoSettings, WagoEnrollment, WagoConfigurationDraft, WagoConfigurationRevision],
   register(context) {
     return {
       module: WagoPluginModule,

package/dist/migrations.js

@@ -21,6 +21,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 // backend/migrations.ts
 var migrations_exports = {};
 __export(migrations_exports, {
+  AddWagoConfigurationRevisions1780000000002: () => AddWagoConfigurationRevisions1780000000002,
   AddWagoEnrollmentRevocation1780000000001: () => AddWagoEnrollmentRevocation1780000000001,
   CreateWagoControllers1780000000000: () => CreateWagoControllers1780000000000
 });
@@ -71,8 +72,35 @@ var AddWagoEnrollmentRevocation1780000000001 = class {
     await queryRunner.query('ALTER TABLE "plugin_wago_enrollments" DROP COLUMN "revoked_at"');
   }
 };
+
+// backend/migrations/1780000000002-add-wago-configuration-revisions.ts
+var AddWagoConfigurationRevisions1780000000002 = class {
+  constructor() {
+    __publicField(this, "name", "AddWagoConfigurationRevisions1780000000002");
+  }
+  async up(queryRunner) {
+    await queryRunner.query(`ALTER TABLE "plugin_wago_settings" ADD COLUMN "operational_prefix" varchar NOT NULL DEFAULT ('attraccess/wago')`);
+    await queryRunner.query(`CREATE TABLE "plugin_wago_configuration_drafts" (
+      "id" integer PRIMARY KEY AUTOINCREMENT NOT NULL, "controller_id" integer NOT NULL,
+      "snapshot" text NOT NULL, "reviewed_hash" varchar, "updated_at" varchar NOT NULL,
+      CONSTRAINT "UQ_plugin_wago_configuration_drafts_controller_id" UNIQUE ("controller_id"))`);
+    await queryRunner.query(`CREATE TABLE "plugin_wago_configuration_revisions" (
+      "id" integer PRIMARY KEY AUTOINCREMENT NOT NULL, "controller_id" integer NOT NULL,
+      "revision" integer NOT NULL, "snapshot" text NOT NULL, "content_hash" varchar NOT NULL,
+      "state" varchar NOT NULL, "rejection_errors" text, "published_at" varchar NOT NULL, "reported_at" varchar,
+      CONSTRAINT "UQ_plugin_wago_configuration_revisions_controller_revision" UNIQUE ("controller_id", "revision"))`);
+    await queryRunner.query('CREATE INDEX "IDX_plugin_wago_configuration_revisions_controller" ON "plugin_wago_configuration_revisions" ("controller_id", "revision")');
+  }
+  async down(queryRunner) {
+    await queryRunner.query('DROP INDEX "IDX_plugin_wago_configuration_revisions_controller"');
+    await queryRunner.query('DROP TABLE "plugin_wago_configuration_revisions"');
+    await queryRunner.query('DROP TABLE "plugin_wago_configuration_drafts"');
+    await queryRunner.query('ALTER TABLE "plugin_wago_settings" DROP COLUMN "operational_prefix"');
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AddWagoConfigurationRevisions1780000000002,
   AddWagoEnrollmentRevocation1780000000001,
   CreateWagoControllers1780000000000
 });

package/package.json

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