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

package/dist/payloads/ScenarioEvent.js

@@ -0,0 +1,294 @@
+"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: ScenarioEvent.proto
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScenarioEvent_ParametersEntry = exports.ScenarioEvent = void 0;
+/* eslint-disable */
+const wire_1 = require("@bufbuild/protobuf/wire");
+const timestamp_1 = require("./google/protobuf/timestamp");
+const typeRegistry_1 = require("./typeRegistry");
+function createBaseScenarioEvent() {
+    return {
+        $type: "keelson.ScenarioEvent",
+        timestamp: undefined,
+        runId: "",
+        tick: 0,
+        action: "",
+        entityId: "",
+        parameters: {},
+        note: "",
+    };
+}
+exports.ScenarioEvent = {
+    $type: "keelson.ScenarioEvent",
+    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.runId !== "") {
+            writer.uint32(18).string(message.runId);
+        }
+        if (message.tick !== 0) {
+            writer.uint32(24).uint64(message.tick);
+        }
+        if (message.action !== "") {
+            writer.uint32(34).string(message.action);
+        }
+        if (message.entityId !== "") {
+            writer.uint32(42).string(message.entityId);
+        }
+        Object.entries(message.parameters).forEach(([key, value]) => {
+            exports.ScenarioEvent_ParametersEntry.encode({ $type: "keelson.ScenarioEvent.ParametersEntry", key: key, value }, writer.uint32(50).fork()).join();
+        });
+        if (message.note !== "") {
+            writer.uint32(58).string(message.note);
+        }
+        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 = createBaseScenarioEvent();
+        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.runId = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.tick = longToNumber(reader.uint64());
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.action = reader.string();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.entityId = reader.string();
+                    continue;
+                }
+                case 6: {
+                    if (tag !== 50) {
+                        break;
+                    }
+                    const entry6 = exports.ScenarioEvent_ParametersEntry.decode(reader, reader.uint32());
+                    if (entry6.value !== undefined) {
+                        message.parameters[entry6.key] = entry6.value;
+                    }
+                    continue;
+                }
+                case 7: {
+                    if (tag !== 58) {
+                        break;
+                    }
+                    message.note = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            $type: exports.ScenarioEvent.$type,
+            timestamp: isSet(object.timestamp) ? fromJsonTimestamp(object.timestamp) : undefined,
+            runId: isSet(object.runId) ? globalThis.String(object.runId) : "",
+            tick: isSet(object.tick) ? globalThis.Number(object.tick) : 0,
+            action: isSet(object.action) ? globalThis.String(object.action) : "",
+            entityId: isSet(object.entityId) ? globalThis.String(object.entityId) : "",
+            parameters: isObject(object.parameters)
+                ? Object.entries(object.parameters).reduce((acc, [key, value]) => {
+                    acc[key] = String(value);
+                    return acc;
+                }, {})
+                : {},
+            note: isSet(object.note) ? globalThis.String(object.note) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.timestamp !== undefined) {
+            obj.timestamp = message.timestamp.toISOString();
+        }
+        if (message.runId !== "") {
+            obj.runId = message.runId;
+        }
+        if (message.tick !== 0) {
+            obj.tick = Math.round(message.tick);
+        }
+        if (message.action !== "") {
+            obj.action = message.action;
+        }
+        if (message.entityId !== "") {
+            obj.entityId = message.entityId;
+        }
+        if (message.parameters) {
+            const entries = Object.entries(message.parameters);
+            if (entries.length > 0) {
+                obj.parameters = {};
+                entries.forEach(([k, v]) => {
+                    obj.parameters[k] = v;
+                });
+            }
+        }
+        if (message.note !== "") {
+            obj.note = message.note;
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.ScenarioEvent.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseScenarioEvent();
+        message.timestamp = object.timestamp ?? undefined;
+        message.runId = object.runId ?? "";
+        message.tick = object.tick ?? 0;
+        message.action = object.action ?? "";
+        message.entityId = object.entityId ?? "";
+        message.parameters = Object.entries(object.parameters ?? {}).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[key] = globalThis.String(value);
+            }
+            return acc;
+        }, {});
+        message.note = object.note ?? "";
+        return message;
+    },
+};
+typeRegistry_1.messageTypeRegistry.set(exports.ScenarioEvent.$type, exports.ScenarioEvent);
+function createBaseScenarioEvent_ParametersEntry() {
+    return { $type: "keelson.ScenarioEvent.ParametersEntry", key: "", value: "" };
+}
+exports.ScenarioEvent_ParametersEntry = {
+    $type: "keelson.ScenarioEvent.ParametersEntry",
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.key !== "") {
+            writer.uint32(10).string(message.key);
+        }
+        if (message.value !== "") {
+            writer.uint32(18).string(message.value);
+        }
+        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 = createBaseScenarioEvent_ParametersEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.key = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.value = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            $type: exports.ScenarioEvent_ParametersEntry.$type,
+            key: isSet(object.key) ? globalThis.String(object.key) : "",
+            value: isSet(object.value) ? globalThis.String(object.value) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.key !== "") {
+            obj.key = message.key;
+        }
+        if (message.value !== "") {
+            obj.value = message.value;
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.ScenarioEvent_ParametersEntry.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseScenarioEvent_ParametersEntry();
+        message.key = object.key ?? "";
+        message.value = object.value ?? "";
+        return message;
+    },
+};
+typeRegistry_1.messageTypeRegistry.set(exports.ScenarioEvent_ParametersEntry.$type, exports.ScenarioEvent_ParametersEntry);
+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 longToNumber(int64) {
+    const num = globalThis.Number(int64.toString());
+    if (num > globalThis.Number.MAX_SAFE_INTEGER) {
+        throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
+    }
+    if (num < globalThis.Number.MIN_SAFE_INTEGER) {
+        throw new globalThis.Error("Value is smaller than Number.MIN_SAFE_INTEGER");
+    }
+    return num;
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null;
+}
+function isSet(value) {
+    return value !== null && value !== undefined;
+}

