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

package/dist/interfaces/VehicleSimulatorControl.js

@@ -5,7 +5,7 @@
 //   protoc               v6.30.2
 // source: VehicleSimulatorControl.proto
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VehicleSimulatorControlDefinition = exports.SetInitialPoseResponse = exports.InitialPose = exports.protobufPackage = void 0;
+exports.VehicleSimulatorControlDefinition = exports.SetStandingOrderResponse = exports.StandingOrder = exports.PropulsionOrder = exports.SteeringOrder = exports.SetInitialPoseResponse = exports.InitialPose = exports.protobufPackage = void 0;
 /* eslint-disable */
 const wire_1 = require("@bufbuild/protobuf/wire");
 const Coordinate_1 = require("./Coordinate");
@@ -132,6 +132,283 @@ exports.SetInitialPoseResponse = {
         return message;
     },
 };
+function createBaseSteeringOrder() {
+    return { courseOverGroundDeg: undefined, headingDeg: undefined };
+}
+exports.SteeringOrder = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.courseOverGroundDeg !== undefined) {
+            writer.uint32(9).double(message.courseOverGroundDeg);
+        }
+        if (message.headingDeg !== undefined) {
+            writer.uint32(17).double(message.headingDeg);
+        }
+        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 = createBaseSteeringOrder();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 9) {
+                        break;
+                    }
+                    message.courseOverGroundDeg = reader.double();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 17) {
+                        break;
+                    }
+                    message.headingDeg = reader.double();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            courseOverGroundDeg: isSet(object.courseOverGroundDeg)
+                ? globalThis.Number(object.courseOverGroundDeg)
+                : undefined,
+            headingDeg: isSet(object.headingDeg) ? globalThis.Number(object.headingDeg) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.courseOverGroundDeg !== undefined) {
+            obj.courseOverGroundDeg = message.courseOverGroundDeg;
+        }
+        if (message.headingDeg !== undefined) {
+            obj.headingDeg = message.headingDeg;
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.SteeringOrder.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseSteeringOrder();
+        message.courseOverGroundDeg = object.courseOverGroundDeg ?? undefined;
+        message.headingDeg = object.headingDeg ?? undefined;
+        return message;
+    },
+};
+function createBasePropulsionOrder() {
+    return { sogMps: undefined, stwMps: undefined, enginePct: undefined, shaftRpm: undefined };
+}
+exports.PropulsionOrder = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.sogMps !== undefined) {
+            writer.uint32(9).double(message.sogMps);
+        }
+        if (message.stwMps !== undefined) {
+            writer.uint32(17).double(message.stwMps);
+        }
+        if (message.enginePct !== undefined) {
+            writer.uint32(25).double(message.enginePct);
+        }
+        if (message.shaftRpm !== undefined) {
+            writer.uint32(33).double(message.shaftRpm);
+        }
+        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 = createBasePropulsionOrder();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 9) {
+                        break;
+                    }
+                    message.sogMps = reader.double();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 17) {
+                        break;
+                    }
+                    message.stwMps = reader.double();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 25) {
+                        break;
+                    }
+                    message.enginePct = reader.double();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 33) {
+                        break;
+                    }
+                    message.shaftRpm = reader.double();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            sogMps: isSet(object.sogMps) ? globalThis.Number(object.sogMps) : undefined,
+            stwMps: isSet(object.stwMps) ? globalThis.Number(object.stwMps) : undefined,
+            enginePct: isSet(object.enginePct) ? globalThis.Number(object.enginePct) : undefined,
+            shaftRpm: isSet(object.shaftRpm) ? globalThis.Number(object.shaftRpm) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.sogMps !== undefined) {
+            obj.sogMps = message.sogMps;
+        }
+        if (message.stwMps !== undefined) {
+            obj.stwMps = message.stwMps;
+        }
+        if (message.enginePct !== undefined) {
+            obj.enginePct = message.enginePct;
+        }
+        if (message.shaftRpm !== undefined) {
+            obj.shaftRpm = message.shaftRpm;
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.PropulsionOrder.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBasePropulsionOrder();
+        message.sogMps = object.sogMps ?? undefined;
+        message.stwMps = object.stwMps ?? undefined;
+        message.enginePct = object.enginePct ?? undefined;
+        message.shaftRpm = object.shaftRpm ?? undefined;
+        return message;
+    },
+};
+function createBaseStandingOrder() {
+    return { steering: undefined, propulsion: undefined };
+}
+exports.StandingOrder = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.steering !== undefined) {
+            exports.SteeringOrder.encode(message.steering, writer.uint32(10).fork()).join();
+        }
+        if (message.propulsion !== undefined) {
+            exports.PropulsionOrder.encode(message.propulsion, writer.uint32(18).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 = createBaseStandingOrder();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.steering = exports.SteeringOrder.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.propulsion = exports.PropulsionOrder.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            steering: isSet(object.steering) ? exports.SteeringOrder.fromJSON(object.steering) : undefined,
+            propulsion: isSet(object.propulsion) ? exports.PropulsionOrder.fromJSON(object.propulsion) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.steering !== undefined) {
+            obj.steering = exports.SteeringOrder.toJSON(message.steering);
+        }
+        if (message.propulsion !== undefined) {
+            obj.propulsion = exports.PropulsionOrder.toJSON(message.propulsion);
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.StandingOrder.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseStandingOrder();
+        message.steering = (object.steering !== undefined && object.steering !== null)
+            ? exports.SteeringOrder.fromPartial(object.steering)
+            : undefined;
+        message.propulsion = (object.propulsion !== undefined && object.propulsion !== null)
+            ? exports.PropulsionOrder.fromPartial(object.propulsion)
+            : undefined;
+        return message;
+    },
+};
+function createBaseSetStandingOrderResponse() {
+    return {};
+}
+exports.SetStandingOrderResponse = {
+    encode(_, writer = new wire_1.BinaryWriter()) {
+        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 = createBaseSetStandingOrderResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(_) {
+        return {};
+    },
+    toJSON(_) {
+        const obj = {};
+        return obj;
+    },
+    create(base) {
+        return exports.SetStandingOrderResponse.fromPartial(base ?? {});
+    },
+    fromPartial(_) {
+        const message = createBaseSetStandingOrderResponse();
+        return message;
+    },
+};
 exports.VehicleSimulatorControlDefinition = {
     name: "VehicleSimulatorControl",
     fullName: "keelson.interfaces.vehicle_simulator_control.VehicleSimulatorControl",
@@ -148,6 +425,21 @@ exports.VehicleSimulatorControlDefinition = {
             responseStream: false,
             options: {},
         },
+        /**
+         * Give a RUNNING entity a new standing order, without moving it. On a
+         * STOPPED or ASSIGNED entity, replies ErrorResponse{code =
+         * INVALID_STATE} — the mirror of set_initial_pose's own rule, and for
+         * the same reason: an order to a vehicle that is not going anywhere is
+         * a caller confusing setup with command.
+         */
+        set_standing_order: {
+            name: "set_standing_order",
+            requestType: exports.StandingOrder,
+            requestStream: false,
+            responseType: exports.SetStandingOrderResponse,
+            responseStream: false,
+            options: {},
+        },
     },
 };
 function isSet(value) {

package/dist/interfaces/serviceRegistry.d.ts

@@ -199,14 +199,6 @@ export declare const serviceDefinitions: {
         readonly name: "ScenarioControl";
         readonly fullName: "keelson.interfaces.scenario_control.ScenarioControl";
         readonly methods: {
-            readonly list: {
-                readonly name: "list";
-                readonly requestType: import("./ScenarioControl").MessageFns<import("./ScenarioControl").ListRequest>;
-                readonly requestStream: false;
-                readonly responseType: import("./ScenarioControl").MessageFns<import("./ScenarioControl").ListResponse>;
-                readonly responseStream: false;
-                readonly options: {};
-            };
             readonly load: {
                 readonly name: "load";
                 readonly requestType: import("./ScenarioControl").MessageFns<import("./ScenarioControl").LoadRequest>;
@@ -509,6 +501,14 @@ export declare const serviceDefinitions: {
                 readonly responseStream: false;
                 readonly options: {};
             };
+            readonly set_standing_order: {
+                readonly name: "set_standing_order";
+                readonly requestType: import("./VehicleSimulatorControl").MessageFns<import("./VehicleSimulatorControl").StandingOrder>;
+                readonly requestStream: false;
+                readonly responseType: import("./VehicleSimulatorControl").MessageFns<import("./VehicleSimulatorControl").SetStandingOrderResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
         };
     };
     readonly "whep_proxy/v1": {

package/dist/payloads/ChecklistEvent.d.ts

@@ -0,0 +1,178 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { ChecklistItemEvidence } from "./ChecklistEvidence";
+/**
+ * Represents a single auditable action performed on a checklist by an operator.
+ * Used for real-time synchronization of checklist activity between Remote Operations Centres.
+ */
+export interface ChecklistEvent {
+    $type: "keelson.ChecklistEvent";
+    timestamp: Date | undefined;
+    eventId: string;
+    eventType: ChecklistEvent_EventType;
+    /** Operator identity */
+    operatorId: string;
+    username: string;
+    role: string;
+    rocSite: string;
+    /** Checklist context */
+    procedureId: string;
+    itemId: string;
+    /** Event-specific text payload (note text, flag reason, resolution text) */
+    detail: string;
+    /**
+     * Which additive entry this event names: `note_id`, `evidence_id`, or `flag_id`.
+     *
+     * Each is the union key its list merges on in protocol-specification.md §7.2, so an event that
+     * omits this can only append — it cannot say which existing entry it acts on.
+     *
+     * LEGACY, and unrelated to the above: on an EVENT_TYPE_TIME_SET from a publisher that predates
+     * `corrected_field`, this instead carries the NAME of the timestamp being corrected, as one of
+     * the strings "started_at", "completed_at", "run_started_at". See `corrected_field` for that
+     * fallback path. New publishers set `corrected_field` and leave this to mean what the first
+     * paragraph says.
+     */
+    referenceId: string;
+    /**
+     * Which RUN of `procedure_id` this event belongs to.
+     *
+     * Empty means a publisher that predates the run model; a receiver adopts such an event under a
+     * legacy run keyed by the procedure id rather than dropping it.
+     */
+    runId: string;
+    /** Set on EVENT_TYPE_EVIDENCE_ATTACHED. Metadata only — see ChecklistEvidence.proto. */
+    evidence: ChecklistItemEvidence | undefined;
+    /**
+     * The corrected instant, on EVENT_TYPE_TIME_SET.
+     *
+     * This used to travel as a UTC ISO-8601 string in `detail`, in a message that already imports
+     * google.protobuf.Timestamp — so every consumer wrote its own parser, and every parser was a
+     * chance to disagree about an instant in a safety record.
+     *
+     * LEGACY FALLBACK: a publisher predating this field leaves it unset and writes the string. A
+     * receiver reads this field when `corrected_field` is set, and falls back to parsing `detail`
+     * only when `corrected_field == TIME_FIELD_UNKNOWN` — never the other way round, so a
+     * publisher writing both cannot be misread. Publishers SHOULD write both until every consumer
+     * is known to read the typed pair; recordings full of the string form must keep replaying.
+     */
+    correctedTime: Date | undefined;
+    /**
+     * Which timestamp `corrected_time` replaces. Set together with it, or neither.
+     *
+     * TIME_FIELD_UNKNOWN on an EVENT_TYPE_TIME_SET means a legacy publisher: fall back to the
+     * `reference_id` string ("started_at", "completed_at", "run_started_at"). An unrecognised
+     * value here is dropped, not guessed — a correction applied to the wrong field is worse than
+     * one not applied at all.
+     */
+    correctedField: ChecklistEvent_TimeField;
+}
+export declare enum ChecklistEvent_EventType {
+    EVENT_TYPE_UNKNOWN = 0,
+    EVENT_TYPE_CHECKLIST_OPENED = 1,
+    EVENT_TYPE_ITEM_STARTED = 2,
+    EVENT_TYPE_ITEM_COMPLETED = 3,
+    EVENT_TYPE_ITEM_REVERTED = 4,
+    EVENT_TYPE_NOTE_ADDED = 5,
+    /**
+     * EVENT_TYPE_ITEM_FLAGGED - An issue raised on an item, and the moment it was cleared.
+     *
+     * Both carry the flag they act on in `reference_id` — the `flag_id`, which is the union key
+     * ChecklistState.ItemState.flags merges on. Without it a receiver folding one of these into
+     * `flags` has nothing to match against and can only append, so resolving a flag would add a
+     * second open one instead of closing the first.
+     *
+     * A publisher of FLAG_RESOLVED must ALSO write the resolution triple on the ItemFlag —
+     * `resolved_at`, `resolved_by`, `resolution` — because that is the half that survives in a
+     * snapshot. The event is the live path; a station bootstrapping later sees only the state.
+     * Those three are absorbing and settled earliest-wins, per protocol-specification.md §7.2: a
+     * peer that never saw the resolution must not reopen it, and two stations genuinely clearing
+     * one flag are decided by the earlier time as a value, never by whose snapshot landed last.
+     */
+    EVENT_TYPE_ITEM_FLAGGED = 6,
+    EVENT_TYPE_FLAG_RESOLVED = 7,
+    /**
+     * EVENT_TYPE_PROCEDURE_STARTED - The run boundary markers. STARTED moves a run to ACTIVE (from PLANNED, or straight from
+     * creation); COMPLETED is the sign-off once every required item is done.
+     */
+    EVENT_TYPE_PROCEDURE_STARTED = 8,
+    EVENT_TYPE_PROCEDURE_COMPLETED = 9,
+    /** EVENT_TYPE_RUN_PLANNED - A run queued for later, with or without a due time. */
+    EVENT_TYPE_RUN_PLANNED = 10,
+    /** EVENT_TYPE_RUN_ABANDONED - A run stopped without completing. The reason is required and travels in `detail`. */
+    EVENT_TYPE_RUN_ABANDONED = 11,
+    /**
+     * EVENT_TYPE_EVIDENCE_ATTACHED - A photo attached to an item. The metadata rides in `evidence`; the bytes are published
+     * separately to `checklist_evidence/{evidence_id}`.
+     */
+    EVENT_TYPE_EVIDENCE_ATTACHED = 12,
+    /**
+     * EVENT_TYPE_TIME_SET - A timestamp corrected after the fact — "I finished at 14:45, I am only ticking it now".
+     *
+     * A dedicated type rather than a backdated ITEM_COMPLETED, because ITEM_COMPLETED resolves
+     * conflicts earliest-wins: a completion moved LATER hits that guard on every station, logs a
+     * "confirmed" row, and changes nothing. The guard is right for genuine concurrent completion
+     * and must not be relaxed for this.
+     *
+     * The corrected instant travels in `corrected_time` and the field it corrects in
+     * `corrected_field`. See those fields for what a receiver does with a publisher that
+     * predates them.
+     *
+     * Applying it patches ONLY that timestamp — status and author are untouched — and it is
+     * recorded as its own kind of entry. In a safety record a corrected time that renders
+     * identically to an original one is a claim nobody can audit.
+     */
+    EVENT_TYPE_TIME_SET = 13,
+    /**
+     * EVENT_TYPE_ITEM_REOPENED - An item taken back out of "done", with the reason in `detail`.
+     *
+     * Publishers have been spelling this EVENT_TYPE_ITEM_REVERTED = 4 with the reason in `detail`,
+     * because adding an enum value costs a release cycle. The behaviour and the audit trail were
+     * right; only the name misled — "reverted" reads as undoing a mistake, while reopening is a
+     * deliberate, reasoned act that a supervisor performs on a record that already stands.
+     *
+     * EVENT_TYPE_ITEM_REVERTED stays valid and is deliberately NOT reserved: recordings and
+     * durable snapshots already contain 4, and they must keep decoding. Treat the two as the same
+     * act; prefer this one for anything published from now on.
+     */
+    EVENT_TYPE_ITEM_REOPENED = 15,
+    UNRECOGNIZED = -1
+}
+export declare function checklistEvent_EventTypeFromJSON(object: any): ChecklistEvent_EventType;
+export declare function checklistEvent_EventTypeToJSON(object: ChecklistEvent_EventType): string;
+/**
+ * Which timestamp an EVENT_TYPE_TIME_SET corrects.
+ *
+ * An enum rather than the field's name as a string, because a string target is matched by
+ * every consumer against its own spelling: a typo is not an error, it is a silent no-op that
+ * logs an audited correction and patches nothing.
+ */
+export declare enum ChecklistEvent_TimeField {
+    TIME_FIELD_UNKNOWN = 0,
+    TIME_FIELD_ITEM_STARTED_AT = 1,
+    TIME_FIELD_ITEM_COMPLETED_AT = 2,
+    /** TIME_FIELD_RUN_STARTED_AT - The run's own start. Ignores `item_id`. */
+    TIME_FIELD_RUN_STARTED_AT = 3,
+    UNRECOGNIZED = -1
+}
+export declare function checklistEvent_TimeFieldFromJSON(object: any): ChecklistEvent_TimeField;
+export declare function checklistEvent_TimeFieldToJSON(object: ChecklistEvent_TimeField): string;
+export declare const ChecklistEvent: MessageFns<ChecklistEvent, "keelson.ChecklistEvent">;
+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 {};