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

package/dist/payloads/Route.d.ts

@@ -107,6 +107,30 @@ export declare enum RouteStatus {
 }
 export declare function routeStatusFromJSON(object: any): RouteStatus;
 export declare function routeStatusToJSON(object: RouteStatus): string;
+/**
+ * Which side of an operational limit counts as a breach.
+ *
+ * RouteInfo's own limit block carries both directions — max_wind_gust_mps is
+ * breached above, min_visibility_m below — so nothing about a limit's identity
+ * says which way it fails. Consumers of an exceedance record need it: "the most
+ * extreme value reached" is undefined without it, and deriving the direction
+ * from a `max_` / `min_` name prefix is a string match that fails silently the
+ * first time a limit is named anything else.
+ *
+ * Lives here rather than beside either consumer because it is a property of the
+ * limit as authored, not of the monitoring. Read by keelson.EnvelopeExceedance
+ * and keelson.EnvelopeLimitState.
+ */
+export declare enum EnvelopeBound {
+    ENVELOPE_BOUND_UNSPECIFIED = 0,
+    /** ENVELOPE_BOUND_UPPER - Breached by going ABOVE the limit value (max_wind_gust_mps, max_roll_deg). */
+    ENVELOPE_BOUND_UPPER = 1,
+    /** ENVELOPE_BOUND_LOWER - Breached by going BELOW it (min_visibility_m, min_speed_knots). */
+    ENVELOPE_BOUND_LOWER = 2,
+    UNRECOGNIZED = -1
+}
+export declare function envelopeBoundFromJSON(object: any): EnvelopeBound;
+export declare function envelopeBoundToJSON(object: EnvelopeBound): string;
 /** Required action for an ActionPoint. */
 export declare enum ActionPointRequiredAction {
     ACTION_POINT_REQUIRED_ACTION_UNSPECIFIED = 0,

package/dist/payloads/Route.js

@@ -5,8 +5,8 @@
 //   protoc               v6.30.2
 // source: Route.proto
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RouteSignatures = exports.RouteIssue = exports.RouteChallenge = exports.HazardZone = exports.ActionPoint = exports.ActionPoints = exports.ScheduleElement = exports.Schedule = exports.Schedules = exports.Leg = exports.Waypoint = exports.DefaultWaypoint = exports.Waypoints = exports.RouteInfo = exports.Route = exports.Extensions_Entry_AttributesEntry = exports.Extensions_Entry = exports.Extensions = exports.CircleGeometry = exports.RouteRef = exports.schedule_OriginToJSON = exports.schedule_OriginFromJSON = exports.Schedule_Origin = exports.actionPointRequiredActionToJSON = exports.actionPointRequiredActionFromJSON = exports.ActionPointRequiredAction = exports.routeStatusToJSON = exports.routeStatusFromJSON = exports.RouteStatus = exports.geometryTypeToJSON = exports.geometryTypeFromJSON = exports.GeometryType = exports.colregTrafficIntensityToJSON = exports.colregTrafficIntensityFromJSON = exports.ColregTrafficIntensity = exports.colregSituationToJSON = exports.colregSituationFromJSON = exports.ColregSituation = exports.hazardZoneTypeToJSON = exports.hazardZoneTypeFromJSON = exports.HazardZoneType = exports.routeChallengeTypeToJSON = exports.routeChallengeTypeFromJSON = exports.RouteChallengeType = exports.operationalContextToJSON = exports.operationalContextFromJSON = exports.OperationalContext = exports.autonomyLevelToJSON = exports.autonomyLevelFromJSON = exports.AutonomyLevel = void 0;
-exports.RouteStatusUpdate = exports.RouteSignature = void 0;
+exports.HazardZone = exports.ActionPoint = exports.ActionPoints = exports.ScheduleElement = exports.Schedule = exports.Schedules = exports.Leg = exports.Waypoint = exports.DefaultWaypoint = exports.Waypoints = exports.RouteInfo = exports.Route = exports.Extensions_Entry_AttributesEntry = exports.Extensions_Entry = exports.Extensions = exports.CircleGeometry = exports.RouteRef = exports.schedule_OriginToJSON = exports.schedule_OriginFromJSON = exports.Schedule_Origin = exports.actionPointRequiredActionToJSON = exports.actionPointRequiredActionFromJSON = exports.ActionPointRequiredAction = exports.envelopeBoundToJSON = exports.envelopeBoundFromJSON = exports.EnvelopeBound = exports.routeStatusToJSON = exports.routeStatusFromJSON = exports.RouteStatus = exports.geometryTypeToJSON = exports.geometryTypeFromJSON = exports.GeometryType = exports.colregTrafficIntensityToJSON = exports.colregTrafficIntensityFromJSON = exports.ColregTrafficIntensity = exports.colregSituationToJSON = exports.colregSituationFromJSON = exports.ColregSituation = exports.hazardZoneTypeToJSON = exports.hazardZoneTypeFromJSON = exports.HazardZoneType = exports.routeChallengeTypeToJSON = exports.routeChallengeTypeFromJSON = exports.RouteChallengeType = exports.operationalContextToJSON = exports.operationalContextFromJSON = exports.OperationalContext = exports.autonomyLevelToJSON = exports.autonomyLevelFromJSON = exports.AutonomyLevel = void 0;
+exports.RouteStatusUpdate = exports.RouteSignature = exports.RouteSignatures = exports.RouteIssue = exports.RouteChallenge = void 0;
 /* eslint-disable */
 const wire_1 = require("@bufbuild/protobuf/wire");
 const Coordinate_1 = require("./Coordinate");
@@ -492,6 +492,61 @@ function routeStatusToJSON(object) {
     }
 }
 exports.routeStatusToJSON = routeStatusToJSON;
