daikin-local-control 0.3.1 → 0.4.0

package/src/codecs/classic/state.ts

@@ -13,18 +13,22 @@ import {
   type VerticalPosition,
 } from "../../models/state.js";
 import { takesClassicDirection, takesClassicHumidity } from "./capabilities.js";
+import {
+  CLASSIC_FAN_SPEED_CODES,
+  CLASSIC_HORIZONTAL_POSITION_CODES,
+  CLASSIC_HUMIDITY_SETTING_CODES,
+  CLASSIC_LOUVER_STOP,
+  CLASSIC_LOUVER_SWING,
+  CLASSIC_NO_SETPOINT,
+  CLASSIC_OPERATING_MODE_CODES,
+  CLASSIC_SPECIAL_MODE_ADV_CODES,
+  CLASSIC_SWING_MODE_CODES,
+  CLASSIC_VERTICAL_POSITION_CODES,
+} from "./tables.js";
 
 // Maps between `DaikinState` and the classic `control_info` wire fields, and reads
 // `DaikinSensors` from `get_sensor_info`.
 
-const OPERATING_MODE_CODES: Record<OperatingMode, string> = {
-  auto: "1",
-  dehumidify: "2",
-  cool: "3",
-  heat: "4",
-  fan: "6",
-};
-
 const OPERATING_MODES_BY_CODE: Record<string, OperatingMode> = {
   "0": "auto",
   "1": "auto",
@@ -35,67 +39,23 @@ const OPERATING_MODES_BY_CODE: Record<string, OperatingMode> = {
   "6": "fan",
 };
 
-const FAN_SPEED_CODES: Record<FanSpeed, string> = {
-  auto: "A",
-  silent: "B",
-  level1: "3",
-  level2: "4",
-  level3: "5",
-  level4: "6",
-  level5: "7",
-};
-
 const FAN_SPEEDS_BY_CODE: Record<string, FanSpeed> = Object.fromEntries(
-  Object.entries(FAN_SPEED_CODES).map(([speed, code]) => [
+  Object.entries(CLASSIC_FAN_SPEED_CODES).map(([speed, code]) => [
     code,
     speed as FanSpeed,
   ]),
 );
 
-const SWING_MODE_CODES: Record<SwingMode, string> = {
-  off: "0",
-  vertical: "1",
-  horizontal: "2",
-  both: "3",
-};
-
 const SWING_MODES_BY_CODE: Record<string, SwingMode> = Object.fromEntries(
-  Object.entries(SWING_MODE_CODES).map(([swing, code]) => [
+  Object.entries(CLASSIC_SWING_MODE_CODES).map(([swing, code]) => [
     code,
     swing as SwingMode,
   ]),
 );
 
-// `f_dir_ud` and `f_dir_lr` carry a digit for stop and each fixed position, and
-// a letter for the rest.
-const LOUVER_STOP = "0";
-const LOUVER_SWING = "S";
-const VERTICAL_POSITION_CODES: Record<VerticalPosition, string> = {
-  stop: LOUVER_STOP,
-  position1: "1",
-  position2: "2",
-  position3: "3",
-  position4: "4",
-  position5: "5",
-  swing: LOUVER_SWING,
-  naturalWind: "N",
-  auto: "A",
-  floorWarming: "F",
-};
-const HORIZONTAL_POSITION_CODES: Record<HorizontalPosition, string> = {
-  stop: LOUVER_STOP,
-  position1: "1",
-  position2: "2",
-  position3: "3",
-  position4: "4",
-  position5: "5",
-  swing: LOUVER_SWING,
-  auto: "A",
-};
-
 const VERTICAL_POSITIONS_BY_CODE: Record<string, VerticalPosition> =
   Object.fromEntries(
-    Object.entries(VERTICAL_POSITION_CODES).map(([position, code]) => [
+    Object.entries(CLASSIC_VERTICAL_POSITION_CODES).map(([position, code]) => [
       code,
       position as VerticalPosition,
     ]),
@@ -103,38 +63,21 @@ const VERTICAL_POSITIONS_BY_CODE: Record<string, VerticalPosition> =
 
 const HORIZONTAL_POSITIONS_BY_CODE: Record<string, HorizontalPosition> =
   Object.fromEntries(
-    Object.entries(HORIZONTAL_POSITION_CODES).map(([position, code]) => [
-      code,
-      position as HorizontalPosition,
-    ]),
+    Object.entries(CLASSIC_HORIZONTAL_POSITION_CODES).map(
+      ([position, code]) => [code, position as HorizontalPosition],
+    ),
   );
 
-const HUMIDITY_SETTING_CODES: Record<HumiditySetting, string> = {
-  off: "0",
-  autoLow: "AUTO_L",
-  auto: "AUTO",
-  autoHigh: "AUTO_H",
-  continuous: "CONTINUE",
-};
-
 const HUMIDITY_SETTINGS_BY_CODE: Record<string, HumiditySetting> =
   Object.fromEntries(
-    Object.entries(HUMIDITY_SETTING_CODES).map(([setting, code]) => [
+    Object.entries(CLASSIC_HUMIDITY_SETTING_CODES).map(([setting, code]) => [
       code,
       setting as HumiditySetting,
     ]),
   );
 
-// `adv` holds one code for each special mode that is on, separated by `/`.
-const SPECIAL_MODE_ADV_CODES: Record<SpecialMode, string> = {
-  powerful: "2",
-  econo: "12",
-  streamer: "13",
-};
-
-// Fan mode keeps no setpoint memory, and dehumidify runs the fan on auto only.
-const NO_SETPOINT = "--";
-const DEHUMIDIFY_FAN_SPEED = "A";
+// Dehumidify runs the fan on auto only.
+const DEHUMIDIFY_FAN_SPEED = CLASSIC_FAN_SPEED_CODES.auto;
 // In `ndfd<mode>`, a louver the unit lacks.
 const NO_LOUVER = "-";
 
@@ -188,11 +131,11 @@ export function applyClassicControl(
   const currentMode =
     heldMode === undefined
       ? (current.mode ?? "")
-      : OPERATING_MODE_CODES[heldMode];
+      : CLASSIC_OPERATING_MODE_CODES[heldMode];
   const mode =
     control.mode === undefined
       ? currentMode
-      : OPERATING_MODE_CODES[control.mode];
+      : CLASSIC_OPERATING_MODE_CODES[control.mode];
   const modeChanged = mode !== currentMode;
   const remembered = (field: string, memoryPrefix: string) =>
     (modeChanged ? current[`${memoryPrefix}${mode}`] : undefined) ??
@@ -202,14 +145,14 @@ export function applyClassicControl(
   const power = control.power ?? current.pow === "1";
   const next: Record<string, string> = { pow: power ? "1" : "0", mode };
 
-  const setpointFrozen = mode === OPERATING_MODE_CODES.fan;
+  const setpointFrozen = mode === CLASSIC_OPERATING_MODE_CODES.fan;
   // Only a mode in the model has a `dt` and a `dh` memory.
   const hasMemory =
     !setpointFrozen && (control.mode !== undefined || heldMode !== undefined);
   next.stemp = setpointFrozen
-    ? NO_SETPOINT
+    ? CLASSIC_NO_SETPOINT
     : control.targetTemperatureInC != null &&
-        mode !== OPERATING_MODE_CODES.dehumidify
+        mode !== CLASSIC_OPERATING_MODE_CODES.dehumidify
       ? control.targetTemperatureInC.toFixed(1)
       : remembered("stemp", "dt");
   if (hasMemory) {
@@ -217,7 +160,7 @@ export function applyClassicControl(
   }
   if (takesClassicHumidity(capabilityFields)) {
     next.shum = setpointFrozen
-      ? NO_SETPOINT
+      ? CLASSIC_NO_SETPOINT
       : control.targetHumidity != null
         ? encodeTargetHumidity(control.targetHumidity)
         : remembered("shum", "dh");
@@ -227,55 +170,60 @@ export function applyClassicControl(
   }
 
   next.f_rate =
-    mode === OPERATING_MODE_CODES.dehumidify
+    mode === CLASSIC_OPERATING_MODE_CODES.dehumidify
       ? DEHUMIDIFY_FAN_SPEED
       : control.fanSpeed === undefined
         ? remembered("f_rate", "dfr")
-        : FAN_SPEED_CODES[control.fanSpeed];
+        : CLASSIC_FAN_SPEED_CODES[control.fanSpeed];
 
   if (capabilityFields.en_fdir2 === "1") {
     // `ndfd<mode>` holds the mode's `f_dir_ud` value, then its `f_dir_lr`
     // value. A value outside the model is sent back as it came.
     const louverMemory = modeChanged ? current[`ndfd${mode}`] : undefined;
     let vertical =
-      rememberedLouver(louverMemory, 0) || current.f_dir_ud || LOUVER_STOP;
+      rememberedLouver(louverMemory, 0) ||
+      current.f_dir_ud ||
+      CLASSIC_LOUVER_STOP;
     let horizontal =
-      rememberedLouver(louverMemory, 1) || current.f_dir_lr || LOUVER_STOP;
+      rememberedLouver(louverMemory, 1) ||
+      current.f_dir_lr ||
+      CLASSIC_LOUVER_STOP;
     if (control.swingMode !== undefined) {
       const swingsVertically =
         control.swingMode === "vertical" || control.swingMode === "both";
       const swingsHorizontally =
         control.swingMode === "horizontal" || control.swingMode === "both";
       vertical = swingsVertically
-        ? LOUVER_SWING
-        : vertical === LOUVER_SWING
-          ? LOUVER_STOP
+        ? CLASSIC_LOUVER_SWING
+        : vertical === CLASSIC_LOUVER_SWING
+          ? CLASSIC_LOUVER_STOP
           : vertical;
       horizontal = swingsHorizontally
-        ? LOUVER_SWING
-        : horizontal === LOUVER_SWING
-          ? LOUVER_STOP
+        ? CLASSIC_LOUVER_SWING
+        : horizontal === CLASSIC_LOUVER_SWING
+          ? CLASSIC_LOUVER_STOP
           : horizontal;
     }
     if (control.verticalPosition != null) {
-      vertical = VERTICAL_POSITION_CODES[control.verticalPosition];
+      vertical = CLASSIC_VERTICAL_POSITION_CODES[control.verticalPosition];
     }
     if (control.horizontalPosition != null) {
-      horizontal = HORIZONTAL_POSITION_CODES[control.horizontalPosition];
+      horizontal =
+        CLASSIC_HORIZONTAL_POSITION_CODES[control.horizontalPosition];
     }
     next.f_dir_ud = vertical;
     next.f_dir_lr = horizontal;
     if (takesDirection) {
       next.f_dir = String(
-        (vertical === LOUVER_SWING ? 1 : 0) |
-          (horizontal === LOUVER_SWING ? 2 : 0),
+        (vertical === CLASSIC_LOUVER_SWING ? 1 : 0) |
+          (horizontal === CLASSIC_LOUVER_SWING ? 2 : 0),
       );
     }
   } else if (takesDirection) {
     next.f_dir =
       control.swingMode === undefined
         ? remembered("f_dir", "dfd")
-        : SWING_MODE_CODES[control.swingMode];
+        : CLASSIC_SWING_MODE_CODES[control.swingMode];
   }
   return next;
 }
@@ -283,7 +231,7 @@ export function applyClassicControl(
 function parseSpecialModes(adv: string | undefined): SpecialMode[] {
   const codes = (adv ?? "").split("/");
   return SPECIAL_MODES.filter((mode) =>
-    codes.includes(SPECIAL_MODE_ADV_CODES[mode]),
+    codes.includes(CLASSIC_SPECIAL_MODE_ADV_CODES[mode]),
   );
 }
 
@@ -298,7 +246,7 @@ function parseTargetHumidity(shum: string | undefined): TargetHumidity | null {
 
 function encodeTargetHumidity(targetHumidity: TargetHumidity): string {
   return typeof targetHumidity === "string"
-    ? HUMIDITY_SETTING_CODES[targetHumidity]
+    ? CLASSIC_HUMIDITY_SETTING_CODES[targetHumidity]
     : String(targetHumidity.percent);
 }
 

package/src/codecs/classic/tables.ts

@@ -0,0 +1,123 @@
+import type { TerminalScope } from "../../models/extendedControl.js";
+import type {
+  FanSpeed,
+  HorizontalPosition,
+  HumiditySetting,
+  OperatingMode,
+  SpecialMode,
+  SwingMode,
+  VerticalPosition,
+} from "../../models/state.js";
+
+// The codes a classic adapter holds each value of a model as. The codecs and
+// the simulators both read them from here: see DESIGN.md#simulators.
+
+export const CLASSIC_OPERATING_MODE_CODES: Record<OperatingMode, string> = {
+  auto: "1",
+  dehumidify: "2",
+  cool: "3",
+  heat: "4",
+  fan: "6",
+};
+
+export const CLASSIC_FAN_SPEED_CODES: Record<FanSpeed, string> = {
+  auto: "A",
+  silent: "B",
+  level1: "3",
+  level2: "4",
+  level3: "5",
+  level4: "6",
+  level5: "7",
+};
+
+export const CLASSIC_SWING_MODE_CODES: Record<SwingMode, string> = {
+  off: "0",
+  vertical: "1",
+  horizontal: "2",
+  both: "3",
+};
+
+// `f_dir_ud` and `f_dir_lr` carry a digit for stop and each fixed position, and
+// a letter for the rest.
+export const CLASSIC_LOUVER_STOP = "0";
+export const CLASSIC_LOUVER_SWING = "S";
+export const CLASSIC_VERTICAL_POSITION_CODES: Record<VerticalPosition, string> =
+  {
+    stop: CLASSIC_LOUVER_STOP,
+    position1: "1",
+    position2: "2",
+    position3: "3",
+    position4: "4",
+    position5: "5",
+    swing: CLASSIC_LOUVER_SWING,
+    naturalWind: "N",
+    auto: "A",
+    floorWarming: "F",
+  };
+export const CLASSIC_HORIZONTAL_POSITION_CODES: Record<
+  HorizontalPosition,
+  string
+> = {
+  stop: CLASSIC_LOUVER_STOP,
+  position1: "1",
+  position2: "2",
+  position3: "3",
+  position4: "4",
+  position5: "5",
+  swing: CLASSIC_LOUVER_SWING,
+  auto: "A",
+};
+
+export const CLASSIC_HUMIDITY_SETTING_CODES: Record<HumiditySetting, string> = {
+  off: "0",
+  autoLow: "AUTO_L",
+  auto: "AUTO",
+  autoHigh: "AUTO_H",
+  continuous: "CONTINUE",
+};
+
+/** What `stemp` and `shum` hold in a mode that has neither, such as fan. */
+export const CLASSIC_NO_SETPOINT = "--";
+
+/** `adv` holds one code for each special mode that is on, separated by
+ * `/`. */
+export const CLASSIC_SPECIAL_MODE_ADV_CODES: Record<SpecialMode, string> = {
+  powerful: "2",
+  econo: "12",
+  streamer: "13",
+};
+
+/** `spmode_kind` in `set_special_mode`, which numbers the modes differently
+ * from `adv`. The streamer has a parameter of its own, `en_streamer`. */
+export const CLASSIC_SPECIAL_MODE_KIND_CODES: Record<
+  Exclude<SpecialMode, "streamer">,
+  string
+> = {
+  powerful: "1",
+  econo: "2",
+};
+
+/** `en_spmode` sets one bit for each special mode the unit takes. Bit 8 is a
+ * mode outside `SpecialMode`. */
+export const CLASSIC_SPECIAL_MODE_BITS: Record<SpecialMode, number> = {
+  powerful: 1,
+  econo: 2,
+  streamer: 4,
+};
+
+/** `type` in `get_model_info` on a unit that only cools. */
+export const CLASSIC_COOLING_ONLY_TYPE = "C";
+
+/** `type` in `unregister_terminal`. */
+export const CLASSIC_TERMINAL_SCOPE_CODES: Record<TerminalScope, string> = {
+  self: "0",
+  others: "1",
+  all: "2",
+};
+
+/** `method`: the adapter is reached from outside the home network while it
+ * polls, and from inside only otherwise. */
+export const CLASSIC_REMOTE_METHODS = {
+  polling: "polling",
+  homeOnly: "home only",
+} as const;

package/src/codecs/credentials.ts

@@ -1,7 +1,15 @@
-/** The header that carries the terminal uuid on every call. The adapter takes
- * the uuid without its dashes. */
+const TERMINAL_UUID_PATTERN = /^[0-9a-f]{32}$/;
+
+/** The header that carries the terminal uuid on every call. It throws an
+ * `Error` unless the uuid is 32 lowercase hexadecimal digits, a UUID without
+ * its dashes: whether the adapter accepts any other form is not known. */
 export function encodeTerminalUuid(uuid: string): Record<string, string> {
-  return { "X-Daikin-uuid": uuid.replaceAll("-", "") };
+  if (!TERMINAL_UUID_PATTERN.test(uuid)) {
+    throw new Error(
+      "The terminal uuid must be 32 lowercase hexadecimal digits, without dashes",
+    );
+  }
+  return { "X-Daikin-uuid": uuid };
 }
 
 /** The query parameter a classic adapter takes the local password as. */

package/src/codecs/device.ts

@@ -1,7 +1,7 @@
 import type { DaikinDevice, DaikinDeviceInfo } from "../models/device.js";
 import { decodeClassicText } from "./classic/keyValue.js";
+import { DSIOT_ADAPTER_TYPE } from "./dsiot/tables.js";
 
-const DSIOT_TYPE = "GPF";
 const MARVELL_ADP_KIND = "3";
 
 /** Turns a `basic_info` reply into a `DaikinDevice`: `type=GPF` marks a DSIOT
@@ -11,7 +11,7 @@ export function parseDevice(
   host: string,
   basicInfo: Record<string, string>,
 ): DaikinDevice {
-  const protocol = basicInfo.type === DSIOT_TYPE ? "dsiot" : "classic";
+  const protocol = basicInfo.type === DSIOT_ADAPTER_TYPE ? "dsiot" : "classic";
   const secure = basicInfo.en_secure === "1";
   return {
     host: basicInfo.api_port ? `${host}:${basicInfo.api_port}` : host,

package/src/codecs/dsiot/capabilities.ts

@@ -17,30 +17,23 @@ import {
   VERTICAL_POSITIONS,
   type VerticalPosition,
 } from "../../models/state.js";
+import { decodeDsiotLittleEndian } from "./state.js";
 import {
+  DSIOT_ADAPTER_PATHS,
+  DSIOT_COOLING_ONLY_MODEL_TYPE,
   DSIOT_HORIZONTAL_POSITION_VALUES,
   DSIOT_MODE_PATHS,
   DSIOT_PATHS,
   DSIOT_SPECIAL_MODE_PATHS,
   DSIOT_VERTICAL_POSITION_VALUES,
   type DsiotSetpoint,
-  decodeDsiotLittleEndian,
-} from "./state.js";
+} from "./tables.js";
 
 const MODE_PATHS = Object.values(DSIOT_MODE_PATHS);
 
-const ADAPTER_PATHS = {
-  region: "adp_i.reg",
-  kind: "adp_i.kind",
-  energyMonitoring: "adp_i.func.en_ipower",
-  demandControl: "adp_i.func.en_demand",
-  scheduleTimer: "adp_i.func.en_scdltmr",
-} as const;
-
 // The `pt` of a special mode's leaf on a unit that takes the mode.
 const SPECIAL_MODE_OFFERED_TYPE = "2";
 
-const COOLING_ONLY_MODEL_TYPE = "01";
 const COOLING_ONLY_MODES: readonly OperatingMode[] = [
   "dehumidify",
   "cool",
@@ -61,7 +54,7 @@ export function parseDsiotCapabilities(
   values: Record<string, string>,
 ): DaikinCapabilities {
   const modes =
-    values[DSIOT_PATHS.modelType] === COOLING_ONLY_MODEL_TYPE
+    values[DSIOT_PATHS.modelType] === DSIOT_COOLING_ONLY_MODEL_TYPE
       ? [...COOLING_ONLY_MODES]
       : [...OPERATING_MODES];
   const offered = (mode: OperatingMode, range: TemperatureRange) =>
@@ -87,7 +80,7 @@ export function parseDsiotCapabilities(
   const vertical = hasLouver(values, "vertical");
   const horizontal = hasLouver(values, "horizontal");
   const energyMonitoring =
-    values[ADAPTER_PATHS.energyMonitoring] === "1" &&
+    values[DSIOT_ADAPTER_PATHS.energyMonitoring] === "1" &&
     values[DSIOT_PATHS.energyMonitoring] === "01";
 
   return {
@@ -136,10 +129,10 @@ export function parseDsiotCapabilities(
     energyMonitoring,
     demandControl:
       energyMonitoring &&
-      values[ADAPTER_PATHS.kind] === "4" &&
-      values[ADAPTER_PATHS.demandControl] === "1",
+      values[DSIOT_ADAPTER_PATHS.kind] === "4" &&
+      values[DSIOT_ADAPTER_PATHS.demandControl] === "1",
     scheduleTimer: ["1", "2"].includes(
-      values[ADAPTER_PATHS.scheduleTimer] ?? "",
+      values[DSIOT_ADAPTER_PATHS.scheduleTimer] ?? "",
     ),
     model: values[DSIOT_PATHS.model],
   };
@@ -164,7 +157,7 @@ function takes(mask: number, value: number | undefined): boolean {
 
 // Japanese units (`jp`) follow other rules: see UNSUPPORTED.md.
 function fanSpeeds(values: Record<string, string>): FanSpeed[] {
-  const region = values[ADAPTER_PATHS.region];
+  const region = values[DSIOT_ADAPTER_PATHS.region];
   if (!region || region === "jp") {
     return [];
   }

package/src/codecs/dsiot/device.ts

@@ -1,11 +1,6 @@
 import type { DaikinDeviceInfo } from "../../models/device.js";
 import { decodeFirmwareVersion, decodeMacAddress } from "../device.js";
-
-const ADAPTER_PATHS = {
-  name: "adp_d.name",
-  macAddress: "adp_i.mac",
-  firmwareVersion: "adp_i.ver",
-} as const;
+import { DSIOT_ADAPTER_PATHS } from "./tables.js";
 
 /** Reads what the flattened `adp_i` and `adp_d` trees say to identify the
  * adapter. Both `adp_i` leaves hold the value a classic adapter sends in
@@ -15,10 +10,10 @@ export function parseDsiotDeviceInfo(
   values: Record<string, string>,
 ): DaikinDeviceInfo {
   return {
-    name: values[ADAPTER_PATHS.name],
-    macAddress: decodeMacAddress(values[ADAPTER_PATHS.macAddress]),
+    name: values[DSIOT_ADAPTER_PATHS.name],
+    macAddress: decodeMacAddress(values[DSIOT_ADAPTER_PATHS.macAddress]),
     firmwareVersion: decodeFirmwareVersion(
-      values[ADAPTER_PATHS.firmwareVersion],
+      values[DSIOT_ADAPTER_PATHS.firmwareVersion],
     ),
   };
 }

package/src/codecs/dsiot/multireq.ts

@@ -1,34 +1,11 @@
 import { DaikinError } from "../../error.js";
+import { DSIOT_EDGE_ROOT, DSIOT_EDGES, DSIOT_OPERATIONS } from "./tables.js";
 
 // The DSIOT (BRP084, `type=GPF`) protocol speaks one endpoint, `/dsiot/multireq`,
 // carrying operations on property trees. A request addresses a resource (`to`);
 // a tree node has pn (name) / pt (type) / pch (children) / pv (value) / md
 // (metadata: mi min, mx max, st step).
 
-export const DSIOT_OPERATIONS = {
-  get: 2,
-  update: 3,
-  delete: 4,
-} as const;
-
-/** The indoor and the outdoor unit are separate edges on the adapter. */
-export const DSIOT_EDGES = {
-  indoor: "adr_0100",
-  outdoor: "adr_0200",
-} as const;
-
-const EDGE_ROOT = "/dsiot/edge";
-
-/** What a read fetches, as the `to` of a request: whole trees, never single
- * leaves. The status trees come with `pt`, which `parseDsiotCapabilities`
- * reads. */
-export const DSIOT_TARGETS = {
-  adapterInfo: `${EDGE_ROOT}.adp_i?filter=pv`,
-  adapterSettings: `${EDGE_ROOT}.adp_d?filter=pv`,
-  indoorStatus: `${EDGE_ROOT}/${DSIOT_EDGES.indoor}.dgc_status?filter=pv,pt,md`,
-  outdoorStatus: `${EDGE_ROOT}/${DSIOT_EDGES.outdoor}.dgc_status?filter=pv,pt,md`,
-} as const;
-
 interface PropertyNode {
   pn: string;
   pt?: number;
@@ -78,7 +55,7 @@ export function buildDsiotMultireqUpdate(
   return {
     requests: roots.map((pc) => ({
       op: DSIOT_OPERATIONS.update,
-      to: `${EDGE_ROOT}/${edge}.${pc.pn}`,
+      to: `${DSIOT_EDGE_ROOT}/${edge}.${pc.pn}`,
       pc,
     })),
   };