@hangtime/grip-connect 0.13.0 → 0.13.1

package/src/models/device/aurora.model.ts

@@ -0,0 +1,497 @@
+import { Device } from "../device.model.js"
+import type { AuroraLedPlacement, IAurora } from "../../interfaces/device/aurora.interface.js"
+
+type AuroraApiLevel = 2 | 3
+
+interface AuroraPacketMarkers {
+  middle: AuroraPacket
+  first: AuroraPacket
+  last: AuroraPacket
+  only: AuroraPacket
+}
+
+interface AuroraResolvedPlacement {
+  position: number
+  colorHex: string
+}
+
+/**
+ * For API level 2 and API level 3.
+ * The first byte in the data is dependent on where the packet is in the message as a whole.
+ */
+export enum AuroraPacket {
+  /** If this packet is in the middle, the byte gets set to 77 (M). */
+  V2_MIDDLE = 77,
+  /** If this packet is the first packet in the message, then this byte gets set to 78 (N). */
+  V2_FIRST,
+  /** If this is the last packet in the message, this byte gets set to 79 (O). */
+  V2_LAST,
+  /** If this packet is the only packet in the message, the byte gets set to 80 (P). Note that this takes priority over the other conditions. */
+  V2_ONLY,
+  /** If this packet is in the middle, the byte gets set to 81 (Q). */
+  V3_MIDDLE,
+  /** If this packet is the first packet in the message, then this byte gets set to 82 (R). */
+  V3_FIRST,
+  /** If this is the last packet in the message, this byte gets set to 83 (S). */
+  V3_LAST,
+  /** If this packet is the only packet in the message, the byte gets set to 84 (T). Note that this takes priority over the other conditions. */
+  V3_ONLY,
+}
+
+/**
+ * Represents a Aurora Climbing device.
+ * Aurora Board
+ * {@link https://auroraclimbing.com}
+ */
+export class Aurora extends Device implements IAurora {
+  /**
+   * UUID for the Aurora Climbing Advertising service.
+   * This constant is used to identify the specific Bluetooth service for Aurora LED boards.
+   * @type {string}
+   * @static
+   * @readonly
+   * @constant
+   */
+  static readonly AuroraUUID: string = "4488b571-7806-4df6-bcff-a2897e4953ff"
+
+  /**
+   * Maximum length of the message body for byte wrapping.
+   * This value defines the limit for the size of messages that can be sent or received
+   * to ensure proper byte wrapping in communication.
+   * @type {number}
+   * @private
+   * @readonly
+   * @constant
+   */
+  private static readonly messageBodyMaxLength: number = 255
+
+  /**
+   * Maximum length of the Bluetooth message chunk.
+   * This value sets the upper limit for the size of individual Bluetooth messages
+   * sent to and from the device to comply with Bluetooth protocol constraints.
+   * @type {number}
+   * @private
+   * @readonly
+   * @constant
+   */
+  private static readonly maxBluetoothMessageSize: number = 20
+
+  private apiLevel: AuroraApiLevel
+
+  private writeQueue: Promise<void> = Promise.resolve()
+
+  constructor() {
+    super({
+      filters: [
+        {
+          services: [Aurora.AuroraUUID],
+        },
+      ],
+      services: [
+        {
+          name: "UART Nordic Service",
+          id: "uart",
+          uuid: "6e400001-b5a3-f393-e0a9-e50e24dcca9e",
+          characteristics: [
+            {
+              name: "TX",
+              id: "tx",
+              uuid: "6e400002-b5a3-f393-e0a9-e50e24dcca9e",
+            },
+            // {
+            //   name: "RX",
+            //   id: "rx",
+            //   uuid: "6e400003-b5a3-f393-e0a9-e50e24dcca9e",
+            // },
+          ],
+        },
+      ],
+    })
+
+    this.apiLevel = 2
+  }
+
+  /**
+   * Sets the API level from the Aurora board name format:
+   * display name, optional #serial, optional trailing @apiLevel. Missing @apiLevel defaults to API level 2.
+   * @param name - The name of the device.
+   */
+  protected setApiLevelFromDeviceName(name?: string | null): void {
+    const detectedApiLevel = this.getApiLevelFromDeviceName(name)
+
+    this.apiLevel = detectedApiLevel
+  }
+
+  protected override onBluetoothDeviceSelected(device: BluetoothDevice): void {
+    this.setApiLevelFromDeviceName(device.name)
+  }
+
+  private getApiLevelFromDeviceName(name?: string | null): AuroraApiLevel {
+    const apiLevel = name?.match(/@(\d+)$/)?.[1]
+
+    if (apiLevel === undefined) {
+      return 2
+    }
+
+    return this.normalizeApiLevel(Number(apiLevel))
+  }
+
+  private normalizeApiLevel(apiLevel: number): AuroraApiLevel {
+    if (apiLevel !== 2 && apiLevel !== 3) {
+      throw new Error(`Unsupported Aurora Board API level: ${apiLevel}`)
+    }
+
+    return apiLevel
+  }
+
+  /**
+   * Calculates the checksum for a byte array by summing up all packet-data bytes in a single-byte variable.
+   * @param data - The array of bytes to calculate the checksum for.
+   * @returns {number} The calculated checksum value.
+   */
+  private checksum(data: number[]): number {
+    let i = 0
+    for (const value of data) {
+      i = (i + value) & 255
+    }
+    return ~i & 255
+  }
+
+  /**
+   * Wraps a byte array with header and footer bytes for transmission.
+   * @param data - The array of bytes to wrap.
+   * @returns {number[]} The wrapped byte array.
+   */
+  private wrapBytes(data: number[]): number[] {
+    if (data.length > Aurora.messageBodyMaxLength) {
+      return []
+    }
+    /**
+  - 0x1
+  - len(packets)
+  - checksum(packets)
+  - 0x2
+  - *packets
+  - 0x3
+
+  First byte is always 1, the second is a number of packets, then checksum, then 2, packets themselves, and finally 3.
+   */
+    return [1, data.length, this.checksum(data), 2, ...data, 3]
+  }
+
+  /**
+   * Encodes an API level 2 position into two bytes.
+   * The lowest 8 bits go in the first byte; the highest 2 bits are reserved for the second byte.
+   * @param position - The position to encode.
+   * @returns {number[]} The encoded byte array representing the position.
+   */
+  private validatePosition(position: number, maxPosition: number, apiLevel: AuroraApiLevel): void {
+    if (!Number.isInteger(position) || position < 0 || position > maxPosition) {
+      throw new Error(
+        `Aurora Board API level ${apiLevel} requires an integer LED position between 0 and ${maxPosition}`,
+      )
+    }
+  }
+
+  private encodePositionV2(position: number): number[] {
+    this.validatePosition(position, 0x3ff, 2)
+
+    const position1 = position & 255
+    const position2 = (position & 0x300) >> 8
+
+    return [position1, position2]
+  }
+
+  /**
+   * Encodes an API level 3 position into two bytes.
+   * The lowest 8 bits go in the first byte; the highest 8 bits go in the second byte.
+   * @param position - The position to encode.
+   * @returns {number[]} The encoded byte array representing the position.
+   */
+  private encodePositionV3(position: number): number[] {
+    this.validatePosition(position, 0xffff, 3)
+
+    const position1 = position & 255
+    const position2 = (position & 65280) >> 8
+
+    return [position1, position2]
+  }
+
+  /**
+   * Encodes a color string into a numeric representation.
+   * The rgb color, 3 bits for the R and G components, 2 bits for the B component, with the 3 R bits occupying the high end of the byte and the 2 B bits in the low end (hence 3 G bits in the middle).
+   * Format: 0bRRRGGGBB where RRR is 3 bits for red, GGG is 3 bits for green, BB is 2 bits for blue.
+   * @param color - The color string in hexadecimal format (e.g., 'FFFFFF').
+   * @returns The encoded /compressed color value.
+   */
+  private encodeColorV3(color: string): number {
+    const r = parseInt(color.substring(0, 2), 16)
+    const g = parseInt(color.substring(2, 4), 16)
+    const b = parseInt(color.substring(4, 6), 16)
+
+    // Integer division: R and G divided by 32, B divided by 64
+    // Then pack into 0bRRRGGGBB format
+    const rBits = Math.floor(r / 32) // 0-7 (3 bits)
+    const gBits = Math.floor(g / 32) // 0-7 (3 bits)
+    const bBits = Math.floor(b / 64) // 0-3 (2 bits)
+
+    // Pack: RRR in bits 7-5, GGG in bits 4-2, BB in bits 1-0
+    return (rBits << 5) | (gBits << 2) | bBits
+  }
+
+  /**
+   * Encodes a color string using API level 2's 2-bit RGB format.
+   * Format: 0bRRGGBB00. The lowest two bits are reserved for the high bits of the LED position.
+   * @param color - The color string in hexadecimal format (e.g., 'FFFFFF').
+   * @returns The encoded /compressed color value.
+   */
+  private encodeColorV2(color: string): number {
+    const r = parseInt(color.substring(0, 2), 16)
+    const g = parseInt(color.substring(2, 4), 16)
+    const b = parseInt(color.substring(4, 6), 16)
+
+    const rBits = Math.floor(r / 64) // 0-3 (2 bits)
+    const gBits = Math.floor(g / 64) // 0-3 (2 bits)
+    const bBits = Math.floor(b / 64) // 0-3 (2 bits)
+
+    return (rBits << 6) | (gBits << 4) | (bBits << 2)
+  }
+
+  private normalizeColor(color: string): string {
+    const colorHex = color.trim().replace(/^#/, "").toUpperCase()
+
+    if (!/^[0-9A-F]{6}$/.test(colorHex)) {
+      throw new Error(`Invalid Aurora Board LED color: ${color}`)
+    }
+
+    return colorHex
+  }
+
+  /**
+   * Encodes an API level 2 placement into two bytes.
+   * API level 2 stores a 10-bit position and a 2-bit-per-channel RGB color.
+   * @param position - The position to encode.
+   * @param ledColor - The color of the LED in hexadecimal format (e.g., 'FFFFFF').
+   * @returns The encoded byte array representing the placement.
+   */
+  private encodePlacementV2(position: number, ledColor: string): number[] {
+    const [position1, position2] = this.encodePositionV2(position)
+
+    return [position1, this.encodeColorV2(ledColor) | position2]
+  }
+
+  /**
+   * Encodes an API level 3 placement into three bytes.
+   * API level 3 stores a 16-bit position and a 3/3/2-bit RGB color.
+   * @param position - The position to encode.
+   * @param ledColor - The color of the LED in hexadecimal format (e.g., 'FFFFFF').
+   * @returns The encoded byte array representing the placement.
+   */
+  private encodePlacementV3(position: number, ledColor: string): number[] {
+    return [...this.encodePositionV3(position), this.encodeColorV3(ledColor)]
+  }
+
+  /**
+   * Resolves placements into LED positions and concrete hex colors.
+   * @param climbPlacementList - The list of climb placements containing position and color.
+   * @returns The resolved placements ready for API-level encoding.
+   */
+  private resolvePlacements(climbPlacementList: AuroraLedPlacement[]): AuroraResolvedPlacement[] {
+    return climbPlacementList.flatMap((climbPlacement) => {
+      const color = climbPlacement.color?.trim() ?? ""
+
+      if (color === "") {
+        return []
+      }
+
+      return [
+        {
+          position: climbPlacement.position,
+          colorHex: this.normalizeColor(color),
+        },
+      ]
+    })
+  }
+
+  private buildPayload(
+    resolvedPlacements: AuroraResolvedPlacement[],
+    markers: AuroraPacketMarkers,
+    bytesPerPlacement: number,
+    encodePlacement: (position: number, ledColor: string) => number[],
+  ): number[] {
+    const resultArray: number[][] = []
+    let tempArray: number[] = [markers.middle]
+
+    for (const climbPlacement of resolvedPlacements) {
+      if (tempArray.length + bytesPerPlacement > Aurora.messageBodyMaxLength) {
+        resultArray.push(tempArray)
+        tempArray = [markers.middle]
+      }
+
+      const encodedPlacement = encodePlacement(climbPlacement.position, climbPlacement.colorHex)
+      tempArray.push(...encodedPlacement)
+    }
+
+    resultArray.push(tempArray)
+
+    if (resultArray.length === 1) {
+      resultArray[0][0] = markers.only
+    } else if (resultArray.length > 1) {
+      resultArray[0][0] = markers.first
+      resultArray[resultArray.length - 1][0] = markers.last
+    }
+
+    const finalResultArray: number[] = []
+    for (const currentArray of resultArray) {
+      finalResultArray.push(...this.wrapBytes(currentArray))
+    }
+
+    return finalResultArray
+  }
+
+  /**
+   * Prepares API level 2 byte arrays for transmission based on a list of climb placements.
+   * @param climbPlacementList - The list of climb placements containing position and color.
+   * @returns The final byte array ready for transmission.
+   */
+  private prepBytesV2(climbPlacementList: AuroraLedPlacement[]): number[] {
+    return this.buildPayload(
+      this.resolvePlacements(climbPlacementList),
+      {
+        middle: AuroraPacket.V2_MIDDLE,
+        first: AuroraPacket.V2_FIRST,
+        last: AuroraPacket.V2_LAST,
+        only: AuroraPacket.V2_ONLY,
+      },
+      2,
+      (position, ledColor) => this.encodePlacementV2(position, ledColor),
+    )
+  }
+
+  /**
+   * Prepares API level 3 byte arrays for transmission based on a list of climb placements.
+   * @param climbPlacementList - The list of climb placements containing position and color.
+   * @returns The final byte array ready for transmission.
+   */
+  private prepBytesV3(climbPlacementList: AuroraLedPlacement[]): number[] {
+    return this.buildPayload(
+      this.resolvePlacements(climbPlacementList),
+      {
+        middle: AuroraPacket.V3_MIDDLE,
+        first: AuroraPacket.V3_FIRST,
+        last: AuroraPacket.V3_LAST,
+        only: AuroraPacket.V3_ONLY,
+      },
+      3,
+      (position, ledColor) => this.encodePlacementV3(position, ledColor),
+    )
+  }
+
+  private prepBytes(climbPlacementList: AuroraLedPlacement[], apiLevel: AuroraApiLevel): number[] {
+    return apiLevel === 2 ? this.prepBytesV2(climbPlacementList) : this.prepBytesV3(climbPlacementList)
+  }
+
+  /**
+   * Splits a collection into slices of the specified length.
+   * https://github.com/ramda/ramda/blob/master/source/splitEvery
+   * @param {Number} n
+   * @param {Array} list
+   * @return {Array<number[]>}
+   */
+  private splitEvery(n: number, list: number[]): number[][] {
+    if (n <= 0) {
+      throw new Error("First argument to splitEvery must be a positive integer")
+    }
+    const result = []
+    let idx = 0
+    while (idx < list.length) {
+      result.push(list.slice(idx, (idx += n)))
+    }
+    return result
+  }
+
+  /**
+   * Aurora boards only support messages of 20 bytes
+   * at a time. This method splits a full message into parts
+   * of 20 bytes
+   *
+   * @param buffer
+   */
+  private splitMessages = (buffer: number[]) =>
+    this.splitEvery(Aurora.maxBluetoothMessageSize, buffer).map((arr) => new Uint8Array(arr))
+
+  private getWriteCharacteristic(): BluetoothRemoteGATTCharacteristic | undefined {
+    return this.services.find((service) => service.id === "uart")?.characteristics.find((char) => char.id === "tx")
+      ?.characteristic
+  }
+
+  /**
+   * Sends a series of messages to a device.
+   */
+  private async writeMessageSeries(characteristic: BluetoothRemoteGATTCharacteristic, messages: Uint8Array[]) {
+    for (const message of messages) {
+      if (!message) {
+        continue
+      }
+
+      await this.writeMessageChunk(characteristic, message)
+    }
+  }
+
+  private async queueWrite(operation: () => Promise<void>): Promise<void> {
+    const queuedOperation = this.writeQueue.catch(() => undefined).then(operation)
+    this.writeQueue = queuedOperation.catch(() => undefined)
+
+    await queuedOperation
+  }
+
+  private async writeMessageChunk(
+    characteristic: BluetoothRemoteGATTCharacteristic,
+    message: Uint8Array,
+  ): Promise<void> {
+    this.updateTimestamp()
+    const valueToWrite = new Uint8Array(message)
+
+    if (this.canWriteWithoutResponse(characteristic)) {
+      await characteristic.writeValueWithoutResponse(valueToWrite)
+    } else {
+      await characteristic.writeValue(valueToWrite)
+    }
+
+    this.writeLast = message
+  }
+
+  private canWriteWithoutResponse(characteristic: BluetoothRemoteGATTCharacteristic): boolean {
+    return (
+      characteristic.properties.writeWithoutResponse !== false &&
+      typeof characteristic.writeValueWithoutResponse === "function"
+    )
+  }
+
+  /**
+   * Configures the LEDs based on an array of climb placements.
+   * @param config - Array of climb placements for the LEDs. Each placement must include a color hex string.
+   * @returns {Promise<number[] | undefined>} A promise that resolves with the payload array for the Aurora board if LED settings were applied, or `undefined` if no action was taken.
+   */
+  led = async (config: AuroraLedPlacement[] = []): Promise<number[] | undefined> => {
+    // Handle Aurora LED board logic: process placements and send payload if connected
+    if (Array.isArray(config)) {
+      // Prepares byte arrays for transmission based on a list of climb placements.
+      const payload = this.prepBytes(config, this.apiLevel)
+      if (this.isConnected()) {
+        const characteristic = this.getWriteCharacteristic()
+        if (characteristic) {
+          await this.queueWrite(() => this.writeMessageSeries(characteristic, this.splitMessages(payload)))
+        }
+      }
+      return payload
+    }
+    return undefined
+  }
+}
+
+/**
+ * Aurora Board
+ * {@link https://auroraboardapp.com}
+ */
+export class AuroraBoard extends Aurora implements IAurora {}

package/src/models/device/climbro.model.ts

@@ -183,7 +183,7 @@ export class Climbro extends Device implements IClimbro {
     if (value) {
       this.updateTimestamp()
       if (value.buffer) {
-        const buffer = new Uint8Array(value.buffer)
+        const buffer = new Uint8Array(value.buffer, value.byteOffset, value.byteLength)
         const byteCount = buffer.length
 
         let flagSynchro = this.flagSynchro

package/src/models/device/cts500.model.ts

@@ -289,17 +289,24 @@ export class CTS500 extends Device implements ICTS500 {
    */
   stream = async (duration = 0): Promise<void> => {
     this.resetPacketTracking()
+    this.resetSessionData()
     this.isStreaming = true
     const command = this.commands.START_WEIGHT_MEAS as Uint8Array
-    await this.queryFrame(
-      command,
-      (frame) =>
-        // The device can start auto-uploading before it echoes the start command, so the first weight frame also confirms success.
-        this.isAckFrame(frame, command[1], [command[2], command[3], command[4]]) || this.isWeightFrame(frame),
-    )
+    try {
+      await this.queryFrame(
+        command,
+        (frame) =>
+          // The device can start auto-uploading before it echoes the start command, so the first weight frame also confirms success.
+          this.isAckFrame(frame, command[1], [command[2], command[3], command[4]]) || this.isWeightFrame(frame),
+      )
+    } catch (error) {
+      this.isStreaming = false
+      throw error
+    }
 
     if (duration > 0) {
       await new Promise((resolve) => setTimeout(resolve, duration))
+      await this.stop()
     }
   }
 
@@ -640,7 +647,7 @@ export class CTS500 extends Device implements ICTS500 {
     )
 
     if (this.isStreaming) {
-      void this.activityCheck(numericData)
+      this.activityCheck(numericData)
     }
 
     this.notifyCallback(this.buildForceMeasurement(currentMassTotal))

package/src/models/device/forceboard.model.ts

@@ -72,7 +72,7 @@ export class ForceBoard extends NordicDfuDevice implements IForceBoard {
           ],
         },
         {
-          name: "Temperature Serivce",
+          name: "Temperature Service",
           id: "temperature",
           uuid: "3a90328c-c266-4c76-b05a-6af6104a0b13",
           characteristics: [
@@ -182,7 +182,7 @@ export class ForceBoard extends NordicDfuDevice implements IForceBoard {
       this.updateTimestamp()
       if (value.buffer) {
         const receivedTime: number = Date.now()
-        const dataArray = new Uint8Array(value.buffer)
+        const dataArray = new Uint8Array(value.buffer, value.byteOffset, value.byteLength)
 
         const numSamples = (dataArray[0] << 8) | dataArray[1]
         this.currentSamplesPerPacket = numSamples
@@ -254,7 +254,11 @@ export class ForceBoard extends NordicDfuDevice implements IForceBoard {
    */
   stream = async (duration = 0): Promise<void> => {
     this.resetPacketTracking()
+    this.resetSessionData()
     await this.write("weight", "tx", this.commands.START_WEIGHT_MEAS, duration)
+    if (duration !== 0) {
+      await this.stop()
+    }
   }
 
   /**

package/src/models/device/motherboard.model.ts

@@ -40,10 +40,13 @@ export class Motherboard extends Device implements IMotherboard {
 
   /** Per-zone peak and running sum for left/center/right (used for distribution stats). */
   private leftPeak = Number.NEGATIVE_INFINITY
+  private leftMin = Number.POSITIVE_INFINITY
   private leftSum = 0
   private centerPeak = Number.NEGATIVE_INFINITY
+  private centerMin = Number.POSITIVE_INFINITY
   private centerSum = 0
   private rightPeak = Number.NEGATIVE_INFINITY
+  private rightMin = Number.POSITIVE_INFINITY
   private rightSum = 0
 
   constructor() {
@@ -295,12 +298,15 @@ export class Motherboard extends Device implements IMotherboard {
             this.dataPointCount++
             this.mean = this.sum / this.dataPointCount
 
-            // Per-zone peak and sum for distribution
+            // Per-zone peak, min and sum for distribution
             this.leftPeak = Math.max(this.leftPeak, leftClamped)
+            this.leftMin = Math.min(this.leftMin, leftClamped)
             this.leftSum += leftClamped
             this.centerPeak = Math.max(this.centerPeak, centerClamped)
+            this.centerMin = Math.min(this.centerMin, centerClamped)
             this.centerSum += centerClamped
             this.rightPeak = Math.max(this.rightPeak, rightClamped)
+            this.rightMin = Math.min(this.rightMin, rightClamped)
             this.rightSum += rightClamped
 
             // Add data to downloadable Array (distribution = per-zone measurements)
@@ -310,13 +316,24 @@ export class Motherboard extends Device implements IMotherboard {
                 battRaw: packet.battRaw,
                 sampleIndex: packet.sampleIndex,
                 distribution: {
-                  left: this.buildZoneMeasurement(leftClamped, this.leftPeak, this.leftSum / this.dataPointCount),
+                  left: this.buildZoneMeasurement(
+                    leftClamped,
+                    this.leftPeak,
+                    this.leftSum / this.dataPointCount,
+                    this.leftMin,
+                  ),
                   center: this.buildZoneMeasurement(
                     centerClamped,
                     this.centerPeak,
                     this.centerSum / this.dataPointCount,
+                    this.centerMin,
+                  ),
+                  right: this.buildZoneMeasurement(
+                    rightClamped,
+                    this.rightPeak,
+                    this.rightSum / this.dataPointCount,
+                    this.rightMin,
                   ),
-                  right: this.buildZoneMeasurement(rightClamped, this.rightPeak, this.rightSum / this.dataPointCount),
                 },
               }),
             )
@@ -324,12 +341,27 @@ export class Motherboard extends Device implements IMotherboard {
             // Check if device is being used
             this.activityCheck(center)
 
-            // Notify with weight data (distribution zones have proper peak/mean per zone)
+            // Notify with weight data (distribution zones have proper peak/mean/min per zone)
             this.notifyCallback(
               this.buildForceMeasurement(totalCurrent, {
-                left: this.buildZoneMeasurement(leftClamped, this.leftPeak, this.leftSum / this.dataPointCount),
-                center: this.buildZoneMeasurement(centerClamped, this.centerPeak, this.centerSum / this.dataPointCount),
-                right: this.buildZoneMeasurement(rightClamped, this.rightPeak, this.rightSum / this.dataPointCount),
+                left: this.buildZoneMeasurement(
+                  leftClamped,
+                  this.leftPeak,
+                  this.leftSum / this.dataPointCount,
+                  this.leftMin,
+                ),
+                center: this.buildZoneMeasurement(
+                  centerClamped,
+                  this.centerPeak,
+                  this.centerSum / this.dataPointCount,
+                  this.centerMin,
+                ),
+                right: this.buildZoneMeasurement(
+                  rightClamped,
+                  this.rightPeak,
+                  this.rightSum / this.dataPointCount,
+                  this.rightMin,
+                ),
               }),
             )
           } else if (this.writeLast === this.commands.GET_CALIBRATION) {
@@ -359,7 +391,7 @@ export class Motherboard extends Device implements IMotherboard {
   /**
    * Sets the LED color based on a single color option. Defaults to turning the LEDs off if no configuration is provided.
    * @param {"green" | "red" | "orange"} [config] - Optional color or array of climb placements for the LEDs. Ignored if placements are provided.
-   * @returns {Promise<number[] | undefined>} A promise that resolves with the payload array for the Kilter Board if LED settings were applied, or `undefined` if no action was taken or for the Motherboard.
+   * @returns {Promise<number[] | undefined>} A promise that resolves with the payload array for Aurora-compatible LED settings, or `undefined` if no action was taken or for the Motherboard.
    */
   led = async (config?: "green" | "red" | "orange"): Promise<number[] | undefined> => {
     if (this.isConnected()) {
@@ -413,7 +445,17 @@ export class Motherboard extends Device implements IMotherboard {
    */
   stream = async (duration = 0): Promise<void> => {
     this.resetPacketTracking()
-    this.downloadPackets.length = 0
+    this.resetSessionData()
+    // Reset per-zone session stats for the distribution measurements
+    this.leftPeak = Number.NEGATIVE_INFINITY
+    this.leftMin = Number.POSITIVE_INFINITY
+    this.leftSum = 0
+    this.centerPeak = Number.NEGATIVE_INFINITY
+    this.centerMin = Number.POSITIVE_INFINITY
+    this.centerSum = 0
+    this.rightPeak = Number.NEGATIVE_INFINITY
+    this.rightMin = Number.POSITIVE_INFINITY
+    this.rightSum = 0
     // Read calibration data if not already available
     if (!this.calibrationData[0].length) {
       await this.calibration()