@aurora-blue/signalk-connector 0.2.0-dev.38 → 0.2.0-dev.41

package/README.md

@@ -132,3 +132,11 @@ The connector can publish observed own-vessel tracks through an independent, bou
 This development integration is not yet qualified for live replacement. Provider approval, actual API delivery, settings UI verification, backlog handover and onboard resource measurements remain pending. Arbitrary cron expressions, automatic import of the original queue and unlimited sent-track archives are not implemented. Ambiguous acknowledgements can cause a replay; exactly-once delivery is not claimed.
 
 See the canonical [integration and handover documentation](../aurora-blue-documentation/docs/NOFOREIGNLAND_CONNECTOR.md) and ADR-0151. Never reuse the official plugin's embedded application key or include credentials in diagnostic output.
+
+## Unpublished AC input-limit control
+
+The local inputLimitControlEnabled option defaults to false. When explicitly enabled, a paired active Connector exchanges only bounded native AC input-current-limit operations. Eligibility requires one inverter, fresh Shore source/current-limit observations, source identity, supportsPut and explicit minValue/maxValue metadata. Missing provider capabilities disable control. The source-specific PUT is sent once and success requires new matching readback; callbacks, stale data or transport retries never manufacture success. Commands are not journaled or replayed after restart. Physical equipment control qualification remains separate. Canonical policy: ADR-0271 in aurora-blue-documentation.
+
+### Equipment identity enrichment
+
+An updated paired Server must advertise equipment_identity=true before this optional collection starts. The Connector reads existing NMEA 2000 product information and may use the existing GX D-Bus ProductName reader on Linux. It associates names by received source, never by numeric instance guesses. Queries are read-only, bounded and optional; no new native dependency is installed. Only bounded product/manufacturer string fields are added to the usual durable batch, with explicit metadata provenance and a null source timestamp. Serial/firmware fields and raw frames are not collected, and opaque identifier-like names are excluded. New/changed values are captured after startup; unchanged values are not repeatedly emitted by this adapter. Standard telemetry and default-off equipment control remain independent. See ADR-0272 in the canonical documentation.

package/VERSION

@@ -1 +1 @@
-0.2.0-dev.38
+0.2.0-dev.41

package/dist/src/config.d.ts

