fossekall-interface 0.1.22 → 0.1.24

package/dist/generated/ecu/commands.d.ts

@@ -1,13 +1,25 @@
 import bin from 'typed-binary';
+export declare const node_bldc_Id: {
+    readonly kFuel: 0;
+    readonly kOx: 1;
+    readonly kCount: 2;
+};
+export type node_bldc_Id = (typeof node_bldc_Id)[keyof typeof node_bldc_Id];
+export declare const BldcCommands_SetBldcCommand: {
+    readonly open: 0;
+    readonly close: 1;
+};
+export type BldcCommands_SetBldcCommand = (typeof BldcCommands_SetBldcCommand)[keyof typeof BldcCommands_SetBldcCommand];
 export declare const Event: {
     readonly Boot: 0;
     readonly NextState: 1;
     readonly PreviousState: 2;
     readonly Timeout: 3;
     readonly CalibrateRequest: 4;
-    readonly Abort: 5;
-    readonly None: 6;
-    readonly Count: 7;
+    readonly BurnwireCut: 5;
+    readonly Abort: 6;
+    readonly None: 7;
+    readonly Count: 8;
 };
 export type Event = (typeof Event)[keyof typeof Event];
 export declare const StateId: {
@@ -51,6 +63,30 @@ export declare const actuators_servo_StartPolicy: {
     readonly kNoInterrupt: 1;
 };
 export type actuators_servo_StartPolicy = (typeof actuators_servo_StartPolicy)[keyof typeof actuators_servo_StartPolicy];
+export declare const node_solenoid_Id: {
+    readonly kFuelVent: 0;
+    readonly kOxVent: 1;
+    readonly kN2Fill: 2;
+    readonly kOxBleed: 3;
+    readonly kN2_200_Supply: 4;
+    readonly kN2_200_Bleed: 5;
+    readonly kN2_300_Supply: 6;
+    readonly kN2_300_Bleed: 7;
+    readonly kQD_1: 8;
+    readonly kQD_2: 9;
+    readonly kCount: 10;
+};
+export type node_solenoid_Id = (typeof node_solenoid_Id)[keyof typeof node_solenoid_Id];
+export declare const SolenoidCommands_SetSolenoidCommand: {
+    readonly open: 0;
+    readonly close: 1;
+};
+export type SolenoidCommands_SetSolenoidCommand = (typeof SolenoidCommands_SetSolenoidCommand)[keyof typeof SolenoidCommands_SetSolenoidCommand];
+export declare const ControlPolicyCommands_PolicyValue: {
+    readonly Disable: 0;
+    readonly Enable: 1;
+};
+export type ControlPolicyCommands_PolicyValue = (typeof ControlPolicyCommands_PolicyValue)[keyof typeof ControlPolicyCommands_PolicyValue];
 export declare const node_regulator_Id: {
     readonly kOxPrechill: 0;
     readonly kCount: 1;
@@ -61,6 +97,11 @@ export declare const RegulatorCommands_RegulatorValue: {
     readonly Enable: 1;
 };
 export type RegulatorCommands_RegulatorValue = (typeof RegulatorCommands_RegulatorValue)[keyof typeof RegulatorCommands_RegulatorValue];
+export declare const BldcCommands_SetBldcPayload: import("typed-binary").ObjectSchema<{
+    bldc_id: import("typed-binary").ByteSchema;
+    command: import("typed-binary").Uint32Schema;
+}>;
+export type BldcCommands_SetBldcPayload = bin.Parsed<typeof BldcCommands_SetBldcPayload>;
 export declare const FsmCommands_RaiseEventPayload: import("typed-binary").ObjectSchema<{
     event: import("typed-binary").ByteSchema;
     current_state: import("typed-binary").ByteSchema;
@@ -84,6 +125,15 @@ export declare const ServoCommands_SetServoPayload: import("typed-binary").Objec
     start_policy: import("typed-binary").ByteSchema;
 }>;
 export type ServoCommands_SetServoPayload = bin.Parsed<typeof ServoCommands_SetServoPayload>;
+export declare const SolenoidCommands_SetSolenoidPayload: import("typed-binary").ObjectSchema<{
+    solenoid_id: import("typed-binary").ByteSchema;
+    command: import("typed-binary").Uint32Schema;
+}>;
+export type SolenoidCommands_SetSolenoidPayload = bin.Parsed<typeof SolenoidCommands_SetSolenoidPayload>;
+export declare const ControlPolicyCommands_SetManualPolicyPayload: import("typed-binary").ObjectSchema<{
+    value: import("typed-binary").ByteSchema;
+}>;
+export type ControlPolicyCommands_SetManualPolicyPayload = bin.Parsed<typeof ControlPolicyCommands_SetManualPolicyPayload>;
 export declare const RegulatorCommands_SetEnabledPayload: import("typed-binary").ObjectSchema<{
     regulator_id: import("typed-binary").ByteSchema;
     value: import("typed-binary").ByteSchema;
@@ -102,6 +152,24 @@ export declare const RegulatorCommands_SetGainsPayload: import("typed-binary").O
 }>;
 export type RegulatorCommands_SetGainsPayload = bin.Parsed<typeof RegulatorCommands_SetGainsPayload>;
 export declare const spec: {
+    BldcCommands_SetBldcPayload: {
+        id: number;
+        schema: import("typed-binary").ObjectSchema<{
+            bldc_id: import("typed-binary").ByteSchema;
+            command: import("typed-binary").Uint32Schema;
+        }>;
+        enums: {
+            bldc_id: {
+                readonly kFuel: 0;
+                readonly kOx: 1;
+                readonly kCount: 2;
+            };
+            command: {
+                readonly open: 0;
+                readonly close: 1;
+            };
+        };
+    };
     FsmCommands_RaiseEventPayload: {
         id: number;
         schema: import("typed-binary").ObjectSchema<{
@@ -115,9 +183,10 @@ export declare const spec: {
                 readonly PreviousState: 2;
                 readonly Timeout: 3;
                 readonly CalibrateRequest: 4;
-                readonly Abort: 5;
-                readonly None: 6;
-                readonly Count: 7;
+                readonly BurnwireCut: 5;
+                readonly Abort: 6;
+                readonly None: 7;
+                readonly Count: 8;
             };
             current_state: {
                 readonly Safe: 0;
@@ -199,6 +268,44 @@ export declare const spec: {
             };
         };
     };
+    SolenoidCommands_SetSolenoidPayload: {
+        id: number;
+        schema: import("typed-binary").ObjectSchema<{
+            solenoid_id: import("typed-binary").ByteSchema;
+            command: import("typed-binary").Uint32Schema;
+        }>;
+        enums: {
+            solenoid_id: {
+                readonly kFuelVent: 0;
+                readonly kOxVent: 1;
+                readonly kN2Fill: 2;
+                readonly kOxBleed: 3;
+                readonly kN2_200_Supply: 4;
+                readonly kN2_200_Bleed: 5;
+                readonly kN2_300_Supply: 6;
+                readonly kN2_300_Bleed: 7;
+                readonly kQD_1: 8;
+                readonly kQD_2: 9;
+                readonly kCount: 10;
+            };
+            command: {
+                readonly open: 0;
+                readonly close: 1;
+            };
+        };
+    };
+    ControlPolicyCommands_SetManualPolicyPayload: {
+        id: number;
+        schema: import("typed-binary").ObjectSchema<{
+            value: import("typed-binary").ByteSchema;
+        }>;
+        enums: {
+            value: {
+                readonly Disable: 0;
+                readonly Enable: 1;
+            };
+        };
+    };
     RegulatorCommands_SetEnabledPayload: {
         id: number;
         schema: import("typed-binary").ObjectSchema<{

package/dist/generated/ecu/commands.js

@@ -1,5 +1,5 @@
 import bin, { Measurer, Schema } from 'typed-binary';
-// This file was generated by FRICC on 2026-03-19 10:51:03. Do not edit manually!
+// This file was generated by FRICC on 2026-03-22 14:17:44. Do not edit manually!
 // The current version of typed-binary does not support 64-bit primitives.
 // So for we'll implement our own schemas. :) 
 const __littleEndian = true;
@@ -60,15 +60,25 @@ class Float64Schema extends Schema {
 const u64 = new UInt64Schema();
 const i64 = new Int64Schema();
 const f64 = new Float64Schema();
+export const node_bldc_Id = {
+    kFuel: 0,
+    kOx: 1,
+    kCount: 2,
+};
+export const BldcCommands_SetBldcCommand = {
+    open: 0,
+    close: 1,
+};
 export const Event = {
     Boot: 0,
     NextState: 1,
     PreviousState: 2,
     Timeout: 3,
     CalibrateRequest: 4,
-    Abort: 5,
-    None: 6,
-    Count: 7,
+    BurnwireCut: 5,
+    Abort: 6,
+    None: 7,
+    Count: 8,
 };
 export const StateId = {
     Safe: 0,
@@ -106,6 +116,27 @@ export const actuators_servo_StartPolicy = {
     kPreempt: 0,
     kNoInterrupt: 1,
 };
+export const node_solenoid_Id = {
+    kFuelVent: 0,
+    kOxVent: 1,
+    kN2Fill: 2,
+    kOxBleed: 3,
+    kN2_200_Supply: 4,
+    kN2_200_Bleed: 5,
+    kN2_300_Supply: 6,
+    kN2_300_Bleed: 7,
+    kQD_1: 8,
+    kQD_2: 9,
+    kCount: 10,
+};
+export const SolenoidCommands_SetSolenoidCommand = {
+    open: 0,
+    close: 1,
+};
+export const ControlPolicyCommands_PolicyValue = {
+    Disable: 0,
+    Enable: 1,
+};
 export const node_regulator_Id = {
     kOxPrechill: 0,
     kCount: 1,
@@ -114,6 +145,10 @@ export const RegulatorCommands_RegulatorValue = {
     Disable: 0,
     Enable: 1,
 };
+export const BldcCommands_SetBldcPayload = bin.object({
+    bldc_id: bin.u8, // node::bldc::Id
+    command: bin.u32, // BldcCommands::SetBldcCommand
+});
 export const FsmCommands_RaiseEventPayload = bin.object({
     event: bin.u8, // Event
     current_state: bin.u8, // StateId
@@ -134,6 +169,13 @@ export const ServoCommands_SetServoPayload = bin.object({
     position_mode: bin.u8, // actuators::servo::PositionMode
     start_policy: bin.u8, // actuators::servo::StartPolicy
 });
+export const SolenoidCommands_SetSolenoidPayload = bin.object({
+    solenoid_id: bin.u8, // node::solenoid::Id
+    command: bin.u32, // SolenoidCommands::SetSolenoidCommand
+});
+export const ControlPolicyCommands_SetManualPolicyPayload = bin.object({
+    value: bin.u8, // ControlPolicyCommands::PolicyValue
+});
 export const RegulatorCommands_SetEnabledPayload = bin.object({
     regulator_id: bin.u8, // node::regulator::Id
     value: bin.u8, // RegulatorCommands::RegulatorValue
@@ -149,6 +191,14 @@ export const RegulatorCommands_SetGainsPayload = bin.object({
     kd: bin.f32, // float
 });
 export const spec = {
+    BldcCommands_SetBldcPayload: {
+        id: 64,
+        schema: BldcCommands_SetBldcPayload,
+        enums: {
+            bldc_id: node_bldc_Id,
+            command: BldcCommands_SetBldcCommand,
+        },
+    },
     FsmCommands_RaiseEventPayload: {
         id: 32,
         schema: FsmCommands_RaiseEventPayload,
@@ -176,6 +226,21 @@ export const spec = {
             start_policy: actuators_servo_StartPolicy,
         },
     },
+    SolenoidCommands_SetSolenoidPayload: {
+        id: 80,
+        schema: SolenoidCommands_SetSolenoidPayload,
+        enums: {
+            solenoid_id: node_solenoid_Id,
+            command: SolenoidCommands_SetSolenoidCommand,
+        },
+    },
+    ControlPolicyCommands_SetManualPolicyPayload: {
+        id: 96,
+        schema: ControlPolicyCommands_SetManualPolicyPayload,
+        enums: {
+            value: ControlPolicyCommands_PolicyValue,
+        },
+    },
     RegulatorCommands_SetEnabledPayload: {
         id: 112,
         schema: RegulatorCommands_SetEnabledPayload,

package/dist/generated/ecu/telemetry.d.ts

@@ -30,6 +30,35 @@ export declare const actuators_solenoid_Opening: {
     readonly kOpen: 2;
 };
 export type actuators_solenoid_Opening = (typeof actuators_solenoid_Opening)[keyof typeof actuators_solenoid_Opening];
+export declare const StateId: {
+    readonly Safe: 0;
+    readonly FuelFill: 1;
+    readonly PostFuelFill: 2;
+    readonly N2Fill: 3;
+    readonly PostN2Fill: 4;
+    readonly OxFill: 5;
+    readonly PostOxFill: 6;
+    readonly Pressurized: 7;
+    readonly Armed: 8;
+    readonly Burn: 9;
+    readonly Shutdown: 10;
+    readonly PostBurn: 11;
+    readonly Depressurize: 12;
+    readonly Calibrate: 13;
+};
+export type StateId = (typeof StateId)[keyof typeof StateId];
+export declare const Event: {
+    readonly Boot: 0;
+    readonly NextState: 1;
+    readonly PreviousState: 2;
+    readonly Timeout: 3;
+    readonly CalibrateRequest: 4;
+    readonly BurnwireCut: 5;
+    readonly Abort: 6;
+    readonly None: 7;
+    readonly Count: 8;
+};
+export type Event = (typeof Event)[keyof typeof Event];
 export declare const actuators_servo_ServoStatus: import("typed-binary").ObjectSchema<{
     commanded_angle_deg: import("typed-binary").Float32Schema;
     target_angle_deg: import("typed-binary").Float32Schema;
@@ -55,15 +84,96 @@ export declare const BldcTelemetry: import("typed-binary").ObjectSchema<{
     calibrated: import("typed-binary").ByteSchema;
 }>;
 export type BldcTelemetry = bin.Parsed<typeof BldcTelemetry>;
+export declare const sensors_pressure_PressureBatch: import("typed-binary").ObjectSchema<{
+    t0_ms: import("typed-binary").Uint32Schema;
+    dt_us: import("typed-binary").Uint16Schema;
+    count: import("typed-binary").ByteSchema;
+    seq: import("typed-binary").ByteSchema;
+    overrun: import("typed-binary").BoolSchema;
+    samples: import("typed-binary").ArraySchema<import("typed-binary").Int16Schema>;
+}>;
+export type sensors_pressure_PressureBatch = bin.Parsed<typeof sensors_pressure_PressureBatch>;
 export declare const actuators_solenoid_SolenoidStatus: import("typed-binary").ObjectSchema<{
     power_state: import("typed-binary").ByteSchema;
     opening: import("typed-binary").ByteSchema;
 }>;
 export type actuators_solenoid_SolenoidStatus = bin.Parsed<typeof actuators_solenoid_SolenoidStatus>;
+export declare const HeartBeatTelemetry: import("typed-binary").ObjectSchema<{
+    message: import("typed-binary").ArraySchema<import("typed-binary").Int8Schema>;
+}>;
+export type HeartBeatTelemetry = bin.Parsed<typeof HeartBeatTelemetry>;
+export declare const regulators_RegulatorStatus: import("typed-binary").ObjectSchema<{
+    operator_enabled: import("typed-binary").BoolSchema;
+    policy_enabled: import("typed-binary").BoolSchema;
+    active: import("typed-binary").BoolSchema;
+    setpoint: import("typed-binary").Float32Schema;
+    kp: import("typed-binary").Float32Schema;
+    ki: import("typed-binary").Float32Schema;
+    kd: import("typed-binary").Float32Schema;
+    integral: import("typed-binary").Float32Schema;
+    previous_error: import("typed-binary").Float32Schema;
+    last_measurement: import("typed-binary").Float32Schema;
+    last_output: import("typed-binary").Float32Schema;
+    last_servo_command_: import("typed-binary").Float32Schema;
+    last_update_ms: import("typed-binary").Uint32Schema;
+}>;
+export type regulators_RegulatorStatus = bin.Parsed<typeof regulators_RegulatorStatus>;
+export declare const RegulatorStatusEntry: import("typed-binary").ObjectSchema<{
+    id: import("typed-binary").ByteSchema;
+    name: import("typed-binary").ArraySchema<import("typed-binary").Int8Schema>;
+    status: import("typed-binary").ObjectSchema<{
+        operator_enabled: import("typed-binary").BoolSchema;
+        policy_enabled: import("typed-binary").BoolSchema;
+        active: import("typed-binary").BoolSchema;
+        setpoint: import("typed-binary").Float32Schema;
+        kp: import("typed-binary").Float32Schema;
+        ki: import("typed-binary").Float32Schema;
+        kd: import("typed-binary").Float32Schema;
+        integral: import("typed-binary").Float32Schema;
+        previous_error: import("typed-binary").Float32Schema;
+        last_measurement: import("typed-binary").Float32Schema;
+        last_output: import("typed-binary").Float32Schema;
+        last_servo_command_: import("typed-binary").Float32Schema;
+        last_update_ms: import("typed-binary").Uint32Schema;
+    }>;
+}>;
+export type RegulatorStatusEntry = bin.Parsed<typeof RegulatorStatusEntry>;
+export declare const RegulatorStatusArrayPacket: import("typed-binary").ObjectSchema<{
+    count: import("typed-binary").ByteSchema;
+    timestamp_ms: import("typed-binary").Uint32Schema;
+    entries: import("typed-binary").ArraySchema<import("typed-binary").ObjectSchema<{
+        id: import("typed-binary").ByteSchema;
+        name: import("typed-binary").ArraySchema<import("typed-binary").Int8Schema>;
+        status: import("typed-binary").ObjectSchema<{
+            operator_enabled: import("typed-binary").BoolSchema;
+            policy_enabled: import("typed-binary").BoolSchema;
+            active: import("typed-binary").BoolSchema;
+            setpoint: import("typed-binary").Float32Schema;
+            kp: import("typed-binary").Float32Schema;
+            ki: import("typed-binary").Float32Schema;
+            kd: import("typed-binary").Float32Schema;
+            integral: import("typed-binary").Float32Schema;
+            previous_error: import("typed-binary").Float32Schema;
+            last_measurement: import("typed-binary").Float32Schema;
+            last_output: import("typed-binary").Float32Schema;
+            last_servo_command_: import("typed-binary").Float32Schema;
+            last_update_ms: import("typed-binary").Uint32Schema;
+        }>;
+    }>>;
+}>;
+export type RegulatorStatusArrayPacket = bin.Parsed<typeof RegulatorStatusArrayPacket>;
+export declare const fsm_FsmStatus: import("typed-binary").ObjectSchema<{
+    state_entry_time_ms: import("typed-binary").Uint32Schema;
+    state_time_ms: import("typed-binary").Uint32Schema;
+    current_state: import("typed-binary").ByteSchema;
+    previous_state: import("typed-binary").ByteSchema;
+    last_event: import("typed-binary").ByteSchema;
+}>;
+export type fsm_FsmStatus = bin.Parsed<typeof fsm_FsmStatus>;
 export declare const spec: {
-    readonly actuators_servo_ServoStatus: {
-        readonly port: 5003;
-        readonly schema: import("typed-binary").ObjectSchema<{
+    actuators_servo_ServoStatus: {
+        port: number;
+        schema: import("typed-binary").ObjectSchema<{
             commanded_angle_deg: import("typed-binary").Float32Schema;
             target_angle_deg: import("typed-binary").Float32Schema;
             measured_angle_deg: import("typed-binary").Float32Schema;
@@ -71,13 +181,13 @@ export declare const spec: {
             mode: import("typed-binary").ByteSchema;
             power_state: import("typed-binary").ByteSchema;
         }>;
-        readonly enums: {
-            readonly mode: {
+        enums: {
+            mode: {
                 readonly kUnknown: 0;
                 readonly kPosition: 1;
                 readonly kCalibrate: 2;
             };
-            readonly power_state: {
+            power_state: {
                 readonly kUnknown: 0;
                 readonly kOff: 1;
                 readonly kBooting: 2;
@@ -85,9 +195,9 @@ export declare const spec: {
             };
         };
     };
-    readonly BldcTelemetry: {
-        readonly port: 5000;
-        readonly schema: import("typed-binary").ObjectSchema<{
+    BldcTelemetry: {
+        port: number;
+        schema: import("typed-binary").ObjectSchema<{
             valve_position: import("typed-binary").Float32Schema;
             motor_position: import("typed-binary").Float32Schema;
             timestamp: UInt64Schema;
@@ -102,27 +212,127 @@ export declare const spec: {
             position_raw: import("typed-binary").Float32Schema;
             calibrated: import("typed-binary").ByteSchema;
         }>;
-        readonly enums: {};
+        enums: {};
+    };
+    sensors_pressure_PressureBatch: {
+        port: number;
+        schema: import("typed-binary").ObjectSchema<{
+            t0_ms: import("typed-binary").Uint32Schema;
+            dt_us: import("typed-binary").Uint16Schema;
+            count: import("typed-binary").ByteSchema;
+            seq: import("typed-binary").ByteSchema;
+            overrun: import("typed-binary").BoolSchema;
+            samples: import("typed-binary").ArraySchema<import("typed-binary").Int16Schema>;
+        }>;
+        enums: {};
     };
-    readonly actuators_solenoid_SolenoidStatus: {
-        readonly port: 5004;
-        readonly schema: import("typed-binary").ObjectSchema<{
+    actuators_solenoid_SolenoidStatus: {
+        port: number;
+        schema: import("typed-binary").ObjectSchema<{
             power_state: import("typed-binary").ByteSchema;
             opening: import("typed-binary").ByteSchema;
         }>;
-        readonly enums: {
-            readonly power_state: {
+        enums: {
+            power_state: {
                 readonly kUnknown: 0;
                 readonly kOff: 1;
                 readonly kOn: 2;
             };
-            readonly opening: {
+            opening: {
                 readonly kUnknown: 0;
                 readonly kClosed: 1;
                 readonly kOpen: 2;
             };
         };
     };
+    HeartBeatTelemetry: {
+        schema: import("typed-binary").ObjectSchema<{
+            message: import("typed-binary").ArraySchema<import("typed-binary").Int8Schema>;
+        }>;
+        enums: {};
+    };
+    RegulatorStatusArrayPacket: {
+        port: number;
+        schema: import("typed-binary").ObjectSchema<{
+            count: import("typed-binary").ByteSchema;
+            timestamp_ms: import("typed-binary").Uint32Schema;
+            entries: import("typed-binary").ArraySchema<import("typed-binary").ObjectSchema<{
+                id: import("typed-binary").ByteSchema;
+                name: import("typed-binary").ArraySchema<import("typed-binary").Int8Schema>;
+                status: import("typed-binary").ObjectSchema<{
+                    operator_enabled: import("typed-binary").BoolSchema;
+                    policy_enabled: import("typed-binary").BoolSchema;
+                    active: import("typed-binary").BoolSchema;
+                    setpoint: import("typed-binary").Float32Schema;
+                    kp: import("typed-binary").Float32Schema;
+                    ki: import("typed-binary").Float32Schema;
+                    kd: import("typed-binary").Float32Schema;
+                    integral: import("typed-binary").Float32Schema;
+                    previous_error: import("typed-binary").Float32Schema;
+                    last_measurement: import("typed-binary").Float32Schema;
+                    last_output: import("typed-binary").Float32Schema;
+                    last_servo_command_: import("typed-binary").Float32Schema;
+                    last_update_ms: import("typed-binary").Uint32Schema;
+                }>;
+            }>>;
+        }>;
+        enums: {};
+    };
+    fsm_FsmStatus: {
+        port: number;
+        schema: import("typed-binary").ObjectSchema<{
+            state_entry_time_ms: import("typed-binary").Uint32Schema;
+            state_time_ms: import("typed-binary").Uint32Schema;
+            current_state: import("typed-binary").ByteSchema;
+            previous_state: import("typed-binary").ByteSchema;
+            last_event: import("typed-binary").ByteSchema;
+        }>;
+        enums: {
+            current_state: {
+                readonly Safe: 0;
+                readonly FuelFill: 1;
+                readonly PostFuelFill: 2;
+                readonly N2Fill: 3;
+                readonly PostN2Fill: 4;
+                readonly OxFill: 5;
+                readonly PostOxFill: 6;
+                readonly Pressurized: 7;
+                readonly Armed: 8;
+                readonly Burn: 9;
+                readonly Shutdown: 10;
+                readonly PostBurn: 11;
+                readonly Depressurize: 12;
+                readonly Calibrate: 13;
+            };
+            previous_state: {
+                readonly Safe: 0;
+                readonly FuelFill: 1;
+                readonly PostFuelFill: 2;
+                readonly N2Fill: 3;
+                readonly PostN2Fill: 4;
+                readonly OxFill: 5;
+                readonly PostOxFill: 6;
+                readonly Pressurized: 7;
+                readonly Armed: 8;
+                readonly Burn: 9;
+                readonly Shutdown: 10;
+                readonly PostBurn: 11;
+                readonly Depressurize: 12;
+                readonly Calibrate: 13;
+            };
+            last_event: {
+                readonly Boot: 0;
+                readonly NextState: 1;
+                readonly PreviousState: 2;
+                readonly Timeout: 3;
+                readonly CalibrateRequest: 4;
+                readonly BurnwireCut: 5;
+                readonly Abort: 6;
+                readonly None: 7;
+                readonly Count: 8;
+            };
+        };
+    };
 };
 export default spec;
 export type Spec = typeof spec;

package/dist/generated/ecu/telemetry.js

@@ -1,5 +1,5 @@
 import bin, { Measurer, Schema } from 'typed-binary';
-// This file was generated by FRICC on 2026-03-19 10:00:44. Do not edit manually!
+// This file was generated by FRICC on 2026-03-23 21:05:05. Do not edit manually!
 // The current version of typed-binary does not support 64-bit primitives.
 // So for we'll implement our own schemas. :) 
 const __littleEndian = true;
@@ -81,6 +81,33 @@ export const actuators_solenoid_Opening = {
     kClosed: 1,
     kOpen: 2,
 };
+export const StateId = {
+    Safe: 0,
+    FuelFill: 1,
+    PostFuelFill: 2,
+    N2Fill: 3,
+    PostN2Fill: 4,
+    OxFill: 5,
+    PostOxFill: 6,
+    Pressurized: 7,
+    Armed: 8,
+    Burn: 9,
+    Shutdown: 10,
+    PostBurn: 11,
+    Depressurize: 12,
+    Calibrate: 13,
+};
+export const Event = {
+    Boot: 0,
+    NextState: 1,
+    PreviousState: 2,
+    Timeout: 3,
+    CalibrateRequest: 4,
+    BurnwireCut: 5,
+    Abort: 6,
+    None: 7,
+    Count: 8,
+};
 export const actuators_servo_ServoStatus = bin.object({
     commanded_angle_deg: bin.f32, // float
     target_angle_deg: bin.f32, // float
@@ -104,10 +131,53 @@ export const BldcTelemetry = bin.object({
     position_raw: bin.f32, // float
     calibrated: bin.u8, // unsigned char
 });
+export const sensors_pressure_PressureBatch = bin.object({
+    t0_ms: bin.u32, // unsigned int
+    dt_us: bin.u16, // unsigned short
+    count: bin.u8, // unsigned char
+    seq: bin.u8, // unsigned char
+    overrun: bin.bool, // bool
+    samples: bin.arrayOf(bin.i16, 10), // short[10]
+});
 export const actuators_solenoid_SolenoidStatus = bin.object({
     power_state: bin.u8, // actuators::solenoid::PowerState
     opening: bin.u8, // actuators::solenoid::Opening
 });
+export const HeartBeatTelemetry = bin.object({
+    message: bin.arrayOf(bin.i8, 16), // char[16]
+});
+export const regulators_RegulatorStatus = bin.object({
+    operator_enabled: bin.bool, // bool
+    policy_enabled: bin.bool, // bool
+    active: bin.bool, // bool
+    setpoint: bin.f32, // float
+    kp: bin.f32, // float
+    ki: bin.f32, // float
+    kd: bin.f32, // float
+    integral: bin.f32, // float
+    previous_error: bin.f32, // float
+    last_measurement: bin.f32, // float
+    last_output: bin.f32, // float
+    last_servo_command_: bin.f32, // float
+    last_update_ms: bin.u32, // unsigned int
+});
+export const RegulatorStatusEntry = bin.object({
+    id: bin.u8, // node::regulator::Id
+    name: bin.arrayOf(bin.i8, 24), // char[24]
+    status: regulators_RegulatorStatus, // regulators::RegulatorStatus
+});
+export const RegulatorStatusArrayPacket = bin.object({
+    count: bin.u8, // unsigned char
+    timestamp_ms: bin.u32, // unsigned int
+    entries: bin.arrayOf(RegulatorStatusEntry, 1), // RegulatorStatusEntry[1]
+});
+export const fsm_FsmStatus = bin.object({
+    state_entry_time_ms: bin.u32, // unsigned int
+    state_time_ms: bin.u32, // unsigned int
+    current_state: bin.u8, // StateId
+    previous_state: bin.u8, // StateId
+    last_event: bin.u8, // Event
+});
 export const spec = {
     actuators_servo_ServoStatus: {
         port: 5003,
@@ -122,6 +192,11 @@ export const spec = {
         schema: BldcTelemetry,
         enums: {},
     },
+    sensors_pressure_PressureBatch: {
+        port: 5002,
+        schema: sensors_pressure_PressureBatch,
+        enums: {},
+    },
     actuators_solenoid_SolenoidStatus: {
         port: 5004,
         schema: actuators_solenoid_SolenoidStatus,
@@ -130,5 +205,23 @@ export const spec = {
             opening: actuators_solenoid_Opening,
         },
     },
+    HeartBeatTelemetry: {
+        schema: HeartBeatTelemetry,
+        enums: {},
+    },
+    RegulatorStatusArrayPacket: {
+        port: 5005,
+        schema: RegulatorStatusArrayPacket,
+        enums: {},
+    },
+    fsm_FsmStatus: {
+        port: 5001,
+        schema: fsm_FsmStatus,
+        enums: {
+            current_state: StateId,
+            previous_state: StateId,
+            last_event: Event,
+        },
+    },
 };
 export default spec;

package/dist/generated/fc/telemetry.d.ts

@@ -5,58 +5,46 @@ declare class Float64Schema extends Schema<number> {
     write(output: ISerialOutput, value: number): void;
     measure(_: number | typeof MaxValue, measurer?: IMeasurer): IMeasurer;
 }
-export declare const Telemetry_AccelData: import("typed-binary").ObjectSchema<{
+export declare const AccelerationData: import("typed-binary").ObjectSchema<{
     acc_x: import("typed-binary").Float32Schema;
     acc_y: import("typed-binary").Float32Schema;
     acc_z: import("typed-binary").Float32Schema;
 }>;
-export type Telemetry_AccelData = bin.Parsed<typeof Telemetry_AccelData>;
-export declare const Telemetry_GNSS_DATA: import("typed-binary").ObjectSchema<{
-    data_valid: import("typed-binary").BoolSchema;
+export type AccelerationData = bin.Parsed<typeof AccelerationData>;
+export declare const GNSS_DATA: import("typed-binary").ObjectSchema<{
     lat: Float64Schema;
     lon: Float64Schema;
-    hAcc: import("typed-binary").Uint32Schema;
-    vAcc: import("typed-binary").Uint32Schema;
     hMSL: Float64Schema;
     gSpeed: Float64Schema;
     headMot: Float64Schema;
-    velN: import("typed-binary").Int32Schema;
-    velE: import("typed-binary").Int32Schema;
-    velD: import("typed-binary").Int32Schema;
     numSV: import("typed-binary").ByteSchema;
 }>;
-export type Telemetry_GNSS_DATA = bin.Parsed<typeof Telemetry_GNSS_DATA>;
-export declare const Telemetry_Loadcell: import("typed-binary").ObjectSchema<{
-    loadcell_value: Float64Schema;
+export type GNSS_DATA = bin.Parsed<typeof GNSS_DATA>;
+export declare const Loadcell: import("typed-binary").ObjectSchema<{
+    loadcell_value: import("typed-binary").Float32Schema;
 }>;
-export type Telemetry_Loadcell = bin.Parsed<typeof Telemetry_Loadcell>;
-export declare const Telemetry_SensorData: import("typed-binary").ObjectSchema<{
+export type Loadcell = bin.Parsed<typeof Loadcell>;
+export declare const SensorData: import("typed-binary").ObjectSchema<{
     iim_acc_data: import("typed-binary").ObjectSchema<{
         acc_x: import("typed-binary").Float32Schema;
         acc_y: import("typed-binary").Float32Schema;
         acc_z: import("typed-binary").Float32Schema;
     }>;
     gnss_data: import("typed-binary").ObjectSchema<{
-        data_valid: import("typed-binary").BoolSchema;
         lat: Float64Schema;
         lon: Float64Schema;
-        hAcc: import("typed-binary").Uint32Schema;
-        vAcc: import("typed-binary").Uint32Schema;
         hMSL: Float64Schema;
         gSpeed: Float64Schema;
         headMot: Float64Schema;
-        velN: import("typed-binary").Int32Schema;
-        velE: import("typed-binary").Int32Schema;
-        velD: import("typed-binary").Int32Schema;
         numSV: import("typed-binary").ByteSchema;
     }>;
     loadcell_data: import("typed-binary").ObjectSchema<{
-        loadcell_value: Float64Schema;
+        loadcell_value: import("typed-binary").Float32Schema;
     }>;
 }>;
-export type Telemetry_SensorData = bin.Parsed<typeof Telemetry_SensorData>;
+export type SensorData = bin.Parsed<typeof SensorData>;
 export declare const spec: {
-    Telemetry_SensorData: {
+    SensorData: {
         port: number;
         schema: import("typed-binary").ObjectSchema<{
             iim_acc_data: import("typed-binary").ObjectSchema<{
@@ -65,21 +53,15 @@ export declare const spec: {
                 acc_z: import("typed-binary").Float32Schema;
             }>;
             gnss_data: import("typed-binary").ObjectSchema<{
-                data_valid: import("typed-binary").BoolSchema;
                 lat: Float64Schema;
                 lon: Float64Schema;
-                hAcc: import("typed-binary").Uint32Schema;
-                vAcc: import("typed-binary").Uint32Schema;
                 hMSL: Float64Schema;
                 gSpeed: Float64Schema;
                 headMot: Float64Schema;
-                velN: import("typed-binary").Int32Schema;
-                velE: import("typed-binary").Int32Schema;
-                velD: import("typed-binary").Int32Schema;
                 numSV: import("typed-binary").ByteSchema;
             }>;
             loadcell_data: import("typed-binary").ObjectSchema<{
-                loadcell_value: Float64Schema;
+                loadcell_value: import("typed-binary").Float32Schema;
             }>;
         }>;
         enums: {

package/dist/generated/fc/telemetry.js

@@ -1,5 +1,5 @@
 import bin, { Measurer, Schema } from 'typed-binary';
-// This file was generated by FRICC on 2026-03-22 14:51:40. Do not edit manually!
+// This file was generated by FRICC on 2026-03-19 15:15:45. Do not edit manually!
 // The current version of typed-binary does not support 64-bit primitives.
 // So for we'll implement our own schemas. :) 
 const __littleEndian = true;
@@ -60,37 +60,31 @@ class Float64Schema extends Schema {
 const u64 = new UInt64Schema();
 const i64 = new Int64Schema();
 const f64 = new Float64Schema();
-export const Telemetry_AccelData = bin.object({
+export const AccelerationData = bin.object({
     acc_x: bin.f32, // float
     acc_y: bin.f32, // float
     acc_z: bin.f32, // float
 });
-export const Telemetry_GNSS_DATA = bin.object({
-    data_valid: bin.bool, // bool
+export const GNSS_DATA = bin.object({
     lat: f64, // double
     lon: f64, // double
-    hAcc: bin.u32, // unsigned int
-    vAcc: bin.u32, // unsigned int
     hMSL: f64, // double
     gSpeed: f64, // double
     headMot: f64, // double
-    velN: bin.i32, // int
-    velE: bin.i32, // int
-    velD: bin.i32, // int
     numSV: bin.u8, // unsigned char
 });
-export const Telemetry_Loadcell = bin.object({
-    loadcell_value: f64, // double
+export const Loadcell = bin.object({
+    loadcell_value: bin.f32, // float
 });
-export const Telemetry_SensorData = bin.object({
-    iim_acc_data: Telemetry_AccelData, // Telemetry::AccelData
-    gnss_data: Telemetry_GNSS_DATA, // Telemetry::GNSS_DATA
-    loadcell_data: Telemetry_Loadcell, // Telemetry::Loadcell
+export const SensorData = bin.object({
+    iim_acc_data: AccelerationData, // AccelerationData
+    gnss_data: GNSS_DATA, // GNSS_DATA
+    loadcell_data: Loadcell, // Loadcell
 });
 export const spec = {
-    Telemetry_SensorData: {
+    SensorData: {
         port: 3001,
-        schema: Telemetry_SensorData,
+        schema: SensorData,
         enums: {
             iim_acc_data: {},
             gnss_data: {},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fossekall-interface",
-  "version": "0.1.22",
+  "version": "0.1.24",
   "description": "API contracts between client and server (rocket and GUI)",
   "license": "ISC",
   "author": "Propulse",