@apocaliss92/nodedreame 1.1.0 → 1.3.0

package/dist/index.js

@@ -1,5 +1,6 @@
 // src/support/version.ts
 var LIBRARY_NAME = "nodedreame";
+var LIBRARY_VERSION = "1.3.0";
 
 // src/transport/errors.ts
 var DreameError = class extends Error {
@@ -1226,11 +1227,27 @@ var MiotState = /* @__PURE__ */ ((MiotState2) => {
   MiotState2[MiotState2["ReturnToEmpty"] = 28] = "ReturnToEmpty";
   MiotState2[MiotState2["WaitingForTask"] = 29] = "WaitingForTask";
   MiotState2[MiotState2["CleanWashboardBase"] = 30] = "CleanWashboardBase";
+  MiotState2[MiotState2["ReturningToDrain"] = 31] = "ReturningToDrain";
+  MiotState2[MiotState2["Draining"] = 32] = "Draining";
   MiotState2[MiotState2["AutoWaterDraining"] = 33] = "AutoWaterDraining";
+  MiotState2[MiotState2["Emptying"] = 34] = "Emptying";
+  MiotState2[MiotState2["DustBagDrying"] = 35] = "DustBagDrying";
+  MiotState2[MiotState2["DustBagDryingPaused"] = 36] = "DustBagDryingPaused";
+  MiotState2[MiotState2["HeadingToExtraCleaning"] = 37] = "HeadingToExtraCleaning";
+  MiotState2[MiotState2["ExtraCleaning"] = 38] = "ExtraCleaning";
+  MiotState2[MiotState2["FindingPetPaused"] = 95] = "FindingPetPaused";
+  MiotState2[MiotState2["FindingPet"] = 96] = "FindingPet";
   MiotState2[MiotState2["ShortcutRunning"] = 97] = "ShortcutRunning";
   MiotState2[MiotState2["CameraMonitoring"] = 98] = "CameraMonitoring";
   MiotState2[MiotState2["CameraMonitoringPaused"] = 99] = "CameraMonitoringPaused";
   MiotState2[MiotState2["InitialDeepClean"] = 101] = "InitialDeepClean";
+  MiotState2[MiotState2["InitialDeepCleanPaused"] = 102] = "InitialDeepCleanPaused";
+  MiotState2[MiotState2["Sanitizing"] = 103] = "Sanitizing";
+  MiotState2[MiotState2["SanitizingWithDry"] = 104] = "SanitizingWithDry";
+  MiotState2[MiotState2["ChangingMop"] = 105] = "ChangingMop";
+  MiotState2[MiotState2["ChangingMopPaused"] = 106] = "ChangingMopPaused";
+  MiotState2[MiotState2["FloorMaintaining"] = 107] = "FloorMaintaining";
+  MiotState2[MiotState2["FloorMaintainingPaused"] = 108] = "FloorMaintainingPaused";
   return MiotState2;
 })(MiotState || {});
 var ChargingStatus = /* @__PURE__ */ ((ChargingStatus2) => {
@@ -1262,21 +1279,87 @@ var CleaningMode = /* @__PURE__ */ ((CleaningMode2) => {
 var MiotError = /* @__PURE__ */ ((MiotError2) => {
   MiotError2[MiotError2["Clear"] = 0] = "Clear";
   MiotError2[MiotError2["WheelRotationAnomaly"] = 1] = "WheelRotationAnomaly";
+  MiotError2[MiotError2["Cliff"] = 2] = "Cliff";
+  MiotError2[MiotError2["Bumper"] = 3] = "Bumper";
+  MiotError2[MiotError2["Gesture"] = 4] = "Gesture";
+  MiotError2[MiotError2["BumperRepeat"] = 5] = "BumperRepeat";
+  MiotError2[MiotError2["DropRepeat"] = 6] = "DropRepeat";
+  MiotError2[MiotError2["OpticalFlow"] = 7] = "OpticalFlow";
+  MiotError2[MiotError2["Box"] = 8] = "Box";
+  MiotError2[MiotError2["TankBox"] = 9] = "TankBox";
+  MiotError2[MiotError2["WaterBoxEmpty"] = 10] = "WaterBoxEmpty";
+  MiotError2[MiotError2["BoxFull"] = 11] = "BoxFull";
+  MiotError2[MiotError2["Brush"] = 12] = "Brush";
+  MiotError2[MiotError2["SideBrush"] = 13] = "SideBrush";
+  MiotError2[MiotError2["Fan"] = 14] = "Fan";
+  MiotError2[MiotError2["LeftWheelMotor"] = 15] = "LeftWheelMotor";
+  MiotError2[MiotError2["RightWheelMotor"] = 16] = "RightWheelMotor";
+  MiotError2[MiotError2["TurnSuffocate"] = 17] = "TurnSuffocate";
   MiotError2[MiotError2["RobotLifted"] = 18] = "RobotLifted";
-  MiotError2[MiotError2["TaskComplete"] = 68] = "TaskComplete";
-  MiotError2[MiotError2["ManualMopInstallRequired"] = 74] = "ManualMopInstallRequired";
-  MiotError2[MiotError2["WastewaterTankFull"] = 105] = "WastewaterTankFull";
-  MiotError2[MiotError2["CleanWaterTankEmpty"] = 107] = "CleanWaterTankEmpty";
-  MiotError2[MiotError2["WashboardFilterNeedsCleaning"] = 114] = "WashboardFilterNeedsCleaning";
-  MiotError2[MiotError2["MopPadsMissing"] = 120] = "MopPadsMissing";
+  MiotError2[MiotError2["ChargerGet"] = 19] = "ChargerGet";
   MiotError2[MiotError2["BatteryLow"] = 20] = "BatteryLow";
   MiotError2[MiotError2["ChargeFault"] = 21] = "ChargeFault";
   MiotError2[MiotError2["BatteryPercentageAnomaly"] = 22] = "BatteryPercentageAnomaly";
+  MiotError2[MiotError2["Heart"] = 23] = "Heart";
+  MiotError2[MiotError2["CameraOcclusion"] = 24] = "CameraOcclusion";
+  MiotError2[MiotError2["Move"] = 25] = "Move";
+  MiotError2[MiotError2["FlowShielding"] = 26] = "FlowShielding";
+  MiotError2[MiotError2["InfraredShielding"] = 27] = "InfraredShielding";
   MiotError2[MiotError2["ChargeNoElectric"] = 28] = "ChargeNoElectric";
   MiotError2[MiotError2["BatteryFault"] = 29] = "BatteryFault";
+  MiotError2[MiotError2["FanSpeedError"] = 30] = "FanSpeedError";
+  MiotError2[MiotError2["LeftWheelSpeed"] = 31] = "LeftWheelSpeed";
+  MiotError2[MiotError2["RightWheelSpeed"] = 32] = "RightWheelSpeed";
+  MiotError2[MiotError2["Bmi055Acce"] = 33] = "Bmi055Acce";
+  MiotError2[MiotError2["Bmi055Gyro"] = 34] = "Bmi055Gyro";
+  MiotError2[MiotError2["Xv7001"] = 35] = "Xv7001";
+  MiotError2[MiotError2["LeftMagnet"] = 36] = "LeftMagnet";
+  MiotError2[MiotError2["RightMagnet"] = 37] = "RightMagnet";
+  MiotError2[MiotError2["FlowError"] = 38] = "FlowError";
+  MiotError2[MiotError2["InfraredFault"] = 39] = "InfraredFault";
+  MiotError2[MiotError2["CameraFault"] = 40] = "CameraFault";
+  MiotError2[MiotError2["StrongMagnet"] = 41] = "StrongMagnet";
+  MiotError2[MiotError2["WaterPump"] = 42] = "WaterPump";
+  MiotError2[MiotError2["Rtc"] = 43] = "Rtc";
+  MiotError2[MiotError2["AutoKeyTrig"] = 44] = "AutoKeyTrig";
+  MiotError2[MiotError2["P3v3"] = 45] = "P3v3";
+  MiotError2[MiotError2["CameraIdle"] = 46] = "CameraIdle";
+  MiotError2[MiotError2["Blocked"] = 47] = "Blocked";
+  MiotError2[MiotError2["LdsError"] = 48] = "LdsError";
+  MiotError2[MiotError2["LdsBumper"] = 49] = "LdsBumper";
+  MiotError2[MiotError2["WaterPump2"] = 50] = "WaterPump2";
+  MiotError2[MiotError2["FilterBlocked"] = 51] = "FilterBlocked";
+  MiotError2[MiotError2["Edge"] = 54] = "Edge";
+  MiotError2[MiotError2["Carpet"] = 55] = "Carpet";
+  MiotError2[MiotError2["Laser"] = 56] = "Laser";
+  MiotError2[MiotError2["Edge2"] = 57] = "Edge2";
+  MiotError2[MiotError2["Ultrasonic"] = 58] = "Ultrasonic";
+  MiotError2[MiotError2["NoGoZone"] = 59] = "NoGoZone";
+  MiotError2[MiotError2["Route"] = 61] = "Route";
+  MiotError2[MiotError2["Route2"] = 62] = "Route2";
+  MiotError2[MiotError2["Blocked2"] = 63] = "Blocked2";
+  MiotError2[MiotError2["Blocked3"] = 64] = "Blocked3";
+  MiotError2[MiotError2["Restricted"] = 65] = "Restricted";
+  MiotError2[MiotError2["Restricted2"] = 66] = "Restricted2";
+  MiotError2[MiotError2["Restricted3"] = 67] = "Restricted3";
+  MiotError2[MiotError2["TaskComplete"] = 68] = "TaskComplete";
+  MiotError2[MiotError2["MopRemoved"] = 69] = "MopRemoved";
+  MiotError2[MiotError2["MopRemoved2"] = 70] = "MopRemoved2";
+  MiotError2[MiotError2["MopPadStopRotate"] = 71] = "MopPadStopRotate";
+  MiotError2[MiotError2["MopPadStopRotate2"] = 72] = "MopPadStopRotate2";
+  MiotError2[MiotError2["ManualMopInstallRequired"] = 74] = "ManualMopInstallRequired";
   MiotError2[MiotError2["LowBatteryTurnOff"] = 75] = "LowBatteryTurnOff";
+  MiotError2[MiotError2["DirtyTankNotInstalled"] = 76] = "DirtyTankNotInstalled";
+  MiotError2[MiotError2["RobotInHiddenRoom"] = 78] = "RobotInHiddenRoom";
+  MiotError2[MiotError2["LdsFailedToLift"] = 79] = "LdsFailedToLift";
   MiotError2[MiotError2["RobotStuck"] = 80] = "RobotStuck";
   MiotError2[MiotError2["RobotStuckRepeat"] = 81] = "RobotStuckRepeat";
+  MiotError2[MiotError2["SlipperyFloor"] = 82] = "SlipperyFloor";
+  MiotError2[MiotError2["UnknownError"] = 84] = "UnknownError";
+  MiotError2[MiotError2["CheckMopInstall"] = 85] = "CheckMopInstall";
+  MiotError2[MiotError2["DirtyWaterTankFull"] = 86] = "DirtyWaterTankFull";
+  MiotError2[MiotError2["RetractableLegStuck"] = 88] = "RetractableLegStuck";
+  MiotError2[MiotError2["InternalError"] = 89] = "InternalError";
   MiotError2[MiotError2["RobotStuck2"] = 90] = "RobotStuck2";
   MiotError2[MiotError2["RobotStuckOnTables"] = 91] = "RobotStuckOnTables";
   MiotError2[MiotError2["RobotStuckOnPassage"] = 92] = "RobotStuckOnPassage";
@@ -1287,19 +1370,82 @@ var MiotError = /* @__PURE__ */ ((MiotError2) => {
   MiotError2[MiotError2["RobotStuckOnPet"] = 97] = "RobotStuckOnPet";
   MiotError2[MiotError2["RobotStuckOnSlipperySurface"] = 98] = "RobotStuckOnSlipperySurface";
   MiotError2[MiotError2["RobotStuckOnCarpet"] = 99] = "RobotStuckOnCarpet";
-  MiotError2[MiotError2["RobotStuckOnCurtain"] = 200] = "RobotStuckOnCurtain";
   MiotError2[MiotError2["BinFull"] = 101] = "BinFull";
+  MiotError2[MiotError2["BinOpen"] = 102] = "BinOpen";
+  MiotError2[MiotError2["BinOpen2"] = 103] = "BinOpen2";
+  MiotError2[MiotError2["BinFull2"] = 104] = "BinFull2";
+  MiotError2[MiotError2["WastewaterTankFull"] = 105] = "WastewaterTankFull";
+  MiotError2[MiotError2["DirtyWaterTank"] = 106] = "DirtyWaterTank";
+  MiotError2[MiotError2["CleanWaterTankEmpty"] = 107] = "CleanWaterTankEmpty";
+  MiotError2[MiotError2["DirtyWaterTank2"] = 108] = "DirtyWaterTank2";
+  MiotError2[MiotError2["DirtyWaterTankBlocked"] = 109] = "DirtyWaterTankBlocked";
+  MiotError2[MiotError2["DirtyWaterTankPump"] = 110] = "DirtyWaterTankPump";
+  MiotError2[MiotError2["MopPad"] = 111] = "MopPad";
+  MiotError2[MiotError2["WetMopPad"] = 112] = "WetMopPad";
+  MiotError2[MiotError2["WashboardFilterNeedsCleaning"] = 114] = "WashboardFilterNeedsCleaning";
+  MiotError2[MiotError2["CleanTankLevel"] = 116] = "CleanTankLevel";
   MiotError2[MiotError2["StationDisconnected"] = 117] = "StationDisconnected";
+  MiotError2[MiotError2["DirtyTankLevel"] = 118] = "DirtyTankLevel";
+  MiotError2[MiotError2["WashboardLevel"] = 119] = "WashboardLevel";
+  MiotError2[MiotError2["MopPadsMissing"] = 120] = "MopPadsMissing";
   MiotError2[MiotError2["DustBagFull"] = 121] = "DustBagFull";
+  MiotError2[MiotError2["UnknownWarning"] = 122] = "UnknownWarning";
+  MiotError2[MiotError2["SelfTestFailed"] = 123] = "SelfTestFailed";
+  MiotError2[MiotError2["WashboardNotWorking"] = 124] = "WashboardNotWorking";
+  MiotError2[MiotError2["DrainageFailed"] = 125] = "DrainageFailed";
+  MiotError2[MiotError2["MopNotDetected"] = 126] = "MopNotDetected";
+  MiotError2[MiotError2["MopHolderError"] = 127] = "MopHolderError";
+  MiotError2[MiotError2["DockError"] = 128] = "DockError";
+  MiotError2[MiotError2["WashFailed"] = 129] = "WashFailed";
+  MiotError2[MiotError2["RobotStuckOnCurtain"] = 200] = "RobotStuckOnCurtain";
+  MiotError2[MiotError2["EdgeMopStopRotate"] = 201] = "EdgeMopStopRotate";
+  MiotError2[MiotError2["EdgeMopDetached"] = 202] = "EdgeMopDetached";
+  MiotError2[MiotError2["ChassisLiftMalfunction"] = 203] = "ChassisLiftMalfunction";
+  MiotError2[MiotError2["InternalError2"] = 207] = "InternalError2";
+  MiotError2[MiotError2["MopCoverError"] = 209] = "MopCoverError";
+  MiotError2[MiotError2["RollerMopError"] = 210] = "RollerMopError";
+  MiotError2[MiotError2["OnboardWaterTankEmpty"] = 213] = "OnboardWaterTankEmpty";
+  MiotError2[MiotError2["OnboardDirtyWaterTankFull"] = 214] = "OnboardDirtyWaterTankFull";
+  MiotError2[MiotError2["MopNotInstalled"] = 215] = "MopNotInstalled";
+  MiotError2[MiotError2["RollerMopError2"] = 218] = "RollerMopError2";
+  MiotError2[MiotError2["FluffingRollerError"] = 222] = "FluffingRollerError";
+  MiotError2[MiotError2["MopCoverError2"] = 223] = "MopCoverError2";
+  MiotError2[MiotError2["BlockedByObstacle"] = 226] = "BlockedByObstacle";
+  MiotError2[MiotError2["ReturnToChargeFailed"] = 1e3] = "ReturnToChargeFailed";
   return MiotError2;
 })(MiotError || {});
 var TaskStatus = /* @__PURE__ */ ((TaskStatus2) => {
+  TaskStatus2[TaskStatus2["Completed"] = 0] = "Completed";
   TaskStatus2[TaskStatus2["InterruptedOrPaused"] = 1] = "InterruptedOrPaused";
   TaskStatus2[TaskStatus2["Active"] = 2] = "Active";
   TaskStatus2[TaskStatus2["Transitioning"] = 3] = "Transitioning";
+  TaskStatus2[TaskStatus2["SpotCleaning"] = 4] = "SpotCleaning";
+  TaskStatus2[TaskStatus2["FastMapping"] = 5] = "FastMapping";
   TaskStatus2[TaskStatus2["OnDockIdle"] = 6] = "OnDockIdle";
+  TaskStatus2[TaskStatus2["ZoneCleaningPaused"] = 7] = "ZoneCleaningPaused";
+  TaskStatus2[TaskStatus2["SegmentCleaningPaused"] = 8] = "SegmentCleaningPaused";
+  TaskStatus2[TaskStatus2["SpotCleaningPaused"] = 9] = "SpotCleaningPaused";
+  TaskStatus2[TaskStatus2["MapCleaningPaused"] = 10] = "MapCleaningPaused";
+  TaskStatus2[TaskStatus2["DockingPaused"] = 11] = "DockingPaused";
   TaskStatus2[TaskStatus2["TransientPauseEdge"] = 12] = "TransientPauseEdge";
+  TaskStatus2[TaskStatus2["SegmentMoppingPaused"] = 13] = "SegmentMoppingPaused";
   TaskStatus2[TaskStatus2["NeedsIntervention"] = 14] = "NeedsIntervention";
+  TaskStatus2[TaskStatus2["AutoMoppingPaused"] = 15] = "AutoMoppingPaused";
+  TaskStatus2[TaskStatus2["AutoDockingPaused"] = 16] = "AutoDockingPaused";
+  TaskStatus2[TaskStatus2["SegmentDockingPaused"] = 17] = "SegmentDockingPaused";
+  TaskStatus2[TaskStatus2["ZoneDockingPaused"] = 18] = "ZoneDockingPaused";
+  TaskStatus2[TaskStatus2["CruisingPath"] = 20] = "CruisingPath";
+  TaskStatus2[TaskStatus2["CruisingPathPaused"] = 21] = "CruisingPathPaused";
+  TaskStatus2[TaskStatus2["CruisingPoint"] = 22] = "CruisingPoint";
+  TaskStatus2[TaskStatus2["CruisingPointPaused"] = 23] = "CruisingPointPaused";
+  TaskStatus2[TaskStatus2["SummonCleanPaused"] = 24] = "SummonCleanPaused";
+  TaskStatus2[TaskStatus2["ReturningInstallMop"] = 25] = "ReturningInstallMop";
+  TaskStatus2[TaskStatus2["ReturningRemoveMop"] = 26] = "ReturningRemoveMop";
+  TaskStatus2[TaskStatus2["StationCleaning"] = 27] = "StationCleaning";
+  TaskStatus2[TaskStatus2["PetFinding"] = 30] = "PetFinding";
+  TaskStatus2[TaskStatus2["AutoCleaningWashingPaused"] = 31] = "AutoCleaningWashingPaused";
+  TaskStatus2[TaskStatus2["AreaCleaningWashingPaused"] = 32] = "AreaCleaningWashingPaused";
+  TaskStatus2[TaskStatus2["CustomCleaningWashingPaused"] = 33] = "CustomCleaningWashingPaused";
   return TaskStatus2;
 })(TaskStatus || {});
 
@@ -2436,6 +2582,18 @@ var VacuumDevice = class _VacuumDevice extends BaseDevice {
   get vacuumCapabilities() {
     return this.#caps;
   }
+  /**
+   * The suction levels this model supports, as a {@link SuctionLevel} enum array
+   * (from the capability record). Lets a consumer see which fan speeds are
+   * selectable without reaching into {@link vacuumCapabilities}.
+   */
+  get supportedSuctionLevels() {
+    return this.#caps.supportedSuctionLevels;
+  }
+  /** The water/mop volumes this model supports, as a {@link WaterVolume} enum array. */
+  get supportedWaterVolumes() {
+    return this.#caps.supportedWaterVolumes;
+  }
   #num(siid, piid) {
     return asNum(this.getProperty(siid, piid)?.value);
   }
@@ -2612,11 +2770,11 @@ var VacuumDevice = class _VacuumDevice extends BaseDevice {
     }
     this.#requireCap(this.#caps.canCleanPerRoom, "cleanZones", "per-room cleaning");
     const { repeats, fan, water } = this.#resolveCleanOpts(opts);
-    const areas = zones.map((z3) => [
-      Math.round(z3.x0),
-      Math.round(z3.y0),
-      Math.round(z3.x1),
-      Math.round(z3.y1),
+    const areas = zones.map((z4) => [
+      Math.round(z4.x0),
+      Math.round(z4.y0),
+      Math.round(z4.x1),
+      Math.round(z4.y1),
       repeats,
       fan,
       water
@@ -2798,6 +2956,83 @@ var MowerTaskStatus = /* @__PURE__ */ ((MowerTaskStatus2) => {
   MowerTaskStatus2[MowerTaskStatus2["SpotIncomplete"] = 7] = "SpotIncomplete";
   return MowerTaskStatus2;
 })(MowerTaskStatus || {});
+var MowerFault = /* @__PURE__ */ ((MowerFault2) => {
+  MowerFault2[MowerFault2["NoDeviceCode"] = 0] = "NoDeviceCode";
+  MowerFault2[MowerFault2["Tilted"] = 1] = "Tilted";
+  MowerFault2[MowerFault2["Trapped"] = 2] = "Trapped";
+  MowerFault2[MowerFault2["NarrowPathToStation"] = 3] = "NarrowPathToStation";
+  MowerFault2[MowerFault2["LeftWheel"] = 4] = "LeftWheel";
+  MowerFault2[MowerFault2["RightWheel"] = 5] = "RightWheel";
+  MowerFault2[MowerFault2["LiftMotor"] = 6] = "LiftMotor";
+  MowerFault2[MowerFault2["Cutter"] = 7] = "Cutter";
+  MowerFault2[MowerFault2["SidedMotor"] = 8] = "SidedMotor";
+  MowerFault2[MowerFault2["CrashPlate"] = 9] = "CrashPlate";
+  MowerFault2[MowerFault2["Charging"] = 10] = "Charging";
+  MowerFault2[MowerFault2["BatteryOverheat"] = 11] = "BatteryOverheat";
+  MowerFault2[MowerFault2["LidarCovered"] = 12] = "LidarCovered";
+  MowerFault2[MowerFault2["LidarOverheatWithoutMap"] = 13] = "LidarOverheatWithoutMap";
+  MowerFault2[MowerFault2["LidarOverheatWithMap"] = 14] = "LidarOverheatWithMap";
+  MowerFault2[MowerFault2["LidarOverheat"] = 15] = "LidarOverheat";
+  MowerFault2[MowerFault2["LidarDirty"] = 16] = "LidarDirty";
+  MowerFault2[MowerFault2["LidarAbnormal"] = 17] = "LidarAbnormal";
+  MowerFault2[MowerFault2["LocationWeak"] = 18] = "LocationWeak";
+  MowerFault2[MowerFault2["LocationLost"] = 19] = "LocationLost";
+  MowerFault2[MowerFault2["Sensor"] = 20] = "Sensor";
+  MowerFault2[MowerFault2["InForbiddenArea"] = 21] = "InForbiddenArea";
+  MowerFault2[MowerFault2["OutOfMap"] = 22] = "OutOfMap";
+  MowerFault2[MowerFault2["EmergencyStop"] = 23] = "EmergencyStop";
+  MowerFault2[MowerFault2["BatteryLow"] = 24] = "BatteryLow";
+  MowerFault2[MowerFault2["MapFileCrack"] = 25] = "MapFileCrack";
+  MowerFault2[MowerFault2["AwayFromMap"] = 26] = "AwayFromMap";
+  MowerFault2[MowerFault2["HumanDetected"] = 27] = "HumanDetected";
+  MowerFault2[MowerFault2["BladeLoss"] = 28] = "BladeLoss";
+  MowerFault2[MowerFault2["StationLoss"] = 29] = "StationLoss";
+  MowerFault2[MowerFault2["MaintainLoss"] = 30] = "MaintainLoss";
+  MowerFault2[MowerFault2["BackChargeFailed"] = 31] = "BackChargeFailed";
+  MowerFault2[MowerFault2["DockingFailed"] = 32] = "DockingFailed";
+  MowerFault2[MowerFault2["LocatingFailedWithMap"] = 33] = "LocatingFailedWithMap";
+  MowerFault2[MowerFault2["LocatingFailedWithoutMap"] = 34] = "LocatingFailedWithoutMap";
+  MowerFault2[MowerFault2["LocatingAbnormal"] = 35] = "LocatingAbnormal";
+  MowerFault2[MowerFault2["TaskStartFailed"] = 36] = "TaskStartFailed";
+  MowerFault2[MowerFault2["PathImpassable"] = 37] = "PathImpassable";
+  MowerFault2[MowerFault2["LidarDirtyWarning"] = 38] = "LidarDirtyWarning";
+  MowerFault2[MowerFault2["CamDirty"] = 39] = "CamDirty";
+  MowerFault2[MowerFault2["CamAbnormal"] = 40] = "CamAbnormal";
+  MowerFault2[MowerFault2["CamCover"] = 41] = "CamCover";
+  MowerFault2[MowerFault2["BatteryOverheatWarning"] = 42] = "BatteryOverheatWarning";
+  MowerFault2[MowerFault2["BatteryTempLow"] = 43] = "BatteryTempLow";
+  MowerFault2[MowerFault2["AutobuildBorder"] = 44] = "AutobuildBorder";
+  MowerFault2[MowerFault2["AutobuildSide"] = 45] = "AutobuildSide";
+  MowerFault2[MowerFault2["BorderFinish"] = 46] = "BorderFinish";
+  MowerFault2[MowerFault2["NewMap"] = 47] = "NewMap";
+  MowerFault2[MowerFault2["TaskFinish"] = 48] = "TaskFinish";
+  MowerFault2[MowerFault2["DestinationNotReachable"] = 49] = "DestinationNotReachable";
+  MowerFault2[MowerFault2["TaskStart"] = 50] = "TaskStart";
+  MowerFault2[MowerFault2["CruiseStart"] = 51] = "CruiseStart";
+  MowerFault2[MowerFault2["PointAndGoStart"] = 52] = "PointAndGoStart";
+  MowerFault2[MowerFault2["ScheduleStart"] = 53] = "ScheduleStart";
+  MowerFault2[MowerFault2["BatteryLowReturning"] = 54] = "BatteryLowReturning";
+  MowerFault2[MowerFault2["BatteryLowScheduleSuspend"] = 55] = "BatteryLowScheduleSuspend";
+  MowerFault2[MowerFault2["BadWeatherProtecting"] = 56] = "BadWeatherProtecting";
+  MowerFault2[MowerFault2["RainScheduleInterupted"] = 57] = "RainScheduleInterupted";
+  MowerFault2[MowerFault2["RainScheduleSuspend"] = 58] = "RainScheduleSuspend";
+  MowerFault2[MowerFault2["ForzenReturning"] = 59] = "ForzenReturning";
+  MowerFault2[MowerFault2["FrozenScheduleSuspend"] = 60] = "FrozenScheduleSuspend";
+  MowerFault2[MowerFault2["NotDisturbReturning"] = 61] = "NotDisturbReturning";
+  MowerFault2[MowerFault2["NotDisturbScheduleSuspend"] = 62] = "NotDisturbScheduleSuspend";
+  MowerFault2[MowerFault2["WorkingScheduleSuspend"] = 63] = "WorkingScheduleSuspend";
+  MowerFault2[MowerFault2["RemoteControlingScheduleSuspend"] = 64] = "RemoteControlingScheduleSuspend";
+  MowerFault2[MowerFault2["EmergencyStoppedScheduleSuspend"] = 65] = "EmergencyStoppedScheduleSuspend";
+  MowerFault2[MowerFault2["TopCoverOpenScheduleSuspend"] = 66] = "TopCoverOpenScheduleSuspend";
+  MowerFault2[MowerFault2["FaultModeScheduleSuspend"] = 67] = "FaultModeScheduleSuspend";
+  MowerFault2[MowerFault2["ScheduleTimeout"] = 68] = "ScheduleTimeout";
+  MowerFault2[MowerFault2["StationNotConnectedToWorkingArea"] = 69] = "StationNotConnectedToWorkingArea";
+  MowerFault2[MowerFault2["ContinueFromBreakpoint"] = 70] = "ContinueFromBreakpoint";
+  MowerFault2[MowerFault2["IdleTimeoutReturning"] = 71] = "IdleTimeoutReturning";
+  MowerFault2[MowerFault2["PauseTimeoutReturning"] = 72] = "PauseTimeoutReturning";
+  MowerFault2[MowerFault2["TopCoverOpen"] = 73] = "TopCoverOpen";
+  return MowerFault2;
+})(MowerFault || {});
 
 // src/models/mower/decode.ts
 function isRecord(v) {
@@ -3477,6 +3712,12 @@ var STATUS = enumLookup(
 var CHARGING2 = enumLookup(
   Object.values(MowerChargingStatus).filter((v) => typeof v === "number")
 );
+var TASK_STATUS = enumLookup(
+  Object.values(MowerTaskStatus).filter((v) => typeof v === "number")
+);
+var FAULT = enumLookup(
+  Object.values(MowerFault).filter((v) => typeof v === "number")
+);
 var MowerDevice = class _MowerDevice extends BaseDevice {
   #caps;
   #fetchBatch;
@@ -3525,6 +3766,25 @@ var MowerDevice = class _MowerDevice extends BaseDevice {
   get taskStatusRaw() {
     return this.#num(MOWER_PROP.TASK_STATUS.siid, MOWER_PROP.TASK_STATUS.piid);
   }
+  /**
+   * TASK_STATUS (5:104) decoded to {@link MowerTaskStatus}, or null. The donor
+   * names only code 7 (SpotIncomplete); codes 2/3/10/13 are documented "Unknown
+   * task status" and intentionally surface as raw via {@link taskStatusRaw}.
+   */
+  get taskStatus() {
+    return TASK_STATUS(this.taskStatusRaw);
+  }
+  get faultRaw() {
+    return this.#num(MOWER_PROP.DEVICE_CODE.siid, MOWER_PROP.DEVICE_CODE.piid);
+  }
+  /**
+   * DEVICE_CODE (2:2) decoded to a {@link MowerFault} (the donor's
+   * BASE_DEVICE_CODES registry, 0..73), or null for a model-specific/undocumented
+   * code — which still surfaces as the raw number via {@link faultRaw}.
+   */
+  get fault() {
+    return FAULT(this.faultRaw);
+  }
   /** Parsed scheduling task descriptor (2:50), or null. */
   get task() {
     return parseTaskDescriptor(
@@ -3599,7 +3859,7 @@ var MowerDevice = class _MowerDevice extends BaseDevice {
     if (zoneIds.length === 0) {
       throw new RangeError("startMowingZones: zoneIds must not be empty");
     }
-    return this.#sendTask(buildZonePayload(zoneIds.map((z3) => Math.trunc(z3))));
+    return this.#sendTask(buildZonePayload(zoneIds.map((z4) => Math.trunc(z4))));
   }
   /** Edge / contour mowing (2:50 o:101). Contour ids are two-int pairs [[1,0]]. */
   async startMowingEdges(contourIds) {
@@ -3667,6 +3927,7 @@ var MowerDevice = class _MowerDevice extends BaseDevice {
   /** Props worth seeding on start() / polling — exported for the facade. */
   static DEFAULT_PROPS = [
     MOWER_PROP.STATUS,
+    MOWER_PROP.DEVICE_CODE,
     MOWER_PROP.BATTERY,
     MOWER_PROP.CHARGING_STATUS,
     MOWER_PROP.TASK_STATUS,
@@ -3822,6 +4083,429 @@ var Nodreame = class extends TypedEmitter {
     await Promise.all(this.#devices.map((d) => d.applySession(session)));
   }
 };
+
+// src/diagnostics/redact.ts
+var REDACTED = "[redacted]";
+var SENSITIVE_KEY_FRAGMENTS = [
+  // identity / secrets
+  "did",
+  "uid",
+  "token",
+  // accessToken, refreshToken, refresh_token, token_type stripped too (safe)
+  "mac",
+  "serial",
+  "email",
+  "account",
+  "password",
+  "passwd",
+  "secret",
+  "authorization",
+  "auth",
+  "credential",
+  "apikey",
+  "api_key",
+  "clientid",
+  "client_id",
+  // location / PII
+  "gps",
+  "coordinate",
+  "latitude",
+  "longitude",
+  "lat",
+  "lon",
+  "lng",
+  "ssid",
+  "wifi",
+  "bssid",
+  "ipaddr",
+  "localip",
+  "binddomain",
+  "host",
+  "address",
+  "room",
+  "area_name",
+  "areaname",
+  "segmentname",
+  "segment_name",
+  // map binary / geometry (location-revealing)
+  "map_info",
+  "mapinfo",
+  "mapblob",
+  // free-text device names that may carry PII. NOTE: the bare fragment `name` is
+  // intentionally NOT listed — it would over-match the catalog's command `name`
+  // field (an enum-derived, non-sensitive label). The specific custom-name
+  // fields below cover every PII-bearing case.
+  "customname",
+  "devicename",
+  "nickname"
+];
+var EXACT_SENSITIVE_KEYS = /* @__PURE__ */ new Set(["ip"]);
+function isSensitiveKey(key2) {
+  const lower = key2.toLowerCase();
+  if (EXACT_SENSITIVE_KEYS.has(lower)) {
+    return true;
+  }
+  return SENSITIVE_KEY_FRAGMENTS.some((frag) => lower.includes(frag));
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function redact(value) {
+  if (Array.isArray(value)) {
+    return value.map((v) => redact(v));
+  }
+  if (isPlainObject(value)) {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = isSensitiveKey(k) ? REDACTED : redact(v);
+    }
+    return out;
+  }
+  return value;
+}
+
+// src/diagnostics/dump-format.ts
+import { z as z3 } from "zod";
+var DumpScalarSchema = z3.union([z3.string(), z3.number(), z3.boolean()]);
+var PropertyObservationSchema = z3.object({
+  values: z3.array(DumpScalarSchema),
+  unmapped: z3.array(DumpScalarSchema),
+  enum: z3.string().optional(),
+  count: z3.number(),
+  firstSeen: z3.number(),
+  lastSeen: z3.number()
+});
+var EventObservationSchema = z3.object({
+  at: z3.number(),
+  type: z3.string(),
+  data: z3.unknown().optional()
+});
+var RawFrameSchema = z3.object({
+  at: z3.number(),
+  source: z3.string(),
+  payload: z3.unknown()
+});
+var CommandSchema = z3.object({
+  name: z3.string(),
+  siid: z3.number().optional(),
+  aiid: z3.number().optional()
+});
+var SensorSchema = z3.object({
+  model: z3.string(),
+  channel: z3.number().optional()
+});
+var DeviceDumpSchema = z3.object({
+  schemaVersion: z3.literal(1),
+  library: z3.union([z3.literal("nodedreame"), z3.literal("nodewitt")]),
+  libraryVersion: z3.string(),
+  device: z3.object({
+    model: z3.string(),
+    firmware: z3.string().optional(),
+    region: z3.string().optional(),
+    type: z3.string().optional()
+  }),
+  observations: z3.object({
+    properties: z3.record(z3.string(), PropertyObservationSchema),
+    events: z3.array(EventObservationSchema),
+    rawFrames: z3.array(RawFrameSchema).optional()
+  }),
+  catalog: z3.object({
+    commands: z3.array(CommandSchema).optional(),
+    capabilities: z3.record(z3.string(), z3.unknown()).optional(),
+    sensors: z3.array(SensorSchema).optional()
+  }),
+  meta: z3.object({
+    startedAt: z3.number(),
+    durationMs: z3.number(),
+    generatedAt: z3.number()
+  })
+});
+
+// src/diagnostics/dumper.ts
+function commandsForFamily(family) {
+  const commands = [];
+  if (family === "vacuum") {
+    for (const [name, ref] of Object.entries(VACUUM_ACTION)) {
+      commands.push({ name, siid: ref.siid, aiid: ref.aiid });
+    }
+  } else if (family === "mower") {
+    for (const [name, ref] of Object.entries(MOWER_ACTION)) {
+      commands.push({ name, siid: ref.siid, aiid: ref.aiid });
+    }
+  }
+  return commands;
+}
+function decoderFor(enumName, members) {
+  const lookup = enumLookup(members);
+  return { enumName, isMember: (raw) => lookup(raw) !== null };
+}
+function vacuumDecoders() {
+  return {
+    "2.1": decoderFor(
+      "MiotState",
+      Object.values(MiotState).filter((v) => typeof v === "number")
+    ),
+    "3.2": decoderFor(
+      "ChargingStatus",
+      Object.values(ChargingStatus).filter((v) => typeof v === "number")
+    ),
+    "4.4": decoderFor(
+      "SuctionLevel",
+      Object.values(SuctionLevel).filter((v) => typeof v === "number")
+    ),
+    "4.5": decoderFor(
+      "WaterVolume",
+      Object.values(WaterVolume).filter((v) => typeof v === "number")
+    ),
+    "2.6": decoderFor(
+      "CleaningMode",
+      Object.values(CleaningMode).filter((v) => typeof v === "number")
+    ),
+    "4.1": decoderFor(
+      "TaskStatus",
+      Object.values(TaskStatus).filter((v) => typeof v === "number")
+    )
+  };
+}
+function mowerDecoders() {
+  return {
+    "2.1": decoderFor(
+      "MowerStatus",
+      Object.values(MowerStatus).filter((v) => typeof v === "number")
+    ),
+    "3.2": decoderFor(
+      "MowerChargingStatus",
+      Object.values(MowerChargingStatus).filter(
+        (v) => typeof v === "number"
+      )
+    ),
+    "5.104": decoderFor(
+      "MowerTaskStatus",
+      Object.values(MowerTaskStatus).filter((v) => typeof v === "number")
+    ),
+    "2.2": decoderFor(
+      "MowerFault",
+      Object.values(MowerFault).filter((v) => typeof v === "number")
+    )
+  };
+}
+function toScalar(value) {
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  return null;
+}
+var PropertyAccumulator = class {
+  #decoders;
+  #entries = /* @__PURE__ */ new Map();
+  constructor(decoders = {}) {
+    this.#decoders = decoders;
+  }
+  record(siid, piid, rawValue, at) {
+    const key2 = `${siid}.${piid}`;
+    const scalar = toScalar(rawValue);
+    let entry = this.#entries.get(key2);
+    if (!entry) {
+      entry = { values: [], unmapped: [], count: 0, firstSeen: at, lastSeen: at };
+      this.#entries.set(key2, entry);
+    }
+    entry.count += 1;
+    entry.lastSeen = at;
+    if (scalar === null) {
+      return;
+    }
+    if (!entry.values.includes(scalar)) {
+      entry.values.push(scalar);
+    }
+    const decoder = this.#decoders[key2];
+    if (decoder && typeof scalar === "number" && !decoder.isMember(scalar)) {
+      if (!entry.unmapped.includes(scalar)) {
+        entry.unmapped.push(scalar);
+      }
+    }
+  }
+  snapshot() {
+    const out = {};
+    for (const [key2, e] of this.#entries) {
+      const decoder = this.#decoders[key2];
+      const base = {
+        values: [...e.values],
+        unmapped: [...e.unmapped],
+        count: e.count,
+        firstSeen: e.firstSeen,
+        lastSeen: e.lastSeen
+      };
+      out[key2] = decoder ? { ...base, enum: decoder.enumName } : base;
+    }
+    return out;
+  }
+};
+var DEFAULT_REFRESH_INTERVAL_MS = 3e4;
+var DEFAULT_MAX_RAW_FRAMES = 500;
+var Dumper = class {
+  #device;
+  #opts;
+  #acc;
+  #events = [];
+  #rawFrames = [];
+  #catalog;
+  #type;
+  #onProperty;
+  #onEvent;
+  #timer = null;
+  #startedAt = 0;
+  #started = false;
+  constructor(device, catalog, type, decoders, options = {}) {
+    this.#device = device;
+    this.#catalog = catalog;
+    this.#type = type;
+    this.#acc = new PropertyAccumulator(decoders);
+    this.#opts = {
+      captureRawFrames: options.captureRawFrames ?? false,
+      maxRawFrames: options.maxRawFrames ?? DEFAULT_MAX_RAW_FRAMES,
+      refreshIntervalMs: options.refreshIntervalMs ?? DEFAULT_REFRESH_INTERVAL_MS
+    };
+    this.#onProperty = (e) => {
+      this.#acc.record(e.siid, e.piid, e.value, Date.now());
+      this.#pushRaw("mqtt:property", e);
+    };
+    this.#onEvent = (e) => {
+      this.#events.push({
+        at: Date.now(),
+        type: `${e.siid}.${e.eiid}`,
+        data: { arguments: e.arguments }
+      });
+      this.#pushRaw("mqtt:event", e);
+    };
+  }
+  /** Attach to the live stream + arm the periodic shadow refresh. Idempotent. */
+  async start() {
+    if (this.#started) {
+      return;
+    }
+    this.#started = true;
+    this.#startedAt = Date.now();
+    this.#device.on("propertyChanged", this.#onProperty);
+    this.#device.on("event", this.#onEvent);
+    await this.#refresh();
+    if (this.#opts.refreshIntervalMs > 0 && this.#device.refreshFromCache) {
+      this.#timer = setInterval(() => void this.#refresh(), this.#opts.refreshIntervalMs);
+      this.#timer.unref?.();
+    }
+  }
+  /** Detach every listener + clear the timer. Idempotent. */
+  stop() {
+    if (!this.#started) {
+      return Promise.resolve();
+    }
+    this.#started = false;
+    if (this.#timer) {
+      clearInterval(this.#timer);
+      this.#timer = null;
+    }
+    this.#device.off("propertyChanged", this.#onProperty);
+    this.#device.off("event", this.#onEvent);
+    return Promise.resolve();
+  }
+  /** Build the anonymized, schema-valid dump. Works live or after {@link stop}. */
+  export() {
+    const now = Date.now();
+    const dump = {
+      schemaVersion: 1,
+      library: "nodedreame",
+      libraryVersion: LIBRARY_VERSION,
+      device: {
+        model: this.#device.model,
+        type: this.#type
+      },
+      observations: {
+        properties: this.#acc.snapshot(),
+        events: [...this.#events],
+        ...this.#opts.captureRawFrames ? { rawFrames: this.#redactFrames() } : {}
+      },
+      catalog: this.#catalog,
+      meta: {
+        startedAt: this.#startedAt,
+        durationMs: Math.max(0, now - this.#startedAt),
+        generatedAt: now
+      }
+    };
+    const anonymized = redact(dump);
+    return DeviceDumpSchema.parse(anonymized);
+  }
+  /** Deterministic pretty JSON of {@link export}. */
+  exportJson() {
+    return JSON.stringify(this.export(), null, 2);
+  }
+  async #refresh() {
+    if (this.#device.refreshFromCache) {
+      try {
+        await this.#device.refreshFromCache();
+      } catch {
+      }
+    }
+  }
+  #pushRaw(source, payload) {
+    if (!this.#opts.captureRawFrames) {
+      return;
+    }
+    this.#rawFrames.push({ at: Date.now(), source, payload });
+    if (this.#rawFrames.length > this.#opts.maxRawFrames) {
+      this.#rawFrames.shift();
+    }
+  }
+  #redactFrames() {
+    return this.#rawFrames.map((f) => ({ at: f.at, source: f.source, payload: redact(f.payload) }));
+  }
+};
+function familyOf(device) {
+  if (device instanceof VacuumDevice) {
+    return "vacuum";
+  }
+  if (device instanceof MowerDevice) {
+    return "mower";
+  }
+  if (!(device instanceof BaseDevice)) {
+    if (device.model.startsWith("dreame.vacuum.")) {
+      return "vacuum";
+    }
+    if (device.model.startsWith("dreame.mower.")) {
+      return "mower";
+    }
+  }
+  return "device";
+}
+function decodersFor(device) {
+  switch (familyOf(device)) {
+    case "vacuum":
+      return vacuumDecoders();
+    case "mower":
+      return mowerDecoders();
+    default:
+      return {};
+  }
+}
+function typeFor(device) {
+  return familyOf(device);
+}
+function catalogFor(device) {
+  return {
+    commands: commandsForFamily(familyOf(device)),
+    capabilities: { tokens: [...device.capabilities.list()] }
+  };
+}
+function createDumper(target, options) {
+  return new Dumper(
+    target,
+    catalogFor(target),
+    typeFor(target),
+    decodersFor(target),
+    options ?? {}
+  );
+}
+function createClientDumper(client, options) {
+  return client.devices.map((d) => createDumper(d, options));
+}
 export {
   BaseDevice,
   ChargingStatus,
@@ -3840,6 +4524,7 @@ export {
   MowerChargingStatus,
   MowerControlAction,
   MowerDevice,
+  MowerFault,
   MowerStatus,
   MowerTaskStatus,
   Nodreame,
@@ -3849,6 +4534,8 @@ export {
   VacuumCapabilityResolver,
   VacuumDevice,
   WaterVolume,
+  createClientDumper,
+  createDumper,
   getMowerCapabilities,
   getVacuumCapabilities,
   renderMowerSvg,