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

package/dist/index.d.ts

@@ -216,6 +216,14 @@ export declare function getInterfaceDefinition(interfaceAndVersion: string): {
     readonly name: "ScenarioControl";
     readonly fullName: "keelson.interfaces.scenario_control.ScenarioControl";
     readonly methods: {
+        readonly list: {
+            readonly name: "list";
+            readonly requestType: import("./interfaces/ScenarioControl").MessageFns<import("./interfaces/ScenarioControl").ListRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/ScenarioControl").MessageFns<import("./interfaces/ScenarioControl").ListResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
         readonly load: {
             readonly name: "load";
             readonly requestType: import("./interfaces/ScenarioControl").MessageFns<import("./interfaces/ScenarioControl").LoadRequest>;

package/dist/interfaces/Route.d.ts

@@ -272,6 +272,19 @@ export interface RouteInfo {
     maxWindSpeedMps?: number | undefined;
     minSpeedKnots?: number | undefined;
     maxSpeedKnots?: number | undefined;
+    /**
+     * Minimum visibility the route is valid above. `visibility_range_m` is
+     * published, so without this the measurement exists and the limit it should
+     * be checked against does not.
+     */
+    minVisibilityM?: number | undefined;
+    /**
+     * Gust limit, distinct from the mean-wind limit above. Gust is what governs
+     * small-craft operations: 12 m/s mean with 20 m/s gusts is a different
+     * proposition from a steady 12 m/s, and only the mean can be constrained
+     * today. Checked against the windowed `true_wind_speed_max_mps`.
+     */
+    maxWindGustMps?: number | undefined;
     /**
      * -- Optimization & autonomy ------------------------------------------------
      * Free-form optimization method label (e.g. "fuel-min", "eta-min", "weather-routed").

package/dist/interfaces/Route.js

@@ -1311,6 +1311,8 @@ function createBaseRouteInfo() {
         maxWindSpeedMps: undefined,
         minSpeedKnots: undefined,
         maxSpeedKnots: undefined,
+        minVisibilityM: undefined,
+        maxWindGustMps: undefined,
         optimizationMethod: "",
         autonomyLevel: 0,
         extensions: undefined,
@@ -1360,6 +1362,12 @@ exports.RouteInfo = {
         if (message.maxSpeedKnots !== undefined) {
             writer.uint32(277).float(message.maxSpeedKnots);
         }
+        if (message.minVisibilityM !== undefined) {
+            writer.uint32(285).float(message.minVisibilityM);
+        }
+        if (message.maxWindGustMps !== undefined) {
+            writer.uint32(293).float(message.maxWindGustMps);
+        }
         if (message.optimizationMethod !== "") {
             writer.uint32(402).string(message.optimizationMethod);
         }
@@ -1476,6 +1484,20 @@ exports.RouteInfo = {
                     message.maxSpeedKnots = reader.float();
                     continue;
                 }
+                case 35: {
+                    if (tag !== 285) {
+                        break;
+                    }
+                    message.minVisibilityM = reader.float();
+                    continue;
+                }
+                case 36: {
+                    if (tag !== 293) {
+                        break;
+                    }
+                    message.maxWindGustMps = reader.float();
+                    continue;
+                }
                 case 50: {
                     if (tag !== 402) {
                         break;
@@ -1521,6 +1543,8 @@ exports.RouteInfo = {
             maxWindSpeedMps: isSet(object.maxWindSpeedMps) ? globalThis.Number(object.maxWindSpeedMps) : undefined,
             minSpeedKnots: isSet(object.minSpeedKnots) ? globalThis.Number(object.minSpeedKnots) : undefined,
             maxSpeedKnots: isSet(object.maxSpeedKnots) ? globalThis.Number(object.maxSpeedKnots) : undefined,
+            minVisibilityM: isSet(object.minVisibilityM) ? globalThis.Number(object.minVisibilityM) : undefined,
+            maxWindGustMps: isSet(object.maxWindGustMps) ? globalThis.Number(object.maxWindGustMps) : undefined,
             optimizationMethod: isSet(object.optimizationMethod) ? globalThis.String(object.optimizationMethod) : "",
             autonomyLevel: isSet(object.autonomyLevel) ? autonomyLevelFromJSON(object.autonomyLevel) : 0,
             extensions: isSet(object.extensions) ? exports.Extensions.fromJSON(object.extensions) : undefined,
@@ -1570,6 +1594,12 @@ exports.RouteInfo = {
         if (message.maxSpeedKnots !== undefined) {
             obj.maxSpeedKnots = message.maxSpeedKnots;
         }
+        if (message.minVisibilityM !== undefined) {
+            obj.minVisibilityM = message.minVisibilityM;
+        }
+        if (message.maxWindGustMps !== undefined) {
+            obj.maxWindGustMps = message.maxWindGustMps;
+        }
         if (message.optimizationMethod !== "") {
             obj.optimizationMethod = message.optimizationMethod;
         }
@@ -1600,6 +1630,8 @@ exports.RouteInfo = {
         message.maxWindSpeedMps = object.maxWindSpeedMps ?? undefined;
         message.minSpeedKnots = object.minSpeedKnots ?? undefined;
         message.maxSpeedKnots = object.maxSpeedKnots ?? undefined;
+        message.minVisibilityM = object.minVisibilityM ?? undefined;
+        message.maxWindGustMps = object.maxWindGustMps ?? undefined;
         message.optimizationMethod = object.optimizationMethod ?? "";
         message.autonomyLevel = object.autonomyLevel ?? 0;
         message.extensions = (object.extensions !== undefined && object.extensions !== null)

package/dist/interfaces/ScenarioControl.d.ts

@@ -1,6 +1,74 @@
 import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
 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;
+    /**
+     * Enough to tell two scenarios apart at a glance. Zero means the
+     * responder does not know or the scenario does not say — for
+     * duration_ticks specifically, an open-ended scenario.
+     */
+    vesselCount: number;
+    durationTicks: number;
+    stepSizeMs: number;
+    /**
+     * False when the responder can see this scenario but would refuse to
+     * load it, with `reason` saying why in the words the failed load would
+     * have used.
+     *
+     * On the wire rather than filtered out, because both alternatives are
+     * worse. Omitting these rows 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.
+     */
+    loadable: boolean;
+    reason: string;
+}
+export interface ListRequest {
+    /**
+     * 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 ListResponse {
+    /**
+     * 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 +97,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 +107,22 @@ 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, and
+     * the run id is minted by the load itself.
+     *
+     * Returned rather than left to the status broadcast for the reason
+     * StepResponse.tick gives twelve lines 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.
+     */
+    scenarioId: string;
+    scenarioHash: string;
+    runId: string;
+}
 export interface StepResponse {
     /**
      * Where the clock came to rest. Returned rather than left to the status
@@ -50,21 +132,32 @@ export interface StepResponse {
     tick: number;
     simulationTime: Date | undefined;
 }
+export declare const ScenarioInfo: MessageFns<ScenarioInfo>;
+export declare const ListRequest: MessageFns<ListRequest>;
+export declare const ListResponse: MessageFns<ListResponse>;
 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: {
+            readonly name: "list";
+            readonly requestType: MessageFns<ListRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns<ListResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
         readonly load: {
             readonly name: "load";
             readonly requestType: MessageFns<LoadRequest>;