@aurora-blue/signalk-connector 0.2.0-dev.22 → 0.2.0-dev.26

package/README.md

@@ -51,7 +51,9 @@ 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 selected own-vessel Signal K paths every second, samples selected AIS paths every five seconds, and enables the preliminary underway change-or-heartbeat profile. 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 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 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.
 
 The optional anchor alarm is an experimental development scaffold. When enabled, position is requested every 250 milliseconds and every received position reaches the safety engine before telemetry reduction. The alarm publishes a local Signal K notification and detects stale position input without requiring the Aurora Blue target. It must not yet be used as the sole safety device.
 
@@ -117,6 +119,16 @@ The public package name is `@aurora-blue/signalk-connector`. Once its first rele
 
 When migrating from the unscoped development package `aurora-blue-signalk-connector`, back up Signal K configuration and plugin data first. Stop Signal K and replace only the installed package; preserve the existing plugin configuration and data directory. Do not install both package names together: they deliberately share one runtime plugin ID. Restart and verify pairing, buffered records and status before resuming normal use.
 
+The Signal K Webapps tile uses `signalk.appIcon` pointing to the bundled canonical `public/favicon.svg`: the white ABOARD sailing mark on the approved variant B gradient. It loads locally without an external image service.
+
 Release maintainers use the protected GitLab pipeline described in the central Connector publication document. Package preparation does not itself publish a release or guarantee App Store indexing.
 
 The authoritative architecture and protocol documentation is maintained in the separate `aurora-blue-documentation` repository.
+
+## Optional NoForeignLand publisher (development)
+
+The connector can publish observed own-vessel tracks through an independent, bounded offline queue using its existing Signal K observations. Enable the optional NoForeignLand settings only after obtaining dedicated ABOARD application credentials and a boat key, disabling the original plugin and completing queue handover. Existing official-plugin configuration blocks startup to prevent duplicate publication. The publisher is disabled by default.
+
+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.

package/VERSION

@@ -1 +1 @@
-0.2.0-dev.22
+0.2.0-dev.26

package/dist/src/config.d.ts

@@ -1,7 +1,9 @@
 import type { AnchorAlarmConfig } from "./safety/anchor-alarm";
 import type { StorageProfile } from "./storage-budget";
 import type { OperatingProfile } from "./telemetry-reducer";
