@rise-maritime/keelson-js 0.5.3 → 0.6.0-alpha.202.dev.1

package/dist/payloads/RouteExecution.js

@@ -0,0 +1,310 @@
+"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: RouteExecution.proto
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouteExecution = 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");
+function createBaseRouteExecution() {
+    return {
+        $type: "keelson.RouteExecution",
+        timestamp: undefined,
+        voyageId: "",
+        routeRef: undefined,
+        currentLegFromWaypointId: undefined,
+        nextWaypointId: undefined,
+        distanceToNextWaypointM: 0,
+        xtdM: 0,
+        bearingToNextDeg: 0,
+        etaNextWaypoint: undefined,
+        etaArrival: undefined,
+        deviationActive: false,
+        deviationThresholdM: 0,
+        speedOverGroundKnots: 0,
+        courseOverGroundDeg: 0,
+    };
+}
+exports.RouteExecution = {
+    $type: "keelson.RouteExecution",
+    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.voyageId !== "") {
+            writer.uint32(18).string(message.voyageId);
+        }
+        if (message.routeRef !== undefined) {
+            Route_1.RouteRef.encode(message.routeRef, writer.uint32(42).fork()).join();
+        }
+        if (message.currentLegFromWaypointId !== undefined) {
+            writer.uint32(122).string(message.currentLegFromWaypointId);
+        }
+        if (message.nextWaypointId !== undefined) {
+            writer.uint32(130).string(message.nextWaypointId);
+        }
+        if (message.distanceToNextWaypointM !== 0) {
+            writer.uint32(101).float(message.distanceToNextWaypointM);
+        }
+        if (message.xtdM !== 0) {
+            writer.uint32(109).float(message.xtdM);
+        }
+        if (message.bearingToNextDeg !== 0) {
+            writer.uint32(117).float(message.bearingToNextDeg);
+        }
+        if (message.etaNextWaypoint !== undefined) {
+            timestamp_1.Timestamp.encode(toTimestamp(message.etaNextWaypoint), writer.uint32(162).fork()).join();
+        }
+        if (message.etaArrival !== undefined) {
+            timestamp_1.Timestamp.encode(toTimestamp(message.etaArrival), writer.uint32(170).fork()).join();
+        }
+        if (message.deviationActive !== false) {
+            writer.uint32(240).bool(message.deviationActive);
+        }
+        if (message.deviationThresholdM !== 0) {
+            writer.uint32(253).float(message.deviationThresholdM);
+        }
+        if (message.speedOverGroundKnots !== 0) {
+            writer.uint32(325).float(message.speedOverGroundKnots);
+        }
+        if (message.courseOverGroundDeg !== 0) {
+            writer.uint32(333).float(message.courseOverGroundDeg);
+        }
+        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 = createBaseRouteExecution();
+        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.voyageId = reader.string();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.routeRef = Route_1.RouteRef.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 15: {
+                    if (tag !== 122) {
+                        break;
+                    }
+                    message.currentLegFromWaypointId = reader.string();
+                    continue;
+                }
+                case 16: {
+                    if (tag !== 130) {
+                        break;
+                    }
+                    message.nextWaypointId = reader.string();
+                    continue;
+                }
+                case 12: {
+                    if (tag !== 101) {
+                        break;
+                    }
+                    message.distanceToNextWaypointM = reader.float();
+                    continue;
+                }
+                case 13: {
+                    if (tag !== 109) {
+                        break;
+                    }
+                    message.xtdM = reader.float();
+                    continue;
+                }
+                case 14: {
+                    if (tag !== 117) {
+                        break;
+                    }
+                    message.bearingToNextDeg = reader.float();
+                    continue;
+                }
+                case 20: {
+                    if (tag !== 162) {
+                        break;
+                    }
+                    message.etaNextWaypoint = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 21: {
+                    if (tag !== 170) {
+                        break;
+                    }
+                    message.etaArrival = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 30: {
+                    if (tag !== 240) {
+                        break;
+                    }
+                    message.deviationActive = reader.bool();
+                    continue;
+                }
+                case 31: {
+                    if (tag !== 253) {
+                        break;
+                    }
+                    message.deviationThresholdM = reader.float();
+                    continue;
+                }
+                case 40: {
+                    if (tag !== 325) {
+                        break;
+                    }
+                    message.speedOverGroundKnots = reader.float();
+                    continue;
+                }
+                case 41: {
+                    if (tag !== 333) {
+                        break;
+                    }
+                    message.courseOverGroundDeg = reader.float();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            $type: exports.RouteExecution.$type,
+            timestamp: isSet(object.timestamp) ? fromJsonTimestamp(object.timestamp) : undefined,
+            voyageId: isSet(object.voyageId) ? globalThis.String(object.voyageId) : "",
+            routeRef: isSet(object.routeRef) ? Route_1.RouteRef.fromJSON(object.routeRef) : undefined,
+            currentLegFromWaypointId: isSet(object.currentLegFromWaypointId)
+                ? globalThis.String(object.currentLegFromWaypointId)
+                : undefined,
+            nextWaypointId: isSet(object.nextWaypointId) ? globalThis.String(object.nextWaypointId) : undefined,
+            distanceToNextWaypointM: isSet(object.distanceToNextWaypointM)
+                ? globalThis.Number(object.distanceToNextWaypointM)
+                : 0,
+            xtdM: isSet(object.xtdM) ? globalThis.Number(object.xtdM) : 0,
+            bearingToNextDeg: isSet(object.bearingToNextDeg) ? globalThis.Number(object.bearingToNextDeg) : 0,
+            etaNextWaypoint: isSet(object.etaNextWaypoint) ? fromJsonTimestamp(object.etaNextWaypoint) : undefined,
+            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,
+            speedOverGroundKnots: isSet(object.speedOverGroundKnots) ? globalThis.Number(object.speedOverGroundKnots) : 0,
+            courseOverGroundDeg: isSet(object.courseOverGroundDeg) ? globalThis.Number(object.courseOverGroundDeg) : 0,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.timestamp !== undefined) {
+            obj.timestamp = message.timestamp.toISOString();
+        }
+        if (message.voyageId !== "") {
+            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.nextWaypointId !== undefined) {
+            obj.nextWaypointId = message.nextWaypointId;
+        }
+        if (message.distanceToNextWaypointM !== 0) {
+            obj.distanceToNextWaypointM = message.distanceToNextWaypointM;
+        }
+        if (message.xtdM !== 0) {
+            obj.xtdM = message.xtdM;
+        }
+        if (message.bearingToNextDeg !== 0) {
+            obj.bearingToNextDeg = message.bearingToNextDeg;
+        }
+        if (message.etaNextWaypoint !== undefined) {
+            obj.etaNextWaypoint = message.etaNextWaypoint.toISOString();
+        }
+        if (message.etaArrival !== undefined) {
+            obj.etaArrival = message.etaArrival.toISOString();
+        }
+        if (message.deviationActive !== false) {
+            obj.deviationActive = message.deviationActive;
+        }
+        if (message.deviationThresholdM !== 0) {
+            obj.deviationThresholdM = message.deviationThresholdM;
+        }
+        if (message.speedOverGroundKnots !== 0) {
+            obj.speedOverGroundKnots = message.speedOverGroundKnots;
+        }
+        if (message.courseOverGroundDeg !== 0) {
+            obj.courseOverGroundDeg = message.courseOverGroundDeg;
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.RouteExecution.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseRouteExecution();
+        message.timestamp = object.timestamp ?? undefined;
+        message.voyageId = object.voyageId ?? "";
+        message.routeRef = (object.routeRef !== undefined && object.routeRef !== null)
+            ? Route_1.RouteRef.fromPartial(object.routeRef)
+            : undefined;
+        message.currentLegFromWaypointId = object.currentLegFromWaypointId ?? undefined;
+        message.nextWaypointId = object.nextWaypointId ?? undefined;
+        message.distanceToNextWaypointM = object.distanceToNextWaypointM ?? 0;
+        message.xtdM = object.xtdM ?? 0;
+        message.bearingToNextDeg = object.bearingToNextDeg ?? 0;
+        message.etaNextWaypoint = object.etaNextWaypoint ?? undefined;
+        message.etaArrival = object.etaArrival ?? undefined;
+        message.deviationActive = object.deviationActive ?? false;
+        message.deviationThresholdM = object.deviationThresholdM ?? 0;
+        message.speedOverGroundKnots = object.speedOverGroundKnots ?? 0;
+        message.courseOverGroundDeg = object.courseOverGroundDeg ?? 0;
+        return message;
+    },
+};
+typeRegistry_1.messageTypeRegistry.set(exports.RouteExecution.$type, exports.RouteExecution);
+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/ScenarioStatus.d.ts

@@ -0,0 +1,160 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { Duration } from "./google/protobuf/duration";
+export interface ScenarioParticipant {
+    $type: "keelson.ScenarioParticipant";
+    entityId: string;
+    sourceId: string;
+    role: ScenarioParticipant_Role;
+    /**
+     * Last tick this participant acknowledged. For a BLOCKING participant
+     * this is what the clock is waiting on; for the others it is a lag
+     * indicator rather than a barrier.
+     */
+    acknowledgedTick: number;
+    /**
+     * False once the authority considers the participant late, wedged, or
+     * gone. The scenario decides the threshold; this field only reports it.
+     */
+    healthy: boolean;
+}
+/**
+ * How this participant relates to the clock. A fixed-step run is only
+ * reproducible if it is explicit about who may hold it up.
+ */
+export declare enum ScenarioParticipant_Role {
+    ROLE_UNKNOWN = 0,
+    /** OBSERVING - Never holds the clock. UIs, recorders in real-time mode. */
+    OBSERVING = 1,
+    /**
+     * BLOCKING - The clock waits for this participant to acknowledge each tick.
+     * Dynamics and any sensor whose output must exist for every tick.
+     */
+    BLOCKING = 2,
+    /**
+     * DECIMATING - May skip work to keep up, and says so, but never stalls the clock.
+     * Render-derived sensors in real-time mode.
+     */
+    DECIMATING = 3,
+    UNRECOGNIZED = -1
+}
+export declare function scenarioParticipant_RoleFromJSON(object: any): ScenarioParticipant_Role;
+export declare function scenarioParticipant_RoleToJSON(object: ScenarioParticipant_Role): string;
+export interface ScenarioStatus {
+    $type: "keelson.ScenarioStatus";
+    /**
+     * Source timestamp: when this status was produced, in wall-clock time.
+     * simulation_time below is the *simulated* clock and the two diverge by
+     * design in every mode except real time.
+     */
+    timestamp: Date | undefined;
+    state: ScenarioStatus_State;
+    mode: ScenarioStatus_Mode;
+    /**
+     * Identity of the loaded scenario, and of this particular run of it.
+     * scenario_hash pins the exact content: two runs quoting the same
+     * scenario_id and different hashes did not run the same scenario, and
+     * no amount of matching seeds makes their results comparable.
+     */
+    scenarioId: string;
+    scenarioHash: string;
+    runId: string;
+    /**
+     * Fixed-step clock. tick counts steps from 0; step_size is the interval
+     * each tick represents; simulation_time is the absolute simulated time
+     * of the current tick.
+     */
+    tick: number;
+    stepSize: Duration | undefined;
+    simulationTime: Date | undefined;
+    /**
+     * Seed the run was started with. Carried here so a recording is
+     * self-describing — a reproduction attempt should never have to guess.
+     */
+    seed: number;
+    /**
+     * Wall-clock scaling requested via set_rate, and what the authority is
+     * actually achieving. They differ when the simulation cannot keep up;
+     * that difference is the honest signal, and a run whose measured_rate
+     * has drifted from its commanded_rate has not been running at the rate
+     * its results claim.
+     */
+    commandedRate: number;
+    measuredRate: number;
+    /**
+     * How far behind the wall-clock schedule the clock is running.
+     * Meaningful in REAL_TIME; zero elsewhere by definition.
+     */
+    lag: Duration | undefined;
+    /**
+     * Everything participating in this run, with its relationship to the
+     * clock. Empty is legal — a single-process simulator has no barrier to
+     * report — but a run that lists no BLOCKING participant while claiming
+     * STEPPED mode is misreporting.
+     */
+    participants: ScenarioParticipant[];
+    /**
+     * Where this run was branched from, if it was restored from a checkpoint
+     * (scenario_checkpoint/v1). Empty parent_run_id means this run started at
+     * tick 0 in the ordinary way; parent_tick is meaningful only when
+     * parent_run_id is set.
+     *
+     * Without these a restored run is indistinguishable on the bus from a
+     * fresh one, and the branch point — the thing that explains why a run's
+     * recording starts mid-exercise — exists only in the responder's log.
+     */
+    parentRunId: string;
+    parentTick: number;
+}
+export declare enum ScenarioStatus_State {
+    UNKNOWN = 0,
+    NO_SCENARIO = 1,
+    LOADING = 2,
+    STOPPED = 3,
+    RUNNING = 4,
+    PAUSED = 5,
+    /**
+     * FINISHED - The scenario reached its declared end. Distinct from STOPPED, which
+     * is an operator decision — an evaluator needs to tell "it finished"
+     * from "someone halted it".
+     */
+    FINISHED = 6,
+    UNRECOGNIZED = -1
+}
+export declare function scenarioStatus_StateFromJSON(object: any): ScenarioStatus_State;
+export declare function scenarioStatus_StateToJSON(object: ScenarioStatus_State): string;
+/**
+ * How the clock is currently being driven. Emergent rather than
+ * commanded: a rate of 0.0 is FAST_TIME, hand-driven steps are STEPPED.
+ */
+export declare enum ScenarioStatus_Mode {
+    MODE_UNKNOWN = 0,
+    REAL_TIME = 1,
+    STEPPED = 2,
+    FAST_TIME = 3,
+    REPLAY = 4,
+    UNRECOGNIZED = -1
+}
+export declare function scenarioStatus_ModeFromJSON(object: any): ScenarioStatus_Mode;
+export declare function scenarioStatus_ModeToJSON(object: ScenarioStatus_Mode): string;
+export declare const ScenarioParticipant: MessageFns<ScenarioParticipant, "keelson.ScenarioParticipant">;
+export declare const ScenarioStatus: MessageFns<ScenarioStatus, "keelson.ScenarioStatus">;
+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 {};