@rise-maritime/keelson-js 0.6.0-alpha.245.dev.1 → 0.6.0-alpha.255.dev.1

package/dist/index.d.ts

@@ -509,6 +509,14 @@ export declare function getInterfaceDefinition(interfaceAndVersion: string): {
             readonly responseStream: false;
             readonly options: {};
         };
+        readonly set_standing_order: {
+            readonly name: "set_standing_order";
+            readonly requestType: import("./interfaces/VehicleSimulatorControl").MessageFns<import("./interfaces/VehicleSimulatorControl").StandingOrder>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/VehicleSimulatorControl").MessageFns<import("./interfaces/VehicleSimulatorControl").SetStandingOrderResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
     };
 } | {
     readonly name: "WHEPProxy";

package/dist/interfaces/VehicleSimulatorControl.d.ts

@@ -15,8 +15,76 @@ export interface InitialPose {
  */
 export interface SetInitialPoseResponse {
 }
+/**
+ * How a vehicle is told to steer. The frame is the field rather than a
+ * separate discriminator, so an order cannot name one frame and carry a
+ * value meant for another.
+ *
+ * The two are different instructions, not two spellings of one. A course
+ * over ground is made good against the water that is moving the hull; a
+ * heading is where she points, and in any current the two differ by the
+ * drift angle. A simulator that treats them alike is wrong by that angle
+ * and says nothing about it.
+ */
+export interface SteeringOrder {
+    /** Make good this course, degrees true, [0, 360). */
+    courseOverGroundDeg?: number | undefined;
+    /**
+     * Point this way, degrees true, [0, 360). What she makes good is then
+     * whatever the water leaves her.
+     */
+    headingDeg?: number | undefined;
+}
+/**
+ * How a vehicle is told to drive. Four frames, in decreasing order of what
+ * the vehicle is asked to guarantee: a speed over the ground is a promise
+ * about the track, a speed through the water is a promise about the hull,
+ * and the last two are machinery settings that promise nothing about
+ * either — what they produce is the vehicle's business.
+ */
+export interface PropulsionOrder {
+    /**
+     * Make good this speed over the ground, m/s. Not always reachable: in
+     * a stream that beats her, the vehicle makes its best and the
+     * shortfall is what the recording shows.
+     */
+    sogMps?: number | undefined;
+    /** This speed through the water, m/s. */
+    stwMps?: number | undefined;
+    /**
+     * A throttle setting, percent. Negative is astern where the vehicle
+     * has it; a vehicle that cannot go astern replies OUT_OF_RANGE rather
+     * than clamping silently.
+     */
+    enginePct?: number | undefined;
+    /** Shaft revolutions per minute. Signed, as engine_pct is. */
+    shaftRpm?: number | undefined;
+}
+/**
+ * A standing order: what the vehicle should be doing until told otherwise.
+ *
+ * Both halves are optional and omitting one leaves it as it is, so a course
+ * can be changed without disturbing a speed. Sending neither is an error
+ * rather than a no-op: it is almost always a caller that failed to set the
+ * field it meant to.
+ */
+export interface StandingOrder {
+    steering: SteeringOrder | undefined;
+    propulsion: PropulsionOrder | undefined;
+}
+/**
+ * Dedicated response for the same reason SetInitialPoseResponse is one: an
+ * order that was accepted but modified — clamped to a limit the vehicle
+ * declares — is a plausible thing to want to return later.
+ */
+export interface SetStandingOrderResponse {
+}
 export declare const InitialPose: MessageFns<InitialPose>;
 export declare const SetInitialPoseResponse: MessageFns<SetInitialPoseResponse>;
+export declare const SteeringOrder: MessageFns<SteeringOrder>;
+export declare const PropulsionOrder: MessageFns<PropulsionOrder>;
+export declare const StandingOrder: MessageFns<StandingOrder>;
+export declare const SetStandingOrderResponse: MessageFns<SetStandingOrderResponse>;
 export type VehicleSimulatorControlDefinition = typeof VehicleSimulatorControlDefinition;
 export declare const VehicleSimulatorControlDefinition: {
     readonly name: "VehicleSimulatorControl";
@@ -34,6 +102,21 @@ export declare const VehicleSimulatorControlDefinition: {
             readonly responseStream: false;
             readonly options: {};
         };
+        /**
+         * Give a RUNNING entity a new standing order, without moving it. On a
+         * STOPPED or ASSIGNED entity, replies ErrorResponse{code =
+         * INVALID_STATE} — the mirror of set_initial_pose's own rule, and for
+         * the same reason: an order to a vehicle that is not going anywhere is
+         * a caller confusing setup with command.
+         */
+        readonly set_standing_order: {
+            readonly name: "set_standing_order";
+            readonly requestType: MessageFns<StandingOrder>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns<SetStandingOrderResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
     };
 };
 type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;

package/dist/interfaces/VehicleSimulatorControl.js

@@ -5,7 +5,7 @@
 //   protoc               v6.30.2
 // source: VehicleSimulatorControl.proto
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VehicleSimulatorControlDefinition = exports.SetInitialPoseResponse = exports.InitialPose = exports.protobufPackage = void 0;
+exports.VehicleSimulatorControlDefinition = exports.SetStandingOrderResponse = exports.StandingOrder = exports.PropulsionOrder = exports.SteeringOrder = exports.SetInitialPoseResponse = exports.InitialPose = exports.protobufPackage = void 0;
 /* eslint-disable */
 const wire_1 = require("@bufbuild/protobuf/wire");
 const Coordinate_1 = require("./Coordinate");
@@ -132,6 +132,283 @@ exports.SetInitialPoseResponse = {
         return message;
     },
 };
+function createBaseSteeringOrder() {
+    return { courseOverGroundDeg: undefined, headingDeg: undefined };
+}
+exports.SteeringOrder = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.courseOverGroundDeg !== undefined) {
+            writer.uint32(9).double(message.courseOverGroundDeg);
+        }
+        if (message.headingDeg !== undefined) {
+            writer.uint32(17).double(message.headingDeg);
+        }
+        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 = createBaseSteeringOrder();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 9) {
+                        break;
+                    }
+                    message.courseOverGroundDeg = reader.double();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 17) {
+                        break;
+                    }
+                    message.headingDeg = reader.double();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            courseOverGroundDeg: isSet(object.courseOverGroundDeg)
+                ? globalThis.Number(object.courseOverGroundDeg)
+                : undefined,
+            headingDeg: isSet(object.headingDeg) ? globalThis.Number(object.headingDeg) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.courseOverGroundDeg !== undefined) {
+            obj.courseOverGroundDeg = message.courseOverGroundDeg;
+        }
+        if (message.headingDeg !== undefined) {
+            obj.headingDeg = message.headingDeg;
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.SteeringOrder.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseSteeringOrder();
+        message.courseOverGroundDeg = object.courseOverGroundDeg ?? undefined;
+        message.headingDeg = object.headingDeg ?? undefined;
+        return message;
+    },
+};
+function createBasePropulsionOrder() {
+    return { sogMps: undefined, stwMps: undefined, enginePct: undefined, shaftRpm: undefined };
+}
+exports.PropulsionOrder = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.sogMps !== undefined) {
+            writer.uint32(9).double(message.sogMps);
+        }
+        if (message.stwMps !== undefined) {
+            writer.uint32(17).double(message.stwMps);
+        }
+        if (message.enginePct !== undefined) {
+            writer.uint32(25).double(message.enginePct);
+        }
+        if (message.shaftRpm !== undefined) {
+            writer.uint32(33).double(message.shaftRpm);
+        }
+        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 = createBasePropulsionOrder();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 9) {
+                        break;
+                    }
+                    message.sogMps = reader.double();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 17) {
+                        break;
+                    }
+                    message.stwMps = reader.double();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 25) {
+                        break;
+                    }
+                    message.enginePct = reader.double();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 33) {
+                        break;
+                    }
+                    message.shaftRpm = reader.double();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            sogMps: isSet(object.sogMps) ? globalThis.Number(object.sogMps) : undefined,
+            stwMps: isSet(object.stwMps) ? globalThis.Number(object.stwMps) : undefined,
+            enginePct: isSet(object.enginePct) ? globalThis.Number(object.enginePct) : undefined,
+            shaftRpm: isSet(object.shaftRpm) ? globalThis.Number(object.shaftRpm) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.sogMps !== undefined) {
+            obj.sogMps = message.sogMps;
+        }
+        if (message.stwMps !== undefined) {
+            obj.stwMps = message.stwMps;
+        }
+        if (message.enginePct !== undefined) {
+            obj.enginePct = message.enginePct;
+        }
+        if (message.shaftRpm !== undefined) {
+            obj.shaftRpm = message.shaftRpm;
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.PropulsionOrder.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBasePropulsionOrder();
+        message.sogMps = object.sogMps ?? undefined;
+        message.stwMps = object.stwMps ?? undefined;
+        message.enginePct = object.enginePct ?? undefined;
+        message.shaftRpm = object.shaftRpm ?? undefined;
+        return message;
+    },
+};
+function createBaseStandingOrder() {
+    return { steering: undefined, propulsion: undefined };
+}
+exports.StandingOrder = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.steering !== undefined) {
+            exports.SteeringOrder.encode(message.steering, writer.uint32(10).fork()).join();
+        }
+        if (message.propulsion !== undefined) {
+            exports.PropulsionOrder.encode(message.propulsion, writer.uint32(18).fork()).join();
+        }
+        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 = createBaseStandingOrder();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.steering = exports.SteeringOrder.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.propulsion = exports.PropulsionOrder.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            steering: isSet(object.steering) ? exports.SteeringOrder.fromJSON(object.steering) : undefined,
+            propulsion: isSet(object.propulsion) ? exports.PropulsionOrder.fromJSON(object.propulsion) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.steering !== undefined) {
+            obj.steering = exports.SteeringOrder.toJSON(message.steering);
+        }
+        if (message.propulsion !== undefined) {
+            obj.propulsion = exports.PropulsionOrder.toJSON(message.propulsion);
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.StandingOrder.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseStandingOrder();
+        message.steering = (object.steering !== undefined && object.steering !== null)
+            ? exports.SteeringOrder.fromPartial(object.steering)
+            : undefined;
+        message.propulsion = (object.propulsion !== undefined && object.propulsion !== null)
+            ? exports.PropulsionOrder.fromPartial(object.propulsion)
+            : undefined;
+        return message;
+    },
+};
+function createBaseSetStandingOrderResponse() {
+    return {};
+}
+exports.SetStandingOrderResponse = {
+    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 = createBaseSetStandingOrderResponse();
+        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 {};
+    },
+    toJSON(_) {
+        const obj = {};
+        return obj;
+    },
+    create(base) {
+        return exports.SetStandingOrderResponse.fromPartial(base ?? {});
+    },
+    fromPartial(_) {
+        const message = createBaseSetStandingOrderResponse();
+        return message;
+    },
+};
 exports.VehicleSimulatorControlDefinition = {
     name: "VehicleSimulatorControl",
     fullName: "keelson.interfaces.vehicle_simulator_control.VehicleSimulatorControl",
@@ -148,6 +425,21 @@ exports.VehicleSimulatorControlDefinition = {
             responseStream: false,
             options: {},
         },
+        /**
+         * Give a RUNNING entity a new standing order, without moving it. On a
+         * STOPPED or ASSIGNED entity, replies ErrorResponse{code =
+         * INVALID_STATE} — the mirror of set_initial_pose's own rule, and for
+         * the same reason: an order to a vehicle that is not going anywhere is
+         * a caller confusing setup with command.
+         */
+        set_standing_order: {
+            name: "set_standing_order",
+            requestType: exports.StandingOrder,
+            requestStream: false,
+            responseType: exports.SetStandingOrderResponse,
+            responseStream: false,
+            options: {},
+        },
     },
 };
 function isSet(value) {

package/dist/interfaces/serviceRegistry.d.ts

@@ -501,6 +501,14 @@ export declare const serviceDefinitions: {
                 readonly responseStream: false;
                 readonly options: {};
             };
+            readonly set_standing_order: {
+                readonly name: "set_standing_order";
+                readonly requestType: import("./VehicleSimulatorControl").MessageFns<import("./VehicleSimulatorControl").StandingOrder>;
+                readonly requestStream: false;
+                readonly responseType: import("./VehicleSimulatorControl").MessageFns<import("./VehicleSimulatorControl").SetStandingOrderResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
         };
     };
     readonly "whep_proxy/v1": {

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.245.dev.1",
+  "version": "0.6.0-alpha.255.dev.1",
   "description": "Keelson JavaScript SDK with Node-RED nodes",
   "main": "dist/index.js",
   "files": [