@opendisplay/opendisplay 1.0.0

package/dist/index.js

@@ -0,0 +1,1936 @@
+// src/device.ts
+import { ColorScheme as ColorScheme4, DitherMode as DitherMode2 } from "@opendisplay/epaper-dithering";
+
+// src/encoding/images.ts
+import {
+  ColorScheme as ColorScheme2,
+  DitherMode,
+  ditherImage
+} from "@opendisplay/epaper-dithering";
+
+// src/exceptions.ts
+var OpenDisplayError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "OpenDisplayError";
+  }
+};
+var BLEConnectionError = class extends OpenDisplayError {
+  constructor(message) {
+    super(message);
+    this.name = "BLEConnectionError";
+  }
+};
+var BLETimeoutError = class extends OpenDisplayError {
+  constructor(message) {
+    super(message);
+    this.name = "BLETimeoutError";
+  }
+};
+var ProtocolError = class extends OpenDisplayError {
+  constructor(message) {
+    super(message);
+    this.name = "ProtocolError";
+  }
+};
+var ConfigParseError = class extends ProtocolError {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigParseError";
+  }
+};
+var InvalidResponseError = class extends ProtocolError {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidResponseError";
+  }
+};
+var ImageEncodingError = class extends OpenDisplayError {
+  constructor(message) {
+    super(message);
+    this.name = "ImageEncodingError";
+  }
+};
+
+// src/encoding/bitplanes.ts
+import { ColorScheme } from "@opendisplay/epaper-dithering";
+function encodeBitplanes(paletteImage, colorScheme) {
+  if (colorScheme !== ColorScheme.BWR && colorScheme !== ColorScheme.BWY) {
+    throw new ImageEncodingError(
+      `Bitplane encoding only supports BWR/BWY, got ${ColorScheme[colorScheme]}`
+    );
+  }
+  const { width, height, indices: pixels } = paletteImage;
+  const bytesPerRow = Math.ceil(width / 8);
+  const plane1 = new Uint8Array(bytesPerRow * height);
+  const plane2 = new Uint8Array(bytesPerRow * height);
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      const byteIdx = y * bytesPerRow + Math.floor(x / 8);
+      const bitIdx = 7 - x % 8;
+      const paletteIdx = pixels[y * width + x];
+      if (paletteIdx === 1) {
+        plane1[byteIdx] |= 1 << bitIdx;
+      } else if (paletteIdx === 2) {
+        plane2[byteIdx] |= 1 << bitIdx;
+      }
+    }
+  }
+  return [plane1, plane2];
+}
+
+// src/encoding/images.ts
+function encodeImage(paletteImage, colorScheme) {
+  switch (colorScheme) {
+    case ColorScheme2.MONO:
+      return encode1bpp(paletteImage);
+    case ColorScheme2.BWR:
+    case ColorScheme2.BWY:
+      throw new ImageEncodingError(
+        `Color scheme ${ColorScheme2[colorScheme]} requires bitplane encoding, use encodeBitplanes() instead`
+      );
+    case ColorScheme2.BWRY:
+      return encode2bpp(paletteImage);
+    case ColorScheme2.BWGBRY:
+      return encode4bpp(paletteImage, true);
+    case ColorScheme2.GRAYSCALE_4:
+      return encode2bpp(paletteImage);
+    default:
+      throw new ImageEncodingError(
+        `Unsupported color scheme: ${ColorScheme2[colorScheme]}`
+      );
+  }
+}
+function encode1bpp(paletteImage) {
+  const { width, height, indices: pixels } = paletteImage;
+  const bytesPerRow = Math.ceil(width / 8);
+  const output = new Uint8Array(bytesPerRow * height);
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      const byteIdx = y * bytesPerRow + Math.floor(x / 8);
+      const bitIdx = 7 - x % 8;
+      if (pixels[y * width + x] > 0) {
+        output[byteIdx] |= 1 << bitIdx;
+      }
+    }
+  }
+  return output;
+}
+function encode2bpp(paletteImage) {
+  const { width, height, indices: pixels } = paletteImage;
+  const bytesPerRow = Math.ceil(width / 4);
+  const output = new Uint8Array(bytesPerRow * height);
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      const byteIdx = y * bytesPerRow + Math.floor(x / 4);
+      const pixelInByte = x % 4;
+      const bitShift = (3 - pixelInByte) * 2;
+      const paletteIdx = pixels[y * width + x] & 3;
+      output[byteIdx] |= paletteIdx << bitShift;
+    }
+  }
+  return output;
+}
+function encode4bpp(paletteImage, bwgbryMapping = false) {
+  const { width, height, indices: pixels } = paletteImage;
+  const BWGBRY_MAP = { 0: 0, 1: 1, 2: 2, 3: 3, 4: 5, 5: 6 };
+  const bytesPerRow = Math.ceil(width / 2);
+  const output = new Uint8Array(bytesPerRow * height);
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      const byteIdx = y * bytesPerRow + Math.floor(x / 2);
+      const pixelInByte = x % 2;
+      let paletteIdx = pixels[y * width + x] & 15;
+      if (bwgbryMapping && paletteIdx in BWGBRY_MAP) {
+        paletteIdx = BWGBRY_MAP[paletteIdx];
+      }
+      const bitShift = (1 - pixelInByte) * 4;
+      output[byteIdx] |= paletteIdx << bitShift;
+    }
+  }
+  return output;
+}
+function prepareImageForUpload(imageData, targetWidth, targetHeight, colorScheme, ditherMode = DitherMode.BURKES) {
+  let resizedImageData = imageData;
+  if (imageData.width !== targetWidth || imageData.height !== targetHeight) {
+    console.warn(
+      `Resizing image from ${imageData.width}x${imageData.height} to ${targetWidth}x${targetHeight}`
+    );
+    resizedImageData = resizeImageData(imageData, targetWidth, targetHeight);
+  }
+  const paletteImage = ditherImage(resizedImageData, colorScheme, ditherMode);
+  if (colorScheme === ColorScheme2.BWR || colorScheme === ColorScheme2.BWY) {
+    const [plane1, plane2] = encodeBitplanes(paletteImage, colorScheme);
+    const result = new Uint8Array(plane1.length + plane2.length);
+    result.set(plane1, 0);
+    result.set(plane2, plane1.length);
+    return result;
+  } else {
+    return encodeImage(paletteImage, colorScheme);
+  }
+}
+function resizeImageData(imageData, targetWidth, targetHeight) {
+  const canvas = new OffscreenCanvas(imageData.width, imageData.height);
+  const ctx = canvas.getContext("2d");
+  if (!ctx) {
+    throw new ImageEncodingError("Failed to get canvas context");
+  }
+  ctx.putImageData(imageData, 0, 0);
+  const targetCanvas = new OffscreenCanvas(targetWidth, targetHeight);
+  const targetCtx = targetCanvas.getContext("2d");
+  if (!targetCtx) {
+    throw new ImageEncodingError("Failed to get target canvas context");
+  }
+  targetCtx.drawImage(canvas, 0, 0, targetWidth, targetHeight);
+  return targetCtx.getImageData(0, 0, targetWidth, targetHeight);
+}
+
+// src/encoding/compression.ts
+import pako from "pako";
+function compressImageData(data, level = 6) {
+  if (level === 0) {
+    return data;
+  }
+  const compressed = pako.deflate(data, { level });
+  const ratio = data.length > 0 ? compressed.length / data.length * 100 : 0;
+  console.debug(
+    `Compressed ${data.length} bytes -> ${compressed.length} bytes (${ratio.toFixed(1)}%)`
+  );
+  return compressed;
+}
+
+// src/models/enums.ts
+var RefreshMode = /* @__PURE__ */ ((RefreshMode2) => {
+  RefreshMode2[RefreshMode2["FULL"] = 0] = "FULL";
+  RefreshMode2[RefreshMode2["FAST"] = 1] = "FAST";
+  RefreshMode2[RefreshMode2["PARTIAL"] = 2] = "PARTIAL";
+  RefreshMode2[RefreshMode2["PARTIAL2"] = 3] = "PARTIAL2";
+  return RefreshMode2;
+})(RefreshMode || {});
+var ICType = /* @__PURE__ */ ((ICType2) => {
+  ICType2[ICType2["NRF52840"] = 1] = "NRF52840";
+  ICType2[ICType2["ESP32_S3"] = 2] = "ESP32_S3";
+  ICType2[ICType2["ESP32_C3"] = 3] = "ESP32_C3";
+  ICType2[ICType2["ESP32_C6"] = 4] = "ESP32_C6";
+  return ICType2;
+})(ICType || {});
+var PowerMode = /* @__PURE__ */ ((PowerMode2) => {
+  PowerMode2[PowerMode2["BATTERY"] = 1] = "BATTERY";
+  PowerMode2[PowerMode2["USB"] = 2] = "USB";
+  PowerMode2[PowerMode2["SOLAR"] = 3] = "SOLAR";
+  return PowerMode2;
+})(PowerMode || {});
+var BusType = /* @__PURE__ */ ((BusType2) => {
+  BusType2[BusType2["I2C"] = 0] = "I2C";
+  BusType2[BusType2["SPI"] = 1] = "SPI";
+  return BusType2;
+})(BusType || {});
+var Rotation = /* @__PURE__ */ ((Rotation2) => {
+  Rotation2[Rotation2["ROTATE_0"] = 0] = "ROTATE_0";
+  Rotation2[Rotation2["ROTATE_90"] = 90] = "ROTATE_90";
+  Rotation2[Rotation2["ROTATE_180"] = 180] = "ROTATE_180";
+  Rotation2[Rotation2["ROTATE_270"] = 270] = "ROTATE_270";
+  return Rotation2;
+})(Rotation || {});
+
+// src/protocol/constants.ts
+var SERVICE_UUID = "00002446-0000-1000-8000-00805f9b34fb";
+var MANUFACTURER_ID = 9286;
+var RESPONSE_HIGH_BIT_FLAG = 32768;
+var CHUNK_SIZE = 230;
+var CONFIG_CHUNK_SIZE = 200;
+var MAX_COMPRESSED_SIZE = 50 * 1024;
+var MAX_START_PAYLOAD = 200;
+var CommandCode = /* @__PURE__ */ ((CommandCode3) => {
+  CommandCode3[CommandCode3["READ_CONFIG"] = 64] = "READ_CONFIG";
+  CommandCode3[CommandCode3["WRITE_CONFIG"] = 65] = "WRITE_CONFIG";
+  CommandCode3[CommandCode3["WRITE_CONFIG_CHUNK"] = 66] = "WRITE_CONFIG_CHUNK";
+  CommandCode3[CommandCode3["READ_FW_VERSION"] = 67] = "READ_FW_VERSION";
+  CommandCode3[CommandCode3["REBOOT"] = 15] = "REBOOT";
+  CommandCode3[CommandCode3["DIRECT_WRITE_START"] = 112] = "DIRECT_WRITE_START";
+  CommandCode3[CommandCode3["DIRECT_WRITE_DATA"] = 113] = "DIRECT_WRITE_DATA";
+  CommandCode3[CommandCode3["DIRECT_WRITE_END"] = 114] = "DIRECT_WRITE_END";
+  return CommandCode3;
+})(CommandCode || {});
+
+// src/protocol/commands.ts
+function buildReadConfigCommand() {
+  const buffer = new ArrayBuffer(2);
+  const view = new DataView(buffer);
+  view.setUint16(0, 64 /* READ_CONFIG */, false);
+  return new Uint8Array(buffer);
+}
+function buildReadFwVersionCommand() {
+  const buffer = new ArrayBuffer(2);
+  const view = new DataView(buffer);
+  view.setUint16(0, 67 /* READ_FW_VERSION */, false);
+  return new Uint8Array(buffer);
+}
+function buildRebootCommand() {
+  const buffer = new ArrayBuffer(2);
+  const view = new DataView(buffer);
+  view.setUint16(0, 15 /* REBOOT */, false);
+  return new Uint8Array(buffer);
+}
+function buildDirectWriteStartCompressed(uncompressedSize, compressedData) {
+  const maxDataInStart = MAX_START_PAYLOAD - 6;
+  const headerSize = 6;
+  const totalSize = compressedData.length <= maxDataInStart ? headerSize + compressedData.length : MAX_START_PAYLOAD;
+  const buffer = new ArrayBuffer(totalSize);
+  const view = new DataView(buffer);
+  view.setUint16(0, 112 /* DIRECT_WRITE_START */, false);
+  view.setUint32(2, uncompressedSize, true);
+  const startCommand = new Uint8Array(buffer);
+  const dataLength = Math.min(compressedData.length, maxDataInStart);
+  startCommand.set(compressedData.subarray(0, dataLength), 6);
+  const remainingData = compressedData.length <= maxDataInStart ? new Uint8Array(0) : compressedData.subarray(maxDataInStart);
+  return [startCommand, remainingData];
+}
+function buildDirectWriteStartUncompressed() {
+  const buffer = new ArrayBuffer(2);
+  const view = new DataView(buffer);
+  view.setUint16(0, 112 /* DIRECT_WRITE_START */, false);
+  return new Uint8Array(buffer);
+}
+function buildDirectWriteDataCommand(chunkData) {
+  if (chunkData.length > CHUNK_SIZE) {
+    throw new Error(
+      `Chunk size ${chunkData.length} exceeds maximum ${CHUNK_SIZE}`
+    );
+  }
+  const buffer = new ArrayBuffer(2 + chunkData.length);
+  const view = new DataView(buffer);
+  view.setUint16(0, 113 /* DIRECT_WRITE_DATA */, false);
+  const result = new Uint8Array(buffer);
+  result.set(chunkData, 2);
+  return result;
+}
+function buildDirectWriteEndCommand(refreshMode = 0) {
+  const buffer = new ArrayBuffer(3);
+  const view = new DataView(buffer);
+  view.setUint16(0, 114 /* DIRECT_WRITE_END */, false);
+  view.setUint8(2, refreshMode);
+  return new Uint8Array(buffer);
+}
+function buildWriteConfigCommand(configData) {
+  const configLen = configData.length;
+  if (configLen <= CONFIG_CHUNK_SIZE) {
+    const buffer = new ArrayBuffer(2 + configLen);
+    const view = new DataView(buffer);
+    view.setUint16(0, 65 /* WRITE_CONFIG */, false);
+    const result = new Uint8Array(buffer);
+    result.set(configData, 2);
+    return [result, []];
+  }
+  const firstChunkDataSize = CONFIG_CHUNK_SIZE - 2;
+  const firstBuffer = new ArrayBuffer(2 + 2 + firstChunkDataSize);
+  const firstView = new DataView(firstBuffer);
+  firstView.setUint16(0, 65 /* WRITE_CONFIG */, false);
+  firstView.setUint16(2, configLen, true);
+  const firstCommand = new Uint8Array(firstBuffer);
+  firstCommand.set(configData.subarray(0, firstChunkDataSize), 4);
+  const chunks = [];
+  let offset = firstChunkDataSize;
+  while (offset < configLen) {
+    const chunkSize = Math.min(CONFIG_CHUNK_SIZE, configLen - offset);
+    const buffer = new ArrayBuffer(2 + chunkSize);
+    const view = new DataView(buffer);
+    view.setUint16(0, 66 /* WRITE_CONFIG_CHUNK */, false);
+    const chunk = new Uint8Array(buffer);
+    chunk.set(configData.subarray(offset, offset + chunkSize), 2);
+    chunks.push(chunk);
+    offset += chunkSize;
+  }
+  return [firstCommand, chunks];
+}
+
+// src/protocol/responses.ts
+function unpackCommandCode(data, offset = 0) {
+  const view = new DataView(data.buffer, data.byteOffset + offset, 2);
+  return view.getUint16(0, false);
+}
+function stripCommandEcho(data, expectedCmd) {
+  if (data.length >= 2) {
+    const echo = unpackCommandCode(data);
+    if (echo === expectedCmd || echo === (expectedCmd | RESPONSE_HIGH_BIT_FLAG)) {
+      return data.subarray(2);
+    }
+  }
+  return data;
+}
+function checkResponseType(response) {
+  const code = unpackCommandCode(response);
+  const isAck = Boolean(code & RESPONSE_HIGH_BIT_FLAG);
+  const command = code & ~RESPONSE_HIGH_BIT_FLAG;
+  return [command, isAck];
+}
+function validateAckResponse(data, expectedCommand) {
+  if (data.length < 2) {
+    throw new InvalidResponseError(
+      `ACK too short: ${data.length} bytes (need at least 2)`
+    );
+  }
+  const responseCode = unpackCommandCode(data);
+  const validResponses = /* @__PURE__ */ new Set([
+    expectedCommand,
+    expectedCommand | RESPONSE_HIGH_BIT_FLAG
+  ]);
+  if (!validResponses.has(responseCode)) {
+    throw new InvalidResponseError(
+      `ACK mismatch: expected 0x${expectedCommand.toString(16).padStart(4, "0")}, got 0x${responseCode.toString(16).padStart(4, "0")}`
+    );
+  }
+}
+function parseFirmwareVersion(data) {
+  if (data.length < 5) {
+    throw new InvalidResponseError(
+      `Firmware version response too short: ${data.length} bytes (need at least 5)`
+    );
+  }
+  const echo = unpackCommandCode(data);
+  if (echo !== 67 && echo !== (67 | RESPONSE_HIGH_BIT_FLAG)) {
+    throw new InvalidResponseError(
+      `Firmware version echo mismatch: expected 0x0043, got 0x${echo.toString(16).padStart(4, "0")}`
+    );
+  }
+  const major = data[2];
+  const minor = data[3];
+  const shaLength = data[4];
+  if (shaLength === 0) {
+    throw new InvalidResponseError(
+      "Firmware version missing SHA hash (shaLength is 0)"
+    );
+  }
+  const expectedTotalLength = 5 + shaLength;
+  if (data.length < expectedTotalLength) {
+    throw new InvalidResponseError(
+      `Firmware version response incomplete: expected ${expectedTotalLength} bytes (5 header + ${shaLength} SHA), got ${data.length}`
+    );
+  }
+  const shaBytes = data.subarray(5, 5 + shaLength);
+  const textDecoder = new TextDecoder("ascii");
+  let sha;
+  try {
+    sha = textDecoder.decode(shaBytes);
+  } catch (e) {
+    throw new InvalidResponseError(
+      `Invalid SHA hash encoding (expected ASCII): ${e}`
+    );
+  }
+  return {
+    major,
+    minor,
+    sha
+  };
+}
+
+// src/models/config.ts
+import { ColorScheme as ColorScheme3 } from "@opendisplay/epaper-dithering";
+var SystemConfig;
+((SystemConfig2) => {
+  SystemConfig2.SIZE = 22;
+  function hasPwrPin(config) {
+    return !!(config.deviceFlags & 1);
+  }
+  SystemConfig2.hasPwrPin = hasPwrPin;
+  function needsXiaoinit(config) {
+    return !!(config.deviceFlags & 2);
+  }
+  SystemConfig2.needsXiaoinit = needsXiaoinit;
+  function icTypeEnum(config) {
+    if (Object.values(ICType).includes(config.icType)) {
+      return config.icType;
+    }
+    return config.icType;
+  }
+  SystemConfig2.icTypeEnum = icTypeEnum;
+  function fromBytes(data) {
+    if (data.length < SystemConfig2.SIZE) {
+      throw new Error(`Invalid SystemConfig size: ${data.length} < ${SystemConfig2.SIZE}`);
+    }
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    return {
+      icType: view.getUint16(0, true),
+      // little-endian
+      communicationModes: view.getUint8(2),
+      deviceFlags: view.getUint8(3),
+      pwrPin: view.getUint8(4),
+      reserved: data.slice(5, 22)
+    };
+  }
+  SystemConfig2.fromBytes = fromBytes;
+})(SystemConfig || (SystemConfig = {}));
+var ManufacturerData;
+((ManufacturerData2) => {
+  ManufacturerData2.SIZE = 22;
+  function fromBytes(data) {
+    if (data.length < ManufacturerData2.SIZE) {
+      throw new Error(`Invalid ManufacturerData size: ${data.length} < ${ManufacturerData2.SIZE}`);
+    }
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    return {
+      manufacturerId: view.getUint16(0, true),
+      // little-endian
+      boardType: view.getUint8(2),
+      boardRevision: view.getUint8(3),
+      reserved: data.slice(4, 22)
+    };
+  }
+  ManufacturerData2.fromBytes = fromBytes;
+})(ManufacturerData || (ManufacturerData = {}));
+var PowerOption;
+((PowerOption2) => {
+  PowerOption2.SIZE = 30;
+  function batteryMah(config) {
+    return config.batteryCapacityMah;
+  }
+  PowerOption2.batteryMah = batteryMah;
+  function powerModeEnum(config) {
+    if (Object.values(PowerMode).includes(config.powerMode)) {
+      return config.powerMode;
+    }
+    return config.powerMode;
+  }
+  PowerOption2.powerModeEnum = powerModeEnum;
+  function fromBytes(data) {
+    if (data.length < PowerOption2.SIZE) {
+      throw new Error(`Invalid PowerOption size: ${data.length} < ${PowerOption2.SIZE}`);
+    }
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const batteryMah2 = data[1] | data[2] << 8 | data[3] << 16;
+    return {
+      powerMode: view.getUint8(0),
+      batteryCapacityMah: batteryMah2,
+      sleepTimeoutMs: view.getUint16(4, true),
+      // little-endian
+      txPower: view.getInt8(6),
+      sleepFlags: view.getUint8(7),
+      batterySensePin: view.getUint8(8),
+      batterySenseEnablePin: view.getUint8(9),
+      batterySenseFlags: view.getUint8(10),
+      capacityEstimator: view.getUint8(11),
+      voltageScalingFactor: view.getUint16(12, true),
+      // little-endian
+      deepSleepCurrentUa: view.getUint32(14, true),
+      // little-endian
+      deepSleepTimeSeconds: view.getUint16(18, true),
+      // little-endian
+      reserved: data.slice(20, 30)
+    };
+  }
+  PowerOption2.fromBytes = fromBytes;
+})(PowerOption || (PowerOption = {}));
+var DisplayConfig;
+((DisplayConfig2) => {
+  DisplayConfig2.SIZE = 46;
+  function supportsRaw(config) {
+    return !!(config.transmissionModes & 1);
+  }
+  DisplayConfig2.supportsRaw = supportsRaw;
+  function supportsZip(config) {
+    return !!(config.transmissionModes & 2);
+  }
+  DisplayConfig2.supportsZip = supportsZip;
+  function supportsG5(config) {
+    return !!(config.transmissionModes & 4);
+  }
+  DisplayConfig2.supportsG5 = supportsG5;
+  function supportsDirectWrite(config) {
+    return !!(config.transmissionModes & 8);
+  }
+  DisplayConfig2.supportsDirectWrite = supportsDirectWrite;
+  function clearOnBoot(config) {
+    return !!(config.transmissionModes & 128);
+  }
+  DisplayConfig2.clearOnBoot = clearOnBoot;
+  function colorSchemeEnum(config) {
+    if (Object.values(ColorScheme3).includes(config.colorScheme)) {
+      return config.colorScheme;
+    }
+    return config.colorScheme;
+  }
+  DisplayConfig2.colorSchemeEnum = colorSchemeEnum;
+  function rotationEnum(config) {
+    if (Object.values(Rotation).includes(config.rotation)) {
+      return config.rotation;
+    }
+    return config.rotation;
+  }
+  DisplayConfig2.rotationEnum = rotationEnum;
+  function fromBytes(data) {
+    if (data.length < DisplayConfig2.SIZE) {
+      throw new Error(`Invalid DisplayConfig size: ${data.length} < ${DisplayConfig2.SIZE}`);
+    }
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    return {
+      instanceNumber: view.getUint8(0),
+      displayTechnology: view.getUint8(1),
+      panelIcType: view.getUint16(2, true),
+      // little-endian
+      pixelWidth: view.getUint16(4, true),
+      // little-endian
+      pixelHeight: view.getUint16(6, true),
+      // little-endian
+      activeWidthMm: view.getUint16(8, true),
+      // little-endian
+      activeHeightMm: view.getUint16(10, true),
+      // little-endian
+      tagType: view.getUint16(12, true),
+      // little-endian
+      rotation: view.getUint8(14),
+      resetPin: view.getUint8(15),
+      busyPin: view.getUint8(16),
+      dcPin: view.getUint8(17),
+      csPin: view.getUint8(18),
+      dataPin: view.getUint8(19),
+      partialUpdateSupport: view.getUint8(20),
+      colorScheme: view.getUint8(21),
+      transmissionModes: view.getUint8(22),
+      clkPin: view.getUint8(23),
+      reservedPins: data.slice(24, 31),
+      // 7 pins
+      reserved: data.slice(31, 46)
+      // 15 bytes
+    };
+  }
+  DisplayConfig2.fromBytes = fromBytes;
+})(DisplayConfig || (DisplayConfig = {}));
+var LedConfig;
+((LedConfig2) => {
+  LedConfig2.SIZE = 22;
+  function fromBytes(data) {
+    if (data.length < LedConfig2.SIZE) {
+      throw new Error(`Invalid LedConfig size: ${data.length} < ${LedConfig2.SIZE}`);
+    }
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    return {
+      instanceNumber: view.getUint8(0),
+      ledType: view.getUint8(1),
+      led1R: view.getUint8(2),
+      led2G: view.getUint8(3),
+      led3B: view.getUint8(4),
+      led4: view.getUint8(5),
+      ledFlags: view.getUint8(6),
+      reserved: data.slice(7, 22)
+    };
+  }
+  LedConfig2.fromBytes = fromBytes;
+})(LedConfig || (LedConfig = {}));
+var SensorData;
+((SensorData2) => {
+  SensorData2.SIZE = 30;
+  function fromBytes(data) {
+    if (data.length < SensorData2.SIZE) {
+      throw new Error(`Invalid SensorData size: ${data.length} < ${SensorData2.SIZE}`);
+    }
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    return {
+      instanceNumber: view.getUint8(0),
+      sensorType: view.getUint16(1, true),
+      // little-endian
+      busId: view.getUint8(3),
+      reserved: data.slice(4, 30)
+    };
+  }
+  SensorData2.fromBytes = fromBytes;
+})(SensorData || (SensorData = {}));
+var DataBus;
+((DataBus2) => {
+  DataBus2.SIZE = 30;
+  function busTypeEnum(config) {
+    if (Object.values(BusType).includes(config.busType)) {
+      return config.busType;
+    }
+    return config.busType;
+  }
+  DataBus2.busTypeEnum = busTypeEnum;
+  function fromBytes(data) {
+    if (data.length < DataBus2.SIZE) {
+      throw new Error(`Invalid DataBus size: ${data.length} < ${DataBus2.SIZE}`);
+    }
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    return {
+      instanceNumber: view.getUint8(0),
+      busType: view.getUint8(1),
+      pin1: view.getUint8(2),
+      pin2: view.getUint8(3),
+      pin3: view.getUint8(4),
+      pin4: view.getUint8(5),
+      pin5: view.getUint8(6),
+      pin6: view.getUint8(7),
+      pin7: view.getUint8(8),
+      busSpeedHz: view.getUint32(9, true),
+      // little-endian
+      busFlags: view.getUint8(13),
+      pullups: view.getUint8(14),
+      pulldowns: view.getUint8(15),
+      reserved: data.slice(16, 30)
+    };
+  }
+  DataBus2.fromBytes = fromBytes;
+})(DataBus || (DataBus = {}));
+var BinaryInputs;
+((BinaryInputs2) => {
+  BinaryInputs2.SIZE = 30;
+  function fromBytes(data) {
+    if (data.length < BinaryInputs2.SIZE) {
+      throw new Error(`Invalid BinaryInputs size: ${data.length} < ${BinaryInputs2.SIZE}`);
+    }
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    return {
+      instanceNumber: view.getUint8(0),
+      inputType: view.getUint8(1),
+      displayAs: view.getUint8(2),
+      reservedPins: data.slice(3, 11),
+      // 8 pins
+      inputFlags: view.getUint8(11),
+      invert: view.getUint8(12),
+      pullups: view.getUint8(13),
+      pulldowns: view.getUint8(14),
+      reserved: data.slice(15, 30)
+    };
+  }
+  BinaryInputs2.fromBytes = fromBytes;
+})(BinaryInputs || (BinaryInputs = {}));
+
+// src/protocol/config-parser.ts
+var PACKET_TYPE_SYSTEM = 1;
+var PACKET_TYPE_MANUFACTURER = 2;
+var PACKET_TYPE_POWER = 4;
+var PACKET_TYPE_DISPLAY = 32;
+var PACKET_TYPE_LED = 33;
+var PACKET_TYPE_SENSOR = 35;
+var PACKET_TYPE_DATABUS = 36;
+var PACKET_TYPE_BINARY_INPUT = 37;
+function parseConfigResponse(rawData) {
+  if (rawData.length < 5) {
+    throw new ConfigParseError(
+      `Config data too short: ${rawData.length} bytes (need at least 5)`
+    );
+  }
+  const view = new DataView(rawData.buffer, rawData.byteOffset, rawData.byteLength);
+  const configLength = view.getUint16(0, true);
+  const configVersion = view.getUint8(2);
+  console.debug(
+    `TLV wrapper: length=${configLength} bytes, version=${configVersion}`
+  );
+  let packetData;
+  if (rawData.length > 5) {
+    packetData = rawData.slice(3, -2);
+  } else {
+    packetData = rawData.slice(3);
+  }
+  console.debug(`Packet data after wrapper strip: ${packetData.length} bytes`);
+  return parseTlvConfig(packetData, configVersion);
+}
+function parseTlvConfig(data, version = 1) {
+  if (data.length < 2) {
+    throw new ConfigParseError(
+      `TLV data too short: ${data.length} bytes (need at least 2)`
+    );
+  }
+  console.debug(`Parsing TLV config, ${data.length} bytes`);
+  let offset = 0;
+  const packets = /* @__PURE__ */ new Map();
+  while (offset < data.length - 1) {
+    if (offset + 2 > data.length) {
+      break;
+    }
+    const packetNumber = data[offset];
+    const packetType = data[offset + 1];
+    offset += 2;
+    const packetSize = getPacketSize(packetType);
+    if (packetSize === null) {
+      console.warn(
+        `Unknown packet type 0x${packetType.toString(16).padStart(2, "0")} at offset ${offset - 2}, skipping`
+      );
+      break;
+    }
+    if (offset + packetSize > data.length) {
+      throw new ConfigParseError(
+        `Packet type 0x${packetType.toString(16).padStart(2, "0")} truncated: need ${packetSize} bytes, have ${data.length - offset}`
+      );
+    }
+    const packetData = data.slice(offset, offset + packetSize);
+    offset += packetSize;
+    const key = `${packetType}-${packetNumber}`;
+    packets.set(key, packetData);
+    console.debug(
+      `Parsed packet: type=0x${packetType.toString(16).padStart(2, "0")}, num=${packetNumber}, size=${packetSize}`
+    );
+  }
+  let system;
+  let manufacturer;
+  let power;
+  const displays = [];
+  const leds = [];
+  const sensors = [];
+  const dataBuses = [];
+  const binaryInputs = [];
+  for (const [key, packetData] of packets) {
+    const [packetTypeStr] = key.split("-");
+    const packetType = parseInt(packetTypeStr, 10);
+    switch (packetType) {
+      case PACKET_TYPE_SYSTEM:
+        system = parseSystemConfig(packetData);
+        break;
+      case PACKET_TYPE_MANUFACTURER:
+        manufacturer = parseManufacturerData(packetData);
+        break;
+      case PACKET_TYPE_POWER:
+        power = parsePowerOption(packetData);
+        break;
+      case PACKET_TYPE_DISPLAY:
+        displays.push(parseDisplayConfig(packetData));
+        break;
+      case PACKET_TYPE_LED:
+        leds.push(parseLedConfig(packetData));
+        break;
+      case PACKET_TYPE_SENSOR:
+        sensors.push(parseSensorData(packetData));
+        break;
+      case PACKET_TYPE_DATABUS:
+        dataBuses.push(parseDataBus(packetData));
+        break;
+      case PACKET_TYPE_BINARY_INPUT:
+        binaryInputs.push(parseBinaryInputs(packetData));
+        break;
+    }
+  }
+  return {
+    system,
+    manufacturer,
+    power,
+    displays,
+    leds,
+    sensors,
+    dataBuses,
+    binaryInputs,
+    version,
+    // From firmware wrapper
+    minorVersion: 1,
+    // Not stored in device (only single version byte exists)
+    loaded: true
+  };
+}
+function getPacketSize(packetType) {
+  const sizes = {
+    [PACKET_TYPE_SYSTEM]: 22,
+    [PACKET_TYPE_MANUFACTURER]: 22,
+    [PACKET_TYPE_POWER]: 30,
+    // Fixed: was 32
+    [PACKET_TYPE_DISPLAY]: 46,
+    // Fixed: was 66
+    [PACKET_TYPE_LED]: 22,
+    [PACKET_TYPE_SENSOR]: 30,
+    [PACKET_TYPE_DATABUS]: 30,
+    // Fixed: was 28
+    [PACKET_TYPE_BINARY_INPUT]: 30
+    // Fixed: was 29
+  };
+  return sizes[packetType] ?? null;
+}
+function parseSystemConfig(data) {
+  if (data.length < 22) {
+    throw new ConfigParseError(
+      `SystemConfig too short: ${data.length} bytes (need 22)`
+    );
+  }
+  return SystemConfig.fromBytes(data);
+}
+function parseManufacturerData(data) {
+  if (data.length < 22) {
+    throw new ConfigParseError(
+      `ManufacturerData too short: ${data.length} bytes (need 22)`
+    );
+  }
+  return ManufacturerData.fromBytes(data);
+}
+function parsePowerOption(data) {
+  if (data.length < 30) {
+    throw new ConfigParseError(
+      `PowerOption too short: ${data.length} bytes (need 30)`
+    );
+  }
+  return PowerOption.fromBytes(data);
+}
+function parseDisplayConfig(data) {
+  if (data.length < 46) {
+    throw new ConfigParseError(
+      `DisplayConfig too short: ${data.length} bytes (need 46)`
+    );
+  }
+  return DisplayConfig.fromBytes(data);
+}
+function parseLedConfig(data) {
+  if (data.length < 22) {
+    throw new ConfigParseError(
+      `LedConfig too short: ${data.length} bytes (need 22)`
+    );
+  }
+  return LedConfig.fromBytes(data);
+}
+function parseSensorData(data) {
+  if (data.length < 30) {
+    throw new ConfigParseError(
+      `SensorData too short: ${data.length} bytes (need 30)`
+    );
+  }
+  return SensorData.fromBytes(data);
+}
+function parseDataBus(data) {
+  if (data.length < 30) {
+    throw new ConfigParseError(
+      `DataBus too short: ${data.length} bytes (need 30)`
+    );
+  }
+  return DataBus.fromBytes(data);
+}
+function parseBinaryInputs(data) {
+  if (data.length < 30) {
+    throw new ConfigParseError(
+      `BinaryInputs too short: ${data.length} bytes (need 30)`
+    );
+  }
+  return BinaryInputs.fromBytes(data);
+}
+
+// src/protocol/config-serializer.ts
+var PACKET_TYPE_SYSTEM2 = 1;
+var PACKET_TYPE_MANUFACTURER2 = 2;
+var PACKET_TYPE_POWER2 = 4;
+var PACKET_TYPE_DISPLAY2 = 32;
+var PACKET_TYPE_LED2 = 33;
+var PACKET_TYPE_SENSOR2 = 35;
+var PACKET_TYPE_DATABUS2 = 36;
+var PACKET_TYPE_BINARY_INPUT2 = 37;
+function calculateConfigCrc(data) {
+  let crc = 4294967295;
+  for (const byte of data) {
+    crc ^= byte;
+    for (let i = 0; i < 8; i++) {
+      if (crc & 1) {
+        crc = crc >>> 1 ^ 3988292384;
+      } else {
+        crc = crc >>> 1;
+      }
+    }
+  }
+  const crc32 = ~crc >>> 0;
+  return crc32 & 65535;
+}
+function serializeSystemConfig(config) {
+  const buffer = new ArrayBuffer(22);
+  const view = new DataView(buffer);
+  const result = new Uint8Array(buffer);
+  view.setUint16(0, config.icType, true);
+  view.setUint8(2, config.communicationModes);
+  view.setUint8(3, config.deviceFlags);
+  view.setUint8(4, config.pwrPin);
+  const reserved = config.reserved || new Uint8Array(17);
+  result.set(reserved.subarray(0, 17), 5);
+  return result;
+}
+function serializeManufacturerData(config) {
+  const buffer = new ArrayBuffer(22);
+  const view = new DataView(buffer);
+  const result = new Uint8Array(buffer);
+  view.setUint16(0, config.manufacturerId, true);
+  view.setUint8(2, config.boardType);
+  view.setUint8(3, config.boardRevision);
+  const reserved = config.reserved || new Uint8Array(18);
+  result.set(reserved.subarray(0, 18), 4);
+  return result;
+}
+function serializePowerOption(config) {
+  const buffer = new ArrayBuffer(30);
+  const view = new DataView(buffer);
+  const result = new Uint8Array(buffer);
+  view.setUint8(0, config.powerMode);
+  view.setUint8(1, config.batteryCapacityMah & 255);
+  view.setUint8(2, config.batteryCapacityMah >> 8 & 255);
+  view.setUint8(3, config.batteryCapacityMah >> 16 & 255);
+  view.setUint16(4, config.sleepTimeoutMs, true);
+  view.setInt8(6, config.txPower);
+  view.setUint8(7, config.sleepFlags);
+  view.setUint8(8, config.batterySensePin);
+  view.setUint8(9, config.batterySenseEnablePin);
+  view.setUint8(10, config.batterySenseFlags);
+  view.setUint8(11, config.capacityEstimator);
+  view.setUint16(12, config.voltageScalingFactor, true);
+  view.setUint32(14, config.deepSleepCurrentUa, true);
+  view.setUint16(18, config.deepSleepTimeSeconds, true);
+  const reserved = config.reserved || new Uint8Array(10);
+  result.set(reserved.subarray(0, 10), 20);
+  return result;
+}
+function serializeDisplayConfig(config) {
+  const buffer = new ArrayBuffer(46);
+  const view = new DataView(buffer);
+  const result = new Uint8Array(buffer);
+  view.setUint8(0, config.instanceNumber);
+  view.setUint8(1, config.displayTechnology);
+  view.setUint16(2, config.panelIcType, true);
+  view.setUint16(4, config.pixelWidth, true);
+  view.setUint16(6, config.pixelHeight, true);
+  view.setUint16(8, config.activeWidthMm, true);
+  view.setUint16(10, config.activeHeightMm, true);
+  view.setUint16(12, config.tagType, true);
+  view.setUint8(14, config.rotation);
+  view.setUint8(15, config.resetPin);
+  view.setUint8(16, config.busyPin);
+  view.setUint8(17, config.dcPin);
+  view.setUint8(18, config.csPin);
+  view.setUint8(19, config.dataPin);
+  view.setUint8(20, config.partialUpdateSupport);
+  view.setUint8(21, config.colorScheme);
+  view.setUint8(22, config.transmissionModes);
+  view.setUint8(23, config.clkPin);
+  const reservedPins = config.reservedPins || new Uint8Array(7).fill(255);
+  result.set(reservedPins.subarray(0, 7), 24);
+  const reserved = config.reserved || new Uint8Array(15);
+  result.set(reserved.subarray(0, 15), 31);
+  return result;
+}
+function serializeLedConfig(config) {
+  const buffer = new ArrayBuffer(22);
+  const view = new DataView(buffer);
+  const result = new Uint8Array(buffer);
+  view.setUint8(0, config.instanceNumber);
+  view.setUint8(1, config.ledType);
+  view.setUint8(2, config.led1R);
+  view.setUint8(3, config.led2G);
+  view.setUint8(4, config.led3B);
+  view.setUint8(5, config.led4);
+  view.setUint8(6, config.ledFlags);
+  const reserved = config.reserved || new Uint8Array(15);
+  result.set(reserved.subarray(0, 15), 7);
+  return result;
+}
+function serializeSensorData(config) {
+  const buffer = new ArrayBuffer(30);
+  const view = new DataView(buffer);
+  const result = new Uint8Array(buffer);
+  view.setUint8(0, config.instanceNumber);
+  view.setUint16(1, config.sensorType, true);
+  view.setUint8(3, config.busId);
+  const reserved = config.reserved || new Uint8Array(26);
+  result.set(reserved.subarray(0, 26), 4);
+  return result;
+}
+function serializeDataBus(config) {
+  const buffer = new ArrayBuffer(30);
+  const view = new DataView(buffer);
+  const result = new Uint8Array(buffer);
+  view.setUint8(0, config.instanceNumber);
+  view.setUint8(1, config.busType);
+  view.setUint8(2, config.pin1);
+  view.setUint8(3, config.pin2);
+  view.setUint8(4, config.pin3);
+  view.setUint8(5, config.pin4);
+  view.setUint8(6, config.pin5);
+  view.setUint8(7, config.pin6);
+  view.setUint8(8, config.pin7);
+  view.setUint32(9, config.busSpeedHz, true);
+  view.setUint8(13, config.busFlags);
+  view.setUint8(14, config.pullups);
+  view.setUint8(15, config.pulldowns);
+  const reserved = config.reserved || new Uint8Array(14);
+  result.set(reserved.subarray(0, 14), 16);
+  return result;
+}
+function serializeBinaryInputs(config) {
+  const buffer = new ArrayBuffer(30);
+  const view = new DataView(buffer);
+  const result = new Uint8Array(buffer);
+  view.setUint8(0, config.instanceNumber);
+  view.setUint8(1, config.inputType);
+  view.setUint8(2, config.displayAs);
+  const reservedPins = config.reservedPins || new Uint8Array(8);
+  result.set(reservedPins.subarray(0, 8), 3);
+  view.setUint8(11, config.inputFlags);
+  view.setUint8(12, config.invert);
+  view.setUint8(13, config.pullups);
+  view.setUint8(14, config.pulldowns);
+  const reserved = config.reserved || new Uint8Array(15);
+  result.set(reserved.subarray(0, 15), 15);
+  return result;
+}
+function serializeConfig(config) {
+  const chunks = [];
+  const header = new Uint8Array([0, 0, config.version]);
+  chunks.push(header);
+  if (config.system) {
+    chunks.push(new Uint8Array([0, PACKET_TYPE_SYSTEM2]));
+    chunks.push(serializeSystemConfig(config.system));
+  }
+  if (config.manufacturer) {
+    chunks.push(new Uint8Array([0, PACKET_TYPE_MANUFACTURER2]));
+    chunks.push(serializeManufacturerData(config.manufacturer));
+  }
+  if (config.power) {
+    chunks.push(new Uint8Array([0, PACKET_TYPE_POWER2]));
+    chunks.push(serializePowerOption(config.power));
+  }
+  for (let i = 0; i < Math.min(config.displays.length, 4); i++) {
+    chunks.push(new Uint8Array([i, PACKET_TYPE_DISPLAY2]));
+    chunks.push(serializeDisplayConfig(config.displays[i]));
+  }
+  for (let i = 0; i < Math.min(config.leds.length, 4); i++) {
+    chunks.push(new Uint8Array([i, PACKET_TYPE_LED2]));
+    chunks.push(serializeLedConfig(config.leds[i]));
+  }
+  for (let i = 0; i < Math.min(config.sensors.length, 4); i++) {
+    chunks.push(new Uint8Array([i, PACKET_TYPE_SENSOR2]));
+    chunks.push(serializeSensorData(config.sensors[i]));
+  }
+  for (let i = 0; i < Math.min(config.dataBuses.length, 4); i++) {
+    chunks.push(new Uint8Array([i, PACKET_TYPE_DATABUS2]));
+    chunks.push(serializeDataBus(config.dataBuses[i]));
+  }
+  for (let i = 0; i < Math.min(config.binaryInputs.length, 4); i++) {
+    chunks.push(new Uint8Array([i, PACKET_TYPE_BINARY_INPUT2]));
+    chunks.push(serializeBinaryInputs(config.binaryInputs[i]));
+  }
+  const totalDataSize = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+  if (totalDataSize + 2 > 4096) {
+    throw new Error(
+      `Config size ${totalDataSize + 2} bytes exceeds maximum 4096 bytes`
+    );
+  }
+  const packetData = new Uint8Array(totalDataSize);
+  let offset = 0;
+  for (const chunk of chunks) {
+    packetData.set(chunk, offset);
+    offset += chunk.length;
+  }
+  const crc16 = calculateConfigCrc(packetData);
+  const result = new Uint8Array(totalDataSize + 2);
+  result.set(packetData, 0);
+  const crcView = new DataView(result.buffer, totalDataSize, 2);
+  crcView.setUint16(0, crc16, true);
+  return result;
+}
+
+// src/transport/notification-queue.ts
+var NotificationQueue = class {
+  queue = [];
+  pendingResolvers = [];
+  /**
+   * Add a notification to the queue.
+   *
+   * If there are pending consumers waiting, immediately resolve the oldest one.
+   * Otherwise, buffer the notification for future consumption.
+   *
+   * @param data - Notification data received from BLE characteristic
+   */
+  enqueue(data) {
+    if (this.pendingResolvers.length > 0) {
+      const pending = this.pendingResolvers.shift();
+      clearTimeout(pending.timeoutId);
+      pending.resolve(data);
+    } else {
+      this.queue.push(data);
+    }
+  }
+  /**
+   * Get the next notification from the queue.
+   *
+   * If a notification is already buffered, return it immediately.
+   * Otherwise, wait for the next notification or timeout.
+   *
+   * @param timeoutMs - Maximum time to wait in milliseconds
+   * @returns Promise that resolves with notification data
+   * @throws {BLETimeoutError} If timeout expires before notification arrives
+   */
+  async dequeue(timeoutMs) {
+    if (this.queue.length > 0) {
+      return this.queue.shift();
+    }
+    return new Promise((resolve, reject) => {
+      const timeoutId = window.setTimeout(() => {
+        const index = this.pendingResolvers.findIndex(
+          (p) => p.resolve === resolve
+        );
+        if (index !== -1) {
+          this.pendingResolvers.splice(index, 1);
+          reject(
+            new BLETimeoutError(
+              `No response received within ${timeoutMs}ms timeout`
+            )
+          );
+        }
+      }, timeoutMs);
+      this.pendingResolvers.push({ resolve, reject, timeoutId });
+    });
+  }
+  /**
+   * Clear the queue and reject all pending requests.
+   *
+   * Called when the connection is closed or reset.
+   *
+   * @param reason - Reason for clearing (default: "Connection closed")
+   */
+  clear(reason = "Connection closed") {
+    this.queue = [];
+    for (const pending of this.pendingResolvers) {
+      clearTimeout(pending.timeoutId);
+      pending.reject(new Error(reason));
+    }
+    this.pendingResolvers = [];
+  }
+  /**
+   * Get the number of buffered notifications.
+   */
+  get size() {
+    return this.queue.length;
+  }
+  /**
+   * Get the number of pending consumers waiting for notifications.
+   */
+  get pendingCount() {
+    return this.pendingResolvers.length;
+  }
+};
+
+// src/transport/connection.ts
+var BLEConnection = class {
+  device = null;
+  gattServer = null;
+  characteristic = null;
+  notificationQueue = new NotificationQueue();
+  disconnectHandler = null;
+  /**
+   * Check if currently connected to a device.
+   */
+  get isConnected() {
+    return this.gattServer?.connected ?? false;
+  }
+  /**
+   * Get the connected device name, if available.
+   */
+  get deviceName() {
+    return this.device?.name;
+  }
+  /**
+   * Connect to an OpenDisplay device.
+   *
+   * @param options - Connection options (device or namePrefix filter)
+   * @throws {BLEConnectionError} If connection fails
+   * @throws {Error} If Web Bluetooth is not supported
+   */
+  async connect(options = {}) {
+    if (!navigator.bluetooth) {
+      throw new Error(
+        "Web Bluetooth API not supported in this browser. Try Chrome, Edge, or Opera on desktop/Android."
+      );
+    }
+    try {
+      if (options.device) {
+        this.device = options.device;
+      } else {
+        const filters = [];
+        if (options.namePrefix) {
+          filters.push({
+            services: [SERVICE_UUID],
+            namePrefix: options.namePrefix
+          });
+        } else {
+          filters.push({
+            services: [SERVICE_UUID]
+          });
+        }
+        filters.push({
+          manufacturerData: [
+            {
+              companyIdentifier: MANUFACTURER_ID
+            }
+          ]
+        });
+        this.device = await navigator.bluetooth.requestDevice({
+          filters,
+          optionalServices: [SERVICE_UUID]
+        });
+      }
+      if (!this.device.gatt) {
+        throw new BLEConnectionError("Device does not support GATT");
+      }
+      this.gattServer = await this.device.gatt.connect();
+      const service = await this.gattServer.getPrimaryService(SERVICE_UUID);
+      const characteristics = await service.getCharacteristics();
+      if (characteristics.length === 0) {
+        throw new BLEConnectionError(
+          "No characteristics found in OpenDisplay service"
+        );
+      }
+      this.characteristic = characteristics[0];
+      await this.characteristic.startNotifications();
+      this.characteristic.addEventListener(
+        "characteristicvaluechanged",
+        this.handleNotification.bind(this)
+      );
+      this.disconnectHandler = this.handleDisconnect.bind(this);
+      this.device.addEventListener(
+        "gattserverdisconnected",
+        this.disconnectHandler
+      );
+      console.log(
+        `Connected to ${this.device.name || "OpenDisplay device"}`
+      );
+    } catch (error) {
+      this.cleanup();
+      if (error instanceof Error) {
+        throw new BLEConnectionError(
+          `Failed to connect: ${error.message}`
+        );
+      }
+      throw new BLEConnectionError("Failed to connect to device");
+    }
+  }
+  /**
+   * Disconnect from the device.
+   */
+  async disconnect() {
+    try {
+      if (this.characteristic) {
+        try {
+          await this.characteristic.stopNotifications();
+        } catch {
+        }
+      }
+      if (this.gattServer?.connected) {
+        this.gattServer.disconnect();
+      }
+    } finally {
+      this.cleanup();
+    }
+  }
+  /**
+   * Write a command to the device.
+   *
+   * @param data - Command data to send
+   * @throws {BLEConnectionError} If not connected or write fails
+   */
+  async writeCommand(data) {
+    if (!this.isConnected || !this.characteristic) {
+      throw new BLEConnectionError("Not connected to device");
+    }
+    try {
+      await this.characteristic.writeValueWithResponse(data);
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new BLEConnectionError(
+          `Failed to write command: ${error.message}`
+        );
+      }
+      throw new BLEConnectionError("Failed to write command");
+    }
+  }
+  /**
+   * Read the next response from the device.
+   *
+   * @param timeoutMs - Maximum time to wait for response
+   * @returns Promise that resolves with response data
+   * @throws {BLETimeoutError} If timeout expires
+   * @throws {BLEConnectionError} If not connected
+   */
+  async readResponse(timeoutMs) {
+    if (!this.isConnected) {
+      throw new BLEConnectionError("Not connected to device");
+    }
+    return this.notificationQueue.dequeue(timeoutMs);
+  }
+  /**
+   * Handle incoming BLE notifications.
+   *
+   * @param event - Characteristic value changed event
+   */
+  handleNotification(event) {
+    const characteristic = event.target;
+    if (!characteristic.value) {
+      return;
+    }
+    const data = new Uint8Array(characteristic.value.buffer);
+    this.notificationQueue.enqueue(data);
+  }
+  /**
+   * Handle device disconnection.
+   */
+  handleDisconnect() {
+    console.log("Device disconnected");
+    this.cleanup();
+  }
+  /**
+   * Clean up resources and reset state.
+   */
+  cleanup() {
+    this.notificationQueue.clear();
+    if (this.characteristic) {
+      this.characteristic.removeEventListener(
+        "characteristicvaluechanged",
+        this.handleNotification.bind(this)
+      );
+      this.characteristic = null;
+    }
+    if (this.device && this.disconnectHandler) {
+      this.device.removeEventListener(
+        "gattserverdisconnected",
+        this.disconnectHandler
+      );
+      this.disconnectHandler = null;
+    }
+    this.gattServer = null;
+    this.device = null;
+  }
+};
+
+// src/device.ts
+var OpenDisplayDevice = class _OpenDisplayDevice {
+  /**
+   * Initialize OpenDisplay device.
+   *
+   * @param options - Device initialization options
+   */
+  constructor(options = {}) {
+    this.options = options;
+    this._config = options.config ?? null;
+    this._capabilities = options.capabilities ?? null;
+  }
+  // BLE operation timeouts (milliseconds)
+  static TIMEOUT_FIRST_CHUNK = 1e4;
+  // First chunk may take longer
+  static TIMEOUT_CHUNK = 2e3;
+  // Subsequent chunks
+  static TIMEOUT_ACK = 5e3;
+  // Command acknowledgments
+  static TIMEOUT_REFRESH = 9e4;
+  // Display refresh (firmware spec: up to 60s)
+  connection = null;
+  _config = null;
+  _capabilities = null;
+  _fwVersion = null;
+  /**
+   * Get full device configuration (if interrogated).
+   */
+  get config() {
+    return this._config;
+  }
+  /**
+   * Get device capabilities (width, height, color scheme, rotation).
+   */
+  get capabilities() {
+    return this._capabilities;
+  }
+  /**
+   * Get display width in pixels.
+   */
+  get width() {
+    return this.ensureCapabilities().width;
+  }
+  /**
+   * Get display height in pixels.
+   */
+  get height() {
+    return this.ensureCapabilities().height;
+  }
+  /**
+   * Get display color scheme.
+   */
+  get colorScheme() {
+    return this.ensureCapabilities().colorScheme;
+  }
+  /**
+   * Get display rotation in degrees.
+   */
+  get rotation() {
+    return this.ensureCapabilities().rotation ?? 0;
+  }
+  /**
+   * Check if currently connected to a device.
+   */
+  get isConnected() {
+    return this.connection?.isConnected ?? false;
+  }
+  /**
+   * Connect to an OpenDisplay device and optionally interrogate.
+   *
+   * @param connectionOptions - Optional connection parameters
+   * @throws {BLEConnectionError} If connection fails
+   */
+  async connect(connectionOptions) {
+    this.connection = new BLEConnection();
+    const mergedOptions = {
+      ...connectionOptions,
+      device: this.options.device ?? connectionOptions?.device,
+      namePrefix: this.options.namePrefix ?? connectionOptions?.namePrefix
+    };
+    await this.connection.connect(mergedOptions);
+    if (!this._config && !this._capabilities) {
+      console.log("No config provided, auto-interrogating device");
+      await this.interrogate();
+    }
+    if (this._config && !this._capabilities) {
+      this._capabilities = this.extractCapabilitiesFromConfig();
+    }
+  }
+  /**
+   * Disconnect from the device.
+   */
+  async disconnect() {
+    if (this.connection) {
+      await this.connection.disconnect();
+      this.connection = null;
+    }
+  }
+  /**
+   * Read device configuration from device.
+   *
+   * @returns GlobalConfig with complete device configuration
+   * @throws {ProtocolError} If interrogation fails
+   */
+  async interrogate() {
+    this.ensureConnected();
+    console.log("Interrogating device");
+    const cmd = buildReadConfigCommand();
+    await this.connection.writeCommand(cmd);
+    const response = await this.connection.readResponse(
+      _OpenDisplayDevice.TIMEOUT_FIRST_CHUNK
+    );
+    const chunkData = stripCommandEcho(response, 64 /* READ_CONFIG */);
+    const view = new DataView(chunkData.buffer, chunkData.byteOffset);
+    const totalLength = view.getUint16(2, true);
+    const tlvData = [chunkData.subarray(4)];
+    let currentLength = chunkData.length - 4;
+    console.debug(`First chunk: ${chunkData.length} bytes, total length: ${totalLength}`);
+    while (currentLength < totalLength) {
+      const nextResponse = await this.connection.readResponse(
+        _OpenDisplayDevice.TIMEOUT_CHUNK
+      );
+      const nextChunkData = stripCommandEcho(nextResponse, 64 /* READ_CONFIG */);
+      tlvData.push(nextChunkData.subarray(2));
+      currentLength += nextChunkData.length - 2;
+      console.debug(`Received chunk, total: ${currentLength}/${totalLength} bytes`);
+    }
+    console.log(`Received complete TLV data: ${currentLength} bytes`);
+    const completeData = new Uint8Array(currentLength);
+    let offset = 0;
+    for (const chunk of tlvData) {
+      completeData.set(chunk, offset);
+      offset += chunk.length;
+    }
+    this._config = parseConfigResponse(completeData);
+    this._capabilities = this.extractCapabilitiesFromConfig();
+    console.log(
+      `Interrogated device: ${this.width}x${this.height}, ${ColorScheme4[this.colorScheme]}, rotation=${this.rotation}\xB0`
+    );
+    return this._config;
+  }
+  /**
+   * Read firmware version from device.
+   *
+   * @returns FirmwareVersion with major, minor, and sha fields
+   */
+  async readFirmwareVersion() {
+    this.ensureConnected();
+    console.log("Reading firmware version");
+    const cmd = buildReadFwVersionCommand();
+    await this.connection.writeCommand(cmd);
+    const response = await this.connection.readResponse(
+      _OpenDisplayDevice.TIMEOUT_ACK
+    );
+    this._fwVersion = parseFirmwareVersion(response);
+    console.log(
+      `Firmware version: ${this._fwVersion.major}.${this._fwVersion.minor} (SHA: ${this._fwVersion.sha.substring(0, 8)}...)`
+    );
+    return this._fwVersion;
+  }
+  /**
+   * Reboot the device.
+   *
+   * Sends a reboot command to the device, which will cause an immediate
+   * system reset. The device will NOT send an ACK response - it simply
+   * resets after a 100ms delay.
+   *
+   * Warning: The BLE connection will be forcibly terminated when the device
+   * resets. This is expected behavior. The device will restart and begin
+   * advertising again after the reset completes (typically within a few seconds).
+   *
+   * @throws {BLEConnectionError} If command cannot be sent
+   */
+  async reboot() {
+    this.ensureConnected();
+    console.log("Sending reboot command to device");
+    const cmd = buildRebootCommand();
+    await this.connection.writeCommand(cmd);
+    console.log("Reboot command sent - device will reset (connection will drop)");
+  }
+  /**
+   * Write configuration to device.
+   *
+   * Serializes the GlobalConfig to TLV binary format and writes it
+   * to the device using the WRITE_CONFIG (0x0041) command with
+   * automatic chunking for large configs.
+   *
+   * @param config - GlobalConfig to write to device
+   * @throws {Error} If config serialization fails or exceeds size limit
+   * @throws {BLEConnectionError} If write fails
+   * @throws {ProtocolError} If device returns error response
+   *
+   * @example
+   * ```typescript
+   * // Read current config
+   * const config = device.config;
+   *
+   * // Modify config
+   * config.displays[0].rotation = 180;
+   *
+   * // Write back to device
+   * await device.writeConfig(config);
+   *
+   * // Reboot to apply changes
+   * await device.reboot();
+   * ```
+   */
+  async writeConfig(config) {
+    this.ensureConnected();
+    console.log("Writing config to device");
+    if (!config.system) {
+      console.warn("Config missing system packet - device may not boot correctly");
+    }
+    if (!config.displays || config.displays.length === 0) {
+      throw new Error("Config must have at least one display");
+    }
+    const missingPackets = [];
+    if (!config.manufacturer) {
+      missingPackets.push("manufacturer");
+    }
+    if (!config.power) {
+      missingPackets.push("power");
+    }
+    if (missingPackets.length > 0) {
+      console.warn(
+        `Config missing optional packets: ${missingPackets.join(", ")}. Device may lose these settings.`
+      );
+    }
+    const configData = serializeConfig(config);
+    console.log(
+      `Serialized config: ${configData.length} bytes (chunking ${configData.length > 200 ? "required" : "not needed"})`
+    );
+    const [firstCmd, chunkCmds] = buildWriteConfigCommand(configData);
+    console.debug(`Sending first config chunk (${firstCmd.length} bytes)`);
+    await this.connection.writeCommand(firstCmd);
+    let response = await this.connection.readResponse(
+      _OpenDisplayDevice.TIMEOUT_ACK
+    );
+    validateAckResponse(response, 65 /* WRITE_CONFIG */);
+    for (let i = 0; i < chunkCmds.length; i++) {
+      const chunkCmd = chunkCmds[i];
+      console.debug(
+        `Sending config chunk ${i + 1}/${chunkCmds.length} (${chunkCmd.length} bytes)`
+      );
+      await this.connection.writeCommand(chunkCmd);
+      response = await this.connection.readResponse(
+        _OpenDisplayDevice.TIMEOUT_ACK
+      );
+      validateAckResponse(response, 66 /* WRITE_CONFIG_CHUNK */);
+    }
+    console.log("Config written successfully");
+  }
+  /**
+   * Upload image to device display.
+   *
+   * Automatically handles:
+   * - Image resizing to display dimensions
+   * - Dithering based on color scheme
+   * - Encoding to device format
+   * - Compression
+   * - Direct write protocol
+   *
+   * @param imageData - Image as ImageData (from canvas or OffscreenCanvas)
+   * @param options - Upload options
+   * @throws {Error} If device not interrogated/configured
+   * @throws {ProtocolError} If upload fails
+   *
+   * @example
+   * ```typescript
+   * const canvas = document.getElementById('myCanvas') as HTMLCanvasElement;
+   * const ctx = canvas.getContext('2d')!;
+   * const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+   *
+   * await device.uploadImage(imageData, {
+   *   refreshMode: RefreshMode.FULL,
+   *   ditherMode: DitherMode.BURKES,
+   *   compress: true
+   * });
+   * ```
+   */
+  async uploadImage(imageData, options = {}) {
+    this.ensureConnected();
+    this.ensureCapabilities();
+    const refreshMode = options.refreshMode ?? 0 /* FULL */;
+    const ditherMode = options.ditherMode ?? DitherMode2.BURKES;
+    const compress = options.compress ?? true;
+    console.log(
+      `Uploading image (${this.width}x${this.height}, ${ColorScheme4[this.colorScheme]})`
+    );
+    const encodedData = prepareImageForUpload(
+      imageData,
+      this.width,
+      this.height,
+      this.colorScheme,
+      ditherMode
+    );
+    let compressedData = null;
+    if (compress) {
+      compressedData = compressImageData(encodedData, 6);
+      if (compressedData.length < MAX_COMPRESSED_SIZE) {
+        console.log(`Using compressed upload protocol (size: ${compressedData.length} bytes)`);
+        await this.executeUpload({
+          imageData: encodedData,
+          refreshMode,
+          useCompression: true,
+          compressedData,
+          uncompressedSize: encodedData.length
+        });
+      } else {
+        console.log(
+          `Compressed size exceeds ${MAX_COMPRESSED_SIZE} bytes, using uncompressed protocol`
+        );
+        await this.executeUpload({ imageData: encodedData, refreshMode });
+      }
+    } else {
+      console.log("Compression disabled, using uncompressed protocol");
+      await this.executeUpload({ imageData: encodedData, refreshMode });
+    }
+    console.log("Image upload complete");
+  }
+  /**
+   * Execute image upload using compressed or uncompressed protocol.
+   */
+  async executeUpload(params) {
+    const {
+      imageData,
+      refreshMode,
+      useCompression = false,
+      compressedData,
+      uncompressedSize
+    } = params;
+    let startCmd;
+    let remainingCompressed = null;
+    if (useCompression && compressedData && uncompressedSize) {
+      [startCmd, remainingCompressed] = buildDirectWriteStartCompressed(
+        uncompressedSize,
+        compressedData
+      );
+    } else {
+      startCmd = buildDirectWriteStartUncompressed();
+    }
+    await this.connection.writeCommand(startCmd);
+    let response = await this.connection.readResponse(
+      _OpenDisplayDevice.TIMEOUT_ACK
+    );
+    validateAckResponse(response, 112 /* DIRECT_WRITE_START */);
+    let autoCompleted = false;
+    if (useCompression && remainingCompressed && remainingCompressed.length > 0) {
+      autoCompleted = await this.sendDataChunks(remainingCompressed);
+    } else if (!useCompression) {
+      autoCompleted = await this.sendDataChunks(imageData);
+    }
+    if (!autoCompleted) {
+      const endCmd = buildDirectWriteEndCommand(refreshMode);
+      await this.connection.writeCommand(endCmd);
+      response = await this.connection.readResponse(
+        _OpenDisplayDevice.TIMEOUT_REFRESH
+      );
+      validateAckResponse(response, 114 /* DIRECT_WRITE_END */);
+    }
+  }
+  /**
+   * Send image data chunks with ACK handling.
+   *
+   * Sends image data in chunks via 0x0071 DATA commands. Handles:
+   * - Timeout recovery when firmware starts display refresh
+   * - Auto-completion detection (firmware sends 0x0072 END early)
+   * - Progress logging
+   *
+   * @param imageData - Data to send in chunks
+   * @returns True if device auto-completed (sent 0x0072 END early), false if all chunks sent normally
+   * @throws {ProtocolError} If unexpected response received
+   * @throws {BLETimeoutError} If no response within timeout
+   */
+  async sendDataChunks(imageData) {
+    let bytesSent = 0;
+    let chunksSent = 0;
+    while (bytesSent < imageData.length) {
+      const chunkStart = bytesSent;
+      const chunkEnd = Math.min(chunkStart + CHUNK_SIZE, imageData.length);
+      const chunkData = imageData.subarray(chunkStart, chunkEnd);
+      const dataCmd = buildDirectWriteDataCommand(chunkData);
+      await this.connection.writeCommand(dataCmd);
+      bytesSent += chunkData.length;
+      chunksSent++;
+      let response;
+      try {
+        response = await this.connection.readResponse(
+          _OpenDisplayDevice.TIMEOUT_ACK
+        );
+      } catch (error) {
+        if (error instanceof BLETimeoutError) {
+          console.log(
+            `No response after chunk ${chunksSent} (${(bytesSent / imageData.length * 100).toFixed(1)}%), waiting for device refresh...`
+          );
+          response = await this.connection.readResponse(
+            _OpenDisplayDevice.TIMEOUT_REFRESH
+          );
+        } else {
+          throw error;
+        }
+      }
+      const [command, isAck] = checkResponseType(response);
+      if (command === 113 /* DIRECT_WRITE_DATA */) {
+      } else if (command === 114 /* DIRECT_WRITE_END */) {
+        console.log(
+          `Received END response after chunk ${chunksSent} - device auto-completed`
+        );
+        return true;
+      } else {
+        throw new ProtocolError(
+          `Unexpected response: ${CommandCode[command]} (0x${command.toString(16).padStart(4, "0")})`
+        );
+      }
+      if (chunksSent % 50 === 0 || bytesSent >= imageData.length) {
+        console.debug(
+          `Sent ${bytesSent}/${imageData.length} bytes (${(bytesSent / imageData.length * 100).toFixed(1)}%)`
+        );
+      }
+    }
+    console.debug(`All data chunks sent (${chunksSent} chunks total)`);
+    return false;
+  }
+  /**
+   * Extract DeviceCapabilities from GlobalConfig.
+   */
+  extractCapabilitiesFromConfig() {
+    if (!this._config) {
+      throw new Error("No config available");
+    }
+    if (!this._config.displays || this._config.displays.length === 0) {
+      throw new Error("Config has no display information");
+    }
+    const display = this._config.displays[0];
+    return {
+      width: display.pixelWidth,
+      height: display.pixelHeight,
+      colorScheme: display.colorScheme,
+      rotation: display.rotation
+    };
+  }
+  /**
+   * Ensure device capabilities are available.
+   */
+  ensureCapabilities() {
+    if (!this._capabilities) {
+      throw new Error(
+        "Device capabilities unknown - interrogate first or provide config/capabilities"
+      );
+    }
+    return this._capabilities;
+  }
+  /**
+   * Ensure device is connected.
+   */
+  ensureConnected() {
+    if (!this.connection || !this.isConnected) {
+      throw new BLEConnectionError("Not connected to device");
+    }
+  }
+};
+
+// src/discovery.ts
+async function discoverDevices(namePrefix) {
+  if (!navigator.bluetooth) {
+    throw new Error(
+      "Web Bluetooth API not supported in this browser. Try Chrome, Edge, or Opera on desktop/Android."
+    );
+  }
+  const filters = [];
+  if (namePrefix) {
+    filters.push({
+      services: [SERVICE_UUID],
+      namePrefix
+    });
+  } else {
+    filters.push({
+      services: [SERVICE_UUID]
+    });
+  }
+  filters.push({
+    manufacturerData: [
+      {
+        companyIdentifier: MANUFACTURER_ID
+      }
+    ]
+  });
+  try {
+    const device = await navigator.bluetooth.requestDevice({
+      filters,
+      optionalServices: [SERVICE_UUID]
+    });
+    console.log(`Selected device: ${device.name || "Unknown"}`);
+    return device;
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(`Device selection failed: ${error.message}`);
+    }
+    throw new Error("Device selection cancelled or failed");
+  }
+}
+
+// src/models/advertisement.ts
+function parseAdvertisement(data) {
+  if (data.length < 11) {
+    throw new Error(
+      `Advertisement data too short: ${data.length} bytes (need 11)`
+    );
+  }
+  const view = new DataView(data.buffer, data.byteOffset);
+  const batteryMv = view.getUint16(7, true);
+  const temperatureC = view.getInt8(9);
+  const loopCounter = data[10];
+  return {
+    batteryMv,
+    temperatureC,
+    loopCounter
+  };
+}
+
+// src/index.ts
+import { ColorScheme as ColorScheme5, DitherMode as DitherMode3 } from "@opendisplay/epaper-dithering";
+export {
+  BLEConnectionError,
+  BLETimeoutError,
+  BinaryInputs,
+  BusType,
+  ColorScheme5 as ColorScheme,
+  ConfigParseError,
+  DataBus,
+  DisplayConfig,
+  DitherMode3 as DitherMode,
+  ICType,
+  ImageEncodingError,
+  InvalidResponseError,
+  LedConfig,
+  ManufacturerData,
+  OpenDisplayDevice,
+  OpenDisplayError,
+  PowerMode,
+  PowerOption,
+  ProtocolError,
+  RefreshMode,
+  Rotation,
+  SensorData,
+  SystemConfig,
+  discoverDevices,
+  parseAdvertisement
+};
+//# sourceMappingURL=index.js.map