@rise-maritime/keelson-js 0.6.0-alpha.280.dev.1 → 0.6.0-alpha.282.dev.1

package/dist/interfaces/serviceRegistry.d.ts

@@ -111,6 +111,44 @@ export declare const serviceDefinitions: {
             };
         };
     };
+    readonly "navigation_control/v1": {
+        readonly name: "NavigationControl";
+        readonly fullName: "keelson.interfaces.navigation_control.NavigationControl";
+        readonly methods: {
+            readonly load_route: {
+                readonly name: "load_route";
+                readonly requestType: import("./NavigationControl").MessageFns<import("./NavigationControl").LoadRouteRequest>;
+                readonly requestStream: false;
+                readonly responseType: import("./NavigationControl").MessageFns<import("./NavigationControl").LoadRouteResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+            readonly set_guidance_order: {
+                readonly name: "set_guidance_order";
+                readonly requestType: import("./NavigationControl").MessageFns<import("./NavigationControl").SetGuidanceOrderRequest>;
+                readonly requestStream: false;
+                readonly responseType: import("./NavigationControl").MessageFns<import("./NavigationControl").SetGuidanceOrderResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+            readonly set_voyage_status: {
+                readonly name: "set_voyage_status";
+                readonly requestType: import("./NavigationControl").MessageFns<import("./NavigationControl").SetVoyageStatusRequest>;
+                readonly requestStream: false;
+                readonly responseType: import("./NavigationControl").MessageFns<import("./NavigationControl").SetVoyageStatusResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+            readonly get_navigation_state: {
+                readonly name: "get_navigation_state";
+                readonly requestType: import("./NavigationControl").MessageFns<import("./NavigationControl").GetNavigationStateRequest>;
+                readonly requestStream: false;
+                readonly responseType: import("./NavigationState").MessageFns<import("./NavigationState").NavigationState>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+        };
+    };
     readonly "network_ping_pong/v1": {
         readonly name: "NetworkPingPong";
         readonly fullName: "keelson.interfaces.network_ping_pong.NetworkPingPong";

package/dist/interfaces/serviceRegistry.js

@@ -6,6 +6,7 @@ const AlarmAck_1 = require("./AlarmAck");
 const Configurable_1 = require("./Configurable");
 const ContainerControl_1 = require("./ContainerControl");
 const MavlinkCommand_1 = require("./MavlinkCommand");
+const NavigationControl_1 = require("./NavigationControl");
 const NetworkPingPong_1 = require("./NetworkPingPong");
 const ReplayControl_1 = require("./ReplayControl");
 const RoutePlanner_1 = require("./RoutePlanner");
@@ -26,6 +27,7 @@ exports.serviceDefinitions = {
     "configurable/v1": Configurable_1.ConfigurableDefinition,
     "container_control/v1": ContainerControl_1.ContainerControlDefinition,
     "mavlink_command/v1": MavlinkCommand_1.MavlinkCommandDefinition,
+    "navigation_control/v1": NavigationControl_1.NavigationControlDefinition,
     "network_ping_pong/v1": NetworkPingPong_1.NetworkPingPongDefinition,
     "replay_control/v1": ReplayControl_1.ReplayControlDefinition,
     "route_planner/v1": RoutePlanner_1.RoutePlannerDefinition,

package/dist/interfaces.json

@@ -3,6 +3,7 @@
     "configurable/v1": "keelson.interfaces.configurable.Configurable",
     "container_control/v1": "keelson.interfaces.container_control.ContainerControl",
     "mavlink_command/v1": "keelson.interfaces.mavlink_command.MavlinkCommand",
+    "navigation_control/v1": "keelson.interfaces.navigation_control.NavigationControl",
     "network_ping_pong/v1": "keelson.interfaces.network_ping_pong.NetworkPingPong",
     "replay_control/v1": "keelson.interfaces.replay_control.ReplayControl",
     "route_planner/v1": "keelson.interfaces.route_planner.RoutePlanner",

package/dist/payloads/NavigationState.d.ts

@@ -30,6 +30,11 @@ export interface NavigationState {
     reason: string;
     /** Subjects this process needs and currently lacks or holds stale, e.g. "location_fix". */
     degradedInputs: string[];
+    /**
+     * The guidance order in force: what this process has been told to steer by, whether or not it
+     * holds the conn to do it. Absent when it has no voyage. Set through navigation_control/v1.
+     */
+    guidanceOrder?: GuidanceOrder | undefined;
 }
 export declare enum NavigationState_Mode {
     MODE_UNSPECIFIED = 0,
@@ -63,11 +68,52 @@ export declare enum NavigationState_SubMode {
     SUB_MODE_HOLDING = 3,
     /** SUB_MODE_REROUTING - awaiting a new route edition */
     SUB_MODE_REROUTING = 4,
+    /** SUB_MODE_STEERING - holding an ordered course or heading, off the track (GuidanceOrder) */
+    SUB_MODE_STEERING = 5,
     UNRECOGNIZED = -1
 }
 export declare function navigationState_SubModeFromJSON(object: any): NavigationState_SubMode;
 export declare function navigationState_SubModeToJSON(object: NavigationState_SubMode): string;
+/**
+ * How a navigation process is ordered to steer while a voyage is active. The one type used both to
+ * give the order (navigation_control/v1 set_guidance_order, load_route) and to report the order in
+ * force (NavigationState.guidance_order), so what was asked and what is held read alike.
+ *
+ * The frame is the field, as in vehicle_navigation/v1's SteeringOrder, so an order cannot name one
+ * frame and carry a value meant for another. Course over ground and heading are different
+ * instructions: in any current they differ by the drift angle.
+ */
+export interface GuidanceOrder {
+    $type: "keelson.GuidanceOrder";
+    track?: GuidanceOrder_Track | undefined;
+    /** Make good this course, degrees true, [0, 360). */
+    courseOverGroundDeg?: number | undefined;
+    /** Point this way, degrees true, [0, 360). */
+    headingDeg?: number | undefined;
+    hold?: GuidanceOrder_Hold | undefined;
+    /**
+     * Speed through the water to keep, in knots. Absent: the planned speed of the current leg for
+     * `track`, the speed she has for a course or heading. Ignored by `hold`.
+     */
+    speedKnots?: number | undefined;
+}
+/** Follow the planned track of the active route edition. */
+export interface GuidanceOrder_Track {
+    $type: "keelson.GuidanceOrder.Track";
+    /**
+     * Rejoin at this waypoint (Waypoint.id, never an index). Absent: the leg the process judges
+     * current, which is how a hand-back from a course or heading order resumes.
+     */
+    resumeFromWaypointId?: string | undefined;
+}
+/** Stop making way and keep station where the order finds her, until told otherwise. */
+export interface GuidanceOrder_Hold {
+    $type: "keelson.GuidanceOrder.Hold";
+}
 export declare const NavigationState: MessageFns<NavigationState, "keelson.NavigationState">;
+export declare const GuidanceOrder: MessageFns<GuidanceOrder, "keelson.GuidanceOrder">;
+export declare const GuidanceOrder_Track: MessageFns<GuidanceOrder_Track, "keelson.GuidanceOrder.Track">;
+export declare const GuidanceOrder_Hold: MessageFns<GuidanceOrder_Hold, "keelson.GuidanceOrder.Hold">;
 type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
 type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
     [K in Exclude<keyof T, "$type">]?: DeepPartial<T[K]>;

package/dist/payloads/NavigationState.js

@@ -5,7 +5,7 @@
 //   protoc               v6.30.2
 // source: NavigationState.proto
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NavigationState = exports.navigationState_SubModeToJSON = exports.navigationState_SubModeFromJSON = exports.NavigationState_SubMode = exports.navigationState_ModeToJSON = exports.navigationState_ModeFromJSON = exports.NavigationState_Mode = void 0;
+exports.GuidanceOrder_Hold = exports.GuidanceOrder_Track = exports.GuidanceOrder = exports.NavigationState = exports.navigationState_SubModeToJSON = exports.navigationState_SubModeFromJSON = exports.NavigationState_SubMode = exports.navigationState_ModeToJSON = exports.navigationState_ModeFromJSON = exports.NavigationState_Mode = void 0;
 /* eslint-disable */
 const wire_1 = require("@bufbuild/protobuf/wire");
 const OperationalAuthority_1 = require("./OperationalAuthority");
@@ -96,6 +96,8 @@ var NavigationState_SubMode;
     NavigationState_SubMode[NavigationState_SubMode["SUB_MODE_HOLDING"] = 3] = "SUB_MODE_HOLDING";
     /** SUB_MODE_REROUTING - awaiting a new route edition */
     NavigationState_SubMode[NavigationState_SubMode["SUB_MODE_REROUTING"] = 4] = "SUB_MODE_REROUTING";
+    /** SUB_MODE_STEERING - holding an ordered course or heading, off the track (GuidanceOrder) */
+    NavigationState_SubMode[NavigationState_SubMode["SUB_MODE_STEERING"] = 5] = "SUB_MODE_STEERING";
     NavigationState_SubMode[NavigationState_SubMode["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
 })(NavigationState_SubMode || (exports.NavigationState_SubMode = NavigationState_SubMode = {}));
 function navigationState_SubModeFromJSON(object) {
@@ -115,6 +117,9 @@ function navigationState_SubModeFromJSON(object) {
         case 4:
         case "SUB_MODE_REROUTING":
             return NavigationState_SubMode.SUB_MODE_REROUTING;
+        case 5:
+        case "SUB_MODE_STEERING":
+            return NavigationState_SubMode.SUB_MODE_STEERING;
         case -1:
         case "UNRECOGNIZED":
         default:
@@ -134,6 +139,8 @@ function navigationState_SubModeToJSON(object) {
             return "SUB_MODE_HOLDING";
         case NavigationState_SubMode.SUB_MODE_REROUTING:
             return "SUB_MODE_REROUTING";
+        case NavigationState_SubMode.SUB_MODE_STEERING:
+            return "SUB_MODE_STEERING";
         case NavigationState_SubMode.UNRECOGNIZED:
         default:
             return "UNRECOGNIZED";
@@ -153,6 +160,7 @@ function createBaseNavigationState() {
         connHeld: false,
         reason: "",
         degradedInputs: [],
+        guidanceOrder: undefined,
     };
 }
 exports.NavigationState = {
@@ -188,6 +196,9 @@ exports.NavigationState = {
         for (const v of message.degradedInputs) {
             writer.uint32(82).string(v);
         }
+        if (message.guidanceOrder !== undefined) {
+            exports.GuidanceOrder.encode(message.guidanceOrder, writer.uint32(90).fork()).join();
+        }
         return writer;
     },
     decode(input, length) {
@@ -267,6 +278,13 @@ exports.NavigationState = {
                     message.degradedInputs.push(reader.string());
                     continue;
                 }
+                case 11: {
+                    if (tag !== 90) {
+                        break;
+                    }
+                    message.guidanceOrder = exports.GuidanceOrder.decode(reader, reader.uint32());
+                    continue;
+                }
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -294,6 +312,7 @@ exports.NavigationState = {
             degradedInputs: globalThis.Array.isArray(object?.degradedInputs)
                 ? object.degradedInputs.map((e) => globalThis.String(e))
                 : [],
+            guidanceOrder: isSet(object.guidanceOrder) ? exports.GuidanceOrder.fromJSON(object.guidanceOrder) : undefined,
         };
     },
     toJSON(message) {
@@ -328,6 +347,9 @@ exports.NavigationState = {
         if (message.degradedInputs?.length) {
             obj.degradedInputs = message.degradedInputs;
         }
+        if (message.guidanceOrder !== undefined) {
+            obj.guidanceOrder = exports.GuidanceOrder.toJSON(message.guidanceOrder);
+        }
         return obj;
     },
     create(base) {
@@ -347,10 +369,239 @@ exports.NavigationState = {
         message.connHeld = object.connHeld ?? false;
         message.reason = object.reason ?? "";
         message.degradedInputs = object.degradedInputs?.map((e) => e) || [];
+        message.guidanceOrder = (object.guidanceOrder !== undefined && object.guidanceOrder !== null)
+            ? exports.GuidanceOrder.fromPartial(object.guidanceOrder)
+            : undefined;
         return message;
     },
 };
 typeRegistry_1.messageTypeRegistry.set(exports.NavigationState.$type, exports.NavigationState);
+function createBaseGuidanceOrder() {
+    return {
+        $type: "keelson.GuidanceOrder",
+        track: undefined,
+        courseOverGroundDeg: undefined,
+        headingDeg: undefined,
+        hold: undefined,
+        speedKnots: undefined,
+    };
+}
+exports.GuidanceOrder = {
+    $type: "keelson.GuidanceOrder",
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.track !== undefined) {
+            exports.GuidanceOrder_Track.encode(message.track, writer.uint32(10).fork()).join();
+        }
+        if (message.courseOverGroundDeg !== undefined) {
+            writer.uint32(17).double(message.courseOverGroundDeg);
+        }
+        if (message.headingDeg !== undefined) {
+            writer.uint32(25).double(message.headingDeg);
+        }
+        if (message.hold !== undefined) {
+            exports.GuidanceOrder_Hold.encode(message.hold, writer.uint32(34).fork()).join();
+        }
+        if (message.speedKnots !== undefined) {
+            writer.uint32(41).double(message.speedKnots);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGuidanceOrder();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.track = exports.GuidanceOrder_Track.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 17) {
+                        break;
+                    }
+                    message.courseOverGroundDeg = reader.double();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 25) {
+                        break;
+                    }
+                    message.headingDeg = reader.double();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.hold = exports.GuidanceOrder_Hold.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 41) {
+                        break;
+                    }
+                    message.speedKnots = reader.double();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            $type: exports.GuidanceOrder.$type,
+            track: isSet(object.track) ? exports.GuidanceOrder_Track.fromJSON(object.track) : undefined,
+            courseOverGroundDeg: isSet(object.courseOverGroundDeg)
+                ? globalThis.Number(object.courseOverGroundDeg)
+                : undefined,
+            headingDeg: isSet(object.headingDeg) ? globalThis.Number(object.headingDeg) : undefined,
+            hold: isSet(object.hold) ? exports.GuidanceOrder_Hold.fromJSON(object.hold) : undefined,
+            speedKnots: isSet(object.speedKnots) ? globalThis.Number(object.speedKnots) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.track !== undefined) {
+            obj.track = exports.GuidanceOrder_Track.toJSON(message.track);
+        }
+        if (message.courseOverGroundDeg !== undefined) {
+            obj.courseOverGroundDeg = message.courseOverGroundDeg;
+        }
+        if (message.headingDeg !== undefined) {
+            obj.headingDeg = message.headingDeg;
+        }
+        if (message.hold !== undefined) {
+            obj.hold = exports.GuidanceOrder_Hold.toJSON(message.hold);
+        }
+        if (message.speedKnots !== undefined) {
+            obj.speedKnots = message.speedKnots;
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.GuidanceOrder.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseGuidanceOrder();
+        message.track = (object.track !== undefined && object.track !== null)
+            ? exports.GuidanceOrder_Track.fromPartial(object.track)
+            : undefined;
+        message.courseOverGroundDeg = object.courseOverGroundDeg ?? undefined;
+        message.headingDeg = object.headingDeg ?? undefined;
+        message.hold = (object.hold !== undefined && object.hold !== null)
+            ? exports.GuidanceOrder_Hold.fromPartial(object.hold)
+            : undefined;
+        message.speedKnots = object.speedKnots ?? undefined;
+        return message;
+    },
+};
+typeRegistry_1.messageTypeRegistry.set(exports.GuidanceOrder.$type, exports.GuidanceOrder);
+function createBaseGuidanceOrder_Track() {
+    return { $type: "keelson.GuidanceOrder.Track", resumeFromWaypointId: undefined };
+}
+exports.GuidanceOrder_Track = {
+    $type: "keelson.GuidanceOrder.Track",
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.resumeFromWaypointId !== undefined) {
+            writer.uint32(10).string(message.resumeFromWaypointId);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGuidanceOrder_Track();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.resumeFromWaypointId = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            $type: exports.GuidanceOrder_Track.$type,
+            resumeFromWaypointId: isSet(object.resumeFromWaypointId)
+                ? globalThis.String(object.resumeFromWaypointId)
+                : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.resumeFromWaypointId !== undefined) {
+            obj.resumeFromWaypointId = message.resumeFromWaypointId;
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.GuidanceOrder_Track.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseGuidanceOrder_Track();
+        message.resumeFromWaypointId = object.resumeFromWaypointId ?? undefined;
+        return message;
+    },
+};
+typeRegistry_1.messageTypeRegistry.set(exports.GuidanceOrder_Track.$type, exports.GuidanceOrder_Track);
+function createBaseGuidanceOrder_Hold() {
+    return { $type: "keelson.GuidanceOrder.Hold" };
+}
+exports.GuidanceOrder_Hold = {
+    $type: "keelson.GuidanceOrder.Hold",
+    encode(_, writer = new wire_1.BinaryWriter()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGuidanceOrder_Hold();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(_) {
+        return { $type: exports.GuidanceOrder_Hold.$type };
+    },
+    toJSON(_) {
+        const obj = {};
+        return obj;
+    },
+    create(base) {
+        return exports.GuidanceOrder_Hold.fromPartial(base ?? {});
+    },
+    fromPartial(_) {
+        const message = createBaseGuidanceOrder_Hold();
+        return message;
+    },
+};
+typeRegistry_1.messageTypeRegistry.set(exports.GuidanceOrder_Hold.$type, exports.GuidanceOrder_Hold);
 function toTimestamp(date) {
     const seconds = Math.trunc(date.getTime() / 1000);
     const nanos = (date.getTime() % 1000) * 1000000;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rise-maritime/keelson-js",
   "//version": "NOT the published version. The release workflow overwrites it from the release tag (npm version --no-git-tag-version), so tag and artifact cannot disagree. Only matters for local installs; do not hand-bump before tagging — that manual step is what broke release 0.5.4.",
-  "version": "0.6.0-alpha.280.dev.1",
+  "version": "0.6.0-alpha.282.dev.1",
   "description": "Keelson JavaScript SDK with Node-RED nodes",
   "main": "dist/index.js",
   "files": [