@limrun/ui 0.17.0-rc.1 → 0.17.0-rc.2

package/src/core/constants.ts

@@ -1,344 +0,0 @@
-export const CONTROL_MSG_TYPE = {
-  INJECT_KEYCODE: 0,
-  INJECT_TEXT: 1,
-  INJECT_TOUCH_EVENT: 2,
-  // iOS-specific: send two touch points in one message (Option/Alt+drag pinch)
-  INJECT_TWO_FINGER_TOUCH_EVENT: 18,
-  INJECT_SCROLL_EVENT: 3,
-  BACK_OR_SCREEN_ON: 4,
-  EXPAND_NOTIFICATION_PANEL: 5,
-  EXPAND_SETTINGS_PANEL: 6,
-  COLLAPSE_PANELS: 7,
-  GET_CLIPBOARD: 8,
-  SET_CLIPBOARD: 9,
-  SET_DISPLAY_POWER: 10,
-  ROTATE_DEVICE: 11,
-} as const;
-
-export const AMOTION_EVENT = {
-  ACTION_DOWN: 0,
-  ACTION_UP: 1,
-  ACTION_MOVE: 2,
-  ACTION_CANCEL: 3,
-  ACTION_POINTER_DOWN: 5,
-  ACTION_POINTER_UP: 6,
-  BUTTON_PRIMARY: 1,
-  BUTTON_SECONDARY: 2,
-  BUTTON_TERTIARY: 4,
-} as const;
-
-export const ANDROID_KEYS = {
-  // Actions
-  ACTION_DOWN: 0,
-  ACTION_UP: 1,
-
-  // Meta state flags (from android.view.KeyEvent)
-  META_NONE: 0,
-  META_SHIFT_ON: 1,
-  META_ALT_ON: 2,
-  META_CTRL_ON: 4096, // META_CTRL_LEFT_ON | META_CTRL_RIGHT_ON
-  META_META_ON: 65536, // META_META_LEFT_ON | META_META_RIGHT_ON
-
-  // Keycodes (from android.view.KeyEvent)
-  KEYCODE_UNKNOWN: 0,
-  KEYCODE_SOFT_LEFT: 1,
-  KEYCODE_SOFT_RIGHT: 2,
-  KEYCODE_HOME: 3,
-  KEYCODE_BACK: 4,
-  KEYCODE_CALL: 5,
-  KEYCODE_ENDCALL: 6,
-  KEYCODE_0: 7,
-  KEYCODE_1: 8,
-  KEYCODE_2: 9,
-  KEYCODE_3: 10,
-  KEYCODE_4: 11,
-  KEYCODE_5: 12,
-  KEYCODE_6: 13,
-  KEYCODE_7: 14,
-  KEYCODE_8: 15,
-  KEYCODE_9: 16,
-  KEYCODE_STAR: 17,
-  KEYCODE_POUND: 18,
-  DPAD_UP: 19, // KEYCODE_DPAD_UP
-  DPAD_DOWN: 20, // KEYCODE_DPAD_DOWN
-  DPAD_LEFT: 21, // KEYCODE_DPAD_LEFT
-  DPAD_RIGHT: 22, // KEYCODE_DPAD_RIGHT
-  KEYCODE_DPAD_CENTER: 23,
-  KEYCODE_VOLUME_UP: 24,
-  KEYCODE_VOLUME_DOWN: 25,
-  KEYCODE_POWER: 26,
-  KEYCODE_CAMERA: 27,
-  KEYCODE_CLEAR: 28,
-  KEYCODE_A: 29,
-  KEYCODE_B: 30,
-  KEYCODE_C: 31,
-  KEYCODE_D: 32,
-  KEYCODE_E: 33,
-  KEYCODE_F: 34,
-  KEYCODE_G: 35,
-  KEYCODE_H: 36,
-  KEYCODE_I: 37,
-  KEYCODE_J: 38,
-  KEYCODE_K: 39,
-  KEYCODE_L: 40,
-  KEYCODE_M: 41,
-  KEYCODE_N: 42,
-  KEYCODE_O: 43,
-  KEYCODE_P: 44,
-  KEYCODE_Q: 45,
-  KEYCODE_R: 46,
-  KEYCODE_S: 47,
-  KEYCODE_T: 48,
-  KEYCODE_U: 49,
-  KEYCODE_V: 50,
-  KEYCODE_W: 51,
-  KEYCODE_X: 52,
-  KEYCODE_Y: 53,
-  KEYCODE_Z: 54,
-  KEYCODE_COMMA: 55,
-  KEYCODE_PERIOD: 56,
-  KEYCODE_ALT_LEFT: 57,
-  KEYCODE_ALT_RIGHT: 58,
-  KEYCODE_SHIFT_LEFT: 59,
-  KEYCODE_SHIFT_RIGHT: 60,
-  KEYCODE_TAB: 61,
-  KEYCODE_SPACE: 62,
-  KEYCODE_SYM: 63,
-  KEYCODE_EXPLORER: 64,
-  KEYCODE_ENVELOPE: 65,
-  ENTER: 66, // KEYCODE_ENTER
-  DEL: 67, // KEYCODE_DEL (Backspace)
-  KEYCODE_GRAVE: 68, // `
-  KEYCODE_MINUS: 69, // -
-  KEYCODE_EQUALS: 70, // =
-  KEYCODE_LEFT_BRACKET: 71, // [
-  KEYCODE_RIGHT_BRACKET: 72, // ]
-  KEYCODE_BACKSLASH: 73, // \
-  KEYCODE_SEMICOLON: 74, // ;
-  KEYCODE_APOSTROPHE: 75, // '
-  KEYCODE_SLASH: 76, // /
-  KEYCODE_AT: 77, // @
-  KEYCODE_NUM: 78,
-  KEYCODE_HEADSETHOOK: 79,
-  KEYCODE_FOCUS: 80,
-  KEYCODE_PLUS: 81,
-  MENU: 82, // KEYCODE_MENU
-  KEYCODE_NOTIFICATION: 83,
-  KEYCODE_SEARCH: 84,
-  KEYCODE_MEDIA_PLAY_PAUSE: 85,
-  KEYCODE_MEDIA_STOP: 86,
-  KEYCODE_MEDIA_NEXT: 87,
-  KEYCODE_MEDIA_PREVIOUS: 88,
-  KEYCODE_MEDIA_REWIND: 89,
-  KEYCODE_MEDIA_FAST_FORWARD: 90,
-  KEYCODE_MUTE: 91,
-  KEYCODE_PAGE_UP: 92,
-  KEYCODE_PAGE_DOWN: 93,
-  KEYCODE_PICTSYMBOLS: 94,
-  KEYCODE_SWITCH_CHARSET: 95,
-  KEYCODE_BUTTON_A: 96,
-  KEYCODE_BUTTON_B: 97,
-  KEYCODE_BUTTON_C: 98,
-  KEYCODE_BUTTON_X: 99,
-  KEYCODE_BUTTON_Y: 100,
-  KEYCODE_BUTTON_Z: 101,
-  KEYCODE_BUTTON_L1: 102,
-  KEYCODE_BUTTON_R1: 103,
-  KEYCODE_BUTTON_L2: 104,
-  KEYCODE_BUTTON_R2: 105,
-  KEYCODE_BUTTON_THUMBL: 106,
-  KEYCODE_BUTTON_THUMBR: 107,
-  KEYCODE_BUTTON_START: 108,
-  KEYCODE_BUTTON_SELECT: 109,
-  KEYCODE_BUTTON_MODE: 110,
-  KEYCODE_ESCAPE: 111,
-  FORWARD_DEL: 112, // KEYCODE_FORWARD_DEL (Delete key)
-  KEYCODE_CTRL_LEFT: 113,
-  KEYCODE_CTRL_RIGHT: 114,
-  KEYCODE_CAPS_LOCK: 115,
-  KEYCODE_SCROLL_LOCK: 116,
-  KEYCODE_META_LEFT: 117,
-  KEYCODE_META_RIGHT: 118,
-  KEYCODE_FUNCTION: 119,
-  KEYCODE_SYSRQ: 120,
-  KEYCODE_BREAK: 121,
-  KEYCODE_MOVE_HOME: 122,
-  KEYCODE_MOVE_END: 123,
-  KEYCODE_INSERT: 124,
-  KEYCODE_FORWARD: 125,
-  KEYCODE_MEDIA_PLAY: 126,
-  KEYCODE_MEDIA_PAUSE: 127,
-  KEYCODE_MEDIA_CLOSE: 128,
-  KEYCODE_MEDIA_EJECT: 129,
-  KEYCODE_MEDIA_RECORD: 130,
-  KEYCODE_F1: 131,
-  KEYCODE_F2: 132,
-  KEYCODE_F3: 133,
-  KEYCODE_F4: 134,
-  KEYCODE_F5: 135,
-  KEYCODE_F6: 136,
-  KEYCODE_F7: 137,
-  KEYCODE_F8: 138,
-  KEYCODE_F9: 139,
-  KEYCODE_F10: 140,
-  KEYCODE_F11: 141,
-  KEYCODE_F12: 142,
-  KEYCODE_NUM_LOCK: 143,
-  KEYCODE_NUMPAD_0: 144,
-  KEYCODE_NUMPAD_1: 145,
-  KEYCODE_NUMPAD_2: 146,
-  KEYCODE_NUMPAD_3: 147,
-  KEYCODE_NUMPAD_4: 148,
-  KEYCODE_NUMPAD_5: 149,
-  KEYCODE_NUMPAD_6: 150,
-  KEYCODE_NUMPAD_7: 151,
-  KEYCODE_NUMPAD_8: 152,
-  KEYCODE_NUMPAD_9: 153,
-  KEYCODE_NUMPAD_DIVIDE: 154,
-  KEYCODE_NUMPAD_MULTIPLY: 155,
-  KEYCODE_NUMPAD_SUBTRACT: 156,
-  KEYCODE_NUMPAD_ADD: 157,
-  KEYCODE_NUMPAD_DOT: 158,
-  KEYCODE_NUMPAD_COMMA: 159,
-  KEYCODE_NUMPAD_ENTER: 160,
-  KEYCODE_NUMPAD_EQUALS: 161,
-  KEYCODE_NUMPAD_LEFT_PAREN: 162,
-  KEYCODE_NUMPAD_RIGHT_PAREN: 163,
-  KEYCODE_VOLUME_MUTE: 164,
-  KEYCODE_INFO: 165,
-  KEYCODE_CHANNEL_UP: 166,
-  KEYCODE_CHANNEL_DOWN: 167,
-  KEYCODE_ZOOM_IN: 168,
-  KEYCODE_ZOOM_OUT: 169,
-  KEYCODE_TV: 170,
-  KEYCODE_WINDOW: 171,
-  KEYCODE_GUIDE: 172,
-  KEYCODE_DVR: 173,
-  KEYCODE_BOOKMARK: 174,
-  KEYCODE_CAPTIONS: 175,
-  KEYCODE_SETTINGS: 176,
-  KEYCODE_TV_POWER: 177,
-  KEYCODE_TV_INPUT: 178,
-  KEYCODE_STB_POWER: 179,
-  KEYCODE_STB_INPUT: 180,
-  KEYCODE_AVR_POWER: 181,
-  KEYCODE_AVR_INPUT: 182,
-  KEYCODE_PROG_RED: 183,
-  KEYCODE_PROG_GREEN: 184,
-  KEYCODE_PROG_YELLOW: 185,
-  KEYCODE_PROG_BLUE: 186,
-  KEYCODE_APP_SWITCH: 187,
-  KEYCODE_LANGUAGE_SWITCH: 204,
-  KEYCODE_ASSIST: 219,
-  KEYCODE_BRIGHTNESS_DOWN: 220,
-  KEYCODE_BRIGHTNESS_UP: 221,
-  KEYCODE_SLEEP: 223,
-  KEYCODE_WAKEUP: 224,
-  KEYCODE_SOFT_SLEEP: 276,
-} as const;
-
-// Map based on event.code for layout independence
-export const codeMap: { [code: string]: number } = {
-  KeyA: ANDROID_KEYS.KEYCODE_A,
-  KeyB: ANDROID_KEYS.KEYCODE_B,
-  KeyC: ANDROID_KEYS.KEYCODE_C,
-  KeyD: ANDROID_KEYS.KEYCODE_D,
-  KeyE: ANDROID_KEYS.KEYCODE_E,
-  KeyF: ANDROID_KEYS.KEYCODE_F,
-  KeyG: ANDROID_KEYS.KEYCODE_G,
-  KeyH: ANDROID_KEYS.KEYCODE_H,
-  KeyI: ANDROID_KEYS.KEYCODE_I,
-  KeyJ: ANDROID_KEYS.KEYCODE_J,
-  KeyK: ANDROID_KEYS.KEYCODE_K,
-  KeyL: ANDROID_KEYS.KEYCODE_L,
-  KeyM: ANDROID_KEYS.KEYCODE_M,
-  KeyN: ANDROID_KEYS.KEYCODE_N,
-  KeyO: ANDROID_KEYS.KEYCODE_O,
-  KeyP: ANDROID_KEYS.KEYCODE_P,
-  KeyQ: ANDROID_KEYS.KEYCODE_Q,
-  KeyR: ANDROID_KEYS.KEYCODE_R,
-  KeyS: ANDROID_KEYS.KEYCODE_S,
-  KeyT: ANDROID_KEYS.KEYCODE_T,
-  KeyU: ANDROID_KEYS.KEYCODE_U,
-  KeyV: ANDROID_KEYS.KEYCODE_V,
-  KeyW: ANDROID_KEYS.KEYCODE_W,
-  KeyX: ANDROID_KEYS.KEYCODE_X,
-  KeyY: ANDROID_KEYS.KEYCODE_Y,
-  KeyZ: ANDROID_KEYS.KEYCODE_Z,
-  Digit0: ANDROID_KEYS.KEYCODE_0,
-  Digit1: ANDROID_KEYS.KEYCODE_1,
-  Digit2: ANDROID_KEYS.KEYCODE_2,
-  Digit3: ANDROID_KEYS.KEYCODE_3,
-  Digit4: ANDROID_KEYS.KEYCODE_4,
-  Digit5: ANDROID_KEYS.KEYCODE_5,
-  Digit6: ANDROID_KEYS.KEYCODE_6,
-  Digit7: ANDROID_KEYS.KEYCODE_7,
-  Digit8: ANDROID_KEYS.KEYCODE_8,
-  Digit9: ANDROID_KEYS.KEYCODE_9,
-  Backquote: ANDROID_KEYS.KEYCODE_GRAVE,
-  Minus: ANDROID_KEYS.KEYCODE_MINUS,
-  Equal: ANDROID_KEYS.KEYCODE_EQUALS,
-  BracketLeft: ANDROID_KEYS.KEYCODE_LEFT_BRACKET,
-  BracketRight: ANDROID_KEYS.KEYCODE_RIGHT_BRACKET,
-  Backslash: ANDROID_KEYS.KEYCODE_BACKSLASH,
-  Semicolon: ANDROID_KEYS.KEYCODE_SEMICOLON,
-  Quote: ANDROID_KEYS.KEYCODE_APOSTROPHE,
-  Comma: ANDROID_KEYS.KEYCODE_COMMA,
-  Period: ANDROID_KEYS.KEYCODE_PERIOD,
-  Slash: ANDROID_KEYS.KEYCODE_SLASH,
-  Space: ANDROID_KEYS.KEYCODE_SPACE,
-  Tab: ANDROID_KEYS.KEYCODE_TAB,
-  Escape: ANDROID_KEYS.KEYCODE_ESCAPE,
-  ArrowUp: ANDROID_KEYS.DPAD_UP,
-  ArrowDown: ANDROID_KEYS.DPAD_DOWN,
-  ArrowLeft: ANDROID_KEYS.DPAD_LEFT,
-  ArrowRight: ANDROID_KEYS.DPAD_RIGHT,
-  Enter: ANDROID_KEYS.ENTER,
-  Backspace: ANDROID_KEYS.DEL,
-  Delete: ANDROID_KEYS.FORWARD_DEL,
-  Home: ANDROID_KEYS.KEYCODE_MOVE_HOME,
-  End: ANDROID_KEYS.KEYCODE_MOVE_END,
-  PageUp: ANDROID_KEYS.KEYCODE_PAGE_UP,
-  PageDown: ANDROID_KEYS.KEYCODE_PAGE_DOWN,
-  Insert: ANDROID_KEYS.KEYCODE_INSERT,
-  F1: ANDROID_KEYS.KEYCODE_F1,
-  F2: ANDROID_KEYS.KEYCODE_F2,
-  F3: ANDROID_KEYS.KEYCODE_F3,
-  F4: ANDROID_KEYS.KEYCODE_F4,
-  F5: ANDROID_KEYS.KEYCODE_F5,
-  F6: ANDROID_KEYS.KEYCODE_F6,
-  F7: ANDROID_KEYS.KEYCODE_F7,
-  F8: ANDROID_KEYS.KEYCODE_F8,
-  F9: ANDROID_KEYS.KEYCODE_F9,
-  F10: ANDROID_KEYS.KEYCODE_F10,
-  F11: ANDROID_KEYS.KEYCODE_F11,
-  F12: ANDROID_KEYS.KEYCODE_F12,
-  ShiftLeft: ANDROID_KEYS.KEYCODE_SHIFT_LEFT,
-  ShiftRight: ANDROID_KEYS.KEYCODE_SHIFT_RIGHT,
-  ControlLeft: ANDROID_KEYS.KEYCODE_CTRL_LEFT,
-  ControlRight: ANDROID_KEYS.KEYCODE_CTRL_RIGHT,
-  AltLeft: ANDROID_KEYS.KEYCODE_ALT_LEFT,
-  AltRight: ANDROID_KEYS.KEYCODE_ALT_RIGHT,
-  MetaLeft: ANDROID_KEYS.KEYCODE_META_LEFT,
-  MetaRight: ANDROID_KEYS.KEYCODE_META_RIGHT, // Windows/Command key
-  ContextMenu: ANDROID_KEYS.MENU, // Often the Menu key
-  // Numpad mappings
-  Numpad0: ANDROID_KEYS.KEYCODE_NUMPAD_0,
-  Numpad1: ANDROID_KEYS.KEYCODE_NUMPAD_1,
-  Numpad2: ANDROID_KEYS.KEYCODE_NUMPAD_2,
-  Numpad3: ANDROID_KEYS.KEYCODE_NUMPAD_3,
-  Numpad4: ANDROID_KEYS.KEYCODE_NUMPAD_4,
-  Numpad5: ANDROID_KEYS.KEYCODE_NUMPAD_5,
-  Numpad6: ANDROID_KEYS.KEYCODE_NUMPAD_6,
-  Numpad7: ANDROID_KEYS.KEYCODE_NUMPAD_7,
-  Numpad8: ANDROID_KEYS.KEYCODE_NUMPAD_8,
-  Numpad9: ANDROID_KEYS.KEYCODE_NUMPAD_9,
-  NumpadDivide: ANDROID_KEYS.KEYCODE_NUMPAD_DIVIDE,
-  NumpadMultiply: ANDROID_KEYS.KEYCODE_NUMPAD_MULTIPLY,
-  NumpadSubtract: ANDROID_KEYS.KEYCODE_NUMPAD_SUBTRACT,
-  NumpadAdd: ANDROID_KEYS.KEYCODE_NUMPAD_ADD,
-  NumpadDecimal: ANDROID_KEYS.KEYCODE_NUMPAD_DOT,
-  NumpadComma: ANDROID_KEYS.KEYCODE_NUMPAD_COMMA, // Some numpads have comma
-  NumpadEnter: ANDROID_KEYS.KEYCODE_NUMPAD_ENTER,
-  NumpadEqual: ANDROID_KEYS.KEYCODE_NUMPAD_EQUALS,
-};

