@aurora-blue/signalk-connector 0.2.0-dev.40 → 0.2.0-dev.42

package/README.md

@@ -51,7 +51,7 @@ Select Aurora Blue ABOARD Connector Status under Signal K Webapps for the cross-
 
 The connector exchanges the pairing code once and clears it from the Signal K plugin configuration after successful pairing. The returned device token is stored only in the protected connector state file and is never written to logs. The pairing is bound to the configured target URL. Changing that URL requires a new pairing code and pauses collection and transfer until the replacement pairing succeeds. The configuration and status page warn that a successful replacement permanently discards telemetry buffered for the previous server. A failed pairing attempt retains the existing pairing and buffer.
 
-The default configuration sends up to 250 events per batch, waits up to five seconds to combine normal telemetry, samples own-vessel Signal K paths every second, samples selected AIS paths every five seconds, and enables the preliminary underway change-or-heartbeat profile. Navigation, performance, steering observations, wind, depth, current, tide, outside weather, water and heave are captured independently of displayed fields. Additional scoped family paths preserve bounded structured source values, with a two-second minimum change interval and 60-second heartbeat under normal storage pressure. Ground- and water-referenced true wind remain separate. Deploy compatible Server acceptance before this Connector expansion; older Servers reject unsupported paths. See the [canonical acquisition decision](../aurora-blue-documentation/docs/decisions/ADR-0153-display-independent-navigation-capture.md). AIS can be disabled independently. The `auto` storage profile selects a constrained, standard, or extended byte budget from filesystem capacity while preserving a free-space reserve. Its effective event limit is derived from measured journal bytes per event instead of a fixed 10,000-event default. Protocol 1.1 permits no more than 500 events per batch, and the server continues to accept exact protocol 1.0 backlog batches during upgrades.
+The default configuration sends up to 250 events per batch, waits up to one second to combine normal telemetry, samples own-vessel Signal K paths every second, samples selected AIS paths every five seconds, and enables the preliminary underway change-or-heartbeat profile. Navigation, performance, steering observations, wind, depth, current, tide, outside weather, water and heave are captured independently of displayed fields. Additional scoped family paths preserve bounded structured source values, with a two-second minimum change interval and 60-second heartbeat under normal storage pressure. Ground- and water-referenced true wind remain separate. Deploy compatible Server acceptance before this Connector expansion; older Servers reject unsupported paths. See the [canonical acquisition decision](../aurora-blue-documentation/docs/decisions/ADR-0153-display-independent-navigation-capture.md). Critical DC voltage/current/power changes use a one-second minimum admission interval with thresholds of 0.005 V, 0.01 A and 0.5 W. Unchanged DC observations retain a 20-second real-observation heartbeat. Empty flushes send no HTTP batch, explicit operator transfer intervals remain respected, and source timestamps are never refreshed from cached values. AIS can be disabled independently. The `auto` storage profile selects a constrained, standard, or extended byte budget from filesystem capacity while preserving a free-space reserve. Its effective event limit is derived from measured journal bytes per event instead of a fixed 10,000-event default. Protocol 1.1 permits no more than 500 events per batch, and the server continues to accept exact protocol 1.0 backlog batches during upgrades.
 
 The connector also subscribes to scalar values below `electrical.switches.*`, including separate channels on multi-output devices. Switch paths use the instant subscription policy so a periodic retransmission of a cached Signal K value is not mistaken for fresh device evidence. The server may use selected `.state` leaves for conservative equipment-runtime estimates. A silent or unpowered device stops contributing runtime after a short bounded interval; accurate long-running counters require a qualified device-originated liveness source.
 
