@aurora-blue/signalk-connector 0.2.0-dev.20

package/dist/src/connector.js

@@ -0,0 +1,487 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectorRuntime = exports.CONNECTOR_VERSION = void 0;
+const node_crypto_1 = require("node:crypto");
+const backoff_1 = require("./backoff");
+const delta_1 = require("./delta");
+const http_client_1 = require("./http-client");
+const storage_budget_1 = require("./storage-budget");
+const anchor_alarm_1 = require("./safety/anchor-alarm");
+const telemetry_catalog_1 = require("./telemetry-catalog");
+const telemetry_reducer_1 = require("./telemetry-reducer");
+// Bound work waiting for flash writes in the shared Signal K process.
+const MAXIMUM_PENDING_CAPTURE_EVENTS = 256;
+const version_1 = require("./version");
+var version_2 = require("./version");
+Object.defineProperty(exports, "CONNECTOR_VERSION", { enumerable: true, get: function () { return version_2.CONNECTOR_VERSION; } });
+const formatBytes = (bytes) => {
+    if (bytes < 1024) {
+        return `${bytes} B`;
+    }
+    if (bytes < 1024 * 1024) {
+        return `${(bytes / 1024).toFixed(1)} KiB`;
+    }
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MiB`;
+};
+class ConnectorRuntime {
+    app;
+    store;
+    config;
+    bootId;
+    now;
+    random;
+    unsubscribes = [];
+    timer = null;
+    safetyTimer = null;
+    runtimeConfigurationTimer = null;
+    stopped = false;
+    retryAttempt = 0;
+    droppedEvents = 0;
+    suppressedEvents = 0;
+    transferNotice = null;
+    operatingMode = "active";
+    runtimeConfigurationPollMs = 60_000;
+    runtimeConfigurationState = "cached";
+    runtimeConfigurationUpdatedAt = null;
+    client;
+    autoSchedule;
+    anchorAlarm;
+    telemetryReducer;
+    monotonicNow;
+    filesystemCapacity = null;
+    nextCapacityRefreshAt = 0;
+    storageBudget;
+    emissionTimes = [];
+    captureTail = Promise.resolve();
+    pendingCaptureEvents = 0;
+    nextCaptureStatusAt = 0;
+    constructor(app, store, config, options = {}) {
+        this.app = app;
+        this.store = store;
+        this.config = config;
+        this.now = options.now ?? (() => new Date().toISOString());
+        this.bootId = (options.uuid ?? node_crypto_1.randomUUID)();
+        this.random = options.random ?? Math.random;
+        this.monotonicNow = options.monotonicNow ?? Date.now;
+        this.client = options.client ?? null;
+        this.autoSchedule = options.autoSchedule ?? true;
+        const startedAt = Date.parse(this.now());
+        this.anchorAlarm = new anchor_alarm_1.AnchorAlarmEngine(config.anchorAlarm, Number.isFinite(startedAt) ? startedAt : Date.now());
+        this.telemetryReducer = new telemetry_reducer_1.TelemetryReducer(config.adaptiveTelemetryEnabled, (0, telemetry_reducer_1.rulesForProfile)(config.operatingProfile));
+        this.storageBudget = (0, storage_budget_1.resolveStorageBudget)(this.storageBudgetPolicy(), { events: 0, bytes: 0, averageRecordBytes: null }, null);
+    }
+    async start() {
+        await this.store.load();
+        await this.refreshStorageBudget(true);
+        this.client ??= new http_client_1.AuroraBlueHttpClient(this.config.targetUrl, this.config.requestTimeoutMs, fetch, this.config.compressionEnabled
+            ? this.config.compressionThresholdBytes
+            : null);
+        let state = await this.store.summary();
+        if (state.device_id === null && this.config.pairingCode !== undefined) {
+            const pairing = await this.client.pair(this.config.pairingCode, this.config.deviceName, version_1.CONNECTOR_VERSION);
+            await this.store.setPairing(pairing);
+            state = await this.store.summary();
+        }
+        if (state.device_id === null) {
+            this.app.setPluginStatus("Unpaired - enter an Aurora Blue pairing code in plugin settings.");
+            return;
+        }
+        this.operatingMode = state.operating_mode;
+        this.configureSubscriptions();
+        this.publishAnchorState(this.anchorAlarm.snapshot());
+        this.startSafetyTimer();
+        await this.updateStatus();
+        this.scheduleRuntimeConfigurationPoll(0);
+        if (this.operatingMode !== "disabled") {
+            this.schedule(0);
+        }
+    }
+    async stop() {
+        this.stopped = true;
+        if (this.timer !== null) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        if (this.safetyTimer !== null) {
+            clearInterval(this.safetyTimer);
+            this.safetyTimer = null;
+        }
+        if (this.runtimeConfigurationTimer !== null) {
+            clearTimeout(this.runtimeConfigurationTimer);
+            this.runtimeConfigurationTimer = null;
+        }
+        for (const unsubscribe of this.unsubscribes.splice(0)) {
+            unsubscribe();
+        }
+        await this.captureTail;
+        await this.store.summary();
+    }
+    async capture(delta, subscriptionScope = "self") {
+        if (this.stopped) {
+            return;
+        }
+        const receivedAt = this.now();
+        const events = (0, delta_1.eventsFromDelta)(delta, this.bootId, receivedAt, subscriptionScope);
+        // Safety observes current positions immediately, even when historical
+        // telemetry admission is saturated by slow storage.
+        for (const event of events) {
+            if (event.context === "vessels.self" &&
+                event.path === "navigation.position" &&
+                typeof event.value === "object" &&
+                "latitude" in event.value) {
+                const observedAt = Date.parse(event.received_at);
+                const transition = this.anchorAlarm.observe(event.value, Number.isFinite(observedAt) ? observedAt : Date.now());
+                this.publishAnchorTransition(transition);
+            }
+        }
+        if (this.operatingMode !== "active" || events.length === 0) {
+            return;
+        }
+        const admitted = events.slice(0, MAXIMUM_PENDING_CAPTURE_EVENTS - this.pendingCaptureEvents);
+        this.droppedEvents += events.length - admitted.length;
+        if (admitted.length === 0) {
+            return;
+        }
+        this.pendingCaptureEvents += admitted.length;
+        const current = this.captureTail.then(() => this.captureEvents(admitted));
+        this.captureTail = current.catch(() => undefined);
+        try {
+            await current;
+        }
+        finally {
+            this.pendingCaptureEvents -= admitted.length;
+        }
+    }
+    async captureEvents(events) {
+        let budget = await this.refreshStorageBudget();
+        for (const event of events) {
+            if (this.stopped || this.operatingMode !== "active") {
+                return;
+            }
+            if (!this.telemetryReducer.shouldEmit(event, budget.pressure)) {
+                this.suppressedEvents += 1;
+                continue;
+            }
+            const buffered = await this.store.append(event, budget.eventLimit, budget.byteLimit);
+            if (buffered === null) {
+                this.droppedEvents += 1;
+            }
+            else {
+                this.telemetryReducer.record(event);
+                this.recordEmission(event.received_at);
+            }
+            budget = await this.refreshStorageBudget();
+        }
+        const now = this.monotonicNow();
+        if (now >= this.nextCaptureStatusAt) {
+            this.nextCaptureStatusAt = now + 1_000;
+            await this.updateStatus();
+        }
+    }
+    async status() {
+        const budget = await this.refreshStorageBudget();
+        const state = await this.store.summary();
+        const emittedPerHour = this.emittedPerHour();
+        return {
+            paired: state.device_id !== null,
+            deviceId: state.device_id,
+            bufferedEvents: state.bufferedEvents,
+            acceptedThrough: state.accepted_through,
+            lastSuccessAt: state.last_success_at,
+            droppedEvents: this.droppedEvents,
+            suppressedEvents: this.suppressedEvents,
+            anchorAlarmState: this.anchorAlarm.snapshot().state,
+            bufferedBytes: budget.byteLimit - budget.remainingBytes,
+            bufferByteLimit: budget.byteLimit,
+            bufferEventLimit: budget.eventLimit,
+            bufferUtilization: budget.utilization,
+            bufferPressure: budget.pressure,
+            storageProfile: budget.requestedProfile,
+            resolvedStorageProfile: budget.resolvedProfile,
+            filesystemFreeBytes: budget.filesystem?.freeBytes ?? null,
+            estimatedRemainingBufferHours: emittedPerHour === null
+                ? null
+                : budget.remainingEvents / emittedPerHour,
+            operatingMode: state.operating_mode,
+            transferState: this.transferNotice !== null
+                ? "delayed"
+                : state.last_success_at === null
+                    ? "waiting"
+                    : "healthy",
+            transferMessage: this.transferNotice,
+            runtimeConfigurationState: this.runtimeConfigurationState,
+            runtimeConfigurationUpdatedAt: this.runtimeConfigurationUpdatedAt,
+        };
+    }
+    async flush() {
+        if (this.stopped ||
+            this.client === null ||
+            this.operatingMode === "disabled") {
+            return;
+        }
+        const state = await this.store.summary();
+        if (state.device_id === null || state.access_token === null) {
+            return;
+        }
+        const batch = await this.store.pendingBatch(this.config.batchSize);
+        if (batch === null) {
+            this.retryAttempt = 0;
+            await this.updateStatus();
+            if (this.operatingMode === "active") {
+                this.schedule(this.config.flushIntervalMs);
+            }
+            return;
+        }
+        try {
+            const acknowledgement = await this.client.sendBatch(batch, state.access_token);
+            await this.store.acknowledge(acknowledgement.accepted_through);
+            await this.applyRuntimeConfiguration(acknowledgement.runtime_configuration);
+            this.retryAttempt = 0;
+            this.transferNotice = null;
+            this.app.reportOutputMessages(batch.events.length);
+            await this.updateStatus();
+            const remaining = (await this.store.summary()).bufferedEvents;
+            if (this.operatingMode === "active") {
+                this.schedule(remaining > 0 ? 0 : this.config.flushIntervalMs);
+            }
+            else if (this.operatingMode === "standby" && remaining > 0) {
+                this.schedule(0);
+            }
+        }
+        catch (error) {
+            this.retryAttempt += 1;
+            const delay = (0, backoff_1.retryDelay)(this.retryAttempt, this.config.retryMinimumMs, this.config.retryMaximumMs, this.random);
+            const reason = error instanceof http_client_1.AuroraBlueHttpError
+                ? `HTTP ${error.status}`
+                : "target unavailable";
+            this.transferNotice = `Transfer delayed (${reason}) - retry in ${Math.ceil(delay / 1000)}s`;
+            await this.updateStatus();
+            this.schedule(delay);
+        }
+    }
+    configureSubscriptions() {
+        for (const unsubscribe of this.unsubscribes.splice(0)) {
+            unsubscribe();
+        }
+        if (this.operatingMode === "disabled") {
+            return;
+        }
+        if (this.operatingMode === "standby") {
+            if (this.config.anchorAlarm.enabled) {
+                this.subscribeToContext("vessels.self", ["navigation.position"], this.config.safetySamplePeriodMs);
+            }
+            return;
+        }
+        this.subscribeToContext("vessels.self", telemetry_catalog_1.SELF_SUBSCRIPTION_PATHS, this.config.samplePeriodMs);
+        if (this.config.aisEnabled) {
+            this.subscribeToContext("vessels.*", telemetry_catalog_1.AIS_SUBSCRIPTION_PATHS, this.config.aisSamplePeriodMs);
+        }
+    }
+    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,
+            })),
+        }, this.unsubscribes, (error) => {
+            this.app.setPluginError("Signal K subscription failed.");
+            this.app.error(error instanceof Error ? error.message : String(error));
+        }, (delta) => {
+            void this.capture(delta, context === "vessels.self" ? "self" : "ais").catch((error) => {
+                this.app.setPluginError("Signal K data could not be buffered safely.");
+                this.app.error(error instanceof Error ? error.message : String(error));
+            });
+        });
+    }
+    startSafetyTimer() {
+        if (this.safetyTimer !== null) {
+            clearInterval(this.safetyTimer);
+            this.safetyTimer = null;
+        }
+        if (!this.autoSchedule ||
+            !this.config.anchorAlarm.enabled ||
+            this.operatingMode === "disabled") {
+            return;
+        }
+        this.safetyTimer = setInterval(() => {
+            const now = Date.parse(this.now());
+            const transition = this.anchorAlarm.checkStale(Number.isFinite(now) ? now : Date.now());
+            this.publishAnchorTransition(transition);
+        }, Math.min(1_000, this.config.anchorAlarm.stalePositionMs));
+    }
+    publishAnchorTransition(transition) {
+        if (transition === null) {
+            return;
+        }
+        this.publishAnchorState(transition);
+    }
+    publishAnchorState(snapshot) {
+        if (snapshot.state === "inactive") {
+            return;
+        }
+        const alarm = snapshot.state === "alarm" || snapshot.state === "position-lost";
+        const warning = snapshot.state === "warning";
+        const message = snapshot.state === "position-lost"
+            ? "Anchor watch has lost position data."
+            : snapshot.state === "alarm"
+                ? "Vessel remains outside the configured anchor radius."
+                : snapshot.state === "warning"
+                    ? "Vessel is outside the configured anchor radius."
+                    : "Anchor watch is armed.";
+        const value = {
+            state: alarm ? "alarm" : warning ? "warn" : "normal",
+            method: alarm ? ["visual", "sound"] : ["visual"],
+            message,
+            data: {
+                distanceMeters: snapshot.distanceMeters,
+                lastPositionAt: snapshot.lastPositionAt,
+            },
+        };
+        this.app.handleMessage("aurora-blue-signalk-connector", {
+            updates: [
+                {
+                    timestamp: snapshot.changedAt,
+                    values: [
+                        {
+                            path: "notifications.navigation.anchor",
+                            value,
+                        },
+                    ],
+                },
+            ],
+        });
+    }
+    schedule(delay) {
+        if (this.stopped ||
+            !this.autoSchedule ||
+            this.operatingMode === "disabled") {
+            return;
+        }
+        if (this.timer !== null) {
+            clearTimeout(this.timer);
+        }
+        this.timer = setTimeout(() => {
+            this.timer = null;
+            void this.flush();
+        }, delay);
+    }
+    scheduleRuntimeConfigurationPoll(delay) {
+        if (this.stopped || !this.autoSchedule) {
+            return;
+        }
+        if (this.runtimeConfigurationTimer !== null) {
+            clearTimeout(this.runtimeConfigurationTimer);
+        }
+        this.runtimeConfigurationTimer = setTimeout(() => {
+            this.runtimeConfigurationTimer = null;
+            void this.pollRuntimeConfiguration();
+        }, delay);
+    }
+    async pollRuntimeConfiguration() {
+        if (this.stopped || this.client === null) {
+            return;
+        }
+        const state = await this.store.summary();
+        if (state.access_token === null) {
+            return;
+        }
+        try {
+            const response = await this.client.fetchRuntimeConfiguration(state.access_token);
+            await this.applyRuntimeConfiguration(response.runtime_configuration);
+        }
+        catch {
+            this.runtimeConfigurationState = "unavailable";
+        }
+        await this.updateStatus();
+        this.scheduleRuntimeConfigurationPoll(this.runtimeConfigurationPollMs);
+    }
+    async applyRuntimeConfiguration(configuration) {
+        const previousMode = this.operatingMode;
+        this.runtimeConfigurationPollMs = configuration.poll_after_seconds * 1_000;
+        this.runtimeConfigurationState = "current";
+        this.runtimeConfigurationUpdatedAt = this.now();
+        if (configuration.operating_mode === previousMode) {
+            return;
+        }
+        this.operatingMode = configuration.operating_mode;
+        await this.store.setOperatingMode(configuration.operating_mode);
+        this.configureSubscriptions();
+        this.startSafetyTimer();
+        if (this.operatingMode === "disabled") {
+            if (this.timer !== null) {
+                clearTimeout(this.timer);
+                this.timer = null;
+            }
+            return;
+        }
+        const bufferedEvents = (await this.store.summary()).bufferedEvents;
+        if (this.operatingMode === "active" || bufferedEvents > 0) {
+            this.schedule(0);
+        }
+    }
+    async updateStatus() {
+        const status = await this.status();
+        const dropped = status.droppedEvents > 0 ? `, dropped ${status.droppedEvents}` : "";
+        const suppressed = status.suppressedEvents > 0
+            ? `, suppressed ${status.suppressedEvents}`
+            : "";
+        const lastSuccess = status.lastSuccessAt ?? "never";
+        const prefix = this.transferNotice ?? "Paired";
+        const utilization = (status.bufferUtilization * 100).toFixed(1);
+        const remaining = status.estimatedRemainingBufferHours === null
+            ? "estimating remaining time"
+            : `${status.estimatedRemainingBufferHours.toFixed(1)} h remaining`;
+        this.app.setPluginStatus(`${prefix} - mode ${status.operatingMode}, buffer ${status.bufferedEvents}/${status.bufferEventLimit} events, ${formatBytes(status.bufferedBytes)}/${formatBytes(status.bufferByteLimit)} (${utilization}%, ${status.bufferPressure}, ${status.storageProfile}:${status.resolvedStorageProfile}, ${remaining}), accepted ${status.acceptedThrough}${suppressed}${dropped}, anchor ${status.anchorAlarmState}, last transfer ${lastSuccess}.`);
+    }
+    storageBudgetPolicy() {
+        return {
+            requestedProfile: this.config.storageProfile,
+            customMaximumBytes: this.config.maxBufferBytes,
+            customReserveBytes: this.config.storageReserveBytes,
+            customMaximumFraction: this.config.storageMaximumFraction,
+            eventSafetyLimit: this.config.storageProfile === "custom"
+                ? this.config.maxBufferEvents
+                : 1_000_000,
+        };
+    }
+    async refreshStorageBudget(forceCapacity = false) {
+        const now = this.monotonicNow();
+        if (forceCapacity || now >= this.nextCapacityRefreshAt) {
+            this.filesystemCapacity = await this.store.filesystemCapacity();
+            this.nextCapacityRefreshAt = now + 60_000;
+        }
+        this.storageBudget = (0, storage_budget_1.resolveStorageBudget)(this.storageBudgetPolicy(), await this.store.journalMetrics(), this.filesystemCapacity);
+        return this.storageBudget;
+    }
+    recordEmission(receivedAt) {
+        const parsed = Date.parse(receivedAt);
+        const emittedAt = Number.isFinite(parsed) ? parsed : this.monotonicNow();
+        const previous = this.emissionTimes.at(-1);
+        if (previous !== undefined && emittedAt < previous) {
+            this.emissionTimes.length = 0;
+        }
+        this.emissionTimes.push(emittedAt);
+        const cutoff = emittedAt - 15 * 60_000;
+        while (this.emissionTimes.length > 1 &&
+            (this.emissionTimes[0] ?? emittedAt) < cutoff) {
+            this.emissionTimes.shift();
+        }
+    }
+    emittedPerHour() {
+        const first = this.emissionTimes[0];
+        const last = this.emissionTimes.at(-1);
+        if (first === undefined ||
+            last === undefined ||
+            this.emissionTimes.length < 2 ||
+            last - first < 60_000) {
+            return null;
+        }
+        return ((this.emissionTimes.length - 1) * 3_600_000) / (last - first);
+    }
+}
+exports.ConnectorRuntime = ConnectorRuntime;

package/dist/src/delta.d.ts

@@ -0,0 +1,4 @@
+import type { Delta } from "@signalk/server-api";
+import type { EventInput } from "./types";
+export type SubscriptionScope = "self" | "ais";
+export declare const eventsFromDelta: (delta: Delta, bootId: string, receivedAt: string, subscriptionScope?: SubscriptionScope) => EventInput[];

package/dist/src/delta.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventsFromDelta = void 0;
+const telemetry_catalog_1 = require("./telemetry-catalog");
+const isoTimestamp = (value) => {
+    if (typeof value !== "string" || Number.isNaN(Date.parse(value))) {
+        return null;
+    }
+    return new Date(value).toISOString();
+};
+const sourceReference = (update) => {
+    if (typeof update.$source === "string" && update.$source !== "") {
+        return update.$source.slice(0, 255);
+    }
+    if (typeof update.source === "string" && update.source !== "") {
+        return update.source.slice(0, 255);
+    }
+    if (update.source !== null && typeof update.source === "object") {
+        const source = update.source;
+        const parts = [source.label, source.src]
+            .filter((part) => typeof part === "string" || typeof part === "number")
+            .map(String);
+        if (parts.length > 0) {
+            return parts.join(".").slice(0, 255);
+        }
+    }
+    return null;
+};
+const validValue = (context, path, value) => {
+    const definition = (0, telemetry_catalog_1.telemetryDefinition)(context, path);
+    if (definition === null) {
+        return null;
+    }
+    if (definition.valueKind === "position") {
+        if (value === null || typeof value !== "object" || Array.isArray(value)) {
+            return null;
+        }
+        const position = value;
+        const latitude = position.latitude;
+        const longitude = position.longitude;
+        if (typeof latitude !== "number" ||
+            !Number.isFinite(latitude) ||
+            latitude < -90 ||
+            latitude > 90 ||
+            typeof longitude !== "number" ||
+            !Number.isFinite(longitude) ||
+            longitude < -180 ||
+            longitude > 180) {
+            return null;
+        }
+        return { latitude, longitude };
+    }
+    if (definition.valueKind === "number") {
+        return typeof value === "number" && Number.isFinite(value) ? value : null;
+    }
+    if (definition.valueKind === "string") {
+        if (path === "mmsi" && !/^[0-9]{9}$/.test(String(value))) {
+            return null;
+        }
+        return typeof value === "string" && value.length > 0
+            ? value.slice(0, 255)
+            : null;
+    }
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    const shipType = value;
+    return typeof shipType.id === "number" &&
+        Number.isInteger(shipType.id) &&
+        shipType.id >= 0 &&
+        shipType.id <= 99 &&
+        typeof shipType.name === "string" &&
+        shipType.name.length > 0
+        ? { id: shipType.id, name: shipType.name.slice(0, 100) }
+        : null;
+};
+const eventContext = (delta, subscriptionScope) => {
+    if (subscriptionScope === "self") {
+        return "vessels.self";
+    }
+    const context = delta.context === undefined ? "" : String(delta.context);
+    return (0, telemetry_catalog_1.isAisContext)(context) ? context : null;
+};
+const flattenedStaticValues = (context, path, value) => {
+    if (context === "vessels.self" ||
+        path !== "" ||
+        value === null ||
+        typeof value !== "object" ||
+        Array.isArray(value)) {
+        return [{ path, value }];
+    }
+    const root = value;
+    const communication = root.communication;
+    const design = root.design;
+    const navigation = root.navigation;
+    return [
+        { path: "name", value: root.name },
+        { path: "mmsi", value: root.mmsi },
+        { path: "communication.callsignVhf", value: communication?.callsignVhf },
+        { path: "design.aisShipType", value: design?.aisShipType },
+        { path: "navigation.state", value: navigation?.state },
+    ];
+};
+const eventsFromDelta = (delta, bootId, receivedAt, subscriptionScope = "self") => {
+    const events = [];
+    const context = eventContext(delta, subscriptionScope);
+    if (context === null) {
+        return events;
+    }
+    for (const update of delta.updates) {
+        if (!("values" in update) || !Array.isArray(update.values)) {
+            continue;
+        }
+        for (const pathValue of update.values) {
+            if (pathValue.state?.timedOut === true) {
+                continue;
+            }
+            for (const candidate of flattenedStaticValues(context, String(pathValue.path), pathValue.value)) {
+                const value = validValue(context, candidate.path, candidate.value);
+                if (value === null) {
+                    continue;
+                }
+                events.push({
+                    boot_id: bootId,
+                    context,
+                    path: candidate.path,
+                    value,
+                    source_timestamp: isoTimestamp(update.timestamp),
+                    received_at: receivedAt,
+                    source: sourceReference(update),
+                });
+            }
+        }
+    }
+    return events;
+};
+exports.eventsFromDelta = eventsFromDelta;

package/dist/src/geometry.d.ts

@@ -0,0 +1,3 @@
+import type { PositionValue } from "./types";
+export declare const distanceMeters: (from: PositionValue, to: PositionValue) => number;
+export declare const circularDistance: (from: number, to: number) => number;

package/dist/src/geometry.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.circularDistance = exports.distanceMeters = void 0;
+const EARTH_RADIUS_METERS = 6_371_008.8;
+const radians = (degrees) => (degrees * Math.PI) / 180;
+const distanceMeters = (from, to) => {
+    const latitudeDelta = radians(to.latitude - from.latitude);
+    const longitudeDelta = radians(to.longitude - from.longitude);
+    const fromLatitude = radians(from.latitude);
+    const toLatitude = radians(to.latitude);
+    const haversine = Math.sin(latitudeDelta / 2) ** 2 +
+        Math.cos(fromLatitude) *
+            Math.cos(toLatitude) *
+            Math.sin(longitudeDelta / 2) ** 2;
+    return (2 *
+        EARTH_RADIUS_METERS *
+        Math.atan2(Math.sqrt(haversine), Math.sqrt(1 - haversine)));
+};
+exports.distanceMeters = distanceMeters;
+const circularDistance = (from, to) => {
+    const fullTurn = Math.PI * 2;
+    const difference = Math.abs(from - to) % fullTurn;
+    return Math.min(difference, fullTurn - difference);
+};
+exports.circularDistance = circularDistance;

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

@@ -0,0 +1,22 @@
+import { type IngestAcknowledgement, type IngestBatch, type PairingResponse, type RuntimeConfigurationResponse } from "./types";
+export interface AuroraBlueClient {
+    pair(pairingCode: string, deviceName: string, connectorVersion: string): Promise<PairingResponse>;
+    sendBatch(batch: IngestBatch, accessToken: string): Promise<IngestAcknowledgement>;
+    fetchRuntimeConfiguration(accessToken: string): Promise<RuntimeConfigurationResponse>;
+}
+export declare class AuroraBlueHttpError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+export declare class AuroraBlueHttpClient implements AuroraBlueClient {
+    private readonly baseUrl;
+    private readonly timeoutMs;
+    private readonly fetchImplementation;
+    private readonly compressionThresholdBytes;
+    constructor(baseUrl: string, timeoutMs: number, fetchImplementation?: typeof fetch, compressionThresholdBytes?: number | null);
+    pair(pairingCode: string, deviceName: string, connectorVersion: string): Promise<PairingResponse>;
+    sendBatch(batch: IngestBatch, accessToken: string): Promise<IngestAcknowledgement>;
+    fetchRuntimeConfiguration(accessToken: string): Promise<RuntimeConfigurationResponse>;
+    private request;
+    private readJson;
+}