@rise-maritime/keelson-js 0.6.0-pre.3 → 0.6.0-pre.4

package/dist/payloads/OperationalAuthority.d.ts

@@ -40,8 +40,14 @@ export interface OperationalAuthority {
      * diagnostic subjects a source happens to publish is not a safety weight.
      * Deliberately left uncapped: overwriting it when an essential component
      * fails would falsely report that all monitored health had failed.
+     *
+     * `optional` because not every policy publishing on this subject scores:
+     * a policy that derives `level` from claim standings rather than from a
+     * score (see the warrant_aggregator connector) publishes no
+     * composite_score at all, and its absence must be distinguishable from
+     * 0.0, which asserts that all monitored health failed.
      */
-    compositeScore: number;
+    compositeScore?: number | undefined;
     /**
      * Human-readable explanation. For operators and logs only — consumers
      * MUST NOT parse this. Everything it says is available structurally in

package/dist/payloads/OperationalAuthority.js

@@ -150,7 +150,7 @@ function createBaseOperationalAuthority() {
         $type: "keelson.OperationalAuthority",
         timestamp: undefined,
         level: 0,
-        compositeScore: 0,
+        compositeScore: undefined,
         reason: "",
         componentScores: {},
         authorityScore: undefined,
@@ -169,7 +169,7 @@ exports.OperationalAuthority = {
         if (message.level !== 0) {
             writer.uint32(16).int32(message.level);
         }
-        if (message.compositeScore !== 0) {
+        if (message.compositeScore !== undefined) {
             writer.uint32(29).float(message.compositeScore);
         }
         if (message.reason !== "") {
@@ -292,7 +292,7 @@ exports.OperationalAuthority = {
             $type: exports.OperationalAuthority.$type,
             timestamp: isSet(object.timestamp) ? fromJsonTimestamp(object.timestamp) : undefined,
             level: isSet(object.level) ? operationalAuthority_AuthorityLevelFromJSON(object.level) : 0,
-            compositeScore: isSet(object.compositeScore) ? globalThis.Number(object.compositeScore) : 0,
+            compositeScore: isSet(object.compositeScore) ? globalThis.Number(object.compositeScore) : undefined,
             reason: isSet(object.reason) ? globalThis.String(object.reason) : "",
             componentScores: isObject(object.componentScores)
                 ? Object.entries(object.componentScores).reduce((acc, [key, value]) => {
@@ -319,7 +319,7 @@ exports.OperationalAuthority = {
         if (message.level !== 0) {
             obj.level = operationalAuthority_AuthorityLevelToJSON(message.level);
         }
-        if (message.compositeScore !== 0) {
+        if (message.compositeScore !== undefined) {
             obj.compositeScore = message.compositeScore;
         }
         if (message.reason !== "") {
@@ -358,7 +358,7 @@ exports.OperationalAuthority = {
         const message = createBaseOperationalAuthority();
         message.timestamp = object.timestamp ?? undefined;
         message.level = object.level ?? 0;
-        message.compositeScore = object.compositeScore ?? 0;
+        message.compositeScore = object.compositeScore ?? undefined;
         message.reason = object.reason ?? "";
         message.componentScores = Object.entries(object.componentScores ?? {}).reduce((acc, [key, value]) => {
             if (value !== undefined) {

package/dist/payloads/WarrantRecord.d.ts

@@ -0,0 +1,133 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+/**
+ * WarrantRecord is the append-only audit stream for claim standings: the
+ * record of why a conclusion held, weakened or lapsed, produced by any
+ * evaluator aboard that maintains justification for its conclusions. The
+ * warrant_aggregator connector is its first producer; the subject is
+ * deliberately producer-neutral and the source_id names the evaluator:
+ *
+ *   {base_path}/@v0/{entity_id}/pubsub/warrant_record/{source_id}
+ *
+ * so the entity's entire justification record is one subject family and an
+ * auditor or recorder watches one place, however many evaluators run.
+ *
+ * This stream is a reconstruction artifact, never a control input:
+ * statements, warrants, backing and evidence are strings by design, and
+ * consumers that act on determinations use the typed subjects the producing
+ * evaluator also publishes (the warrant_aggregator publishes
+ * operational_authority). Durability is a router storage_manager
+ * responsibility, not a payload one (protocol-specification.md section 6.3).
+ * Events are immutable once published: any future attestation must sign the
+ * stored Envelope bytes, never re-serialized state (section 6.3.1).
+ */
+export interface WarrantRecord {
+    $type: "keelson.WarrantRecord";
+    /** The source timestamp of the event. */
+    timestamp: Date | undefined;
+    standingTransition?: WarrantRecord_StandingTransition | undefined;
+    snapshot?: WarrantRecord_Snapshot | undefined;
+}
+/**
+ * The standing of a claim. Every claim starts WITHDRAWN: standing must
+ * be positively established, and absence of evidence counts against a
+ * claim, never for it.
+ */
+export declare enum WarrantRecord_Standing {
+    STANDING_UNSPECIFIED = 0,
+    STANDING_WITHDRAWN = 1,
+    STANDING_WEAKENED = 2,
+    STANDING_LICENSED = 3,
+    UNRECOGNIZED = -1
+}
+export declare function warrantRecord_StandingFromJSON(object: any): WarrantRecord_Standing;
+export declare function warrantRecord_StandingToJSON(object: WarrantRecord_Standing): string;
+/** A rebuttal condition that fired, with the evidence that fired it. */
+export interface WarrantRecord_RebuttalFired {
+    $type: "keelson.WarrantRecord.RebuttalFired";
+    id: string;
+    description: string;
+    /** Human-readable rendering of the evidence at firing time. */
+    evidence: string;
+    /**
+     * The health level of the evidence when determinable (the
+     * HealthLevel enum name from EntityHealth.proto), empty when the
+     * rebuttal fired on absence of evidence.
+     */
+    evidenceLevel: string;
+}
+/** The standing of one ground at evaluation time. */
+export interface WarrantRecord_GroundStanding {
+    $type: "keelson.WarrantRecord.GroundStanding";
+    claimId: string;
+    standing: WarrantRecord_Standing;
+}
+/**
+ * One claim changed standing. Lean by design: justification prose lives
+ * in the periodic Snapshot, which makes the stream self-contained.
+ */
+export interface WarrantRecord_StandingTransition {
+    $type: "keelson.WarrantRecord.StandingTransition";
+    claimId: string;
+    fromStanding: WarrantRecord_Standing;
+    toStanding: WarrantRecord_Standing;
+    rebuttalsFired: WarrantRecord_RebuttalFired[];
+    grounds: WarrantRecord_GroundStanding[];
+}
+/** The full state of one claim, carried in snapshots. */
+export interface WarrantRecord_ClaimState {
+    $type: "keelson.WarrantRecord.ClaimState";
+    claimId: string;
+    standing: WarrantRecord_Standing;
+    since: Date | undefined;
+    rebuttalsFired: WarrantRecord_RebuttalFired[];
+    grounds: WarrantRecord_GroundStanding[];
+    /**
+     * The configured justification, carried for legibility so the
+     * stream reconstructs without access to the evaluator's config.
+     */
+    statement: string;
+    warrant: string;
+    backing: string;
+}
+/**
+ * Periodic full state, so reconstruction needs only the stream: the
+ * state at any instant is the latest snapshot at or before it plus the
+ * transitions since.
+ */
+export interface WarrantRecord_Snapshot {
+    $type: "keelson.WarrantRecord.Snapshot";
+    claims: WarrantRecord_ClaimState[];
+    /**
+     * Identify the evaluator policy and configuration that produced
+     * this state, for replay and audit (same convention as
+     * OperationalAuthority).
+     */
+    policyConfigDigest?: Uint8Array | undefined;
+    policyId?: string | undefined;
+}
+export declare const WarrantRecord: MessageFns<WarrantRecord, "keelson.WarrantRecord">;
+export declare const WarrantRecord_RebuttalFired: MessageFns<WarrantRecord_RebuttalFired, "keelson.WarrantRecord.RebuttalFired">;
+export declare const WarrantRecord_GroundStanding: MessageFns<WarrantRecord_GroundStanding, "keelson.WarrantRecord.GroundStanding">;
+export declare const WarrantRecord_StandingTransition: MessageFns<WarrantRecord_StandingTransition, "keelson.WarrantRecord.StandingTransition">;
+export declare const WarrantRecord_ClaimState: MessageFns<WarrantRecord_ClaimState, "keelson.WarrantRecord.ClaimState">;
+export declare const WarrantRecord_Snapshot: MessageFns<WarrantRecord_Snapshot, "keelson.WarrantRecord.Snapshot">;
+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 {};

package/dist/payloads/WarrantRecord.js

@@ -0,0 +1,765 @@
+"use strict";
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.6.1
+//   protoc               v6.30.2
+// source: WarrantRecord.proto
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WarrantRecord_Snapshot = exports.WarrantRecord_ClaimState = exports.WarrantRecord_StandingTransition = exports.WarrantRecord_GroundStanding = exports.WarrantRecord_RebuttalFired = exports.WarrantRecord = exports.warrantRecord_StandingToJSON = exports.warrantRecord_StandingFromJSON = exports.WarrantRecord_Standing = void 0;
+/* eslint-disable */
+const wire_1 = require("@bufbuild/protobuf/wire");
+const timestamp_1 = require("./google/protobuf/timestamp");
+const typeRegistry_1 = require("./typeRegistry");
+/**
+ * The standing of a claim. Every claim starts WITHDRAWN: standing must
+ * be positively established, and absence of evidence counts against a
+ * claim, never for it.
+ */
+var WarrantRecord_Standing;
+(function (WarrantRecord_Standing) {
+    WarrantRecord_Standing[WarrantRecord_Standing["STANDING_UNSPECIFIED"] = 0] = "STANDING_UNSPECIFIED";
+    WarrantRecord_Standing[WarrantRecord_Standing["STANDING_WITHDRAWN"] = 1] = "STANDING_WITHDRAWN";
+    WarrantRecord_Standing[WarrantRecord_Standing["STANDING_WEAKENED"] = 2] = "STANDING_WEAKENED";
+    WarrantRecord_Standing[WarrantRecord_Standing["STANDING_LICENSED"] = 3] = "STANDING_LICENSED";
+    WarrantRecord_Standing[WarrantRecord_Standing["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(WarrantRecord_Standing || (exports.WarrantRecord_Standing = WarrantRecord_Standing = {}));
+function warrantRecord_StandingFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "STANDING_UNSPECIFIED":
+            return WarrantRecord_Standing.STANDING_UNSPECIFIED;
+        case 1:
+        case "STANDING_WITHDRAWN":
+            return WarrantRecord_Standing.STANDING_WITHDRAWN;
+        case 2:
+        case "STANDING_WEAKENED":
+            return WarrantRecord_Standing.STANDING_WEAKENED;
+        case 3:
+        case "STANDING_LICENSED":
+            return WarrantRecord_Standing.STANDING_LICENSED;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return WarrantRecord_Standing.UNRECOGNIZED;
+    }
+}
+exports.warrantRecord_StandingFromJSON = warrantRecord_StandingFromJSON;
+function warrantRecord_StandingToJSON(object) {
+    switch (object) {
+        case WarrantRecord_Standing.STANDING_UNSPECIFIED:
+            return "STANDING_UNSPECIFIED";
+        case WarrantRecord_Standing.STANDING_WITHDRAWN:
+            return "STANDING_WITHDRAWN";
+        case WarrantRecord_Standing.STANDING_WEAKENED:
+            return "STANDING_WEAKENED";
+        case WarrantRecord_Standing.STANDING_LICENSED:
+            return "STANDING_LICENSED";
+        case WarrantRecord_Standing.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+exports.warrantRecord_StandingToJSON = warrantRecord_StandingToJSON;
+function createBaseWarrantRecord() {
+    return { $type: "keelson.WarrantRecord", timestamp: undefined, standingTransition: undefined, snapshot: undefined };
+}
+exports.WarrantRecord = {
+    $type: "keelson.WarrantRecord",
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.timestamp !== undefined) {
+            timestamp_1.Timestamp.encode(toTimestamp(message.timestamp), writer.uint32(10).fork()).join();
+        }
+        if (message.standingTransition !== undefined) {
+            exports.WarrantRecord_StandingTransition.encode(message.standingTransition, writer.uint32(18).fork()).join();
+        }
+        if (message.snapshot !== undefined) {
+            exports.WarrantRecord_Snapshot.encode(message.snapshot, writer.uint32(26).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 = createBaseWarrantRecord();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.timestamp = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.standingTransition = exports.WarrantRecord_StandingTransition.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.snapshot = exports.WarrantRecord_Snapshot.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            $type: exports.WarrantRecord.$type,
+            timestamp: isSet(object.timestamp) ? fromJsonTimestamp(object.timestamp) : undefined,
+            standingTransition: isSet(object.standingTransition)
+                ? exports.WarrantRecord_StandingTransition.fromJSON(object.standingTransition)
+                : undefined,
+            snapshot: isSet(object.snapshot) ? exports.WarrantRecord_Snapshot.fromJSON(object.snapshot) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.timestamp !== undefined) {
+            obj.timestamp = message.timestamp.toISOString();
+        }
+        if (message.standingTransition !== undefined) {
+            obj.standingTransition = exports.WarrantRecord_StandingTransition.toJSON(message.standingTransition);
+        }
+        if (message.snapshot !== undefined) {
+            obj.snapshot = exports.WarrantRecord_Snapshot.toJSON(message.snapshot);
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.WarrantRecord.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseWarrantRecord();
+        message.timestamp = object.timestamp ?? undefined;
+        message.standingTransition = (object.standingTransition !== undefined && object.standingTransition !== null)
+            ? exports.WarrantRecord_StandingTransition.fromPartial(object.standingTransition)
+            : undefined;
+        message.snapshot = (object.snapshot !== undefined && object.snapshot !== null)
+            ? exports.WarrantRecord_Snapshot.fromPartial(object.snapshot)
+            : undefined;
+        return message;
+    },
+};
+typeRegistry_1.messageTypeRegistry.set(exports.WarrantRecord.$type, exports.WarrantRecord);
+function createBaseWarrantRecord_RebuttalFired() {
+    return { $type: "keelson.WarrantRecord.RebuttalFired", id: "", description: "", evidence: "", evidenceLevel: "" };
+}
+exports.WarrantRecord_RebuttalFired = {
+    $type: "keelson.WarrantRecord.RebuttalFired",
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.id !== "") {
+            writer.uint32(10).string(message.id);
+        }
+        if (message.description !== "") {
+            writer.uint32(18).string(message.description);
+        }
+        if (message.evidence !== "") {
+            writer.uint32(26).string(message.evidence);
+        }
+        if (message.evidenceLevel !== "") {
+            writer.uint32(34).string(message.evidenceLevel);
+        }
+        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 = createBaseWarrantRecord_RebuttalFired();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.id = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.description = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.evidence = reader.string();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.evidenceLevel = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            $type: exports.WarrantRecord_RebuttalFired.$type,
+            id: isSet(object.id) ? globalThis.String(object.id) : "",
+            description: isSet(object.description) ? globalThis.String(object.description) : "",
+            evidence: isSet(object.evidence) ? globalThis.String(object.evidence) : "",
+            evidenceLevel: isSet(object.evidenceLevel) ? globalThis.String(object.evidenceLevel) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.id !== "") {
+            obj.id = message.id;
+        }
+        if (message.description !== "") {
+            obj.description = message.description;
+        }
+        if (message.evidence !== "") {
+            obj.evidence = message.evidence;
+        }
+        if (message.evidenceLevel !== "") {
+            obj.evidenceLevel = message.evidenceLevel;
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.WarrantRecord_RebuttalFired.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseWarrantRecord_RebuttalFired();
+        message.id = object.id ?? "";
+        message.description = object.description ?? "";
+        message.evidence = object.evidence ?? "";
+        message.evidenceLevel = object.evidenceLevel ?? "";
+        return message;
+    },
+};
+typeRegistry_1.messageTypeRegistry.set(exports.WarrantRecord_RebuttalFired.$type, exports.WarrantRecord_RebuttalFired);
+function createBaseWarrantRecord_GroundStanding() {
+    return { $type: "keelson.WarrantRecord.GroundStanding", claimId: "", standing: 0 };
+}
+exports.WarrantRecord_GroundStanding = {
+    $type: "keelson.WarrantRecord.GroundStanding",
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.claimId !== "") {
+            writer.uint32(10).string(message.claimId);
+        }
+        if (message.standing !== 0) {
+            writer.uint32(16).int32(message.standing);
+        }
+        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 = createBaseWarrantRecord_GroundStanding();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.claimId = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.standing = reader.int32();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            $type: exports.WarrantRecord_GroundStanding.$type,
+            claimId: isSet(object.claimId) ? globalThis.String(object.claimId) : "",
+            standing: isSet(object.standing) ? warrantRecord_StandingFromJSON(object.standing) : 0,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.claimId !== "") {
+            obj.claimId = message.claimId;
+        }
+        if (message.standing !== 0) {
+            obj.standing = warrantRecord_StandingToJSON(message.standing);
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.WarrantRecord_GroundStanding.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseWarrantRecord_GroundStanding();
+        message.claimId = object.claimId ?? "";
+        message.standing = object.standing ?? 0;
+        return message;
+    },
+};
+typeRegistry_1.messageTypeRegistry.set(exports.WarrantRecord_GroundStanding.$type, exports.WarrantRecord_GroundStanding);
+function createBaseWarrantRecord_StandingTransition() {
+    return {
+        $type: "keelson.WarrantRecord.StandingTransition",
+        claimId: "",
+        fromStanding: 0,
+        toStanding: 0,
+        rebuttalsFired: [],
+        grounds: [],
+    };
+}
+exports.WarrantRecord_StandingTransition = {
+    $type: "keelson.WarrantRecord.StandingTransition",
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.claimId !== "") {
+            writer.uint32(10).string(message.claimId);
+        }
+        if (message.fromStanding !== 0) {
+            writer.uint32(16).int32(message.fromStanding);
+        }
+        if (message.toStanding !== 0) {
+            writer.uint32(24).int32(message.toStanding);
+        }
+        for (const v of message.rebuttalsFired) {
+            exports.WarrantRecord_RebuttalFired.encode(v, writer.uint32(34).fork()).join();
+        }
+        for (const v of message.grounds) {
+            exports.WarrantRecord_GroundStanding.encode(v, writer.uint32(42).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 = createBaseWarrantRecord_StandingTransition();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.claimId = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.fromStanding = reader.int32();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.toStanding = reader.int32();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.rebuttalsFired.push(exports.WarrantRecord_RebuttalFired.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.grounds.push(exports.WarrantRecord_GroundStanding.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            $type: exports.WarrantRecord_StandingTransition.$type,
+            claimId: isSet(object.claimId) ? globalThis.String(object.claimId) : "",
+            fromStanding: isSet(object.fromStanding) ? warrantRecord_StandingFromJSON(object.fromStanding) : 0,
+            toStanding: isSet(object.toStanding) ? warrantRecord_StandingFromJSON(object.toStanding) : 0,
+            rebuttalsFired: globalThis.Array.isArray(object?.rebuttalsFired)
+                ? object.rebuttalsFired.map((e) => exports.WarrantRecord_RebuttalFired.fromJSON(e))
+                : [],
+            grounds: globalThis.Array.isArray(object?.grounds)
+                ? object.grounds.map((e) => exports.WarrantRecord_GroundStanding.fromJSON(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.claimId !== "") {
+            obj.claimId = message.claimId;
+        }
+        if (message.fromStanding !== 0) {
+            obj.fromStanding = warrantRecord_StandingToJSON(message.fromStanding);
+        }
+        if (message.toStanding !== 0) {
+            obj.toStanding = warrantRecord_StandingToJSON(message.toStanding);
+        }
+        if (message.rebuttalsFired?.length) {
+            obj.rebuttalsFired = message.rebuttalsFired.map((e) => exports.WarrantRecord_RebuttalFired.toJSON(e));
+        }
+        if (message.grounds?.length) {
+            obj.grounds = message.grounds.map((e) => exports.WarrantRecord_GroundStanding.toJSON(e));
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.WarrantRecord_StandingTransition.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseWarrantRecord_StandingTransition();
+        message.claimId = object.claimId ?? "";
+        message.fromStanding = object.fromStanding ?? 0;
+        message.toStanding = object.toStanding ?? 0;
+        message.rebuttalsFired = object.rebuttalsFired?.map((e) => exports.WarrantRecord_RebuttalFired.fromPartial(e)) || [];
+        message.grounds = object.grounds?.map((e) => exports.WarrantRecord_GroundStanding.fromPartial(e)) || [];
+        return message;
+    },
+};
+typeRegistry_1.messageTypeRegistry.set(exports.WarrantRecord_StandingTransition.$type, exports.WarrantRecord_StandingTransition);
+function createBaseWarrantRecord_ClaimState() {
+    return {
+        $type: "keelson.WarrantRecord.ClaimState",
+        claimId: "",
+        standing: 0,
+        since: undefined,
+        rebuttalsFired: [],
+        grounds: [],
+        statement: "",
+        warrant: "",
+        backing: "",
+    };
+}
+exports.WarrantRecord_ClaimState = {
+    $type: "keelson.WarrantRecord.ClaimState",
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.claimId !== "") {
+            writer.uint32(10).string(message.claimId);
+        }
+        if (message.standing !== 0) {
+            writer.uint32(16).int32(message.standing);
+        }
+        if (message.since !== undefined) {
+            timestamp_1.Timestamp.encode(toTimestamp(message.since), writer.uint32(26).fork()).join();
+        }
+        for (const v of message.rebuttalsFired) {
+            exports.WarrantRecord_RebuttalFired.encode(v, writer.uint32(34).fork()).join();
+        }
+        for (const v of message.grounds) {
+            exports.WarrantRecord_GroundStanding.encode(v, writer.uint32(42).fork()).join();
+        }
+        if (message.statement !== "") {
+            writer.uint32(50).string(message.statement);
+        }
+        if (message.warrant !== "") {
+            writer.uint32(58).string(message.warrant);
+        }
+        if (message.backing !== "") {
+            writer.uint32(66).string(message.backing);
+        }
+        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 = createBaseWarrantRecord_ClaimState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.claimId = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.standing = reader.int32();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.since = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.rebuttalsFired.push(exports.WarrantRecord_RebuttalFired.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.grounds.push(exports.WarrantRecord_GroundStanding.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 6: {
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.statement = reader.string();
+                    continue;
+                }
+                case 7: {
+                    if (tag !== 58) {
+                        break;
+                    }
+                    message.warrant = reader.string();
+                    continue;
+                }
+                case 8: {
+                    if (tag !== 66) {
+                        break;
+                    }
+                    message.backing = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            $type: exports.WarrantRecord_ClaimState.$type,
+            claimId: isSet(object.claimId) ? globalThis.String(object.claimId) : "",
+            standing: isSet(object.standing) ? warrantRecord_StandingFromJSON(object.standing) : 0,
+            since: isSet(object.since) ? fromJsonTimestamp(object.since) : undefined,
+            rebuttalsFired: globalThis.Array.isArray(object?.rebuttalsFired)
+                ? object.rebuttalsFired.map((e) => exports.WarrantRecord_RebuttalFired.fromJSON(e))
+                : [],
+            grounds: globalThis.Array.isArray(object?.grounds)
+                ? object.grounds.map((e) => exports.WarrantRecord_GroundStanding.fromJSON(e))
+                : [],
+            statement: isSet(object.statement) ? globalThis.String(object.statement) : "",
+            warrant: isSet(object.warrant) ? globalThis.String(object.warrant) : "",
+            backing: isSet(object.backing) ? globalThis.String(object.backing) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.claimId !== "") {
+            obj.claimId = message.claimId;
+        }
+        if (message.standing !== 0) {
+            obj.standing = warrantRecord_StandingToJSON(message.standing);
+        }
+        if (message.since !== undefined) {
+            obj.since = message.since.toISOString();
+        }
+        if (message.rebuttalsFired?.length) {
+            obj.rebuttalsFired = message.rebuttalsFired.map((e) => exports.WarrantRecord_RebuttalFired.toJSON(e));
+        }
+        if (message.grounds?.length) {
+            obj.grounds = message.grounds.map((e) => exports.WarrantRecord_GroundStanding.toJSON(e));
+        }
+        if (message.statement !== "") {
+            obj.statement = message.statement;
+        }
+        if (message.warrant !== "") {
+            obj.warrant = message.warrant;
+        }
+        if (message.backing !== "") {
+            obj.backing = message.backing;
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.WarrantRecord_ClaimState.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseWarrantRecord_ClaimState();
+        message.claimId = object.claimId ?? "";
+        message.standing = object.standing ?? 0;
+        message.since = object.since ?? undefined;
+        message.rebuttalsFired = object.rebuttalsFired?.map((e) => exports.WarrantRecord_RebuttalFired.fromPartial(e)) || [];
+        message.grounds = object.grounds?.map((e) => exports.WarrantRecord_GroundStanding.fromPartial(e)) || [];
+        message.statement = object.statement ?? "";
+        message.warrant = object.warrant ?? "";
+        message.backing = object.backing ?? "";
+        return message;
+    },
+};
+typeRegistry_1.messageTypeRegistry.set(exports.WarrantRecord_ClaimState.$type, exports.WarrantRecord_ClaimState);
+function createBaseWarrantRecord_Snapshot() {
+    return { $type: "keelson.WarrantRecord.Snapshot", claims: [], policyConfigDigest: undefined, policyId: undefined };
+}
+exports.WarrantRecord_Snapshot = {
+    $type: "keelson.WarrantRecord.Snapshot",
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        for (const v of message.claims) {
+            exports.WarrantRecord_ClaimState.encode(v, writer.uint32(10).fork()).join();
+        }
+        if (message.policyConfigDigest !== undefined) {
+            writer.uint32(18).bytes(message.policyConfigDigest);
+        }
+        if (message.policyId !== undefined) {
+            writer.uint32(26).string(message.policyId);
+        }
+        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 = createBaseWarrantRecord_Snapshot();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.claims.push(exports.WarrantRecord_ClaimState.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.policyConfigDigest = reader.bytes();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.policyId = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            $type: exports.WarrantRecord_Snapshot.$type,
+            claims: globalThis.Array.isArray(object?.claims)
+                ? object.claims.map((e) => exports.WarrantRecord_ClaimState.fromJSON(e))
+                : [],
+            policyConfigDigest: isSet(object.policyConfigDigest) ? bytesFromBase64(object.policyConfigDigest) : undefined,
+            policyId: isSet(object.policyId) ? globalThis.String(object.policyId) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.claims?.length) {
+            obj.claims = message.claims.map((e) => exports.WarrantRecord_ClaimState.toJSON(e));
+        }
+        if (message.policyConfigDigest !== undefined) {
+            obj.policyConfigDigest = base64FromBytes(message.policyConfigDigest);
+        }
+        if (message.policyId !== undefined) {
+            obj.policyId = message.policyId;
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.WarrantRecord_Snapshot.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseWarrantRecord_Snapshot();
+        message.claims = object.claims?.map((e) => exports.WarrantRecord_ClaimState.fromPartial(e)) || [];
+        message.policyConfigDigest = object.policyConfigDigest ?? undefined;
+        message.policyId = object.policyId ?? undefined;
+        return message;
+    },
+};
+typeRegistry_1.messageTypeRegistry.set(exports.WarrantRecord_Snapshot.$type, exports.WarrantRecord_Snapshot);
+function bytesFromBase64(b64) {
+    if (globalThis.Buffer) {
+        return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
+    }
+    else {
+        const bin = globalThis.atob(b64);
+        const arr = new Uint8Array(bin.length);
+        for (let i = 0; i < bin.length; ++i) {
+            arr[i] = bin.charCodeAt(i);
+        }
+        return arr;
+    }
+}
+function base64FromBytes(arr) {
+    if (globalThis.Buffer) {
+        return globalThis.Buffer.from(arr).toString("base64");
+    }
+    else {
+        const bin = [];
+        arr.forEach((byte) => {
+            bin.push(globalThis.String.fromCharCode(byte));
+        });
+        return globalThis.btoa(bin.join(""));
+    }
+}
+function toTimestamp(date) {
+    const seconds = Math.trunc(date.getTime() / 1000);
+    const nanos = (date.getTime() % 1000) * 1000000;
+    return { $type: "google.protobuf.Timestamp", seconds, nanos };
+}
+function fromTimestamp(t) {
+    let millis = (t.seconds || 0) * 1000;
+    millis += (t.nanos || 0) / 1000000;
+    return new globalThis.Date(millis);
+}
+function fromJsonTimestamp(o) {
+    if (o instanceof globalThis.Date) {
+        return o;
+    }
+    else if (typeof o === "string") {
+        return new globalThis.Date(o);
+    }
+    else {
+        return fromTimestamp(timestamp_1.Timestamp.fromJSON(o));
+    }
+}
+function isSet(value) {
+    return value !== null && value !== undefined;
+}

package/dist/payloads/index.keelson.d.ts

@@ -27,4 +27,5 @@ export * from "./VehicleState";
 export * from "./VesselNavStatus";
 export * from "./VesselType";
 export * from "./Voyage";
+export * from "./WarrantRecord";
 export * from "./Weather";

package/dist/payloads/index.keelson.js

@@ -48,4 +48,5 @@ __exportStar(require("./VehicleState"), exports);
 __exportStar(require("./VesselNavStatus"), exports);
 __exportStar(require("./VesselType"), exports);
 __exportStar(require("./Voyage"), exports);
+__exportStar(require("./WarrantRecord"), exports);
 __exportStar(require("./Weather"), exports);

package/dist/qos.json

@@ -83,6 +83,7 @@
         "raw_lwe450": "background",
         "log_message": "background",
         "replay_status": "background",
-        "route_change_event": "background"
+        "route_change_event": "background",
+        "warrant_record": "background"
     }
 }

package/dist/subjects.json

@@ -13,6 +13,7 @@
     "roc_status": "keelson.ROCStatus",
     "operational_authority": "keelson.OperationalAuthority",
     "entity_health": "keelson.EntityHealth",
+    "warrant_record": "keelson.WarrantRecord",
     "test_object_status": "keelson.TestObjectStatus",
     "vehicle_mode": "keelson.TimestampedString",
     "vehicle_armed": "keelson.TimestampedBool",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rise-maritime/keelson-js",
   "//version": "NOT the published version. The release workflow overwrites it from the release tag (npm version --no-git-tag-version), so tag and artifact cannot disagree. Only matters for local installs; do not hand-bump before tagging — that manual step is what broke release 0.5.4.",
-  "version": "0.6.0-pre.3",
+  "version": "0.6.0-pre.4",
   "description": "Keelson JavaScript SDK with Node-RED nodes",
   "main": "dist/index.js",
   "files": [