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

package/dist/index.d.ts

@@ -4,6 +4,7 @@ import './payloads';
 export declare function construct_pubSub_key(base_path: string, entityId: string, subject: string, sourceId: string, targetId?: string): string;
 export declare function construct_rpc_key(base_path: string, entityId: string, iface: string, version: string, procedure: string, sourceId: string): string;
 export declare function construct_source_liveliness_key(base_path: string, entityId: string, sourceId: string): string;
+export declare function construct_pubsub_subject_liveliness_keys(base_path: string, entityId: string, subject: string, sourceId: string, targeted?: boolean): string[];
 export declare function construct_rpc_interface_liveliness_key(base_path: string, entityId: string, iface: string, version: string, sourceId: string): string;
 export interface ParsedPubSubKey {
     base_path: string;
@@ -23,6 +24,19 @@ export declare function isInterfaceWellKnown(interfaceAndVersion: string): boole
 export declare function getInterfaceService(interfaceAndVersion: string): string | undefined;
 export declare function listInterfaces(): string[];
 export declare function getInterfaceDefinition(interfaceAndVersion: string): {
+    readonly name: "AlarmAck";
+    readonly fullName: "keelson.interfaces.alarm_ack.AlarmAck";
+    readonly methods: {
+        readonly acknowledge_alarm: {
+            readonly name: "acknowledge_alarm";
+            readonly requestType: import("./interfaces/AlarmAck").MessageFns<import("./interfaces/AlarmAck").AcknowledgeAlarmRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/AlarmAck").MessageFns<import("./interfaces/AlarmAck").AcknowledgeAlarmResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
+} | {
     readonly name: "Configurable";
     readonly fullName: "keelson.interfaces.configurable.Configurable";
     readonly methods: {
@@ -43,6 +57,59 @@ export declare function getInterfaceDefinition(interfaceAndVersion: string): {
             readonly options: {};
         };
     };
+} | {
+    readonly name: "ContainerControl";
+    readonly fullName: "keelson.interfaces.container_control.ContainerControl";
+    readonly methods: {
+        readonly list: {
+            readonly name: "list";
+            readonly requestType: import("./interfaces/ContainerControl").MessageFns<import("./interfaces/ContainerControl").ListContainersRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/ContainerControl").MessageFns<import("./interfaces/ContainerControl").ListContainersResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly logs: {
+            readonly name: "logs";
+            readonly requestType: import("./interfaces/ContainerControl").MessageFns<import("./interfaces/ContainerControl").GetLogsRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/ContainerControl").MessageFns<import("./interfaces/ContainerControl").GetLogsResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly start: {
+            readonly name: "start";
+            readonly requestType: import("./interfaces/ContainerControl").MessageFns<import("./interfaces/ContainerControl").StartContainerRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/ContainerControl").MessageFns<import("./interfaces/ContainerControl").ContainerActionResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly stop: {
+            readonly name: "stop";
+            readonly requestType: import("./interfaces/ContainerControl").MessageFns<import("./interfaces/ContainerControl").StopContainerRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/ContainerControl").MessageFns<import("./interfaces/ContainerControl").ContainerActionResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly restart: {
+            readonly name: "restart";
+            readonly requestType: import("./interfaces/ContainerControl").MessageFns<import("./interfaces/ContainerControl").RestartContainerRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/ContainerControl").MessageFns<import("./interfaces/ContainerControl").ContainerActionResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly remove: {
+            readonly name: "remove";
+            readonly requestType: import("./interfaces/ContainerControl").MessageFns<import("./interfaces/ContainerControl").RemoveContainerRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/ContainerControl").MessageFns<import("./interfaces/ContainerControl").RemoveContainerResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
 } | {
     readonly name: "MavlinkCommand";
     readonly fullName: "keelson.interfaces.mavlink_command.MavlinkCommand";
@@ -216,6 +283,14 @@ export declare function getInterfaceDefinition(interfaceAndVersion: string): {
     readonly name: "ScenarioControl";
     readonly fullName: "keelson.interfaces.scenario_control.ScenarioControl";
     readonly methods: {
+        readonly list_scenarios: {
+            readonly name: "list_scenarios";
+            readonly requestType: import("./interfaces/ScenarioControl").MessageFns<import("./interfaces/ScenarioControl").ListScenariosRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/ScenarioControl").MessageFns<import("./interfaces/ScenarioControl").ListScenariosResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
         readonly load: {
             readonly name: "load";
             readonly requestType: import("./interfaces/ScenarioControl").MessageFns<import("./interfaces/ScenarioControl").LoadRequest>;
@@ -451,6 +526,14 @@ export declare function getInterfaceDefinition(interfaceAndVersion: string): {
             readonly responseStream: false;
             readonly options: {};
         };
+        readonly set_steering_order: {
+            readonly name: "set_steering_order";
+            readonly requestType: import("./interfaces/VehicleNavigation").MessageFns<import("./interfaces/VehicleNavigation").SetSteeringOrderRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/VehicleNavigation").MessageFns<import("./interfaces/VehicleNavigation").SetSteeringOrderResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
     };
 } | {
     readonly name: "VehicleParam";
@@ -509,14 +592,6 @@ export declare function getInterfaceDefinition(interfaceAndVersion: string): {
             readonly responseStream: false;
             readonly options: {};
         };
-        readonly set_standing_order: {
-            readonly name: "set_standing_order";
-            readonly requestType: import("./interfaces/VehicleSimulatorControl").MessageFns<import("./interfaces/VehicleSimulatorControl").StandingOrder>;
-            readonly requestStream: false;
-            readonly responseType: import("./interfaces/VehicleSimulatorControl").MessageFns<import("./interfaces/VehicleSimulatorControl").SetStandingOrderResponse>;
-            readonly responseStream: false;
-            readonly options: {};
-        };
     };
 } | {
     readonly name: "WHEPProxy";

package/dist/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.encloseFromTypeName = exports.encodePayloadFromTypeName = exports.decodePayloadFromTypeName = exports.getProtobufClassFromTypeName = exports.qosFor = exports.getProcedureCodecs = exports.getProcedures = exports.getInterfaceDefinition = exports.listInterfaces = exports.getInterfaceService = exports.isInterfaceWellKnown = exports.getSubjectSchema = exports.isSubjectWellKnown = exports.uncover = exports.enclose = exports.get_subject_from_pubsub_key = exports.parse_rpc_key = exports.parse_pubsub_key = exports.construct_rpc_interface_liveliness_key = exports.construct_source_liveliness_key = exports.construct_rpc_key = exports.construct_pubSub_key = void 0;
+exports.encloseFromTypeName = exports.encodePayloadFromTypeName = exports.decodePayloadFromTypeName = exports.getProtobufClassFromTypeName = exports.qosFor = exports.getProcedureCodecs = exports.getProcedures = exports.getInterfaceDefinition = exports.listInterfaces = exports.getInterfaceService = exports.isInterfaceWellKnown = exports.getSubjectSchema = exports.isSubjectWellKnown = exports.uncover = exports.enclose = exports.get_subject_from_pubsub_key = exports.parse_rpc_key = exports.parse_pubsub_key = exports.construct_rpc_interface_liveliness_key = exports.construct_pubsub_subject_liveliness_keys = exports.construct_source_liveliness_key = exports.construct_rpc_key = exports.construct_pubSub_key = void 0;
 const Envelope_1 = require("./Envelope");
 const subjects_json_1 = __importDefault(require("./subjects.json"));
 const interfaces_json_1 = __importDefault(require("./interfaces.json"));
@@ -73,6 +73,28 @@ function construct_source_liveliness_key(base_path, entityId, sourceId) {
     return `${base_path}/@v0/${entityId}/*/${sourceId}`;
 }
 exports.construct_source_liveliness_key = construct_source_liveliness_key;
+function construct_pubsub_subject_liveliness_keys(base_path, entityId, subject, sourceId, targeted = false) {
+    /**
+     * Construct the subject-level liveliness token key(s) for one subject.
+     *
+     * One key normally. Two for a source that publishes about OTHER
+     * entities — an AIS, TAK or track source — the second carrying the
+     * bare `@target` chunk. Both are declared, never one: `@target` is a
+     * verbatim chunk no wildcard crosses, so a source holding only the
+     * target form is invisible to every existing discovery query, while a
+     * source holding only the plain form advertises a key it never writes
+     * a sample to. See §5.2 of the protocol specification.
+     *
+     * The target form is the plain key plus `@target`, a strict prefix of
+     * every key published about a target, with no target id and no
+     * wildcard: a `*` in a declared token acts as a pattern and would
+     * answer a query for any concrete target. A target producer commits to
+     * subjects, never to a roster of targets, so there is no per-target token.
+     */
+    const plain = construct_pubSub_key(base_path, entityId, subject, sourceId);
+    return targeted ? [plain, `${plain}/@target`] : [plain];
+}
+exports.construct_pubsub_subject_liveliness_keys = construct_pubsub_subject_liveliness_keys;
 function construct_rpc_interface_liveliness_key(base_path, entityId, iface, version, sourceId) {
     /**
      * Construct the liveliness token key for one served RPC

package/dist/index.test.js

@@ -216,3 +216,34 @@ describe("interface introspection", () => {
         expect(() => getProcedureCodecs("replay_control/v1", "warp")).toThrow();
     });
 });
+describe("construct_pubsub_subject_liveliness_keys", () => {
+    it("builds one key for a source publishing about itself", () => {
+        expect((0, index_1.construct_pubsub_subject_liveliness_keys)("realm", "boat", "location_fix", "gnss/0"))
+            .toStrictEqual(["realm/@v0/boat/pubsub/location_fix/gnss/0"]);
+    });
+    // Both forms, never one. `@target` is verbatim, so a source holding only
+    // the target form is invisible to every existing discovery query, and one
+    // holding only the plain form advertises a key it never writes to.
+    it("builds both keys for a source publishing about others", () => {
+        expect((0, index_1.construct_pubsub_subject_liveliness_keys)("realm", "shore", "location_fix", "ais", true))
+            .toStrictEqual([
+            "realm/@v0/shore/pubsub/location_fix/ais",
+            "realm/@v0/shore/pubsub/location_fix/ais/@target",
+        ]);
+    });
+    // The target form is a chunk-boundary prefix of every published target
+    // key, so the token cannot drift from the data it advertises.
+    it("is a strict prefix of a published target key", () => {
+        const [, token] = (0, index_1.construct_pubsub_subject_liveliness_keys)("rise", "maritimedb", "name", "srv-herakles/sjofartsverket", true);
+        const published = (0, index_1.construct_pubSub_key)("rise", "maritimedb", "name", "srv-herakles/sjofartsverket", "mmsi_245060000");
+        expect(published.startsWith(`${token}/`)).toBe(true);
+    });
+    // Not hypothetical: maritimedb publishes AIS under this source id.
+    it("keeps a multi-level source id intact", () => {
+        expect((0, index_1.construct_pubsub_subject_liveliness_keys)("rise", "maritimedb", "name", "srv-herakles/sjofartsverket", true))
+            .toStrictEqual([
+            "rise/@v0/maritimedb/pubsub/name/srv-herakles/sjofartsverket",
+            "rise/@v0/maritimedb/pubsub/name/srv-herakles/sjofartsverket/@target",
+        ]);
+    });
+});

package/dist/interfaces/AlarmAck.d.ts

@@ -1,5 +1,5 @@
 import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
-export declare const protobufPackage = "";
+export declare const protobufPackage = "keelson.interfaces.alarm_ack";
 export interface AcknowledgeAlarmRequest {
     /** Client wall-clock at send, so the responder can log round-trip latency. */
     timestamp: Date | undefined;
@@ -29,7 +29,7 @@ export declare const AcknowledgeAlarmResponse: MessageFns<AcknowledgeAlarmRespon
 export type AlarmAckDefinition = typeof AlarmAckDefinition;
 export declare const AlarmAckDefinition: {
     readonly name: "AlarmAck";
-    readonly fullName: "AlarmAck";
+    readonly fullName: "keelson.interfaces.alarm_ack.AlarmAck";
     readonly methods: {
         readonly acknowledge_alarm: {
             readonly name: "acknowledge_alarm";

package/dist/interfaces/AlarmAck.js

@@ -9,7 +9,7 @@ exports.AlarmAckDefinition = exports.AcknowledgeAlarmResponse = exports.Acknowle
 /* eslint-disable */
 const wire_1 = require("@bufbuild/protobuf/wire");
 const timestamp_1 = require("./google/protobuf/timestamp");
-exports.protobufPackage = "";
+exports.protobufPackage = "keelson.interfaces.alarm_ack";
 function createBaseAcknowledgeAlarmRequest() {
     return { timestamp: undefined, identifier: "", acknowledgedBy: "" };
 }
@@ -180,7 +180,7 @@ exports.AcknowledgeAlarmResponse = {
 };
 exports.AlarmAckDefinition = {
     name: "AlarmAck",
-    fullName: "AlarmAck",
+    fullName: "keelson.interfaces.alarm_ack.AlarmAck",
     methods: {
         acknowledge_alarm: {
             name: "acknowledge_alarm",

package/dist/interfaces/ContainerControl.d.ts

@@ -0,0 +1,239 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { ContainerInfo } from "./ContainerHost";
+export declare const protobufPackage = "keelson.interfaces.container_control";
+/**
+ * Which stream one log line came from. UNSPECIFIED is the honest answer for a
+ * TTY-allocated container, whose streams are merged before the runtime sees them
+ * and cannot be separated after the fact.
+ */
+export declare enum LogStream {
+    LOG_STREAM_UNSPECIFIED = 0,
+    LOG_STREAM_STDOUT = 1,
+    LOG_STREAM_STDERR = 2,
+    UNRECOGNIZED = -1
+}
+export declare function logStreamFromJSON(object: any): LogStream;
+export declare function logStreamToJSON(object: LogStream): string;
+/**
+ * Which streams a caller wants back. Separate from LogStream so the zero value
+ * can mean "both" on the request side without meaning "both" on a line.
+ */
+export declare enum LogStreamSelector {
+    /** LOG_STREAM_SELECTOR_UNSPECIFIED - both */
+    LOG_STREAM_SELECTOR_UNSPECIFIED = 0,
+    LOG_STREAM_SELECTOR_STDOUT = 1,
+    LOG_STREAM_SELECTOR_STDERR = 2,
+    LOG_STREAM_SELECTOR_BOTH = 3,
+    UNRECOGNIZED = -1
+}
+export declare function logStreamSelectorFromJSON(object: any): LogStreamSelector;
+export declare function logStreamSelectorToJSON(object: LogStreamSelector): string;
+export interface ListContainersRequest {
+    /**
+     * Default (false) returns every container including stopped ones -- a client
+     * cannot offer "start" for a container it was never told about.
+     */
+    runningOnly: boolean;
+    /** Optional shell-style glob against ContainerInfo.name. Empty matches all. */
+    nameGlob: string;
+}
+export interface ListContainersResponse {
+    containers: ContainerInfo[];
+    /** When the responder read the runtime's state. */
+    observedAt: Date | undefined;
+    /**
+     * False when this responder is read-only: every start/stop/restart on it will
+     * reply PERMISSION_DENIED regardless of which container is named.
+     */
+    controlEnabled: boolean;
+    /**
+     * False when this responder will remove nothing: every `remove` on it will
+     * reply PERMISSION_DENIED regardless of which container is named. Read
+     * INDEPENDENTLY of control_enabled -- neither implies the other, and the
+     * common configuration is control_enabled true with this false.
+     */
+    removeEnabled: boolean;
+}
+export interface GetLogsRequest {
+    name: string;
+    /**
+     * Lines from the end of the log. 0 selects the responder's default; values
+     * above its ceiling are clamped, and the effective value comes back in
+     * GetLogsResponse.tail_lines rather than erroring.
+     */
+    tailLines: number;
+    /** Optional: only lines at or after this instant. */
+    since: Date | undefined;
+    stream: LogStreamSelector;
+}
+export interface LogLine {
+    /** Unset when the runtime emitted no parseable timestamp for the line. */
+    time: Date | undefined;
+    stream: LogStream;
+    text: string;
+}
+export interface GetLogsResponse {
+    name: string;
+    id: string;
+    lines: LogLine[];
+    /**
+     * True when the responder dropped lines to stay under its byte ceiling. The
+     * OLDEST lines are dropped, so `lines` is always the most recent window.
+     */
+    truncated: boolean;
+    /** The tail_lines the responder actually applied after defaulting/clamping. */
+    tailLines: number;
+}
+export interface StartContainerRequest {
+    name: string;
+}
+export interface StopContainerRequest {
+    name: string;
+    /** Grace period before SIGKILL. 0 selects the responder's default. */
+    timeoutS: number;
+}
+export interface RestartContainerRequest {
+    name: string;
+    timeoutS: number;
+}
+/**
+ * Shared by start, stop and restart. Carries the container's state AFTER the
+ * operation, so a client does not have to follow every action with a `list` and
+ * race the runtime for the answer. All three are idempotent: starting a running
+ * container or stopping a stopped one succeeds and returns its unchanged state.
+ */
+export interface ContainerActionResponse {
+    container: ContainerInfo | undefined;
+}
+export interface RemoveContainerRequest {
+    name: string;
+    /**
+     * Remove a RUNNING container, killing it first. Default (false) makes a
+     * running container reply ErrorResponse.INVALID_STATE naming the stop it
+     * needs, rather than taking a vessel's connector off the air because a click
+     * landed one row lower than the operator meant. An operator who does mean it
+     * says so in a second call, which is the point: the confirmation lives in the
+     * protocol rather than only in whichever UI happens to be in front of them.
+     */
+    force: boolean;
+    /**
+     * Also delete the ANONYMOUS volumes this container owns. Named volumes are
+     * never touched by this and a responder must not offer to: they outlive the
+     * container by definition and are shared with whatever else mounts them, so
+     * removing one on a container's behalf destroys data nobody asked about.
+     * Default (false) leaves even the anonymous ones behind -- reclaiming disk is
+     * a deliberate act, not a side effect of tidying a container list.
+     */
+    removeVolumes: boolean;
+}
+/**
+ * NOT ContainerActionResponse, deliberately. That message carries the
+ * container's state AFTER the operation, which is the one thing removal does
+ * not leave behind: there is nothing to re-read, and a ContainerInfo describing
+ * a container that no longer exists is a falsehood a client would render as a
+ * perfectly ordinary row. This says what went away, and stops.
+ */
+export interface RemoveContainerResponse {
+    /**
+     * Echoed from the request, so a client with several calls in flight can tell
+     * the replies apart.
+     */
+    name: string;
+    /**
+     * The id the container had at the moment it was removed, for correlating with
+     * the `list` the caller was looking at. Nothing resolves it any more.
+     */
+    id: string;
+    /**
+     * True when the container was running on arrival and `force` killed it. The
+     * ordinary path -- removing something already stopped -- reports false, so an
+     * operator can tell "I tidied up an exited container" from "I took a running
+     * one down", after the fact, from the reply alone.
+     */
+    forceApplied: boolean;
+}
+export declare const ListContainersRequest: MessageFns<ListContainersRequest>;
+export declare const ListContainersResponse: MessageFns<ListContainersResponse>;
+export declare const GetLogsRequest: MessageFns<GetLogsRequest>;
+export declare const LogLine: MessageFns<LogLine>;
+export declare const GetLogsResponse: MessageFns<GetLogsResponse>;
+export declare const StartContainerRequest: MessageFns<StartContainerRequest>;
+export declare const StopContainerRequest: MessageFns<StopContainerRequest>;
+export declare const RestartContainerRequest: MessageFns<RestartContainerRequest>;
+export declare const ContainerActionResponse: MessageFns<ContainerActionResponse>;
+export declare const RemoveContainerRequest: MessageFns<RemoveContainerRequest>;
+export declare const RemoveContainerResponse: MessageFns<RemoveContainerResponse>;
+export type ContainerControlDefinition = typeof ContainerControlDefinition;
+export declare const ContainerControlDefinition: {
+    readonly name: "ContainerControl";
+    readonly fullName: "keelson.interfaces.container_control.ContainerControl";
+    readonly methods: {
+        readonly list: {
+            readonly name: "list";
+            readonly requestType: MessageFns<ListContainersRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns<ListContainersResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly logs: {
+            readonly name: "logs";
+            readonly requestType: MessageFns<GetLogsRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns<GetLogsResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly start: {
+            readonly name: "start";
+            readonly requestType: MessageFns<StartContainerRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns<ContainerActionResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly stop: {
+            readonly name: "stop";
+            readonly requestType: MessageFns<StopContainerRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns<ContainerActionResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly restart: {
+            readonly name: "restart";
+            readonly requestType: MessageFns<RestartContainerRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns<ContainerActionResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly remove: {
+            readonly name: "remove";
+            readonly requestType: MessageFns<RemoveContainerRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns<RemoveContainerResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export 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 keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export 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>>]: never;
+};
+export interface MessageFns<T> {
+    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 {};