@robdobsn/raftjs 1.11.5 → 1.11.6

package/src/RaftAttributeHandler.ts

@@ -37,7 +37,7 @@ export default class AttributeHandler {
         const msgDataStartIdx = msgBufIdx;
 
         // New attribute values (in order as they appear in the attributes JSON)
-        let newAttrValues: number[][] = [];
+        let newAttrValues: (number | string)[][] = [];
         if ("c" in pollRespMetadata) {
 
             // Extract attribute values using custom handler
@@ -201,7 +201,7 @@ export default class AttributeHandler {
         }
     }
 
-    private processMsgAttribute(attrDef: DeviceTypeAttribute, msgBuffer: Uint8Array, msgBufIdx: number, msgDataStartIdx: number): { values: number[], newMsgBufIdx: number} {
+    private processMsgAttribute(attrDef: DeviceTypeAttribute, msgBuffer: Uint8Array, msgBufIdx: number, msgDataStartIdx: number): { values: (number | string)[], newMsgBufIdx: number} {
 
         // Current field message string index
         let curFieldBufIdx = msgBufIdx;
@@ -253,11 +253,14 @@ export default class AttributeHandler {
 
         // Extract the value using python-struct
         const unpackValues = structUnpack(maskOnSignedValue ? attrTypesOnly.toUpperCase() : attrTypesOnly, attrBuf);
-        let attrValues = unpackValues as number[];
+        let attrValues = unpackValues as (number | string)[];
 
         // Get number of bytes consumed
         const numBytesConsumed = structSizeOf(attrTypesOnly);
 
+        // Check if any values are strings (from 's' format) — skip numeric transforms for those
+        const hasStringValues = attrValues.some(v => typeof v === 'string');
+
         // // Check if sign extendable mask specified on signed value
         // if (mmSpecifiedOnSignedValue) {
         //     const signBitMask = 1 << (signExtendableMaskSignPos - 1);
@@ -270,57 +273,57 @@ export default class AttributeHandler {
         // }
 
         // Check for XOR mask
-        if ("x" in attrDef) {
+        if (!hasStringValues && "x" in attrDef) {
             const mask = typeof attrDef.x === "string" ? parseInt(attrDef.x, 16) : attrDef.x as number;
-            attrValues = attrValues.map((value) => (value >>> 0) ^ mask);
+            attrValues = attrValues.map((value) => ((value as number) >>> 0) ^ mask);
         }
         
         // Check for AND mask
-        if ("m" in attrDef) {
+        if (!hasStringValues && "m" in attrDef) {
             const mask = typeof attrDef.m === "string" ? parseInt(attrDef.m, 16) : attrDef.m as number;
-            attrValues = attrValues.map((value) => (maskOnSignedValue ? this.signExtend(value, mask) : (value >>> 0) & mask));
+            attrValues = attrValues.map((value) => (maskOnSignedValue ? this.signExtend(value as number, mask) : ((value as number) >>> 0) & mask));
         }
 
         // Check for a sign-bit
-        if ("sb" in attrDef) {
+        if (!hasStringValues && "sb" in attrDef) {
             const signBitPos = attrDef.sb as number;
             const signBitMask = 1 << signBitPos;
             if ("ss" in attrDef) {
                 const signBitSubtract = attrDef.ss as number;
-                attrValues = attrValues.map((value) => (value & signBitMask) ? signBitSubtract - value : value);
+                attrValues = attrValues.map((value) => ((value as number) & signBitMask) ? signBitSubtract - (value as number) : value);
             } else {
-                attrValues = attrValues.map((value) => (value & signBitMask) ? value - (signBitMask << 1) : value);
+                attrValues = attrValues.map((value) => ((value as number) & signBitMask) ? (value as number) - (signBitMask << 1) : value);
             }
         }
 
         // Check for bit shift required
-        if ("s" in attrDef && attrDef.s) {
+        if (!hasStringValues && "s" in attrDef && attrDef.s) {
             const bitshift = attrDef.s as number;
             if (bitshift > 0) {
-                attrValues = attrValues.map((value) => (value >>> 0) >>> bitshift);
+                attrValues = attrValues.map((value) => ((value as number) >>> 0) >>> bitshift);
             } else if (bitshift < 0) {
-                attrValues = attrValues.map((value) => (value >>> 0) << -bitshift);
+                attrValues = attrValues.map((value) => ((value as number) >>> 0) << -bitshift);
             }
         }
 
         // Check for divisor
-        if ("d" in attrDef && attrDef.d) {
+        if (!hasStringValues && "d" in attrDef && attrDef.d) {
             const divisor = attrDef.d as number;
-            attrValues = attrValues.map((value) => (value) / divisor);
+            attrValues = attrValues.map((value) => (value as number) / divisor);
         }
 
         // Check for value to add
-        if ("a" in attrDef && attrDef.a !== undefined) {
+        if (!hasStringValues && "a" in attrDef && attrDef.a !== undefined) {
             const addValue = attrDef.a as number;
-            attrValues = attrValues.map((value) => (value) + addValue);
+            attrValues = attrValues.map((value) => (value as number) + addValue);
         }
 
         // Apply lookup table if defined
-        if ("lut" in attrDef && attrDef.lut !== undefined) {
+        if (!hasStringValues && "lut" in attrDef && attrDef.lut !== undefined) {
             attrValues = attrValues.map((value): number => {
                 // Skip NaN values
-                if (isNaN(value)) {
-                    return value;
+                if (isNaN(value as number)) {
+                    return value as number;
                 }
 
                 // Search through the lookup table rows for a match
@@ -334,7 +337,7 @@ export default class AttributeHandler {
                     }
                     
                     // Parse the range string
-                    if (this.isValueInRangeString(value, row.r)) {
+                    if (this.isValueInRangeString(value as number, row.r)) {
                         return row.v;
                     }
                 }
@@ -345,7 +348,7 @@ export default class AttributeHandler {
                 }
                 
                 // Otherwise keep the original value
-                return value;
+                return value as number;
             });
         }
 

package/src/RaftDeviceManager.ts

@@ -23,7 +23,7 @@ export interface DeviceDecodedData {
     deviceAddress: string;
     deviceType: string;
     attrGroupName?: string;
-    attrValues: Record<string, number[]>;
+    attrValues: Record<string, (number | string)[]>;
     timestampsUs: number[];
     markers?: Record<string, unknown>;
     fromOfflineBuffer?: boolean;
@@ -956,7 +956,7 @@ export class DeviceManager implements RaftDeviceMgrIF{
             return;
         }
 
-        const attrValues: Record<string, number[]> = {};
+        const attrValues: Record<string, (number | string)[]> = {};
         let hasValues = false;
 
         pollRespMetadata.a.forEach((attr) => {

package/src/RaftDeviceStates.ts

@@ -14,10 +14,14 @@ export function deviceAttrGetLatestFormatted(attrState: DeviceAttributeState): s
     if (attrState.values.length === 0) {
         return 'N/A';
     }
+    const value = attrState.values[attrState.values.length - 1];
+    // String values are returned directly
+    if (typeof value === 'string') {
+        return value;
+    }
     if (attrState.format.length === 0) {
-        return attrState.values[attrState.values.length - 1].toString();
+        return value.toString();
     }
-    const value = attrState.values[attrState.values.length - 1];
     let format = attrState.format;
     if (format.startsWith("%")) {
         format = format.slice(1);
@@ -52,7 +56,7 @@ export interface DeviceAttributeState {
     newAttribute: boolean;
     newData: boolean;
     numNewValues: number;
-    values: number[];
+    values: (number | string)[];
     units: string;
     range: number[];
     format: string;

package/src/RaftStruct.test.ts

@@ -0,0 +1,229 @@
+import { structUnpack, structPack, structSizeOf } from "./RaftStruct";
+
+// Helper to create Uint8Array from byte values
+function bytes(...vals: number[]): Uint8Array {
+    return new Uint8Array(vals);
+}
+
+// ===== Existing functionality (regression tests) =====
+
+describe("structUnpack", () => {
+    test("single B", () => {
+        expect(structUnpack("B", bytes(0xff))).toEqual([255]);
+    });
+
+    test("single b (signed)", () => {
+        expect(structUnpack("b", bytes(0xff))).toEqual([-1]);
+    });
+
+    test("<H little-endian uint16", () => {
+        expect(structUnpack("<H", bytes(0x01, 0x02))).toEqual([0x0201]);
+    });
+
+    test(">H big-endian uint16", () => {
+        expect(structUnpack(">H", bytes(0x01, 0x02))).toEqual([0x0102]);
+    });
+
+    test("BBBB four bytes", () => {
+        expect(structUnpack("BBBB", bytes(1, 2, 3, 4))).toEqual([1, 2, 3, 4]);
+    });
+
+    test("<I little-endian uint32", () => {
+        const buf = bytes(0x78, 0x56, 0x34, 0x12);
+        expect(structUnpack("<I", buf)).toEqual([0x12345678]);
+    });
+
+    test(">I big-endian uint32", () => {
+        const buf = bytes(0x12, 0x34, 0x56, 0x78);
+        expect(structUnpack(">I", buf)).toEqual([0x12345678]);
+    });
+
+    test("[N] bracket repeat", () => {
+        expect(structUnpack("B[3]", bytes(10, 20, 30))).toEqual([10, 20, 30]);
+    });
+
+    test("x padding skips byte", () => {
+        expect(structUnpack("xB", bytes(0xff, 0x42))).toEqual([0x42]);
+    });
+
+    test("<f float32", () => {
+        const buf = new Uint8Array(4);
+        new DataView(buf.buffer).setFloat32(0, 3.14, true);
+        const result = structUnpack("<f", buf);
+        expect(result[0]).toBeCloseTo(3.14, 2);
+    });
+});
+
+// ===== Prefix digit syntax =====
+
+describe("prefix digit syntax", () => {
+    test("3B equivalent to BBB", () => {
+        expect(structUnpack("3B", bytes(1, 2, 3))).toEqual([1, 2, 3]);
+    });
+
+    test("2H two uint16s", () => {
+        expect(structUnpack(">2H", bytes(0, 1, 0, 2))).toEqual([1, 2]);
+    });
+
+    test("prefix and bracket multiply", () => {
+        // 2B[3] means repeat=6
+        expect(structUnpack("2B[3]", bytes(1, 2, 3, 4, 5, 6))).toEqual([1, 2, 3, 4, 5, 6]);
+    });
+
+    test("prefix digits in structSizeOf", () => {
+        expect(structSizeOf("3B")).toBe(3);
+        expect(structSizeOf(">2H")).toBe(4);
+        expect(structSizeOf("2I")).toBe(8);
+    });
+
+    test("prefix digits in structPack", () => {
+        const packed = structPack("3B", [10, 20, 30]);
+        expect(Array.from(packed)).toEqual([10, 20, 30]);
+    });
+
+    test("multi-digit prefix count", () => {
+        expect(structSizeOf("16s")).toBe(16);
+        expect(structSizeOf("10B")).toBe(10);
+    });
+});
+
+// ===== s format code =====
+
+describe("s format (byte strings)", () => {
+    test("unpack 5s reads a string", () => {
+        const buf = bytes(0x48, 0x65, 0x6c, 0x6c, 0x6f); // "Hello"
+        expect(structUnpack("5s", buf)).toEqual(["Hello"]);
+    });
+
+    test("unpack s with trailing nulls trims them", () => {
+        const buf = bytes(0x48, 0x69, 0x00, 0x00, 0x00); // "Hi\0\0\0"
+        expect(structUnpack("5s", buf)).toEqual(["Hi"]);
+    });
+
+    test("unpack s produces one value regardless of count", () => {
+        const buf = bytes(0x41, 0x42, 0x43); // "ABC"
+        const result = structUnpack("3s", buf);
+        expect(result).toHaveLength(1);
+        expect(result[0]).toBe("ABC");
+    });
+
+    test("s combined with other types", () => {
+        // B then 3s then B
+        const buf = bytes(0xff, 0x41, 0x42, 0x43, 0x01);
+        const result = structUnpack("B3sB", buf);
+        expect(result).toEqual([255, "ABC", 1]);
+    });
+
+    test("structSizeOf with s", () => {
+        expect(structSizeOf("5s")).toBe(5);
+        expect(structSizeOf("B5sH")).toBe(8); // 1 + 5 + 2
+        expect(structSizeOf(">16s")).toBe(16);
+    });
+
+    test("structPack with string value", () => {
+        const packed = structPack("5s", ["Hello"]);
+        expect(Array.from(packed)).toEqual([0x48, 0x65, 0x6c, 0x6c, 0x6f]);
+    });
+
+    test("structPack s zero-pads short strings", () => {
+        const packed = structPack("5s", ["Hi"]);
+        expect(Array.from(packed)).toEqual([0x48, 0x69, 0x00, 0x00, 0x00]);
+    });
+
+    test("structPack s with Uint8Array value", () => {
+        const packed = structPack("3s", [bytes(0x01, 0x02, 0x03)]);
+        expect(Array.from(packed)).toEqual([1, 2, 3]);
+    });
+
+    test("structPack s combined with numeric types", () => {
+        const packed = structPack("B3sB", [0xff, "ABC", 0x01]);
+        expect(Array.from(packed)).toEqual([0xff, 0x41, 0x42, 0x43, 0x01]);
+    });
+
+    test("round-trip pack/unpack s", () => {
+        const original = "Test";
+        const packed = structPack("8s", [original]);
+        const [unpacked] = structUnpack("8s", packed);
+        expect(unpacked).toBe(original);
+    });
+});
+
+// ===== q/Q 64-bit integers =====
+
+describe("q/Q 64-bit integers", () => {
+    test("unpack >q signed 64-bit", () => {
+        // 0x0000000000000001 = 1
+        const buf = bytes(0, 0, 0, 0, 0, 0, 0, 1);
+        expect(structUnpack(">q", buf)).toEqual([1]);
+    });
+
+    test("unpack >Q unsigned 64-bit", () => {
+        const buf = bytes(0, 0, 0, 0, 0, 0, 0, 42);
+        expect(structUnpack(">Q", buf)).toEqual([42]);
+    });
+
+    test("unpack <q little-endian", () => {
+        const buf = new Uint8Array(8);
+        new DataView(buf.buffer).setBigInt64(0, BigInt(-1000), true);
+        expect(structUnpack("<q", buf)).toEqual([-1000]);
+    });
+
+    test("unpack >q negative", () => {
+        const buf = new Uint8Array(8);
+        new DataView(buf.buffer).setBigInt64(0, BigInt(-1), false);
+        expect(structUnpack(">q", buf)).toEqual([-1]);
+    });
+
+    test("structSizeOf q and Q", () => {
+        expect(structSizeOf("q")).toBe(8);
+        expect(structSizeOf("Q")).toBe(8);
+        expect(structSizeOf(">qQ")).toBe(16);
+    });
+
+    test("structPack >q", () => {
+        const packed = structPack(">q", [1]);
+        expect(Array.from(packed)).toEqual([0, 0, 0, 0, 0, 0, 0, 1]);
+    });
+
+    test("structPack <Q", () => {
+        const packed = structPack("<Q", [256]);
+        const view = new DataView(packed.buffer);
+        expect(Number(view.getBigUint64(0, true))).toBe(256);
+    });
+
+    test("round-trip q", () => {
+        const packed = structPack(">q", [-123456789]);
+        const [unpacked] = structUnpack(">q", packed);
+        expect(unpacked).toBe(-123456789);
+    });
+
+    test("round-trip Q", () => {
+        const packed = structPack(">Q", [123456789]);
+        const [unpacked] = structUnpack(">Q", packed);
+        expect(unpacked).toBe(123456789);
+    });
+});
+
+// ===== Error handling =====
+
+describe("error handling", () => {
+    test("unknown format code throws", () => {
+        expect(() => structUnpack("Z", bytes(0))).toThrow("Unknown format character");
+    });
+
+    test("missing ] throws", () => {
+        expect(() => structUnpack("B[3", bytes(1, 2, 3))).toThrow("missing closing ]");
+    });
+
+    test("digit without format code throws", () => {
+        expect(() => structUnpack("3", bytes(1, 2, 3))).toThrow("Expected format code after prefix count");
+    });
+
+    test("structPack insufficient values throws", () => {
+        expect(() => structPack("HH", [1])).toThrow("Insufficient values");
+    });
+
+    test("structPack s with number throws", () => {
+        expect(() => structPack("3s", [42])).toThrow("Expected string or Uint8Array");
+    });
+});

package/src/RaftStruct.ts

@@ -33,22 +33,40 @@ function parseFormatInstructions(format: string): FormatInstruction[] {
             continue;
         }
 
+        // Check for prefix digit count (e.g. 3H, 16s)
+        let repeat = 1;
+        if (/\d/.test(char)) {
+            let numStr = char;
+            idx++;
+            while (idx < format.length && /\d/.test(format[idx])) {
+                numStr += format[idx];
+                idx++;
+            }
+            repeat = parseInt(numStr, 10);
+            if (!Number.isFinite(repeat) || repeat <= 0) {
+                throw new Error(`Invalid prefix count "${numStr}" in format string "${format}"`);
+            }
+            if (idx >= format.length || /[\s<>\d]/.test(format[idx])) {
+                throw new Error(`Expected format code after prefix count "${numStr}" in format string "${format}"`);
+            }
+        }
+
         // Attribute code
-        const code = char;
-        idx++;
+        const code = /\d/.test(char) ? format[idx] : char;
+        if (/\d/.test(char)) idx++; else idx++;
 
-        // Check for repeat count using [N] syntax
-        let repeat = 1;
+        // Check for [N] suffix count (e.g. B[3]) — multiplied with any prefix count
         if (idx < format.length && format[idx] === "[") {
             const endIdx = format.indexOf("]", idx + 1);
             if (endIdx === -1) {
                 throw new Error(`Invalid format string: missing closing ] in "${format}"`);
             }
             const repeatStr = format.slice(idx + 1, endIdx);
-            repeat = parseInt(repeatStr, 10);
-            if (!Number.isFinite(repeat) || repeat <= 0) {
+            const bracketRepeat = parseInt(repeatStr, 10);
+            if (!Number.isFinite(bracketRepeat) || bracketRepeat <= 0) {
                 throw new Error(`Invalid repeat count "${repeatStr}" in format string "${format}"`);
             }
+            repeat *= bracketRepeat;
             idx = endIdx + 1;
         }
 
@@ -58,9 +76,9 @@ function parseFormatInstructions(format: string): FormatInstruction[] {
     return instructions;
 }
 
-export function structUnpack(format: string, data: Uint8Array): number[] {
+export function structUnpack(format: string, data: Uint8Array): (number | string)[] {
     const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
-    const results: number[] = [];
+    const results: (number | string)[] = [];
     let offset = 0;
     let littleEndian = false;
 
@@ -107,14 +125,14 @@ export function structUnpack(format: string, data: Uint8Array): number[] {
                     results.push(view.getUint32(offset, littleEndian));
                     offset += 4;
                     break;
-                // case "q": // Signed 64-bit integer
-                //     results.push(Number(view.getBigInt64(offset, littleEndian)));
-                //     offset += 8;
-                //     break;
-                // case "Q": // Unsigned 64-bit integer
-                //     results.push(Number(view.getBigUint64(offset, littleEndian)));
-                //     offset += 8;
-                //     break;
+                case "q": // Signed 64-bit integer
+                    results.push(Number(view.getBigInt64(offset, littleEndian)));
+                    offset += 8;
+                    break;
+                case "Q": // Unsigned 64-bit integer
+                    results.push(Number(view.getBigUint64(offset, littleEndian)));
+                    offset += 8;
+                    break;
                 case "f": // 32-bit float
                     results.push(view.getFloat32(offset, littleEndian));
                     offset += 4;
@@ -123,9 +141,20 @@ export function structUnpack(format: string, data: Uint8Array): number[] {
                     results.push(view.getFloat64(offset, littleEndian));
                     offset += 8;
                     break;
+                case "s": { // Byte string (repeat = byte length, produces one string value)
+                    const bytes = data.slice(offset, offset + repeat);
+                    // Trim trailing null bytes for C-string compatibility
+                    let end = bytes.length;
+                    while (end > 0 && bytes[end - 1] === 0) end--;
+                    results.push(new TextDecoder().decode(bytes.subarray(0, end)));
+                    offset += repeat;
+                    break;
+                }
                 default:
                     throw new Error(`Unknown format character: ${code}`);
             }
+            // For 's', the repeat is consumed as byte-length in one go
+            if (code === "s") break;
         }
     }
 
@@ -162,16 +191,19 @@ export function structSizeOf(format: string): number {
             case "L": // Unsigned 32-bit integer
                 unitSize = 4;
                 break;
-            // case "q": // Signed 64-bit integer
-            // case "Q": // Unsigned 64-bit integer
-            //     unitSize = 8;
-            //     break;
+            case "q": // Signed 64-bit integer
+            case "Q": // Unsigned 64-bit integer
+                unitSize = 8;
+                break;
             case "f": // 32-bit float
                 unitSize = 4;
                 break;
             case "d": // 64-bit float
                 unitSize = 8;
                 break;
+            case "s": // Byte string (repeat = byte length)
+                size += repeat;
+                continue;
             default:
                 throw new Error(`Unknown format character: ${code}`);
         }
@@ -181,7 +213,7 @@ export function structSizeOf(format: string): number {
     return size;
 }
 
-export function structPack(format: string, values: number[]): Uint8Array {
+export function structPack(format: string, values: (number | string | Uint8Array)[]): Uint8Array {
     const size = structSizeOf(format);
     const buffer = new ArrayBuffer(size);
     const view = new DataView(buffer);
@@ -209,7 +241,7 @@ export function structPack(format: string, values: number[]): Uint8Array {
                     if (valueIdx >= values.length) {
                         throw new Error("Insufficient values provided for structPack");
                     }
-                    view.setInt8(offset, values[valueIdx++]);
+                    view.setInt8(offset, values[valueIdx++] as number);
                     offset += 1;
                     break;
                 case "B": // Unsigned 8-bit integer
@@ -217,21 +249,21 @@ export function structPack(format: string, values: number[]): Uint8Array {
                     if (valueIdx >= values.length) {
                         throw new Error("Insufficient values provided for structPack");
                     }
-                    view.setUint8(offset, values[valueIdx++]);
+                    view.setUint8(offset, values[valueIdx++] as number);
                     offset += 1;
                     break;
                 case "h": // Signed 16-bit integer
                     if (valueIdx >= values.length) {
                         throw new Error("Insufficient values provided for structPack");
                     }
-                    view.setInt16(offset, values[valueIdx++], littleEndian);
+                    view.setInt16(offset, values[valueIdx++] as number, littleEndian);
                     offset += 2;
                     break;
                 case "H": // Unsigned 16-bit integer
                     if (valueIdx >= values.length) {
                         throw new Error("Insufficient values provided for structPack");
                     }
-                    view.setUint16(offset, values[valueIdx++], littleEndian);
+                    view.setUint16(offset, values[valueIdx++] as number, littleEndian);
                     offset += 2;
                     break;
                 case "i": // Signed 32-bit integer
@@ -239,7 +271,7 @@ export function structPack(format: string, values: number[]): Uint8Array {
                     if (valueIdx >= values.length) {
                         throw new Error("Insufficient values provided for structPack");
                     }
-                    view.setInt32(offset, values[valueIdx++], littleEndian);
+                    view.setInt32(offset, values[valueIdx++] as number, littleEndian);
                     offset += 4;
                     break;
                 case "I": // Unsigned 32-bit integer
@@ -247,34 +279,66 @@ export function structPack(format: string, values: number[]): Uint8Array {
                     if (valueIdx >= values.length) {
                         throw new Error("Insufficient values provided for structPack");
                     }
-                    view.setUint32(offset, values[valueIdx++], littleEndian);
+                    view.setUint32(offset, values[valueIdx++] as number, littleEndian);
                     offset += 4;
                     break;
-                // case "q": // Signed 64-bit integer
-                //     view.setBigInt64(offset, BigInt(values[valueIdx++]), littleEndian);
-                //     offset += 8;
-                //     break;
-                // case "Q": // Unsigned 64-bit integer
-                //     view.setBigUint64(offset, BigInt(values[valueIdx++]), littleEndian);
-                //     offset += 8;
-                //     break;
+                case "q": // Signed 64-bit integer
+                    if (valueIdx >= values.length) {
+                        throw new Error("Insufficient values provided for structPack");
+                    }
+                    view.setBigInt64(offset, BigInt(values[valueIdx++] as number), littleEndian);
+                    offset += 8;
+                    break;
+                case "Q": // Unsigned 64-bit integer
+                    if (valueIdx >= values.length) {
+                        throw new Error("Insufficient values provided for structPack");
+                    }
+                    view.setBigUint64(offset, BigInt(values[valueIdx++] as number), littleEndian);
+                    offset += 8;
+                    break;
                 case "f": // 32-bit float
                     if (valueIdx >= values.length) {
                         throw new Error("Insufficient values provided for structPack");
                     }
-                    view.setFloat32(offset, values[valueIdx++], littleEndian);
+                    view.setFloat32(offset, values[valueIdx++] as number, littleEndian);
                     offset += 4;
                     break;
                 case "d": // 64-bit float
                     if (valueIdx >= values.length) {
                         throw new Error("Insufficient values provided for structPack");
                     }
-                    view.setFloat64(offset, values[valueIdx++], littleEndian);
+                    view.setFloat64(offset, values[valueIdx++] as number, littleEndian);
                     offset += 8;
                     break;
+                case "s": { // Byte string (repeat = byte length, consumes one value)
+                    if (valueIdx >= values.length) {
+                        throw new Error("Insufficient values provided for structPack");
+                    }
+                    const val = values[valueIdx++];
+                    let bytes: Uint8Array;
+                    if (val instanceof Uint8Array) {
+                        bytes = val;
+                    } else if (typeof val === "string") {
+                        bytes = new TextEncoder().encode(val);
+                    } else {
+                        throw new Error(`Expected string or Uint8Array for 's' format, got number`);
+                    }
+                    // Copy bytes, zero-pad if shorter than repeat
+                    const copyLen = Math.min(bytes.length, repeat);
+                    for (let j = 0; j < copyLen; j++) {
+                        view.setUint8(offset + j, bytes[j]);
+                    }
+                    for (let j = copyLen; j < repeat; j++) {
+                        view.setUint8(offset + j, 0);
+                    }
+                    offset += repeat;
+                    break;
+                }
                 default:
                     throw new Error(`Unknown format character: ${code}`);
             }
+            // For 's', the repeat is consumed as byte-length in one go
+            if (code === "s") break;
         }
     }