fossekall-interface 0.1.14 → 0.1.16

package/README.md

@@ -11,16 +11,14 @@ npm install fossekall-interface
 
 ## Usage
 
-Import generated modules from published `dist` paths:
+Import generated objects from the package root:
 
 ```ts
-import * as telemetry from "fossekall-interface/dist/ecu/telemetry";
-import * as commands from "fossekall-interface/dist/ecu/commands";
-import type { TelemetrySpec, CommandSpec } from "fossekall-interface/dist/types";
+import { SomeSchema, type SomeType } from "fossekall-interface";
 ```
 
-These modules expose generated schemas, enums, and spec types for integration
-and type-safe data handling.
+The root export surfaces generated modules intended for application
+integration and type-safe data handling.
 
 ## Package Output
 

package/dist/constants.d.ts

@@ -0,0 +1,8 @@
+export declare const ecu: {
+    ip: string;
+    commandPort: number;
+};
+export declare const fc: {
+    ip: string;
+    commandPort: number;
+};

package/dist/constants.js

@@ -0,0 +1,10 @@
+// This file contains all manually entered
+// constants for the different MCUs.
+export const ecu = {
+    ip: "10.19.0.111",
+    commandPort: 25565,
+};
+export const fc = {
+    ip: "10.19.0.110",
+    commandPort: 25566,
+};

package/dist/fc/commands.d.ts

@@ -0,0 +1,3 @@
+export declare const spec: {};
+export default spec;
+export type Spec = typeof spec;

package/dist/fc/commands.js