@@ -135,4 +135,8 @@ See the canonical [integration and handover documentation](../aurora-blue-docume
 
 ## 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. This local implementation is not a published release or physical equipment qualification. Canonical policy: ADR-0266 in aurora-blue-documentation.
+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.40
+0.2.0-dev.42

package/dist/src/config.js

@@ -137,7 +137,7 @@ const resolveConfig = (input) => {
             : undefined,
         allowInsecureHttp,
         batchSize: integer(raw.batchSize, 250, 1, 500, "Batch size"),
-        flushIntervalMs: integer(raw.flushIntervalMs, 5_000, 250, 60_000, "Flush interval"),
+        flushIntervalMs: integer(raw.flushIntervalMs, 1_000, 250, 60_000, "Flush interval"),
         samplePeriodMs: integer(raw.samplePeriodMs, 1_000, 250, 60_000, "Sample period"),
         aisEnabled: raw.aisEnabled !== false,
         aisSamplePeriodMs: integer(raw.aisSamplePeriodMs, 5_000, 1_000, 120_000, "AIS sample period"),

package/dist/src/connector.d.ts

@@ -24,6 +24,16 @@ export declare class ConnectorRuntime {
     private readonly now;
     private readonly random;
     private readonly unsubscribes;
+    private identitySupported;
+    private nmeaEnergySupported;
+    private readonly nmeaEnergy;
+    private acTotalSupported;
+    private victronInputLimitSupported;
+    private stopVictronInputLimit;
+    private identityStarted;
+    private identityPolls;
+    private identityTimer;
+    private readonly identityValues;
     private timer;
     private safetyTimer;
     private runtimeConfigurationTimer;
@@ -77,11 +87,13 @@ export declare class ConnectorRuntime {
     private publishAnchorTransition;
     private publishAnchorState;
     private schedule;
+    private startEquipmentIdentity;
     private startEnergyControl;
     private pollEnergyControl;
     private scheduleRuntimeConfigurationPoll;
     private pollRuntimeConfiguration;
     private requirePairing;
+    private startVictronInputLimit;
     private applyRuntimeConfiguration;
     private updateStatus;
     private storageBudgetPolicy;

package/dist/src/connector.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConnectorRuntime = exports.CONNECTOR_VERSION = void 0;
+const nmea_energy_1 = require("./nmea-energy");
+const victron_input_limit_1 = require("./victron-input-limit");
+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");
@@ -37,6 +40,16 @@ class ConnectorRuntime {
     now;
     random;
     unsubscribes = [];
+    identitySupported = false;
+    nmeaEnergySupported = false;
+    nmeaEnergy = new nmea_energy_1.NmeaEnergy();
+    acTotalSupported = false;
+    victronInputLimitSupported = false;
+    stopVictronInputLimit = null;
+    identityStarted = false;
+    identityPolls = 0;
+    identityTimer = null;
+    identityValues = new Map();
     timer = null;
     safetyTimer = null;
     runtimeConfigurationTimer = null;
@@ -185,6 +198,8 @@ class ConnectorRuntime {
         await this.updateStatus();
         this.scheduleRuntimeConfigurationPoll(0);
         this.startEnergyControl();
+        this.startEquipmentIdentity();
+        this.startVictronInputLimit();
         if (this.operatingMode !== "disabled") {
             this.schedule(0);
         }
@@ -194,6 +209,10 @@ class ConnectorRuntime {
     }
     async stop() {
         this.stopped = true;
+        this.stopVictronInputLimit?.();
+        this.stopVictronInputLimit = null;
+        if (this.identityTimer)
+            clearTimeout(this.identityTimer);
         this.energyExecutor?.stop();
         if (this.energyTimer)
             clearTimeout(this.energyTimer);
@@ -221,7 +240,13 @@ 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)) &&
+            (this.nmeaEnergySupported ||
+                !/^electrical\.(?:solar|inverters)\.n2k_[a-f0-9]{32}\./.test(event.path)) &&
+            (this.victronInputLimitSupported ||
+                !event.path.endsWith(".activeInputCurrentLimit")) &&
+            (this.acTotalSupported ||
+                !/^electrical\.ac\.[A-Za-z0-9_:-]+\.total\.realPower$/.test(event.path)));
         for (const event of events)
             this.publisher?.observe(event);
         // Safety observes current positions immediately, even when historical
@@ -549,6 +574,54 @@ 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 ||
@@ -623,6 +696,7 @@ 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();
@@ -667,7 +741,58 @@ class ConnectorRuntime {
         this.startSafetyTimer();
         await this.updateStatus();
     }
+    startVictronInputLimit() {
+        const events = this.app;
+        if (!events.on || !events.removeListener || this.stopVictronInputLimit)
+            return;
+        const listener = (message) => {
+            if (this.stopped ||
+                (!this.victronInputLimitSupported && !this.nmeaEnergySupported) ||
+                this.pairingState !== "paired" ||
+                this.operatingMode !== "active")
+                return;
+            if (this.nmeaEnergySupported) {
+                for (const observation of this.nmeaEnergy.observe(message, this.app.getPath("/sources"), Date.parse(this.now()))) {
+                    this.app.handleMessage("aurora-blue-signalk-connector", {
+                        context: "vessels.self",
+                        updates: [
+                            {
+                                timestamp: observation.at,
+                                $source: observation.source,
+                                values: [
+                                    { path: observation.path, value: observation.value },
+                                ],
+                            },
+                        ],
+                    });
+                }
+            }
+            if (!this.victronInputLimitSupported)
+                return;
+            const sample = (0, victron_input_limit_1.victronInputLimit)(message, this.app.getPath("/sources"), this.app.getSelfPath("electrical"), Date.parse(this.now()));
+            if (!sample)
+                return;
+            this.app.handleMessage("aurora-blue-signalk-connector", {
+                context: "vessels.self",
+                updates: [
+                    {
+                        timestamp: sample.at,
+                        $source: sample.source,
+                        values: [{ path: sample.path, value: sample.value }],
+                    },
+                ],
+            });
+        };
+        events.on("N2KAnalyzerOut", listener);
+        this.stopVictronInputLimit = () => events.removeListener("N2KAnalyzerOut", listener);
+    }
     async applyRuntimeConfiguration(configuration) {
+        this.identitySupported = configuration.equipment_identity === true;
+        this.nmeaEnergySupported = configuration.nmea_energy === true;
+        this.acTotalSupported = configuration.ac_total_power === true;
+        this.victronInputLimitSupported =
+            configuration.victron_input_limit === true;
+        this.startVictronInputLimit();
         const previousMode = this.operatingMode;
         this.runtimeConfigurationPollMs = configuration.poll_after_seconds * 1_000;
         this.runtimeConfigurationState = "current";

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

@@ -0,0 +1,12 @@
+export interface EquipmentIdentity {
+    path: string;
+    value: string;
+    source: string;
+}
+/** Protocol NAME, not model text or bus address, identifies duplicate receive paths. */
+export declare function nmeaPhysicalIdentity(value: unknown): string | null;
+/** 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,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEquipmentIdentityPath = void 0;
+exports.nmeaPhysicalIdentity = nmeaPhysicalIdentity;
+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}$/;
+/** Protocol NAME, not model text or bus address, identifies duplicate receive paths. */
+function nmeaPhysicalIdentity(value) {
+    const name = text(value);
+    if (!name)
+        return null;
+    let normalized;
+    try {
+        if (/^(?:0x)?[0-9a-fA-F]{16}$/.test(name))
+            normalized = BigInt("0x" + name.replace(/^0x/, ""));
+        else if (/^[0-9]{1,20}$/.test(name))
+            normalized = BigInt(name);
+        else
+            return null;
+    }
+    catch {
+        return null;
+    }
+    if (normalized <= 0n || normalized > 0xffffffffffffffffn)
+        return null;
+    return (0, node_crypto_1.createHash)("sha256")
+        .update("nmea2000:" + normalized.toString(16).padStart(16, "0"))
+        .digest("hex")
+        .slice(0, 32);
+}
+/** 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}`,
+                functionCode: identity.deviceFunction,
+                physicalIdentity: nmeaPhysicalIdentity(identity.canName),
+            });
+        }
+    }
+    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,
+                });
+        }
+    }
+    // Reuse the existing AC name contract; never infer input/output from bus numbers.
+    for (const [instance, raw] of Object.entries(record(record(electrical).ac)).slice(0, 32)) {
+        if (!/^[A-Za-z0-9_:-]{1,80}$/.test(instance))
+            continue;
+        const node = record(raw);
+        if (text(record(node.name).value))
+            continue;
+        const upstream = new Set();
+        const visit = (value, depth) => {
+            if (depth > 3)
+                return;
+            const item = record(value);
+            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);
+        if (upstream.size !== 1)
+            continue;
+        const source = [...upstream][0];
+        const identity = nmea.get(source);
+        if (!identity || identity.manufacturer !== "Victron Energy")
+            continue;
+        // Victron's established function mapping reverses the generic NMEA labels.
+        const role = identity.functionCode === 153
+            ? "AC output"
+            : identity.functionCode === 154
+                ? "AC input"
+                : null;
+        if (!role)
+            continue;
+        found.push({
+            path: `electrical.ac.${instance}.name`,
+            value: `Victron Energy - ${identity.model.slice(0, 85)} - ${role}`,
+            source: `aboard.metadata.nmea2000:${identity.functionCode === 153 ? "output" : "input"}:${identity.physicalIdentity ? "n2k_" + identity.physicalIdentity + ":" : ""}${source}`,
+        });
+    }
+    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.js

@@ -14,7 +14,15 @@ const runtimeConfigurationFrom = (value) => {
         return defaultRuntimeConfiguration();
     }
     const configuration = value;
-    if (typeof configuration.version !== "number" ||
+    if ((configuration.nmea_energy !== undefined &&
+        typeof configuration.nmea_energy !== "boolean") ||
+        (configuration.victron_input_limit !== undefined &&
+            typeof configuration.victron_input_limit !== "boolean") ||
+        (configuration.ac_total_power !== undefined &&
+            typeof configuration.ac_total_power !== "boolean") ||
+        (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)) ||

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

@@ -0,0 +1,13 @@
+export interface NmeaEnergyObservation {
+    path: string;
+    value: number | string;
+    source: string;
+    at: string;
+}
+/** Receive-only normalization. Device NAME and DC type separate shared data instances. */
+export declare class NmeaEnergy {
+    private readonly dcTypes;
+    private readonly inverterDcInstances;
+    private readonly states;
+    observe(message: unknown, sources: unknown, now: number): NmeaEnergyObservation[];
+}

package/dist/src/nmea-energy.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NmeaEnergy = void 0;
+const equipment_identity_1 = require("./equipment-identity");
+const object = (value) => value !== null && typeof value === "object" && !Array.isArray(value)
+    ? value
+    : {};
+const victron = (value) => value === 358 || value === "Victron Energy";
+/** Receive-only normalization. Device NAME and DC type separate shared data instances. */
+class NmeaEnergy {
+    dcTypes = new Map();
+    inverterDcInstances = new Map();
+    states = new Map();
+    observe(message, sources, now) {
+        const pgn = object(message), fields = object(pgn.fields);
+        if (![127506, 127508, 127507, 127509].includes(Number(pgn.pgn)) ||
+            pgn.direction !== "R" ||
+            pgn.dst !== 255 ||
+            !Number.isInteger(pgn.src) ||
+            Number(pgn.src) < 0 ||
+            Number(pgn.src) > 252)
+            return [];
+        const at = typeof pgn.timestamp === "string" ? pgn.timestamp : "", clock = Date.parse(at);
+        if (!Number.isFinite(clock) || clock > now + 30000 || now - clock > 120000)
+            return [];
+        const providers = Object.entries(object(sources))
+            .slice(0, 64)
+            .flatMap(([provider, collection]) => {
+            const raw = object(object(collection)[String(pgn.src)]);
+            return Object.keys(raw).length
+                ? [{ provider, identity: object(raw.n2k) }]
+                : [];
+        });
+        if (providers.length !== 1)
+            return [];
+        const { provider, identity } = providers[0];
+        const physical = (0, equipment_identity_1.nmeaPhysicalIdentity)(identity.canName);
+        if (!/^[A-Za-z0-9_-]{1,100}$/.test(provider) ||
+            !physical ||
+            !victron(identity.manufacturerCode))
+            return [];
+        const source = `${provider}.${pgn.src}`, id = `n2k_${physical}`, key = `${provider}:${physical}`;
+        const observations = [];
+        const emit = (path, value) => observations.push({ path, value, source, at });
+        if (identity.deviceFunction === 160 &&
+            /^(?:SmartSolar|BlueSolar)\b/.test(String(identity.modelId))) {
+            if (!Number.isInteger(fields.instance) ||
+                Number(fields.instance) < 0 ||
+                Number(fields.instance) > 252)
+                return [];
+            const instance = `${key}:${fields.instance}`;
+            if (pgn.pgn === 127506 &&
+                ["Battery", "Solar cell"].includes(String(fields.dcType))) {
+                const previous = this.dcTypes.get(instance);
+                if (!previous || clock >= previous.at)
+                    this.dcTypes.set(instance, {
+                        type: String(fields.dcType),
+                        at: clock,
+                    });
+            }
+            if (pgn.pgn === 127508) {
+                const type = this.dcTypes.get(instance);
+                const outputs = [...this.dcTypes].filter(([entry, value]) => entry.startsWith(key + ":") &&
+                    value.type === "Battery" &&
+                    clock - value.at <= 120000);
+                if (type?.type === "Battery" &&
+                    Math.abs(clock - type.at) <= 120000 &&
+                    outputs.length === 1) {
+                    for (const field of ["voltage", "current"]) {
+                        const value = fields[field];
+                        if (typeof value === "number" &&
+                            Number.isFinite(value) &&
+                            (field !== "voltage" || value >= 0))
+                            emit(`electrical.solar.${id}.${field}`, value);
+                    }
+                }
+            }
+        }
+        if (identity.deviceFunction === 153 &&
+            /^(?:Quattro|MultiPlus|Phoenix|EasySolar)\b/.test(String(identity.modelId))) {
+            if (pgn.pgn === 127509) {
+                const previous = this.inverterDcInstances.get(key);
+                if (!previous || clock >= previous.at) {
+                    if (Number.isInteger(fields.dcInstance) &&
+                        Number(fields.dcInstance) >= 0 &&
+                        Number(fields.dcInstance) <= 252)
+                        this.inverterDcInstances.set(key, {
+                            instance: Number(fields.dcInstance),
+                            at: clock,
+                        });
+                    else
+                        this.inverterDcInstances.delete(key);
+                }
+            }
+            if (pgn.pgn === 127508) {
+                const channel = this.inverterDcInstances.get(key);
+                if (channel &&
+                    fields.instance === channel.instance &&
+                    Math.abs(clock - channel.at) <= 120000) {
+                    for (const field of ["voltage", "current"]) {
+                        const value = fields[field];
+                        if (typeof value === "number" &&
+                            Number.isFinite(value) &&
+                            (field !== "voltage" || value >= 0))
+                            emit(`electrical.inverters.${id}.dc.${field}`, value);
+                    }
+                }
+            }
+            const state = typeof fields.operatingState === "string"
+                ? fields.operatingState
+                : null;
+            if (state && (pgn.pgn === 127507 || pgn.pgn === 127509)) {
+                const entry = `${key}:${pgn.pgn}`, previous = this.states.get(entry);
+                if (!previous || clock >= previous.at)
+                    this.states.set(entry, { value: state, at: clock });
+                const inverter = this.states.get(`${key}:127509`), charger = this.states.get(`${key}:127507`);
+                if (inverter && Math.abs(clock - inverter.at) <= 10000) {
+                    const inverterModes = {
+                        "Inverter on": "inverting",
+                        Inverting: "inverting",
+                        "AC passthru": "passthrough",
+                        Off: "disabled",
+                        Standby: "standby",
+                        Fault: "faulted",
+                    };
+                    const chargerModes = {
+                        Bulk: "bulk",
+                        Absorption: "absorption",
+                        Float: "float",
+                        Equalize: "equalize",
+                        Overcharge: "overcharge",
+                    };
+                    let mode = inverterModes[inverter.value];
+                    if (mode === "passthrough" &&
+                        charger &&
+                        Math.abs(clock - charger.at) <= 10000)
+                        mode = chargerModes[charger.value] ?? mode;
+                    if (mode)
+                        emit(`electrical.inverters.${id}.inverterMode`, mode);
+                }
+            }
+        }
+        for (const cache of [this.dcTypes, this.states, this.inverterDcInstances])
+            while (cache.size > 256)
+                cache.delete(cache.keys().next().value);
+        return observations;
+    }
+}
+exports.NmeaEnergy = NmeaEnergy;

package/dist/src/noforeignland.d.ts

@@ -20,6 +20,7 @@ export declare class NoForeignLandPublisher {
     private readonly emit;
     private readonly request;
     private readonly now;
+    private readonly availableBytes;
     private journal;
     private state;
     private message;
@@ -36,7 +37,7 @@ export declare class NoForeignLandPublisher {
     private nextSendAt;
     private readonly file;
     private journalBytes;
-    constructor(directory: string, config: NoForeignLandConfig, emit: (status: ReturnType<NoForeignLandPublisher["status"]>) => void, request?: typeof fetch, now?: () => number);
+    constructor(directory: string, config: NoForeignLandConfig, emit: (status: ReturnType<NoForeignLandPublisher["status"]>) => void, request?: typeof fetch, now?: () => number, availableBytes?: () => Promise<number>);
     status(): {
         state: PublisherState;
         message: string;

package/dist/src/noforeignland.js

@@ -16,6 +16,7 @@ class NoForeignLandPublisher {
     emit;
     request;
     now;
+    availableBytes;
     journal;
     state = "disabled";
     message = "Disabled";
@@ -32,12 +33,16 @@ class NoForeignLandPublisher {
     nextSendAt = 0;
     file;
     journalBytes = 0;
-    constructor(directory, config, emit, request = fetch, now = Date.now) {
+    constructor(directory, config, emit, request = fetch, now = Date.now, availableBytes = async () => {
+        const capacity = await (0, promises_1.statfs)(directory);
+        return capacity.bavail * capacity.bsize;
+    }) {
         this.directory = directory;
         this.config = config;
         this.emit = emit;
         this.request = request;
         this.now = now;
+        this.availableBytes = availableBytes;
         this.file = (0, node_path_1.join)(directory, "publisher.jsonl");
         this.journal = {
             version: 1,
@@ -348,8 +353,7 @@ class NoForeignLandPublisher {
         }
     }
     async save(updated) {
-        const capacity = await (0, promises_1.statfs)(this.directory);
-        if (capacity.bavail * capacity.bsize < 32 * 1024 * 1024)
+        if ((await this.availableBytes()) < 32 * 1024 * 1024)
             throw new Error("reserve");
         if (this.journalBytes === 0 || this.journalBytes > 2_000_000) {
             const payload = JSON.stringify(updated) + "\n";

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),
@@ -65,36 +73,38 @@ exports.SELF_TELEMETRY = [
     self("electrical.inverters.*.acout.voltage", "number", "scalar", 5_000, 60_000, 1),
     self("electrical.inverters.*.acout.current", "number", "scalar", 5_000, 60_000, 1),
     self("electrical.inverters.*.acout.frequency", "number", "scalar", 5_000, 60_000, 1),
-    self("electrical.venus.dcPower", "number", "scalar", 5_000, 60_000, 1),
+    self("electrical.venus.dcPower", "number", "scalar", 1_000, 20_000, 0.5),
     self("electrical.venus.acSource", "string", "identity", 5_000, 60_000, 0),
     self("electrical.venus.state", "string", "identity", 5_000, 60_000, 0),
-    self("electrical.batteries.*.power", "number", "scalar", 5_000, 60_000, 1),
+    self("electrical.batteries.*.power", "number", "scalar", 1_000, 20_000, 0.5),
     self("electrical.batteries.*.capacity.remaining", "number", "scalar", 5_000, 60_000, 1),
     self("electrical.batteries.*.capacity.nominal", "number", "scalar", 5_000, 60_000, 1),
-    self("electrical.solar.*.voltage", "number", "scalar", 5_000, 60_000, 1),
-    self("electrical.solar.*.current", "number", "scalar", 5_000, 60_000, 1),
-    self("electrical.solar.*.power", "number", "scalar", 5_000, 60_000, 1),
-    self("electrical.chargers.*.voltage", "number", "scalar", 5_000, 60_000, 1),
-    self("electrical.chargers.*.current", "number", "scalar", 5_000, 60_000, 1),
-    self("electrical.chargers.*.power", "number", "scalar", 5_000, 60_000, 1),
-    self("electrical.alternators.*.voltage", "number", "scalar", 5_000, 60_000, 1),
-    self("electrical.alternators.*.current", "number", "scalar", 5_000, 60_000, 1),
-    self("electrical.alternators.*.power", "number", "scalar", 5_000, 60_000, 1),
+    self("electrical.solar.*.voltage", "number", "scalar", 1_000, 20_000, 0.005),
+    self("electrical.solar.*.current", "number", "scalar", 1_000, 20_000, 0.01),
+    self("electrical.solar.*.power", "number", "scalar", 1_000, 20_000, 0.5),
+    self("electrical.chargers.*.voltage", "number", "scalar", 1_000, 20_000, 0.005),
+    self("electrical.chargers.*.current", "number", "scalar", 1_000, 20_000, 0.01),
+    self("electrical.chargers.*.power", "number", "scalar", 1_000, 20_000, 0.5),
+    self("electrical.alternators.*.voltage", "number", "scalar", 1_000, 20_000, 0.005),
+    self("electrical.alternators.*.current", "number", "scalar", 1_000, 20_000, 0.01),
+    self("electrical.alternators.*.power", "number", "scalar", 1_000, 20_000, 0.5),
     self("electrical.solar.*.panelPower", "number", "scalar", 5_000, 60_000, 1),
     self("electrical.solar.*.yieldToday", "number", "scalar", 5_000, 60_000, 1),
-    self("electrical.inverters.*.dc.voltage", "number", "scalar", 5_000, 60_000, 1),
-    self("electrical.inverters.*.dc.current", "number", "scalar", 5_000, 60_000, 1),
-    self("electrical.inverters.*.dc.power", "number", "scalar", 5_000, 60_000, 1),
+    self("electrical.inverters.*.dc.voltage", "number", "scalar", 1_000, 20_000, 0.005),
+    self("electrical.inverters.*.dc.current", "number", "scalar", 1_000, 20_000, 0.01),
+    self("electrical.inverters.*.dc.power", "number", "scalar", 1_000, 20_000, 0.5),
     self("electrical.inverters.*.ac.realPower", "number", "scalar", 5_000, 60_000, 1),
     self("electrical.inverters.*.ac.lineNeutralVoltage", "number", "scalar", 5_000, 60_000, 1),
     self("electrical.inverters.*.ac.frequency", "number", "scalar", 5_000, 60_000, 1),
+    self("electrical.ac.*.activeInputCurrentLimit", "number", "scalar", 5_000, 60_000, 0.1),
+    self("electrical.ac.*.total.realPower", "number", "scalar", 5_000, 60_000, 1),
     self("electrical.ac.*.phase.*.realPower", "number", "scalar", 5_000, 60_000, 1),
     self("electrical.ac.*.phase.*.lineNeutralVoltage", "number", "scalar", 5_000, 60_000, 1),
     self("electrical.ac.*.phase.*.current", "number", "scalar", 5_000, 60_000, 1),
     self("electrical.ac.*.phase.*.frequency", "number", "scalar", 5_000, 60_000, 1),
-    self("electrical.dc.*.power", "number", "scalar", 5_000, 60_000, 1),
-    self("electrical.dc.*.voltage", "number", "scalar", 5_000, 60_000, 1),
-    self("electrical.dc.*.current", "number", "scalar", 5_000, 60_000, 1),
+    self("electrical.dc.*.power", "number", "scalar", 1_000, 20_000, 0.5),
+    self("electrical.dc.*.voltage", "number", "scalar", 1_000, 20_000, 0.005),
+    self("electrical.dc.*.current", "number", "scalar", 1_000, 20_000, 0.01),
     self("electrical.batteries.*.name", "string", "identity", 30_000, 600_000, 0),
     self("electrical.solar.*.name", "string", "identity", 30_000, 600_000, 0),
     self("electrical.chargers.*.name", "string", "identity", 30_000, 600_000, 0),
@@ -104,8 +114,8 @@ exports.SELF_TELEMETRY = [
     self("electrical.dc.*.name", "string", "identity", 30_000, 600_000, 0),
     self("electrical.inverters.*.inverterMode", "string", "identity", 30_000, 60_000, 0),
     self("electrical.chargers.*.chargingMode", "string", "identity", 30_000, 60_000, 0),
-    self("electrical.batteries.*.voltage", "number", "scalar", 10_000, 300_000, 0.1),
-    self("electrical.batteries.*.current", "number", "scalar", 5_000, 120_000, 1),
+    self("electrical.batteries.*.voltage", "number", "scalar", 1_000, 20_000, 0.005),
+    self("electrical.batteries.*.current", "number", "scalar", 1_000, 20_000, 0.01),
     self("electrical.batteries.*.temperature", "number", "scalar", 30_000, 600_000, 0.5),
     self("electrical.batteries.*.capacity.stateOfCharge", "number", "scalar", 30_000, 600_000, 0.01),
     self("electrical.batteries.*.capacity.timeRemaining", "number", "scalar", 300_000, 1_800_000, 60),

package/dist/src/types.d.ts

@@ -5,6 +5,10 @@ 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;
+    nmea_energy?: boolean;
+    ac_total_power?: boolean;
+    victron_input_limit?: 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.40";
+export declare const CONNECTOR_VERSION = "0.2.0-dev.42";

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.40";
+exports.CONNECTOR_VERSION = "0.2.0-dev.42";

package/dist/src/victron-input-limit.d.ts

@@ -0,0 +1,7 @@
+/** Decode received broadcast data only. This adapter never sends a CAN request or command. */
+export declare function victronInputLimit(message: unknown, sources: unknown, electrical: unknown, now: number): {
+    path: string;
+    value: number;
+    source: string;
+    at: string;
+} | null;

package/dist/src/victron-input-limit.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.victronInputLimit = victronInputLimit;
+const object = (value) => value !== null && typeof value === "object" && !Array.isArray(value)
+    ? value
+    : {};
+const victron = (value) => value === 358 || value === "Victron Energy";
+/** Decode received broadcast data only. This adapter never sends a CAN request or command. */
+function victronInputLimit(message, sources, electrical, now) {
+    const pgn = object(message), fields = object(pgn.fields);
+    if (pgn.pgn !== 61184 ||
+        pgn.dst !== 255 ||
+        pgn.direction !== "R" ||
+        !victron(fields.manufacturerCode) ||
+        fields.industryCode !== "Marine Industry" ||
+        fields.registerId !== 0x0203 ||
+        !Number.isInteger(fields.payload) ||
+        Number(fields.payload) < 0 ||
+        Number(fields.payload) >= 0xffff ||
+        !Number.isInteger(pgn.src) ||
+        Number(pgn.src) < 0 ||
+        Number(pgn.src) > 252)
+        return null;
+    const at = typeof pgn.timestamp === "string" ? pgn.timestamp : "", clock = Date.parse(at);
+    if (!Number.isFinite(clock) || clock > now + 30000 || now - clock > 120000)
+        return null;
+    // The global parser event has no provider label. Ambiguous receiver addresses stay unresolved.
+    const providers = Object.entries(object(sources))
+        .slice(0, 64)
+        .flatMap(([provider, collection]) => {
+        const device = object(object(collection)[String(pgn.src)]);
+        return Object.keys(device).length
+            ? [{ provider, n2k: object(device.n2k) }]
+            : [];
+    });
+    if (providers.length !== 1)
+        return null;
+    const { provider, n2k } = providers[0];
+    if (!/^[A-Za-z0-9_-]{1,100}$/.test(provider) ||
+        !victron(n2k.manufacturerCode) ||
+        n2k.deviceFunction !== 153)
+        return null;
+    const source = `${provider}.${pgn.src}`;
+    const meters = Object.entries(object(object(electrical).ac))
+        .slice(0, 100)
+        .filter(([id, value]) => {
+        if (!/^[A-Za-z0-9_:-]{1,100}$/.test(id))
+            return false;
+        const phase = object(object(value).phase), total = object(object(value).total);
+        return [
+            total.realPower,
+            ...Object.values(phase).flatMap((value) => Object.values(object(value))),
+        ].some((value) => object(value).$source === source);
+    });
+    if (meters.length !== 1)
+        return null;
+    return {
+        path: `electrical.ac.${meters[0][0]}.activeInputCurrentLimit`,
+        value: Number(fields.payload) / 10,
+        source,
+        at,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aurora-blue/signalk-connector",
-  "version": "0.2.0-dev.40",
+  "version": "0.2.0-dev.42",
   "description": "Signal K edge connector for the Aurora Blue ABOARD ingest protocol",
   "private": false,
   "main": "dist/src/index.js",
@@ -37,7 +37,7 @@
     "prepack": "npm run build",
     "replay:signalk": "npm run build && node tools/replay-signalk.mjs",
     "simulate:offline": "npm run build && node tools/simulate-offline-buffer.mjs",
-    "test": "npm run build && node --test dist/test/*.test.js",
+    "test": "npm run build && node --test --test-concurrency=1 dist/test/*.test.js",
     "test:tools": "node --test tools/test/*.test.mjs",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "verify:package": "npm pack --dry-run",
@@ -48,8 +48,8 @@
     "release:verify": "node tools/release.mjs verify"
   },
   "devDependencies": {
-    "@signalk/server-api": "2.35.0",
-    "@types/node": "24.19.2",
+    "@signalk/server-api": "2.37.0",
+    "@types/node": "26.6.6",
     "prettier": "3.9.10",
     "typescript": "7.0.2"
   },

package/public/ci-tokens.css

@@ -1,6 +1,8 @@
 /* Aurora Blue Web UI CI 1.46 implementation tokens. */
 :root {
+    --aboard-map-seamark-night: #79b8ea;
     color-scheme: light;
+    --aboard-product-gradient: radial-gradient(ellipse farthest-corner at 0% 0%,rgb(var(--aboard-surface-rgb)) 0%,rgb(var(--aboard-control-rgb) / .9) 48%,rgb(var(--aboard-accent-rgb) / .42) 100%);
     --aboard-font-xs: .75rem;
     --aboard-font-body: .875rem;
     --aboard-font-base: 1rem;
@@ -34,6 +36,7 @@
     --aboard-border-rgb: 79 119 126;
     --aboard-text: #17343c;
     --aboard-heading: #0d2a32;
+    --aboard-weather-label: #000;
     --aboard-muted: #60777d;
     --aboard-muted-strong: #486a72;
     --aboard-accent: #167f88;
@@ -44,6 +47,8 @@
     --aboard-success-rgb: 24 118 80;
     --aboard-warning: #9a6508;
     --aboard-danger: #b83245;
+    --aboard-weather-danger: #a41d34;
+    --aboard-weather-danger-fill: #ed344b;
     --aboard-scrim-rgb: 15 34 39;
     --aboard-shadow-rgb: 25 51 57;
     --aboard-map-departure: #f0c76e;
@@ -53,6 +58,7 @@
     --aboard-map-land: #e6ebe1;
     --aboard-map-coast: #789197;
     --aboard-map-grid: #6f8c92;
+    --aboard-map-ais: #076f2d;
     --aboard-map-label: #345860;
     --aboard-select-chevron: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 20 20'%3E%3Cpath d='m5 7.5 5 5 5-5' fill='none' stroke='%2360777d' stroke-linecap='round' stroke-linejoin='round' stroke-width='1.7'/%3E%3C/svg%3E");
     --aboard-button-bg: rgb(var(--aboard-control-rgb) / .58);
@@ -61,8 +67,12 @@
     background: var(--aboard-bg);
 }
 
-:root[data-theme='dark'] {
+:root[data-theme='dark'],
+.aboard-provisioning-stock-card--photo,
+.aboard-marketing [data-theme='dark'],
+.aboard-marketing.home .aboard-website-header-shell {
     color-scheme: dark;
+    --aboard-product-gradient: radial-gradient(ellipse farthest-corner at 0% 0%,rgb(var(--aboard-accent-rgb) / .38) 0%,rgb(var(--aboard-control-rgb)) 58%,rgb(var(--aboard-surface-rgb)) 100%);
     --aboard-bg: #061019;
     --aboard-bg-rgb: 6 16 25;
     --aboard-surface: #071923;
@@ -76,6 +86,7 @@
     --aboard-border-rgb: 129 190 200;
     --aboard-text: #e8f5f8;
     --aboard-heading: #f4fbfc;
+    --aboard-weather-label: #fff;
     --aboard-muted: #78959d;
     --aboard-muted-strong: #9ecbd0;
     --aboard-accent: #76e8e8;
@@ -86,12 +97,14 @@
     --aboard-success-rgb: 118 232 194;
     --aboard-warning: #f3d27f;
     --aboard-danger: #f1a2a2;
+    --aboard-weather-danger: #ff8989;
     --aboard-scrim-rgb: 0 7 11;
     --aboard-shadow-rgb: 0 0 0;
     --aboard-map-water: #102f3b;
     --aboard-map-land: #1d3435;
     --aboard-map-coast: #78959d;
     --aboard-map-grid: #66858e;
+    --aboard-map-ais: #35ad51;
     --aboard-map-label: #bce5e9;
     --aboard-select-chevron: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 20 20'%3E%3Cpath d='m5 7.5 5 5 5-5' fill='none' stroke='%2378959d' stroke-linecap='round' stroke-linejoin='round' stroke-width='1.7'/%3E%3C/svg%3E");
 }
@@ -99,6 +112,7 @@
 @media (prefers-color-scheme: dark) {
     :root:not([data-theme]) {
         color-scheme: dark;
+    --aboard-product-gradient: radial-gradient(ellipse farthest-corner at 0% 0%,rgb(var(--aboard-accent-rgb) / .38) 0%,rgb(var(--aboard-control-rgb)) 58%,rgb(var(--aboard-surface-rgb)) 100%);
         --aboard-bg: #061019;
         --aboard-bg-rgb: 6 16 25;
         --aboard-surface: #071923;
@@ -112,6 +126,7 @@
         --aboard-border-rgb: 129 190 200;
         --aboard-text: #e8f5f8;
         --aboard-heading: #f4fbfc;
+        --aboard-weather-label: #fff;
         --aboard-muted: #78959d;
         --aboard-muted-strong: #9ecbd0;
         --aboard-accent: #76e8e8;
@@ -122,12 +137,14 @@
         --aboard-success-rgb: 118 232 194;
         --aboard-warning: #f3d27f;
         --aboard-danger: #f1a2a2;
+    --aboard-weather-danger: #ff8989;
         --aboard-scrim-rgb: 0 7 11;
         --aboard-shadow-rgb: 0 0 0;
         --aboard-map-water: #102f3b;
         --aboard-map-land: #1d3435;
         --aboard-map-coast: #78959d;
         --aboard-map-grid: #66858e;
+        --aboard-map-ais: #35ad51;
         --aboard-map-label: #bce5e9;
         --aboard-select-chevron: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 20 20'%3E%3Cpath d='m5 7.5 5 5 5-5' fill='none' stroke='%2378959d' stroke-linecap='round' stroke-linejoin='round' stroke-width='1.7'/%3E%3C/svg%3E");
     }