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

package/dist/payloads/NavigationState.d.ts

@@ -0,0 +1,90 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { OperationalAuthority_AuthorityLevel } from "./OperationalAuthority";
+import { RouteRef } from "./Route";
+/**
+ * What the vessel's navigation function is doing right now, stated by the process doing it.
+ *
+ * Not a lock and not a grant. command_authority says who holds the conn, operational_authority
+ * says the most the vessel may claim, and this says what navigation made of both. A consumer
+ * deciding whether to act on the vessel reads those, never this.
+ */
+export interface NavigationState {
+    $type: "keelson.NavigationState";
+    timestamp: Date | undefined;
+    mode: NavigationState_Mode;
+    subMode: NavigationState_SubMode;
+    /** The voyage being monitored or sailed. Absent in MODE_IDLE. */
+    voyageId?: string | undefined;
+    /** The route edition in force. Absent when no edition is resolved; never `latest`. */
+    routeRef?: RouteRef | undefined;
+    /** The leg being sailed, named by the waypoint it leaves (RouteExecution convention). */
+    currentLegFromWaypointId?: string | undefined;
+    /**
+     * The operational_authority level this process is acting under. UNKNOWN when it has heard
+     * none, which is non-authorising exactly as OperationalAuthority defines it.
+     */
+    authorityLevelInForce: OperationalAuthority_AuthorityLevel;
+    /** True only while this process holds a live command_authority lease, judged on its own clock. */
+    connHeld: boolean;
+    /** Why the process is in this mode. For operators and logs; consumers MUST NOT parse it. */
+    reason: string;
+    /** Subjects this process needs and currently lacks or holds stale, e.g. "location_fix". */
+    degradedInputs: string[];
+}
+export declare enum NavigationState_Mode {
+    MODE_UNSPECIFIED = 0,
+    /** MODE_IDLE - No active voyage, or none this process can resolve. */
+    MODE_IDLE = 1,
+    /** MODE_READY - A voyage is active and monitored. Not holding the conn, commanding nothing. */
+    MODE_READY = 2,
+    /** MODE_UNDERWAY - Holding the conn and commanding the vessel along the voyage. */
+    MODE_UNDERWAY = 3,
+    /**
+     * MODE_FALLBACK - Lost something it needs to navigate (conn, authority, fresh ownship state) and has
+     * commanded its declared safe state. `reason` and `degraded_inputs` say what.
+     */
+    MODE_FALLBACK = 4,
+    /** MODE_ARRIVED - Reached the final waypoint of the active voyage. */
+    MODE_ARRIVED = 5,
+    /** MODE_ENDED - The voyage was completed or aborted; conn released. */
+    MODE_ENDED = 6,
+    UNRECOGNIZED = -1
+}
+export declare function navigationState_ModeFromJSON(object: any): NavigationState_Mode;
+export declare function navigationState_ModeToJSON(object: NavigationState_Mode): string;
+/** Refines MODE_UNDERWAY; UNSPECIFIED in every other mode. */
+export declare enum NavigationState_SubMode {
+    SUB_MODE_UNSPECIFIED = 0,
+    /** SUB_MODE_TRACK - following the planned track */
+    SUB_MODE_TRACK = 1,
+    /** SUB_MODE_AVOIDING - executing accepted collision-avoidance advice */
+    SUB_MODE_AVOIDING = 2,
+    /** SUB_MODE_HOLDING - speed zero or loitering, waiting on a condition */
+    SUB_MODE_HOLDING = 3,
+    /** SUB_MODE_REROUTING - awaiting a new route edition */
+    SUB_MODE_REROUTING = 4,
+    UNRECOGNIZED = -1
+}
+export declare function navigationState_SubModeFromJSON(object: any): NavigationState_SubMode;
+export declare function navigationState_SubModeToJSON(object: NavigationState_SubMode): string;
+export declare const NavigationState: MessageFns<NavigationState, "keelson.NavigationState">;
+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]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+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> | "$type">]: never;
+};
+interface MessageFns<T, V extends string> {
+    readonly $type: V;
+    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 {};

package/dist/payloads/NavigationState.js

@@ -0,0 +1,377 @@
+"use strict";
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.6.1
+//   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;
+/* eslint-disable */
+const wire_1 = require("@bufbuild/protobuf/wire");
+const OperationalAuthority_1 = require("./OperationalAuthority");
+const Route_1 = require("./Route");
+const timestamp_1 = require("./google/protobuf/timestamp");
+const typeRegistry_1 = require("./typeRegistry");
+var NavigationState_Mode;
+(function (NavigationState_Mode) {
+    NavigationState_Mode[NavigationState_Mode["MODE_UNSPECIFIED"] = 0] = "MODE_UNSPECIFIED";
+    /** MODE_IDLE - No active voyage, or none this process can resolve. */
+    NavigationState_Mode[NavigationState_Mode["MODE_IDLE"] = 1] = "MODE_IDLE";
+    /** MODE_READY - A voyage is active and monitored. Not holding the conn, commanding nothing. */
+    NavigationState_Mode[NavigationState_Mode["MODE_READY"] = 2] = "MODE_READY";
+    /** MODE_UNDERWAY - Holding the conn and commanding the vessel along the voyage. */
+    NavigationState_Mode[NavigationState_Mode["MODE_UNDERWAY"] = 3] = "MODE_UNDERWAY";
+    /**
+     * MODE_FALLBACK - Lost something it needs to navigate (conn, authority, fresh ownship state) and has
+     * commanded its declared safe state. `reason` and `degraded_inputs` say what.
+     */
+    NavigationState_Mode[NavigationState_Mode["MODE_FALLBACK"] = 4] = "MODE_FALLBACK";
+    /** MODE_ARRIVED - Reached the final waypoint of the active voyage. */
+    NavigationState_Mode[NavigationState_Mode["MODE_ARRIVED"] = 5] = "MODE_ARRIVED";
+    /** MODE_ENDED - The voyage was completed or aborted; conn released. */
+    NavigationState_Mode[NavigationState_Mode["MODE_ENDED"] = 6] = "MODE_ENDED";
+    NavigationState_Mode[NavigationState_Mode["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(NavigationState_Mode || (exports.NavigationState_Mode = NavigationState_Mode = {}));
+function navigationState_ModeFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "MODE_UNSPECIFIED":
+            return NavigationState_Mode.MODE_UNSPECIFIED;
+        case 1:
+        case "MODE_IDLE":
+            return NavigationState_Mode.MODE_IDLE;
+        case 2:
+        case "MODE_READY":
+            return NavigationState_Mode.MODE_READY;
+        case 3:
+        case "MODE_UNDERWAY":
+            return NavigationState_Mode.MODE_UNDERWAY;
+        case 4:
+        case "MODE_FALLBACK":
+            return NavigationState_Mode.MODE_FALLBACK;
+        case 5:
+        case "MODE_ARRIVED":
+            return NavigationState_Mode.MODE_ARRIVED;
+        case 6:
+        case "MODE_ENDED":
+            return NavigationState_Mode.MODE_ENDED;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return NavigationState_Mode.UNRECOGNIZED;
+    }
+}
+exports.navigationState_ModeFromJSON = navigationState_ModeFromJSON;
+function navigationState_ModeToJSON(object) {
+    switch (object) {
+        case NavigationState_Mode.MODE_UNSPECIFIED:
+            return "MODE_UNSPECIFIED";
+        case NavigationState_Mode.MODE_IDLE:
+            return "MODE_IDLE";
+        case NavigationState_Mode.MODE_READY:
+            return "MODE_READY";
+        case NavigationState_Mode.MODE_UNDERWAY:
+            return "MODE_UNDERWAY";
+        case NavigationState_Mode.MODE_FALLBACK:
+            return "MODE_FALLBACK";
+        case NavigationState_Mode.MODE_ARRIVED:
+            return "MODE_ARRIVED";
+        case NavigationState_Mode.MODE_ENDED:
+            return "MODE_ENDED";
+        case NavigationState_Mode.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+exports.navigationState_ModeToJSON = navigationState_ModeToJSON;
+/** Refines MODE_UNDERWAY; UNSPECIFIED in every other mode. */
+var NavigationState_SubMode;
+(function (NavigationState_SubMode) {
+    NavigationState_SubMode[NavigationState_SubMode["SUB_MODE_UNSPECIFIED"] = 0] = "SUB_MODE_UNSPECIFIED";
+    /** SUB_MODE_TRACK - following the planned track */
+    NavigationState_SubMode[NavigationState_SubMode["SUB_MODE_TRACK"] = 1] = "SUB_MODE_TRACK";
+    /** SUB_MODE_AVOIDING - executing accepted collision-avoidance advice */
+    NavigationState_SubMode[NavigationState_SubMode["SUB_MODE_AVOIDING"] = 2] = "SUB_MODE_AVOIDING";
+    /** SUB_MODE_HOLDING - speed zero or loitering, waiting on a condition */
+    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";
+    NavigationState_SubMode[NavigationState_SubMode["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(NavigationState_SubMode || (exports.NavigationState_SubMode = NavigationState_SubMode = {}));
+function navigationState_SubModeFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "SUB_MODE_UNSPECIFIED":
+            return NavigationState_SubMode.SUB_MODE_UNSPECIFIED;
+        case 1:
+        case "SUB_MODE_TRACK":
+            return NavigationState_SubMode.SUB_MODE_TRACK;
+        case 2:
+        case "SUB_MODE_AVOIDING":
+            return NavigationState_SubMode.SUB_MODE_AVOIDING;
+        case 3:
+        case "SUB_MODE_HOLDING":
+            return NavigationState_SubMode.SUB_MODE_HOLDING;
+        case 4:
+        case "SUB_MODE_REROUTING":
+            return NavigationState_SubMode.SUB_MODE_REROUTING;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return NavigationState_SubMode.UNRECOGNIZED;
+    }
+}
+exports.navigationState_SubModeFromJSON = navigationState_SubModeFromJSON;
+function navigationState_SubModeToJSON(object) {
+    switch (object) {
+        case NavigationState_SubMode.SUB_MODE_UNSPECIFIED:
+            return "SUB_MODE_UNSPECIFIED";
+        case NavigationState_SubMode.SUB_MODE_TRACK:
+            return "SUB_MODE_TRACK";
+        case NavigationState_SubMode.SUB_MODE_AVOIDING:
+            return "SUB_MODE_AVOIDING";
+        case NavigationState_SubMode.SUB_MODE_HOLDING:
+            return "SUB_MODE_HOLDING";
+        case NavigationState_SubMode.SUB_MODE_REROUTING:
+            return "SUB_MODE_REROUTING";
+        case NavigationState_SubMode.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+exports.navigationState_SubModeToJSON = navigationState_SubModeToJSON;
+function createBaseNavigationState() {
+    return {
+        $type: "keelson.NavigationState",
+        timestamp: undefined,
+        mode: 0,
+        subMode: 0,
+        voyageId: undefined,
+        routeRef: undefined,
+        currentLegFromWaypointId: undefined,
+        authorityLevelInForce: 0,
+        connHeld: false,
+        reason: "",
+        degradedInputs: [],
+    };
+}
+exports.NavigationState = {
+    $type: "keelson.NavigationState",
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.timestamp !== undefined) {
+            timestamp_1.Timestamp.encode(toTimestamp(message.timestamp), writer.uint32(10).fork()).join();
+        }
+        if (message.mode !== 0) {
+            writer.uint32(16).int32(message.mode);
+        }
+        if (message.subMode !== 0) {
+            writer.uint32(24).int32(message.subMode);
+        }
+        if (message.voyageId !== undefined) {
+            writer.uint32(34).string(message.voyageId);
+        }
+        if (message.routeRef !== undefined) {
+            Route_1.RouteRef.encode(message.routeRef, writer.uint32(42).fork()).join();
+        }
+        if (message.currentLegFromWaypointId !== undefined) {
+            writer.uint32(50).string(message.currentLegFromWaypointId);
+        }
+        if (message.authorityLevelInForce !== 0) {
+            writer.uint32(56).int32(message.authorityLevelInForce);
+        }
+        if (message.connHeld !== false) {
+            writer.uint32(64).bool(message.connHeld);
+        }
+        if (message.reason !== "") {
+            writer.uint32(74).string(message.reason);
+        }
+        for (const v of message.degradedInputs) {
+            writer.uint32(82).string(v);
+        }
+        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 = createBaseNavigationState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.timestamp = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.mode = reader.int32();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.subMode = reader.int32();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.voyageId = reader.string();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.routeRef = Route_1.RouteRef.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 6: {
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.currentLegFromWaypointId = reader.string();
+                    continue;
+                }
+                case 7: {
+                    if (tag !== 56) {
+                        break;
+                    }
+                    message.authorityLevelInForce = reader.int32();
+                    continue;
+                }
+                case 8: {
+                    if (tag !== 64) {
+                        break;
+                    }
+                    message.connHeld = reader.bool();
+                    continue;
+                }
+                case 9: {
+                    if (tag !== 74) {
+                        break;
+                    }
+                    message.reason = reader.string();
+                    continue;
+                }
+                case 10: {
+                    if (tag !== 82) {
+                        break;
+                    }
+                    message.degradedInputs.push(reader.string());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            $type: exports.NavigationState.$type,
+            timestamp: isSet(object.timestamp) ? fromJsonTimestamp(object.timestamp) : undefined,
+            mode: isSet(object.mode) ? navigationState_ModeFromJSON(object.mode) : 0,
+            subMode: isSet(object.subMode) ? navigationState_SubModeFromJSON(object.subMode) : 0,
+            voyageId: isSet(object.voyageId) ? globalThis.String(object.voyageId) : undefined,
+            routeRef: isSet(object.routeRef) ? Route_1.RouteRef.fromJSON(object.routeRef) : undefined,
+            currentLegFromWaypointId: isSet(object.currentLegFromWaypointId)
+                ? globalThis.String(object.currentLegFromWaypointId)
+                : undefined,
+            authorityLevelInForce: isSet(object.authorityLevelInForce)
+                ? (0, OperationalAuthority_1.operationalAuthority_AuthorityLevelFromJSON)(object.authorityLevelInForce)
+                : 0,
+            connHeld: isSet(object.connHeld) ? globalThis.Boolean(object.connHeld) : false,
+            reason: isSet(object.reason) ? globalThis.String(object.reason) : "",
+            degradedInputs: globalThis.Array.isArray(object?.degradedInputs)
+                ? object.degradedInputs.map((e) => globalThis.String(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.timestamp !== undefined) {
+            obj.timestamp = message.timestamp.toISOString();
+        }
+        if (message.mode !== 0) {
+            obj.mode = navigationState_ModeToJSON(message.mode);
+        }
+        if (message.subMode !== 0) {
+            obj.subMode = navigationState_SubModeToJSON(message.subMode);
+        }
+        if (message.voyageId !== undefined) {
+            obj.voyageId = message.voyageId;
+        }
+        if (message.routeRef !== undefined) {
+            obj.routeRef = Route_1.RouteRef.toJSON(message.routeRef);
+        }
+        if (message.currentLegFromWaypointId !== undefined) {
+            obj.currentLegFromWaypointId = message.currentLegFromWaypointId;
+        }
+        if (message.authorityLevelInForce !== 0) {
+            obj.authorityLevelInForce = (0, OperationalAuthority_1.operationalAuthority_AuthorityLevelToJSON)(message.authorityLevelInForce);
+        }
+        if (message.connHeld !== false) {
+            obj.connHeld = message.connHeld;
+        }
+        if (message.reason !== "") {
+            obj.reason = message.reason;
+        }
+        if (message.degradedInputs?.length) {
+            obj.degradedInputs = message.degradedInputs;
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.NavigationState.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseNavigationState();
+        message.timestamp = object.timestamp ?? undefined;
+        message.mode = object.mode ?? 0;
+        message.subMode = object.subMode ?? 0;
+        message.voyageId = object.voyageId ?? undefined;
+        message.routeRef = (object.routeRef !== undefined && object.routeRef !== null)
+            ? Route_1.RouteRef.fromPartial(object.routeRef)
+            : undefined;
+        message.currentLegFromWaypointId = object.currentLegFromWaypointId ?? undefined;
+        message.authorityLevelInForce = object.authorityLevelInForce ?? 0;
+        message.connHeld = object.connHeld ?? false;
+        message.reason = object.reason ?? "";
+        message.degradedInputs = object.degradedInputs?.map((e) => e) || [];
+        return message;
+    },
+};
+typeRegistry_1.messageTypeRegistry.set(exports.NavigationState.$type, exports.NavigationState);
+function toTimestamp(date) {
+    const seconds = Math.trunc(date.getTime() / 1000);
+    const nanos = (date.getTime() % 1000) * 1000000;
+    return { $type: "google.protobuf.Timestamp", seconds, nanos };
+}
+function fromTimestamp(t) {
+    let millis = (t.seconds || 0) * 1000;
+    millis += (t.nanos || 0) / 1000000;
+    return new globalThis.Date(millis);
+}
+function fromJsonTimestamp(o) {
+    if (o instanceof globalThis.Date) {
+        return o;
+    }
+    else if (typeof o === "string") {
+        return new globalThis.Date(o);
+    }
+    else {
+        return fromTimestamp(timestamp_1.Timestamp.fromJSON(o));
+    }
+}
+function isSet(value) {
+    return value !== null && value !== undefined;
+}

package/dist/payloads/Route.d.ts

@@ -56,13 +56,24 @@ export declare enum HazardZoneType {
 }
 export declare function hazardZoneTypeFromJSON(object: any): HazardZoneType;
 export declare function hazardZoneTypeToJSON(object: HazardZoneType): string;
-/** COLREG encounter situation for an annotated leg. */
+/**
+ * COLREG encounter situation, from own ship's side. One vocabulary for the plan and the live
+ * picture: a Route leg is annotated with 1-4 only; Encounter.situation may also carry 5-6, which
+ * describe a live target and never a planned leg.
+ */
 export declare enum ColregSituation {
     COLREG_SITUATION_UNSPECIFIED = 0,
+    /** COLREG_SITUATION_OVERTAKING - own ship is overtaking */
     COLREG_SITUATION_OVERTAKING = 1,
+    /** COLREG_SITUATION_CROSSING_STBD - target crossing from own starboard */
     COLREG_SITUATION_CROSSING_STBD = 2,
+    /** COLREG_SITUATION_CROSSING_PORT - target crossing from own port */
     COLREG_SITUATION_CROSSING_PORT = 3,
     COLREG_SITUATION_HEAD_ON = 4,
+    /** COLREG_SITUATION_OVERTAKEN - target is overtaking own ship (Encounter only) */
+    COLREG_SITUATION_OVERTAKEN = 5,
+    /** COLREG_SITUATION_NONE - target not under way, or restricted visibility (Encounter only) */
+    COLREG_SITUATION_NONE = 6,
     UNRECOGNIZED = -1
 }
 export declare function colregSituationFromJSON(object: any): ColregSituation;
@@ -87,6 +98,61 @@ 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.
+     * xtd_port_m / xtd_starboard_m still carry a nominal limit for a monitor
+     * that does not evaluate the boundary. That fallback is NOT conservative when
+     * the drawn corridor is narrower than the nominal one, which is why such a
+     * monitor SHOULD report the leg as monitored at reduced fidelity.
+     */
+    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
+ * uniqueness) or left closing to consumer convention (silently wrong the first
+ * time a consumer chooses not to loop). This field makes the author say.
+ *
+ * An enum rather than a bool, like every other classification in this file:
+ * OPEN says closure was considered and declined, and there is room for a
+ * third topology (out-and-back). UNSPECIFIED MUST be read as OPEN; that is
+ * the fail-safe direction, since sailing a point-to-point route as a circuit
+ * takes the vessel over unplanned water. Terminal behaviour (stop, hold, go
+ * round again) is execution policy and belongs on keelson.Voyage, not here.
+ * See protocol-specification.md §6.2.1.
+ */
+export declare enum RouteTopology {
+    ROUTE_TOPOLOGY_UNSPECIFIED = 0,
+    /**
+     * ROUTE_TOPOLOGY_OPEN - Runs from the first waypoint to the last and ends there. The last
+     * waypoint has no outgoing leg.
+     */
+    ROUTE_TOPOLOGY_OPEN = 1,
+    /**
+     * ROUTE_TOPOLOGY_CLOSED - A circuit: the last waypoint's outgoing leg terminates at the first
+     * waypoint, which is NOT repeated at the end of the list.
+     */
+    ROUTE_TOPOLOGY_CLOSED = 2,
+    UNRECOGNIZED = -1
+}
+export declare function routeTopologyFromJSON(object: any): RouteTopology;
+export declare function routeTopologyToJSON(object: RouteTopology): string;
 /**
  * Lifecycle status for the route artifact (authoring + quality).
  * Execution-side state (vessel sailing, paused, completed) lives on
@@ -330,10 +396,18 @@ export interface Waypoints {
     defaults: DefaultWaypoint | undefined;
     /** Ordered list of waypoints, in route order. */
     waypoint: Waypoint[];
+    /**
+     * Whether the list above closes back on itself. Lives here because it is a
+     * statement about this list. Unset reads as ROUTE_TOPOLOGY_OPEN (§6.2.1).
+     */
+    topology: RouteTopology;
     extensions: Extensions | undefined;
 }
 /**
- * Default values for waypoint/leg fields. RTZ-aligned.
+ * Default values for waypoint/leg fields. RTZ-aligned — the field set matches
+ * RTZ's own defaultWaypoint element, which is a separate question from where
+ * leg data hangs: a merged default inherits the departure convention of the
+ * field it backs, same as an explicit value (§6.2.1).
  *
  * The scalars are `optional` for the same reason as their `Waypoint`
  * counterparts, one level up: without presence there is no way to say "this
@@ -373,8 +447,9 @@ export interface Waypoint {
      */
     position: Coordinate | undefined;
     /**
-     * Planned speed over ground when leaving this waypoint. `optional` because
-     * `Waypoints.defaults` backs this field: without presence, "no override,
+     * Planned speed over ground when LEAVING this waypoint, i.e. on `leg`
+     * below. RTZ indexes this on the arrival waypoint instead (§6.2.1).
+     * `optional` because `Waypoints.defaults` backs this field: without presence, "no override,
      * use the default" and "hold zero speed here" are the same bytes, and 0.0
      * is the more dangerous reading of the pair.
      */
@@ -398,12 +473,23 @@ export interface Waypoint {
     lock: boolean;
     /** Operational context for this waypoint (open sea, port approach, lock, ...). */
     operationalContext: OperationalContext;
-    /** Outgoing leg from this waypoint to the next. The last waypoint has none. */
+    /**
+     * Outgoing leg from this waypoint to the next: `waypoint[i].leg` is the edge
+     * to `waypoint[i+1]`. In an OPEN route the last waypoint has none and a
+     * consumer MUST ignore one if present. In a CLOSED route the last waypoint's
+     * leg runs to `waypoint[0]`; that is how a circuit closes, never by
+     * repeating the first waypoint. RTZ hangs the leg on the ARRIVAL waypoint,
+     * so a converter shifts by one (§6.2.1).
+     */
     leg: Leg | undefined;
     /** Free-form notes attached to this waypoint. */
     note: string;
     extensions: Extensions | undefined;
 }
+/**
+ * Every field here describes the edge LEAVING the waypoint that carries it
+ * (see Waypoint.leg and §6.2.1 for the RTZ shift).
+ */
 export interface Leg {
     $type: "keelson.Leg";
     /**
@@ -415,6 +501,19 @@ export interface Leg {
     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.
+     */
+    xtdPortBoundary: XtdBoundaryPoint[];
+    xtdStarboardBoundary: XtdBoundaryPoint[];
     /**
      * Safety contour (depth in metres below chart datum) below which the route
      * is considered unsafe.
@@ -463,6 +562,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"). */
@@ -502,7 +632,12 @@ export interface ScheduleElement {
     etdWindowEnd: Date | undefined;
     /** Planned duration of stay at this waypoint (port, anchorage, ...). */
     stay: Duration | undefined;
-    /** -- Environmental forecast for this leg ------------------------------------ */
+    /**
+     * -- Environmental forecast for this leg ------------------------------------
+     * The OUTGOING leg — the one leaving `waypoint_id`, matching `Waypoint.leg`
+     * and `planned_sog_knots`. The last waypoint of an OPEN route has no
+     * outgoing leg and so no forecast to carry (§6.2.1).
+     */
     windSpeedMps: number;
     windDirectionDeg: number;
     currentSpeedMps: number;
@@ -653,6 +788,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">;