@elizaos/plugin-facewear 2.0.3-beta.5 → 2.0.3-beta.7

package/dist/protocol/smartglasses.js

@@ -0,0 +1,1485 @@
+const EVEN_G1_UART = {
+  service: "6e400001-b5a3-f393-e0a9-e50e24dcca9e",
+  tx: "6e400002-b5a3-f393-e0a9-e50e24dcca9e",
+  rx: "6e400003-b5a3-f393-e0a9-e50e24dcca9e"
+};
+var G1Command = /* @__PURE__ */ ((G1Command2) => {
+  G1Command2[G1Command2["StartAi"] = 245] = "StartAi";
+  G1Command2[G1Command2["OpenMic"] = 14] = "OpenMic";
+  G1Command2[G1Command2["ReceiveMicData"] = 241] = "ReceiveMicData";
+  G1Command2[G1Command2["Init"] = 77] = "Init";
+  G1Command2[G1Command2["RightInit"] = 244] = "RightInit";
+  G1Command2[G1Command2["Heartbeat"] = 37] = "Heartbeat";
+  G1Command2[G1Command2["Battery"] = 44] = "Battery";
+  G1Command2[G1Command2["SendResult"] = 78] = "SendResult";
+  G1Command2[G1Command2["QuickNote"] = 33] = "QuickNote";
+  G1Command2[G1Command2["Dashboard"] = 34] = "Dashboard";
+  G1Command2[G1Command2["Notification"] = 75] = "Notification";
+  G1Command2[G1Command2["DashboardContent"] = 6] = "DashboardContent";
+  G1Command2[G1Command2["Navigation"] = 10] = "Navigation";
+  G1Command2[G1Command2["TranslateSetup"] = 57] = "TranslateSetup";
+  G1Command2[G1Command2["TranslateStart"] = 80] = "TranslateStart";
+  G1Command2[G1Command2["TranslateLanguages"] = 28] = "TranslateLanguages";
+  G1Command2[G1Command2["TranslateOriginalText"] = 15] = "TranslateOriginalText";
+  G1Command2[G1Command2["TranslateTranslatedText"] = 13] = "TranslateTranslatedText";
+  G1Command2[G1Command2["AppWhitelist"] = 4] = "AppWhitelist";
+  G1Command2[G1Command2["ExitFunction"] = 24] = "ExitFunction";
+  G1Command2[G1Command2["SilentMode"] = 3] = "SilentMode";
+  G1Command2[G1Command2["Brightness"] = 1] = "Brightness";
+  G1Command2[G1Command2["DashboardPosition"] = 38] = "DashboardPosition";
+  G1Command2[G1Command2["HeadUpAngle"] = 11] = "HeadUpAngle";
+  G1Command2[G1Command2["GlassesWear"] = 39] = "GlassesWear";
+  G1Command2[G1Command2["BmpData"] = 21] = "BmpData";
+  G1Command2[G1Command2["BmpCrc"] = 22] = "BmpCrc";
+  G1Command2[G1Command2["BmpEnd"] = 32] = "BmpEnd";
+  G1Command2[G1Command2["Note"] = 30] = "Note";
+  G1Command2[G1Command2["GetSerial"] = 52] = "GetSerial";
+  return G1Command2;
+})(G1Command || {});
+var G1DashboardLayout = /* @__PURE__ */ ((G1DashboardLayout2) => {
+  G1DashboardLayout2["Full"] = "full";
+  G1DashboardLayout2["Dual"] = "dual";
+  G1DashboardLayout2["Minimal"] = "minimal";
+  return G1DashboardLayout2;
+})(G1DashboardLayout || {});
+var G1WeatherIcon = /* @__PURE__ */ ((G1WeatherIcon2) => {
+  G1WeatherIcon2[G1WeatherIcon2["Nothing"] = 0] = "Nothing";
+  G1WeatherIcon2[G1WeatherIcon2["Night"] = 1] = "Night";
+  G1WeatherIcon2[G1WeatherIcon2["Clouds"] = 2] = "Clouds";
+  G1WeatherIcon2[G1WeatherIcon2["Drizzle"] = 3] = "Drizzle";
+  G1WeatherIcon2[G1WeatherIcon2["HeavyDrizzle"] = 4] = "HeavyDrizzle";
+  G1WeatherIcon2[G1WeatherIcon2["Rain"] = 5] = "Rain";
+  G1WeatherIcon2[G1WeatherIcon2["HeavyRain"] = 6] = "HeavyRain";
+  G1WeatherIcon2[G1WeatherIcon2["Thunder"] = 7] = "Thunder";
+  G1WeatherIcon2[G1WeatherIcon2["Thunderstorm"] = 8] = "Thunderstorm";
+  G1WeatherIcon2[G1WeatherIcon2["Snow"] = 9] = "Snow";
+  G1WeatherIcon2[G1WeatherIcon2["Mist"] = 10] = "Mist";
+  G1WeatherIcon2[G1WeatherIcon2["Fog"] = 11] = "Fog";
+  G1WeatherIcon2[G1WeatherIcon2["Sand"] = 12] = "Sand";
+  G1WeatherIcon2[G1WeatherIcon2["Squalls"] = 13] = "Squalls";
+  G1WeatherIcon2[G1WeatherIcon2["Tornado"] = 14] = "Tornado";
+  G1WeatherIcon2[G1WeatherIcon2["FreezingRain"] = 15] = "FreezingRain";
+  G1WeatherIcon2[G1WeatherIcon2["Sunny"] = 16] = "Sunny";
+  return G1WeatherIcon2;
+})(G1WeatherIcon || {});
+var G1TemperatureUnit = /* @__PURE__ */ ((G1TemperatureUnit2) => {
+  G1TemperatureUnit2["Celsius"] = "celsius";
+  G1TemperatureUnit2["Fahrenheit"] = "fahrenheit";
+  return G1TemperatureUnit2;
+})(G1TemperatureUnit || {});
+var G1TimeFormat = /* @__PURE__ */ ((G1TimeFormat2) => {
+  G1TimeFormat2["TwentyFourHour"] = "24h";
+  G1TimeFormat2["TwelveHour"] = "12h";
+  return G1TimeFormat2;
+})(G1TimeFormat || {});
+var G1NavigationTurn = /* @__PURE__ */ ((G1NavigationTurn2) => {
+  G1NavigationTurn2[G1NavigationTurn2["StraightDot"] = 1] = "StraightDot";
+  G1NavigationTurn2[G1NavigationTurn2["Straight"] = 2] = "Straight";
+  G1NavigationTurn2[G1NavigationTurn2["Right"] = 3] = "Right";
+  G1NavigationTurn2[G1NavigationTurn2["Left"] = 4] = "Left";
+  G1NavigationTurn2[G1NavigationTurn2["SlightRight"] = 5] = "SlightRight";
+  G1NavigationTurn2[G1NavigationTurn2["SlightLeft"] = 6] = "SlightLeft";
+  G1NavigationTurn2[G1NavigationTurn2["StrongRight"] = 7] = "StrongRight";
+  G1NavigationTurn2[G1NavigationTurn2["StrongLeft"] = 8] = "StrongLeft";
+  G1NavigationTurn2[G1NavigationTurn2["UTurnLeft"] = 9] = "UTurnLeft";
+  G1NavigationTurn2[G1NavigationTurn2["UTurnRight"] = 10] = "UTurnRight";
+  G1NavigationTurn2[G1NavigationTurn2["Merge"] = 11] = "Merge";
+  G1NavigationTurn2[G1NavigationTurn2["SlightRightAtFork"] = 34] = "SlightRightAtFork";
+  G1NavigationTurn2[G1NavigationTurn2["SlightLeftAtFork"] = 35] = "SlightLeftAtFork";
+  return G1NavigationTurn2;
+})(G1NavigationTurn || {});
+var G1TranslateLanguage = /* @__PURE__ */ ((G1TranslateLanguage2) => {
+  G1TranslateLanguage2[G1TranslateLanguage2["Chinese"] = 1] = "Chinese";
+  G1TranslateLanguage2[G1TranslateLanguage2["English"] = 2] = "English";
+  G1TranslateLanguage2[G1TranslateLanguage2["French"] = 5] = "French";
+  G1TranslateLanguage2[G1TranslateLanguage2["Dutch"] = 9] = "Dutch";
+  return G1TranslateLanguage2;
+})(G1TranslateLanguage || {});
+var G1SubCommand = /* @__PURE__ */ ((G1SubCommand2) => {
+  G1SubCommand2[G1SubCommand2["Exit"] = 0] = "Exit";
+  G1SubCommand2[G1SubCommand2["PageControl"] = 1] = "PageControl";
+  G1SubCommand2[G1SubCommand2["Start"] = 23] = "Start";
+  G1SubCommand2[G1SubCommand2["Stop"] = 24] = "Stop";
+  return G1SubCommand2;
+})(G1SubCommand || {});
+var G1MicStatus = /* @__PURE__ */ ((G1MicStatus2) => {
+  G1MicStatus2[G1MicStatus2["Disable"] = 0] = "Disable";
+  G1MicStatus2[G1MicStatus2["Enable"] = 1] = "Enable";
+  return G1MicStatus2;
+})(G1MicStatus || {});
+var G1ResponseStatus = /* @__PURE__ */ ((G1ResponseStatus2) => {
+  G1ResponseStatus2[G1ResponseStatus2["Success"] = 201] = "Success";
+  G1ResponseStatus2[G1ResponseStatus2["Failure"] = 202] = "Failure";
+  return G1ResponseStatus2;
+})(G1ResponseStatus || {});
+var G1ScreenAction = /* @__PURE__ */ ((G1ScreenAction2) => {
+  G1ScreenAction2[G1ScreenAction2["NewContent"] = 1] = "NewContent";
+  return G1ScreenAction2;
+})(G1ScreenAction || {});
+var G1AiStatus = /* @__PURE__ */ ((G1AiStatus2) => {
+  G1AiStatus2[G1AiStatus2["Displaying"] = 48] = "Displaying";
+  G1AiStatus2[G1AiStatus2["DisplayComplete"] = 64] = "DisplayComplete";
+  G1AiStatus2[G1AiStatus2["ManualMode"] = 80] = "ManualMode";
+  G1AiStatus2[G1AiStatus2["NetworkError"] = 96] = "NetworkError";
+  return G1AiStatus2;
+})(G1AiStatus || {});
+var G1TextStatus = /* @__PURE__ */ ((G1TextStatus2) => {
+  G1TextStatus2[G1TextStatus2["TextShow"] = 112] = "TextShow";
+  return G1TextStatus2;
+})(G1TextStatus || {});
+var G1SilentModeStatus = /* @__PURE__ */ ((G1SilentModeStatus2) => {
+  G1SilentModeStatus2[G1SilentModeStatus2["Off"] = 10] = "Off";
+  G1SilentModeStatus2[G1SilentModeStatus2["On"] = 12] = "On";
+  return G1SilentModeStatus2;
+})(G1SilentModeStatus || {});
+var G1DashboardState = /* @__PURE__ */ ((G1DashboardState2) => {
+  G1DashboardState2[G1DashboardState2["Off"] = 0] = "Off";
+  G1DashboardState2[G1DashboardState2["On"] = 1] = "On";
+  return G1DashboardState2;
+})(G1DashboardState || {});
+var G1GlassesWearStatus = /* @__PURE__ */ ((G1GlassesWearStatus2) => {
+  G1GlassesWearStatus2[G1GlassesWearStatus2["Off"] = 0] = "Off";
+  G1GlassesWearStatus2[G1GlassesWearStatus2["On"] = 1] = "On";
+  return G1GlassesWearStatus2;
+})(G1GlassesWearStatus || {});
+var G1VoiceNoteSubCommand = /* @__PURE__ */ ((G1VoiceNoteSubCommand2) => {
+  G1VoiceNoteSubCommand2[G1VoiceNoteSubCommand2["RequestAudioInfo"] = 1] = "RequestAudioInfo";
+  G1VoiceNoteSubCommand2[G1VoiceNoteSubCommand2["RequestAudioData"] = 2] = "RequestAudioData";
+  G1VoiceNoteSubCommand2[G1VoiceNoteSubCommand2["DeleteAudioStream"] = 4] = "DeleteAudioStream";
+  G1VoiceNoteSubCommand2[G1VoiceNoteSubCommand2["DeleteAll"] = 5] = "DeleteAll";
+  return G1VoiceNoteSubCommand2;
+})(G1VoiceNoteSubCommand || {});
+var G1InteractionCode = /* @__PURE__ */ ((G1InteractionCode2) => {
+  G1InteractionCode2[G1InteractionCode2["DoubleTap"] = 0] = "DoubleTap";
+  G1InteractionCode2[G1InteractionCode2["SingleTap"] = 1] = "SingleTap";
+  G1InteractionCode2[G1InteractionCode2["LongPress"] = 23] = "LongPress";
+  G1InteractionCode2[G1InteractionCode2["StopAiRecording"] = 24] = "StopAiRecording";
+  G1InteractionCode2[G1InteractionCode2["SilentModeOn"] = 4] = "SilentModeOn";
+  G1InteractionCode2[G1InteractionCode2["SilentModeOff"] = 5] = "SilentModeOff";
+  G1InteractionCode2[G1InteractionCode2["OpenDashboardStart"] = 2] = "OpenDashboardStart";
+  G1InteractionCode2[G1InteractionCode2["CloseDashboardStart"] = 3] = "CloseDashboardStart";
+  G1InteractionCode2[G1InteractionCode2["OpenDashboardConfirm"] = 30] = "OpenDashboardConfirm";
+  G1InteractionCode2[G1InteractionCode2["CloseDashboardConfirm"] = 31] = "CloseDashboardConfirm";
+  return G1InteractionCode2;
+})(G1InteractionCode || {});
+function microphoneActionForInteractionEvent(event) {
+  if (event.type !== "state") return null;
+  if (event.label === "single_tap" || event.label === "long_press") {
+    return "enable";
+  }
+  if (event.label === "double_tap" || event.label === "stop_ai_recording") {
+    return "disable";
+  }
+  return null;
+}
+const G1_DISPLAY = {
+  displayWidthPx: 576,
+  charsPerLine: 40,
+  linesPerPage: 5,
+  maxTextLength: 40 * 5,
+  maxPayloadBytes: 191
+};
+const G1_GLYPH_WIDTHS = new Map(
+  Object.entries({
+    " ": 2,
+    "!": 1,
+    '"': 2,
+    "#": 6,
+    $: 5,
+    "%": 6,
+    "&": 7,
+    "'": 1,
+    "(": 2,
+    ")": 2,
+    "*": 3,
+    "+": 4,
+    ",": 1,
+    "-": 4,
+    ".": 1,
+    "/": 3,
+    "0": 5,
+    "1": 3,
+    "2": 5,
+    "3": 5,
+    "4": 5,
+    "5": 5,
+    "6": 5,
+    "7": 5,
+    "8": 5,
+    "9": 5,
+    ":": 1,
+    ";": 1,
+    "<": 4,
+    "=": 4,
+    ">": 4,
+    "?": 5,
+    "@": 7,
+    A: 6,
+    B: 5,
+    C: 5,
+    D: 5,
+    E: 4,
+    F: 4,
+    G: 5,
+    H: 5,
+    I: 2,
+    J: 3,
+    K: 5,
+    L: 4,
+    M: 7,
+    N: 5,
+    O: 5,
+    P: 5,
+    Q: 5,
+    R: 5,
+    S: 5,
+    T: 5,
+    U: 5,
+    V: 6,
+    W: 7,
+    X: 6,
+    Y: 6,
+    Z: 5,
+    "[": 2,
+    "\\": 3,
+    "]": 2,
+    "^": 4,
+    _: 3,
+    "`": 2,
+    a: 5,
+    b: 4,
+    c: 4,
+    d: 4,
+    e: 4,
+    f: 4,
+    g: 4,
+    h: 4,
+    i: 1,
+    j: 2,
+    k: 4,
+    l: 1,
+    m: 7,
+    n: 4,
+    o: 4,
+    p: 4,
+    q: 4,
+    r: 3,
+    s: 4,
+    t: 3,
+    u: 5,
+    v: 5,
+    w: 7,
+    x: 5,
+    y: 5,
+    z: 4,
+    "{": 3,
+    "|": 1,
+    "}": 3,
+    "~": 7
+  })
+);
+const G1_BMP = {
+  width: 576,
+  height: 136,
+  bitsPerPixel: 1
+};
+const INTERACTION_LABELS = /* @__PURE__ */ new Map([
+  [0 /* DoubleTap */, "double_tap"],
+  [1 /* SingleTap */, "single_tap"],
+  [23 /* LongPress */, "long_press"],
+  [24 /* StopAiRecording */, "stop_ai_recording"],
+  [4 /* SilentModeOn */, "silent_mode_on"],
+  [5 /* SilentModeOff */, "silent_mode_off"],
+  [2 /* OpenDashboardStart */, "open_dashboard_start"],
+  [3 /* CloseDashboardStart */, "close_dashboard_start"],
+  [30 /* OpenDashboardConfirm */, "open_dashboard_confirm"],
+  [31 /* CloseDashboardConfirm */, "close_dashboard_confirm"]
+]);
+const PHYSICAL_LABELS = /* @__PURE__ */ new Map([
+  [6, "wearing"],
+  [7, "transitioning"],
+  [8, "cradle_open"],
+  [9, "charged_in_cradle"],
+  [11, "cradle_closed"]
+]);
+const BATTERY_LABELS = /* @__PURE__ */ new Map([
+  [9, "glasses_fully_charged"],
+  [14, "cradle_charging_cable_changed"],
+  [15, "cradle_fully_charged"]
+]);
+const DEVICE_LABELS = /* @__PURE__ */ new Map([
+  [10, "device_unknown_0a"],
+  [17, "connected"],
+  [18, "device_unknown_12"],
+  [20, "device_unknown_14"],
+  [21, "device_unknown_15"]
+]);
+function classifyStateCode(code) {
+  if (code === void 0) return null;
+  const interaction = INTERACTION_LABELS.get(code);
+  if (interaction)
+    return { category: "interaction", label: interaction, name: interaction };
+  const physical = PHYSICAL_LABELS.get(code);
+  if (physical)
+    return { category: "physical", label: physical, name: physical };
+  const battery = BATTERY_LABELS.get(code);
+  if (battery) return { category: "battery", label: battery, name: battery };
+  const device = DEVICE_LABELS.get(code);
+  if (device) return { category: "device", label: device, name: device };
+  return null;
+}
+function measureG1DisplayText(text) {
+  let width = 0;
+  for (const char of text) width += measureG1DisplayChar(char);
+  return width;
+}
+function measureG1DisplayChar(char) {
+  const codePoint = char.codePointAt(0) ?? 0;
+  if (isKorean(codePoint)) return 24;
+  if (isCjk(codePoint) || isHiragana(codePoint) || isKatakana(codePoint))
+    return 18;
+  if (isCyrillic(codePoint)) return 18;
+  const glyphWidth = G1_GLYPH_WIDTHS.get(char);
+  return glyphWidth === void 0 ? 16 : (glyphWidth + 1) * 2;
+}
+function isCjk(codePoint) {
+  return codePoint >= 13312 && codePoint <= 19903 || codePoint >= 19968 && codePoint <= 40959 || codePoint >= 63744 && codePoint <= 64255;
+}
+function isHiragana(codePoint) {
+  return codePoint >= 12352 && codePoint <= 12447;
+}
+function isKatakana(codePoint) {
+  return codePoint >= 12448 && codePoint <= 12543;
+}
+function isKorean(codePoint) {
+  return codePoint >= 44032 && codePoint <= 55215;
+}
+function isCyrillic(codePoint) {
+  return codePoint >= 1024 && codePoint <= 1279;
+}
+function fitsG1DisplayLine(text, maxWidthPx) {
+  return measureG1DisplayText(text) <= maxWidthPx;
+}
+function formatDisplayLines(text, options = {}) {
+  const charsPerLine = typeof options === "number" ? options : options.charsPerLine;
+  const maxWidthPx = typeof options === "number" ? void 0 : options.maxWidthPx ?? G1_DISPLAY.displayWidthPx;
+  if (charsPerLine !== void 0)
+    return formatDisplayLinesByCharacters(text, charsPerLine);
+  return formatDisplayLinesByPixels(
+    text,
+    maxWidthPx ?? G1_DISPLAY.displayWidthPx
+  );
+}
+function formatDisplayLinesByCharacters(text, charsPerLine) {
+  const lines = [];
+  for (const paragraph of text.split(/\r?\n/).map((p) => p.trim()).filter(Boolean)) {
+    let rest = paragraph;
+    while (rest.length > charsPerLine) {
+      let splitAt = rest.lastIndexOf(" ", charsPerLine);
+      if (splitAt < 1) splitAt = charsPerLine;
+      lines.push(rest.slice(0, splitAt).trimEnd());
+      rest = rest.slice(splitAt).trimStart();
+    }
+    if (rest) lines.push(rest);
+  }
+  return lines.length ? lines : [""];
+}
+function formatDisplayLinesByPixels(text, maxWidthPx) {
+  const lines = [];
+  for (const paragraph of text.split(/\r?\n/)) {
+    const trimmed = paragraph.trim();
+    if (!trimmed) {
+      if (lines.length > 0) lines.push("");
+      continue;
+    }
+    lines.push(...wrapDisplayParagraphByPixels(trimmed, maxWidthPx));
+  }
+  return lines.length ? lines : [""];
+}
+function wrapDisplayParagraphByPixels(paragraph, maxWidthPx) {
+  if (fitsG1DisplayLine(paragraph, maxWidthPx)) return [paragraph];
+  const lines = [];
+  let current = "";
+  for (const word of paragraph.split(/\s+/).filter(Boolean)) {
+    const candidate = current ? `${current} ${word}` : word;
+    if (fitsG1DisplayLine(candidate, maxWidthPx)) {
+      current = candidate;
+      continue;
+    }
+    if (current) {
+      lines.push(current);
+      current = "";
+    }
+    const wordLines = breakDisplayTokenByPixels(word, maxWidthPx);
+    lines.push(...wordLines.slice(0, -1));
+    current = wordLines.at(-1) ?? "";
+  }
+  if (current) lines.push(current);
+  return lines;
+}
+function breakDisplayTokenByPixels(token, maxWidthPx) {
+  const lines = [];
+  let current = "";
+  for (const char of Array.from(token)) {
+    const candidate = current + char;
+    if (fitsG1DisplayLine(candidate, maxWidthPx)) {
+      current = candidate;
+      continue;
+    }
+    if (current) lines.push(current);
+    current = char;
+  }
+  if (current) lines.push(current);
+  return lines.length ? lines : [""];
+}
+function paginateDisplayText(text, options = {}) {
+  const charsPerLine = options.charsPerLine ?? G1_DISPLAY.charsPerLine;
+  const linesPerPage = options.linesPerPage ?? G1_DISPLAY.linesPerPage;
+  const lines = formatDisplayLines(
+    text,
+    options.charsPerLine === void 0 ? { maxWidthPx: G1_DISPLAY.displayWidthPx } : { charsPerLine }
+  );
+  const maxPages = Math.max(1, Math.ceil(lines.length / linesPerPage));
+  const pages = [];
+  for (let pageIndex = 0; pageIndex < maxPages; pageIndex++) {
+    const pageLines = lines.slice(
+      pageIndex * linesPerPage,
+      (pageIndex + 1) * linesPerPage
+    );
+    const missing = linesPerPage - pageLines.length;
+    if (missing > 0) {
+      const before = Math.floor(missing / 2);
+      const after = missing - before;
+      pageLines.unshift(...Array.from({ length: before }, () => ""));
+      pageLines.push(...Array.from({ length: after }, () => ""));
+    }
+    pages.push({
+      pageNumber: pageIndex + 1,
+      maxPages,
+      text: pageLines.join("\n"),
+      screenStatus: pageIndex === maxPages - 1 ? 64 /* DisplayComplete */ : 48 /* Displaying */ | 1 /* NewContent */
+    });
+  }
+  return pages;
+}
+function encodeTextPacket(page, seq = 0) {
+  const data = new TextEncoder().encode(page.text);
+  if (data.byteLength > G1_DISPLAY.maxPayloadBytes) {
+    throw new RangeError(
+      `G1 display payload is ${data.byteLength} bytes; use encodeTextPackets for payloads over ${G1_DISPLAY.maxPayloadBytes} bytes`
+    );
+  }
+  return encodeTextPacketChunk(page, data, seq, 1, 0);
+}
+function encodeTextPackets(page, seq = 0) {
+  const chunks = splitUtf8Chunks(page.text, G1_DISPLAY.maxPayloadBytes);
+  const totalPackages = chunks.length;
+  const packets = [];
+  let charPosition = 0;
+  for (const [currentPackage, chunk] of chunks.entries()) {
+    packets.push(
+      encodeTextPacketChunk(
+        page,
+        chunk,
+        seq,
+        totalPackages,
+        currentPackage,
+        charPosition
+      )
+    );
+    charPosition += chunk.length;
+  }
+  return packets;
+}
+function splitUtf8Chunks(text, maxBytes) {
+  const encoder = new TextEncoder();
+  if (text.length === 0) return [new Uint8Array()];
+  const chunks = [];
+  let current = "";
+  for (const char of text) {
+    const next = current + char;
+    const nextBytes = encoder.encode(next);
+    if (nextBytes.byteLength > maxBytes && current) {
+      chunks.push(encoder.encode(current));
+      current = char;
+      continue;
+    }
+    if (nextBytes.byteLength > maxBytes) {
+      throw new RangeError(
+        `Single UTF-8 character exceeds G1 display packet payload limit of ${maxBytes} bytes`
+      );
+    }
+    current = next;
+  }
+  if (current || chunks.length === 0) chunks.push(encoder.encode(current));
+  return chunks;
+}
+function encodeTextPacketChunk(page, data, seq, totalPackages, currentPackage, charPosition = 0) {
+  const packet = new Uint8Array(9 + data.length);
+  packet.set([
+    78 /* SendResult */,
+    seq & 255,
+    totalPackages & 255,
+    currentPackage & 255,
+    page.screenStatus & 255,
+    charPosition >>> 8 & 255,
+    charPosition & 255,
+    page.pageNumber & 255,
+    page.maxPages & 255
+  ]);
+  packet.set(data, 9);
+  return packet;
+}
+function encodeMicCommand(enabled) {
+  return Uint8Array.from([
+    14 /* OpenMic */,
+    enabled ? 1 /* Enable */ : 0 /* Disable */
+  ]);
+}
+function encodeHeartbeat(seq) {
+  const s = seq & 255;
+  return Uint8Array.from([37 /* Heartbeat */, 6, 0, s, 4, s]);
+}
+function encodeBatteryStatusRequest() {
+  return Uint8Array.from([44 /* Battery */, 1]);
+}
+function encodeConnectionReady(side, mode = "lens-specific") {
+  return Uint8Array.from([
+    mode === "android-f4" ? 244 /* RightInit */ : mode === "official" || side === "left" ? 77 /* Init */ : 244 /* RightInit */,
+    1
+  ]);
+}
+function encodeStartAi(subcommand, param = new Uint8Array()) {
+  const packet = new Uint8Array(2 + param.length);
+  packet.set([245 /* StartAi */, subcommand]);
+  packet.set(param, 2);
+  return packet;
+}
+function encodeExitFunction() {
+  return Uint8Array.from([24 /* ExitFunction */]);
+}
+function encodeGetSerial() {
+  return Uint8Array.from([52 /* GetSerial */]);
+}
+function encodeClearScreen() {
+  return Uint8Array.from([
+    245 /* StartAi */,
+    24 /* Stop */,
+    0,
+    0,
+    0
+  ]);
+}
+function encodeSilentMode(enabled) {
+  return Uint8Array.from([
+    3 /* SilentMode */,
+    enabled ? 12 /* On */ : 10 /* Off */,
+    0
+  ]);
+}
+function encodeBrightness(level, auto = false) {
+  if (!Number.isInteger(level) || level < 0 || level > 41) {
+    throw new RangeError(
+      "Brightness level must be an integer between 0 and 0x29"
+    );
+  }
+  return Uint8Array.from([
+    1 /* Brightness */,
+    level & 255,
+    auto ? 1 : 0
+  ]);
+}
+function encodeDashboard(state, position = 0) {
+  if (!Number.isInteger(position) || position < 0 || position > 8) {
+    throw new RangeError(
+      "Dashboard position must be an integer between 0 and 8"
+    );
+  }
+  const stateValue = typeof state === "boolean" ? state ? 1 /* On */ : 0 /* Off */ : state;
+  return Uint8Array.from([
+    38 /* DashboardPosition */,
+    7,
+    0,
+    1,
+    2,
+    stateValue,
+    position & 255
+  ]);
+}
+function encodeDashboardPosition(height, depth, seqId = 1) {
+  if (!Number.isInteger(height) || height < 0 || height > 8) {
+    throw new RangeError("Dashboard height must be an integer between 0 and 8");
+  }
+  if (!Number.isInteger(depth) || depth < 1 || depth > 9) {
+    throw new RangeError("Dashboard depth must be an integer between 1 and 9");
+  }
+  return Uint8Array.from([
+    38 /* DashboardPosition */,
+    8,
+    0,
+    seqId & 255,
+    2,
+    1,
+    height & 255,
+    depth & 255
+  ]);
+}
+function encodeDashboardLayout(layout) {
+  const layoutBytes = layout === "full" /* Full */ ? [8, 6, 0, 0] : layout === "dual" /* Dual */ ? [30, 6, 1, 0] : [49, 6, 2, 0];
+  return Uint8Array.from([
+    6 /* DashboardContent */,
+    7,
+    0,
+    ...layoutBytes
+  ]);
+}
+function encodeDashboardCalendarItem(payload) {
+  const name = new TextEncoder().encode(payload.name);
+  const time = new TextEncoder().encode(payload.time);
+  const location = new TextEncoder().encode(payload.location);
+  for (const [field, bytes] of [
+    ["name", name],
+    ["time", time],
+    ["location", location]
+  ]) {
+    if (bytes.length > 255)
+      throw new RangeError(
+        `Dashboard calendar ${field} must be at most 255 bytes`
+      );
+  }
+  const prefix = [
+    0,
+    109,
+    3,
+    1,
+    0,
+    1,
+    0,
+    0,
+    0,
+    3,
+    1
+  ];
+  const body = new Uint8Array(
+    prefix.length + 6 + name.length + time.length + location.length
+  );
+  let offset = 0;
+  body.set(prefix, offset);
+  offset += prefix.length;
+  body.set([1, name.length], offset);
+  offset += 2;
+  body.set(name, offset);
+  offset += name.length;
+  body.set([2, time.length], offset);
+  offset += 2;
+  body.set(time, offset);
+  offset += time.length;
+  body.set([3, location.length], offset);
+  offset += 2;
+  body.set(location, offset);
+  return Uint8Array.from([
+    6 /* DashboardContent */,
+    body.length + 2 & 255,
+    ...body
+  ]);
+}
+function encodeDashboardTimeWeather(payload) {
+  if (!Number.isInteger(payload.temperatureInCelsius) || payload.temperatureInCelsius < -128 || payload.temperatureInCelsius > 127) {
+    throw new RangeError("Dashboard temperature must fit in signed 8 bits");
+  }
+  const seqId = payload.seqId ?? 0;
+  const timestampMs = payload.timestampMs ?? Date.now();
+  const timezoneOffsetSeconds = payload.timezoneOffsetSeconds ?? -new Date(timestampMs).getTimezoneOffset() * 60;
+  const localMs = timestampMs + timezoneOffsetSeconds * 1e3;
+  const out = new Uint8Array(21);
+  const view = new DataView(out.buffer);
+  out.set([6 /* DashboardContent */, 21, 0, seqId & 255, 1]);
+  view.setUint32(5, Math.floor(localMs / 1e3), true);
+  view.setBigUint64(9, BigInt(Math.trunc(localMs)), true);
+  out[17] = (payload.weatherIcon ?? 0 /* Nothing */) & 255;
+  out[18] = payload.temperatureInCelsius & 255;
+  out[19] = payload.temperatureUnit === "fahrenheit" /* Fahrenheit */ ? 1 : 0;
+  out[20] = payload.timeFormat === "12h" /* TwelveHour */ ? 1 : 0;
+  return out;
+}
+function encodeHeadUpAngle(angle) {
+  if (!Number.isInteger(angle) || angle < 0 || angle > 60) {
+    throw new RangeError(
+      "Head-up display angle must be an integer between 0 and 60"
+    );
+  }
+  return Uint8Array.from([11 /* HeadUpAngle */, angle & 255, 1]);
+}
+function encodeG1Setup(payload) {
+  const text = typeof payload === "string" ? payload : JSON.stringify(payload);
+  const data = new TextEncoder().encode(text);
+  const maxPayload = 176;
+  const totalPackets = Math.max(1, Math.ceil(data.byteLength / maxPayload));
+  const packets = [];
+  for (let index = 0; index < totalPackets; index++) {
+    const chunk = data.slice(index * maxPayload, (index + 1) * maxPayload);
+    const packet = new Uint8Array(3 + chunk.length);
+    packet.set([4 /* AppWhitelist */, totalPackets & 255, index & 255]);
+    packet.set(chunk, 3);
+    packets.push(packet);
+  }
+  return packets;
+}
+function encodeNavigationInit(seqId) {
+  return Uint8Array.from([
+    10 /* Navigation */,
+    6,
+    0,
+    seqId & 255,
+    0,
+    1
+  ]);
+}
+function encodeNavigationDirections(payload) {
+  const encoder = new TextEncoder();
+  const totalDuration = encoder.encode(payload.totalDuration);
+  const totalDistance = encoder.encode(payload.totalDistance);
+  const direction = encoder.encode(payload.direction);
+  const distance = encoder.encode(payload.distance);
+  const speed = encoder.encode(payload.speed);
+  const customX = payload.customX ?? [0, 0];
+  const body = new Uint8Array(
+    8 + totalDuration.length + totalDistance.length + direction.length + distance.length + speed.length + 5
+  );
+  let offset = 0;
+  body.set(
+    [
+      0,
+      payload.seqId & 255,
+      1,
+      payload.directionTurn & 255,
+      customX[0] ?? 0,
+      customX[1] ?? 0,
+      payload.customY ?? 0,
+      0
+    ],
+    offset
+  );
+  offset += 8;
+  for (const bytes of [
+    totalDuration,
+    totalDistance,
+    direction,
+    distance,
+    speed
+  ]) {
+    body.set(bytes, offset);
+    offset += bytes.length;
+    body[offset++] = 0;
+  }
+  return Uint8Array.from([
+    10 /* Navigation */,
+    body.length + 2 & 255,
+    ...body
+  ]);
+}
+function encodeNavigationPrimaryImage(image, overlay, seqId = 0) {
+  validateBitPlanes(image, overlay, 136 * 136, "primary navigation image");
+  return encodeNavigationImagePackets(
+    runLengthEncodeBits([...Array.from(image), ...Array.from(overlay)]),
+    2,
+    seqId,
+    false
+  );
+}
+function encodeNavigationSecondaryImage(image, overlay, seqId = 0) {
+  validateBitPlanes(image, overlay, 488 * 136, "secondary navigation image");
+  return encodeNavigationImagePackets(
+    [...Array.from(image), ...Array.from(overlay)],
+    3,
+    seqId,
+    true
+  );
+}
+function encodeNavigationPoller(seqId, pollerSeqId) {
+  return Uint8Array.from([
+    10 /* Navigation */,
+    6,
+    0,
+    seqId & 255,
+    4,
+    pollerSeqId & 255
+  ]);
+}
+function encodeNavigationEnd(seqId) {
+  return Uint8Array.from([
+    10 /* Navigation */,
+    6,
+    0,
+    seqId & 255,
+    5,
+    1
+  ]);
+}
+function encodeTranslateSetup() {
+  return Uint8Array.from([57 /* TranslateSetup */, 5, 0, 0, 19]);
+}
+function encodeTranslateStart() {
+  return Uint8Array.from([
+    80 /* TranslateStart */,
+    6,
+    0,
+    0,
+    1,
+    1
+  ]);
+}
+function encodeTranslateLanguages(fromLanguage, toLanguage) {
+  return Uint8Array.from([
+    28 /* TranslateLanguages */,
+    0,
+    fromLanguage & 255,
+    toLanguage & 255
+  ]);
+}
+function encodeTranslateText(kind, text, syncId) {
+  const encoded = new TextEncoder().encode(text);
+  const command = kind === "original" ? 15 /* TranslateOriginalText */ : 13 /* TranslateTranslatedText */;
+  return Uint8Array.from([
+    command,
+    syncId & 255,
+    1,
+    0,
+    0,
+    0,
+    text ? 32 : 0,
+    13,
+    ...encoded
+  ]);
+}
+function encodeGlassesWear(enabled) {
+  return Uint8Array.from([
+    39 /* GlassesWear */,
+    enabled ? 1 /* On */ : 0 /* Off */
+  ]);
+}
+function encodeAppWhitelist(whitelist) {
+  const text = typeof whitelist === "string" ? whitelist : JSON.stringify(whitelist);
+  const data = new TextEncoder().encode(text);
+  const maxPayload = 177;
+  const totalPackets = Math.max(1, Math.ceil(data.byteLength / maxPayload));
+  const packets = [];
+  for (let seq = 0; seq < totalPackets; seq++) {
+    const start = seq * maxPayload;
+    const chunk = data.slice(start, start + maxPayload);
+    const packet = new Uint8Array(3 + chunk.length);
+    packet.set([4 /* AppWhitelist */, totalPackets & 255, seq & 255]);
+    packet.set(chunk, 3);
+    packets.push(packet);
+  }
+  return packets;
+}
+function encodeNoteDelete(noteNumber) {
+  validateNoteNumber(noteNumber);
+  return Uint8Array.from([
+    30 /* Note */,
+    16,
+    0,
+    224,
+    3,
+    1,
+    0,
+    1,
+    0,
+    noteNumber,
+    0,
+    1,
+    0,
+    1,
+    0,
+    0
+  ]);
+}
+function encodeNoteAdd(noteNumber, title, text, version = Date.now()) {
+  validateNoteNumber(noteNumber);
+  const titleBytes = new TextEncoder().encode(title);
+  const textBytes = new TextEncoder().encode(text);
+  if (titleBytes.length > 255 || textBytes.length > 255) {
+    throw new RangeError(
+      "G1 note title and text must each encode to at most 255 bytes"
+    );
+  }
+  const fixed = Uint8Array.from([3, 1, 0, 1, 0]);
+  const payloadLength = 1 + 1 + fixed.length + 1 + 1 + 1 + titleBytes.length + 1 + 1 + textBytes.length + 2;
+  const out = new Uint8Array(
+    4 + fixed.length + 3 + titleBytes.length + 2 + textBytes.length
+  );
+  let offset = 0;
+  out.set(
+    [
+      30 /* Note */,
+      payloadLength & 255,
+      0,
+      Math.floor(version / 1e3) & 255
+    ],
+    offset
+  );
+  offset += 4;
+  out.set(fixed, offset);
+  offset += fixed.length;
+  out.set([noteNumber, 1, titleBytes.length & 255], offset);
+  offset += 3;
+  out.set(titleBytes, offset);
+  offset += titleBytes.length;
+  out.set([textBytes.length & 255, 0], offset);
+  offset += 2;
+  out.set(textBytes, offset);
+  return out;
+}
+function encodeVoiceNoteFetch(noteIndex, syncId) {
+  validateVoiceNoteIndex(noteIndex);
+  return Uint8Array.from([
+    30 /* Note */,
+    6,
+    0,
+    syncId & 255,
+    2 /* RequestAudioData */,
+    noteIndex & 255
+  ]);
+}
+function encodeVoiceNoteList(syncId) {
+  return Uint8Array.from([
+    30 /* Note */,
+    6,
+    0,
+    syncId & 255,
+    1 /* RequestAudioInfo */,
+    0
+  ]);
+}
+function encodeVoiceNoteDelete(noteIndex, syncId) {
+  validateVoiceNoteIndex(noteIndex);
+  return Uint8Array.from([
+    30 /* Note */,
+    6,
+    0,
+    syncId & 255,
+    4 /* DeleteAudioStream */,
+    noteIndex & 255
+  ]);
+}
+function encodeVoiceNoteDeleteAll(syncId) {
+  return Uint8Array.from([
+    30 /* Note */,
+    6,
+    0,
+    syncId & 255,
+    5 /* DeleteAll */,
+    0
+  ]);
+}
+function encodeNotification(payload) {
+  const nowSeconds = Math.floor(Date.now() / 1e3);
+  const model = {
+    ncs_notification: {
+      msg_id: payload.msgId ?? nowSeconds,
+      type: payload.type ?? 1,
+      app_identifier: payload.appIdentifier,
+      title: payload.title,
+      subtitle: payload.subtitle ?? "",
+      message: payload.message,
+      time_s: payload.timeS ?? nowSeconds,
+      date: payload.date ?? new Date((payload.timeS ?? nowSeconds) * 1e3).toISOString().slice(0, 19).replace("T", " "),
+      display_name: payload.displayName ?? payload.appIdentifier
+    },
+    type: "Add"
+  };
+  const bytes = new TextEncoder().encode(JSON.stringify(model));
+  const chunkSize = 176;
+  const chunks = [];
+  const total = Math.max(1, Math.ceil(bytes.length / chunkSize));
+  const packetMessageId = (payload.msgId ?? 0) & 255;
+  for (let index = 0; index < total; index++) {
+    const chunk = bytes.slice(index * chunkSize, (index + 1) * chunkSize);
+    const packet = new Uint8Array(4 + chunk.length);
+    packet.set([
+      75 /* Notification */,
+      packetMessageId,
+      total & 255,
+      index & 255
+    ]);
+    packet.set(chunk, 4);
+    chunks.push(packet);
+  }
+  return chunks;
+}
+function encodeBmpTransfer(imageData) {
+  const packets = [];
+  const packetSize = 194;
+  for (let offset = 0, seq = 0; offset < imageData.length; offset += packetSize, seq++) {
+    const chunk = imageData.slice(offset, offset + packetSize);
+    const prefix = seq === 0 ? [21 /* BmpData */, seq & 255, 0, 28, 0, 0] : [21 /* BmpData */, seq & 255];
+    const packet = new Uint8Array(prefix.length + chunk.length);
+    packet.set(prefix);
+    packet.set(chunk, prefix.length);
+    packets.push(packet);
+  }
+  packets.push(Uint8Array.from([32 /* BmpEnd */, 13, 14]));
+  const crcInput = new Uint8Array(4 + imageData.length);
+  crcInput.set([0, 28, 0, 0]);
+  crcInput.set(imageData, 4);
+  const crc = crc32(crcInput);
+  packets.push(
+    Uint8Array.from([
+      22 /* BmpCrc */,
+      crc >>> 24 & 255,
+      crc >>> 16 & 255,
+      crc >>> 8 & 255,
+      crc & 255
+    ])
+  );
+  return packets;
+}
+function encodeG1MonochromeBmp(pixels, options = {}) {
+  const width = options.width ?? G1_BMP.width;
+  const height = options.height ?? G1_BMP.height;
+  const threshold = options.threshold ?? 128;
+  if (!Number.isInteger(width) || width <= 0) {
+    throw new RangeError("BMP width must be a positive integer");
+  }
+  if (!Number.isInteger(height) || height <= 0) {
+    throw new RangeError("BMP height must be a positive integer");
+  }
+  const expectedPixels = width * height;
+  if (pixels.length !== expectedPixels) {
+    throw new RangeError(
+      `Expected ${expectedPixels} monochrome pixels, got ${pixels.length}`
+    );
+  }
+  const rowStride = Math.ceil(width / 32) * 4;
+  const pixelDataSize = rowStride * height;
+  const pixelOffset = 14 + 40 + 8;
+  const fileSize = pixelOffset + pixelDataSize;
+  const out = new Uint8Array(fileSize);
+  const view = new DataView(out.buffer);
+  out.set([66, 77], 0);
+  view.setUint32(2, fileSize, true);
+  view.setUint32(10, pixelOffset, true);
+  view.setUint32(14, 40, true);
+  view.setInt32(18, width, true);
+  view.setInt32(22, height, true);
+  view.setUint16(26, 1, true);
+  view.setUint16(28, 1, true);
+  view.setUint32(34, pixelDataSize, true);
+  view.setUint32(46, 2, true);
+  view.setUint32(50, 2, true);
+  out.set([0, 0, 0, 0, 255, 255, 255, 0], 54);
+  for (let y = 0; y < height; y++) {
+    const sourceY = height - 1 - y;
+    const rowOffset = pixelOffset + y * rowStride;
+    for (let x = 0; x < width; x++) {
+      const source = pixels[sourceY * width + x] ?? 0;
+      if (source < threshold) continue;
+      out[rowOffset + (x >> 3)] |= 128 >> (x & 7);
+    }
+  }
+  return out;
+}
+function parseG1Notification(side, data) {
+  const command = data[0];
+  if (command === 245 /* StartAi */) {
+    const code = data[1];
+    const state = classifyStateCode(code);
+    return {
+      side,
+      raw: data,
+      type: "state",
+      code,
+      label: state?.label ?? `unknown_0x${code?.toString(16)}`,
+      stateCategory: state?.category,
+      stateName: state?.name
+    };
+  }
+  if (command === 14 /* OpenMic */) {
+    const responseStatus = data.length >= 3 ? data[1] : void 0;
+    const requested = data[data.length - 1];
+    const responseOk = responseStatus === void 0 || responseStatus === 201 /* Success */;
+    const micRequested = requested === 1 /* Enable */;
+    return {
+      side,
+      raw: data,
+      type: "mic-response",
+      micEnabled: responseOk ? micRequested : !micRequested,
+      micRequested,
+      responseStatus,
+      responseOk,
+      code: requested,
+      label: responseOk && micRequested ? "mic_enabled" : responseOk ? "mic_disabled" : "mic_failed"
+    };
+  }
+  if (command === 241 /* ReceiveMicData */) {
+    return {
+      side,
+      raw: data,
+      type: "mic-data",
+      sequence: data[1],
+      audioData: data.slice(2),
+      audioEncoding: "lc3",
+      label: "mic_data"
+    };
+  }
+  if (command === 77 /* Init */ || command === 244 /* RightInit */) {
+    return {
+      side,
+      raw: data,
+      type: "init",
+      code: data[1],
+      label: command === 244 /* RightInit */ ? "right_init" : "init"
+    };
+  }
+  if (command === 78 /* SendResult */) {
+    return parseDisplayResult(side, data);
+  }
+  if (command === 75 /* Notification */) {
+    return parseNotificationChunk(side, data);
+  }
+  if (command === 33 /* QuickNote */) {
+    return parseVoiceNoteList(side, data);
+  }
+  if (command === 30 /* Note */ && data.length >= 11 && data[4] === 2 /* RequestAudioData */) {
+    const totalPackets = readUint16LE(data, 5);
+    const currentPacket = readUint16LE(data, 7);
+    const noteIndex = Math.max(0, (data[9] ?? 1) - 1);
+    return {
+      side,
+      raw: data,
+      type: "voice-note-audio",
+      syncId: data[3],
+      subcommand: data[4],
+      totalPackets,
+      currentPacket,
+      noteIndex,
+      sequence: currentPacket,
+      audioData: data.slice(10),
+      audioEncoding: "lc3",
+      label: "voice_note_audio"
+    };
+  }
+  if (command === 34 /* Dashboard */) {
+    const code = data[1];
+    return {
+      side,
+      raw: data,
+      type: "dashboard",
+      code,
+      label: `dashboard_0x${code?.toString(16).padStart(2, "0")}`
+    };
+  }
+  if (command === 52 /* GetSerial */) {
+    const serialNumber = new TextDecoder().decode(data.slice(2, 18)).replace(/\0+$/g, "");
+    return {
+      side,
+      raw: data,
+      type: "serial",
+      code: data[1],
+      responseStatus: data[1],
+      responseOk: data[1] === void 0 || data[1] === 201 /* Success */,
+      serialNumber,
+      label: "serial_number"
+    };
+  }
+  if (command === 37 /* Heartbeat */) {
+    return { side, raw: data, type: "heartbeat", label: "heartbeat" };
+  }
+  if (command === 44 /* Battery */) {
+    return parseBatteryStatus(side, data);
+  }
+  if (command === 3) {
+    return {
+      side,
+      raw: data,
+      type: "response",
+      code: data[1],
+      label: "response"
+    };
+  }
+  if (command === 4) {
+    return {
+      side,
+      raw: data,
+      type: "error",
+      code: data[1],
+      label: `error_0x${data[1]?.toString(16).padStart(2, "0")}`
+    };
+  }
+  return {
+    side,
+    raw: data,
+    type: "unknown",
+    code: command,
+    label: `unknown_0x${command?.toString(16)}`
+  };
+}
+function parseBatteryStatus(side, data) {
+  if (data.length < 6 || data[1] !== 102) {
+    return {
+      side,
+      raw: data,
+      type: "battery-status",
+      responseStatus: data[1],
+      responseOk: false,
+      label: "battery_status_invalid"
+    };
+  }
+  return {
+    side,
+    raw: data,
+    type: "battery-status",
+    responseStatus: data[1],
+    responseOk: true,
+    batteryPercent: data[2],
+    batteryFlags: data[3],
+    batteryVoltageMv: ((data[5] ?? 0) << 8 | (data[4] ?? 0)) / 10,
+    label: "battery_status"
+  };
+}
+function parseDisplayResult(side, data) {
+  if (data.length < 9) {
+    return {
+      side,
+      raw: data,
+      type: "display-result",
+      label: "display_result_invalid"
+    };
+  }
+  const textBytes = data.slice(9);
+  return {
+    side,
+    raw: data,
+    type: "display-result",
+    displaySeq: data[1],
+    totalPackages: data[2],
+    currentPackage: data[3],
+    screenStatus: data[4],
+    charPosition: readUint16BE(data, 5),
+    pageNumber: data[7],
+    maxPages: data[8],
+    text: new TextDecoder().decode(textBytes),
+    label: "display_result"
+  };
+}
+function parseNotificationChunk(side, data) {
+  if (data.length < 4) {
+    return {
+      side,
+      raw: data,
+      type: "notification",
+      label: "notification_invalid"
+    };
+  }
+  const notificationChunk = data.slice(4);
+  return {
+    side,
+    raw: data,
+    type: "notification",
+    notificationId: data[1],
+    totalPackages: data[2],
+    currentPackage: data[3],
+    notificationChunk,
+    text: new TextDecoder().decode(notificationChunk),
+    label: "notification"
+  };
+}
+function parseVoiceNoteList(side, data) {
+  const length = readUint16LE(data, 1);
+  const syncId = data[3];
+  const subcommand = data[4];
+  if (data.length < 6 || subcommand !== 1 /* RequestAudioInfo */) {
+    return {
+      side,
+      raw: data,
+      type: "voice-note-list",
+      syncId,
+      subcommand,
+      voiceNotes: [],
+      label: "voice_note_list_invalid"
+    };
+  }
+  const noteCount = data[5] ?? 0;
+  const expectedLength = 6 + noteCount * 9;
+  const boundedLength = Math.min(data.length, Math.max(length, expectedLength));
+  const voiceNotes = [];
+  for (let offset = 6; offset + 8 < boundedLength && voiceNotes.length < noteCount; offset += 9) {
+    voiceNotes.push({
+      index: data[offset],
+      timestamp: readUint32LE(data, offset + 1),
+      crc: readUint32LE(data, offset + 5)
+    });
+  }
+  return {
+    side,
+    raw: data,
+    type: "voice-note-list",
+    syncId,
+    subcommand,
+    voiceNotes,
+    label: "voice_note_list"
+  };
+}
+function pcm16ToFloat32(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const out = new Float32Array(Math.floor(bytes.byteLength / 2));
+  for (let i = 0; i < out.length; i++)
+    out[i] = view.getInt16(i * 2, true) / 32768;
+  return out;
+}
+function validateNoteNumber(noteNumber) {
+  if (!Number.isInteger(noteNumber) || noteNumber < 1 || noteNumber > 4) {
+    throw new RangeError("Note number must be an integer between 1 and 4");
+  }
+}
+function validateVoiceNoteIndex(noteIndex) {
+  if (!Number.isInteger(noteIndex) || noteIndex < 0 || noteIndex > 255) {
+    throw new RangeError(
+      "G1 voice note index must be an integer from 0 to 255"
+    );
+  }
+}
+function validateBitPlanes(image, overlay, expectedLength, label) {
+  if (image.length !== expectedLength || overlay.length !== expectedLength) {
+    throw new RangeError(
+      `Expected ${expectedLength} bits for ${label} and overlay`
+    );
+  }
+}
+function runLengthEncodeBits(data) {
+  if (data.length === 0) return [];
+  const encoded = [];
+  let current = data[0] ? 1 : 0;
+  let count = 1;
+  for (let index = 1; index < data.length; index++) {
+    const bit = data[index] ? 1 : 0;
+    if (bit === current && count < 255) {
+      count += 1;
+      continue;
+    }
+    encoded.push(count, current);
+    current = bit;
+    count = 1;
+  }
+  encoded.push(count, current);
+  return encoded;
+}
+function encodeNavigationImagePackets(bytes, partType, startSeqId, includeExtraZero) {
+  const maxPayload = 185;
+  const packetCount = Math.max(1, Math.ceil(bytes.length / maxPayload));
+  const packets = [];
+  let seqId = startSeqId & 255;
+  for (let index = 0; index < packetCount; index++) {
+    const chunk = bytes.slice(index * maxPayload, (index + 1) * maxPayload);
+    const part = [
+      0,
+      seqId,
+      partType,
+      packetCount & 255,
+      0,
+      index + 1 & 255,
+      0,
+      ...includeExtraZero ? [0] : [],
+      ...chunk.map((byte) => byte & 255)
+    ];
+    packets.push(
+      Uint8Array.from([
+        10 /* Navigation */,
+        part.length + 2 & 255,
+        ...part
+      ])
+    );
+    seqId = seqId + 1 & 255;
+  }
+  return packets;
+}
+function readUint16LE(data, offset) {
+  return (data[offset] ?? 0) | (data[offset + 1] ?? 0) << 8;
+}
+function readUint16BE(data, offset) {
+  return (data[offset] ?? 0) << 8 | (data[offset + 1] ?? 0);
+}
+function readUint32LE(data, offset) {
+  return ((data[offset] ?? 0) | (data[offset + 1] ?? 0) << 8 | (data[offset + 2] ?? 0) << 16 | (data[offset + 3] ?? 0) << 24) >>> 0;
+}
+function crc32(bytes) {
+  let crc = 4294967295;
+  for (const byte of bytes) {
+    crc ^= byte;
+    for (let bit = 0; bit < 8; bit++) {
+      crc = crc & 1 ? crc >>> 1 ^ 3988292384 : crc >>> 1;
+    }
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+export {
+  EVEN_G1_UART,
+  G1AiStatus,
+  G1Command,
+  G1DashboardLayout,
+  G1DashboardState,
+  G1GlassesWearStatus,
+  G1InteractionCode,
+  G1MicStatus,
+  G1NavigationTurn,
+  G1ResponseStatus,
+  G1ScreenAction,
+  G1SilentModeStatus,
+  G1SubCommand,
+  G1TemperatureUnit,
+  G1TextStatus,
+  G1TimeFormat,
+  G1TranslateLanguage,
+  G1VoiceNoteSubCommand,
+  G1WeatherIcon,
+  G1_BMP,
+  G1_DISPLAY,
+  encodeAppWhitelist,
+  encodeBatteryStatusRequest,
+  encodeBmpTransfer,
+  encodeBrightness,
+  encodeClearScreen,
+  encodeConnectionReady,
+  encodeDashboard,
+  encodeDashboardCalendarItem,
+  encodeDashboardLayout,
+  encodeDashboardPosition,
+  encodeDashboardTimeWeather,
+  encodeExitFunction,
+  encodeG1MonochromeBmp,
+  encodeG1Setup,
+  encodeGetSerial,
+  encodeGlassesWear,
+  encodeHeadUpAngle,
+  encodeHeartbeat,
+  encodeMicCommand,
+  encodeNavigationDirections,
+  encodeNavigationEnd,
+  encodeNavigationInit,
+  encodeNavigationPoller,
+  encodeNavigationPrimaryImage,
+  encodeNavigationSecondaryImage,
+  encodeNoteAdd,
+  encodeNoteDelete,
+  encodeNotification,
+  encodeSilentMode,
+  encodeStartAi,
+  encodeTextPacket,
+  encodeTextPackets,
+  encodeTranslateLanguages,
+  encodeTranslateSetup,
+  encodeTranslateStart,
+  encodeTranslateText,
+  encodeVoiceNoteDelete,
+  encodeVoiceNoteDeleteAll,
+  encodeVoiceNoteFetch,
+  encodeVoiceNoteList,
+  formatDisplayLines,
+  measureG1DisplayText,
+  microphoneActionForInteractionEvent,
+  paginateDisplayText,
+  parseG1Notification,
+  pcm16ToFloat32
+};
+//# sourceMappingURL=smartglasses.js.map