package/dist/payloads/ScenarioTickAck.d.ts

@@ -0,0 +1,95 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+/**
+ * A participant telling the clock authority it has finished a tick.
+ *
+ * The other half of the barrier ScenarioStatus already describes. A
+ * ScenarioParticipant declares a Role and reports an acknowledged_tick, but
+ * that message is published *by the authority*, about the participant — there
+ * has been no way for the participant itself to say the thing the authority is
+ * reporting. Implementations have used a raw JSON subject for it.
+ *
+ * Publish one per tick, on the participant's own key. The entity and source
+ * are already in the key expression, so they are not repeated here: two places
+ * to say who acknowledged is two places for them to disagree.
+ */
+export interface ScenarioTickAck {
+    $type: "keelson.ScenarioTickAck";
+    /** Source timestamp: when the acknowledgement was produced. */
+    timestamp: Date | undefined;
+    /**
+     * The run and tick being acknowledged. run_id is not redundant: after a
+     * restore, a participant that is still running carries the old run's ticks
+     * in flight, and an ack matched on tick alone would satisfy the new run's
+     * barrier with the previous run's work.
+     */
+    runId: string;
+    tick: number;
+    disposition: ScenarioTickAck_Disposition;
+    /**
+     * Why, when disposition is SKIPPED or FAILED. Free text for an operator or
+     * a post-run report; empty otherwise.
+     */
+    detail: string;
+}
+/**
+ * What the participant did with this tick. A BLOCKING participant is
+ * expected to COMPLETE every one; a DECIMATING participant is explicitly
+ * permitted to skip work to keep up, and this is where it says so — a skip
+ * that looks identical to a completion on the wire makes the distinction
+ * ScenarioParticipant.Role draws unobservable.
+ */
+export declare enum ScenarioTickAck_Disposition {
+    /**
+     * DISPOSITION_UNKNOWN - Nothing said about what was done. Treated as COMPLETED: it is the ACK'S
+     * EXISTENCE that releases the barrier, and SKIPPED/FAILED refine what
+     * happened rather than change whether the tick was answered.
+     *
+     * Stated because it is the default, and every producer ported from the
+     * raw-JSON ack emits it until it is updated. Left unsaid, one
+     * implementation holds the barrier waiting for a disposition it will never
+     * get and another releases it, and both readings are defensible.
+     *
+     * The distinction that carries weight is an ack against SILENCE — silence
+     * is indistinguishable from a dead process, which is what FAILED exists to
+     * separate it from.
+     */
+    DISPOSITION_UNKNOWN = 0,
+    /** COMPLETED - The work for this tick is done. */
+    COMPLETED = 1,
+    /**
+     * SKIPPED - Deliberately did less than a full tick's work, and stayed causal.
+     * Not an error: the participant is keeping up as designed.
+     */
+    SKIPPED = 2,
+    /**
+     * FAILED - Could not do the work. The authority decides what that means for the
+     * run — a failed tick from a BLOCKING participant is a failed run, from a
+     * DECIMATING one it is a degraded one — but it must be able to tell this
+     * apart from silence, which is indistinguishable from a dead process.
+     */
+    FAILED = 3,
+    UNRECOGNIZED = -1
+}
+export declare function scenarioTickAck_DispositionFromJSON(object: any): ScenarioTickAck_Disposition;
+export declare function scenarioTickAck_DispositionToJSON(object: ScenarioTickAck_Disposition): string;
+export declare const ScenarioTickAck: MessageFns<ScenarioTickAck, "keelson.ScenarioTickAck">;
+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/ScenarioTickAck.js

