dualsense-ts 6.2.0 → 6.4.0

package/src/hid/factory_info.ts

@@ -0,0 +1,206 @@
+import { HIDProvider } from "./hid_provider";
+
+/** Known DualSense body colors */
+export enum DualsenseColor {
+  Unknown = "Unknown",
+  White = "White",
+  MidnightBlack = "Midnight Black",
+  CosmicRed = "Cosmic Red",
+  NovaPink = "Nova Pink",
+  GalacticPurple = "Galactic Purple",
+  StarlightBlue = "Starlight Blue",
+  GreyCamouflage = "Grey Camouflage",
+  VolcanicRed = "Volcanic Red",
+  SterlingSilver = "Sterling Silver",
+  CobaltBlue = "Cobalt Blue",
+  ChromaTeal = "Chroma Teal",
+  ChromaIndigo = "Chroma Indigo",
+  ChromaPearl = "Chroma Pearl",
+  Anniversary30th = "30th Anniversary",
+  GodOfWarRagnarok = "God of War Ragnarok",
+  SpiderMan2 = "Spider-Man 2",
+  AstroBot = "Astro Bot",
+  Fortnite = "Fortnite",
+  TheLastOfUs = "The Last of Us",
+  IconBlueLimitedEdition = "Icon Blue Limited Edition",
+  GenshinImpact = "Genshin Impact",
+}
+
+/** Known DualSense body colors, keyed by the 2-char code from the serial number */
+export const DualsenseColorMap: Record<string, DualsenseColor> = {
+  "00": DualsenseColor.White,
+  "01": DualsenseColor.MidnightBlack,
+  "02": DualsenseColor.CosmicRed,
+  "03": DualsenseColor.NovaPink,
+  "04": DualsenseColor.GalacticPurple,
+  "05": DualsenseColor.StarlightBlue,
+  "06": DualsenseColor.GreyCamouflage,
+  "07": DualsenseColor.VolcanicRed,
+  "08": DualsenseColor.SterlingSilver,
+  "09": DualsenseColor.CobaltBlue,
+  "10": DualsenseColor.ChromaTeal,
+  "11": DualsenseColor.ChromaIndigo,
+  "12": DualsenseColor.ChromaPearl,
+  "30": DualsenseColor.Anniversary30th,
+  Z1: DualsenseColor.GodOfWarRagnarok,
+  Z2: DualsenseColor.SpiderMan2,
+  Z3: DualsenseColor.AstroBot,
+  Z4: DualsenseColor.Fortnite,
+  Z6: DualsenseColor.TheLastOfUs,
+  ZB: DualsenseColor.IconBlueLimitedEdition,
+  ZE: DualsenseColor.GenshinImpact,
+};
+
+/** Board revision names, keyed by the character at serial position 1 */
+const BoardRevisionMap: Record<string, string> = {
+  "1": "BDM-010",
+  "2": "BDM-020",
+  "3": "BDM-030",
+  "4": "BDM-040",
+  "5": "BDM-050",
+};
+
+/** Factory information derived from the controller's serial number */
+export interface FactoryInfo {
+  /** Raw serial number string */
+  serialNumber: string;
+  /** Controller body color name (e.g. "Cosmic Red") */
+  colorName: string;
+  /** Raw 2-character color code from the serial number */
+  colorCode: string;
+  /** Board revision (e.g. "BDM-030") */
+  boardRevision: string;
+}
+
+/** Default FactoryInfo used when the test command protocol is unavailable (e.g. Linux Bluetooth via node-hid) */
+export const DefaultFactoryInfo: FactoryInfo = {
+  serialNumber: "unknown",
+  colorName: "unknown",
+  colorCode: "??",
+  boardRevision: "unknown",
+};
+
+/** Feature report IDs for the test command protocol */
+const SEND_REPORT_ID = 0x80;
+const RECV_REPORT_ID = 0x81;
+/** Report size for test command feature reports (report ID + 63 bytes payload) */
+const REPORT_SIZE = 64;
+
+/** Test command device/action IDs */
+const DEVICE_SYSTEM = 0x01;
+const ACTION_READ_SERIAL = 0x13;
+
+/** Test command response status values */
+const STATUS_COMPLETE = 0x02;
+
+/**
+ * Send a test command via Feature Report 0x80 and poll 0x81 for the response.
+ * Returns the result data bytes (after the header), or undefined on failure.
+ */
+async function sendTestCommand(
+  provider: HIDProvider,
+  deviceId: number,
+  actionId: number,
+  maxAttempts: number = 20,
+): Promise<Uint8Array | undefined> {
+  // Build the send report: report ID at byte 0, then payload.
+  // The provider handles platform differences (WebHID strips byte 0, adds CRC for BT).
+  const sendBuf = new Uint8Array(REPORT_SIZE).fill(0);
+  sendBuf[0] = SEND_REPORT_ID;
+  sendBuf[1] = deviceId;
+  sendBuf[2] = actionId;
+
+  await provider.sendFeatureReport(SEND_REPORT_ID, sendBuf);
+
+  // Poll for response
+  for (let i = 0; i < maxAttempts; i++) {
+    await sleep(50);
+
+    const response = await provider.readFeatureReport(
+      RECV_REPORT_ID,
+      REPORT_SIZE,
+    );
+    if (response.length === 0) continue;
+
+    // Response layout: [reportId, deviceId, actionId, status, ...data]
+    // Note: node-hid includes the report ID at byte 0; WebHID may not.
+    // Find the actual start based on whether byte 0 is the report ID.
+    const offset = response[0] === RECV_REPORT_ID ? 1 : 0;
+    const respDevice = response[offset];
+    const respAction = response[offset + 1];
+    const respStatus = response[offset + 2];
+
+    if (respDevice !== deviceId || respAction !== actionId) continue;
+    if (respStatus === STATUS_COMPLETE) {
+      return response.slice(offset + 3);
+    }
+  }
+
+  return undefined;
+}
+
+/** Decode a byte array as ASCII, stopping at null terminator */
+function decodeAscii(data: Uint8Array, offset: number, length: number): string {
+  let str = "";
+  for (let i = 0; i < length; i++) {
+    const byte = data[offset + i];
+    if (byte === 0) break;
+    str += String.fromCharCode(byte);
+  }
+  return str;
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Read factory info (serial number, body color, board revision) from a connected controller.
+ *
+ * Requires firmware support: hardwareInfo >= 777 and mainFirmwareVersion >= 65655.
+ * Use the values from FirmwareInfo (Feature Report 0x20) to check this gate.
+ *
+ * @param provider The HID provider for the connected controller
+ * @param hardwareInfo Hardware info word from FirmwareInfo
+ * @param mainFwVersionRaw Raw uint32 main firmware version from FirmwareInfo
+ */
+export async function readFactoryInfo(
+  provider: HIDProvider,
+  hardwareInfo: number,
+  mainFwVersionRaw: number,
+): Promise<FactoryInfo | undefined> {
+  // Firmware gate check
+  if ((hardwareInfo & 0xffff) < 777 || mainFwVersionRaw < 65655) {
+    return undefined;
+  }
+
+  try {
+    const result = await sendTestCommand(
+      provider,
+      DEVICE_SYSTEM,
+      ACTION_READ_SERIAL,
+    );
+    if (!result) return undefined;
+
+    const serialNumber = decodeAscii(result, 0, 32);
+    if (serialNumber.length < 6) return undefined;
+
+    const colorCode = serialNumber.slice(4, 6);
+    const revisionChar = serialNumber.slice(1, 2);
+    const colorName =
+      colorCode in DualsenseColorMap ? DualsenseColorMap[colorCode] : colorCode;
+    const boardRevision =
+      revisionChar in BoardRevisionMap
+        ? BoardRevisionMap[revisionChar]
+        : "unknown";
+
+    return {
+      serialNumber,
+      colorName,
+      colorCode,
+      boardRevision,
+    };
+  } catch {
+    return undefined;
+  }
+}

package/src/hid/firmware_info.ts

@@ -0,0 +1,157 @@
+import { HIDProvider } from "./hid_provider";
+
+/** Parsed firmware version in major.minor.patch format */
+export interface FirmwareVersion {
+  major: number;
+  minor: number;
+  patch: number;
+}
+
+/** Firmware and hardware information from Feature Report 0x20 */
+export interface FirmwareInfo {
+  /** Firmware build date (e.g. "Apr 14 2023") */
+  buildDate: string;
+  /** Firmware build time (e.g. "12:34:56") */
+  buildTime: string;
+  /** Firmware type (2 or 3 indicates production firmware) */
+  firmwareType: number;
+  /** Software series identifier */
+  softwareSeries: number;
+  /** Hardware info word (lower 16 bits used for feature gating) */
+  hardwareInfo: number;
+  /** Main firmware version */
+  mainFirmwareVersion: FirmwareVersion;
+  /** Raw uint32 main firmware version (used for feature gating) */
+  mainFirmwareVersionRaw: number;
+  /** Device info (raw hex string) */
+  deviceInfo: string;
+  /** Update version (formatted as HH.LL hex) */
+  updateVersion: string;
+  /** Update image info */
+  updateImageInfo: number;
+  /** SBL (second bootloader) firmware version */
+  sblFirmwareVersion: FirmwareVersion;
+  /** DSP firmware version (formatted as HHHH_LLLL hex) */
+  dspFirmwareVersion: string;
+  /** Spider DSP firmware version */
+  spiderDspFirmwareVersion: FirmwareVersion;
+}
+
+/** A zeroed firmware version */
+const UnknownVersion: FirmwareVersion = { major: 0, minor: 0, patch: 0 };
+
+/** Default FirmwareInfo used when Feature Report 0x20 could not be read */
+export const DefaultFirmwareInfo: FirmwareInfo = {
+  buildDate: "unknown",
+  buildTime: "unknown",
+  firmwareType: 0,
+  softwareSeries: 0,
+  hardwareInfo: 0,
+  mainFirmwareVersion: UnknownVersion,
+  mainFirmwareVersionRaw: 0,
+  deviceInfo: "unknown",
+  updateVersion: "00.00",
+  updateImageInfo: 0,
+  sblFirmwareVersion: UnknownVersion,
+  dspFirmwareVersion: "0000_0000",
+  spiderDspFirmwareVersion: UnknownVersion,
+};
+
+/** Format a FirmwareVersion as "major.minor.patch" */
+export function formatFirmwareVersion(v: FirmwareVersion): string {
+  return `${v.major}.${v.minor}.${v.patch}`;
+}
+
+/** Feature report ID for firmware information */
+const REPORT_ID = 0x20;
+/** Expected report length (report ID + 63 bytes of data) */
+const REPORT_LENGTH = 64;
+
+/** Parse a uint32 version into major.minor.patch */
+function parseVersion(ver: number): FirmwareVersion {
+  return {
+    major: (ver >>> 24) & 0xff,
+    minor: (ver >>> 16) & 0xff,
+    patch: ver & 0xffff,
+  };
+}
+
+/** Format a uint16 as HH.LL hex */
+function formatUpdateVersion(ver: number): string {
+  const hi = ((ver >>> 8) & 0xff).toString(16).padStart(2, "0");
+  const lo = (ver & 0xff).toString(16).padStart(2, "0");
+  return `${hi}.${lo}`;
+}
+
+/** Format a uint32 as HHHH_LLLL hex */
+function formatDspVersion(ver: number): string {
+  const hi = ((ver >>> 16) & 0xffff).toString(16).padStart(4, "0");
+  const lo = (ver & 0xffff).toString(16).padStart(4, "0");
+  return `${hi}_${lo}`;
+}
+
+/** Read a null-terminated ASCII string from a buffer */
+function readString(data: Uint8Array, offset: number, length: number): string {
+  let str = "";
+  for (let i = 0; i < length; i++) {
+    const byte = data[offset + i];
+    if (byte === 0) break;
+    str += String.fromCharCode(byte);
+  }
+  return str;
+}
+
+/** Read a little-endian uint16 from a buffer */
+function readUint16LE(data: Uint8Array, offset: number): number {
+  return data[offset] | (data[offset + 1] << 8);
+}
+
+/** Read a little-endian uint32 from a buffer */
+function readUint32LE(data: Uint8Array, offset: number): number {
+  return (
+    data[offset] |
+    (data[offset + 1] << 8) |
+    (data[offset + 2] << 16) |
+    ((data[offset + 3] << 24) >>> 0)
+  );
+}
+
+/** Convert bytes to a hex string */
+function toHex(data: Uint8Array, offset: number, length: number): string {
+  return Array.from(data.slice(offset, offset + length))
+    .map((b) => b.toString(16).padStart(2, "0"))
+    .join("");
+}
+
+/**
+ * Read and parse Feature Report 0x20 from a connected controller.
+ * Returns undefined if the report cannot be read.
+ */
+export async function readFirmwareInfo(
+  provider: HIDProvider,
+): Promise<FirmwareInfo | undefined> {
+  try {
+    const data = await provider.readFeatureReport(REPORT_ID, REPORT_LENGTH);
+
+    // Offsets are from byte 1 (after the report ID byte)
+    const base = 1;
+
+    return {
+      buildDate: readString(data, base, 11),
+      buildTime: readString(data, base + 11, 8),
+      firmwareType: readUint16LE(data, base + 19),
+      softwareSeries: readUint16LE(data, base + 21),
+      hardwareInfo: readUint32LE(data, base + 23),
+      mainFirmwareVersion: parseVersion(readUint32LE(data, base + 27)),
+      mainFirmwareVersionRaw: readUint32LE(data, base + 27),
+      deviceInfo: toHex(data, base + 31, 12),
+      updateVersion: formatUpdateVersion(readUint16LE(data, base + 43)),
+      updateImageInfo: data[base + 45],
+      sblFirmwareVersion: parseVersion(readUint32LE(data, base + 47)),
+      dspFirmwareVersion: formatDspVersion(readUint32LE(data, base + 51)),
+      spiderDspFirmwareVersion: parseVersion(readUint32LE(data, base + 55)),
+    };
+  } catch {
+    return undefined;
+  }
+}

package/src/hid/hid_provider.ts

@@ -76,6 +76,8 @@ export interface DualsenseHIDState {
   [InputId.BatteryLevel]: number;
   [InputId.BatteryStatus]: ChargeStatus;
   [InputId.MuteLed]: boolean;
+  [InputId.Microphone]: boolean;
+  [InputId.Headphone]: boolean;
 }
 
 /** Default values for all inputs */
@@ -124,6 +126,8 @@ export const DefaultDualsenseHIDState: DualsenseHIDState = {
   [InputId.BatteryLevel]: 0,
   [InputId.BatteryStatus]: ChargeStatus.Discharging,
   [InputId.MuteLed]: false,
+  [InputId.Microphone]: false,
+  [InputId.Headphone]: false,
 };
 
 /** Information about an available Dualsense device */
@@ -156,6 +160,12 @@ export abstract class HIDProvider {
   /** Callback to use for Error events */
   public onError: (error: Error) => void = () => {};
 
+  /** Callback fired the moment a device is fully attached and ready for I/O */
+  public onConnect: () => void = () => {};
+
+  /** Callback fired the moment a device detaches (cleanly or via error) */
+  public onDisconnect: () => void = () => {};
+
   /** Unique identifier for the connected device (path or serial) */
   public deviceId?: string;
 
@@ -186,6 +196,12 @@ export abstract class HIDProvider {
   /** Write to the HID device */
   abstract write(data: Uint8Array): Promise<void>;
 
+  /** Read a feature report from the device */
+  abstract readFeatureReport(reportId: number, length?: number): Promise<Uint8Array>;
+
+  /** Send a feature report to the device */
+  abstract sendFeatureReport(reportId: number, data: Uint8Array): Promise<void>;
+
   /** If true, gyroscope, touchpad, accelerometer are disabled */
   public limited?: boolean;
 
@@ -217,6 +233,7 @@ export abstract class HIDProvider {
    * Reset the HIDProvider state when the device is disconnected
    */
   protected reset(): void {
+    const wasAttached = this.device !== undefined;
     if (this.deviceId) {
       HIDProvider.claimedDevices.delete(this.deviceId);
     }
@@ -227,6 +244,7 @@ export abstract class HIDProvider {
     this.deviceId = undefined;
     this.serialNumber = undefined;
     this.onData(DefaultDualsenseHIDState);
+    if (wasAttached) this.onDisconnect();
   }
 
   /**
@@ -342,6 +360,8 @@ export abstract class HIDProvider {
       [InputId.TouchY1]: mapAxis(buffer.readUint16LE(40) >> 4, 1080),
       [InputId.Status]: (buffer.readUint8(55) & 8) > 0,
       [InputId.MuteLed]: (buffer.readUint8(55) & 4) > 0,
+      [InputId.Microphone]: (buffer.readUint8(55) & 2) > 0,
+      [InputId.Headphone]: (buffer.readUint8(55) & 1) > 0,
       [InputId.BatteryLevel]: mapBatteryLevel(buffer.readUint8(54)),
       [InputId.BatteryStatus]: (buffer.readUint8(54) >> 4) as ChargeStatus,
     };
@@ -416,6 +436,8 @@ export abstract class HIDProvider {
       // 12 reserved bytes
       [InputId.Status]: (buffer.readUint8(54) & 8) > 0,
       [InputId.MuteLed]: (buffer.readUint8(54) & 4) > 0,
+      [InputId.Microphone]: (buffer.readUint8(54) & 2) > 0,
+      [InputId.Headphone]: (buffer.readUint8(54) & 1) > 0,
       [InputId.BatteryLevel]: mapBatteryLevel(buffer.readUint8(53)),
       [InputId.BatteryStatus]: (buffer.readUint8(53) >> 4) as ChargeStatus,
     };

package/src/hid/index.ts

@@ -7,7 +7,10 @@ export * from "./bt_checksum";
 export * from "./byte_array";
 export * from "./command";
 export * from "./dualsense_hid";
+export * from "./factory_info";
+export * from "./firmware_info";
 export * from "./hid_provider";
 export * from "./node_hid_provider";
+export * from "./pairing_info";
 export * from "./platform_hid_provider";
 export * from "./web_hid_provider";

package/src/hid/node_hid_provider.ts

@@ -133,6 +133,7 @@ export class NodeHIDProvider extends HIDProvider {
       });
 
       this.device = device;
+      this.onConnect();
     } catch (err) {
       this.onError(
         err instanceof Error ? err : new Error(String(err))
@@ -148,6 +149,19 @@ export class NodeHIDProvider extends HIDProvider {
     return Promise.resolve();
   }
 
+  readFeatureReport(reportId: number, length: number): Promise<Uint8Array> {
+    if (!this.device) return Promise.reject(new Error("No device connected"));
+    const buf = this.device.getFeatureReport(reportId, length);
+    return Promise.resolve(new Uint8Array(buf));
+  }
+
+  sendFeatureReport(_reportId: number, data: Uint8Array): Promise<void> {
+    if (!this.device) return Promise.resolve();
+    // node-hid sendFeatureReport expects the report ID as the first byte of the buffer
+    this.device.sendFeatureReport(Array.from(data));
+    return Promise.resolve();
+  }
+
   get connected(): boolean {
     return this.device !== undefined;
   }

package/src/hid/pairing_info.ts

@@ -0,0 +1,33 @@
+import { HIDProvider } from "./hid_provider";
+
+/** Feature report ID for pairing info */
+const REPORT_ID = 0x09;
+/** Expected report length (report ID + 19 bytes) */
+const REPORT_LENGTH = 20;
+
+/**
+ * Read the controller's Bluetooth MAC address from Feature Report 0x09.
+ * Works over both USB and Bluetooth on all platforms.
+ * Returns the MAC as a colon-separated hex string (e.g. "AA:BB:CC:DD:EE:FF"),
+ * or undefined if the report cannot be read.
+ */
+export async function readMacAddress(
+  provider: HIDProvider,
+): Promise<string | undefined> {
+  try {
+    const data = await provider.readFeatureReport(REPORT_ID, REPORT_LENGTH);
+
+    // Bytes 1–6 contain the MAC in little-endian order
+    const mac: string[] = [];
+    for (let i = 6; i >= 1; i--) {
+      mac.push(data[i].toString(16).padStart(2, "0"));
+    }
+
+    const result = mac.join(":");
+    // Reject all-zero MACs (no pairing info available)
+    if (result === "00:00:00:00:00:00") return undefined;
+    return result;
+  } catch {
+    return undefined;
+  }
+}

package/src/hid/web_hid_provider.ts

@@ -1,5 +1,6 @@
 import { ByteArray } from "./byte_array";
 import { HIDProvider, DualsenseHIDState } from "./hid_provider";
+import { computeFeatureReportChecksum } from "./bt_checksum";
 
 export interface WebHIDProviderOptions {
   /** Attach to this specific HIDDevice instead of discovering one */
@@ -25,7 +26,8 @@ export class WebHIDProvider extends HIDProvider {
 
     navigator.hid.addEventListener("disconnect", ({ device }) => {
       if (device === this.device) {
-        this.device = undefined;
+        // Let disconnect() → reset() handle nulling this.device so that
+        // reset() can detect the device was attached and fire onDisconnect.
         this.disconnect();
       }
     });
@@ -93,16 +95,12 @@ export class WebHIDProvider extends HIDProvider {
 
   attach(device: HIDDevice): void {
     const key = WebHIDProvider.deviceKey(device);
-    if (HIDProvider.claimedDevices.has(key)) {
-      return; // Already claimed by another instance
-    }
 
-    device
-      .open()
+    const openPromise = device.opened ? Promise.resolve() : device.open();
+    openPromise
       .then(() => {
         this.device = device;
         this.deviceId = key;
-        HIDProvider.claimedDevices.add(key);
         this.detectConnectionType();
 
         // Enable accelerometer, gyro, touchpad
@@ -114,6 +112,7 @@ export class WebHIDProvider extends HIDProvider {
           this.buffer = data;
           this.onData(this.process({ reportId, buffer: data }));
         });
+        this.onConnect();
       })
       .catch((err: Error) => {
         this.onError(err);
@@ -121,6 +120,29 @@ export class WebHIDProvider extends HIDProvider {
       });
   }
 
+  /**
+   * Detach the current HIDDevice (if any) and attach a different one in place.
+   * Used by the manager to transplant a freshly-discovered device into an
+   * existing slot's provider after identity matching, so the consumer's
+   * Dualsense reference survives reconnection.
+   *
+   * The new device must already be open (or openable) — we close the old one,
+   * release its claim, and run the standard attach() flow on the new one.
+   */
+  replaceDevice(device: HIDDevice): void {
+    // Tear down the existing device without firing the disconnect cascade
+    // (we don't want subscribers to see a disconnect/reconnect blip).
+    if (this.device) {
+      const old = this.device;
+      const oldKey = this.deviceId;
+      this.device = undefined;
+      if (oldKey) HIDProvider.claimedDevices.delete(oldKey);
+      // Best-effort close; failures are non-fatal.
+      old.close().catch(() => {});
+    }
+    this.attach(device);
+  }
+
   /**
    * You need to get HID device permissions from an interactive
    * component, like a button. This returns a callback for triggering
@@ -199,12 +221,69 @@ export class WebHIDProvider extends HIDProvider {
 
   disconnect(): void {
     if (this.device) {
-      this.device.close().finally(() => this.reset());
+      const dev = this.device;
+      // Reset synchronously so claimedDevices is freed immediately —
+      // otherwise a rapid disconnect/reconnect can race: the browser's
+      // connect event arrives before close() resolves, and attach() sees
+      // the key still claimed and silently bails out.
+      this.reset();
+      dev.close().catch(() => {});
     } else {
       this.reset();
     }
   }
 
+  async readFeatureReport(reportId: number): Promise<Uint8Array> {
+    if (!this.device) throw new Error("No device connected");
+    const view = await this.device.receiveFeatureReport(reportId);
+    return new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+  }
+
+  async sendFeatureReport(reportId: number, data: Uint8Array): Promise<void> {
+    if (!this.device) return;
+
+    // WebHID sendFeatureReport takes the report ID separately.
+    // data[0] is the report ID (for node-hid compat); strip it for WebHID.
+    const rawPayload = data.slice(1);
+
+    // Pad to the expected payload length from the HID descriptor
+    const expectedLength = this.getFeatureReportLength(reportId);
+    const payload = expectedLength > 0 && rawPayload.length < expectedLength
+      ? new Uint8Array(expectedLength)
+      : new Uint8Array(rawPayload);
+
+    if (expectedLength > rawPayload.length) {
+      payload.set(rawPayload);
+    }
+
+    // Bluetooth requires CRC-32 in the last 4 bytes of the payload
+    if (this.wireless) {
+      const crc = computeFeatureReportChecksum(reportId, payload);
+      const off = payload.length - 4;
+      payload[off] = crc & 0xff;
+      payload[off + 1] = (crc >>> 8) & 0xff;
+      payload[off + 2] = (crc >>> 16) & 0xff;
+      payload[off + 3] = (crc >>> 24) & 0xff;
+    }
+
+    await this.device.sendFeatureReport(reportId, payload);
+  }
+
+  /** Query the HID descriptor for the expected payload length of a feature report */
+  private getFeatureReportLength(reportId: number): number {
+    if (!this.device) return 0;
+    for (const c of this.device.collections) {
+      const report = (c.featureReports ?? []).find((r) => r.reportId === reportId);
+      if (report) {
+        return (report.items ?? []).reduce(
+          (sum, item) => sum + Math.ceil(((item.reportSize ?? 0) * (item.reportCount ?? 0)) / 8),
+          0,
+        );
+      }
+    }
+    return 0;
+  }
+
   async write(data: Uint8Array): Promise<void> {
     if (!this.device) return;
     const reportId = data[0];

package/src/id.ts

@@ -58,6 +58,11 @@ export const enum InputId {
   BatteryStatus = "BatteryStatus",
   MuteLed = "MuteLed",
 
+  /** Whether a microphone is connected to the controller */
+  Microphone = "Microphone",
+  /** Whether headphones are connected to the controller */
+  Headphone = "Headphone",
+
   /** For placeholder inputs */
   Unknown = "Unknown",
 }