@rise-maritime/keelson-js 0.6.0-experimental.2 → 0.6.0-experimental.20

package/dist/index.d.ts

@@ -131,6 +131,59 @@ export declare function getInterfaceDefinition(interfaceAndVersion: string): {
             readonly options: {};
         };
     };
+} | {
+    readonly name: "NavigationControl";
+    readonly fullName: "keelson.interfaces.navigation_control.NavigationControl";
+    readonly methods: {
+        readonly load_route: {
+            readonly name: "load_route";
+            readonly requestType: import("./interfaces/NavigationControl").MessageFns<import("./interfaces/NavigationControl").LoadRouteRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/NavigationControl").MessageFns<import("./interfaces/NavigationControl").LoadRouteResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly set_guidance_order: {
+            readonly name: "set_guidance_order";
+            readonly requestType: import("./interfaces/NavigationControl").MessageFns<import("./interfaces/NavigationControl").SetGuidanceOrderRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/NavigationControl").MessageFns<import("./interfaces/NavigationControl").SetGuidanceOrderResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly set_voyage_status: {
+            readonly name: "set_voyage_status";
+            readonly requestType: import("./interfaces/NavigationControl").MessageFns<import("./interfaces/NavigationControl").SetVoyageStatusRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/NavigationControl").MessageFns<import("./interfaces/NavigationControl").SetVoyageStatusResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly get_navigation_state: {
+            readonly name: "get_navigation_state";
+            readonly requestType: import("./interfaces/NavigationControl").MessageFns<import("./interfaces/NavigationControl").GetNavigationStateRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/NavigationState").MessageFns<import("./interfaces/NavigationState").NavigationState>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly get_settings: {
+            readonly name: "get_settings";
+            readonly requestType: import("./interfaces/NavigationControl").MessageFns<import("./interfaces/NavigationControl").GetSettingsRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/NavigationControl").MessageFns<import("./interfaces/NavigationControl").GetSettingsResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly set_settings: {
+            readonly name: "set_settings";
+            readonly requestType: import("./interfaces/NavigationControl").MessageFns<import("./interfaces/NavigationControl").SetSettingsRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/NavigationControl").MessageFns<import("./interfaces/NavigationControl").SetSettingsResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
 } | {
     readonly name: "NetworkPingPong";
     readonly fullName: "keelson.interfaces.network_ping_pong.NetworkPingPong";
@@ -144,6 +197,35 @@ export declare function getInterfaceDefinition(interfaceAndVersion: string): {
             readonly options: {};
         };
     };
+} | {
+    readonly name: "NavigationRiskControl";
+    readonly fullName: "keelson.interfaces.navigation_risk_control.NavigationRiskControl";
+    readonly methods: {
+        readonly list_assessments: {
+            readonly name: "list_assessments";
+            readonly requestType: import("./interfaces/NavigationRiskControl").MessageFns<import("./interfaces/NavigationRiskControl").ListAssessmentsRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/NavigationRiskControl").MessageFns<import("./interfaces/NavigationRiskControl").ListAssessmentsResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly start_assessment: {
+            readonly name: "start_assessment";
+            readonly requestType: import("./interfaces/NavigationRiskControl").MessageFns<import("./interfaces/NavigationRiskControl").StartAssessmentRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/NavigationRiskControl").MessageFns<import("./interfaces/NavigationRiskControl").StartAssessmentResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly stop_assessment: {
+            readonly name: "stop_assessment";
+            readonly requestType: import("./interfaces/NavigationRiskControl").MessageFns<import("./interfaces/NavigationRiskControl").StopAssessmentRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/NavigationRiskControl").MessageFns<import("./interfaces/NavigationRiskControl").StopAssessmentResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
 } | {
     readonly name: "ReplayControl";
     readonly fullName: "keelson.interfaces.replay_control.ReplayControl";
@@ -220,6 +302,14 @@ export declare function getInterfaceDefinition(interfaceAndVersion: string): {
             readonly responseStream: false;
             readonly options: {};
         };
+        readonly set_range: {
+            readonly name: "set_range";
+            readonly requestType: import("./interfaces/ReplayControl").MessageFns<import("./interfaces/ReplayControl").SetRangeRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/ReplayControl").MessageFns<import("./interfaces/ReplayControl").ReplaySuccessResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
     };
 } | {
     readonly name: "RoutePlanner";
@@ -476,6 +566,14 @@ export declare function getInterfaceDefinition(interfaceAndVersion: string): {
             readonly responseStream: false;
             readonly options: {};
         };
+        readonly crash_stop: {
+            readonly name: "crash_stop";
+            readonly requestType: import("./interfaces/VehicleLifecycle").MessageFns<import("./interfaces/VehicleLifecycle").CrashStopRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/VehicleLifecycle").MessageFns<import("./interfaces/VehicleLifecycle").CrashStopResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
     };
 } | {
     readonly name: "VehicleMission";

package/dist/index.test.js

@@ -205,7 +205,7 @@ describe("interface introspection", () => {
         expect(interfaces.length).toBeGreaterThanOrEqual(14);
     });
     it("enumerates procedures", () => {
-        expect(getProcedures("vehicle_lifecycle/v1")).toEqual(["arm", "set_mode", "emergency_stop"]);
+        expect(getProcedures("vehicle_lifecycle/v1")).toEqual(["arm", "set_mode", "emergency_stop", "crash_stop"]);
         expect(() => getProcedures("nope/v1")).toThrow();
     });
     it("resolves procedure codecs that roundtrip", () => {

package/dist/interfaces/NavigationControl.d.ts

@@ -0,0 +1,266 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { GuidanceOrder, NavigationState } from "./NavigationState";
+import { RouteRef } from "./Route";
+import { CommandResult } from "./VehicleCommon";
+import { VoyageStatus } from "./Voyage";
+export declare const protobufPackage = "keelson.interfaces.navigation_control";
+/** Who is calling, and on what authority. Carried by every mutating request. */
+export interface Caller {
+    /**
+     * Identity of the operator and site, or the service, e.g. "ted@ROC-1", "slipway". Recorded in
+     * the responder's decision log, so it should mean something to somebody reading that later.
+     */
+    controllerId: string;
+    /**
+     * The token of the command_authority lease the caller holds. Absent when it holds none, which
+     * is valid only while the responder holds the conn itself. The token is broadcast on a stored
+     * slot, so this is an interlock against a station that has lost the conn, not a credential
+     * (protocols/navigation_conduct.yaml).
+     */
+    authorityToken?: string | undefined;
+}
+/** Make a route edition the active voyage of this vessel. */
+export interface LoadRouteRequest {
+    /** Client wall-clock at send, for latency logging only. */
+    timestamp: Date | undefined;
+    caller: Caller | undefined;
+    /**
+     * The entity whose route tree holds the edition. RouteRef names no entity, so it always
+     * resolves inside the vessel's own tree; a route drawn for another vessel is copied first.
+     * When it differs from this vessel, the responder reads
+     * `{base}/@v0/{source_entity_id}/pubsub/route/{route_id}/edition/{N}` and republishes it
+     * unchanged under its own vessel, with the same route_id and edition, before activating it.
+     * Editions are immutable, so the copy is the same route, not a new one.
+     */
+    sourceEntityId: string;
+    /**
+     * The edition to sail. Never `latest`: an edition that cannot be resolved is refused, never
+     * silently replaced.
+     */
+    routeRef: RouteRef | undefined;
+    /**
+     * The voyage to activate. Absent: the responder mints one. Present and already a voyage of
+     * this vessel: that voyage is re-pinned to `route_ref` (a reroute).
+     */
+    voyageId?: string | undefined;
+    /** The guidance order to take up once the voyage is active. Absent: TRACK. */
+    initialOrder?: GuidanceOrder | undefined;
+}
+export interface LoadRouteResponse {
+    result: CommandResult;
+    /**
+     * Why not, when result is not ACCEPTED: an unresolvable edition, no conn, another voyage the
+     * responder will not displace. Empty otherwise.
+     */
+    detail: string;
+    /** The voyage now ACTIVE, when result is ACCEPTED. */
+    voyageId?: string | undefined;
+    /** The navigation state the order produced. */
+    state?: NavigationState | undefined;
+}
+/** Change how the vessel is steered while a voyage is active. */
+export interface SetGuidanceOrderRequest {
+    timestamp: Date | undefined;
+    caller: Caller | undefined;
+    order: GuidanceOrder | undefined;
+}
+export interface SetGuidanceOrderResponse {
+    /**
+     * UNSUPPORTED when the responder, or the vehicle behind it, cannot hold the requested frame —
+     * it never substitutes course for heading or the reverse, never approximates a `go_to` by a
+     * course, and never a `dynamic_positioning` by a `go_to`: DP without lateral authority is
+     * UNSUPPORTED; so is a track offset, reverse travel or speed_plan_factor from a responder that
+     * cannot honour it -- never ignored. TEMPORARILY_REJECTED when there is no active voyage to steer. INVALID_ARGUMENT
+     * for both cross-track offsets or both speed_knots and speed_plan_factor, a
+     * cross_track_offset_fraction outside -1..1, a speed_plan_factor that is not greater than zero,
+     * for a position outside WGS84 ranges, a negative arrival radius, a loiter radius that is not
+     * greater than zero, a DP heading outside [0, 360), or a walk or return speed that is not
+     * greater than zero.
+     */
+    result: CommandResult;
+    detail: string;
+    state?: NavigationState | undefined;
+}
+/** Pause, resume, complete or abort the active voyage. */
+export interface SetVoyageStatusRequest {
+    timestamp: Date | undefined;
+    caller: Caller | undefined;
+    voyageId: string;
+    /**
+     * PAUSED, ACTIVE (resume), COMPLETED or ABORTED. PLANNED is refused: a voyage is planned by
+     * publishing it, not by asking the process sailing it.
+     */
+    status: VoyageStatus;
+    /** Why, for the voyage's audit trail. Free text. */
+    reason: string;
+}
+export interface SetVoyageStatusResponse {
+    result: CommandResult;
+    detail: string;
+    state?: NavigationState | undefined;
+}
+export interface GetNavigationStateRequest {
+}
+/**
+ * What an operator may tune while the navigation process runs. Every field is optional: in a
+ * set_settings request only the fields present change; in a reply a field is present when the
+ * process has that setting at all. Settings tune HOW it carries out orders -- they never move the
+ * conn, change the voyage, or give an order.
+ */
+export interface NavigationSettings {
+    /**
+     * false pauses the COLREG advisor: no new encounters or advice. Advice already accepted is
+     * steered to its end; open advice is left to expire.
+     */
+    colregAdvisorActive?: boolean | undefined;
+    /**
+     * Accept its own advice, within what the authority level in force allows. false: every piece
+     * of advice waits for an operator's advice_disposition.
+     */
+    autoAcceptAdvice?: boolean | undefined;
+    /** The passage speed, knots, > 0, when an order names none and a leg plans none. */
+    defaultSpeedKnots?: number | undefined;
+    /** Arrival radius, metres, >= 0, for a GuidanceOrder.go_to that names none. */
+    goToArrivalRadiusM?: number | undefined;
+    /** Return speed through the water, knots, > 0, for a GuidanceOrder.loiter that names none. */
+    loiterReturnSpeedKnots?: number | undefined;
+    /** Targets farther than this, metres, > 0, are not considered for traffic or COLREG. */
+    trafficRangeM?: number | undefined;
+    /** Whether the route monitor publishes its alarms (deviation, envelope). Monitoring itself goes on. */
+    routeAlarms?: boolean | undefined;
+}
+export interface GetSettingsRequest {
+}
+export interface GetSettingsResponse {
+    settings: NavigationSettings | undefined;
+    /**
+     * Settings this process has but cannot change while it runs, by field name (e.g.
+     * "colreg_advisor_active" when the advisor was not started). A set naming one is UNSUPPORTED.
+     */
+    fixed: string[];
+}
+/**
+ * Change settings while the process runs. The same who-may-call rule as every other mutating
+ * procedure here: the holder of the live lease presenting its token, or a permitted controller.
+ */
+export interface SetSettingsRequest {
+    timestamp: Date | undefined;
+    caller: Caller | undefined;
+    settings: NavigationSettings | undefined;
+}
+export interface SetSettingsResponse {
+    /**
+     * DENIED without the conn or its token. UNSUPPORTED for a field in GetSettingsResponse.fixed, or
+     * one this process does not have. INVALID_ARGUMENT for a value out of range. A request is applied
+     * whole or not at all -- never partly.
+     */
+    result: CommandResult;
+    detail: string;
+    /** The settings in force after the call, whatever the result. */
+    settings: NavigationSettings | undefined;
+}
+export declare const Caller: MessageFns<Caller>;
+export declare const LoadRouteRequest: MessageFns<LoadRouteRequest>;
+export declare const LoadRouteResponse: MessageFns<LoadRouteResponse>;
+export declare const SetGuidanceOrderRequest: MessageFns<SetGuidanceOrderRequest>;
+export declare const SetGuidanceOrderResponse: MessageFns<SetGuidanceOrderResponse>;
+export declare const SetVoyageStatusRequest: MessageFns<SetVoyageStatusRequest>;
+export declare const SetVoyageStatusResponse: MessageFns<SetVoyageStatusResponse>;
+export declare const GetNavigationStateRequest: MessageFns<GetNavigationStateRequest>;
+export declare const NavigationSettings: MessageFns<NavigationSettings>;
+export declare const GetSettingsRequest: MessageFns<GetSettingsRequest>;
+export declare const GetSettingsResponse: MessageFns<GetSettingsResponse>;
+export declare const SetSettingsRequest: MessageFns<SetSettingsRequest>;
+export declare const SetSettingsResponse: MessageFns<SetSettingsResponse>;
+export type NavigationControlDefinition = typeof NavigationControlDefinition;
+export declare const NavigationControlDefinition: {
+    readonly name: "NavigationControl";
+    readonly fullName: "keelson.interfaces.navigation_control.NavigationControl";
+    readonly methods: {
+        /**
+         * Make a route edition this vessel's active voyage, copying it from another vessel's tree when
+         * needed, and take up a guidance order.
+         */
+        readonly load_route: {
+            readonly name: "load_route";
+            readonly requestType: MessageFns<LoadRouteRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns<LoadRouteResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /**
+         * Steer by the track, a course, a heading, for a position; hold, loiter, or keep a position and
+         * heading (DP); optionally with a speed.
+         */
+        readonly set_guidance_order: {
+            readonly name: "set_guidance_order";
+            readonly requestType: MessageFns<SetGuidanceOrderRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns<SetGuidanceOrderResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /** Pause, resume, complete or abort the active voyage. */
+        readonly set_voyage_status: {
+            readonly name: "set_voyage_status";
+            readonly requestType: MessageFns<SetVoyageStatusRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns<SetVoyageStatusResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /**
+         * The current NavigationState — the same payload as the `navigation_state` broadcast, for a
+         * caller that cannot wait for the next one. Needs no authority.
+         */
+        readonly get_navigation_state: {
+            readonly name: "get_navigation_state";
+            readonly requestType: MessageFns<GetNavigationStateRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./NavigationState").MessageFns<NavigationState>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /** The settings in force, and which cannot change while it runs. Needs no authority. */
+        readonly get_settings: {
+            readonly name: "get_settings";
+            readonly requestType: MessageFns<GetSettingsRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns<GetSettingsResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /**
+         * Tune the process while it runs: COLREG advisor, advice auto-accept, default speeds and radii,
+         * traffic range, route alarms. Never moves the conn.
+         */
+        readonly set_settings: {
+            readonly name: "set_settings";
+            readonly requestType: MessageFns<SetSettingsRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns<SetSettingsResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export 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 keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
+export {};