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

package/dist/payloads/EnvelopeExceedance.d.ts

@@ -0,0 +1,216 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { EnvelopeBound, RouteRef } from "./Route";
+/**
+ * The record that an operational envelope limit was breached, that the system
+ * noticed, and what it did about it.
+ *
+ * Companion to `RouteExecution.envelope_limits`, and deliberately separate from
+ * it. That one is the live standing — "are we outside the envelope now" — and
+ * is an ephemeral 1 Hz snapshot that storage_manager does not persist. This is
+ * the durable half: the audit record a readiness assessment is written from.
+ *
+ * The three timestamps are the reason this message exists. Constraint
+ * monitoring latency is two distinct questions:
+ *
+ *     detected_at  - crossed_at   how long before the system noticed
+ *     responded_at - detected_at  how long before it acted
+ *
+ * A system can notice instantly and act slowly, or run a slow detector into a
+ * fast reaction. One timestamp cannot tell those apart, and neither can a
+ * boolean sampled at 1 Hz.
+ *
+ * Not folded into `Alarm`: an alarm is an operator notification, and a limit
+ * crossed and handled autonomously raises none — which is exactly the case an
+ * assessment most wants evidence of. Tying the record to the alarm path would
+ * lose it.
+ *
+ * -- KEY LAYOUT --------------------------------------------------------------
+ *
+ *   {base_path}/@v0/{entity_id}/pubsub/envelope_exceedance/{voyage_id}/{exceedance_id}
+ *
+ * Voyage first because that is what an assessment correlates by: one wildcard
+ * read returns every breach of one sailing. Both tokens are single by
+ * construction, so a `.../envelope_exceedance/* /*` storage covers them; a
+ * composite id in either position publishes without error and never persists.
+ *
+ * There is no separate `state/` key tree — durability is a router
+ * `storage_manager` responsibility, not a payload or key-space one, exactly as
+ * protocol-specification.md section 6.3 states for the route family.
+ *
+ * -- EMISSION MODEL ----------------------------------------------------------
+ *
+ * One record per state change, and AT LEAST TWO per breach: one when it is
+ * detected, one when it clears. A response applied or escalated part-way
+ * through is a state change and emits one of its own.
+ *
+ * EVERY RECORD IS A FULL RESTATEMENT. `crossed_at`, `detected_at`,
+ * `limit_value`, `measured_value`, `responses`, `responded_at` and everything
+ * identifying the breach are repeated on every subsequent record carrying the
+ * same `exceedance_id`.
+ *
+ * That rule is what makes the key safe. The store keeps the last value per key,
+ * so a closing record that omitted the opening one's fields would silently
+ * destroy the latency evidence this message exists to carry — the one thing no
+ * consumer could reconstruct. Restating instead means the key always holds the
+ * most COMPLETE record rather than merely the most recent, and a late joiner
+ * reading the storage gets the whole breach in one value.
+ */
+export interface EnvelopeExceedance {
+    $type: "keelson.EnvelopeExceedance";
+    /**
+     * When this record was emitted. Distinct from every timestamp below, which
+     * describe the breach rather than the reporting of it.
+     */
+    timestamp: Date | undefined;
+    /**
+     * Unique breach identifier (UUID). Also the trailing key segment, and stable
+     * across every record of the same breach, so a consumer pairs the opening and
+     * closing records without matching on limit and time.
+     */
+    exceedanceId: string;
+    /**
+     * The RouteInfo field the limit came from, e.g. "max_wind_gust_mps".
+     *
+     * A STRING ON PURPOSE, not an enum. We do not yet know whether limits are
+     * named by RouteInfo field, by a context-scoped id, or by something a
+     * capability declaration defines — that is the open question in #226. An enum
+     * frozen before it settles would have to be reserved and replaced; a
+     * documented naming convention costs nothing to change. Revisit when #226
+     * decides what an operational envelope is.
+     */
+    limitId: string;
+    /**
+     * The voyage this breach happened on, and the leading key segment.
+     *
+     * NOT optional, and not derivable from `route_ref`: a RouteRef identifies the
+     * plan edition, not the sailing. The same route sailed twice produces records
+     * that can only be attributed to a voyage by guessing at time windows, and
+     * voyage is the primary correlation key an assessment reads by.
+     *
+     * A producer with no voyage has nothing to key on, so it has no business
+     * publishing this subject — an empty value yields an unaddressable key.
+     */
+    voyageId: string;
+    /**
+     * The route edition the limit was read from. An edition rather than a bare
+     * route_id because a route bumped mid-voyage may carry different limits, and
+     * a breach is only interpretable against the ones actually in force.
+     */
+    routeRef?: RouteRef | undefined;
+    /**
+     * The leg being sailed, named by the waypoint it leaves — the same stable-id
+     * convention RouteExecution uses. Never an index: an index means a different
+     * leg the moment a waypoint is inserted.
+     */
+    legFromWaypointId?: string | undefined;
+    /**
+     * Identifies the limit set in force when this breach was judged, so a
+     * recorded message can be replayed against the rules that were actually
+     * applied — the same provenance pair OperationalAuthority carries as
+     * `policy_id` / `policy_config_digest`, for the same reason.
+     *
+     * This matters more here than it looks. If the envelope turns out to vary
+     * with context (#226), a recorded 8 m/s breach cannot distinguish the right
+     * limit correctly applied from a stale one wrongly applied — and the second
+     * is a monitoring failure this record exists to catch. Without the digest the
+     * record can only be replayed against whatever the envelope says TODAY.
+     */
+    envelopeId?: string | undefined;
+    envelopeConfigDigest?: Uint8Array | undefined;
+    /**
+     * When the measurement actually crossed the limit. `optional` because a
+     * producer sampling at an interval knows when it *saw* the crossing, not
+     * when it happened; publishing an interpolated guess as a measured instant
+     * would corrupt the latency figure this message exists to support.
+     */
+    crossedAt?: Date | undefined;
+    /** When the system determined the limit was breached. */
+    detectedAt: Date | undefined;
+    /** The limit, and the measurement that breached it. */
+    limitValue: number;
+    /**
+     * The value AT DETECTION — the reading the verdict was actually taken on, at
+     * the instant `detected_at` names.
+     *
+     * Deliberately not the value at crossing: `crossed_at` is optional precisely
+     * because a producer sampling at an interval often cannot know the crossing
+     * instant, and a value it cannot time is not evidence. This one is always
+     * timed, by the timestamp beside it.
+     */
+    measuredValue: number;
+    /**
+     * Which side of `limit_value` counts as a breach. Without it `peak_value`
+     * below has no meaning — see EnvelopeBound in Route.proto.
+     */
+    bound: EnvelopeBound;
+    /**
+     * The most extreme value reached before the breach cleared: the HIGHEST under
+     * ENVELOPE_BOUND_UPPER, the LOWEST under ENVELOPE_BOUND_LOWER. Set on the
+     * closing record; a breach that peaked far past the limit is a different
+     * finding from one that grazed it.
+     */
+    peakValue?: number | undefined;
+    /**
+     * Everything done in response, not just the first or the most severe. Real
+     * reactions compound — a breach can be alerted AND speed-limited — and a
+     * scalar would have forced a producer to pick one and discard the rest, in
+     * the one message written to be read back as evidence.
+     *
+     * RESPONSE_NONE is a MEMBER of this list, never an empty list. Deciding not
+     * to act is a finding; an empty `responses` is a producer that never filled
+     * the field in, and an assessment must be able to tell those apart.
+     */
+    responses: EnvelopeExceedance_Response[];
+    /**
+     * When the response was applied. Absent while none has been. On a compound
+     * response this is when the FIRST of them was applied — it is the endpoint of
+     * the reaction-latency measurement, and reaction latency is measured to the
+     * moment something happened.
+     */
+    respondedAt?: Date | undefined;
+    /**
+     * When the measurement returned inside the limit. Absent while the breach is
+     * still open, so an open exceedance is distinguishable from one whose closing
+     * record was lost — without a consumer having to invent a timeout.
+     */
+    clearedAt?: Date | undefined;
+}
+export declare enum EnvelopeExceedance_Response {
+    RESPONSE_UNSPECIFIED = 0,
+    /**
+     * RESPONSE_NONE - Observed, and no action taken. A value rather than an absence on
+     * purpose: "we saw it and chose not to act" is a finding, and must not be
+     * indistinguishable from a producer that never filled the field in.
+     */
+    RESPONSE_NONE = 1,
+    /** RESPONSE_ALERTED - operator notified */
+    RESPONSE_ALERTED = 2,
+    RESPONSE_SPEED_LIMIT = 3,
+    RESPONSE_REROUTE = 4,
+    RESPONSE_HOLD = 5,
+    RESPONSE_ABORT = 6,
+    UNRECOGNIZED = -1
+}
+export declare function envelopeExceedance_ResponseFromJSON(object: any): EnvelopeExceedance_Response;
+export declare function envelopeExceedance_ResponseToJSON(object: EnvelopeExceedance_Response): string;
+export declare const EnvelopeExceedance: MessageFns<EnvelopeExceedance, "keelson.EnvelopeExceedance">;
+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/EnvelopeExceedance.js