package/src/core/duo.test.ts

@@ -1,142 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import {
-  createDisplayTouchMessage,
-  flatDisplayTouch,
-  duoPointerMode,
-  DuoButtonSender,
-  HingeSender,
-  panelTouch,
-  validHingeAngle,
-} from './duo';
-
-describe('native Duo input', () => {
-  it.each([
-    [0, 0.2, 0.3],
-    [1, 0.3, 0.8],
-    [2, 0.8, 0.7],
-    [3, 0.7, 0.2],
-  ])('maps 2D screen coordinates back to the native panel at rotation %s', (turns, x, y) => {
-    const point = flatDisplayTouch(0.2, 0.3, turns!);
-    expect(point.x).toBeCloseTo(x!);
-    expect(point.y).toBeCloseTo(y!);
-  });
-  it('keeps a captured drag inside the native panel after it leaves the screen', () => {
-    expect(flatDisplayTouch(-1, 2, 1)).toEqual({ x: 1, y: 1 });
-  });
-  it('rejects non-finite and out-of-range hinge values', () => {
-    for (const angle of [NaN, Infinity, -1, 181]) expect(validHingeAngle(angle)).toBe(false);
-    for (const angle of [0, 45.5, 90, 180]) expect(validHingeAngle(angle)).toBe(true);
-  });
-  it('encodes panel identity and top-left coordinates without video rotation', () => {
-    const point = panelTouch(0.3, 0.6);
-    const data = new DataView(createDisplayTouchMessage(0, 3, point.x, point.y));
-    expect(data.byteLength).toBe(12);
-    expect(data.getUint8(0)).toBe(19);
-    expect(data.getUint8(2)).toBe(3);
-    expect(data.getFloat32(4, true)).toBeCloseTo(0.3);
-    expect(data.getFloat32(8, true)).toBeCloseTo(0.4);
-    expect(() => createDisplayTouchMessage(0, 3, NaN, 0)).toThrow();
-  });
-  it('sends the final slider angle while coalescing intermediate positions', async () => {
-    let finish!: () => void;
-    const send = vi
-      .fn()
-      .mockImplementationOnce(
-        () =>
-          new Promise<void>((resolve) => {
-            finish = resolve;
-          }),
-      )
-      .mockResolvedValue(undefined);
-    const sender = new HingeSender(send, vi.fn());
-    sender.set(10);
-    sender.set(20);
-    sender.set(90);
-    sender.set(180);
-    expect(send.mock.calls).toEqual([[10]]);
-    finish();
-    await vi.waitFor(() => expect(send.mock.calls).toEqual([[10], [180]]));
-  });
-  it('drops pending angles after disconnect and reports failures', async () => {
-    const failed = vi.fn();
-    const sender = new HingeSender(async () => {
-      throw new Error('offline');
-    }, failed);
-    sender.set(120);
-    await vi.waitFor(() => expect(failed).toHaveBeenCalledOnce());
-    sender.stop();
-    sender.set(0);
-    expect(failed).toHaveBeenCalledOnce();
-  });
-});
-
-describe('Duo position lock', () => {
-  it.each([false, true])('keeps touch active while locked (Alt=%s)', (alt) => {
-    expect(duoPointerMode(true, true, alt)).toBe('touch');
-    expect(duoPointerMode(true, false, alt)).toBe('ignore');
-  });
-  it('allows deliberate orbit only after unlocking', () => {
-    expect(duoPointerMode(false, false, false)).toBe('orbit');
-    expect(duoPointerMode(false, true, false)).toBe('touch');
-    expect(duoPointerMode(false, true, true)).toBe('orbit');
-  });
-});
-
-describe('Duo hardware input', () => {
-  it('orders a quick release after the acknowledged down event', async () => {
-    let ack!: () => void;
-    const send = vi
-      .fn()
-      .mockImplementationOnce(
-        () =>
-          new Promise<void>((resolve) => {
-            ack = resolve;
-          }),
-      )
-      .mockResolvedValue(undefined);
-    const sender = new DuoButtonSender(send, vi.fn());
-    sender.press('side');
-    sender.release();
-    sender.release();
-    await vi.waitFor(() => expect(send.mock.calls).toEqual([['side', true]]));
-    ack();
-    await vi.waitFor(() =>
-      expect(send.mock.calls).toEqual([
-        ['side', true],
-        ['side', false],
-      ]),
-    );
-  });
-  it('still releases when a down event fails or times out', async () => {
-    const send = vi.fn().mockRejectedValueOnce(new Error('timeout')).mockResolvedValue(undefined);
-    const failed = vi.fn();
-    const sender = new DuoButtonSender(send, failed);
-    sender.press('volumeDown');
-    sender.press('volumeUp');
-    sender.release();
-    await vi.waitFor(() =>
-      expect(send.mock.calls).toEqual([
-        ['volumeDown', true],
-        ['volumeDown', false],
-      ]),
-    );
-    expect(failed).toHaveBeenCalledOnce();
-  });
-  it('releases a button if the browser loses the pointer release', async () => {
-    vi.useFakeTimers();
-    try {
-      const send = vi.fn().mockResolvedValue(undefined);
-      const sender = new DuoButtonSender(send, vi.fn());
-      sender.press('volumeUp');
-      await vi.advanceTimersByTimeAsync(10000);
-      expect(send.mock.calls).toEqual([
-        ['volumeUp', true],
-        ['volumeUp', false],
-      ]);
-      sender.release();
-      expect(send).toHaveBeenCalledTimes(2);
-    } finally {
-      vi.useRealTimers();
-    }
-  });
-});