+import type { NoForeignLandConfig } from "./noforeignland";
 export interface ConnectorConfig {
+    noforeignland?: NoForeignLandConfig;
     targetUrl: string;
     deviceName: string;
     pairingCode?: string;
@@ -32,6 +34,75 @@ export declare const pluginSchema: {
     readonly type: "object";
     readonly required: readonly ["targetUrl"];
     readonly properties: {
+        readonly noforeignland: {
+            readonly type: "object";
+            readonly title: "NoForeignLand publishing";
+            readonly description: "Optional direct track publication. Requires dedicated ABOARD application credentials. Disable the separate NoForeignLand plugin before enabling this publisher.";
+            readonly properties: {
+                readonly enabled: {
+                    readonly type: "boolean";
+                    readonly title: "Publish to NoForeignLand";
+                    readonly default: false;
+                };
+                readonly applicationKey: {
+                    readonly type: "string";
+                    readonly title: "ABOARD application key";
+                };
+                readonly boatKey: {
+                    readonly type: "string";
+                    readonly title: "Boat API key";
+                };
+                readonly source: {
+                    readonly type: "string";
+                    readonly title: "Position source (empty selects automatically)";
+                };
+                readonly sampleSeconds: {
+                    readonly type: "integer";
+                    readonly title: "Minimum sample interval (seconds)";
+                    readonly minimum: 10;
+                    readonly maximum: 3600;
+                    readonly default: 60;
+                };
+                readonly minimumMoveMeters: {
+                    readonly type: "integer";
+                    readonly title: "Minimum movement (meters)";
+                    readonly minimum: 0;
+                    readonly maximum: 10000;
+                    readonly default: 80;
+                };
+                readonly minimumSpeedKnots: {
+                    readonly type: "number";
+                    readonly title: "Minimum speed (knots)";
+                    readonly minimum: 0;
+                    readonly maximum: 100;
+                    readonly default: 1.5;
+                };
+                readonly maximumVelocity: {
+                    readonly type: "integer";
+                    readonly title: "Maximum plausible velocity (meters per second)";
+                    readonly minimum: 1;
+                    readonly maximum: 500;
+                    readonly default: 50;
+                };
+                readonly sendWhileMoving: {
+                    readonly type: "boolean";
+                    readonly title: "Send while moving";
+                    readonly default: true;
+                };
+                readonly keepalive: {
+                    readonly type: "boolean";
+                    readonly title: "Publish a fresh position every 24 hours";
+                    readonly default: true;
+                };
+                readonly sendIntervalSeconds: {
+                    readonly type: "integer";
+                    readonly title: "Send interval (seconds)";
+                    readonly minimum: 60;
+                    readonly maximum: 86400;
+                    readonly default: 600;
+                };
+            };
+        };
         readonly targetUrl: {
             readonly type: "string";
             readonly title: "Aurora Blue target URL";
@@ -181,6 +252,14 @@ export declare const pluginSchema: {
     };
 };
 export declare const pluginUiSchema: {
+    readonly noforeignland: {
+        readonly applicationKey: {
+            readonly "ui:widget": "password";
+        };
+        readonly boatKey: {
+            readonly "ui:widget": "password";
+        };
+    };
     readonly targetUrl: {
         readonly "ui:options": {
             readonly enableMarkdownInDescription: true;

package/dist/src/config.js

@@ -104,7 +104,32 @@ const resolveConfig = (input) => {
     if (anchorHysteresisMeters >= anchorRadiusMeters) {
         throw new Error("Anchor hysteresis must be smaller than the anchor radius.");
     }
+    if (raw.noforeignland !== undefined &&
+        (raw.noforeignland === null ||
+            typeof raw.noforeignland !== "object" ||
+            Array.isArray(raw.noforeignland))) {
+        throw new Error("NoForeignLand settings must be an object.");
+    }
+    const nfl = (raw.noforeignland ?? {});
+    const nflEnabled = nfl.enabled === true;
+    const secret = (value) => typeof value === "string" ? value.trim() : "";
+    if (nflEnabled && (!secret(nfl.applicationKey) || !secret(nfl.boatKey))) {
+        throw new Error("NoForeignLand requires an ABOARD application key and a boat key.");
+    }
     return {
+        noforeignland: {
+            enabled: nflEnabled,
+            applicationKey: secret(nfl.applicationKey),
+            boatKey: secret(nfl.boatKey),
+            source: secret(nfl.source),
+            sampleSeconds: integer(nfl.sampleSeconds, 60, 10, 3600, "NoForeignLand sample interval"),
+            minimumMoveMeters: integer(nfl.minimumMoveMeters, 80, 0, 10000, "NoForeignLand minimum movement"),
+            minimumSpeedKnots: finiteNumber(nfl.minimumSpeedKnots, 0, 100, "NoForeignLand minimum speed") ?? 1.5,
+            maximumVelocity: integer(nfl.maximumVelocity, 50, 1, 500, "NoForeignLand maximum velocity"),
+            sendWhileMoving: nfl.sendWhileMoving !== false,
+            keepalive: nfl.keepalive !== false,
+            sendIntervalSeconds: integer(nfl.sendIntervalSeconds, 600, 60, 86400, "NoForeignLand send interval"),
+        },
         targetUrl: parsedUrl.toString().replace(/\/$/, ""),
         deviceName: deviceName || "Aurora Blue Signal K",
         pairingCode: typeof raw.pairingCode === "string" && raw.pairingCode.trim() !== ""
@@ -151,6 +176,69 @@ exports.pluginSchema = {
     type: "object",
     required: ["targetUrl"],
     properties: {
+        noforeignland: {
+            type: "object",
+            title: "NoForeignLand publishing",
+            description: "Optional direct track publication. Requires dedicated ABOARD application credentials. Disable the separate NoForeignLand plugin before enabling this publisher.",
+            properties: {
+                enabled: {
+                    type: "boolean",
+                    title: "Publish to NoForeignLand",
+                    default: false,
+                },
+                applicationKey: { type: "string", title: "ABOARD application key" },
+                boatKey: { type: "string", title: "Boat API key" },
+                source: {
+                    type: "string",
+                    title: "Position source (empty selects automatically)",
+                },
+                sampleSeconds: {
+                    type: "integer",
+                    title: "Minimum sample interval (seconds)",
+                    minimum: 10,
+                    maximum: 3600,
+                    default: 60,
+                },
+                minimumMoveMeters: {
+                    type: "integer",
+                    title: "Minimum movement (meters)",
+                    minimum: 0,
+                    maximum: 10000,
+                    default: 80,
+                },
+                minimumSpeedKnots: {
+                    type: "number",
+                    title: "Minimum speed (knots)",
+                    minimum: 0,
+                    maximum: 100,
+                    default: 1.5,
+                },
+                maximumVelocity: {
+                    type: "integer",
+                    title: "Maximum plausible velocity (meters per second)",
+                    minimum: 1,
+                    maximum: 500,
+                    default: 50,
+                },
+                sendWhileMoving: {
+                    type: "boolean",
+                    title: "Send while moving",
+                    default: true,
+                },
+                keepalive: {
+                    type: "boolean",
+                    title: "Publish a fresh position every 24 hours",
+                    default: true,
+                },
+                sendIntervalSeconds: {
+                    type: "integer",
+                    title: "Send interval (seconds)",
+                    minimum: 60,
+                    maximum: 86400,
+                    default: 600,
+                },
+            },
+        },
         targetUrl: {
             type: "string",
             title: "Aurora Blue target URL",
@@ -306,6 +394,10 @@ exports.pluginSchema = {
     },
 };
 exports.pluginUiSchema = {
+    noforeignland: {
+        applicationKey: { "ui:widget": "password" },
+        boatKey: { "ui:widget": "password" },
+    },
     targetUrl: {
         "ui:options": {
             enableMarkdownInDescription: true,

package/dist/src/connector.d.ts

@@ -43,11 +43,21 @@ export declare class ConnectorRuntime {
     private nextCapacityRefreshAt;
     private storageBudget;
     private readonly emissionTimes;
+    private publisher;
     private captureTail;
     private pendingCaptureEvents;
     private nextCaptureStatusAt;
     constructor(app: ServerAPI, store: StateStore, config: ConnectorConfig, options?: ConnectorRuntimeOptions);
     start(): Promise<void>;
+    publisherStatus(): {
+        state: import("./noforeignland").PublisherState;
+        message: string;
+        pending: number;
+        dropped: number;
+        savedAt: number | null;
+        sentAt: number | null;
+        source: string | null;
+    } | null;
     stop(): Promise<void>;
     capture(delta: Delta, subscriptionScope?: SubscriptionScope): Promise<void>;
     private captureEvents;

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 node_path_1 = require("node:path");
+const noforeignland_1 = require("./noforeignland");
 const node_crypto_1 = require("node:crypto");
 const backoff_1 = require("./backoff");
 const delta_1 = require("./delta");
@@ -53,6 +55,7 @@ class ConnectorRuntime {
     nextCapacityRefreshAt = 0;
     storageBudget;
     emissionTimes = [];
+    publisher = null;
     captureTail = Promise.resolve();
     pendingCaptureEvents = 0;
     nextCaptureStatusAt = 0;
@@ -73,6 +76,47 @@ class ConnectorRuntime {
     }
     async start() {
         await this.store.load();
+        if (this.config.noforeignland?.enabled) {
+            this.publisher = new noforeignland_1.NoForeignLandPublisher((0, node_path_1.join)(this.app.getDataDirPath(), "noforeignland"), this.config.noforeignland, (status) => {
+                this.app.handleMessage("aurora-blue-signalk-connector", {
+                    context: "vessels.self",
+                    updates: [
+                        {
+                            timestamp: this.now(),
+                            values: [
+                                {
+                                    path: "noforeignland.status",
+                                    value: status.message,
+                                },
+                                {
+                                    path: "noforeignland.status_boolean",
+                                    value: status.state === "error" || status.state === "waiting"
+                                        ? 1
+                                        : 0,
+                                },
+                                ...(status.savedAt === null
+                                    ? []
+                                    : [
+                                        {
+                                            path: "noforeignland.savepoint",
+                                            value: new Date(status.savedAt).toISOString(),
+                                        },
+                                    ]),
+                                ...(status.sentAt === null
+                                    ? []
+                                    : [
+                                        {
+                                            path: "noforeignland.sent_to_api",
+                                            value: new Date(status.sentAt).toISOString(),
+                                        },
+                                    ]),
+                            ],
+                        },
+                    ],
+                });
+            });
+            await this.publisher.start(this.autoSchedule);
+        }
         await this.refreshStorageBudget(true);
         this.client ??= new http_client_1.AuroraBlueHttpClient(this.config.targetUrl, this.config.requestTimeoutMs, fetch, this.config.compressionEnabled
             ? this.config.compressionThresholdBytes
@@ -90,6 +134,7 @@ class ConnectorRuntime {
         }
         if (state.device_id === null) {
             this.pairingState = "unpaired";
+            this.configureSubscriptions();
             this.app.setPluginStatus("Unpaired - enter an Aurora Blue pairing code in plugin settings.");
             return;
         }
@@ -135,6 +180,9 @@ class ConnectorRuntime {
             this.schedule(0);
         }
     }
+    publisherStatus() {
+        return this.publisher?.status() ?? null;
+    }
     async stop() {
         this.stopped = true;
         if (this.timer !== null) {
@@ -152,6 +200,7 @@ class ConnectorRuntime {
         for (const unsubscribe of this.unsubscribes.splice(0)) {
             unsubscribe();
         }
+        await this.publisher?.stop();
         await this.captureTail;
         await this.store.summary();
     }
@@ -161,6 +210,8 @@ class ConnectorRuntime {
         }
         const receivedAt = this.now();
         const events = (0, delta_1.eventsFromDelta)(delta, this.bootId, receivedAt, subscriptionScope);
+        for (const event of events)
+            this.publisher?.observe(event);
         // Safety observes current positions immediately, even when historical
         // telemetry admission is saturated by slow storage.
         for (const event of events) {
@@ -318,14 +369,24 @@ class ConnectorRuntime {
             return;
         }
         if (this.pairingState !== "paired") {
-            if (this.config.anchorAlarm.enabled) {
-                this.subscribeToContext("vessels.self", ["navigation.position"], this.config.safetySamplePeriodMs);
+            if (this.config.anchorAlarm.enabled || this.publisher) {
+                this.subscribeToContext("vessels.self", [
+                    "navigation.position",
+                    ...(this.publisher ? ["navigation.speedOverGround"] : []),
+                ], this.config.anchorAlarm.enabled
+                    ? this.config.safetySamplePeriodMs
+                    : this.config.samplePeriodMs);
             }
             return;
         }
         if (this.operatingMode === "standby") {
-            if (this.config.anchorAlarm.enabled) {
-                this.subscribeToContext("vessels.self", ["navigation.position"], this.config.safetySamplePeriodMs);
+            if (this.config.anchorAlarm.enabled || this.publisher) {
+                this.subscribeToContext("vessels.self", [
+                    "navigation.position",
+                    ...(this.publisher ? ["navigation.speedOverGround"] : []),
+                ], this.config.anchorAlarm.enabled
+                    ? this.config.safetySamplePeriodMs
+                    : this.config.samplePeriodMs);
             }
             return;
         }
@@ -337,14 +398,16 @@ class ConnectorRuntime {
     subscribeToContext(context, paths, period) {
         this.app.subscriptionmanager.subscribe({
             context,
-            subscribe: paths.map((path) => ({
-                path: path,
-                period: context === "vessels.self" &&
-                    path === "navigation.position" &&
-                    this.config.anchorAlarm.enabled
-                    ? Math.min(this.config.samplePeriodMs, this.config.safetySamplePeriodMs)
-                    : period,
-            })),
+            subscribe: paths.map((path) => context === "vessels.self" && path === "electrical.switches.*"
+                ? { path: path, policy: "instant", minPeriod: 0 }
+                : {
+                    path: path,
+                    period: context === "vessels.self" &&
+                        (path === "navigation.position" || path === "navigation.*") &&
+                        this.config.anchorAlarm.enabled
+                        ? Math.min(this.config.samplePeriodMs, this.config.safetySamplePeriodMs)
+                        : period,
+                }),
         }, this.unsubscribes, (error) => {
             this.app.setPluginError("Signal K subscription failed.");
             this.app.error(error instanceof Error ? error.message : String(error));

package/dist/src/delta.js

@@ -26,6 +26,28 @@ const sourceReference = (update) => {
     }
     return null;
 };
+// Bound generic navigation payloads without changing their source shape.
+const validNavigationValue = (value) => {
+    let nodes = 0;
+    const visit = (item, depth) => {
+        if (++nodes > 1024 || depth > 8)
+            return false;
+        if (item === null || typeof item === "boolean")
+            return true;
+        if (typeof item === "number")
+            return Number.isFinite(item);
+        if (typeof item === "string")
+            return !item.includes("\u0000");
+        if (Array.isArray(item))
+            return item.every((child) => visit(child, depth + 1));
+        if (typeof item !== "object")
+            return false;
+        return Object.entries(item).every(([key, child]) => !key.includes("\u0000") && visit(child, depth + 1));
+    };
+    return (value !== null &&
+        visit(value, 0) &&
+        Buffer.byteLength(JSON.stringify(value), "utf8") <= 16_384);
+};
 const validValue = (context, path, value) => {
     const definition = (0, telemetry_catalog_1.telemetryDefinition)(context, path);
     if (definition === null) {
@@ -48,11 +70,27 @@ const validValue = (context, path, value) => {
             longitude > 180) {
             return null;
         }
-        return { latitude, longitude };
+        return validNavigationValue(value)
+            ? { ...position, latitude, longitude }
+            : null;
+    }
+    if (definition.valueKind === "json") {
+        return validNavigationValue(value)
+            ? structuredClone(value)
+            : null;
     }
     if (definition.valueKind === "number") {
         return typeof value === "number" && Number.isFinite(value) ? value : null;
     }
+    if (definition.valueKind === "switch") {
+        if (typeof value === "boolean")
+            return value;
+        if (typeof value === "number" && Number.isFinite(value))
+            return value;
+        return typeof value === "string" && value.length > 0
+            ? value.slice(0, 255)
+            : null;
+    }
     if (definition.valueKind === "string") {
         if (path === "mmsi" && !/^[0-9]{9}$/.test(String(value))) {
             return null;
@@ -101,6 +139,32 @@ const flattenedStaticValues = (context, path, value) => {
         { path: "navigation.state", value: navigation?.state },
     ];
 };
+const flattenedSwitchValues = (path, value) => {
+    if (path !== "electrical.switches" &&
+        !path.startsWith("electrical.switches.")) {
+        return [{ path, value }];
+    }
+    const leaves = [];
+    const visit = (currentPath, currentValue, depth) => {
+        if (leaves.length >= 100 || depth > 8)
+            return;
+        if (currentValue === null || Array.isArray(currentValue))
+            return;
+        if (typeof currentValue !== "object") {
+            leaves.push({ path: currentPath, value: currentValue });
+            return;
+        }
+        for (const [name, child] of Object.entries(currentValue)) {
+            if (!/^[A-Za-z0-9_:-]+$/.test(name))
+                continue;
+            visit(`${currentPath}.${name}`, child, depth + 1);
+            if (leaves.length >= 100)
+                break;
+        }
+    };
+    visit(path, value, 0);
+    return leaves;
+};
 const eventsFromDelta = (delta, bootId, receivedAt, subscriptionScope = "self") => {
     const events = [];
     const context = eventContext(delta, subscriptionScope);
@@ -115,7 +179,11 @@ const eventsFromDelta = (delta, bootId, receivedAt, subscriptionScope = "self")
             if (pathValue.state?.timedOut === true) {
                 continue;
             }
-            for (const candidate of flattenedStaticValues(context, String(pathValue.path), pathValue.value)) {
+            const path = String(pathValue.path);
+            const candidates = context === "vessels.self"
+                ? flattenedSwitchValues(path, pathValue.value)
+                : flattenedStaticValues(context, path, pathValue.value);
+            for (const candidate of candidates) {
                 const value = validValue(context, candidate.path, candidate.value);
                 if (value === null) {
                     continue;

package/dist/src/index.js

@@ -27,11 +27,12 @@ const createPlugin = (app) => {
             generated_at: new Date().toISOString(),
             last_error: lastError,
             status,
+            noforeignland: runtime?.publisherStatus() ?? null,
         };
     };
     return {
         id: "aurora-blue-signalk-connector",
-        name: "Aurora Blue ABOARD Connector",
+        name: "Aurora Blue ABOARD SK",
         description: "Buffers selected Signal K data and transfers it to Aurora Blue ABOARD.",
         schema: config_1.pluginSchema,
         uiSchema: config_1.pluginUiSchema,

package/dist/src/noforeignland.d.ts

@@ -0,0 +1,57 @@
+import type { EventInput } from "./types";
+export interface NoForeignLandConfig {
+    enabled: boolean;
+    applicationKey: string;
+    boatKey: string;
+    source: string;
+    sampleSeconds: number;
+    minimumMoveMeters: number;
+    minimumSpeedKnots: number;
+    maximumVelocity: number;
+    sendWhileMoving: boolean;
+    keepalive: boolean;
+    sendIntervalSeconds: number;
+}
+export type PublisherState = "disabled" | "ready" | "waiting" | "sending" | "error";
+/** Independent, bounded publisher consuming the connector's existing observations. */
+export declare class NoForeignLandPublisher {
+    private readonly directory;
+    private readonly config;
+    private readonly emit;
+    private readonly request;
+    private readonly now;
+    private journal;
+    private state;
+    private message;
+    private selectedSource;
+    private sourceSeenAt;
+    private speed;
+    private tail;
+    private outstanding;
+    private flight;
+    private controller;
+    private timer;
+    private stopped;
+    private dropped;
+    private nextSendAt;
+    private readonly file;
+    private journalBytes;
+    constructor(directory: string, config: NoForeignLandConfig, emit: (status: ReturnType<NoForeignLandPublisher["status"]>) => void, request?: typeof fetch, now?: () => number);
+    status(): {
+        state: PublisherState;
+        message: string;
+        pending: number;
+        dropped: number;
+        savedAt: number | null;
+        sentAt: number | null;
+        source: string | null;
+    };
+    start(schedule?: boolean): Promise<void>;
+    observe(event: EventInput): void;
+    idle(): Promise<void>;
+    flush(): Promise<void>;
+    private send;
+    private save;
+    private schedule;
+    stop(): Promise<void>;
+}

package/dist/src/noforeignland.js

@@ -0,0 +1,425 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoForeignLandPublisher = void 0;
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const geometry_1 = require("./geometry");
+const version_1 = require("./version");
+const MAX_POINTS = 10_000;
+const MAX_FILE_BYTES = 4_000_000;
+const ENDPOINT = "https://www.noforeignland.com/home/api/v1/boat/tracking/track";
+/** Independent, bounded publisher consuming the connector's existing observations. */
+class NoForeignLandPublisher {
+    directory;
+    config;
+    emit;
+    request;
+    now;
+    journal;
+    state = "disabled";
+    message = "Disabled";
+    selectedSource = null;
+    sourceSeenAt = 0;
+    speed = null;
+    tail = Promise.resolve();
+    outstanding = 0;
+    flight = null;
+    controller = null;
+    timer = null;
+    stopped = false;
+    dropped = 0;
+    nextSendAt = 0;
+    file;
+    journalBytes = 0;
+    constructor(directory, config, emit, request = fetch, now = Date.now) {
+        this.directory = directory;
+        this.config = config;
+        this.emit = emit;
+        this.request = request;
+        this.now = now;
+        this.file = (0, node_path_1.join)(directory, "publisher.jsonl");
+        this.journal = {
+            version: 1,
+            account: (0, node_crypto_1.createHash)("sha256").update(config.boatKey).digest("hex"),
+            pending: [],
+            last: null,
+            sentAt: null,
+        };
+    }
+    status() {
+        return {
+            state: this.state,
+            message: this.message,
+            pending: this.journal.pending.length,
+            dropped: this.dropped,
+            savedAt: this.journal.last?.timestamp ?? null,
+            sentAt: this.journal.sentAt,
+            source: this.selectedSource,
+        };
+    }
+    async start(schedule = true) {
+        if (!this.config.enabled)
+            return;
+        try {
+            // Signal K stores the two historical plugin IDs alongside this plugin.
+            for (const name of [
+                "signalk-to-noforeignland.json",
+                "@noforeignland-signalk-to-noforeignland.json",
+            ]) {
+                try {
+                    const other = JSON.parse(await (0, promises_1.readFile)((0, node_path_1.join)((0, node_path_1.dirname)((0, node_path_1.dirname)(this.directory)), name), "utf8"));
+                    if (other.enabled === true) {
+                        this.state = "error";
+                        this.message =
+                            "Disable the separate NoForeignLand plugin before enabling publication";
+                        this.emit(this.status());
+                        return;
+                    }
+                }
+                catch (error) {
+                    if (error.code !== "ENOENT")
+                        throw error;
+                }
+            }
+            await (0, promises_1.mkdir)(this.directory, { recursive: true, mode: 0o700 });
+            try {
+                if ((await (0, promises_1.stat)(this.file)).size > MAX_FILE_BYTES)
+                    throw new Error("oversized");
+                const contents = await (0, promises_1.readFile)(this.file, "utf8");
+                const lines = contents.trimEnd().split("\n");
+                const saved = JSON.parse(lines.shift() ?? "");
+                if (saved.version !== 1 ||
+                    saved.account !== this.journal.account ||
+                    !Array.isArray(saved.pending))
+                    throw new Error("invalid journal or changed boat");
+                for (const line of lines) {
+                    const record = JSON.parse(line);
+                    if (record.point && validPoint(record.point)) {
+                        if (saved.last && record.point.timestamp <= saved.last.timestamp)
+                            throw new Error("invalid order");
+                        saved.pending.push(record.point);
+                        saved.last = record.point;
+                    }
+                    else if (Number.isFinite(record.ack) &&
+                        Number.isFinite(record.sentAt)) {
+                        saved.pending = saved.pending.filter((point) => point.timestamp > record.ack);
+                        saved.sentAt = record.sentAt;
+                    }
+                    else
+                        throw new Error("invalid record");
+                    if (saved.pending.length > MAX_POINTS)
+                        throw new Error("queue limit");
+                }
+                if (saved.pending.length > MAX_POINTS ||
+                    !saved.pending.every(validPoint) ||
+                    (saved.last !== null && !validPoint(saved.last)) ||
+                    (saved.sentAt !== null && !Number.isFinite(saved.sentAt)))
+                    throw new Error("invalid journal");
+                this.journalBytes = Buffer.byteLength(contents);
+                this.journal = saved;
+            }
+            catch (error) {
+                if (error.code !== "ENOENT")
+                    throw error;
+            }
+            this.state = "ready";
+            this.message = "Waiting for current position";
+            this.nextSendAt = this.now() + this.config.sendIntervalSeconds * 1000;
+            if (schedule)
+                this.schedule();
+        }
+        catch {
+            this.state = "error";
+            this.message = "Publisher storage unavailable or belongs to another boat";
+        }
+        this.emit(this.status());
+    }
+    observe(event) {
+        if (!this.config.enabled ||
+            this.stopped ||
+            this.state === "disabled" ||
+            this.state === "error" ||
+            event.context !== "vessels.self")
+            return;
+        if (event.path !== "navigation.position" &&
+            event.path !== "navigation.speedOverGround")
+            return;
+        if (this.outstanding >= 32) {
+            this.dropped++;
+            return;
+        }
+        this.outstanding++;
+        this.tail = this.tail
+            .then(async () => {
+            if (this.stopped || this.state === "error")
+                return;
+            const time = event.source_timestamp === null
+                ? NaN
+                : Date.parse(event.source_timestamp);
+            if (!Number.isFinite(time) ||
+                time > this.now() + 5000 ||
+                time < this.now() - 120_000)
+                return;
+            if (this.config.source && event.source !== this.config.source)
+                return;
+            if (event.path === "navigation.speedOverGround") {
+                if (typeof event.value === "number" && event.value >= 0)
+                    this.speed = { value: event.value, at: time, source: event.source };
+                return;
+            }
+            const position = event.value;
+            const point = {
+                ...position,
+                timestamp: time,
+                source: event.source,
+            };
+            if (!validPoint(point))
+                return;
+            if (this.selectedSource !== null &&
+                event.source !== this.selectedSource &&
+                this.now() - this.sourceSeenAt < 300_000)
+                return;
+            this.selectedSource = event.source;
+            this.sourceSeenAt = this.now();
+            const last = this.journal.last;
+            if (last && time <= last.timestamp)
+                return;
+            const distance = last ? (0, geometry_1.distanceMeters)(last, point) : 0;
+            if (last &&
+                distance / ((time - last.timestamp) / 1000) >
+                    this.config.maximumVelocity)
+                return;
+            if (last && time - last.timestamp < this.config.sampleSeconds * 1000)
+                return;
+            const heartbeat = this.config.keepalive &&
+                last !== null &&
+                time - last.timestamp >= 86_400_000;
+            if (!heartbeat) {
+                if (last && distance < this.config.minimumMoveMeters)
+                    return;
+                if (this.config.minimumSpeedKnots > 0 &&
+                    (!this.speed ||
+                        this.speed.source !== event.source ||
+                        Math.abs(time - this.speed.at) > 120_000 ||
+                        this.speed.value * 1.943844 < this.config.minimumSpeedKnots))
+                    return;
+            }
+            if (this.journal.pending.length >= MAX_POINTS) {
+                this.dropped++;
+                this.message = "Offline queue full - new points omitted";
+                this.emit(this.status());
+                return;
+            }
+            const updated = {
+                ...this.journal,
+                pending: [...this.journal.pending, point],
+                last: point,
+            };
+            await this.save(updated);
+            this.journal = updated;
+            this.emit(this.status());
+        })
+            .catch(() => {
+            this.state = "error";
+            this.message = "Publisher storage failed; pending track retained";
+            this.emit(this.status());
+        })
+            .finally(() => {
+            this.outstanding--;
+        });
+    }
+    async idle() {
+        await this.tail;
+    }
+    async flush() {
+        if (this.flight)
+            return this.flight;
+        this.flight = this.send().finally(() => {
+            this.flight = null;
+        });
+        return this.flight;
+    }
+    async send() {
+        await this.tail;
+        if (this.stopped ||
+            !this.config.enabled ||
+            this.state === "error" ||
+            this.state === "disabled" ||
+            !this.journal.pending.length ||
+            this.now() < this.nextSendAt)
+            return;
+        if (!this.config.sendWhileMoving &&
+            this.journal.last &&
+            this.now() - this.journal.last.timestamp <
+                this.config.sampleSeconds * 2000)
+            return;
+        const batch = this.journal.pending.slice(0, 500);
+        this.state = "sending";
+        this.message = "Sending track";
+        this.emit(this.status());
+        this.controller = new AbortController();
+        const timeout = setTimeout(() => this.controller?.abort(), 30_000);
+        try {
+            const response = await this.request(ENDPOINT, {
+                method: "POST",
+                redirect: "error",
+                signal: this.controller.signal,
+                headers: {
+                    "X-NFL-API-Key": this.config.applicationKey,
+                    "Accept-Encoding": "identity",
+                },
+                body: new URLSearchParams({
+                    timestamp: String(batch[batch.length - 1].timestamp),
+                    track: JSON.stringify(batch.map((p) => [p.timestamp, p.latitude, p.longitude])),
+                    boatApiKey: this.config.boatKey,
+                    pluginVersion: `aurora-blue/${version_1.CONNECTOR_VERSION}`,
+                    nodeVersion: process.version,
+                    skVersion: "unknown",
+                }),
+            });
+            if (!response.ok) {
+                await response.body?.cancel();
+                if (response.status >= 400 &&
+                    response.status < 500 &&
+                    response.status !== 429) {
+                    this.state = "error";
+                    this.message = `Publication rejected (HTTP ${response.status}); check configuration`;
+                    return;
+                }
+                throw new Error("retry");
+            }
+            // Require an explicit acknowledgement. An ambiguous response retains data;
+            // exactly-once delivery requires a provider-supported idempotency contract.
+            const reader = response.body?.getReader();
+            if (!reader)
+                throw new Error("missing response");
+            let body = "";
+            for (;;) {
+                const chunk = await reader.read();
+                if (chunk.done)
+                    break;
+                if (body.length + chunk.value.length > 4096) {
+                    await reader.cancel();
+                    throw new Error("large response");
+                }
+                body += new TextDecoder().decode(chunk.value);
+            }
+            if (JSON.parse(body).status !== "ok") {
+                this.state = "error";
+                this.message = "Publication rejected by provider; check configuration";
+                return;
+            }
+            const cutoff = batch[batch.length - 1].timestamp;
+            // Serialize acknowledgement with writes that arrived during the request.
+            this.tail = this.tail.then(async () => {
+                const updated = {
+                    ...this.journal,
+                    pending: this.journal.pending.filter((p) => p.timestamp > cutoff),
+                    sentAt: this.now(),
+                };
+                await this.save(updated);
+                this.journal = updated;
+            });
+            try {
+                await this.tail;
+            }
+            catch {
+                this.tail = Promise.resolve();
+                this.state = "error";
+                this.message =
+                    "Publication acknowledged but checkpoint failed; inspect before retry";
+                return;
+            }
+            this.state = "ready";
+            this.message = "Track published";
+        }
+        catch {
+            if (this.state !== "error") {
+                this.state = "waiting";
+                this.message = "Transfer delayed; pending track retained";
+            }
+        }
+        finally {
+            clearTimeout(timeout);
+            this.controller = null;
+            this.nextSendAt = this.now() + this.config.sendIntervalSeconds * 1000;
+            this.emit(this.status());
+        }
+    }
+    async save(updated) {
+        const capacity = await (0, promises_1.statfs)(this.directory);
+        if (capacity.bavail * capacity.bsize < 32 * 1024 * 1024)
+            throw new Error("reserve");
+        if (this.journalBytes === 0 || this.journalBytes > 2_000_000) {
+            const payload = JSON.stringify(updated) + "\n";
+            if (Buffer.byteLength(payload) > MAX_FILE_BYTES)
+                throw new Error("limit");
+            const temporary = `${this.file}.tmp`;
+            const handle = await (0, promises_1.open)(temporary, "w", 0o600);
+            try {
+                await handle.writeFile(payload);
+                await handle.sync();
+            }
+            finally {
+                await handle.close();
+            }
+            await (0, promises_1.rename)(temporary, this.file);
+            const directory = await (0, promises_1.open)(this.directory, "r");
+            try {
+                await directory.sync();
+            }
+            finally {
+                await directory.close();
+            }
+            this.journalBytes = Buffer.byteLength(payload);
+            return;
+        }
+        const record = updated.last !== this.journal.last
+            ? { point: updated.last }
+            : {
+                ack: this.journal.pending[this.journal.pending.length - updated.pending.length - 1]?.timestamp,
+                sentAt: updated.sentAt,
+            };
+        const payload = JSON.stringify(record) + "\n";
+        const handle = await (0, promises_1.open)(this.file, "a", 0o600);
+        try {
+            await handle.writeFile(payload);
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        this.journalBytes += Buffer.byteLength(payload);
+    }
+    schedule() {
+        this.timer = setTimeout(() => {
+            void this.flush().finally(() => {
+                if (!this.stopped)
+                    this.schedule();
+            });
+        }, this.config.sendIntervalSeconds * 1000);
+        this.timer.unref();
+    }
+    async stop() {
+        this.stopped = true;
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.controller?.abort();
+        await this.flight;
+        await this.tail;
+    }
+}
+exports.NoForeignLandPublisher = NoForeignLandPublisher;
+function validPoint(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const p = value;
+    return (Number.isFinite(p.timestamp) &&
+        Number.isFinite(p.latitude) &&
+        Math.abs(p.latitude) <= 90 &&
+        Number.isFinite(p.longitude) &&
+        Math.abs(p.longitude) <= 180 &&
+        (p.source === null ||
+            (typeof p.source === "string" && p.source.length <= 255)));
+}

package/dist/src/telemetry-catalog.d.ts

@@ -1,6 +1,6 @@
 import type { EventContext } from "./types";
 export type TelemetryScope = "self" | "ais";
-export type ValueKind = "number" | "position" | "string" | "aisShipType";
+export type ValueKind = "number" | "position" | "string" | "boolean" | "switch" | "aisShipType" | "json";
 export type ChangeKind = "scalar" | "angle" | "position" | "identity";
 export interface TelemetryDefinition {
     scope: TelemetryScope;
@@ -13,6 +13,8 @@ export interface TelemetryDefinition {
 }
 export declare const SELF_TELEMETRY: readonly TelemetryDefinition[];
 export declare const AIS_TELEMETRY: readonly TelemetryDefinition[];
+export declare const NAVIGATION_SUBSCRIPTION_PATHS: readonly ["navigation.*", "environment.wind.*", "environment.depth.*", "environment.current", "environment.current.*", "environment.tide.*", "environment.outside.*", "environment.water.*", "environment.heave", "performance.*", "steering.*"];
+export declare const isNavigationPath: (path: string) => boolean;
 export declare const SELF_SUBSCRIPTION_PATHS: string[];
 export declare const AIS_SUBSCRIPTION_PATHS: string[];
 export declare const isAisContext: (context: string) => context is EventContext;

package/dist/src/telemetry-catalog.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.telemetryDefinition = exports.isAisContext = exports.AIS_SUBSCRIPTION_PATHS = exports.SELF_SUBSCRIPTION_PATHS = exports.AIS_TELEMETRY = exports.SELF_TELEMETRY = void 0;
+exports.telemetryDefinition = exports.isAisContext = exports.AIS_SUBSCRIPTION_PATHS = exports.SELF_SUBSCRIPTION_PATHS = exports.isNavigationPath = exports.NAVIGATION_SUBSCRIPTION_PATHS = exports.AIS_TELEMETRY = exports.SELF_TELEMETRY = void 0;
 const degrees = (value) => (value * Math.PI) / 180;
 const self = (path, valueKind, changeKind, minimumIntervalMs, maximumHeartbeatMs, changeThreshold) => ({
     scope: "self",
@@ -72,7 +72,27 @@ exports.AIS_TELEMETRY = [
     ais("communication.callsignVhf", "string", "identity", 60_000, 21_600_000, 0),
     ais("design.aisShipType", "aisShipType", "identity", 60_000, 21_600_000, 0),
 ];
-exports.SELF_SUBSCRIPTION_PATHS = exports.SELF_TELEMETRY.map((definition) => definition.path);
+exports.NAVIGATION_SUBSCRIPTION_PATHS = [
+    "navigation.*",
+    "environment.wind.*",
+    "environment.depth.*",
+    "environment.current",
+    "environment.current.*",
+    "environment.tide.*",
+    "environment.outside.*",
+    "environment.water.*",
+    "environment.heave",
+    "performance.*",
+    "steering.*",
+];
+const isNavigationPath = (path) => path.length <= 255 &&
+    (/^(?:navigation|performance|steering|environment\.(?:wind|depth|current|tide|outside|water))(?:\.[A-Za-z0-9_:-]+)+$/.test(path) ||
+        path === "environment.current" ||
+        path === "environment.heave");
+exports.isNavigationPath = isNavigationPath;
+exports.SELF_SUBSCRIPTION_PATHS = exports.SELF_TELEMETRY.filter((definition) => !(0, exports.isNavigationPath)(definition.path))
+    .map((definition) => definition.path)
+    .concat(...exports.NAVIGATION_SUBSCRIPTION_PATHS, "electrical.switches.*");
 exports.AIS_SUBSCRIPTION_PATHS = exports.AIS_TELEMETRY.map((definition) => definition.path);
 const matchesPath = (pattern, path) => {
     const patternParts = pattern.split(".");
@@ -83,11 +103,20 @@ const matchesPath = (pattern, path) => {
 const isAisContext = (context) => /^vessels\.(?:urn:mrn:imo:mmsi:)?[0-9]{9}$/.test(context);
 exports.isAisContext = isAisContext;
 const telemetryDefinition = (context, path) => {
+    if (context === "vessels.self" &&
+        path.startsWith("electrical.switches.") &&
+        path.length <= 255 &&
+        /^electrical\.switches\.[A-Za-z0-9_:-]+(?:\.[A-Za-z0-9_:-]+)+$/.test(path)) {
+        return self(path, "switch", "identity", 0, 60_000, 0);
+    }
     const definitions = context === "vessels.self"
         ? exports.SELF_TELEMETRY
         : (0, exports.isAisContext)(context)
             ? exports.AIS_TELEMETRY
             : [];
-    return (definitions.find((definition) => matchesPath(definition.path, path)) ?? null);
+    return (definitions.find((definition) => matchesPath(definition.path, path)) ??
+        (context === "vessels.self" && (0, exports.isNavigationPath)(path)
+            ? self(path, "json", "identity", 2_000, 60_000, 0)
+            : null));
 };
 exports.telemetryDefinition = telemetryDefinition;

package/dist/src/telemetry-reducer.js

@@ -51,7 +51,8 @@ const changedEnough = (kind, previous, current, threshold) => {
             !("latitude" in current)) {
             return true;
         }
-        return (0, geometry_1.distanceMeters)(previous, current) >= threshold;
+        return ((0, geometry_1.distanceMeters)(previous, current) >=
+            threshold);
     }
     if (kind === "identity") {
         return JSON.stringify(previous) !== JSON.stringify(current);

package/dist/src/types.d.ts

@@ -12,6 +12,7 @@ export interface RuntimeConfiguration {
 export type EventContext = "vessels.self" | `vessels.${number}` | `vessels.urn:mrn:imo:mmsi:${number}`;
 export type AllowedPath = string;
 export interface PositionValue {
+    altitude?: number;
     latitude: number;
     longitude: number;
 }
@@ -19,7 +20,7 @@ export interface AisShipTypeValue {
     id: number;
     name: string;
 }
-export type EventValue = number | string | PositionValue | AisShipTypeValue;
+export type EventValue = number | string | boolean | PositionValue | AisShipTypeValue | Record<string, unknown> | unknown[];
 export interface EventInput {
     boot_id: string;
     context: EventContext;

package/dist/src/version.d.ts

@@ -1 +1 @@
-export declare const CONNECTOR_VERSION = "0.2.0-dev.22";
+export declare const CONNECTOR_VERSION = "0.2.0-dev.26";

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aurora-blue/signalk-connector",
-  "version": "0.2.0-dev.22",
+  "version": "0.2.0-dev.26",
   "description": "Signal K edge connector for the Aurora Blue ABOARD ingest protocol",
   "private": false,
   "main": "dist/src/index.js",
@@ -18,7 +18,8 @@
     "signalk-category-cloud"
   ],
   "signalk": {
-    "displayName": "Aurora Blue ABOARD Connector Status"
+    "appIcon": "./favicon.svg",
+    "displayName": "Aurora Blue ABOARD SK"
   },
   "signalk-plugin-enabled-by-default": false,
   "engines": {
@@ -43,6 +44,7 @@
     "verify:platforms": "sh tools/verify-platforms.sh",
     "release:build": "node tools/release.mjs build",
     "release:stage": "node tools/release.mjs stage",
+    "release:publish": "node tools/release.mjs publish",
     "release:verify": "node tools/release.mjs verify"
   },
   "devDependencies": {

package/public/ci-tokens.css

@@ -46,6 +46,9 @@
     --aboard-danger: #b83245;
     --aboard-scrim-rgb: 15 34 39;
     --aboard-shadow-rgb: 25 51 57;
+    --aboard-map-departure: #f0c76e;
+    --aboard-map-arrival: #65e0c0;
+    --aboard-map-endpoint-ink: #12313c;
     --aboard-map-water: #cfe5ec;
     --aboard-map-land: #e6ebe1;
     --aboard-map-coast: #789197;
@@ -134,6 +137,9 @@
     :root { --aboard-font-title: 1.75rem; }
 }
 
+/* Machine-readable codes retain a white quiet zone in every theme. */
+:root { --aboard-qr-background: #fff; --aboard-qr-foreground: #000; }
+
 :root { --aboard-chart: url("aurora-blue-archipelago-light.svg"); }
 @media (prefers-color-scheme: dark) { :root:not([data-theme]) { --aboard-chart: url("aurora-blue-archipelago-dark.svg"); } }
 :root[data-theme="dark"] { --aboard-chart: url("aurora-blue-archipelago-dark.svg"); }

package/public/favicon.svg

@@ -1,7 +1,16 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 591 591" role="img" aria-labelledby="title">
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1024 1024" role="img" aria-labelledby="title">
   <title id="title">Aurora Blue ABOARD</title>
-  <g fill="#7ee4e6" transform="matrix(1,0,0,1,-889,-2810)">
+  <defs>
+    <linearGradient id="aboard-icon-gradient" x1="100%" y1="0%" x2="0%" y2="100%">
+      <stop offset="0%" stop-color="#279fa8"/>
+      <stop offset="52%" stop-color="#167f88"/>
+      <stop offset="100%" stop-color="#123e56"/>
+    </linearGradient>
+  </defs>
+  <rect width="1024" height="1024" fill="url(#aboard-icon-gradient)"/>
+  <g transform="translate(13.319897172236494 13.319897172236494) scale(1.687580720229318)">
+<g fill="#ffffff" transform="matrix(1,0,0,1,-889,-2810)">
     <g transform="matrix(1,0,0,1,-637,622)">
       <g transform="matrix(2.572721,0,0,2.572721,1472.604933,2173.221564)">
         <g transform="matrix(0.720795,0,0,0.720795,199.370511,207.270387)">
@@ -16,4 +25,6 @@
       </g>
     </g>
   </g>
+
+  </g>
 </svg>

package/public/index.html

@@ -4,8 +4,9 @@
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1" />
     <meta name="color-scheme" content="dark light" />
-    <title data-i18n="page.title">Aurora Blue ABOARD Connector Status</title>
-    <link rel="icon" href="favicon.svg?v=3" type="image/svg+xml" />
+    <title data-i18n="page.title">Aurora Blue ABOARD SK</title>
+    <link rel="icon" href="favicon.ico?v=6" type="image/x-icon" />
+    <link rel="icon" href="favicon.svg?v=6" type="image/svg+xml" />
     <link rel="stylesheet" href="ci-fonts.css" />
     <link rel="stylesheet" href="ci-tokens.css" />
     <link rel="stylesheet" href="ci-brand.css?v=5" />
@@ -16,7 +17,7 @@
       <header class="brand-header">
         <div
           class="aurora-blue-brand"
-          aria-label="Aurora Blue ABOARD, Signal K Connector"
+          aria-label="Aurora Blue ABOARD SK"
           data-i18n-aria-label="brand.label"
           style="
             --aurora-blue-mark-url: url(&quot;aurora-blue-aboard-mark.svg&quot;);

package/public/locales/de.json

@@ -1,7 +1,7 @@
 {
-  "page.title": "Aurora Blue ABOARD Connector-Status",
+  "page.title": "Aurora Blue ABOARD SK",
   "brand.context": "Signal K Connector",
-  "brand.label": "Aurora Blue ABOARD, Signal K Connector",
+  "brand.label": "Aurora Blue ABOARD SK",
   "appearance.system": "Systemdarstellung: {appearance}",
   "appearance.dark": "dunkel",
   "appearance.light": "hell",

package/public/locales/en.json

@@ -1,7 +1,7 @@
 {
-  "page.title": "Aurora Blue ABOARD Connector Status",
+  "page.title": "Aurora Blue ABOARD SK",
   "brand.context": "Signal K Connector",
-  "brand.label": "Aurora Blue ABOARD, Signal K Connector",
+  "brand.label": "Aurora Blue ABOARD SK",
   "appearance.system": "System appearance: {appearance}",
   "appearance.dark": "dark",
   "appearance.light": "light",

package/public/locales/es.json

@@ -1,7 +1,7 @@
 {
-  "page.title": "Estado del conector Aurora Blue ABOARD",
+  "page.title": "Aurora Blue ABOARD SK",
   "brand.context": "Conector Signal K",
-  "brand.label": "Aurora Blue ABOARD, conector Signal K",
+  "brand.label": "Aurora Blue ABOARD SK",
   "appearance.system": "Apariencia del sistema: {appearance}",
   "appearance.dark": "oscura",
   "appearance.light": "clara",

package/public/locales/fr.json

@@ -1,7 +1,7 @@
 {
-  "page.title": "État du connecteur Aurora Blue ABOARD",
+  "page.title": "Aurora Blue ABOARD SK",
   "brand.context": "Connecteur Signal K",
-  "brand.label": "Aurora Blue ABOARD, connecteur Signal K",
+  "brand.label": "Aurora Blue ABOARD SK",
   "appearance.system": "Apparence du système : {appearance}",
   "appearance.dark": "sombre",
   "appearance.light": "claire",