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

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";
@@ -137,14 +175,6 @@ export declare const serviceDefinitions: {
                 readonly responseStream: false;
                 readonly options: {};
             };
-            readonly describe_file: {
-                readonly name: "describe_file";
-                readonly requestType: import("./ReplayControl").MessageFns<import("./ReplayControl").DescribeFileRequest>;
-                readonly requestStream: false;
-                readonly responseType: import("./ReplayControl").MessageFns<import("./ReplayControl").DescribeFileResponse>;
-                readonly responseStream: false;
-                readonly options: {};
-            };
             readonly load_file: {
                 readonly name: "load_file";
                 readonly requestType: import("./ReplayControl").MessageFns<import("./ReplayControl").LoadFileRequest>;

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/dist/payloads/Route.d.ts

@@ -98,6 +98,34 @@ export declare enum GeometryType {
 }
 export declare function geometryTypeFromJSON(object: any): GeometryType;
 export declare function geometryTypeToJSON(object: GeometryType): string;
+/**
+ * How a leg's XTD corridor is shaped. UNSPECIFIED MUST be read as FIXED:
+ * every leg published before this field existed is a fixed-width corridor, and
+ * reading it any other way would change routes nobody edited.
+ */
+export declare enum XtdCorridorMode {
+    XTD_CORRIDOR_MODE_UNSPECIFIED = 0,
+    /**
+     * XTD_CORRIDOR_MODE_FIXED - Fixed width: parallel lines at xtd_port_m / xtd_starboard_m either side of
+     * track.
+     */
+    XTD_CORRIDOR_MODE_FIXED = 1,
+    /**
+     * XTD_CORRIDOR_MODE_VARIABLE - Variable width: a boundary drawn by the planner (Leg.xtd_port_boundary /
+     * xtd_starboard_boundary), e.g. a corridor that narrows past a shoal.
+     * The metre fields (xtd_port_m / xtd_starboard_m and the monitoring pair)
+     * MUST NOT exceed the closest approach to track of that side's drawn
+     * boundary: they are the INSCRIBED fixed corridor. A monitor that does not
+     * evaluate the boundary then alarms early on a wide stretch and never late at
+     * the narrow one, which is the direction an XTD limit has to fail. Such a
+     * monitor SHOULD report the leg as monitored at reduced fidelity, which is
+     * why its alarm may come early.
+     */
+    XTD_CORRIDOR_MODE_VARIABLE = 2,
+    UNRECOGNIZED = -1
+}
+export declare function xtdCorridorModeFromJSON(object: any): XtdCorridorMode;
+export declare function xtdCorridorModeToJSON(object: XtdCorridorMode): string;
 /**
  * Whether a route's waypoint list closes back on itself. RTZ 1.2 has no such
  * concept, so producers either repeated the first waypoint (breaking id
@@ -470,12 +498,29 @@ export interface Leg {
     /**
      * Cross-track distance (XTD) limits and monitoring thresholds, in metres.
      * `optional` so producers can distinguish "no XTD limit" (unset) from
-     * "zero XTD limit" (set to 0).
+     * "zero XTD limit" (set to 0). Under XTD_CORRIDOR_MODE_VARIABLE all four are
+     * the inscribed corridor (protocol-specification.md §6.2.2).
      */
     xtdPortM?: number | undefined;
     xtdStarboardM?: number | undefined;
     xtdMonitoringPortM?: number | undefined;
     xtdMonitoringStarboardM?: number | undefined;
+    /**
+     * Whether this leg's XTD corridor is fixed or variable width. See XtdCorridorMode and
+     * protocol-specification.md §6.2.2.
+     */
+    xtdCorridorMode: XtdCorridorMode;
+    /**
+     * VARIABLE only: the drawn corridor boundary on each side, vertices in
+     * along-track order, covering this leg and the turn at the waypoint it
+     * arrives at. A consumer MUST ignore both lists unless the mode is VARIABLE,
+     * so a stale shape left behind by a switch back to FIXED is never sailed.
+     * Where the next leg is VARIABLE too, the last vertex on a side SHOULD
+     * coincide with the first vertex of waypoint[i+1].leg's list on that side, so
+     * a monitor meets neither a gap nor an overlap at the junction.
+     */
+    xtdPortBoundary: XtdBoundaryPoint[];
+    xtdStarboardBoundary: XtdBoundaryPoint[];
     /**
      * Safety contour (depth in metres below chart datum) below which the route
      * is considered unsafe.
@@ -524,6 +569,37 @@ export interface Leg {
     colregTrafficIntensity: ColregTrafficIntensity;
     extensions: Extensions | undefined;
 }
+/**
+ * One vertex of a variable-width XTD corridor boundary (Leg.xtd_port_boundary /
+ * Leg.xtd_starboard_boundary).
+ */
+export interface XtdBoundaryPoint {
+    $type: "keelson.XtdBoundaryPoint";
+    /**
+     * WGS-84 vertex. Authoritative: this is the boundary a monitor checks
+     * against, whatever the anchor below says.
+     */
+    position: Coordinate | undefined;
+    /**
+     * Editor anchor — where along the leg's straight the vertex was placed,
+     * 0 at the leg's start and 1 at its end, and how far off track. Lets an
+     * editor keep the vertex attached to the leg when a waypoint moves, instead
+     * of leaving it stranded at its old position. `optional` because a vertex
+     * placed freely (at a leg end or inside a turn) has no such anchor, and 0
+     * is a real fraction.
+     */
+    alongTrackFraction?: number | undefined;
+    /**
+     * Perpendicular distance from track for that anchor, metres, always
+     * positive: the side is given by which boundary list holds the vertex.
+     */
+    offsetM?: number | undefined;
+    /**
+     * True when the vertex lies on the turn at the leg's end rather than on the
+     * straight.
+     */
+    inTurn: boolean;
+}
 export interface Schedules {
     $type: "keelson.Schedules";
     /** Multiple schedules can coexist (e.g. "manual", "weather-optimized"). */
@@ -719,6 +795,7 @@ export declare const Waypoints: MessageFns<Waypoints, "keelson.Waypoints">;
 export declare const DefaultWaypoint: MessageFns<DefaultWaypoint, "keelson.DefaultWaypoint">;
 export declare const Waypoint: MessageFns<Waypoint, "keelson.Waypoint">;
 export declare const Leg: MessageFns<Leg, "keelson.Leg">;
+export declare const XtdBoundaryPoint: MessageFns<XtdBoundaryPoint, "keelson.XtdBoundaryPoint">;
 export declare const Schedules: MessageFns<Schedules, "keelson.Schedules">;
 export declare const Schedule: MessageFns<Schedule, "keelson.Schedule">;
 export declare const ScheduleElement: MessageFns<ScheduleElement, "keelson.ScheduleElement">;