@@ -0,0 +1,461 @@
+"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: EnvelopeExceedance.proto
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvelopeExceedance = exports.envelopeExceedance_ResponseToJSON = exports.envelopeExceedance_ResponseFromJSON = exports.EnvelopeExceedance_Response = 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 EnvelopeExceedance_Response;
+(function (EnvelopeExceedance_Response) {
+    EnvelopeExceedance_Response[EnvelopeExceedance_Response["RESPONSE_UNSPECIFIED"] = 0] = "RESPONSE_UNSPECIFIED";
+    /**
+     * RESPONSE_NONE - Observed, and no action taken. A value rather than an absence on
+     * purpose: "we saw it and chose not to act" is a finding, and must not be
+     * indistinguishable from a producer that never filled the field in.
+     */
+    EnvelopeExceedance_Response[EnvelopeExceedance_Response["RESPONSE_NONE"] = 1] = "RESPONSE_NONE";
+    /** RESPONSE_ALERTED - operator notified */
+    EnvelopeExceedance_Response[EnvelopeExceedance_Response["RESPONSE_ALERTED"] = 2] = "RESPONSE_ALERTED";
+    EnvelopeExceedance_Response[EnvelopeExceedance_Response["RESPONSE_SPEED_LIMIT"] = 3] = "RESPONSE_SPEED_LIMIT";
+    EnvelopeExceedance_Response[EnvelopeExceedance_Response["RESPONSE_REROUTE"] = 4] = "RESPONSE_REROUTE";
+    EnvelopeExceedance_Response[EnvelopeExceedance_Response["RESPONSE_HOLD"] = 5] = "RESPONSE_HOLD";
+    EnvelopeExceedance_Response[EnvelopeExceedance_Response["RESPONSE_ABORT"] = 6] = "RESPONSE_ABORT";
+    EnvelopeExceedance_Response[EnvelopeExceedance_Response["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(EnvelopeExceedance_Response || (exports.EnvelopeExceedance_Response = EnvelopeExceedance_Response = {}));
+function envelopeExceedance_ResponseFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "RESPONSE_UNSPECIFIED":
+            return EnvelopeExceedance_Response.RESPONSE_UNSPECIFIED;
+        case 1:
+        case "RESPONSE_NONE":
+            return EnvelopeExceedance_Response.RESPONSE_NONE;
+        case 2:
+        case "RESPONSE_ALERTED":
+            return EnvelopeExceedance_Response.RESPONSE_ALERTED;
+        case 3:
+        case "RESPONSE_SPEED_LIMIT":
+            return EnvelopeExceedance_Response.RESPONSE_SPEED_LIMIT;
+        case 4:
+        case "RESPONSE_REROUTE":
+            return EnvelopeExceedance_Response.RESPONSE_REROUTE;
+        case 5:
+        case "RESPONSE_HOLD":
+            return EnvelopeExceedance_Response.RESPONSE_HOLD;
+        case 6:
+        case "RESPONSE_ABORT":
+            return EnvelopeExceedance_Response.RESPONSE_ABORT;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return EnvelopeExceedance_Response.UNRECOGNIZED;
+    }
+}
+exports.envelopeExceedance_ResponseFromJSON = envelopeExceedance_ResponseFromJSON;
+function envelopeExceedance_ResponseToJSON(object) {
+    switch (object) {
+        case EnvelopeExceedance_Response.RESPONSE_UNSPECIFIED:
+            return "RESPONSE_UNSPECIFIED";
+        case EnvelopeExceedance_Response.RESPONSE_NONE:
+            return "RESPONSE_NONE";
+        case EnvelopeExceedance_Response.RESPONSE_ALERTED:
+            return "RESPONSE_ALERTED";
+        case EnvelopeExceedance_Response.RESPONSE_SPEED_LIMIT:
+            return "RESPONSE_SPEED_LIMIT";
+        case EnvelopeExceedance_Response.RESPONSE_REROUTE:
+            return "RESPONSE_REROUTE";
+        case EnvelopeExceedance_Response.RESPONSE_HOLD:
+            return "RESPONSE_HOLD";
+        case EnvelopeExceedance_Response.RESPONSE_ABORT:
+            return "RESPONSE_ABORT";
+        case EnvelopeExceedance_Response.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+exports.envelopeExceedance_ResponseToJSON = envelopeExceedance_ResponseToJSON;
+function createBaseEnvelopeExceedance() {
+    return {
+        $type: "keelson.EnvelopeExceedance",
+        timestamp: undefined,
+        exceedanceId: "",
+        limitId: "",
+        voyageId: "",
+        routeRef: undefined,
+        legFromWaypointId: undefined,
+        envelopeId: undefined,
+        envelopeConfigDigest: undefined,
+        crossedAt: undefined,
+        detectedAt: undefined,
+        limitValue: 0,
+        measuredValue: 0,
+        bound: 0,
+        peakValue: undefined,
+        responses: [],
+        respondedAt: undefined,
+        clearedAt: undefined,
+    };
+}
+exports.EnvelopeExceedance = {
+    $type: "keelson.EnvelopeExceedance",
+    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.exceedanceId !== "") {
+            writer.uint32(18).string(message.exceedanceId);
+        }
+        if (message.limitId !== "") {
+            writer.uint32(26).string(message.limitId);
+        }
+        if (message.voyageId !== "") {
+            writer.uint32(114).string(message.voyageId);
+        }
+        if (message.routeRef !== undefined) {
+            Route_1.RouteRef.encode(message.routeRef, writer.uint32(34).fork()).join();
+        }
+        if (message.legFromWaypointId !== undefined) {
+            writer.uint32(42).string(message.legFromWaypointId);
+        }
+        if (message.envelopeId !== undefined) {
+            writer.uint32(122).string(message.envelopeId);
+        }
+        if (message.envelopeConfigDigest !== undefined) {
+            writer.uint32(130).bytes(message.envelopeConfigDigest);
+        }
+        if (message.crossedAt !== undefined) {
+            timestamp_1.Timestamp.encode(toTimestamp(message.crossedAt), writer.uint32(50).fork()).join();
+        }
+        if (message.detectedAt !== undefined) {
+            timestamp_1.Timestamp.encode(toTimestamp(message.detectedAt), writer.uint32(58).fork()).join();
+        }
+        if (message.limitValue !== 0) {
+            writer.uint32(69).float(message.limitValue);
+        }
+        if (message.measuredValue !== 0) {
+            writer.uint32(77).float(message.measuredValue);
+        }
+        if (message.bound !== 0) {
+            writer.uint32(136).int32(message.bound);
+        }
+        if (message.peakValue !== undefined) {
+            writer.uint32(85).float(message.peakValue);
+        }
+        writer.uint32(90).fork();
+        for (const v of message.responses) {
+            writer.int32(v);
+        }
+        writer.join();
+        if (message.respondedAt !== undefined) {
+            timestamp_1.Timestamp.encode(toTimestamp(message.respondedAt), writer.uint32(98).fork()).join();
+        }
+        if (message.clearedAt !== undefined) {
+            timestamp_1.Timestamp.encode(toTimestamp(message.clearedAt), writer.uint32(106).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseEnvelopeExceedance();
+        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 !== 18) {
+                        break;
+                    }
+                    message.exceedanceId = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.limitId = reader.string();
+                    continue;
+                }
+                case 14: {
+                    if (tag !== 114) {
+                        break;
+                    }
+                    message.voyageId = reader.string();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.routeRef = Route_1.RouteRef.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.legFromWaypointId = reader.string();
+                    continue;
+                }
+                case 15: {
+                    if (tag !== 122) {
+                        break;
+                    }
+                    message.envelopeId = reader.string();
+                    continue;
+                }
+                case 16: {
+                    if (tag !== 130) {
+                        break;
+                    }
+                    message.envelopeConfigDigest = reader.bytes();
+                    continue;
+                }
+                case 6: {
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.crossedAt = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 7: {
+                    if (tag !== 58) {
+                        break;
+                    }
+                    message.detectedAt = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 8: {
+                    if (tag !== 69) {
+                        break;
+                    }
+                    message.limitValue = reader.float();
+                    continue;
+                }
+                case 9: {
+                    if (tag !== 77) {
+                        break;
+                    }
+                    message.measuredValue = reader.float();
+                    continue;
+                }
+                case 17: {
+                    if (tag !== 136) {
+                        break;
+                    }
+                    message.bound = reader.int32();
+                    continue;
+                }
+                case 10: {
+                    if (tag !== 85) {
+                        break;
+                    }
+                    message.peakValue = reader.float();
+                    continue;
+                }
+                case 11: {
+                    if (tag === 88) {
+                        message.responses.push(reader.int32());
+                        continue;
+                    }
+                    if (tag === 90) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.responses.push(reader.int32());
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                case 12: {
+                    if (tag !== 98) {
+                        break;
+                    }
+                    message.respondedAt = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 13: {
+                    if (tag !== 106) {
+                        break;
+                    }
+                    message.clearedAt = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            $type: exports.EnvelopeExceedance.$type,
+            timestamp: isSet(object.timestamp) ? fromJsonTimestamp(object.timestamp) : undefined,
+            exceedanceId: isSet(object.exceedanceId) ? globalThis.String(object.exceedanceId) : "",
+            limitId: isSet(object.limitId) ? globalThis.String(object.limitId) : "",
+            voyageId: isSet(object.voyageId) ? globalThis.String(object.voyageId) : "",
+            routeRef: isSet(object.routeRef) ? Route_1.RouteRef.fromJSON(object.routeRef) : undefined,
+            legFromWaypointId: isSet(object.legFromWaypointId) ? globalThis.String(object.legFromWaypointId) : undefined,
+            envelopeId: isSet(object.envelopeId) ? globalThis.String(object.envelopeId) : undefined,
+            envelopeConfigDigest: isSet(object.envelopeConfigDigest)
+                ? bytesFromBase64(object.envelopeConfigDigest)
+                : undefined,
+            crossedAt: isSet(object.crossedAt) ? fromJsonTimestamp(object.crossedAt) : undefined,
+            detectedAt: isSet(object.detectedAt) ? fromJsonTimestamp(object.detectedAt) : undefined,
+            limitValue: isSet(object.limitValue) ? globalThis.Number(object.limitValue) : 0,
+            measuredValue: isSet(object.measuredValue) ? globalThis.Number(object.measuredValue) : 0,
+            bound: isSet(object.bound) ? (0, Route_1.envelopeBoundFromJSON)(object.bound) : 0,
+            peakValue: isSet(object.peakValue) ? globalThis.Number(object.peakValue) : undefined,
+            responses: globalThis.Array.isArray(object?.responses)
+                ? object.responses.map((e) => envelopeExceedance_ResponseFromJSON(e))
+                : [],
+            respondedAt: isSet(object.respondedAt) ? fromJsonTimestamp(object.respondedAt) : undefined,
+            clearedAt: isSet(object.clearedAt) ? fromJsonTimestamp(object.clearedAt) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.timestamp !== undefined) {
+            obj.timestamp = message.timestamp.toISOString();
+        }
+        if (message.exceedanceId !== "") {
+            obj.exceedanceId = message.exceedanceId;
+        }
+        if (message.limitId !== "") {
+            obj.limitId = message.limitId;
+        }
+        if (message.voyageId !== "") {
+            obj.voyageId = message.voyageId;
+        }
+        if (message.routeRef !== undefined) {
+            obj.routeRef = Route_1.RouteRef.toJSON(message.routeRef);
+        }
+        if (message.legFromWaypointId !== undefined) {
+            obj.legFromWaypointId = message.legFromWaypointId;
+        }
+        if (message.envelopeId !== undefined) {
+            obj.envelopeId = message.envelopeId;
+        }
+        if (message.envelopeConfigDigest !== undefined) {
+            obj.envelopeConfigDigest = base64FromBytes(message.envelopeConfigDigest);
+        }
+        if (message.crossedAt !== undefined) {
+            obj.crossedAt = message.crossedAt.toISOString();
+        }
+        if (message.detectedAt !== undefined) {
+            obj.detectedAt = message.detectedAt.toISOString();
+        }
+        if (message.limitValue !== 0) {
+            obj.limitValue = message.limitValue;
+        }
+        if (message.measuredValue !== 0) {
+            obj.measuredValue = message.measuredValue;
+        }
+        if (message.bound !== 0) {
+            obj.bound = (0, Route_1.envelopeBoundToJSON)(message.bound);
+        }
+        if (message.peakValue !== undefined) {
+            obj.peakValue = message.peakValue;
+        }
+        if (message.responses?.length) {
+            obj.responses = message.responses.map((e) => envelopeExceedance_ResponseToJSON(e));
+        }
+        if (message.respondedAt !== undefined) {
+            obj.respondedAt = message.respondedAt.toISOString();
+        }
+        if (message.clearedAt !== undefined) {
+            obj.clearedAt = message.clearedAt.toISOString();
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.EnvelopeExceedance.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseEnvelopeExceedance();
+        message.timestamp = object.timestamp ?? undefined;
+        message.exceedanceId = object.exceedanceId ?? "";
+        message.limitId = object.limitId ?? "";
+        message.voyageId = object.voyageId ?? "";
+        message.routeRef = (object.routeRef !== undefined && object.routeRef !== null)
+            ? Route_1.RouteRef.fromPartial(object.routeRef)
+            : undefined;
+        message.legFromWaypointId = object.legFromWaypointId ?? undefined;
+        message.envelopeId = object.envelopeId ?? undefined;
+        message.envelopeConfigDigest = object.envelopeConfigDigest ?? undefined;
+        message.crossedAt = object.crossedAt ?? undefined;
+        message.detectedAt = object.detectedAt ?? undefined;
+        message.limitValue = object.limitValue ?? 0;
+        message.measuredValue = object.measuredValue ?? 0;
+        message.bound = object.bound ?? 0;
+        message.peakValue = object.peakValue ?? undefined;
+        message.responses = object.responses?.map((e) => e) || [];
+        message.respondedAt = object.respondedAt ?? undefined;
+        message.clearedAt = object.clearedAt ?? undefined;
+        return message;
+    },
+};
+typeRegistry_1.messageTypeRegistry.set(exports.EnvelopeExceedance.$type, exports.EnvelopeExceedance);
+function bytesFromBase64(b64) {
+    if (globalThis.Buffer) {
+        return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
+    }
+    else {
+        const bin = globalThis.atob(b64);
+        const arr = new Uint8Array(bin.length);
+        for (let i = 0; i < bin.length; ++i) {
+            arr[i] = bin.charCodeAt(i);
+        }
+        return arr;
+    }
+}
+function base64FromBytes(arr) {
+    if (globalThis.Buffer) {
+        return globalThis.Buffer.from(arr).toString("base64");
+    }
+    else {
+        const bin = [];
+        arr.forEach((byte) => {
+            bin.push(globalThis.String.fromCharCode(byte));
+        });
+        return globalThis.btoa(bin.join(""));
+    }
+}
+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;
+}