@@ -0,0 +1,64 @@
+import { Measurer, Schema } from 'typed-binary';
+// This file was generated by FRICC on 2026-03-19 11:27:20. 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;
+class UInt64Schema extends Schema {
+    maxSize = 8;
+    read(input) {
+        const bytes = new Uint8Array(8);
+        input.readSlice(bytes, 0, 8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        return view.getBigUint64(0, __littleEndian);
+    }
+    write(output, value) {
+        const bytes = new Uint8Array(8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        view.setBigUint64(0, value, __littleEndian);
+        output.writeSlice(bytes);
+    }
+    measure(_, measurer = new Measurer()) {
+        return measurer.add(8);
+    }
+}
+class Int64Schema extends Schema {
+    maxSize = 8;
+    read(input) {
+        const bytes = new Uint8Array(8);
+        input.readSlice(bytes, 0, 8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        return view.getBigInt64(0, __littleEndian);
+    }
+    write(output, value) {
+        const bytes = new Uint8Array(8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        view.setBigInt64(0, value, __littleEndian);
+        output.writeSlice(bytes);
+    }
+    measure(_, measurer = new Measurer()) {
+        return measurer.add(8);
+    }
+}
+class Float64Schema extends Schema {
+    maxSize = 8;
+    read(input) {
+        const bytes = new Uint8Array(8);
+        input.readSlice(bytes, 0, 8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        return view.getFloat64(0, __littleEndian);
+    }
+    write(output, value) {
+        const bytes = new Uint8Array(8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        view.setFloat64(0, value, __littleEndian);
+        output.writeSlice(bytes);
+    }
+    measure(_, measurer = new Measurer()) {
+        return measurer.add(8);
+    }
+}
+const u64 = new UInt64Schema();
+const i64 = new Int64Schema();
+const f64 = new Float64Schema();
+export const spec = {};
+export default spec;

package/dist/fc/index.d.ts

@@ -1 +1,3 @@
+export * as commands from "./commands";
 export * as constants from "./constants";
+export * as telemetry from "./telemetry";

package/dist/fc/index.js

@@ -1 +1,3 @@
+export * as commands from "./commands";
 export * as constants from "./constants";
+export * as telemetry from "./telemetry";

package/dist/fc/telemetry.d.ts

@@ -0,0 +1,3 @@
+export declare const spec: {};
+export default spec;
+export type Spec = typeof spec;

package/dist/fc/telemetry.js

@@ -0,0 +1,64 @@
+import { Measurer, Schema } from 'typed-binary';
+// This file was generated by FRICC on 2026-03-19 11:27:31. 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;
+class UInt64Schema extends Schema {
+    maxSize = 8;
+    read(input) {
+        const bytes = new Uint8Array(8);
+        input.readSlice(bytes, 0, 8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        return view.getBigUint64(0, __littleEndian);
+    }
+    write(output, value) {
+        const bytes = new Uint8Array(8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        view.setBigUint64(0, value, __littleEndian);
+        output.writeSlice(bytes);
+    }
+    measure(_, measurer = new Measurer()) {
+        return measurer.add(8);
+    }
+}
+class Int64Schema extends Schema {
+    maxSize = 8;
+    read(input) {
+        const bytes = new Uint8Array(8);
+        input.readSlice(bytes, 0, 8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        return view.getBigInt64(0, __littleEndian);
+    }
+    write(output, value) {
+        const bytes = new Uint8Array(8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        view.setBigInt64(0, value, __littleEndian);
+        output.writeSlice(bytes);
+    }
+    measure(_, measurer = new Measurer()) {
+        return measurer.add(8);
+    }
+}
+class Float64Schema extends Schema {
+    maxSize = 8;
+    read(input) {
+        const bytes = new Uint8Array(8);
+        input.readSlice(bytes, 0, 8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        return view.getFloat64(0, __littleEndian);
+    }
+    write(output, value) {
+        const bytes = new Uint8Array(8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        view.setFloat64(0, value, __littleEndian);
+        output.writeSlice(bytes);
+    }
+    measure(_, measurer = new Measurer()) {
+        return measurer.add(8);
+    }
+}
+const u64 = new UInt64Schema();
+const i64 = new Int64Schema();
+const f64 = new Float64Schema();
+export const spec = {};
+export default spec;

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

@@ -0,0 +1,249 @@
+import bin from 'typed-binary';
+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;
+};
+export type Event = (typeof Event)[keyof typeof Event];
+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 node_servo_Id: {
+    readonly kMainFuel: 0;
+    readonly kMainOx: 1;
+    readonly kOxFill: 2;
+    readonly kOxPrechill: 3;
+    readonly kOxSupply: 4;
+    readonly kCount: 5;
+};
+export type node_servo_Id = (typeof node_servo_Id)[keyof typeof node_servo_Id];
+export declare const ServoCommands_OpenClose: {
+    readonly Open: 0;
+    readonly Close: 1;
+};
+export type ServoCommands_OpenClose = (typeof ServoCommands_OpenClose)[keyof typeof ServoCommands_OpenClose];
+export declare const actuators_servo_PositionMode: {
+    readonly kAbsolute: 0;
+    readonly kRelative: 1;
+};
+export type actuators_servo_PositionMode = (typeof actuators_servo_PositionMode)[keyof typeof actuators_servo_PositionMode];
+export declare const actuators_servo_StartPolicy: {
+    readonly kPreempt: 0;
+    readonly kNoInterrupt: 1;
+};
+export type actuators_servo_StartPolicy = (typeof actuators_servo_StartPolicy)[keyof typeof actuators_servo_StartPolicy];
+export declare const node_regulator_Id: {
+    readonly kOxPrechill: 0;
+    readonly kCount: 1;
+};
+export type node_regulator_Id = (typeof node_regulator_Id)[keyof typeof node_regulator_Id];
+export declare const RegulatorCommands_RegulatorValue: {
+    readonly Disable: 0;
+    readonly Enable: 1;
+};
+export type RegulatorCommands_RegulatorValue = (typeof RegulatorCommands_RegulatorValue)[keyof typeof RegulatorCommands_RegulatorValue];
+export declare const FsmCommands_RaiseEventPayload: import("typed-binary").ObjectSchema<{
+    event: import("typed-binary").ByteSchema;
+    current_state: import("typed-binary").ByteSchema;
+}>;
+export type FsmCommands_RaiseEventPayload = bin.Parsed<typeof FsmCommands_RaiseEventPayload>;
+export declare const ServoCommands_OpenCloseServoPayload: import("typed-binary").ObjectSchema<{
+    servo_id: import("typed-binary").ByteSchema;
+    open_close: import("typed-binary").ByteSchema;
+    duration_ms: import("typed-binary").Uint16Schema;
+    delay_ms: import("typed-binary").Uint16Schema;
+    position_mode: import("typed-binary").ByteSchema;
+    start_policy: import("typed-binary").ByteSchema;
+}>;
+export type ServoCommands_OpenCloseServoPayload = bin.Parsed<typeof ServoCommands_OpenCloseServoPayload>;
+export declare const ServoCommands_SetServoPayload: import("typed-binary").ObjectSchema<{
+    servo_id: import("typed-binary").ByteSchema;
+    angle_deg: import("typed-binary").Float32Schema;
+    duration_ms: import("typed-binary").Uint16Schema;
+    delay_ms: import("typed-binary").Uint16Schema;
+    position_mode: import("typed-binary").ByteSchema;
+    start_policy: import("typed-binary").ByteSchema;
+}>;
+export type ServoCommands_SetServoPayload = bin.Parsed<typeof ServoCommands_SetServoPayload>;
+export declare const RegulatorCommands_SetEnabledPayload: import("typed-binary").ObjectSchema<{
+    regulator_id: import("typed-binary").ByteSchema;
+    value: import("typed-binary").ByteSchema;
+}>;
+export type RegulatorCommands_SetEnabledPayload = bin.Parsed<typeof RegulatorCommands_SetEnabledPayload>;
+export declare const RegulatorCommands_SetSetpointPayload: import("typed-binary").ObjectSchema<{
+    regulator_id: import("typed-binary").ByteSchema;
+    setpoint: import("typed-binary").Float32Schema;
+}>;
+export type RegulatorCommands_SetSetpointPayload = bin.Parsed<typeof RegulatorCommands_SetSetpointPayload>;
+export declare const RegulatorCommands_SetGainsPayload: import("typed-binary").ObjectSchema<{
+    regulator_id: import("typed-binary").ByteSchema;
+    kp: import("typed-binary").Float32Schema;
+    ki: import("typed-binary").Float32Schema;
+    kd: import("typed-binary").Float32Schema;
+}>;
+export type RegulatorCommands_SetGainsPayload = bin.Parsed<typeof RegulatorCommands_SetGainsPayload>;
+export declare const spec: {
+    FsmCommands_RaiseEventPayload: {
+        id: number;
+        schema: import("typed-binary").ObjectSchema<{
+            event: import("typed-binary").ByteSchema;
+            current_state: import("typed-binary").ByteSchema;
+        }>;
+        enums: {
+            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;
+            };
+            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;
+            };
+        };
+    };
+    ServoCommands_OpenCloseServoPayload: {
+        id: number;
+        schema: import("typed-binary").ObjectSchema<{
+            servo_id: import("typed-binary").ByteSchema;
+            open_close: import("typed-binary").ByteSchema;
+            duration_ms: import("typed-binary").Uint16Schema;
+            delay_ms: import("typed-binary").Uint16Schema;
+            position_mode: import("typed-binary").ByteSchema;
+            start_policy: import("typed-binary").ByteSchema;
+        }>;
+        enums: {
+            servo_id: {
+                readonly kMainFuel: 0;
+                readonly kMainOx: 1;
+                readonly kOxFill: 2;
+                readonly kOxPrechill: 3;
+                readonly kOxSupply: 4;
+                readonly kCount: 5;
+            };
+            open_close: {
+                readonly Open: 0;
+                readonly Close: 1;
+            };
+            position_mode: {
+                readonly kAbsolute: 0;
+                readonly kRelative: 1;
+            };
+            start_policy: {
+                readonly kPreempt: 0;
+                readonly kNoInterrupt: 1;
+            };
+        };
+    };
+    ServoCommands_SetServoPayload: {
+        id: number;
+        schema: import("typed-binary").ObjectSchema<{
+            servo_id: import("typed-binary").ByteSchema;
+            angle_deg: import("typed-binary").Float32Schema;
+            duration_ms: import("typed-binary").Uint16Schema;
+            delay_ms: import("typed-binary").Uint16Schema;
+            position_mode: import("typed-binary").ByteSchema;
+            start_policy: import("typed-binary").ByteSchema;
+        }>;
+        enums: {
+            servo_id: {
+                readonly kMainFuel: 0;
+                readonly kMainOx: 1;
+                readonly kOxFill: 2;
+                readonly kOxPrechill: 3;
+                readonly kOxSupply: 4;
+                readonly kCount: 5;
+            };
+            position_mode: {
+                readonly kAbsolute: 0;
+                readonly kRelative: 1;
+            };
+            start_policy: {
+                readonly kPreempt: 0;
+                readonly kNoInterrupt: 1;
+            };
+        };
+    };
+    RegulatorCommands_SetEnabledPayload: {
+        id: number;
+        schema: import("typed-binary").ObjectSchema<{
+            regulator_id: import("typed-binary").ByteSchema;
+            value: import("typed-binary").ByteSchema;
+        }>;
+        enums: {
+            regulator_id: {
+                readonly kOxPrechill: 0;
+                readonly kCount: 1;
+            };
+            value: {
+                readonly Disable: 0;
+                readonly Enable: 1;
+            };
+        };
+    };
+    RegulatorCommands_SetSetpointPayload: {
+        id: number;
+        schema: import("typed-binary").ObjectSchema<{
+            regulator_id: import("typed-binary").ByteSchema;
+            setpoint: import("typed-binary").Float32Schema;
+        }>;
+        enums: {
+            regulator_id: {
+                readonly kOxPrechill: 0;
+                readonly kCount: 1;
+            };
+        };
+    };
+    RegulatorCommands_SetGainsPayload: {
+        id: number;
+        schema: import("typed-binary").ObjectSchema<{
+            regulator_id: import("typed-binary").ByteSchema;
+            kp: import("typed-binary").Float32Schema;
+            ki: import("typed-binary").Float32Schema;
+            kd: import("typed-binary").Float32Schema;
+        }>;
+        enums: {
+            regulator_id: {
+                readonly kOxPrechill: 0;
+                readonly kCount: 1;
+            };
+        };
+    };
+};
+export default spec;
+export type Spec = typeof spec;

package/dist/generated/ecu/commands.js

@@ -0,0 +1,202 @@
+import bin, { Measurer, Schema } from 'typed-binary';
+// This file was generated by FRICC on 2026-03-19 10:51:03. 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;
+class UInt64Schema extends Schema {
+    maxSize = 8;
+    read(input) {
+        const bytes = new Uint8Array(8);
+        input.readSlice(bytes, 0, 8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        return view.getBigUint64(0, __littleEndian);
+    }
+    write(output, value) {
+        const bytes = new Uint8Array(8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        view.setBigUint64(0, value, __littleEndian);
+        output.writeSlice(bytes);
+    }
+    measure(_, measurer = new Measurer()) {
+        return measurer.add(8);
+    }
+}
+class Int64Schema extends Schema {
+    maxSize = 8;
+    read(input) {
+        const bytes = new Uint8Array(8);
+        input.readSlice(bytes, 0, 8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        return view.getBigInt64(0, __littleEndian);
+    }
+    write(output, value) {
+        const bytes = new Uint8Array(8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        view.setBigInt64(0, value, __littleEndian);
+        output.writeSlice(bytes);
+    }
+    measure(_, measurer = new Measurer()) {
+        return measurer.add(8);
+    }
+}
+class Float64Schema extends Schema {
+    maxSize = 8;
+    read(input) {
+        const bytes = new Uint8Array(8);
+        input.readSlice(bytes, 0, 8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        return view.getFloat64(0, __littleEndian);
+    }
+    write(output, value) {
+        const bytes = new Uint8Array(8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        view.setFloat64(0, value, __littleEndian);
+        output.writeSlice(bytes);
+    }
+    measure(_, measurer = new Measurer()) {
+        return measurer.add(8);
+    }
+}
+const u64 = new UInt64Schema();
+const i64 = new Int64Schema();
+const f64 = new Float64Schema();
+export const Event = {
+    Boot: 0,
+    NextState: 1,
+    PreviousState: 2,
+    Timeout: 3,
+    CalibrateRequest: 4,
+    Abort: 5,
+    None: 6,
+    Count: 7,
+};
+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 node_servo_Id = {
+    kMainFuel: 0,
+    kMainOx: 1,
+    kOxFill: 2,
+    kOxPrechill: 3,
+    kOxSupply: 4,
+    kCount: 5,
+};
+export const ServoCommands_OpenClose = {
+    Open: 0,
+    Close: 1,
+};
+export const actuators_servo_PositionMode = {
+    kAbsolute: 0,
+    kRelative: 1,
+};
+export const actuators_servo_StartPolicy = {
+    kPreempt: 0,
+    kNoInterrupt: 1,
+};
+export const node_regulator_Id = {
+    kOxPrechill: 0,
+    kCount: 1,
+};
+export const RegulatorCommands_RegulatorValue = {
+    Disable: 0,
+    Enable: 1,
+};
+export const FsmCommands_RaiseEventPayload = bin.object({
+    event: bin.u8, // Event
+    current_state: bin.u8, // StateId
+});
+export const ServoCommands_OpenCloseServoPayload = bin.object({
+    servo_id: bin.u8, // node::servo::Id
+    open_close: bin.u8, // ServoCommands::OpenClose
+    duration_ms: bin.u16, // unsigned short
+    delay_ms: bin.u16, // unsigned short
+    position_mode: bin.u8, // actuators::servo::PositionMode
+    start_policy: bin.u8, // actuators::servo::StartPolicy
+});
+export const ServoCommands_SetServoPayload = bin.object({
+    servo_id: bin.u8, // node::servo::Id
+    angle_deg: bin.f32, // float
+    duration_ms: bin.u16, // unsigned short
+    delay_ms: bin.u16, // unsigned short
+    position_mode: bin.u8, // actuators::servo::PositionMode
+    start_policy: bin.u8, // actuators::servo::StartPolicy
+});
+export const RegulatorCommands_SetEnabledPayload = bin.object({
+    regulator_id: bin.u8, // node::regulator::Id
+    value: bin.u8, // RegulatorCommands::RegulatorValue
+});
+export const RegulatorCommands_SetSetpointPayload = bin.object({
+    regulator_id: bin.u8, // node::regulator::Id
+    setpoint: bin.f32, // float
+});
+export const RegulatorCommands_SetGainsPayload = bin.object({
+    regulator_id: bin.u8, // node::regulator::Id
+    kp: bin.f32, // float
+    ki: bin.f32, // float
+    kd: bin.f32, // float
+});
+export const spec = {
+    FsmCommands_RaiseEventPayload: {
+        id: 32,
+        schema: FsmCommands_RaiseEventPayload,
+        enums: {
+            event: Event,
+            current_state: StateId,
+        },
+    },
+    ServoCommands_OpenCloseServoPayload: {
+        id: 48,
+        schema: ServoCommands_OpenCloseServoPayload,
+        enums: {
+            servo_id: node_servo_Id,
+            open_close: ServoCommands_OpenClose,
+            position_mode: actuators_servo_PositionMode,
+            start_policy: actuators_servo_StartPolicy,
+        },
+    },
+    ServoCommands_SetServoPayload: {
+        id: 49,
+        schema: ServoCommands_SetServoPayload,
+        enums: {
+            servo_id: node_servo_Id,
+            position_mode: actuators_servo_PositionMode,
+            start_policy: actuators_servo_StartPolicy,
+        },
+    },
+    RegulatorCommands_SetEnabledPayload: {
+        id: 112,
+        schema: RegulatorCommands_SetEnabledPayload,
+        enums: {
+            regulator_id: node_regulator_Id,
+            value: RegulatorCommands_RegulatorValue,
+        },
+    },
+    RegulatorCommands_SetSetpointPayload: {
+        id: 113,
+        schema: RegulatorCommands_SetSetpointPayload,
+        enums: {
+            regulator_id: node_regulator_Id,
+        },
+    },
+    RegulatorCommands_SetGainsPayload: {
+        id: 114,
+        schema: RegulatorCommands_SetGainsPayload,
+        enums: {
+            regulator_id: node_regulator_Id,
+        },
+    },
+};
+export default spec;

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

@@ -0,0 +1,2 @@
+export declare const ip = "10.19.0.111";
+export declare const commandPort = 25565;

package/dist/generated/ecu/constants.js

@@ -0,0 +1,2 @@
+export const ip = "10.19.0.111";
+export const commandPort = 25565;

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

@@ -0,0 +1,2 @@
+export * as commands from "./commands";
+export * as telemetry from "./telemetry";

package/dist/generated/ecu/index.js

@@ -0,0 +1,2 @@
+export * as commands from "./commands";
+export * as telemetry from "./telemetry";

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

@@ -0,0 +1,128 @@
+import bin, { MaxValue, Schema, type IMeasurer, type ISerialInput, type ISerialOutput } from 'typed-binary';
+declare class UInt64Schema extends Schema<bigint> {
+    readonly maxSize = 8;
+    read(input: ISerialInput): bigint;
+    write(output: ISerialOutput, value: bigint): void;
+    measure(_: bigint | typeof MaxValue, measurer?: IMeasurer): IMeasurer;
+}
+export declare const actuators_servo_ServoMode: {
+    readonly kUnknown: 0;
+    readonly kPosition: 1;
+    readonly kCalibrate: 2;
+};
+export type actuators_servo_ServoMode = (typeof actuators_servo_ServoMode)[keyof typeof actuators_servo_ServoMode];
+export declare const actuators_servo_PowerState: {
+    readonly kUnknown: 0;
+    readonly kOff: 1;
+    readonly kBooting: 2;
+    readonly kOn: 3;
+};
+export type actuators_servo_PowerState = (typeof actuators_servo_PowerState)[keyof typeof actuators_servo_PowerState];
+export declare const actuators_solenoid_PowerState: {
+    readonly kUnknown: 0;
+    readonly kOff: 1;
+    readonly kOn: 2;
+};
+export type actuators_solenoid_PowerState = (typeof actuators_solenoid_PowerState)[keyof typeof actuators_solenoid_PowerState];
+export declare const actuators_solenoid_Opening: {
+    readonly kUnknown: 0;
+    readonly kClosed: 1;
+    readonly kOpen: 2;
+};
+export type actuators_solenoid_Opening = (typeof actuators_solenoid_Opening)[keyof typeof actuators_solenoid_Opening];
+export declare const actuators_servo_ServoStatus: 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;
+    current_ma: import("typed-binary").Float32Schema;
+    mode: import("typed-binary").ByteSchema;
+    power_state: import("typed-binary").ByteSchema;
+}>;
+export type actuators_servo_ServoStatus = bin.Parsed<typeof actuators_servo_ServoStatus>;
+export declare const BldcTelemetry: import("typed-binary").ObjectSchema<{
+    valve_position: import("typed-binary").Float32Schema;
+    motor_position: import("typed-binary").Float32Schema;
+    timestamp: UInt64Schema;
+    current_draw: import("typed-binary").Float32Schema;
+    u_p: import("typed-binary").Float32Schema;
+    u_i: import("typed-binary").Float32Schema;
+    u_d: import("typed-binary").Float32Schema;
+    u_pid: import("typed-binary").Float32Schema;
+    u_ff: import("typed-binary").Float32Schema;
+    u_set: import("typed-binary").Float32Schema;
+    u_total: import("typed-binary").Float32Schema;
+    position_raw: import("typed-binary").Float32Schema;
+    calibrated: import("typed-binary").ByteSchema;
+}>;
+export type BldcTelemetry = bin.Parsed<typeof BldcTelemetry>;
+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 spec: {
+    readonly actuators_servo_ServoStatus: {
+        readonly port: 5003;
+        readonly 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;
+            current_ma: import("typed-binary").Float32Schema;
+            mode: import("typed-binary").ByteSchema;
+            power_state: import("typed-binary").ByteSchema;
+        }>;
+        readonly enums: {
+            readonly mode: {
+                readonly kUnknown: 0;
+                readonly kPosition: 1;
+                readonly kCalibrate: 2;
+            };
+            readonly power_state: {
+                readonly kUnknown: 0;
+                readonly kOff: 1;
+                readonly kBooting: 2;
+                readonly kOn: 3;
+            };
+        };
+    };
+    readonly BldcTelemetry: {
+        readonly port: 5000;
+        readonly schema: import("typed-binary").ObjectSchema<{
+            valve_position: import("typed-binary").Float32Schema;
+            motor_position: import("typed-binary").Float32Schema;
+            timestamp: UInt64Schema;
+            current_draw: import("typed-binary").Float32Schema;
+            u_p: import("typed-binary").Float32Schema;
+            u_i: import("typed-binary").Float32Schema;
+            u_d: import("typed-binary").Float32Schema;
+            u_pid: import("typed-binary").Float32Schema;
+            u_ff: import("typed-binary").Float32Schema;
+            u_set: import("typed-binary").Float32Schema;
+            u_total: import("typed-binary").Float32Schema;
+            position_raw: import("typed-binary").Float32Schema;
+            calibrated: import("typed-binary").ByteSchema;
+        }>;
+        readonly enums: {};
+    };
+    readonly actuators_solenoid_SolenoidStatus: {
+        readonly port: 5004;
+        readonly schema: import("typed-binary").ObjectSchema<{
+            power_state: import("typed-binary").ByteSchema;
+            opening: import("typed-binary").ByteSchema;
+        }>;
+        readonly enums: {
+            readonly power_state: {
+                readonly kUnknown: 0;
+                readonly kOff: 1;
+                readonly kOn: 2;
+            };
+            readonly opening: {
+                readonly kUnknown: 0;
+                readonly kClosed: 1;
+                readonly kOpen: 2;
+            };
+        };
+    };
+};
+export default spec;
+export type Spec = typeof spec;

package/dist/generated/ecu/telemetry.js

@@ -0,0 +1,134 @@
+import bin, { Measurer, Schema } from 'typed-binary';
+// This file was generated by FRICC on 2026-03-19 10:00: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;
+class UInt64Schema extends Schema {
+    maxSize = 8;
+    read(input) {
+        const bytes = new Uint8Array(8);
+        input.readSlice(bytes, 0, 8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        return view.getBigUint64(0, __littleEndian);
+    }
+    write(output, value) {
+        const bytes = new Uint8Array(8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        view.setBigUint64(0, value, __littleEndian);
+        output.writeSlice(bytes);
+    }
+    measure(_, measurer = new Measurer()) {
+        return measurer.add(8);
+    }
+}
+class Int64Schema extends Schema {
+    maxSize = 8;
+    read(input) {
+        const bytes = new Uint8Array(8);
+        input.readSlice(bytes, 0, 8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        return view.getBigInt64(0, __littleEndian);
+    }
+    write(output, value) {
+        const bytes = new Uint8Array(8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        view.setBigInt64(0, value, __littleEndian);
+        output.writeSlice(bytes);
+    }
+    measure(_, measurer = new Measurer()) {
+        return measurer.add(8);
+    }
+}
+class Float64Schema extends Schema {
+    maxSize = 8;
+    read(input) {
+        const bytes = new Uint8Array(8);
+        input.readSlice(bytes, 0, 8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        return view.getFloat64(0, __littleEndian);
+    }
+    write(output, value) {
+        const bytes = new Uint8Array(8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        view.setFloat64(0, value, __littleEndian);
+        output.writeSlice(bytes);
+    }
+    measure(_, measurer = new Measurer()) {
+        return measurer.add(8);
+    }
+}
+const u64 = new UInt64Schema();
+const i64 = new Int64Schema();
+const f64 = new Float64Schema();
+export const actuators_servo_ServoMode = {
+    kUnknown: 0,
+    kPosition: 1,
+    kCalibrate: 2,
+};
+export const actuators_servo_PowerState = {
+    kUnknown: 0,
+    kOff: 1,
+    kBooting: 2,
+    kOn: 3,
+};
+export const actuators_solenoid_PowerState = {
+    kUnknown: 0,
+    kOff: 1,
+    kOn: 2,
+};
+export const actuators_solenoid_Opening = {
+    kUnknown: 0,
+    kClosed: 1,
+    kOpen: 2,
+};
+export const actuators_servo_ServoStatus = bin.object({
+    commanded_angle_deg: bin.f32, // float
+    target_angle_deg: bin.f32, // float
+    measured_angle_deg: bin.f32, // float
+    current_ma: bin.f32, // float
+    mode: bin.u8, // actuators::servo::ServoMode
+    power_state: bin.u8, // actuators::servo::PowerState
+});
+export const BldcTelemetry = bin.object({
+    valve_position: bin.f32, // float
+    motor_position: bin.f32, // float
+    timestamp: u64, // unsigned long long
+    current_draw: bin.f32, // float
+    u_p: bin.f32, // float
+    u_i: bin.f32, // float
+    u_d: bin.f32, // float
+    u_pid: bin.f32, // float
+    u_ff: bin.f32, // float
+    u_set: bin.f32, // float
+    u_total: bin.f32, // float
+    position_raw: bin.f32, // float
+    calibrated: bin.u8, // unsigned char
+});
+export const actuators_solenoid_SolenoidStatus = bin.object({
+    power_state: bin.u8, // actuators::solenoid::PowerState
+    opening: bin.u8, // actuators::solenoid::Opening
+});
+export const spec = {
+    actuators_servo_ServoStatus: {
+        port: 5003,
+        schema: actuators_servo_ServoStatus,
+        enums: {
+            mode: actuators_servo_ServoMode,
+            power_state: actuators_servo_PowerState,
+        },
+    },
+    BldcTelemetry: {
+        port: 5000,
+        schema: BldcTelemetry,
+        enums: {},
+    },
+    actuators_solenoid_SolenoidStatus: {
+        port: 5004,
+        schema: actuators_solenoid_SolenoidStatus,
+        enums: {
+            power_state: actuators_solenoid_PowerState,
+            opening: actuators_solenoid_Opening,
+        },
+    },
+};
+export default spec;

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

@@ -0,0 +1,3 @@
+export declare const spec: {};
+export default spec;
+export type Spec = typeof spec;

package/dist/generated/fc/commands.js

@@ -0,0 +1,64 @@
+import { Measurer, Schema } from 'typed-binary';
+// This file was generated by FRICC on 2026-03-19 11:27:20. 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;
+class UInt64Schema extends Schema {
+    maxSize = 8;
+    read(input) {
+        const bytes = new Uint8Array(8);
+        input.readSlice(bytes, 0, 8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        return view.getBigUint64(0, __littleEndian);
+    }
+    write(output, value) {
+        const bytes = new Uint8Array(8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        view.setBigUint64(0, value, __littleEndian);
+        output.writeSlice(bytes);
+    }
+    measure(_, measurer = new Measurer()) {
+        return measurer.add(8);
+    }
+}
+class Int64Schema extends Schema {
+    maxSize = 8;
+    read(input) {
+        const bytes = new Uint8Array(8);
+        input.readSlice(bytes, 0, 8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        return view.getBigInt64(0, __littleEndian);
+    }
+    write(output, value) {
+        const bytes = new Uint8Array(8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        view.setBigInt64(0, value, __littleEndian);
+        output.writeSlice(bytes);
+    }
+    measure(_, measurer = new Measurer()) {
+        return measurer.add(8);
+    }
+}
+class Float64Schema extends Schema {
+    maxSize = 8;
+    read(input) {
+        const bytes = new Uint8Array(8);
+        input.readSlice(bytes, 0, 8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        return view.getFloat64(0, __littleEndian);
+    }
+    write(output, value) {
+        const bytes = new Uint8Array(8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        view.setFloat64(0, value, __littleEndian);
+        output.writeSlice(bytes);
+    }
+    measure(_, measurer = new Measurer()) {
+        return measurer.add(8);
+    }
+}
+const u64 = new UInt64Schema();
+const i64 = new Int64Schema();
+const f64 = new Float64Schema();
+export const spec = {};
+export default spec;

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

@@ -0,0 +1 @@
+export declare const ip = "10.19.0.110";

package/dist/generated/fc/constants.js

@@ -0,0 +1 @@
+export const ip = "10.19.0.110";

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

@@ -0,0 +1,2 @@
+export * as commands from "./commands";
+export * as telemetry from "./telemetry";

package/dist/generated/fc/index.js

@@ -0,0 +1,2 @@
+export * as commands from "./commands";
+export * as telemetry from "./telemetry";

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

@@ -0,0 +1,5 @@
+export declare const spec: {
+    beans: number;
+};
+export default spec;
+export type Spec = typeof spec;

package/dist/generated/fc/telemetry.js

@@ -0,0 +1,66 @@
+import { Measurer, Schema } from 'typed-binary';
+// This file was generated by FRICC on 2026-03-19 11:27:31. 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;
+class UInt64Schema extends Schema {
+    maxSize = 8;
+    read(input) {
+        const bytes = new Uint8Array(8);
+        input.readSlice(bytes, 0, 8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        return view.getBigUint64(0, __littleEndian);
+    }
+    write(output, value) {
+        const bytes = new Uint8Array(8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        view.setBigUint64(0, value, __littleEndian);
+        output.writeSlice(bytes);
+    }
+    measure(_, measurer = new Measurer()) {
+        return measurer.add(8);
+    }
+}
+class Int64Schema extends Schema {
+    maxSize = 8;
+    read(input) {
+        const bytes = new Uint8Array(8);
+        input.readSlice(bytes, 0, 8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        return view.getBigInt64(0, __littleEndian);
+    }
+    write(output, value) {
+        const bytes = new Uint8Array(8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        view.setBigInt64(0, value, __littleEndian);
+        output.writeSlice(bytes);
+    }
+    measure(_, measurer = new Measurer()) {
+        return measurer.add(8);
+    }
+}
+class Float64Schema extends Schema {
+    maxSize = 8;
+    read(input) {
+        const bytes = new Uint8Array(8);
+        input.readSlice(bytes, 0, 8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        return view.getFloat64(0, __littleEndian);
+    }
+    write(output, value) {
+        const bytes = new Uint8Array(8);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        view.setFloat64(0, value, __littleEndian);
+        output.writeSlice(bytes);
+    }
+    measure(_, measurer = new Measurer()) {
+        return measurer.add(8);
+    }
+}
+const u64 = new UInt64Schema();
+const i64 = new Int64Schema();
+const f64 = new Float64Schema();
+export const spec = {
+    beans: 1,
+};
+export default spec;

package/dist/generated/index.d.ts

@@ -0,0 +1,2 @@
+export * as ecu from "./ecu";
+export * as fc from "./fc";

package/dist/generated/index.js

@@ -0,0 +1,2 @@
+export * as ecu from "./ecu";
+export * as fc from "./fc";

package/dist/index.d.ts

@@ -1,7 +1,3 @@
-import * as ecu from './ecu';
-import * as fc from './fc';
-export declare const mcu: {
-    ecu: typeof ecu;
-    fc: typeof fc;
-};
+export * as mcu from './generated';
+export * as constants from './constants';
 export * as types from './types';

package/dist/index.js

@@ -1,7 +1,3 @@
-import * as ecu from './ecu';
-import * as fc from './fc';
-export const mcu = {
-    ecu,
-    fc,
-};
+export * as mcu from './generated';
+export * as constants from './constants';
 export * as types from './types';

package/dist/types.d.ts

@@ -1,14 +1,14 @@
 import { AnyObjectSchema } from 'typed-binary';
-import * as ecu from './ecu';
+import * as mcu from './generated';
 type EnumTree = {
     [key: string]: number | EnumTree;
 };
 type Widen<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T extends AnyObjectSchema ? AnyObjectSchema : T extends EnumTree ? EnumTree : {
     [K in keyof T]: Widen<T[K]>;
 };
-type MergeAll<T extends Record<string, object>> = {
+type MergeAll<T extends object> = {
     [K in keyof T[keyof T]]: T[keyof T][K & keyof T[keyof T]];
 };
-export type TelemetrySpec = MergeAll<Widen<ecu.telemetry.Spec>>;
-export type CommandSpec = MergeAll<Widen<ecu.commands.Spec>>;
+export type TelemetrySpec = MergeAll<Widen<mcu.ecu.telemetry.Spec>>;
+export type CommandSpec = MergeAll<Widen<mcu.ecu.commands.Spec>>;
 export {};

package/dist/types.js

@@ -1 +1,2 @@
+// This file contains generic types for telemetry and command specs.
 export {};

package/package.json

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