@ephia/dova-sdk 1.0.0

package/dist/chunk-3LXZODL4.js

@@ -0,0 +1,886 @@
+import {
+  useEphiaInternal
+} from "./chunk-THNHRV2B.js";
+
+// src/devices/speechmike/constants.ts
+var SPEECHMIKE_VENDOR_IDS = {
+  PHILIPS: 2321
+};
+var SPEECHMIKE_CONFIG = {
+  BUTTON_DEBOUNCE_MS: 150,
+  WATCHDOG_INTERVAL_MS: 1e4,
+  DEVICE_OPERATION_TIMEOUT_MS: 2e3,
+  REQUEST_DEVICE_TIMEOUT_MS: 15e3,
+  LED_OPERATION_TIMEOUT_MS: 500
+};
+var LED_MODE = {
+  OFF: 0,
+  ON: 1,
+  ON_BRIGHT: 3
+};
+var DEFAULT_BUTTON_MAPPING = {
+  RECORD: "record.toggle",
+  PLAY: "play.toggle",
+  FORWARD: "seek.forward",
+  REWIND: "seek.backward",
+  F1: "audio.discard",
+  F1_A: "audio.discard",
+  F2: "audio.discard",
+  F2_B: "audio.discard",
+  F3: "audio.submit",
+  F3_C: "audio.submit",
+  F4: "audio.submit",
+  F4_D: "audio.submit",
+  INS: "agent.open",
+  OVR: "exam.new",
+  INS_OVR: "exam.new",
+  EOL: "resources.toggle",
+  EOL_PRIO: "resources.toggle"
+};
+var ALL_LEDS_OFF = {
+  0: 0,
+  1: 0,
+  2: 0,
+  3: 0,
+  4: 0,
+  5: 0,
+  6: 0,
+  7: 0,
+  8: 0,
+  9: 0
+};
+var DEFAULT_LED_INTENTS = {
+  off: { ...ALL_LEDS_OFF },
+  idle: { ...ALL_LEDS_OFF, 2: LED_MODE.ON_BRIGHT },
+  recording: { ...ALL_LEDS_OFF, 1: LED_MODE.ON_BRIGHT },
+  processing: { ...ALL_LEDS_OFF, 2: LED_MODE.ON, 4: LED_MODE.ON },
+  audio_available: {
+    ...ALL_LEDS_OFF,
+    6: LED_MODE.ON_BRIGHT,
+    7: LED_MODE.ON_BRIGHT,
+    8: LED_MODE.ON_BRIGHT,
+    9: LED_MODE.ON_BRIGHT
+  },
+  success: { ...ALL_LEDS_OFF, 2: 2 },
+  error: { ...ALL_LEDS_OFF, 3: 2 },
+  cancelled: { ...ALL_LEDS_OFF, 3: LED_MODE.ON_BRIGHT }
+};
+
+// src/devices/speechmike/dictation-support-loader.ts
+var runtimePromise = null;
+function resetDictationSupportLoaderForTests() {
+  runtimePromise = null;
+}
+function loadDictationSupport() {
+  if (runtimePromise) return runtimePromise;
+  const specifier = "dictation_support";
+  runtimePromise = import(
+    /* @vite-ignore */
+    specifier
+  ).then((mod) => {
+    if (!mod.DictationDeviceManager || !mod.ButtonEvent) {
+      throw new Error("dictation_support exports are incomplete");
+    }
+    return {
+      DictationDeviceManager: mod.DictationDeviceManager,
+      ButtonEvent: mod.ButtonEvent,
+      MotionEvent: mod.MotionEvent
+    };
+  }).catch((error) => {
+    runtimePromise = null;
+    throw Object.assign(new Error("dictation_support unavailable"), {
+      code: "speechmike.driver_missing",
+      cause: error
+    });
+  });
+  return runtimePromise;
+}
+
+// src/devices/speechmike/speechmike-audio-resolver.ts
+function scoreSpeechMikeAudioDevice(device) {
+  if (device.kind !== "audioinput") return 0;
+  const label = (device.label ?? "").toLowerCase();
+  let score = 0;
+  if (label.includes("speechmike")) score += 100;
+  if (label.includes("philips")) score += 60;
+  if (label.includes("dictation")) score += 40;
+  if (label.includes("microphone")) score += 10;
+  return score;
+}
+async function listAudioInputDevices() {
+  if (typeof navigator === "undefined" || !navigator.mediaDevices?.enumerateDevices) {
+    return [];
+  }
+  const devices = await navigator.mediaDevices.enumerateDevices();
+  return devices.filter((device) => device.kind === "audioinput");
+}
+async function resolveSpeechMikeAudioInput(options) {
+  if (typeof navigator === "undefined" || !navigator.mediaDevices) return null;
+  let permissionStream = null;
+  if (options?.requestPermission) {
+    permissionStream = await navigator.mediaDevices.getUserMedia({ audio: true });
+  }
+  try {
+    const inputs = await listAudioInputDevices();
+    const matches = inputs.map((device) => ({
+      deviceId: device.deviceId,
+      label: device.label,
+      score: scoreSpeechMikeAudioDevice(device),
+      raw: device
+    })).filter((match) => match.score > 0).sort((a, b) => b.score - a.score);
+    return matches[0] ?? null;
+  } finally {
+    permissionStream?.getTracks().forEach((track) => track.stop());
+  }
+}
+
+// src/devices/speechmike/speechmike-button-router.ts
+var SpeechMikeButtonRouter = class {
+  constructor(buttonEnum, mapping = {}, debounceMs = SPEECHMIKE_CONFIG.BUTTON_DEBOUNCE_MS) {
+    this.buttonEnum = buttonEnum;
+    this.debounceMs = debounceMs;
+    this.mapping = mergeButtonMapping(mapping);
+  }
+  buttonEnum;
+  debounceMs;
+  lastEventTime = 0;
+  processedEvents = /* @__PURE__ */ new Set();
+  mapping;
+  setMapping(mapping) {
+    this.mapping = mergeButtonMapping(mapping);
+  }
+  parse(bitMask) {
+    const now = Date.now();
+    const buttons = /* @__PURE__ */ new Set();
+    for (const value of Object.values(this.buttonEnum)) {
+      const numeric = Number(value);
+      if (Number.isNaN(numeric)) continue;
+      if (bitMask & numeric) {
+        const name = this.buttonEnum[numeric];
+        if (name) buttons.add(name);
+      }
+    }
+    if (buttons.size === 0) {
+      return { buttons, actions: [], rawBitMask: bitMask };
+    }
+    if (now - this.lastEventTime < this.debounceMs) return null;
+    const eventKey = `${[...buttons].join(",")}_${Math.floor(now / this.debounceMs)}`;
+    if (this.processedEvents.has(eventKey)) return null;
+    this.processedEvents.add(eventKey);
+    if (typeof window !== "undefined") {
+      window.setTimeout(() => this.processedEvents.delete(eventKey), 1e3);
+    }
+    this.lastEventTime = now;
+    const actions = [...buttons].map((button) => this.mapping[button] ?? "none").filter((action) => action !== "none");
+    return { buttons, actions, rawBitMask: bitMask };
+  }
+};
+function mergeButtonMapping(mapping) {
+  const merged = { ...DEFAULT_BUTTON_MAPPING };
+  for (const [button, action] of Object.entries(mapping)) {
+    if (action !== void 0) merged[button] = action;
+  }
+  return merged;
+}
+
+// src/devices/speechmike/browser.ts
+function isBrowser() {
+  return typeof window !== "undefined" && typeof navigator !== "undefined";
+}
+function getNavigatorHid() {
+  if (!isBrowser()) return null;
+  return navigator.hid ?? null;
+}
+function createTimeoutError(operation, timeoutMs) {
+  return new Error(`${operation} timeout after ${timeoutMs}ms`);
+}
+function withTimeout(promise, timeoutMs, operation) {
+  if (typeof window === "undefined") return promise;
+  let timeoutId = null;
+  return Promise.race([
+    promise.finally(() => {
+      if (timeoutId !== null) window.clearTimeout(timeoutId);
+    }),
+    new Promise((_, reject) => {
+      timeoutId = window.setTimeout(() => {
+        reject(createTimeoutError(operation, timeoutMs));
+      }, timeoutMs);
+    })
+  ]);
+}
+function matchesSpeechMikeIdentity(device) {
+  const productName = device.productName?.toLowerCase() ?? "";
+  const manufacturerName = device.manufacturerName?.toLowerCase() ?? "";
+  return productName.includes("speechmike") || productName.includes("philips") || manufacturerName.includes("philips");
+}
+
+// src/devices/speechmike/speechmike-led-controller.ts
+function isLedCapableDevice(device) {
+  if (!device || typeof device !== "object") return false;
+  return "setLed" in device || "setLeds" in device;
+}
+var SpeechMikeLedController = class {
+  constructor(getDevice) {
+    this.getDevice = getDevice;
+  }
+  getDevice;
+  queue = Promise.resolve();
+  setIntent(intent) {
+    this.setBatchQueued(DEFAULT_LED_INTENTS[intent]);
+  }
+  setBatchQueued(states) {
+    this.queue = this.queue.catch(() => void 0).then(() => this.setBatch(states)).catch(() => void 0);
+  }
+  async setBatch(states) {
+    const device = this.getLedDevice();
+    if (!device) return;
+    if (typeof device.setLeds === "function") {
+      try {
+        await withTimeout(
+          device.setLeds(states),
+          SPEECHMIKE_CONFIG.LED_OPERATION_TIMEOUT_MS,
+          "setLeds"
+        );
+        return;
+      } catch {
+      }
+    }
+    await Promise.allSettled(
+      Object.entries(states).map(([index, mode]) => this.setLed(Number(index), mode))
+    );
+  }
+  async setLed(index, mode) {
+    const device = this.getLedDevice();
+    if (!device?.setLed) return false;
+    try {
+      await withTimeout(
+        device.setLed(index, mode),
+        SPEECHMIKE_CONFIG.LED_OPERATION_TIMEOUT_MS,
+        `setLed(${index})`
+      );
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  clear() {
+    this.setIntent("off");
+  }
+  getLedDevice() {
+    const device = this.getDevice();
+    return isLedCapableDevice(device) ? device : null;
+  }
+};
+
+// src/devices/speechmike/speechmike-device-manager.ts
+function toError(error, fallbackCode) {
+  if (error && typeof error === "object" && "code" in error) {
+    const code = String(error.code ?? fallbackCode);
+    const message = error instanceof Error ? error.message : String(error);
+    return { code, message };
+  }
+  return {
+    code: fallbackCode,
+    message: error instanceof Error ? error.message : String(error)
+  };
+}
+function toRecord(value) {
+  return value && typeof value === "object" ? value : null;
+}
+function getDeviceHidDevice(device) {
+  const maybeDevice = toRecord(device);
+  return maybeDevice?.hidDevice ?? null;
+}
+function sameHidDevice(a, b) {
+  if (!a || !b) return false;
+  return a === b;
+}
+function extractDeviceInfo(value) {
+  const record = toRecord(value);
+  if (!record) return null;
+  const productName = typeof record.productName === "string" ? record.productName : void 0;
+  const manufacturerName = typeof record.manufacturerName === "string" ? record.manufacturerName : void 0;
+  const vendorId = typeof record.vendorId === "number" ? record.vendorId : void 0;
+  const productId = typeof record.productId === "number" ? record.productId : void 0;
+  if (productName === void 0 && manufacturerName === void 0 && vendorId === void 0 && productId === void 0) {
+    return null;
+  }
+  return { productName, manufacturerName, vendorId, productId };
+}
+var SpeechMikeDeviceManager = class {
+  listeners = {
+    status: /* @__PURE__ */ new Set(),
+    device: /* @__PURE__ */ new Set(),
+    deviceInfo: /* @__PURE__ */ new Set(),
+    presence: /* @__PURE__ */ new Set(),
+    button: /* @__PURE__ */ new Set(),
+    error: /* @__PURE__ */ new Set()
+  };
+  loadRuntime;
+  initialButtonMapping;
+  manager = null;
+  router = null;
+  currentDevice = null;
+  currentDeviceInfo = null;
+  status = "idle";
+  physicallyPresent = false;
+  initialized = false;
+  disposed = false;
+  reconnectLock = false;
+  watchdogInterval = null;
+  onButtonEvent = (_device, bitMask) => {
+    const event = this.router?.parse(bitMask);
+    if (event) this.emit("button", event);
+  };
+  onDeviceConnected = (device) => {
+    void this.attachDevice(device, "sdk-connect");
+  };
+  onDeviceDisconnected = () => {
+    this.detachDevice("sdk-disconnect");
+  };
+  onMotionEvent = () => {
+  };
+  onHidConnect = (event) => {
+    void this.handleHidConnect(event);
+  };
+  onHidDisconnect = (event) => {
+    void this.handleHidDisconnect(event);
+  };
+  constructor(options = {}) {
+    this.loadRuntime = options.loadRuntime ?? loadDictationSupport;
+    this.initialButtonMapping = options.buttonMapping ?? {};
+  }
+  async initialize() {
+    if (this.disposed) return;
+    if (this.initialized) return;
+    this.initialized = true;
+    const hid = getNavigatorHid();
+    if (!hid) {
+      this.setStatus("unsupported");
+      return;
+    }
+    this.setStatus("initializing");
+    try {
+      const runtime = await this.loadRuntime();
+      if (this.disposed) return;
+      this.router = new SpeechMikeButtonRouter(runtime.ButtonEvent, this.initialButtonMapping);
+      const manager = new runtime.DictationDeviceManager();
+      this.manager = manager;
+      manager.addButtonEventListener?.(this.onButtonEvent);
+      manager.addDeviceConnectedEventListener?.(this.onDeviceConnected);
+      manager.addDeviceDisconnectedEventListener?.(this.onDeviceDisconnected);
+      manager.addMotionEventListener?.(this.onMotionEvent);
+      hid.addEventListener("connect", this.onHidConnect);
+      hid.addEventListener("disconnect", this.onHidDisconnect);
+      if (manager.init) {
+        await withTimeout(
+          manager.init(),
+          SPEECHMIKE_CONFIG.DEVICE_OPERATION_TIMEOUT_MS,
+          "speechmike.init"
+        );
+      }
+      await this.reconnect();
+      this.startWatchdog();
+    } catch (error) {
+      const err = toError(error, "speechmike.initialize_failed");
+      this.emit("error", err);
+      this.setStatus(err.code === "speechmike.driver_missing" ? "driver_missing" : "error");
+    }
+  }
+  async requestAuthorization() {
+    await this.initialize();
+    if (this.disposed) return;
+    if (!this.manager) {
+      const error = {
+        code: "speechmike.manager_unavailable",
+        message: "SpeechMike manager is not initialized"
+      };
+      this.emit("error", error);
+      throw new Error(error.message);
+    }
+    this.setStatus("authorization_required");
+    try {
+      await withTimeout(
+        this.manager.requestDevice(),
+        SPEECHMIKE_CONFIG.REQUEST_DEVICE_TIMEOUT_MS,
+        "speechmike.requestDevice"
+      );
+      const device = this.getManagerDevices()[0] ?? null;
+      if (!device) {
+        this.setStatus("error");
+        throw new Error("No SpeechMike device returned after authorization");
+      }
+      await this.attachDevice(device, "user-grant");
+    } catch (error) {
+      const err = toError(error, "speechmike.authorization_failed");
+      this.emit("error", err);
+      this.setStatus("present_unauthorized");
+      throw error;
+    }
+  }
+  async reconnect() {
+    if (this.reconnectLock || this.disposed) return;
+    this.reconnectLock = true;
+    this.setStatus(this.currentDevice ? "recovering" : "restoring");
+    try {
+      const device = this.getManagerDevices()[0] ?? null;
+      if (device) {
+        await this.attachDevice(device, "reconnect");
+        return;
+      }
+      const present = await this.detectPhysicalPresence();
+      this.setPhysicallyPresent(present);
+      this.detachDevice(present ? "present-unauthorized" : "not-present", {
+        status: present ? "present_unauthorized" : "not_present"
+      });
+    } catch (error) {
+      const err = toError(error, "speechmike.reconnect_failed");
+      this.emit("error", err);
+      this.setStatus("error");
+    } finally {
+      this.reconnectLock = false;
+    }
+  }
+  dispose() {
+    this.disposed = true;
+    if (this.watchdogInterval !== null && typeof window !== "undefined") {
+      window.clearInterval(this.watchdogInterval);
+      this.watchdogInterval = null;
+    }
+    const hid = getNavigatorHid();
+    hid?.removeEventListener("connect", this.onHidConnect);
+    hid?.removeEventListener("disconnect", this.onHidDisconnect);
+    this.manager?.removeButtonEventListener?.(this.onButtonEvent);
+    this.manager?.removeDeviceConnectedEventListener?.(this.onDeviceConnected);
+    this.manager?.removeDeviceDisconnectedEventListener?.(this.onDeviceDisconnected);
+    this.manager?.removeMotionEventListener?.(this.onMotionEvent);
+    this.manager?.disconnect?.();
+    this.currentDevice = null;
+    this.currentDeviceInfo = null;
+    this.manager = null;
+    this.router = null;
+    this.initialized = false;
+    this.emit("device", null);
+    this.emit("deviceInfo", null);
+  }
+  getCurrentDevice() {
+    return this.currentDevice;
+  }
+  getStatus() {
+    return this.status;
+  }
+  getPhysicallyPresent() {
+    return this.physicallyPresent;
+  }
+  getDeviceInfo() {
+    return this.currentDeviceInfo;
+  }
+  setButtonMapping(mapping) {
+    this.router?.setMapping(mapping);
+  }
+  on(event, cb) {
+    this.listeners[event].add(cb);
+    return () => {
+      this.listeners[event].delete(cb);
+    };
+  }
+  async attachDevice(device, _cause) {
+    if (this.disposed) return;
+    this.currentDevice = device;
+    this.setPhysicallyPresent(true);
+    this.currentDeviceInfo = await this.resolveDeviceInfo(device);
+    this.emit("device", device);
+    this.emit("deviceInfo", this.currentDeviceInfo);
+    this.setStatus("connected");
+  }
+  detachDevice(_cause, options = {}) {
+    this.currentDevice = null;
+    this.currentDeviceInfo = null;
+    this.emit("device", null);
+    this.emit("deviceInfo", null);
+    this.setStatus(options.status ?? "disconnected");
+  }
+  async handleHidConnect(event) {
+    if (this.disposed) return;
+    const present = await this.detectPhysicalPresence();
+    this.setPhysicallyPresent(present);
+    if (!present) return;
+    const devices = this.getManagerDevices();
+    const connectedHidDevice = event.device;
+    const match = devices.find((device) => sameHidDevice(getDeviceHidDevice(device), connectedHidDevice)) ?? devices[0] ?? null;
+    if (match) {
+      await this.attachDevice(match, "hid-connect");
+    } else {
+      this.setStatus("present_unauthorized");
+    }
+  }
+  async handleHidDisconnect(event) {
+    if (this.disposed) return;
+    const currentHidDevice = getDeviceHidDevice(this.currentDevice);
+    if (sameHidDevice(currentHidDevice, event.device)) {
+      this.detachDevice("hid-disconnect");
+    }
+    this.setPhysicallyPresent(await this.detectPhysicalPresence());
+  }
+  startWatchdog() {
+    if (this.watchdogInterval !== null || typeof window === "undefined") return;
+    this.watchdogInterval = window.setInterval(() => {
+      void this.watchdogTick();
+    }, SPEECHMIKE_CONFIG.WATCHDOG_INTERVAL_MS);
+  }
+  async watchdogTick() {
+    if (this.reconnectLock || this.disposed) return;
+    this.reconnectLock = true;
+    try {
+      const present = await this.detectPhysicalPresence();
+      this.setPhysicallyPresent(present);
+      if (!this.currentDevice && present) {
+        const device = this.getManagerDevices()[0] ?? null;
+        if (device) {
+          await this.attachDevice(device, "watchdog-restore");
+        } else {
+          this.setStatus("present_unauthorized");
+        }
+      } else if (this.currentDevice && !present) {
+        this.detachDevice("watchdog-absent", { status: "disconnected" });
+      }
+    } finally {
+      this.reconnectLock = false;
+    }
+  }
+  async detectPhysicalPresence() {
+    const hid = getNavigatorHid();
+    if (hid) {
+      try {
+        const devices = await hid.getDevices();
+        if (devices.some(matchesSpeechMikeIdentity)) return true;
+      } catch {
+      }
+    }
+    try {
+      const devices = await navigator.mediaDevices?.enumerateDevices?.();
+      return !!devices?.some((device) => {
+        const label = (device.label ?? "").toLowerCase();
+        return device.kind === "audioinput" && (label.includes("speechmike") || label.includes("philips") || label.includes("dictation"));
+      });
+    } catch {
+      return false;
+    }
+  }
+  async resolveDeviceInfo(device) {
+    const fromDevice = extractDeviceInfo(device);
+    if (fromDevice) return fromDevice;
+    const hidDevice = getDeviceHidDevice(device);
+    const fromHid = extractDeviceInfo(hidDevice);
+    if (fromHid) return fromHid;
+    try {
+      const info = await this.manager?.getDeviceInfo?.(device);
+      return extractDeviceInfo(info);
+    } catch {
+      return null;
+    }
+  }
+  getManagerDevices() {
+    const devices = this.manager?.getDevices?.() ?? [];
+    return Array.isArray(devices) ? devices : [];
+  }
+  setStatus(status) {
+    if (this.status === status) return;
+    this.status = status;
+    this.emit("status", status);
+  }
+  setPhysicallyPresent(present) {
+    if (this.physicallyPresent === present) return;
+    this.physicallyPresent = present;
+    this.emit("presence", present);
+  }
+  emit(event, payload) {
+    for (const listener of this.listeners[event]) {
+      listener(payload);
+    }
+  }
+};
+
+// src/devices/speechmike/react/EphiaSpeechMikeProvider.tsx
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+
+// src/devices/speechmike/react/EphiaSpeechMikeContext.ts
+import { createContext } from "react";
+var FALLBACK_EPHIA_SPEECHMIKE_STATE = {
+  status: { hid: "unsupported", audio: "idle" },
+  device: null,
+  deviceInfo: null,
+  physicallyPresent: false,
+  audioInputDeviceId: null,
+  audioInputDeviceLabel: null,
+  pressedButtons: /* @__PURE__ */ new Set(),
+  lastButton: null,
+  lastAction: null,
+  error: null
+};
+var EphiaSpeechMikeContext = createContext(null);
+
+// src/devices/speechmike/react/EphiaSpeechMikeProvider.tsx
+import { jsx } from "react/jsx-runtime";
+var INITIAL_STATE = {
+  status: { hid: "idle", audio: "idle" },
+  device: null,
+  deviceInfo: null,
+  physicallyPresent: false,
+  audioInputDeviceId: null,
+  audioInputDeviceLabel: null,
+  pressedButtons: /* @__PURE__ */ new Set(),
+  lastButton: null,
+  lastAction: null,
+  error: null
+};
+function EphiaSpeechMikeProvider({
+  children,
+  enabled = true,
+  autoConnect = true,
+  preferAudioInput = true,
+  requestAudioPermissionOnInit = false,
+  ledSync = true,
+  initialLedIntent = "idle",
+  buttonMapping,
+  onAction,
+  onError,
+  onStatusChange
+}) {
+  const internal = useEphiaInternal();
+  const managerRef = useRef(null);
+  const ledRef = useRef(null);
+  const onActionRef = useRef(onAction);
+  const onErrorRef = useRef(onError);
+  const onStatusChangeRef = useRef(onStatusChange);
+  const ledSyncRef = useRef(ledSync);
+  const initialLedIntentRef = useRef(initialLedIntent);
+  const buttonMappingRef = useRef(buttonMapping);
+  const [state, setState] = useState(INITIAL_STATE);
+  onActionRef.current = onAction;
+  onErrorRef.current = onError;
+  onStatusChangeRef.current = onStatusChange;
+  ledSyncRef.current = ledSync;
+  initialLedIntentRef.current = initialLedIntent;
+  buttonMappingRef.current = buttonMapping;
+  const patchState = useCallback((patch) => {
+    setState((prev) => {
+      const next = typeof patch === "function" ? patch(prev) : {
+        ...prev,
+        ...patch
+      };
+      onStatusChangeRef.current?.(next);
+      return next;
+    });
+  }, []);
+  const setAudioStatus = useCallback(
+    (audio) => {
+      patchState((prev) => ({
+        ...prev,
+        status: { ...prev.status, audio }
+      }));
+    },
+    [patchState]
+  );
+  const resolveAndApplyAudioInput = useCallback(async () => {
+    if (!preferAudioInput) return;
+    setAudioStatus("resolving");
+    try {
+      const match = await resolveSpeechMikeAudioInput({
+        requestPermission: requestAudioPermissionOnInit
+      });
+      if (!match) {
+        patchState((prev) => ({
+          ...prev,
+          status: { ...prev.status, audio: "not_found" },
+          audioInputDeviceId: null,
+          audioInputDeviceLabel: null
+        }));
+        return;
+      }
+      internal.clientRef.current?.setPreferredAudioInputDeviceId(match.deviceId);
+      patchState((prev) => ({
+        ...prev,
+        status: { ...prev.status, audio: "ready" },
+        audioInputDeviceId: match.deviceId,
+        audioInputDeviceLabel: match.label,
+        error: null
+      }));
+    } catch (error) {
+      const err = {
+        code: "speechmike.audio_resolve_failed",
+        message: error instanceof Error ? error.message : String(error)
+      };
+      patchState((prev) => ({
+        ...prev,
+        status: { ...prev.status, audio: "error" },
+        error: err
+      }));
+      onErrorRef.current?.(err);
+    }
+  }, [
+    internal.clientRef,
+    patchState,
+    preferAudioInput,
+    requestAudioPermissionOnInit,
+    setAudioStatus
+  ]);
+  useEffect(() => {
+    if (!enabled) {
+      patchState(INITIAL_STATE);
+      return;
+    }
+    const manager = new SpeechMikeDeviceManager({
+      buttonMapping: buttonMappingRef.current
+    });
+    const led = new SpeechMikeLedController(() => manager.getCurrentDevice());
+    managerRef.current = manager;
+    ledRef.current = led;
+    const unsubs = [
+      manager.on("status", (hidStatus) => {
+        patchState((prev) => ({
+          ...prev,
+          status: { ...prev.status, hid: hidStatus }
+        }));
+      }),
+      manager.on("presence", (physicallyPresent) => {
+        patchState({ physicallyPresent });
+      }),
+      manager.on("deviceInfo", (deviceInfo) => {
+        patchState({ deviceInfo });
+      }),
+      manager.on("device", (device) => {
+        patchState({ device });
+        if (device && ledSyncRef.current) {
+          led.setIntent(initialLedIntentRef.current);
+        }
+        if (device && preferAudioInput) {
+          void resolveAndApplyAudioInput();
+        }
+      }),
+      manager.on("button", ({ buttons, actions }) => {
+        const buttonList = [...buttons];
+        const lastButton = buttonList[buttonList.length - 1] ?? null;
+        const lastAction = actions[actions.length - 1] ?? null;
+        patchState({
+          pressedButtons: new Set(buttons),
+          lastButton,
+          lastAction
+        });
+        for (const action of actions) {
+          onActionRef.current?.(action);
+        }
+      }),
+      manager.on("error", (error) => {
+        patchState({ error });
+        onErrorRef.current?.(error);
+      })
+    ];
+    if (autoConnect) {
+      manager.initialize().catch((error) => {
+        const err = {
+          code: "speechmike.initialize_failed",
+          message: error instanceof Error ? error.message : String(error)
+        };
+        patchState({ error: err });
+        onErrorRef.current?.(err);
+      });
+    }
+    return () => {
+      unsubs.forEach((unsub) => unsub());
+      led.clear();
+      manager.dispose();
+      managerRef.current = null;
+      ledRef.current = null;
+    };
+  }, [
+    autoConnect,
+    enabled,
+    patchState,
+    preferAudioInput,
+    resolveAndApplyAudioInput
+  ]);
+  useEffect(() => {
+    managerRef.current?.setButtonMapping(buttonMapping ?? {});
+  }, [buttonMapping]);
+  useEffect(() => {
+    if (!enabled || !preferAudioInput) return;
+    if (typeof navigator === "undefined" || !navigator.mediaDevices?.addEventListener) return;
+    const handler = () => {
+      void resolveAndApplyAudioInput();
+    };
+    navigator.mediaDevices.addEventListener("devicechange", handler);
+    return () => {
+      navigator.mediaDevices.removeEventListener("devicechange", handler);
+    };
+  }, [enabled, preferAudioInput, resolveAndApplyAudioInput]);
+  const value = useMemo(
+    () => ({
+      ...state,
+      isConnected: state.status.hid === "connected",
+      isReady: state.status.hid === "connected" && state.status.audio === "ready",
+      requestAuthorization: async () => {
+        if (!enabled) {
+          throw new Error("EphiaSpeechMikeProvider is disabled");
+        }
+        await managerRef.current?.requestAuthorization();
+        await resolveAndApplyAudioInput();
+      },
+      reconnect: async () => {
+        if (!enabled) return;
+        await managerRef.current?.reconnect();
+        await resolveAndApplyAudioInput();
+      },
+      setLedIntent: (intent) => {
+        ledRef.current?.setIntent(intent);
+      },
+      setButtonMapping: (mapping) => {
+        managerRef.current?.setButtonMapping(mapping);
+      }
+    }),
+    [enabled, resolveAndApplyAudioInput, state]
+  );
+  return /* @__PURE__ */ jsx(EphiaSpeechMikeContext.Provider, { value, children });
+}
+
+// src/devices/speechmike/react/useEphiaSpeechMike.ts
+import { useContext } from "react";
+function useEphiaSpeechMike() {
+  const ctx = useContext(EphiaSpeechMikeContext);
+  if (ctx) return ctx;
+  return {
+    ...FALLBACK_EPHIA_SPEECHMIKE_STATE,
+    isConnected: false,
+    isReady: false,
+    requestAuthorization: async () => {
+      throw new Error("EphiaSpeechMikeProvider not mounted");
+    },
+    reconnect: async () => {
+    },
+    setLedIntent: () => {
+    },
+    setButtonMapping: () => {
+    }
+  };
+}
+
+export {
+  SPEECHMIKE_VENDOR_IDS,
+  SPEECHMIKE_CONFIG,
+  LED_MODE,
+  DEFAULT_BUTTON_MAPPING,
+  DEFAULT_LED_INTENTS,
+  resetDictationSupportLoaderForTests,
+  loadDictationSupport,
+  scoreSpeechMikeAudioDevice,
+  listAudioInputDevices,
+  resolveSpeechMikeAudioInput,
+  SpeechMikeButtonRouter,
+  SpeechMikeLedController,
+  SpeechMikeDeviceManager,
+  FALLBACK_EPHIA_SPEECHMIKE_STATE,
+  EphiaSpeechMikeContext,
+  EphiaSpeechMikeProvider,
+  useEphiaSpeechMike
+};
+//# sourceMappingURL=chunk-3LXZODL4.js.map