+/**
+ * Which side of an operational limit counts as a breach.
+ *
+ * RouteInfo's own limit block carries both directions — max_wind_gust_mps is
+ * breached above, min_visibility_m below — so nothing about a limit's identity
+ * says which way it fails. Consumers of an exceedance record need it: "the most
+ * extreme value reached" is undefined without it, and deriving the direction
+ * from a `max_` / `min_` name prefix is a string match that fails silently the
+ * first time a limit is named anything else.
+ *
+ * Lives here rather than beside either consumer because it is a property of the
+ * limit as authored, not of the monitoring. Read by keelson.EnvelopeExceedance
+ * and keelson.EnvelopeLimitState.
+ */
+var EnvelopeBound;
+(function (EnvelopeBound) {
+    EnvelopeBound[EnvelopeBound["ENVELOPE_BOUND_UNSPECIFIED"] = 0] = "ENVELOPE_BOUND_UNSPECIFIED";
+    /** ENVELOPE_BOUND_UPPER - Breached by going ABOVE the limit value (max_wind_gust_mps, max_roll_deg). */
+    EnvelopeBound[EnvelopeBound["ENVELOPE_BOUND_UPPER"] = 1] = "ENVELOPE_BOUND_UPPER";
+    /** ENVELOPE_BOUND_LOWER - Breached by going BELOW it (min_visibility_m, min_speed_knots). */
+    EnvelopeBound[EnvelopeBound["ENVELOPE_BOUND_LOWER"] = 2] = "ENVELOPE_BOUND_LOWER";
+    EnvelopeBound[EnvelopeBound["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(EnvelopeBound || (exports.EnvelopeBound = EnvelopeBound = {}));
+function envelopeBoundFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "ENVELOPE_BOUND_UNSPECIFIED":
+            return EnvelopeBound.ENVELOPE_BOUND_UNSPECIFIED;
+        case 1:
+        case "ENVELOPE_BOUND_UPPER":
+            return EnvelopeBound.ENVELOPE_BOUND_UPPER;
+        case 2:
+        case "ENVELOPE_BOUND_LOWER":
+            return EnvelopeBound.ENVELOPE_BOUND_LOWER;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return EnvelopeBound.UNRECOGNIZED;
+    }
+}
+exports.envelopeBoundFromJSON = envelopeBoundFromJSON;
+function envelopeBoundToJSON(object) {
+    switch (object) {
+        case EnvelopeBound.ENVELOPE_BOUND_UNSPECIFIED:
+            return "ENVELOPE_BOUND_UNSPECIFIED";
+        case EnvelopeBound.ENVELOPE_BOUND_UPPER:
+            return "ENVELOPE_BOUND_UPPER";
+        case EnvelopeBound.ENVELOPE_BOUND_LOWER:
+            return "ENVELOPE_BOUND_LOWER";
+        case EnvelopeBound.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+exports.envelopeBoundToJSON = envelopeBoundToJSON;
 /** Required action for an ActionPoint. */
 var ActionPointRequiredAction;
 (function (ActionPointRequiredAction) {

package/dist/payloads/RouteExecution.d.ts

@@ -1,5 +1,5 @@
 import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
-import { RouteRef } from "./Route";
+import { EnvelopeBound, RouteRef } from "./Route";
 export interface RouteExecution {
     $type: "keelson.RouteExecution";
     /** Sample timestamp. */
@@ -33,6 +33,20 @@ export interface RouteExecution {
      * current Leg's xtd_port_m / xtd_stbd_m or a configured fallback.
      */
     deviationThresholdM: number;
+    /**
+     * -- Operational envelope state ---------------------------------------------
+     * Live standing of every RouteInfo operational limit being monitored, one
+     * entry per limit. Generalises the XTD deviation above, which stays as it is:
+     * cross-track is per-leg geometry rather than a RouteInfo envelope limit, and
+     * it is already published.
+     *
+     * This is the *live* half. It says whether the vessel is outside its envelope
+     * right now; it deliberately does not say when the breach was noticed or what
+     * was done about it. RouteExecution is an ephemeral snapshot and is not
+     * persisted, so it cannot be the evidence record — that is the
+     * `envelope_exceedance` subject.
+     */
+    envelopeLimits: EnvelopeLimitState[];
     /**
      * -- Kinematics (echo of own-ship state for convenience) --------------------
      * Knots to match the bus convention (subjects.yaml: speed_over_ground_knots)
@@ -41,7 +55,73 @@ export interface RouteExecution {
     speedOverGroundKnots: number;
     courseOverGroundDeg: number;
 }
+/** The standing of one operational limit at the sample instant. */
+export interface EnvelopeLimitState {
+    $type: "keelson.EnvelopeLimitState";
+    /**
+     * The RouteInfo field the limit came from, e.g. "max_wind_gust_mps". Named
+     * rather than positional so a consumer can attribute a breach without
+     * holding the route, and so the id survives a route edition bump.
+     *
+     * A string on purpose — see keelson.EnvelopeExceedance.limit_id for why, and
+     * for when to revisit it.
+     */
+    limitId: string;
+    /** The authored limit this sample was tested against. */
+    limitValue: number;
+    /**
+     * The measurement it was tested against. `optional` because a limit can be
+     * authored with nothing measuring it, and that is not the same as measuring
+     * zero.
+     */
+    measuredValue?: number | undefined;
+    state: EnvelopeLimitState_State;
+    /**
+     * When `measured_value` was taken. `optional`, and absent under
+     * STATE_UNMEASURED by definition.
+     *
+     * Without it a ten-minute-old measurement reads as STATE_WITHIN exactly like
+     * a fresh one — the same failure STATE_UNMEASURED exists to prevent, one
+     * level down: a stale reading that renders as compliance. A consumer decides
+     * for itself what "too old" means for a given limit, which it cannot do
+     * without this.
+     *
+     * A receiver must NOT stamp this from the enclosing snapshot's own timestamp
+     * when a publisher leaves it unset. That asserts a measurement time that is
+     * simply wrong, and looks authoritative doing it; unset means "not known".
+     */
+    measuredAt?: Date | undefined;
+    /**
+     * Which side of `limit_value` counts as a breach — see EnvelopeBound in
+     * Route.proto. Carried on the live standing as well as on the durable record
+     * so a consumer can render "8.0 / 12.0" the right way round without holding
+     * the route.
+     */
+    bound: EnvelopeBound;
+}
+export declare enum EnvelopeLimitState_State {
+    STATE_UNSPECIFIED = 0,
+    /** STATE_WITHIN - Measured, and inside the limit. */
+    STATE_WITHIN = 1,
+    /** STATE_BREACHED - Measured, and outside it. */
+    STATE_BREACHED = 2,
+    /**
+     * STATE_UNMEASURED - The limit is authored but nothing is measuring it, so no verdict exists.
+     *
+     * This is why the field is an enum rather than a bool. A `false` for a
+     * limit nothing measures is indistinguishable from a limit being honoured,
+     * and an unmonitored constraint that reads as compliance is worse than one
+     * that is absent: it looks managed. Keelson draws the same line elsewhere —
+     * HealthLevel separates UNKNOWN from CRITICAL, AuthorityLevel separates
+     * UNKNOWN from MINIMAL_SAFE_MODE.
+     */
+    STATE_UNMEASURED = 3,
+    UNRECOGNIZED = -1
+}
+export declare function envelopeLimitState_StateFromJSON(object: any): EnvelopeLimitState_State;
+export declare function envelopeLimitState_StateToJSON(object: EnvelopeLimitState_State): string;
 export declare const RouteExecution: MessageFns<RouteExecution, "keelson.RouteExecution">;
+export declare const EnvelopeLimitState: MessageFns<EnvelopeLimitState, "keelson.EnvelopeLimitState">;
 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/RouteExecution.js

@@ -5,12 +5,69 @@
 //   protoc               v6.30.2
 // source: RouteExecution.proto
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RouteExecution = void 0;
+exports.EnvelopeLimitState = exports.RouteExecution = exports.envelopeLimitState_StateToJSON = exports.envelopeLimitState_StateFromJSON = exports.EnvelopeLimitState_State = void 0;
 /* eslint-disable */
 const wire_1 = require("@bufbuild/protobuf/wire");
 const Route_1 = require("./Route");
 const timestamp_1 = require("./google/protobuf/timestamp");
 const typeRegistry_1 = require("./typeRegistry");
+var EnvelopeLimitState_State;
+(function (EnvelopeLimitState_State) {
+    EnvelopeLimitState_State[EnvelopeLimitState_State["STATE_UNSPECIFIED"] = 0] = "STATE_UNSPECIFIED";
+    /** STATE_WITHIN - Measured, and inside the limit. */
+    EnvelopeLimitState_State[EnvelopeLimitState_State["STATE_WITHIN"] = 1] = "STATE_WITHIN";
+    /** STATE_BREACHED - Measured, and outside it. */
+    EnvelopeLimitState_State[EnvelopeLimitState_State["STATE_BREACHED"] = 2] = "STATE_BREACHED";
+    /**
+     * STATE_UNMEASURED - The limit is authored but nothing is measuring it, so no verdict exists.
+     *
+     * This is why the field is an enum rather than a bool. A `false` for a
+     * limit nothing measures is indistinguishable from a limit being honoured,
+     * and an unmonitored constraint that reads as compliance is worse than one
+     * that is absent: it looks managed. Keelson draws the same line elsewhere —
+     * HealthLevel separates UNKNOWN from CRITICAL, AuthorityLevel separates
+     * UNKNOWN from MINIMAL_SAFE_MODE.
+     */
+    EnvelopeLimitState_State[EnvelopeLimitState_State["STATE_UNMEASURED"] = 3] = "STATE_UNMEASURED";
+    EnvelopeLimitState_State[EnvelopeLimitState_State["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(EnvelopeLimitState_State || (exports.EnvelopeLimitState_State = EnvelopeLimitState_State = {}));
+function envelopeLimitState_StateFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "STATE_UNSPECIFIED":
+            return EnvelopeLimitState_State.STATE_UNSPECIFIED;
+        case 1:
+        case "STATE_WITHIN":
+            return EnvelopeLimitState_State.STATE_WITHIN;
+        case 2:
+        case "STATE_BREACHED":
+            return EnvelopeLimitState_State.STATE_BREACHED;
+        case 3:
+        case "STATE_UNMEASURED":
+            return EnvelopeLimitState_State.STATE_UNMEASURED;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return EnvelopeLimitState_State.UNRECOGNIZED;
+    }
+}
+exports.envelopeLimitState_StateFromJSON = envelopeLimitState_StateFromJSON;
+function envelopeLimitState_StateToJSON(object) {
+    switch (object) {
+        case EnvelopeLimitState_State.STATE_UNSPECIFIED:
+            return "STATE_UNSPECIFIED";
+        case EnvelopeLimitState_State.STATE_WITHIN:
+            return "STATE_WITHIN";
+        case EnvelopeLimitState_State.STATE_BREACHED:
+            return "STATE_BREACHED";
+        case EnvelopeLimitState_State.STATE_UNMEASURED:
+            return "STATE_UNMEASURED";
+        case EnvelopeLimitState_State.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+exports.envelopeLimitState_StateToJSON = envelopeLimitState_StateToJSON;
 function createBaseRouteExecution() {
     return {
         $type: "keelson.RouteExecution",
@@ -26,6 +83,7 @@ function createBaseRouteExecution() {
         etaArrival: undefined,
         deviationActive: false,
         deviationThresholdM: 0,
+        envelopeLimits: [],
         speedOverGroundKnots: 0,
         courseOverGroundDeg: 0,
     };
@@ -69,6 +127,9 @@ exports.RouteExecution = {
         if (message.deviationThresholdM !== 0) {
             writer.uint32(253).float(message.deviationThresholdM);
         }
+        for (const v of message.envelopeLimits) {
+            exports.EnvelopeLimitState.encode(v, writer.uint32(258).fork()).join();
+        }
         if (message.speedOverGroundKnots !== 0) {
             writer.uint32(325).float(message.speedOverGroundKnots);
         }
@@ -168,6 +229,13 @@ exports.RouteExecution = {
                     message.deviationThresholdM = reader.float();
                     continue;
                 }
+                case 32: {
+                    if (tag !== 258) {
+                        break;
+                    }
+                    message.envelopeLimits.push(exports.EnvelopeLimitState.decode(reader, reader.uint32()));
+                    continue;
+                }
                 case 40: {
                     if (tag !== 325) {
                         break;
@@ -209,6 +277,9 @@ exports.RouteExecution = {
             etaArrival: isSet(object.etaArrival) ? fromJsonTimestamp(object.etaArrival) : undefined,
             deviationActive: isSet(object.deviationActive) ? globalThis.Boolean(object.deviationActive) : false,
             deviationThresholdM: isSet(object.deviationThresholdM) ? globalThis.Number(object.deviationThresholdM) : 0,
+            envelopeLimits: globalThis.Array.isArray(object?.envelopeLimits)
+                ? object.envelopeLimits.map((e) => exports.EnvelopeLimitState.fromJSON(e))
+                : [],
             speedOverGroundKnots: isSet(object.speedOverGroundKnots) ? globalThis.Number(object.speedOverGroundKnots) : 0,
             courseOverGroundDeg: isSet(object.courseOverGroundDeg) ? globalThis.Number(object.courseOverGroundDeg) : 0,
         };
@@ -251,6 +322,9 @@ exports.RouteExecution = {
         if (message.deviationThresholdM !== 0) {
             obj.deviationThresholdM = message.deviationThresholdM;
         }
+        if (message.envelopeLimits?.length) {
+            obj.envelopeLimits = message.envelopeLimits.map((e) => exports.EnvelopeLimitState.toJSON(e));
+        }
         if (message.speedOverGroundKnots !== 0) {
             obj.speedOverGroundKnots = message.speedOverGroundKnots;
         }
@@ -278,12 +352,152 @@ exports.RouteExecution = {
         message.etaArrival = object.etaArrival ?? undefined;
         message.deviationActive = object.deviationActive ?? false;
         message.deviationThresholdM = object.deviationThresholdM ?? 0;
+        message.envelopeLimits = object.envelopeLimits?.map((e) => exports.EnvelopeLimitState.fromPartial(e)) || [];
         message.speedOverGroundKnots = object.speedOverGroundKnots ?? 0;
         message.courseOverGroundDeg = object.courseOverGroundDeg ?? 0;
         return message;
     },
 };
 typeRegistry_1.messageTypeRegistry.set(exports.RouteExecution.$type, exports.RouteExecution);
+function createBaseEnvelopeLimitState() {
+    return {
+        $type: "keelson.EnvelopeLimitState",
+        limitId: "",
+        limitValue: 0,
+        measuredValue: undefined,
+        state: 0,
+        measuredAt: undefined,
+        bound: 0,
+    };
+}
+exports.EnvelopeLimitState = {
+    $type: "keelson.EnvelopeLimitState",
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.limitId !== "") {
+            writer.uint32(10).string(message.limitId);
+        }
+        if (message.limitValue !== 0) {
+            writer.uint32(21).float(message.limitValue);
+        }
+        if (message.measuredValue !== undefined) {
+            writer.uint32(29).float(message.measuredValue);
+        }
+        if (message.state !== 0) {
+            writer.uint32(32).int32(message.state);
+        }
+        if (message.measuredAt !== undefined) {
+            timestamp_1.Timestamp.encode(toTimestamp(message.measuredAt), writer.uint32(42).fork()).join();
+        }
+        if (message.bound !== 0) {
+            writer.uint32(48).int32(message.bound);
+        }
+        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 = createBaseEnvelopeLimitState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.limitId = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 21) {
+                        break;
+                    }
+                    message.limitValue = reader.float();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 29) {
+                        break;
+                    }
+                    message.measuredValue = reader.float();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.state = reader.int32();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.measuredAt = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 6: {
+                    if (tag !== 48) {
+                        break;
+                    }
+                    message.bound = reader.int32();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            $type: exports.EnvelopeLimitState.$type,
+            limitId: isSet(object.limitId) ? globalThis.String(object.limitId) : "",
+            limitValue: isSet(object.limitValue) ? globalThis.Number(object.limitValue) : 0,
+            measuredValue: isSet(object.measuredValue) ? globalThis.Number(object.measuredValue) : undefined,
+            state: isSet(object.state) ? envelopeLimitState_StateFromJSON(object.state) : 0,
+            measuredAt: isSet(object.measuredAt) ? fromJsonTimestamp(object.measuredAt) : undefined,
+            bound: isSet(object.bound) ? (0, Route_1.envelopeBoundFromJSON)(object.bound) : 0,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.limitId !== "") {
+            obj.limitId = message.limitId;
+        }
+        if (message.limitValue !== 0) {
+            obj.limitValue = message.limitValue;
+        }
+        if (message.measuredValue !== undefined) {
+            obj.measuredValue = message.measuredValue;
+        }
+        if (message.state !== 0) {
+            obj.state = envelopeLimitState_StateToJSON(message.state);
+        }
+        if (message.measuredAt !== undefined) {
+            obj.measuredAt = message.measuredAt.toISOString();
+        }
+        if (message.bound !== 0) {
+            obj.bound = (0, Route_1.envelopeBoundToJSON)(message.bound);
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.EnvelopeLimitState.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseEnvelopeLimitState();
+        message.limitId = object.limitId ?? "";
+        message.limitValue = object.limitValue ?? 0;
+        message.measuredValue = object.measuredValue ?? undefined;
+        message.state = object.state ?? 0;
+        message.measuredAt = object.measuredAt ?? undefined;
+        message.bound = object.bound ?? 0;
+        return message;
+    },
+};
+typeRegistry_1.messageTypeRegistry.set(exports.EnvelopeLimitState.$type, exports.EnvelopeLimitState);
 function toTimestamp(date) {
     const seconds = Math.trunc(date.getTime() / 1000);
     const nanos = (date.getTime() % 1000) * 1000000;

package/dist/payloads/ScenarioEvent.d.ts

@@ -0,0 +1,90 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+/**
+ * Something the exercise script did, at the moment it did it.
+ *
+ * A recording shows a vessel slowing down; it does not show whether that was
+ * the autonomy under test deciding to slow down or the scenario commanding it.
+ * Nothing else on the bus can settle that afterwards, which is why this is
+ * evidence rather than convenience: without it, an evaluator reading a
+ * recording cannot separate the system's behaviour from the exercise's
+ * intervention.
+ *
+ * Distinct from the interfaces that *cause* these things. A simulator's RPC
+ * surface (simulation_control/v1, scenario_control/v1) is how an operator acts
+ * on a run; this subject is the record that an action occurred, published by
+ * the authority that applied it, whether the cause was an operator, a scripted
+ * event or a fault schedule.
+ *
+ * Relationship to ScenarioStatus: that answers "what is the world doing now?"
+ * on a continuous cadence. This answers "what was done to it, and when?", once
+ * per occurrence.
+ */
+export interface ScenarioEvent {
+    $type: "keelson.ScenarioEvent";
+    /**
+     * Source timestamp: wall-clock time at which the event was applied.
+     * simulated time lives in tick below, and in a stepped or fast-time run the
+     * two diverge by design.
+     */
+    timestamp: Date | undefined;
+    /**
+     * Which run this happened in, and at which tick of it. A recording that
+     * spans a restore contains events from more than one run_id (see
+     * ScenarioStatus.parent_run_id), and an event attributed to the wrong run is
+     * worse than a missing one.
+     */
+    runId: string;
+    tick: number;
+    /**
+     * What was done. A free string rather than an enum, deliberately: the
+     * vocabulary belongs to the scenario format, not to keelson, and a fixed
+     * list here would decide what a simulator is allowed to script. Consumers
+     * that care match on values they know and record the rest verbatim.
+     */
+    action: string;
+    /**
+     * What it was done to, empty for a world-level event. Names an entity in the
+     * key space, so a consumer can join this against that entity's subjects.
+     */
+    entityId: string;
+    /**
+     * Arguments to the action — a new speed, a fault's target, a mark's label.
+     * Untyped because the actions are: constraining these would constrain the
+     * action vocabulary above by the back door.
+     */
+    parameters: {
+        [key: string]: string;
+    };
+    /**
+     * Human-readable note for a timeline. Never parsed: anything a consumer must
+     * act on belongs in action or parameters.
+     */
+    note: string;
+}
+export interface ScenarioEvent_ParametersEntry {
+    $type: "keelson.ScenarioEvent.ParametersEntry";
+    key: string;
+    value: string;
+}
+export declare const ScenarioEvent: MessageFns<ScenarioEvent, "keelson.ScenarioEvent">;
+export declare const ScenarioEvent_ParametersEntry: MessageFns<ScenarioEvent_ParametersEntry, "keelson.ScenarioEvent.ParametersEntry">;
+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 {};