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

package/dist/interfaces/ScenarioControl.d.ts

@@ -1,6 +1,109 @@
 import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { Duration } from "./google/protobuf/duration";
 import { Empty } from "./google/protobuf/empty";
 export declare const protobufPackage = "keelson.interfaces.scenario_control";
+/**
+ * One scenario the responder is willing to be asked about. Deliberately
+ * thin: the fields are the ones an operator needs to *choose* between two
+ * scenarios, not a description of what a scenario is. What a scenario is
+ * varies by simulator, and pinning that here would bind every
+ * implementation to one — the same reason LoadRequest.scenario is opaque.
+ */
+export interface ScenarioInfo {
+    /**
+     * Exactly what `load` takes. A listing whose ids are not loadable ids is
+     * a listing a picker cannot act on.
+     */
+    scenarioId: string;
+    /** One line, from the document. Empty if it carries none. */
+    description: string;
+    /**
+     * Content hash of the scenario as the responder reads it — the same hash
+     * ScenarioStatus broadcasts, so a picker can tell which of these is the
+     * running one, and two responders offering the same id can be compared.
+     */
+    scenarioHash: string;
+    /**
+     * How many vessels the scenario declares. Absent when the responder did
+     * not count; present 0 is a real answer — an environment-only scenario.
+     */
+    vesselCount?: number | undefined;
+    /**
+     * The scenario's declared length in ticks, present only when it declares
+     * an end. Absent means there is no declared end to report: the scenario
+     * is open-ended, or the responder could not determine one. This listing
+     * deliberately does not distinguish those two — a picker renders both the
+     * same way, and a responder that guessed between them would be inventing
+     * the distinction rather than reporting it.
+     */
+    durationTicks?: number | undefined;
+    /**
+     * The fixed step each tick represents. A Duration rather than a scalar of
+     * milliseconds so it is directly comparable with
+     * keelson.ScenarioStatus.step_size — a picker holding a listed scenario
+     * against the running one should not have to convert between encodings of
+     * the same quantity. Absent when the responder does not know.
+     */
+    stepSize: Duration | undefined;
+    loadability: ScenarioInfo_Loadability;
+    /**
+     * Why, in the words the failed load would have used. Set when loadability
+     * is NOT_LOADABLE; it may also explain a LOADABILITY_UNKNOWN. It MUST be
+     * empty when loadability is LOADABLE — a caller must never have to decide
+     * whether text here is a warning about a scenario it can load.
+     */
+    reason: string;
+}
+/**
+ * Whether the responder would load this scenario if asked.
+ *
+ * An enum with a countable unknown rather than a bool, because the zero
+ * value is what a partially-populated row reports and the affirmative has
+ * to be the safe one: LOADABILITY_UNKNOWN means the responder expressed no
+ * opinion, and a picker must offer such a row and let `load` answer. A
+ * bool would make every row a simpler responder builds read as "would
+ * refuse", greying out a whole library nobody has anything against.
+ *
+ * NOT_LOADABLE rows stay on the wire rather than being filtered out,
+ * because both alternatives are worse. Omitting them hides files the
+ * operator can see in the library and leaves them asking why one is
+ * missing; listing them as loadable is a lie the picker only discovers by
+ * trying. A simulator whose scenario language is still growing has these
+ * constantly: the document parses, and names a construct this build
+ * cannot elaborate.
+ */
+export declare enum ScenarioInfo_Loadability {
+    LOADABILITY_UNKNOWN = 0,
+    LOADABLE = 1,
+    NOT_LOADABLE = 2,
+    UNRECOGNIZED = -1
+}
+export declare function scenarioInfo_LoadabilityFromJSON(object: any): ScenarioInfo_Loadability;
+export declare function scenarioInfo_LoadabilityToJSON(object: ScenarioInfo_Loadability): string;
+export interface ListScenariosRequest {
+    /**
+     * Optional; the responder decides what it means (an id prefix, a glob).
+     * No filter lists everything the responder is willing to list. Same
+     * contract as ListCheckpointsRequest.pattern and ListFilesRequest.pattern.
+     */
+    pattern: string;
+}
+export interface ListScenariosResponse {
+    /**
+     * Where the responder is listing from, for the reason its two siblings
+     * carry it: an operator choosing between two scenarios with the same id
+     * needs to know whether they came from the same place.
+     */
+    baseDirectory: string;
+    /** Ordered by scenario_id, so a listing read twice reads the same way. */
+    scenarios: ScenarioInfo[];
+    /**
+     * True when the responder capped the listing. On the wire because a
+     * listing that quietly stopped short reads as "that is all of them", and
+     * an operator would go looking for a scenario that is in fact there.
+     */
+    truncated: boolean;
+}
 export interface LoadRequest {
     /**
      * Identifier of the scenario to load, as the responder understands it —
@@ -29,8 +132,6 @@ export interface SetRateRequest {
  * individual command can grow a return field later without a breaking
  * type change and without that field bleeding onto the other commands.
  */
-export interface LoadResponse {
-}
 export interface StartResponse {
 }
 export interface PauseResponse {
@@ -41,6 +142,23 @@ export interface ResetResponse {
 }
 export interface SetRateResponse {
 }
+export interface LoadResponse {
+    /**
+     * What was actually loaded, resolved. `scenario` in the request is
+     * whatever the caller typed; these are the responder's answer to it.
+     *
+     * Returned rather than left to the status broadcast for the reason
+     * StepResponse.tick gives below: a caller should not have to race a 1 Hz
+     * status sample to learn the result of its own call. It also makes an
+     * ambiguous id visible — a caller that asked for "harbor" and got back a
+     * hash it did not expect can say so.
+     *
+     * No run id here; see "Run identity" above. A load lands in STOPPED, where
+     * no run has begun.
+     */
+    scenarioId: string;
+    scenarioHash: string;
+}
 export interface StepResponse {
     /**
      * Where the clock came to rest. Returned rather than left to the status
@@ -50,21 +168,32 @@ export interface StepResponse {
     tick: number;
     simulationTime: Date | undefined;
 }
+export declare const ScenarioInfo: MessageFns<ScenarioInfo>;
+export declare const ListScenariosRequest: MessageFns<ListScenariosRequest>;
+export declare const ListScenariosResponse: MessageFns<ListScenariosResponse>;
 export declare const LoadRequest: MessageFns<LoadRequest>;
 export declare const StepRequest: MessageFns<StepRequest>;
 export declare const SetRateRequest: MessageFns<SetRateRequest>;
-export declare const LoadResponse: MessageFns<LoadResponse>;
 export declare const StartResponse: MessageFns<StartResponse>;
 export declare const PauseResponse: MessageFns<PauseResponse>;
 export declare const StopResponse: MessageFns<StopResponse>;
 export declare const ResetResponse: MessageFns<ResetResponse>;
 export declare const SetRateResponse: MessageFns<SetRateResponse>;
+export declare const LoadResponse: MessageFns<LoadResponse>;
 export declare const StepResponse: MessageFns<StepResponse>;
 export type ScenarioControlDefinition = typeof ScenarioControlDefinition;
 export declare const ScenarioControlDefinition: {
     readonly name: "ScenarioControl";
     readonly fullName: "keelson.interfaces.scenario_control.ScenarioControl";
     readonly methods: {
+        readonly list_scenarios: {
+            readonly name: "list_scenarios";
+            readonly requestType: MessageFns<ListScenariosRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns<ListScenariosResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
         readonly load: {
             readonly name: "load";
             readonly requestType: MessageFns<LoadRequest>;