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

package/dist/payloads/Severity.js

@@ -8,16 +8,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.severityLevelToJSON = exports.severityLevelFromJSON = exports.SeverityLevel = void 0;
 /* eslint-disable */
 /**
- * Shared severity vocabulary for alerts and events across payloads
- * (weather, route, ...). Keep this the single source of truth so the bus
- * does not accumulate per-domain severity scales.
+ * Shared severity vocabulary for alarms, alerts and events across
+ * payloads (alarm, weather, route, ...). Keep this the single source of
+ * truth so the bus does not accumulate per-domain severity scales.
+ *
+ * Four levels, unified from the previously-parallel Alarm.Severity
+ * (LOW/MEDIUM/HIGH/CRITICAL) and the 3-level alert scale
+ * (INFO/WARNING/CRITICAL): informational maps to LOW, warning-grade
+ * maps to MEDIUM or HIGH per the emitter's judgement, CRITICAL stays
+ * CRITICAL.
  */
 var SeverityLevel;
 (function (SeverityLevel) {
     SeverityLevel[SeverityLevel["SEVERITY_LEVEL_UNSPECIFIED"] = 0] = "SEVERITY_LEVEL_UNSPECIFIED";
-    SeverityLevel[SeverityLevel["INFO"] = 1] = "INFO";
-    SeverityLevel[SeverityLevel["WARNING"] = 2] = "WARNING";
-    SeverityLevel[SeverityLevel["CRITICAL"] = 3] = "CRITICAL";
+    SeverityLevel[SeverityLevel["SEVERITY_LEVEL_LOW"] = 1] = "SEVERITY_LEVEL_LOW";
+    SeverityLevel[SeverityLevel["SEVERITY_LEVEL_MEDIUM"] = 2] = "SEVERITY_LEVEL_MEDIUM";
+    SeverityLevel[SeverityLevel["SEVERITY_LEVEL_HIGH"] = 3] = "SEVERITY_LEVEL_HIGH";
+    SeverityLevel[SeverityLevel["SEVERITY_LEVEL_CRITICAL"] = 4] = "SEVERITY_LEVEL_CRITICAL";
     SeverityLevel[SeverityLevel["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
 })(SeverityLevel || (exports.SeverityLevel = SeverityLevel = {}));
 function severityLevelFromJSON(object) {
@@ -26,14 +33,17 @@ function severityLevelFromJSON(object) {
         case "SEVERITY_LEVEL_UNSPECIFIED":
             return SeverityLevel.SEVERITY_LEVEL_UNSPECIFIED;
         case 1:
-        case "INFO":
-            return SeverityLevel.INFO;
+        case "SEVERITY_LEVEL_LOW":
+            return SeverityLevel.SEVERITY_LEVEL_LOW;
         case 2:
-        case "WARNING":
-            return SeverityLevel.WARNING;
+        case "SEVERITY_LEVEL_MEDIUM":
+            return SeverityLevel.SEVERITY_LEVEL_MEDIUM;
         case 3:
-        case "CRITICAL":
-            return SeverityLevel.CRITICAL;
+        case "SEVERITY_LEVEL_HIGH":
+            return SeverityLevel.SEVERITY_LEVEL_HIGH;
+        case 4:
+        case "SEVERITY_LEVEL_CRITICAL":
+            return SeverityLevel.SEVERITY_LEVEL_CRITICAL;
         case -1:
         case "UNRECOGNIZED":
         default:
@@ -45,12 +55,14 @@ function severityLevelToJSON(object) {
     switch (object) {
         case SeverityLevel.SEVERITY_LEVEL_UNSPECIFIED:
             return "SEVERITY_LEVEL_UNSPECIFIED";
-        case SeverityLevel.INFO:
-            return "INFO";
-        case SeverityLevel.WARNING:
-            return "WARNING";
-        case SeverityLevel.CRITICAL:
-            return "CRITICAL";
+        case SeverityLevel.SEVERITY_LEVEL_LOW:
+            return "SEVERITY_LEVEL_LOW";
+        case SeverityLevel.SEVERITY_LEVEL_MEDIUM:
+            return "SEVERITY_LEVEL_MEDIUM";
+        case SeverityLevel.SEVERITY_LEVEL_HIGH:
+            return "SEVERITY_LEVEL_HIGH";
+        case SeverityLevel.SEVERITY_LEVEL_CRITICAL:
+            return "SEVERITY_LEVEL_CRITICAL";
         case SeverityLevel.UNRECOGNIZED:
         default:
             return "UNRECOGNIZED";

package/dist/payloads/SimulationStatus.d.ts

@@ -10,14 +10,13 @@ export interface SimulationStatus {
     /** The unique identifier of the simulation */
     id: string;
     /** The simulation timestamp */
-    timestampSimulation: Date | undefined;
+    simulationTimestamp: Date | undefined;
 }
 export declare enum SimulationStatus_SimulationState {
     UNKNOWN = 0,
     STOPPED = 1,
-    ASSIGNED = 2,
-    RUNNING = 3,
-    PAUSED = 4,
+    RUNNING = 2,
+    PAUSED = 3,
     UNRECOGNIZED = -1
 }
 export declare function simulationStatus_SimulationStateFromJSON(object: any): SimulationStatus_SimulationState;

package/dist/payloads/SimulationStatus.js

@@ -14,9 +14,8 @@ var SimulationStatus_SimulationState;
 (function (SimulationStatus_SimulationState) {
     SimulationStatus_SimulationState[SimulationStatus_SimulationState["UNKNOWN"] = 0] = "UNKNOWN";
     SimulationStatus_SimulationState[SimulationStatus_SimulationState["STOPPED"] = 1] = "STOPPED";
-    SimulationStatus_SimulationState[SimulationStatus_SimulationState["ASSIGNED"] = 2] = "ASSIGNED";
-    SimulationStatus_SimulationState[SimulationStatus_SimulationState["RUNNING"] = 3] = "RUNNING";
-    SimulationStatus_SimulationState[SimulationStatus_SimulationState["PAUSED"] = 4] = "PAUSED";
+    SimulationStatus_SimulationState[SimulationStatus_SimulationState["RUNNING"] = 2] = "RUNNING";
+    SimulationStatus_SimulationState[SimulationStatus_SimulationState["PAUSED"] = 3] = "PAUSED";
     SimulationStatus_SimulationState[SimulationStatus_SimulationState["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
 })(SimulationStatus_SimulationState || (exports.SimulationStatus_SimulationState = SimulationStatus_SimulationState = {}));
 function simulationStatus_SimulationStateFromJSON(object) {
@@ -28,12 +27,9 @@ function simulationStatus_SimulationStateFromJSON(object) {
         case "STOPPED":
             return SimulationStatus_SimulationState.STOPPED;
         case 2:
-        case "ASSIGNED":
-            return SimulationStatus_SimulationState.ASSIGNED;
-        case 3:
         case "RUNNING":
             return SimulationStatus_SimulationState.RUNNING;
-        case 4:
+        case 3:
         case "PAUSED":
             return SimulationStatus_SimulationState.PAUSED;
         case -1:
@@ -49,8 +45,6 @@ function simulationStatus_SimulationStateToJSON(object) {
             return "UNKNOWN";
         case SimulationStatus_SimulationState.STOPPED:
             return "STOPPED";
-        case SimulationStatus_SimulationState.ASSIGNED:
-            return "ASSIGNED";
         case SimulationStatus_SimulationState.RUNNING:
             return "RUNNING";
         case SimulationStatus_SimulationState.PAUSED:
@@ -68,7 +62,7 @@ function createBaseSimulationStatus() {
         state: 0,
         name: "",
         id: "",
-        timestampSimulation: undefined,
+        simulationTimestamp: undefined,
     };
 }
 exports.SimulationStatus = {
@@ -86,8 +80,8 @@ exports.SimulationStatus = {
         if (message.id !== "") {
             writer.uint32(34).string(message.id);
         }
-        if (message.timestampSimulation !== undefined) {
-            timestamp_1.Timestamp.encode(toTimestamp(message.timestampSimulation), writer.uint32(42).fork()).join();
+        if (message.simulationTimestamp !== undefined) {
+            timestamp_1.Timestamp.encode(toTimestamp(message.simulationTimestamp), writer.uint32(42).fork()).join();
         }
         return writer;
     },
@@ -130,7 +124,7 @@ exports.SimulationStatus = {
                     if (tag !== 42) {
                         break;
                     }
-                    message.timestampSimulation = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
+                    message.simulationTimestamp = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
                     continue;
                 }
             }
@@ -148,8 +142,8 @@ exports.SimulationStatus = {
             state: isSet(object.state) ? simulationStatus_SimulationStateFromJSON(object.state) : 0,
             name: isSet(object.name) ? globalThis.String(object.name) : "",
             id: isSet(object.id) ? globalThis.String(object.id) : "",
-            timestampSimulation: isSet(object.timestampSimulation)
-                ? fromJsonTimestamp(object.timestampSimulation)
+            simulationTimestamp: isSet(object.simulationTimestamp)
+                ? fromJsonTimestamp(object.simulationTimestamp)
                 : undefined,
         };
     },
@@ -167,8 +161,8 @@ exports.SimulationStatus = {
         if (message.id !== "") {
             obj.id = message.id;
         }
-        if (message.timestampSimulation !== undefined) {
-            obj.timestampSimulation = message.timestampSimulation.toISOString();
+        if (message.simulationTimestamp !== undefined) {
+            obj.simulationTimestamp = message.simulationTimestamp.toISOString();
         }
         return obj;
     },
@@ -181,7 +175,7 @@ exports.SimulationStatus = {
         message.state = object.state ?? 0;
         message.name = object.name ?? "";
         message.id = object.id ?? "";
-        message.timestampSimulation = object.timestampSimulation ?? undefined;
+        message.simulationTimestamp = object.simulationTimestamp ?? undefined;
         return message;
     },
 };

package/dist/payloads/TestObjectStatus.d.ts

@@ -0,0 +1,154 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+/**
+ * ISO 22133 test-object status, as reported by an object to a control centre.
+ *
+ * ISO 22133 ("Road vehicles — Test object monitoring and control for active
+ * safety and automated/autonomous vehicle testing") governs how a test control
+ * centre monitors and commands objects on a proving ground. The values below
+ * are taken VERBATIM from the standard's reference implementation,
+ * https://github.com/RI-SE/iso22133 (include/defines.h), which RI-SE maintains
+ * — the standard itself is paywalled, so that library is the practical
+ * normative source.
+ *
+ * WHY THE VALUES ARE COPIED RATHER THAN TRANSLATED
+ * ------------------------------------------------
+ * keelson already carries several state machines that overlap this one:
+ * VehicleState (operational lifecycle), SimulationStatus (STOPPED/RUNNING/
+ * PAUSED), ROCStatus (who is controlling), OperationalAuthority (how much
+ * autonomy the vessel will accept) and the plain vehicle_armed flag. It would
+ * be easy to fold ISO states into those and avoid a new message.
+ *
+ * That would be wrong. A conformance claim is only meaningful if the state the
+ * object reported round-trips exactly: an operator asked "was the object in
+ * PRE_ARMING or ARMED at t?" must get the object's own answer, not this bus's
+ * nearest equivalent. POSTRUN, PRE_ARMING and PRE_RUNNING have no counterpart
+ * in any existing keelson enum, and a lossy mapping would quietly discard them.
+ *
+ * The RELATIONSHIP to the existing subjects is documented instead — see
+ * Crowsnest docs/ISO-22133.md — so a consumer can correlate without this
+ * message pretending to be them.
+ *
+ * SCOPE: MONITORING ONLY. This message is a report, not a command. ISO 22133's
+ * command path (OSTM state transitions, STRT, and the control-centre heartbeat
+ * whose loss obliges the object to abort) is deliberately absent: keelson has
+ * no heartbeat contract and no vessel implements abort-on-loss, so shipping the
+ * commands would imply a safety property that does not exist. That gap is
+ * written up rather than papered over.
+ */
+export interface TestObjectStatus {
+    $type: "keelson.TestObjectStatus";
+    /** The source timestamp of this report */
+    timestamp: Date | undefined;
+    state: TestObjectStatus_ObjectState;
+    readyToArm: TestObjectStatus_ArmReadiness;
+    controlCentreStatus: TestObjectStatus_ControlCentreStatus;
+    errors: TestObjectStatus_ErrorFlags | undefined;
+    /**
+     * The error bitmask exactly as received, so nothing is lost if the standard
+     * adds a bit this build does not know about.
+     */
+    errorBitmaskRaw: number;
+    /**
+     * Object identifier as configured in OSEM. NOT the keelson entity id: one
+     * connector may bridge several objects, and the mapping between the two is
+     * the connector's configuration, not something to infer here.
+     */
+    objectId: number;
+    /** The object's own transmitter/session id, when it reports one. */
+    objectName: string;
+}
+/**
+ * ISO 22133 object state. Values are the standard's own numbering
+ * (iso22133 include/defines.h, enum ObjectStateValues) — do NOT renumber.
+ */
+export declare enum TestObjectStatus_ObjectState {
+    OBJECT_STATE_OFF = 0,
+    OBJECT_STATE_INIT = 1,
+    OBJECT_STATE_ARMED = 2,
+    OBJECT_STATE_DISARMED = 3,
+    OBJECT_STATE_RUNNING = 4,
+    OBJECT_STATE_POSTRUN = 5,
+    OBJECT_STATE_REMOTE_CONTROLLED = 6,
+    OBJECT_STATE_ABORTING = 7,
+    OBJECT_STATE_PRE_ARMING = 8,
+    OBJECT_STATE_PRE_RUNNING = 9,
+    OBJECT_STATE_UNAVAILABLE = 255,
+    UNRECOGNIZED = -1
+}
+export declare function testObjectStatus_ObjectStateFromJSON(object: any): TestObjectStatus_ObjectState;
+export declare function testObjectStatus_ObjectStateToJSON(object: TestObjectStatus_ObjectState): string;
+/**
+ * Whether the object will accept an arm request (enum ArmReadinessValues).
+ * UNAVAILABLE is distinct from NOT_READY: the object is not telling us.
+ */
+export declare enum TestObjectStatus_ArmReadiness {
+    ARM_READINESS_NOT_READY = 0,
+    ARM_READINESS_READY = 1,
+    ARM_READINESS_UNAVAILABLE = 255,
+    UNRECOGNIZED = -1
+}
+export declare function testObjectStatus_ArmReadinessFromJSON(object: any): TestObjectStatus_ArmReadiness;
+export declare function testObjectStatus_ArmReadinessToJSON(object: TestObjectStatus_ArmReadiness): string;
+/**
+ * Control-centre status as the object last received it
+ * (enum ControlCenterStatusType). Reported so a reader can see the object's
+ * view of the session, which may lag or differ from the centre's own.
+ */
+export declare enum TestObjectStatus_ControlCentreStatus {
+    CONTROL_CENTRE_STATUS_INIT = 0,
+    CONTROL_CENTRE_STATUS_READY = 1,
+    CONTROL_CENTRE_STATUS_ABORT = 2,
+    CONTROL_CENTRE_STATUS_RUNNING = 3,
+    CONTROL_CENTRE_STATUS_TEST_DONE = 4,
+    CONTROL_CENTRE_STATUS_NORMAL_STOP = 5,
+    UNRECOGNIZED = -1
+}
+export declare function testObjectStatus_ControlCentreStatusFromJSON(object: any): TestObjectStatus_ControlCentreStatus;
+export declare function testObjectStatus_ControlCentreStatusToJSON(object: TestObjectStatus_ControlCentreStatus): string;
+/**
+ * MONR error flags, unpacked from the standard's bitmask into named
+ * booleans. Unpacked deliberately: a bitmask on the wire means every
+ * consumer re-derives the bit positions, and the one that gets a bit wrong
+ * reports the wrong fault. The raw byte is kept alongside for fidelity.
+ */
+export interface TestObjectStatus_ErrorFlags {
+    $type: "keelson.TestObjectStatus.ErrorFlags";
+    /** 0x80 */
+    abortRequest: boolean;
+    /** 0x40 */
+    outsideGeofence: boolean;
+    /** 0x20 */
+    badPositioningAccuracy: boolean;
+    /** 0x10 */
+    engineFault: boolean;
+    /** 0x08 */
+    batteryFault: boolean;
+    /** 0x04 */
+    other: boolean;
+    /** 0x02 */
+    syncPointEnded: boolean;
+    /** 0x01 */
+    vendorSpecific: boolean;
+}
+export declare const TestObjectStatus: MessageFns<TestObjectStatus, "keelson.TestObjectStatus">;
+export declare const TestObjectStatus_ErrorFlags: MessageFns<TestObjectStatus_ErrorFlags, "keelson.TestObjectStatus.ErrorFlags">;
+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 {};