package/src/core/duo.ts

@@ -1,156 +0,0 @@
-/** Native iPhone Duo display metadata. Pixel geometry comes from CoreSimulator. */
-export interface DuoDisplay {
-  id: 'outer' | 'inner';
-  screenId: number;
-  trackId: string;
-  width: number;
-  height: number;
-  scale: number;
-  orientation: number;
-}
-
-export type DuoOrientation = 'portrait' | 'pud' | 'landscape-left' | 'landscape-right';
-
-export interface DuoState {
-  orientation: DuoOrientation;
-  angleDegrees: number;
-  minAngleDegrees: number;
-  maxAngleDegrees: number;
-  displays: DuoDisplay[];
-}
-
-export const DUO_DIMENSIONS = { width: 164.6, height: 117.8, depth: 5.2 } as const;
-
-/** Invert the CSS display rotation before sending native panel coordinates. */
-export function flatDisplayTouch(x: number, y: number, turns: number): { x: number; y: number } {
-  x = Math.max(0, Math.min(1, x));
-  y = Math.max(0, Math.min(1, y));
-  if (turns === 1) return { x: y, y: 1 - x };
-  if (turns === 2) return { x: 1 - x, y: 1 - y };
-  if (turns === 3) return { x: 1 - y, y: x };
-  return { x, y };
-}
-
-export function validHingeAngle(angle: number): boolean {
-  return Number.isFinite(angle) && angle >= 0 && angle <= 180;
-}
-
-/** Mesh UVs use the native portrait panel; HID has a top-left origin. */
-export function panelTouch(u: number, v: number): { x: number; y: number } {
-  return { x: Math.max(0, Math.min(1, u)), y: Math.max(0, Math.min(1, 1 - v)) };
-}
-
-/** Locking the view never suppresses screen input, including accidental Alt presses. */
-export function duoPointerMode(
-  locked: boolean,
-  screenHit: boolean,
-  altKey: boolean,
-): 'touch' | 'orbit' | 'ignore' {
-  if (screenHit && (locked || !altKey)) return 'touch';
-  return locked ? 'ignore' : 'orbit';
-}
-
-export function createDisplayTouchMessage(
-  action: number,
-  screenId: number,
-  x: number,
-  y: number,
-): ArrayBuffer {
-  if (
-    !Number.isInteger(action) ||
-    action < 0 ||
-    action > 3 ||
-    !Number.isInteger(screenId) ||
-    screenId < 1 ||
-    screenId > 255 ||
-    !Number.isFinite(x) ||
-    !Number.isFinite(y) ||
-    x < 0 ||
-    x > 1 ||
-    y < 0 ||
-    y > 1
-  ) {
-    throw new RangeError('Invalid display touch coordinates');
-  }
-  const message = new ArrayBuffer(12);
-  const view = new DataView(message);
-  view.setUint8(0, 19);
-  view.setUint8(1, action);
-  view.setUint8(2, screenId);
-  view.setFloat32(4, x, true);
-  view.setFloat32(8, y, true);
-  return message;
-}
-
-/** One request in flight; intermediate slider positions are replaced by the newest position. */
-export class HingeSender {
-  private latest: number | undefined;
-  private running = false;
-  private stopped = false;
-  constructor(
-    private send: (angle: number) => Promise<void>,
-    private failed: (error: unknown) => void,
-  ) {}
-
-  set(angle: number): void {
-    if (this.stopped || !validHingeAngle(angle)) return;
-    this.latest = angle;
-    void this.flush();
-  }
-
-  stop(): void {
-    this.stopped = true;
-    this.latest = undefined;
-  }
-
-  private async flush(): Promise<void> {
-    if (this.running || this.stopped) return;
-    this.running = true;
-    try {
-      while (this.latest !== undefined && !this.stopped) {
-        const angle = this.latest;
-        this.latest = undefined;
-        await this.send(angle);
-      }
-    } catch (error) {
-      this.latest = undefined;
-      if (!this.stopped) this.failed(error);
-    } finally {
-      this.running = false;
-    }
-  }
-}
-
-export type DuoButton = 'side' | 'volumeUp' | 'volumeDown';
-export const DUO_BUTTONS: Record<DuoButton, string> = {
-  side: 'Sleep/Wake',
-  volumeUp: 'Volume Up',
-  volumeDown: 'Volume Down',
-};
-
-/** Keeps button edges ordered, including releases after cancellation or a failed press. */
-export class DuoButtonSender {
-  private held?: DuoButton;
-  private tail = Promise.resolve();
-  private timeout?: ReturnType<typeof setTimeout>;
-  constructor(
-    private send: (button: DuoButton, down: boolean) => Promise<void>,
-    private failed: (error: unknown) => void,
-  ) {}
-  press(button: DuoButton): void {
-    if (this.held) return;
-    this.held = button;
-    this.enqueue(button, true);
-    this.timeout = setTimeout(() => this.release(), 10000);
-  }
-  release(): void {
-    if (!this.held) return;
-    clearTimeout(this.timeout);
-    const button = this.held;
-    this.held = undefined;
-    this.enqueue(button, false);
-  }
-  private enqueue(button: DuoButton, down: boolean): void {
-    this.tail = this.tail.then(() => this.send(button, down)).catch(this.failed);
-  }
-}