v2c-any 0.5.3 → 0.6.1

package/README.md

@@ -1,4 +1,6 @@
+<!-- markdownlint-disable MD041 -->
 ![v2a - V2C any](docs/assets/images/v2ca.png)
+<!-- markdownlint-enable MD041 -->
 
 ![GitHub License](https://img.shields.io/github/license/tvcsantos/v2c-any)
 ![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/tvcsantos/v2c-any/ci-build.yml)
@@ -15,18 +17,18 @@
 
 **v2c-any** (binary: `v2ca`) is a universal adapter that allows **any device** — physical meters, MQTT topics, simulators, or proxies — to integrate with **V2C wallboxes** for **Dynamic Power Control**.
 
-If it can expose power data, **v2c-any** can make it speak *V2C*.
+If it can expose power data, **v2c-any** can make it speak _V2C_.
 
 ## Why v2c-any?
 
 V2C wallboxes support Dynamic Power Control via specific meters or MQTT inputs.  
 In real installations, however, power data often comes from **heterogeneous sources**:
 
-- Different brands of energy meters  
-- Existing MQTT infrastructures  
-- Home Assistant sensors  
-- Custom hardware or software systems  
-- Simulated or virtual meters for testing  
+- Different brands of energy meters
+- Existing MQTT infrastructures
+- Home Assistant sensors
+- Custom hardware or software systems
+- Simulated or virtual meters for testing
 
 **v2c-any** bridges that gap.
 
@@ -52,13 +54,13 @@ Or in practical terms:
 
 ## Key features
 
-- 🔌 **Universal adapter** – works with *any* power data source  
-- 📡 **MQTT support** – publish once, charge dynamically  
-- ⚡ **Dynamic Power Control** – grid, solar, or hybrid scenarios  
-- 🧪 **Simulation mode** – emulate supported meters for testing  
-- 🔁 **Proxy mode** – forward and transform existing devices  
-- 🧩 **Extensible architecture** – add new adapters easily  
-- 🟦 **TypeScript-first** – predictable, typed, maintainable  
+- 🔌 **Universal adapter** – works with _any_ power data source
+- 📡 **MQTT support** – publish once, charge dynamically
+- ⚡ **Dynamic Power Control** – grid, solar, or hybrid scenarios
+- 🧪 **Simulation mode** – emulate supported meters for testing
+- 🔁 **Proxy mode** – forward and transform existing devices
+- 🧩 **Extensible architecture** – add new adapters easily
+- 🟦 **TypeScript-first** – predictable, typed, maintainable
 
 ## Quick Start
 
@@ -96,7 +98,7 @@ properties:
         type: adapter
         properties:
           interval: 5000
-          ip: 192.168.1.100
+          host: 192.168.1.100
     solar:
       mode: pull
       feed:
@@ -134,7 +136,7 @@ Emulates a **Shelly Pro EM** energy meter by exposing a REST API that V2C wallbo
 - You want to act as a drop-in replacement for physical hardware
 - You prefer a pull-based (polling) approach
 
-**Configuration example:**
+**Quick example:**
 
 ```yaml
 provider: rest
@@ -146,29 +148,26 @@ properties:
         type: adapter
         properties:
           device: shelly-pro-em
-          ip: 192.168.1.100
+          host: 192.168.1.100
     solar:
       feed:
         type: mock
         properties:
-          value:          
+          value:
             id: 1
-            voltage: 230.2
-            current: 3.785
             act_power: 852.7
-            aprt_power: 873.1
-            pf: 0.98
-            freq: 50
             calibration: factory
 ```
 
 **How it works:**
 
 1. `v2ca` starts a Fastify HTTP server
-2. Exposes endpoints matching Shelly Pro EM API format
-3. V2C wallbox polls these endpoints (e.g., `/rpc/EM1.GetStatus?id=0`)
+2. Exposes endpoint matching Shelly Pro EM API format (i.e., `/rpc/EM1.GetStatus`)
+3. V2C wallbox polls the endpoint at configured intervals
 4. Returns real-time power data from your configured sources
 
+📖 **[See full REST Mode documentation](docs/REST_MODE.md)** for detailed configuration options, schemas, and examples.
+
 ### MQTT Mode (Direct Publisher)
 
 Publishes power data directly to MQTT topics that V2C wallboxes subscribe to.
@@ -180,7 +179,7 @@ Publishes power data directly to MQTT topics that V2C wallboxes subscribe to.
 - You want push-based (event-driven) updates
 - You need lower latency or more frequent updates
 
-**Configuration example:**
+**Quick example:**
 
 ```yaml
 provider: mqtt
@@ -188,15 +187,15 @@ properties:
   url: mqtt://broker.local:1883
   meters:
     grid:
-      mode: pull       # v2ca polls your device
+      mode: pull # v2ca polls your device
       feed:
         type: adapter
         properties:
           device: shelly-pro-em
-          interval: 2000   # Every 2 seconds
-          ip: 192.168.1.100
+          interval: 2000
+          host: 192.168.1.100
     solar:
-      mode: push       # v2ca subscribes to MQTT topic
+      mode: push # v2ca subscribes to MQTT topic
       feed:
         type: bridge
         properties:
@@ -211,10 +210,12 @@ properties:
 3. Supports both **pull** (polling devices) and **push** (subscribing to topics)
 4. V2C wallbox subscribes and receives real-time updates
 
+📖 **[See full MQTT Mode documentation](docs/MQTT_MODE.md)** for detailed configuration options, schemas, and examples.
+
 ### Mode Comparison
 
 | Feature         | REST Mode                  | MQTT Mode                   |
-|-----------------|----------------------------|-----------------------------|
+| --------------- | -------------------------- | --------------------------- |
 | **Protocol**    | HTTP/REST                  | MQTT                        |
 | **Direction**   | Pull (V2C polls v2ca)      | Push (v2ca publishes)       |
 | **Latency**     | Higher (polling interval)  | Lower (event-driven)        |
@@ -222,11 +223,11 @@ properties:
 | **Use Case**    | Shelly meter replacement   | MQTT-native setups          |
 | **Scalability** | Limited by polling         | Better for multiple devices |
 
-## What v2c-any is *not*
+## What v2c-any is _not_
 
-- ❌ Not a replacement for your existing meters  
-- ❌ Not tied to a single vendor or ecosystem  
-- ❌ Not limited to one communication protocol  
+- ❌ Not a replacement for your existing meters
+- ❌ Not tied to a single vendor or ecosystem
+- ❌ Not limited to one communication protocol
 
 It’s an **adapter**, not a lock-in.
 

package/dist/device/shelly-pro-em/em1-status-provider.js

@@ -7,18 +7,18 @@ import { em1StatusComparator, em1StatusInterpolator, em1StatusZeroValue, } from
  * Provider that fetches EM1 status data from a Shelly Pro EM device via HTTP.
  * Retrieves real-time energy monitoring data by querying the device's RPC API endpoint.
  */
-export class EM1StatusProvider {
+class EM1StatusProvider {
     /**
      * Creates a new EM1 status provider.
      * @param host - The IP address or hostname of the Shelly Pro EM device
      * @param energyType - The type of energy data to retrieve (e.g., active, reactive)
      */
-    constructor(host, energyType) {
-        this.host = host;
-        this.energyType = energyType;
+    constructor(properties) {
+        this.properties = properties;
+        this.url = `${properties.protocol}://${properties.host}:${properties.port}`;
         const { responseError } = interceptors;
-        this.client = new Client(`http://${this.host}`).compose(responseError());
-        this.id = energyTypeToId(energyType);
+        this.client = new Client(this.url).compose(responseError());
+        this.id = energyTypeToId(properties.energyType);
     }
     /**
      * Fetches the current EM1 status from the device.
@@ -26,7 +26,7 @@ export class EM1StatusProvider {
      * @throws {Error} If the HTTP request fails or returns invalid data
      */
     async get() {
-        logger.debug({ host: this.host, energyType: this.energyType }, 'Fetching EM1Status');
+        logger.debug({ url: this.url, energyType: this.properties.energyType }, 'Fetching EM1Status');
         const res = await this.client.request({
             path: `/rpc/EM1.GetStatus?id=${this.id}`,
             method: 'GET',
@@ -45,9 +45,23 @@ class EM1StatusProviderFactory {
      * @returns A configured EM1StatusProvider instance
      */
     create(options) {
-        logger.debug({ ip: options.properties.ip, energyType: options.energyType }, 'Creating EM1StatusProvider');
-        const provider = new EM1StatusProvider(options.properties.ip, options.energyType);
-        return createResiliantProvider(provider, em1StatusInterpolator, em1StatusZeroValue, em1StatusComparator, options.properties.breaker, options.properties.retry, options.properties.ema);
+        logger.debug({
+            url: `${options.properties.protocol}://${options.properties.host}:${options.properties.port}`,
+            energyType: options.energyType,
+        }, 'Creating EM1StatusProvider');
+        const provider = new EM1StatusProvider({
+            energyType: options.energyType,
+            ...options.properties,
+        });
+        return createResiliantProvider({
+            provider,
+            interpolator: em1StatusInterpolator,
+            zeroValue: em1StatusZeroValue,
+            comparator: em1StatusComparator,
+            breakerOptions: options.properties.breaker,
+            retryOptions: options.properties.retry,
+            emaOptions: options.properties.ema,
+        });
     }
 }
 /**

package/dist/device/shelly-pro-em/energy-information-em1-notify-status-adapter.js

@@ -1,8 +1,23 @@
 import { energyTypeToId } from '../../utils/mappers.js';
+/**
+ * Adapter for transforming Shelly Pro EM1 NotifyStatus notifications into energy information.
+ * Extracts active power data from the appropriate EM1 channel based on the configured energy type.
+ */
 class EnergyInformationEM1NotifyStatusAdapter {
+    /**
+     * Creates a new EM1 NotifyStatus adapter for a specific energy type.
+     * @param energyType - The type of energy (grid or solar) to extract from notifications
+     */
     constructor(energyType) {
         this.id = energyTypeToId(energyType);
     }
+    /**
+     * Adapts an EM1 NotifyStatus notification frame into energy information.
+     * Extracts the active power from the configured EM1 channel.
+     *
+     * @param input - The notification frame containing EM1 status data
+     * @returns A promise resolving to energy information with power value, or undefined if the channel data is not present
+     */
     adapt(input) {
         const key = `em1:${this.id}`;
         const em1Status = input.params[key];
@@ -12,9 +27,23 @@ class EnergyInformationEM1NotifyStatusAdapter {
         return Promise.resolve(undefined);
     }
 }
+/**
+ * Factory for creating EnergyInformationEM1NotifyStatusAdapter instances.
+ * Implements the AdapterFactory pattern to produce adapters configured for specific energy types.
+ */
 class EnergyInformationEM1NotifyStatusAdapterFactory {
+    /**
+     * Creates a new EM1 NotifyStatus adapter configured for the specified energy type.
+     *
+     * @param options - Configuration options specifying the energy type
+     * @returns An adapter that transforms EM1 NotifyStatus notifications into energy information
+     */
     create(options) {
         return new EnergyInformationEM1NotifyStatusAdapter(options.energyType);
     }
 }
+/**
+ * Singleton instance of the EM1 NotifyStatus adapter factory.
+ * Used to create adapters for transforming Shelly Pro EM NotifyStatus notifications into energy information.
+ */
 export const energyInformationEM1NotifyStatusAdapterFactory = new EnergyInformationEM1NotifyStatusAdapterFactory();

package/dist/device/shelly-pro-em/energy-information-em1-status-adapter.js

@@ -22,7 +22,18 @@ class EnergyInformationEM1StatusAdapter {
  * Use this ready-to-use instance where an adapter object is required.
  */
 const energyInformationEM1StatusAdapter = new EnergyInformationEM1StatusAdapter();
+/**
+ * Factory for creating EnergyInformationEM1StatusAdapter instances.
+ * Returns a singleton adapter instance that transforms EM1Status data into EnergyInformation.
+ * Implements the AdapterFactory pattern without requiring configuration options.
+ */
 export const energyInformationEM1StatusAdapterFactory = {
+    /**
+     * Creates and returns the singleton EM1 Status adapter instance.
+     * No configuration options are required as the adapter uses a fixed transformation logic.
+     *
+     * @returns An adapter that transforms EM1Status data into energy information
+     */
     create() {
         return energyInformationEM1StatusAdapter;
     },

package/dist/factory/mqtt-pull-executable-service-factory.js

@@ -11,11 +11,11 @@ export class MqttPullExecutableServiceFactory {
     /**
      * Creates a new MQTT pull executable service factory.
      * @param providerFactoryRegistry - Registry of device providers for adapter-based sources
-     * @param adapterRegistry - Registry of device adapters for transforming provider output
+     * @param adapterFactoryRegistry - Registry of device adapters for transforming provider output
      */
-    constructor(providerFactoryRegistry, adapterRegistry) {
+    constructor(providerFactoryRegistry, adapterFactoryRegistry) {
         this.providerFactoryRegistry = providerFactoryRegistry;
-        this.adapterRegistry = adapterRegistry;
+        this.adapterFactoryRegistry = adapterFactoryRegistry;
     }
     /**
      * Creates the appropriate provider factory based on the feed configuration type.
@@ -33,7 +33,7 @@ export class MqttPullExecutableServiceFactory {
                 if (!providerFactory) {
                     throw new Error(`No provider registered for device: ${device}`);
                 }
-                const adapterFactory = this.adapterRegistry.get(device);
+                const adapterFactory = this.adapterFactoryRegistry.get(device);
                 if (!adapterFactory) {
                     throw new Error(`No adapter registered for device: ${device}`);
                 }

package/dist/factory/mqtt-push-executable-service-factory.js

@@ -8,10 +8,10 @@ import { MqttBridgeService } from '../service/mqtt-bridge-service.js';
 export class MqttPushExecutableServiceFactory {
     /**
      * Creates a new MQTT push executable service factory.
-     * @param devicesAdapter - Registry of device adapters to transform incoming messages
+     * @param devicesAdapterFactoryRegistry - Registry of device adapters to transform incoming messages
      */
-    constructor(devicesAdapter) {
-        this.devicesAdapter = devicesAdapter;
+    constructor(devicesAdapterFactoryRegistry) {
+        this.devicesAdapterFactoryRegistry = devicesAdapterFactoryRegistry;
     }
     /**
      * Creates an executable service using the appropriate push strategy.
@@ -24,11 +24,11 @@ export class MqttPushExecutableServiceFactory {
         switch (options.configuration.type) {
             case 'bridge': {
                 const device = options.configuration.properties.device;
-                const adapter = this.devicesAdapter.get(device);
-                if (!adapter) {
+                const adapterFactory = this.devicesAdapterFactoryRegistry.get(device);
+                if (!adapterFactory) {
                     throw new Error(`No adapter registered for device: ${device}`);
                 }
-                return new MqttBridgeService(options.configuration.properties, options.callbackProperties, adapter.create({ energyType: options.energyType }));
+                return new MqttBridgeService(options.configuration.properties, options.callbackProperties, adapterFactory.create({ energyType: options.energyType }));
             }
             case 'off':
                 return noOpExecutableService;

package/dist/provider/asymmetric-ema-provider.js

@@ -8,7 +8,7 @@ import { logger } from '../utils/logger.js';
  */
 export class AsymmetricEMAProvider {
     /**
-     * Creates a new InnerAsymmetricEMAProvider.
+     * Creates a new AsymmetricEMAProvider.
      * @param provider - The underlying provider to fetch raw values from
      * @param interpolator - The interpolator to use for blending values
      * @param options - Configuration options for the asymmetric EMA calculation
@@ -18,7 +18,9 @@ export class AsymmetricEMAProvider {
         this.provider = provider;
         this.interpolator = interpolator;
         this.options = options;
+        /** The current exponential moving average value, or null if not yet initialized */
         this.ema = null;
+        /** Timestamp of the last successful value update in milliseconds since epoch */
         this.lastUpdateTime = null;
         if (options.alphaRise < 0 || options.alphaRise > 1) {
             throw new Error('alphaRise must be between 0 and 1');
@@ -27,6 +29,13 @@ export class AsymmetricEMAProvider {
             throw new Error('alphaFall must be between 0 and 1');
         }
     }
+    /**
+     * Updates the EMA with a newly received value.
+     * Determines whether the value is rising or falling and applies the appropriate smoothing factor.
+     * Initializes the EMA on first call.
+     *
+     * @param newValue - The new value to incorporate into the EMA
+     */
     onNewValue(newValue) {
         if (this.ema === null) {
             this.ema = newValue;
@@ -36,6 +45,11 @@ export class AsymmetricEMAProvider {
         const alpha = comparison >= 0 ? this.options.alphaRise : this.options.alphaFall;
         this.ema = this.interpolator.interpolate(newValue, this.ema, alpha);
     }
+    /**
+     * Handles the case when a value fetch fails or returns no data.
+     * Decays the current EMA toward the configured zero value using the missing value smoothing factor.
+     * Only applies if the EMA has been previously initialized.
+     */
     onMissingValue() {
         if (this.ema !== null) {
             this.ema = this.interpolator.interpolate(this.options.zeroValue, this.ema, this.options.alphaMissing);
@@ -46,7 +60,10 @@ export class AsymmetricEMAProvider {
      * On first call, initializes the EMA with the fetched value.
      * On subsequent calls, interpolates between the new value and current EMA,
      * using alphaRise if the value is increasing or alphaFall if decreasing.
-     * @returns A promise that resolves to the updated EMA value
+     * If the fetch fails and a freshness threshold is configured, decays toward zero value.
+     *
+     * @returns A promise that resolves to the newly fetched value, or the current EMA if fetch fails
+     * @throws {Error} If fetch fails and no EMA has been initialized yet
      */
     async get() {
         try {
@@ -79,6 +96,8 @@ export class AsymmetricEMAProvider {
     /**
      * Resets the EMA to its initial state.
      * The next call to get() will reinitialize the EMA.
+     *
+     * @param value - Optional value to set as the new EMA. Defaults to null (uninitialized state)
      */
     reset(value = null) {
         this.ema = value;

package/dist/provider/circuit-breaker-provider.js

@@ -1,17 +1,17 @@
 import CircuitBreaker from 'opossum';
 /**
- * Resilient Asymmetric EMA Provider with circuit breaker pattern.
- * Wraps an InnerAsymmetricEMAProvider with resilience features, providing
- * fallback to the last known EMA value when the underlying provider fails.
+ * Provider wrapper that implements the circuit breaker pattern for resilience.
+ * Protects against cascading failures by automatically opening the circuit when
+ * the underlying provider exceeds failure thresholds. Supports timeout, retry,
+ * and fallback mechanisms provided by the Opossum circuit breaker library.
  *
  * @template T - The type of value this provider supplies
  */
 export class CircuitBreakerProvider {
     /**
-     * Creates a new AsymmetricEMAProvider with circuit breaker protection.
-     * @param provider - The underlying provider to fetch raw values from
-     * @param interpolator - The interpolator to use for blending values
-     * @param asymmetricEmaOptions - Configuration options for the asymmetric EMA calculation
+     * Creates a new CircuitBreakerProvider wrapping the given provider.
+     * @param provider - The underlying provider to protect with circuit breaker logic
+     * @param options - Optional Opossum circuit breaker configuration (timeout, error thresholds, etc.)
      */
     constructor(provider, options) {
         this.provider = provider;
@@ -19,10 +19,12 @@ export class CircuitBreakerProvider {
         this.circuitBreaker = new CircuitBreaker(this.provider.get.bind(this.provider), this.options);
     }
     /**
-     * Fetches the value from the wrapped provider with resilience features.
-     * If the underlying provider fails or times out, falls back to the last known EMA value.
-     * @returns A promise that resolves to the EMA value
-     * @throws {Error} If no EMA value is available for fallback when the provider fails
+     * Fetches a value from the underlying provider with circuit breaker protection.
+     * Automatically fails fast when the circuit is open due to excessive failures.
+     * Falls back to configured fallback mechanisms if the provider fails.
+     *
+     * @returns A promise that resolves to the value from the underlying provider
+     * @throws {Error} If the circuit is open or the provider fails without a configured fallback
      */
     get() {
         return this.circuitBreaker.fire();

package/dist/provider/retryable-provider.js

@@ -10,7 +10,7 @@ export class RetryableProvider {
     /**
      * Creates a new RetryableProvider.
      * @param provider - The underlying provider to wrap with retry logic
-     * @param options - Configuration options for retry behavior
+     * @param options - Configuration options for retry behavior (retries, minTimeout, maxTimeout, factor, etc.)
      */
     constructor(provider, options) {
         this.provider = provider;

package/dist/schema/mqtt-configuration.js

@@ -29,7 +29,9 @@ export const mqttPullAdapterFeedSchema = z
     .object({
     interval: z.number().int().nonnegative(),
     device: z.string(),
-    ip: z.string(),
+    host: z.string(),
+    protocol: z.enum(['http', 'https']).default('http'),
+    port: z.number().int().min(1).max(65535).default(80),
     breaker: breakerScehema.optional(),
     retry: retrySchema.optional(),
     ema: emaSchema.optional(),

package/dist/schema/rest-configuration.js

@@ -45,8 +45,10 @@ export const em1StatusSchema = z.object({
 });
 export const restAdapterFeedSchema = z
     .object({
-    ip: z.string(),
     device: z.string(),
+    host: z.string(),
+    protocol: z.enum(['http', 'https']).default('http'),
+    port: z.number().int().min(1).max(65535).default(80),
     breaker: breakerScehema.optional(),
     retry: retrySchema.optional(),
     ema: emaSchema.optional(),

package/dist/service/rest-service.js

@@ -11,11 +11,18 @@ import { AbstractExecutableService } from './abstract-executable-service.js';
  * Implements the executable service lifecycle to start and stop the HTTP server.
  */
 export class RestService extends AbstractExecutableService {
+    /**
+     * Creates a new REST service with configured energy providers.
+     * @param gridEnergyProvider - Provider for grid energy status data (EM1 channel 0)
+     * @param solarEnergyProvider - Provider for solar energy status data (EM1 channel 1)
+     * @param properties - Configuration properties including the server port
+     */
     constructor(gridEnergyProvider, solarEnergyProvider, properties) {
         super();
         this.gridEnergyProvider = gridEnergyProvider;
         this.solarEnergyProvider = solarEnergyProvider;
         this.properties = properties;
+        /** The Fastify application instance, or null when the service is not running */
         this.app = null;
     }
     /**

package/dist/utils/mqtt.js

@@ -5,6 +5,7 @@ import { logger } from './logger.js';
  * Subscribes to lifecycle events (connect, error, reconnect) for visibility.
  *
  * @param url - MQTT broker URL (e.g., mqtt://localhost:1883)
+ * @param options - Optional connection options including username and password for authentication
  * @returns A promise that resolves to a connected MqttClient instance
  * @throws {Error} If the underlying connection fails
  */

package/dist/utils/resiliance.js

@@ -2,7 +2,18 @@ import { AsymmetricEMAProvider } from '../provider/asymmetric-ema-provider.js';
 import { CircuitBreakerProvider } from '../provider/circuit-breaker-provider.js';
 import { RetryableProvider } from '../provider/retryable-provider.js';
 import { logger } from './logger.js';
-export function createResiliantProvider(provider, interpolator, zeroValue, comparator, breakerOptions, retryOptions, emaOptions) {
+/**
+ * Creates a resilient provider by wrapping a base provider with optional circuit breaker,
+ * retry, and exponential moving average (EMA) capabilities. The providers are composed
+ * in layers: circuit breaker (outermost) → retry → EMA → base provider (innermost).
+ * This composition provides comprehensive resilience against transient failures.
+ *
+ * @template T - The type of value the provider supplies
+ * @param options - Configuration options for creating the resilient provider
+ * @returns A composed provider with the requested resilience features
+ */
+export function createResiliantProvider(options) {
+    const { provider, interpolator, zeroValue, comparator, breakerOptions, retryOptions, emaOptions, } = options;
     let result = provider;
     if (breakerOptions) {
         result = new CircuitBreakerProvider(result, breakerOptions);
@@ -36,10 +47,10 @@ export function createResiliantProvider(provider, interpolator, zeroValue, compa
     }
     if (emaOptions) {
         result = new AsymmetricEMAProvider(result, interpolator, {
-            alphaRise: emaOptions?.alphaRise,
-            alphaFall: emaOptions?.alphaFall,
-            alphaMissing: emaOptions?.alphaMissing,
-            freshnessThreshold: emaOptions?.freshnessThreshold,
+            alphaRise: emaOptions.alphaRise,
+            alphaFall: emaOptions.alphaFall,
+            alphaMissing: emaOptions.alphaMissing,
+            freshnessThreshold: emaOptions.freshnessThreshold,
             zeroValue,
             comparator,
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "v2c-any",
-  "version": "0.5.3",
+  "version": "0.6.1",
   "type": "module",
   "description": "Turn any device into V2C Dynamic Power Control",
   "main": "dist/index.js",