@@ -0,0 +1,239 @@
+"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: ScenarioTickAck.proto
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScenarioTickAck = exports.scenarioTickAck_DispositionToJSON = exports.scenarioTickAck_DispositionFromJSON = exports.ScenarioTickAck_Disposition = void 0;
+/* eslint-disable */
+const wire_1 = require("@bufbuild/protobuf/wire");
+const timestamp_1 = require("./google/protobuf/timestamp");
+const typeRegistry_1 = require("./typeRegistry");
+/**
+ * What the participant did with this tick. A BLOCKING participant is
+ * expected to COMPLETE every one; a DECIMATING participant is explicitly
+ * permitted to skip work to keep up, and this is where it says so — a skip
+ * that looks identical to a completion on the wire makes the distinction
+ * ScenarioParticipant.Role draws unobservable.
+ */
+var ScenarioTickAck_Disposition;
+(function (ScenarioTickAck_Disposition) {
+    /**
+     * DISPOSITION_UNKNOWN - Nothing said about what was done. Treated as COMPLETED: it is the ACK'S
+     * EXISTENCE that releases the barrier, and SKIPPED/FAILED refine what
+     * happened rather than change whether the tick was answered.
+     *
+     * Stated because it is the default, and every producer ported from the
+     * raw-JSON ack emits it until it is updated. Left unsaid, one
+     * implementation holds the barrier waiting for a disposition it will never
+     * get and another releases it, and both readings are defensible.
+     *
+     * The distinction that carries weight is an ack against SILENCE — silence
+     * is indistinguishable from a dead process, which is what FAILED exists to
+     * separate it from.
+     */
+    ScenarioTickAck_Disposition[ScenarioTickAck_Disposition["DISPOSITION_UNKNOWN"] = 0] = "DISPOSITION_UNKNOWN";
+    /** COMPLETED - The work for this tick is done. */
+    ScenarioTickAck_Disposition[ScenarioTickAck_Disposition["COMPLETED"] = 1] = "COMPLETED";
+    /**
+     * SKIPPED - Deliberately did less than a full tick's work, and stayed causal.
+     * Not an error: the participant is keeping up as designed.
+     */
+    ScenarioTickAck_Disposition[ScenarioTickAck_Disposition["SKIPPED"] = 2] = "SKIPPED";
+    /**
+     * FAILED - Could not do the work. The authority decides what that means for the
+     * run — a failed tick from a BLOCKING participant is a failed run, from a
+     * DECIMATING one it is a degraded one — but it must be able to tell this
+     * apart from silence, which is indistinguishable from a dead process.
+     */
+    ScenarioTickAck_Disposition[ScenarioTickAck_Disposition["FAILED"] = 3] = "FAILED";
+    ScenarioTickAck_Disposition[ScenarioTickAck_Disposition["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(ScenarioTickAck_Disposition || (exports.ScenarioTickAck_Disposition = ScenarioTickAck_Disposition = {}));
+function scenarioTickAck_DispositionFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "DISPOSITION_UNKNOWN":
+            return ScenarioTickAck_Disposition.DISPOSITION_UNKNOWN;
+        case 1:
+        case "COMPLETED":
+            return ScenarioTickAck_Disposition.COMPLETED;
+        case 2:
+        case "SKIPPED":
+            return ScenarioTickAck_Disposition.SKIPPED;
+        case 3:
+        case "FAILED":
+            return ScenarioTickAck_Disposition.FAILED;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return ScenarioTickAck_Disposition.UNRECOGNIZED;
+    }
+}
+exports.scenarioTickAck_DispositionFromJSON = scenarioTickAck_DispositionFromJSON;
+function scenarioTickAck_DispositionToJSON(object) {
+    switch (object) {
+        case ScenarioTickAck_Disposition.DISPOSITION_UNKNOWN:
+            return "DISPOSITION_UNKNOWN";
+        case ScenarioTickAck_Disposition.COMPLETED:
+            return "COMPLETED";
+        case ScenarioTickAck_Disposition.SKIPPED:
+            return "SKIPPED";
+        case ScenarioTickAck_Disposition.FAILED:
+            return "FAILED";
+        case ScenarioTickAck_Disposition.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+exports.scenarioTickAck_DispositionToJSON = scenarioTickAck_DispositionToJSON;
+function createBaseScenarioTickAck() {
+    return { $type: "keelson.ScenarioTickAck", timestamp: undefined, runId: "", tick: 0, disposition: 0, detail: "" };
+}
+exports.ScenarioTickAck = {
+    $type: "keelson.ScenarioTickAck",
+    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.runId !== "") {
+            writer.uint32(18).string(message.runId);
+        }
+        if (message.tick !== 0) {
+            writer.uint32(24).uint64(message.tick);
+        }
+        if (message.disposition !== 0) {
+            writer.uint32(32).int32(message.disposition);
+        }
+        if (message.detail !== "") {
+            writer.uint32(42).string(message.detail);
+        }
+        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 = createBaseScenarioTickAck();
+        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.runId = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.tick = longToNumber(reader.uint64());
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.disposition = reader.int32();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.detail = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            $type: exports.ScenarioTickAck.$type,
+            timestamp: isSet(object.timestamp) ? fromJsonTimestamp(object.timestamp) : undefined,
+            runId: isSet(object.runId) ? globalThis.String(object.runId) : "",
+            tick: isSet(object.tick) ? globalThis.Number(object.tick) : 0,
+            disposition: isSet(object.disposition) ? scenarioTickAck_DispositionFromJSON(object.disposition) : 0,
+            detail: isSet(object.detail) ? globalThis.String(object.detail) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.timestamp !== undefined) {
+            obj.timestamp = message.timestamp.toISOString();
+        }
+        if (message.runId !== "") {
+            obj.runId = message.runId;
+        }
+        if (message.tick !== 0) {
+            obj.tick = Math.round(message.tick);
+        }
+        if (message.disposition !== 0) {
+            obj.disposition = scenarioTickAck_DispositionToJSON(message.disposition);
+        }
+        if (message.detail !== "") {
+            obj.detail = message.detail;
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.ScenarioTickAck.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseScenarioTickAck();
+        message.timestamp = object.timestamp ?? undefined;
+        message.runId = object.runId ?? "";
+        message.tick = object.tick ?? 0;
+        message.disposition = object.disposition ?? 0;
+        message.detail = object.detail ?? "";
+        return message;
+    },
+};
+typeRegistry_1.messageTypeRegistry.set(exports.ScenarioTickAck.$type, exports.ScenarioTickAck);
+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 longToNumber(int64) {
+    const num = globalThis.Number(int64.toString());
+    if (num > globalThis.Number.MAX_SAFE_INTEGER) {
+        throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
+    }
+    if (num < globalThis.Number.MIN_SAFE_INTEGER) {
+        throw new globalThis.Error("Value is smaller than Number.MIN_SAFE_INTEGER");
+    }
+    return num;
+}
+function isSet(value) {
+    return value !== null && value !== undefined;
+}

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

@@ -2,11 +2,11 @@ export * from "./foxglove/RawImage";
 export * from "./foxglove/CompressedImage";
 export * from "./foxglove/CompressedVideo";
 export * from "./foxglove/Vector3";
+export * from "./foxglove/LocationFix";
 export * from "./foxglove/GeoJSON";
 export * from "./foxglove/Quaternion";
 export * from "./foxglove/Pose";
 export * from "./foxglove/PackedElementField";
-export * from "./foxglove/LocationFix";
 export * from "./foxglove/Color";
 export * from "./foxglove/ArrowPrimitive";
 export * from "./foxglove/CameraCalibration";

package/dist/payloads/index.foxglove.js

@@ -23,11 +23,11 @@ __exportStar(require("./foxglove/RawImage"), exports);
 __exportStar(require("./foxglove/CompressedImage"), exports);
 __exportStar(require("./foxglove/CompressedVideo"), exports);
 __exportStar(require("./foxglove/Vector3"), exports);
+__exportStar(require("./foxglove/LocationFix"), exports);
 __exportStar(require("./foxglove/GeoJSON"), exports);
 __exportStar(require("./foxglove/Quaternion"), exports);
 __exportStar(require("./foxglove/Pose"), exports);
 __exportStar(require("./foxglove/PackedElementField"), exports);
-__exportStar(require("./foxglove/LocationFix"), exports);
 __exportStar(require("./foxglove/Color"), exports);
 __exportStar(require("./foxglove/ArrowPrimitive"), exports);
 __exportStar(require("./foxglove/CameraCalibration"), exports);

package/dist/payloads/index.google.protobuf.d.ts

@@ -1,4 +1,4 @@
 export * from "./google/protobuf/timestamp";
-export * from "./google/protobuf/empty";
 export * from "./google/protobuf/duration";
 export * from "./google/protobuf/any";
+export * from "./google/protobuf/empty";

package/dist/payloads/index.google.protobuf.js

@@ -20,6 +20,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 /* eslint-disable */
 __exportStar(require("./google/protobuf/timestamp"), exports);
-__exportStar(require("./google/protobuf/empty"), exports);
 __exportStar(require("./google/protobuf/duration"), exports);
 __exportStar(require("./google/protobuf/any"), exports);
+__exportStar(require("./google/protobuf/empty"), exports);