@@ -3,6 +3,7 @@ import type { StorageProfile } from "./storage-budget";
 import type { OperatingProfile } from "./telemetry-reducer";
 import type { NoForeignLandConfig } from "./noforeignland";
 export interface ConnectorConfig {
+    inputLimitControlEnabled?: boolean;
     noforeignland?: NoForeignLandConfig;
     targetUrl: string;
     deviceName: string;
@@ -150,6 +151,12 @@ export declare const pluginSchema: {
             readonly maximum: 120000;
             readonly default: 5000;
         };
+        readonly inputLimitControlEnabled: {
+            readonly type: "boolean";
+            readonly default: false;
+            readonly title: "Allow confirmed AC input-limit changes from ABOARD";
+            readonly description: "Requires a writable provider with explicit current bounds. Never buffers or retries equipment commands.";
+        };
         readonly adaptiveTelemetryEnabled: {
             readonly type: "boolean";
             readonly title: "Reduce telemetry by change or heartbeat";

package/dist/src/config.js

@@ -157,6 +157,7 @@ const resolveConfig = (input) => {
         bufferSegmentBytes: integer(raw.bufferSegmentKilobytes, 256, 64, 2_048, "Buffer segment size in kilobytes") * 1024,
         compressionEnabled: raw.compressionEnabled !== false,
         compressionThresholdBytes: integer(raw.compressionThresholdBytes, 1_024, 256, 65_536, "Compression threshold"),
+        inputLimitControlEnabled: raw.inputLimitControlEnabled === true,
         adaptiveTelemetryEnabled: raw.adaptiveTelemetryEnabled !== false,
         operatingProfile: operatingProfile,
         anchorAlarm: {
@@ -286,6 +287,12 @@ exports.pluginSchema = {
             maximum: 120000,
             default: 5000,
         },
+        inputLimitControlEnabled: {
+            type: "boolean",
+            default: false,
+            title: "Allow confirmed AC input-limit changes from ABOARD",
+            description: "Requires a writable provider with explicit current bounds. Never buffers or retries equipment commands.",
+        },
         adaptiveTelemetryEnabled: {
             type: "boolean",
             title: "Reduce telemetry by change or heartbeat",

package/dist/src/connector.d.ts

@@ -17,10 +17,18 @@ export declare class ConnectorRuntime {
     private readonly app;
     private readonly store;
     private readonly config;
+    private energyTimer;
+    private energyExecutor;
+    private energyResult;
     private readonly bootId;
     private readonly now;
     private readonly random;
     private readonly unsubscribes;
+    private identitySupported;
+    private identityStarted;
+    private identityPolls;
+    private identityTimer;
+    private readonly identityValues;
     private timer;
     private safetyTimer;
     private runtimeConfigurationTimer;
@@ -74,6 +82,9 @@ export declare class ConnectorRuntime {
     private publishAnchorTransition;
     private publishAnchorState;
     private schedule;
+    private startEquipmentIdentity;
+    private startEnergyControl;
+    private pollEnergyControl;
     private scheduleRuntimeConfigurationPoll;
     private pollRuntimeConfiguration;
     private requirePairing;

package/dist/src/connector.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConnectorRuntime = exports.CONNECTOR_VERSION = void 0;
+const equipment_identity_1 = require("./equipment-identity");
+const energy_control_1 = require("./energy-control");
 const node_path_1 = require("node:path");
 const noforeignland_1 = require("./noforeignland");
 const node_crypto_1 = require("node:crypto");
@@ -29,10 +31,18 @@ class ConnectorRuntime {
     app;
     store;
     config;
+    energyTimer = null;
+    energyExecutor = null;
+    energyResult = null;
     bootId;
     now;
     random;
     unsubscribes = [];
+    identitySupported = false;
+    identityStarted = false;
+    identityPolls = 0;
+    identityTimer = null;
+    identityValues = new Map();
     timer = null;
     safetyTimer = null;
     runtimeConfigurationTimer = null;
@@ -180,6 +190,8 @@ class ConnectorRuntime {
         this.startSafetyTimer();
         await this.updateStatus();
         this.scheduleRuntimeConfigurationPoll(0);
+        this.startEnergyControl();
+        this.startEquipmentIdentity();
         if (this.operatingMode !== "disabled") {
             this.schedule(0);
         }
@@ -189,6 +201,11 @@ class ConnectorRuntime {
     }
     async stop() {
         this.stopped = true;
+        if (this.identityTimer)
+            clearTimeout(this.identityTimer);
+        this.energyExecutor?.stop();
+        if (this.energyTimer)
+            clearTimeout(this.energyTimer);
         if (this.timer !== null) {
             clearTimeout(this.timer);
             this.timer = null;
@@ -213,7 +230,7 @@ class ConnectorRuntime {
             return;
         }
         const receivedAt = this.now();
-        const events = (0, delta_1.eventsFromDelta)(delta, this.bootId, receivedAt, subscriptionScope);
+        const events = (0, delta_1.eventsFromDelta)(delta, this.bootId, receivedAt, subscriptionScope).filter((event) => this.identitySupported || !(0, equipment_identity_1.isEquipmentIdentityPath)(event.path));
         for (const event of events)
             this.publisher?.observe(event);
         // Safety observes current positions immediately, even when historical
@@ -541,6 +558,95 @@ class ConnectorRuntime {
             void this.flush();
         }, delay);
     }
+    startEquipmentIdentity() {
+        if (!this.identitySupported ||
+            this.identityStarted ||
+            !this.autoSchedule ||
+            this.stopped)
+            return;
+        this.identityStarted = true;
+        const poll = async () => {
+            try {
+                if (this.identitySupported &&
+                    this.pairingState === "paired" &&
+                    this.operatingMode === "active") {
+                    const identities = await (0, equipment_identity_1.equipmentIdentities)(this.app.getSelfPath("electrical"), typeof this.app.getPath === "function"
+                        ? this.app.getPath("/sources")
+                        : {});
+                    for (const identity of identities) {
+                        if (this.stopped ||
+                            !this.identitySupported ||
+                            this.operatingMode !== "active")
+                            break;
+                        const key = identity.path + "\0" + identity.source;
+                        if (this.identityValues.get(key) === identity.value)
+                            continue;
+                        await this.capture({
+                            context: "vessels.self",
+                            updates: [
+                                {
+                                    $source: identity.source,
+                                    values: [{ path: identity.path, value: identity.value }],
+                                },
+                            ],
+                        });
+                        this.identityValues.set(key, identity.value);
+                        if (this.identityValues.size > 384)
+                            this.identityValues.delete(this.identityValues.keys().next().value);
+                    }
+                }
+            }
+            catch {
+                /* Optional identity reads never interrupt ordinary telemetry. */
+            }
+            if (!this.stopped)
+                this.identityTimer = setTimeout(() => {
+                    void poll();
+                }, this.identityPolls++ < 5 ? 30_000 : 600_000);
+        };
+        void poll();
+    }
+    startEnergyControl() {
+        if (this.stopped ||
+            this.energyExecutor ||
+            !this.config.inputLimitControlEnabled ||
+            !this.autoSchedule)
+            return;
+        this.energyExecutor = new energy_control_1.InputLimitExecutor(this.app, this.bootId, () => !this.stopped &&
+            this.pairingState === "paired" &&
+            this.operatingMode === "active");
+        void this.pollEnergyControl();
+    }
+    async pollEnergyControl() {
+        if (this.stopped ||
+            !this.energyExecutor ||
+            !this.client?.exchangeEnergyControl)
+            return;
+        try {
+            const state = await this.store.summary();
+            if (state.access_token &&
+                state.target_url === this.config.targetUrl &&
+                this.pairingState === "paired") {
+                const requestedAt = Date.now();
+                const response = await this.client.exchangeEnergyControl(state.access_token, {
+                    session: this.bootId,
+                    capability: this.energyExecutor.capability(),
+                    result: this.energyResult,
+                });
+                this.energyResult = null;
+                if (response.command && !this.stopped) {
+                    this.energyResult = await this.energyExecutor.execute(response.command, new Date(Date.parse(response.server_time) + Date.now() - requestedAt).toISOString());
+                }
+            }
+        }
+        catch {
+            /* Never repeat an equipment write after uncertain transport. */
+        }
+        if (!this.stopped)
+            this.energyTimer = setTimeout(() => {
+                void this.pollEnergyControl();
+            }, 5000);
+    }
     scheduleRuntimeConfigurationPoll(delay) {
         if (this.stopped || !this.autoSchedule) {
             return;
@@ -573,6 +679,8 @@ class ConnectorRuntime {
             }
             this.pairingState = "paired";
             await this.applyRuntimeConfiguration(response.runtime_configuration);
+            this.startEnergyControl();
+            this.startEquipmentIdentity();
             if (this.unsubscribes.length === 0) {
                 this.operatingMode = response.runtime_configuration.operating_mode;
                 this.configureSubscriptions();
@@ -618,6 +726,7 @@ class ConnectorRuntime {
         await this.updateStatus();
     }
     async applyRuntimeConfiguration(configuration) {
+        this.identitySupported = configuration.equipment_identity === true;
         const previousMode = this.operatingMode;
         this.runtimeConfigurationPollMs = configuration.poll_after_seconds * 1_000;
         this.runtimeConfigurationState = "current";

package/dist/src/energy-control.d.ts

@@ -0,0 +1,47 @@
+import type { ServerAPI } from "@signalk/server-api";
+export interface InputLimitCapability {
+    path: string;
+    source: string;
+    value: number;
+    minimum: number;
+    maximum: number;
+}
+export interface InputLimitCommand {
+    installation_maximum: number;
+    configuration_version: number;
+    id: string;
+    session: string;
+    path: string;
+    source: string;
+    previous_value: number;
+    value: number;
+    expires_at: string;
+}
+export interface InputLimitResult {
+    id: string;
+    state: "completed" | "rejected" | "unconfirmed";
+}
+export interface EnergyControlExchange {
+    session: string;
+    capability: InputLimitCapability | null;
+    result: InputLimitResult | null;
+}
+export interface EnergyControlResponse {
+    command: InputLimitCommand | null;
+    server_time: string;
+}
+/** Only an explicitly writable, bounded, fresh native AC input is eligible. */
+export declare function inputLimitCapability(app: ServerAPI, now?: number): InputLimitCapability | null;
+export declare class InputLimitExecutor {
+    private readonly app;
+    private readonly session;
+    private readonly active;
+    private readonly now;
+    private readonly wait;
+    private stopped;
+    private readonly seen;
+    constructor(app: ServerAPI, session: string, active: () => boolean, now?: () => number, wait?: (ms: number) => Promise<void>);
+    stop(): void;
+    capability(): InputLimitCapability | null;
+    execute(command: InputLimitCommand, serverTime: string): Promise<InputLimitResult>;
+}

package/dist/src/energy-control.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InputLimitExecutor = void 0;
+exports.inputLimitCapability = inputLimitCapability;
+const presets = [6, 10, 16, 20, 25, 32];
+const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value)
+    ? value
+    : {};
+/** Only an explicitly writable, bounded, fresh native AC input is eligible. */
+function inputLimitCapability(app, now = Date.now()) {
+    const source = record(app.getSelfPath("electrical.venus.acSource"));
+    const fresh = (leaf) => typeof leaf.timestamp === "string" &&
+        Date.parse(leaf.timestamp) <= now + 30000 &&
+        now - Date.parse(leaf.timestamp) < 120000;
+    if (source.value !== "shore" || !fresh(source))
+        return null;
+    const inverters = Object.keys(record(app.getSelfPath("electrical.inverters")));
+    if (inverters.length !== 1 || !/^[A-Za-z0-9_:-]+$/.test(inverters[0]))
+        return null;
+    const path = `electrical.inverters.${inverters[0]}.acin.currentLimit`;
+    const leaf = record(app.getSelfPath(path));
+    const meta = record(leaf.meta);
+    if (meta.supportsPut !== true ||
+        !fresh(leaf) ||
+        typeof leaf.$source !== "string" ||
+        !leaf.$source ||
+        typeof leaf.value !== "number" ||
+        !Number.isFinite(leaf.value) ||
+        typeof meta.minValue !== "number" ||
+        !Number.isFinite(meta.minValue) ||
+        meta.minValue < 0 ||
+        typeof meta.maxValue !== "number" ||
+        !Number.isFinite(meta.maxValue) ||
+        meta.maxValue < meta.minValue ||
+        meta.maxValue > 1000 ||
+        leaf.value < meta.minValue ||
+        leaf.value > meta.maxValue)
+        return null;
+    return {
+        path,
+        source: leaf.$source,
+        value: leaf.value,
+        minimum: meta.minValue,
+        maximum: meta.maxValue,
+    };
+}
+class InputLimitExecutor {
+    app;
+    session;
+    active;
+    now;
+    wait;
+    stopped = false;
+    seen = new Set();
+    constructor(app, session, active, now = Date.now, wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms))) {
+        this.app = app;
+        this.session = session;
+        this.active = active;
+        this.now = now;
+        this.wait = wait;
+    }
+    stop() {
+        this.stopped = true;
+    }
+    capability() {
+        return !this.stopped && this.active()
+            ? inputLimitCapability(this.app, this.now())
+            : null;
+    }
+    async execute(command, serverTime) {
+        const reject = { id: command.id, state: "rejected" };
+        const remaining = Date.parse(command.expires_at) - Date.parse(serverTime);
+        const cap = this.capability();
+        if (!cap ||
+            this.seen.has(command.id) ||
+            command.session !== this.session ||
+            !Number.isFinite(remaining) ||
+            remaining <= 0 ||
+            remaining > 20000 ||
+            cap.path !== command.path ||
+            cap.source !== command.source ||
+            Math.abs(cap.value - command.previous_value) > 0.01 ||
+            !Number.isFinite(command.installation_maximum) ||
+            command.installation_maximum <= 0 ||
+            !Number.isInteger(command.configuration_version) ||
+            command.configuration_version < 1 ||
+            command.value > command.installation_maximum ||
+            !(presets.includes(command.value) ||
+                Math.abs(command.value - Math.min(command.installation_maximum, cap.maximum)) < 0.01) ||
+            command.value < cap.minimum ||
+            command.value > cap.maximum)
+            return reject;
+        this.seen.add(command.id);
+        if (this.seen.size > 64)
+            this.seen.delete(this.seen.values().next().value);
+        const started = this.now();
+        let failed = false;
+        try {
+            // Dispatch exactly once. A callback alone never proves equipment readback.
+            void Promise.resolve(this.app.putPath(`vessels.self.${cap.path}`, command.value, (error) => {
+                if (error)
+                    failed = true;
+            }, cap.source)).catch(() => {
+                failed = true;
+            });
+        }
+        catch {
+            return reject;
+        }
+        for (let attempt = 0; attempt < Math.min(32, Math.floor(remaining / 250)); attempt++) {
+            await this.wait(250);
+            if (this.stopped || !this.active() || failed)
+                return { id: command.id, state: "unconfirmed" };
+            const current = this.capability();
+            const leaf = record(this.app.getSelfPath(cap.path));
+            if (!current ||
+                current.path !== cap.path ||
+                current.source !== cap.source)
+                return { id: command.id, state: "unconfirmed" };
+            if (Math.abs(current.value - command.value) < 0.01 &&
+                typeof leaf.timestamp === "string" &&
+                Date.parse(leaf.timestamp) >= started)
+                return { id: command.id, state: "completed" };
+        }
+        return { id: command.id, state: "unconfirmed" };
+    }
+}
+exports.InputLimitExecutor = InputLimitExecutor;

package/dist/src/equipment-identity.d.ts

@@ -0,0 +1,10 @@
+export interface EquipmentIdentity {
+    path: string;
+    value: string;
+    source: string;
+}
+/** Optional GX adapter. Fixed executable, fixed read-only method, no shell or writes. */
+export declare function readVictronProductName(service: string): Promise<string | null>;
+/** Capture identity only for received electrical sources, plus identified GX controllers. */
+export declare function equipmentIdentities(electrical: unknown, sources: unknown, readProduct?: typeof readVictronProductName): Promise<EquipmentIdentity[]>;
+export declare const isEquipmentIdentityPath: (path: string) => boolean;

package/dist/src/equipment-identity.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEquipmentIdentityPath = void 0;
+exports.readVictronProductName = readVictronProductName;
+exports.equipmentIdentities = equipmentIdentities;
+const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = require("node:crypto");
+const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value)
+    ? value
+    : {};
+const text = (value) => typeof value === "string" &&
+    value.trim() &&
+    value.length <= 120 &&
+    !/[\x00-\x1f]/.test(value)
+    ? value.trim()
+    : null;
+const productText = (value) => {
+    const name = text(value);
+    return name && !/^[A-Za-z0-9]{12,}$/.test(name) ? name : null;
+};
+const servicePattern = /^com\.victronenergy\.(?:vebus|solarcharger|battery|charger|alternator)\.[A-Za-z0-9_]{1,100}$/;
+/** Optional GX adapter. Fixed executable, fixed read-only method, no shell or writes. */
+function readVictronProductName(service) {
+    if (process.platform !== "linux" || !servicePattern.test(service))
+        return Promise.resolve(null);
+    return new Promise((resolve) => {
+        (0, node_child_process_1.execFile)("/usr/bin/dbus-send", [
+            "--system",
+            "--print-reply",
+            `--dest=${service}`,
+            "/ProductName",
+            "com.victronenergy.BusItem.GetValue",
+        ], { timeout: 1500, maxBuffer: 8192 }, (error, stdout) => {
+            if (error)
+                return resolve(null);
+            const match = /variant\s+string\s+("(?:[^"\\]|\\.)*")/.exec(stdout);
+            try {
+                resolve(match ? productText(JSON.parse(match[1])) : null);
+            }
+            catch {
+                resolve(null);
+            }
+        });
+    });
+}
+/** Capture identity only for received electrical sources, plus identified GX controllers. */
+async function equipmentIdentities(electrical, sources, readProduct = readVictronProductName) {
+    const found = [];
+    const nmea = new Map();
+    for (const [provider, collection] of Object.entries(record(sources)).slice(0, 64)) {
+        for (const [address, device] of Object.entries(record(collection)).slice(0, 128)) {
+            const identity = record(record(device).n2k);
+            const model = productText(identity.modelId ?? identity["Model ID"]);
+            if (!model)
+                continue;
+            nmea.set(`${provider}.${address}`, {
+                model,
+                manufacturer: text(identity.manufacturerCode ?? identity["Manufacturer Code"]),
+                stable: `${provider}:${text(identity.canName) ?? address}`,
+            });
+        }
+    }
+    const products = new Map();
+    for (const group of [
+        "inverters",
+        "chargers",
+        "solar",
+        "batteries",
+        "alternators",
+    ]) {
+        for (const [instance, raw] of Object.entries(record(record(electrical)[group])).slice(0, 32)) {
+            if (!/^[A-Za-z0-9_:-]{1,80}$/.test(instance))
+                continue;
+            const upstream = new Set();
+            const visit = (node, depth) => {
+                if (depth > 3)
+                    return;
+                const item = record(node);
+                if (typeof item.$source === "string")
+                    upstream.add(item.$source);
+                for (const child of Object.values(item))
+                    if (child && typeof child === "object")
+                        visit(child, depth + 1);
+            };
+            visit(raw, 0);
+            // An aggregate with competing providers cannot establish one product identity.
+            if (upstream.size !== 1)
+                continue;
+            const source = [...upstream][0];
+            const native = nmea.get(source);
+            let model = native?.model ?? null;
+            let manufacturer = native?.manufacturer ?? null;
+            let provenance = `aboard.metadata.nmea2000:${source}`;
+            const service = source.startsWith("venus.") ? source.slice(6) : "";
+            if (servicePattern.test(service)) {
+                if (!products.has(service) && products.size < 16)
+                    products.set(service, readProduct(service));
+                model = productText(await products.get(service));
+                manufacturer =
+                    model &&
+                        /^(?:Quattro|MultiPlus|EasySolar|SmartSolar|BlueSolar|Lynx Shunt|SmartShunt|BMV(?:-|\s))/i.test(model)
+                        ? "Victron Energy"
+                        : null;
+                provenance = `aboard.metadata.dbus:${service}`;
+            }
+            if (!model)
+                continue;
+            const base = `electrical.${group}.${instance}`;
+            found.push({
+                path: `${base}.productName`,
+                value: model,
+                source: provenance,
+            });
+            if (manufacturer)
+                found.push({
+                    path: `${base}.manufacturer`,
+                    value: manufacturer,
+                    source: provenance,
+                });
+        }
+    }
+    for (const [source, identity] of nmea) {
+        if (identity.manufacturer !== "Victron Energy" ||
+            !/^(?:Ekrano GX|Cerbo GX(?: MK2)?|Venus GX|Color Control GX|Octo GX)$/i.test(identity.model))
+            continue;
+        const id = (0, node_crypto_1.createHash)("sha256")
+            .update(identity.stable)
+            .digest("hex")
+            .slice(0, 16);
+        const base = `electrical.controllers.n2k_${id}`;
+        found.push({
+            path: `${base}.productName`,
+            value: identity.model,
+            source: `aboard.metadata.nmea2000:${source}`,
+        });
+        found.push({
+            path: `${base}.manufacturer`,
+            value: identity.manufacturer,
+            source: `aboard.metadata.nmea2000:${source}`,
+        });
+    }
+    return found.slice(0, 192);
+}
+const isEquipmentIdentityPath = (path) => /^electrical\.(?:inverters|chargers|solar|batteries|alternators|controllers)\.[A-Za-z0-9_:-]+\.(?:productName|manufacturer)$/.test(path);
+exports.isEquipmentIdentityPath = isEquipmentIdentityPath;

package/dist/src/http-client.d.ts

@@ -1,5 +1,7 @@
+import type { EnergyControlExchange, EnergyControlResponse } from "./energy-control";
 import { type IngestAcknowledgement, type IngestBatch, type PairingResponse, type RuntimeConfigurationResponse } from "./types";
 export interface AuroraBlueClient {
+    exchangeEnergyControl?(accessToken: string, data: EnergyControlExchange): Promise<EnergyControlResponse>;
     pair(pairingCode: string, deviceName: string, connectorVersion: string): Promise<PairingResponse>;
     sendBatch(batch: IngestBatch, accessToken: string): Promise<IngestAcknowledgement>;
     fetchRuntimeConfiguration(accessToken: string): Promise<RuntimeConfigurationResponse>;
@@ -17,6 +19,7 @@ export declare class AuroraBlueHttpClient implements AuroraBlueClient {
     pair(pairingCode: string, deviceName: string, connectorVersion: string): Promise<PairingResponse>;
     sendBatch(batch: IngestBatch, accessToken: string): Promise<IngestAcknowledgement>;
     fetchRuntimeConfiguration(accessToken: string): Promise<RuntimeConfigurationResponse>;
+    exchangeEnergyControl(accessToken: string, data: EnergyControlExchange): Promise<EnergyControlResponse>;
     private request;
     private readJson;
 }

package/dist/src/http-client.js

@@ -14,7 +14,9 @@ const runtimeConfigurationFrom = (value) => {
         return defaultRuntimeConfiguration();
     }
     const configuration = value;
-    if (typeof configuration.version !== "number" ||
+    if ((configuration.equipment_identity !== undefined &&
+        typeof configuration.equipment_identity !== "boolean") ||
+        typeof configuration.version !== "number" ||
         !Number.isInteger(configuration.version) ||
         configuration.version < 1 ||
         !["active", "standby", "disabled"].includes(String(configuration.operating_mode)) ||
@@ -104,6 +106,18 @@ class AuroraBlueHttpClient {
             server_time: response.server_time,
         };
     }
+    async exchangeEnergyControl(accessToken, data) {
+        const response = await this.request("/api/v1/devices/self/energy-control", {
+            method: "POST",
+            headers: { Authorization: `Bearer ${accessToken}` },
+            body: JSON.stringify(data),
+        });
+        if (typeof response.server_time !== "string" ||
+            !Number.isFinite(Date.parse(response.server_time))) {
+            throw new Error("Invalid energy-control response.");
+        }
+        return response;
+    }
     async request(path, init) {
         const abort = new AbortController();
         const timeout = setTimeout(() => abort.abort(), this.timeoutMs);

package/dist/src/telemetry-catalog.js

@@ -21,6 +21,14 @@ const ais = (path, valueKind, changeKind, minimumIntervalMs, maximumHeartbeatMs,
     changeThreshold,
 });
 exports.SELF_TELEMETRY = [
+    ...[
+        "inverters",
+        "chargers",
+        "solar",
+        "batteries",
+        "alternators",
+        "controllers",
+    ].flatMap((group) => ["productName", "manufacturer"].map((field) => self(`electrical.${group}.*.${field}`, "string", "identity", 0, 600_000, 0))),
     // GX-owned sensor names and SI readings need no per-installation path mapping.
     self("environment.venus.*.name", "string", "identity", 0, 600_000, 0),
     self("environment.venus.*.temperature", "number", "scalar", 30_000, 60_000, 0.2),

package/dist/src/types.d.ts

@@ -5,6 +5,7 @@ export type ProtocolVersion = (typeof SUPPORTED_PROTOCOL_VERSIONS)[number];
 export type OperatingMode = "active" | "standby" | "disabled";
 export type PairingState = "unpaired" | "verifying" | "paired" | "pairing-required";
 export interface RuntimeConfiguration {
+    equipment_identity?: boolean;
     version: number;
     operating_mode: OperatingMode;
     poll_after_seconds: number;

package/dist/src/version.d.ts

@@ -1 +1 @@
-export declare const CONNECTOR_VERSION = "0.2.0-dev.38";
+export declare const CONNECTOR_VERSION = "0.2.0-dev.41";

package/dist/src/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CONNECTOR_VERSION = void 0;
-exports.CONNECTOR_VERSION = "0.2.0-dev.38";
+exports.CONNECTOR_VERSION = "0.2.0-dev.41";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aurora-blue/signalk-connector",
-  "version": "0.2.0-dev.38",
+  "version": "0.2.0-dev.41",
   "description": "Signal K edge connector for the Aurora Blue ABOARD ingest protocol",
   "private": false,
   "main": "dist/src/index.js",