@limrun/ui 0.14.0-rc.5 → 0.14.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@limrun/ui",
-  "version": "0.14.0-rc.5",
+  "version": "0.14.1",
   "publishConfig": {
     "access": "public",
     "tag": "next"
@@ -14,51 +14,6 @@
       "import": "./dist/index.js",
       "require": "./dist/index.cjs"
     },
-    "./app-store-relay": {
-      "types": "./dist/app-store-relay/index.d.ts",
-      "import": "./dist/app-store-relay/index.js",
-      "require": "./dist/app-store-relay/index.cjs"
-    },
-    "./app-store-relay/react": {
-      "types": "./dist/app-store-relay/react.d.ts",
-      "import": "./dist/app-store-relay/react.js",
-      "require": "./dist/app-store-relay/react.cjs"
-    },
-    "./apple-credentials": {
-      "types": "./dist/apple-credentials/index.d.ts",
-      "import": "./dist/apple-credentials/index.js",
-      "require": "./dist/apple-credentials/index.cjs"
-    },
-    "./device-build": {
-      "types": "./dist/device-build/index.d.ts",
-      "import": "./dist/device-build/index.js",
-      "require": "./dist/device-build/index.cjs"
-    },
-    "./device-build/react": {
-      "types": "./dist/device-build/react.d.ts",
-      "import": "./dist/device-build/react.js",
-      "require": "./dist/device-build/react.cjs"
-    },
-    "./device-install": {
-      "types": "./dist/device-install/index.d.ts",
-      "import": "./dist/device-install/index.js",
-      "require": "./dist/device-install/index.cjs"
-    },
-    "./device-install/react": {
-      "types": "./dist/device-install/react.d.ts",
-      "import": "./dist/device-install/react.js",
-      "require": "./dist/device-install/react.cjs"
-    },
-    "./play-publish": {
-      "types": "./dist/play-publish/index.d.ts",
-      "import": "./dist/play-publish/index.js",
-      "require": "./dist/play-publish/index.cjs"
-    },
-    "./play-publish/react": {
-      "types": "./dist/play-publish/react.d.ts",
-      "import": "./dist/play-publish/react.js",
-      "require": "./dist/play-publish/react.cjs"
-    },
     "./package.json": "./package.json"
   },
   "scripts": {
@@ -76,23 +31,27 @@
     "directory": "packages/ui"
   },
   "license": "MIT",
+  "peerDependencies": {
+    "react": "^18.0.0 || ^19.0.0",
+    "react-dom": "^18.0.0 || ^19.0.0"
+  },
   "devDependencies": {
-    "@types/node-forge": "^1.3.14",
     "@types/react": "^19.1.12",
     "@types/react-dom": "^19.1.9",
     "@vitejs/plugin-react-swc": "^4.0.1",
+    "eslint": "^9.39.1",
     "jsdom": "^26.0.0",
     "path": "^0.12.7",
     "react": "^19.1.1",
     "react-dom": "^19.1.1",
+    "typescript": "5.8.3",
+    "typescript-eslint": "8.31.1",
     "vite": "^7.1.4",
     "vite-plugin-dts": "^4.5.4",
     "vite-plugin-lib-inject-css": "^2.2.2",
-    "vitest": "^2.1.9"
+    "vitest": "^3.2.6"
   },
   "dependencies": {
-    "@foxt/js-srp": "^0.0.3-patch2",
-    "clsx": "^2.1.1",
-    "node-forge": "^1.4.0"
+    "clsx": "^2.1.1"
   }
 }

package/src/components/remote-control.tsx

@@ -233,6 +233,45 @@ interface RemoteControlProps {
    * 16:9 / 1920×1080 — applies).
    */
   cameraAspect?: CameraAspect;
+
+  /**
+   * iOS only: when true, capture the user's microphone via
+   * `getUserMedia({ audio: true })` and stream it live into the
+   * simulator's mock microphone. Unlike the camera (which is
+   * demand-driven by apps inside the sim), the microphone is
+   * user-driven: flip this prop from a button in your UI. The
+   * component handles the browser permission prompt, the WebRTC
+   * track attach (no SDP renegotiation — the audio slot is
+   * pre-allocated) and the `microphoneStart`/`microphoneStop`
+   * signaling to the host. Progress and failures are reported via
+   * `onMicrophoneStateChange`. Ignored on Android instances.
+   */
+  microphoneEnabled?: boolean;
+
+  /**
+   * Fires whenever the live-microphone pipeline changes state:
+   * after an enable attempt resolves (granted or denied), when the
+   * host acknowledges or rejects the stream, when the browser
+   * revokes the track mid-stream, and on disable. Use it to render
+   * the mic button's on/off/error state.
+   */
+  onMicrophoneStateChange?: (state: MicrophoneState) => void;
+}
+
+/**
+ * Snapshot of the live-microphone pipeline, reported through
+ * `onMicrophoneStateChange`.
+ */
+export interface MicrophoneState {
+  /** True while the browser mic is captured and streaming to the sim. */
+  active: boolean;
+  /**
+   * Human-readable failure from the last attempt, if any (permission
+   * denied, no device, host rejection, ...).
+   */
+  error?: string;
+  /** Device label of the captured microphone, when available. */
+  label?: string;
 }
 
 /**
@@ -510,6 +549,8 @@ export const RemoteControl = forwardRef<RemoteControlHandle, RemoteControlProps>
       onCameraStats,
       cameraResolutionCap = 'auto',
       cameraAspect,
+      microphoneEnabled = false,
+      onMicrophoneStateChange,
     }: RemoteControlProps,
     ref,
   ) => {
@@ -594,6 +635,28 @@ export const RemoteControl = forwardRef<RemoteControlHandle, RemoteControlProps>
       packetsSent?: number;
       packetsLost?: number;
     } | null>(null);
+    // User-driven outbound microphone state (iOS only). Unlike the
+    // camera, the mic is toggled by the `microphoneEnabled` prop; the
+    // track rides a pre-allocated sendonly audio transceiver so
+    // enabling/disabling is just a `replaceTrack`, plus a
+    // `microphoneStart`/`microphoneStop` WS signal so the host's
+    // audio state machine switches its source.
+    const microphoneEnabledRef = useRef(microphoneEnabled);
+    microphoneEnabledRef.current = microphoneEnabled;
+    const onMicrophoneStateChangeRef = useRef(onMicrophoneStateChange);
+    onMicrophoneStateChangeRef.current = onMicrophoneStateChange;
+    const outboundMicSenderRef = useRef<RTCRtpSender | null>(null);
+    const outboundMicStreamRef = useRef<MediaStream | null>(null);
+    // Bumped by detach and teardown so an attach suspended on an await
+    // (the getUserMedia prompt) detects it was superseded and bails.
+    const micGenerationRef = useRef(0);
+    // Serializes attach/detach work so their awaits (replaceTrack on the
+    // shared sender) can never interleave and undo each other's effects.
+    const micOpQueueRef = useRef<Promise<void>>(Promise.resolve());
+    // Correlates the in-flight `microphoneStart` with its result so a
+    // host-side rejection (e.g. no loopback device on the node) can
+    // tear the capture back down and surface the error.
+    const micStartPendingIdRef = useRef<string | null>(null);
     const firstFrameShownRef = useRef(false);
     const pendingScreenshotResolversRef = useRef<
       Map<string, (value: ScreenshotData | PromiseLike<ScreenshotData>) => void>
@@ -625,6 +688,14 @@ export const RemoteControl = forwardRef<RemoteControlHandle, RemoteControlProps>
       pointerId1: number;
     };
     const twoFingerStateRef = useRef<TwoFingerState | null>(null);
+    // Wheel-scroll drag state; lives for a single synthesized gesture.
+    const wheelStateRef = useRef<{ pos: PointerGeometry; endTimer: number } | null>(null);
+    // Latest wheel handlers, so the once-attached native listener and the
+    // pointer machinery always call the current render's closures.
+    const wheelCallbacksRef = useRef<{ handle: (event: WheelEvent) => void; end: () => void }>({
+      handle: () => {},
+      end: () => {},
+    });
 
     // Hover point for rendering two-finger indicators when Alt is held.
     // Only computed/set when Alt is held to avoid unnecessary re-renders.
@@ -726,8 +797,8 @@ export const RemoteControl = forwardRef<RemoteControlHandle, RemoteControlProps>
     };
 
     // Pointer ID used by inspect-driven taps. Distinct from human pointers
-    // (-1 mouse, -2 alt-mirror) and our touch identifiers so they never
-    // interfere with an in-progress drag.
+    // (-1 mouse, -2 alt-mirror), the synthesized wheel finger (-3), and our
+    // touch identifiers so they never interfere with an in-progress drag.
     const AX_TAP_POINTER_ID = -10;
 
     // Send a down+up tap at a viewport-space (clientX/Y) position. The point
@@ -791,6 +862,8 @@ export const RemoteControl = forwardRef<RemoteControlHandle, RemoteControlProps>
     // Fixed pointer IDs for Alt-simulated two-finger gestures
     const ALT_POINTER_ID_PRIMARY = -1;
     const ALT_POINTER_ID_MIRROR = -2;
+    // Synthesized finger for wheel-scroll drags.
+    const WHEEL_POINTER_ID = -3;
 
     // Helper to send a single-touch control message (used by both single-finger and Android two-finger paths)
     const sendSingleTouch = (
@@ -848,6 +921,11 @@ export const RemoteControl = forwardRef<RemoteControlHandle, RemoteControlProps>
 
       switch (eventType) {
         case 'down':
+          // A real pointer going down takes over from any synthesized
+          // wheel-scroll finger, so the tap isn't sent as a second finger.
+          if (pointerId !== WHEEL_POINTER_ID) {
+            wheelCallbacksRef.current.end();
+          }
           // For multi-touch: use ACTION_DOWN for first pointer, ACTION_POINTER_DOWN for additional pointers
           const currentPointerCount = activePointers.current.size;
           action = currentPointerCount === 0 ? AMOTION_EVENT.ACTION_DOWN : AMOTION_EVENT.ACTION_POINTER_DOWN;
@@ -1136,6 +1214,12 @@ export const RemoteControl = forwardRef<RemoteControlHandle, RemoteControlProps>
         p1: { x: x1, y: y1, id: pointerId1 },
       });
 
+      if (eventType === 'down') {
+        // A real two-finger gesture takes over from any synthesized
+        // wheel-scroll finger.
+        wheelCallbacksRef.current.end();
+      }
+
       if (platform === 'ios') {
         // iOS: use special two-finger message (type=18)
         const action =
@@ -1491,6 +1575,130 @@ export const RemoteControl = forwardRef<RemoteControlHandle, RemoteControlProps>
       }
     };
 
+    // Mouse wheel / trackpad scrolling over the stream scrolls inside the
+    // simulator. iOS has no scroll wheel, so we fake a finger: press down
+    // where the cursor is, drag it as wheel events come in, lift when they
+    // stop. If the fake finger reaches the screen edge before the user stops
+    // scrolling, lift and press again to keep going.
+    const WHEEL_END_QUIET_MS = 150;
+    const endWheelGesture = () => {
+      const state = wheelStateRef.current;
+      if (!state) return;
+      window.clearTimeout(state.endTimer);
+      applyPointerEvent(WHEEL_POINTER_ID, 'up', state.pos);
+      wheelStateRef.current = null;
+    };
+    const handleWheel = (event: WheelEvent) => {
+      // Trackpad pinches arrive as ctrl+wheel; don't turn them into scrolls.
+      if (event.ctrlKey) return;
+      // If the user is already touching/dragging (or holding Alt for the
+      // two-finger gesture), let that win - don't add a second fake finger.
+      if (isAltHeldRef.current || twoFingerStateRef.current) return;
+      const pointerCount = activePointers.current.size;
+      if (pointerCount > 1 || (pointerCount === 1 && !activePointers.current.has(WHEEL_POINTER_ID))) return;
+
+      const ctx = computeVideoMappingContext();
+      if (!ctx) return;
+      // Outside the rendered video (frame, letterbox) let the page scroll.
+      const relativeX = event.clientX - ctx.videoRect.left - ctx.offsetX;
+      const relativeY = event.clientY - ctx.videoRect.top - ctx.offsetY;
+      if (relativeX < 0 || relativeX > ctx.actualWidth || relativeY < 0 || relativeY > ctx.actualHeight) {
+        return;
+      }
+      const anchor = mapClientPointToVideo(ctx, event.clientX, event.clientY);
+      if (!anchor) return;
+      event.preventDefault();
+
+      // deltaMode: 0=pixels, 1=lines, 2=pages. Deltas are CSS pixels; convert
+      // to stream pixels so a tick scrolls the same visual distance at any
+      // window size.
+      const scaleX =
+        (event.deltaMode === 1 ? 16
+        : event.deltaMode === 2 ? ctx.actualWidth
+        : 1) *
+        (ctx.videoWidth / ctx.actualWidth);
+      const scaleY =
+        (event.deltaMode === 1 ? 16
+        : event.deltaMode === 2 ? ctx.actualHeight
+        : 1) *
+        (ctx.videoHeight / ctx.actualHeight);
+      const dx = -event.deltaX * scaleX;
+      const dy = -event.deltaY * scaleY;
+      const armEnd = (s: { endTimer: number }) => {
+        window.clearTimeout(s.endTimer);
+        s.endTimer = window.setTimeout(endWheelGesture, WHEEL_END_QUIET_MS);
+      };
+      if (dx === 0 && dy === 0) {
+        // Some wheel events carry no movement (momentum tails); just keep
+        // the gesture alive.
+        if (wheelStateRef.current) armEnd(wheelStateRef.current);
+        return;
+      }
+
+      // Where to press the fake finger down: at the cursor, but nudged away
+      // from the screen edges so the drag has room to travel.
+      const pressPoint = (): PointerGeometry => ({
+        videoWidth: anchor.videoWidth,
+        videoHeight: anchor.videoHeight,
+        videoX:
+          Math.abs(dx) > Math.abs(dy) ?
+            Math.min(Math.max(anchor.videoX, anchor.videoWidth * 0.2), anchor.videoWidth * 0.8)
+          : anchor.videoX,
+        videoY:
+          Math.abs(dy) >= Math.abs(dx) ?
+            Math.min(Math.max(anchor.videoY, anchor.videoHeight * 0.2), anchor.videoHeight * 0.8)
+          : anchor.videoY,
+      });
+
+      const advance = (p: PointerGeometry): PointerGeometry => ({
+        ...p,
+        videoX: Math.min(Math.max(p.videoX + dx, 0), p.videoWidth),
+        videoY: Math.min(Math.max(p.videoY + dy, 0), p.videoHeight),
+      });
+
+      let state = wheelStateRef.current;
+      if (!state) {
+        const start = pressPoint();
+        applyPointerEvent(WHEEL_POINTER_ID, 'down', start);
+        state = { pos: start, endTimer: 0 };
+        wheelStateRef.current = state;
+      } else {
+        window.clearTimeout(state.endTimer);
+      }
+
+      let pos = state.pos;
+      let next = advance(pos);
+      if (next.videoX === pos.videoX && next.videoY === pos.videoY) {
+        // Finger reached the screen edge: lift it, press again with room to
+        // travel, and move right away (a press that never moves would count
+        // as a tap).
+        applyPointerEvent(WHEEL_POINTER_ID, 'up', pos);
+        pos = pressPoint();
+        applyPointerEvent(WHEEL_POINTER_ID, 'down', pos);
+        next = advance(pos);
+      }
+      applyPointerEvent(WHEEL_POINTER_ID, 'move', next);
+      state.pos = next;
+      armEnd(state);
+    };
+    useEffect(() => {
+      wheelCallbacksRef.current = { handle: handleWheel, end: endWheelGesture };
+    });
+
+    // React attaches onWheel passively, so preventDefault (needed to keep the
+    // page from scrolling) requires a native non-passive listener. Cleanup
+    // lifts an in-flight synthesized finger before the channel goes away.
+    useEffect(() => {
+      const container = containerRef.current;
+      if (!container) return;
+      const listener = (event: WheelEvent) => wheelCallbacksRef.current.handle(event);
+      container.addEventListener('wheel', listener, { passive: false });
+      return () => {
+        wheelCallbacksRef.current.end();
+        container.removeEventListener('wheel', listener);
+      };
+    }, []);
+
     useEffect(() => {
       const handleKeyDown = (event: KeyboardEvent) => {
         if (event.key === 'Alt') {
@@ -1694,6 +1902,149 @@ export const RemoteControl = forwardRef<RemoteControlHandle, RemoteControlProps>
       stopMediaStream(stream);
     };
 
+    // Runs one attach/detach operation after all previously queued ones,
+    // so two operations' awaits never interleave on the shared sender (a
+    // stale detach could otherwise clear a fresh attach's track, or send
+    // `microphoneStop` after its `microphoneStart`).
+    const runMicOp = (op: () => Promise<void>): Promise<void> => {
+      const next = micOpQueueRef.current.then(op).catch((err) => {
+        debugWarn('microphone operation failed:', err);
+      });
+      micOpQueueRef.current = next;
+      return next;
+    };
+
+    // Capture the user's microphone and stream it to the simulator's
+    // mock microphone. Safe to call redundantly: bails when already
+    // attached, when the connection isn't up yet (the ICE-connected
+    // handler re-invokes it), or when the prop flipped off mid-prompt.
+    // Does NOT bump the generation: a redundant call (e.g. the ICE
+    // handler firing on both `connected` and `completed`) must not
+    // cancel an attach already in flight; only detach/teardown cancel.
+    const attachMicrophone = (): Promise<void> => {
+      if (platform !== 'ios') return Promise.resolve();
+      return runMicOp(() => attachMicrophoneOp());
+    };
+
+    const attachMicrophoneOp = async () => {
+      const generation = micGenerationRef.current;
+      const isCurrent = () => generation === micGenerationRef.current && microphoneEnabledRef.current;
+      const reportMicError = (error: string) => {
+        safeInvoke('onMicrophoneStateChange', onMicrophoneStateChangeRef.current, {
+          active: false,
+          error,
+        });
+      };
+      if (!isCurrent()) return;
+      const ws = wsRef.current;
+      const sender = outboundMicSenderRef.current;
+      if (!ws || ws.readyState !== WebSocket.OPEN || !sender) {
+        // Not connected yet — the post-connect hook retries while the
+        // prop is still on.
+        return;
+      }
+      if (outboundMicStreamRef.current) return;
+      if (!navigator.mediaDevices || typeof navigator.mediaDevices.getUserMedia !== 'function') {
+        // eslint-disable-next-line no-console
+        console.warn(
+          '[RemoteControl] navigator.mediaDevices.getUserMedia unavailable. ' +
+            'getUserMedia requires a secure context (https or http://localhost).',
+        );
+        reportMicError('Microphone capture requires a secure context (https)');
+        return;
+      }
+      let stream: MediaStream | null = null;
+      try {
+        stream = await navigator.mediaDevices.getUserMedia({ audio: true, video: false });
+      } catch (err) {
+        // eslint-disable-next-line no-console
+        console.warn('[RemoteControl] microphone getUserMedia denied/failed:', err);
+      }
+      if (!isCurrent()) {
+        if (stream) stopMediaStream(stream);
+        return;
+      }
+      if (!stream) {
+        reportMicError('Microphone permission denied or no device available');
+        return;
+      }
+      const audioTrack = stream.getAudioTracks()[0] ?? null;
+      if (!audioTrack) {
+        stopMediaStream(stream);
+        reportMicError('Captured stream has no audio track');
+        return;
+      }
+      try {
+        await sender.replaceTrack(audioTrack);
+      } catch (err) {
+        debugWarn('replaceTrack(audioTrack) failed:', err);
+        stopMediaStream(stream);
+        reportMicError('Failed to attach the microphone track to the connection');
+        return;
+      }
+      if (!isCurrent()) {
+        try {
+          await sender.replaceTrack(null);
+        } catch (err) {
+          debugWarn('replaceTrack(null) on stale mic attach failed:', err);
+        }
+        stopMediaStream(stream);
+        return;
+      }
+      outboundMicStreamRef.current = stream;
+      // If the browser revokes the track later (user clicks Stop in
+      // the tab's mic indicator, device unplugged, ...) tear down and
+      // tell the host, so the sim's mic goes back to silence instead
+      // of freezing on the last buffer.
+      audioTrack.onended = () => {
+        if (outboundMicStreamRef.current !== stream) return;
+        void detachMicrophone('microphone capture ended by the browser');
+      };
+      const id = `ui-mic-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+      micStartPendingIdRef.current = id;
+      ws.send(JSON.stringify({ type: 'microphoneStart', id }));
+      safeInvoke('onMicrophoneStateChange', onMicrophoneStateChangeRef.current, {
+        active: true,
+        label: audioTrack.label || undefined,
+      });
+    };
+
+    // Stop the live microphone: drop the track from the sender, stop
+    // the capture (turning the browser's mic indicator off) and tell
+    // the host to switch its audio source back to silence. Safe to
+    // call when nothing is attached.
+    const detachMicrophone = (error?: string): Promise<void> => {
+      // Bump synchronously (not on the queue) so an attach that is
+      // suspended on an await bails at its next checkpoint even while
+      // it still owns the queue.
+      ++micGenerationRef.current;
+      micStartPendingIdRef.current = null;
+      return runMicOp(async () => {
+        const sender = outboundMicSenderRef.current;
+        const stream = outboundMicStreamRef.current;
+        outboundMicStreamRef.current = null;
+        if (sender && stream) {
+          try {
+            await sender.replaceTrack(null);
+          } catch (err) {
+            debugWarn('replaceTrack(null) on mic detach failed:', err);
+          }
+        }
+        if (stream) stopMediaStream(stream);
+        const ws = wsRef.current;
+        if (stream && ws && ws.readyState === WebSocket.OPEN) {
+          const id = `ui-mic-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+          ws.send(JSON.stringify({ type: 'microphoneStop', id }));
+        }
+        if (stream || error) {
+          safeInvoke('onMicrophoneStateChange', onMicrophoneStateChangeRef.current, {
+            active: false,
+            ...(error !== undefined && { error }),
+          });
+        }
+      });
+    };
+
     // Translate the user-facing resolution cap into a
     // MediaTrackConstraints fragment we can feed `getUserMedia`
     // or `applyConstraints`. Always returns a 30 fps ceiling so
@@ -1845,6 +2196,22 @@ export const RemoteControl = forwardRef<RemoteControlHandle, RemoteControlProps>
       stopCameraStatsPoller();
       stopOutboundLocalStream();
       outboundCameraSenderRef.current = null;
+      // Same for the live microphone. No `microphoneStop` signal here —
+      // the WS is going away with the connection; if `microphoneEnabled`
+      // is still on, the post-reconnect hook re-attaches.
+      ++micGenerationRef.current;
+      micStartPendingIdRef.current = null;
+      if (outboundMicStreamRef.current) {
+        stopMediaStream(outboundMicStreamRef.current);
+        outboundMicStreamRef.current = null;
+        // The capture is gone; report it so consumers don't keep a stale
+        // `active: true` across drops (a re-attach after reconnect
+        // reports again).
+        safeInvoke('onMicrophoneStateChange', onMicrophoneStateChangeRef.current, {
+          active: false,
+        });
+      }
+      outboundMicSenderRef.current = null;
       // A scheduled cursor flush would otherwise call setState on a
       // teardown component once the next frame runs.
       if (cursorRafIdRef.current !== undefined) {
@@ -2162,6 +2529,18 @@ export const RemoteControl = forwardRef<RemoteControlHandle, RemoteControlProps>
           : null;
         outboundCameraSenderRef.current = outboundCameraTransceiver?.sender ?? null;
 
+        // Same pre-allocation for the live microphone: a sendonly audio
+        // slot negotiated once at connection setup, so toggling the mic
+        // later is just `replaceTrack` — no SDP renegotiation. iOS only,
+        // like the camera.
+        const outboundMicTransceiver =
+          platform === 'ios' ?
+            peerConnection.addTransceiver('audio', {
+              direction: 'sendonly',
+            })
+          : null;
+        outboundMicSenderRef.current = outboundMicTransceiver?.sender ?? null;
+
         // As hardware encoder, we use H265 for iOS and VP9 for Android.
         // We make sure these two are the first ones in the list.
         // If not, the fallback is H264 which is also hardware accelerated, although not as good,
@@ -2383,6 +2762,11 @@ export const RemoteControl = forwardRef<RemoteControlHandle, RemoteControlProps>
           updateStatus('ICE state: ' + iceState);
           if (iceState === 'connected' || iceState === 'completed') {
             clearIceDisconnectedGrace();
+            // Re-attach the live microphone across reconnects (or apply a
+            // prop that was flipped on before the connection was up).
+            if (microphoneEnabledRef.current && !outboundMicStreamRef.current) {
+              void attachMicrophone();
+            }
             return;
           }
           if (iceState === 'failed') {
@@ -2780,6 +3164,22 @@ export const RemoteControl = forwardRef<RemoteControlHandle, RemoteControlProps>
               startCameraStatsPoller();
               break;
             }
+            case 'microphoneStartResult': {
+              if (micStartPendingIdRef.current === null || message.id !== micStartPendingIdRef.current) {
+                break;
+              }
+              micStartPendingIdRef.current = null;
+              if (typeof message.error === 'string') {
+                // Host rejected the stream (e.g. no loopback device
+                // assigned on the node). Tear the capture back down so
+                // the browser's mic indicator doesn't stay lit for a
+                // stream nobody hears.
+                // eslint-disable-next-line no-console
+                console.warn('[RemoteControl] microphoneStart rejected by host:', message.error);
+                void detachMicrophone(message.error);
+              }
+              break;
+            }
             case 'terminateAppResult':
               if (typeof message.id !== 'string') {
                 debugWarn('Received invalid terminateApp result message:', message);
@@ -2906,6 +3306,18 @@ export const RemoteControl = forwardRef<RemoteControlHandle, RemoteControlProps>
       }
     }, [cameraAspect]);
 
+    // Drive the live microphone from the `microphoneEnabled` prop.
+    // When flipped on before the connection is up, attachMicrophone
+    // bails and the ICE-connected handler picks it up instead.
+    useEffect(() => {
+      if (microphoneEnabled) {
+        void attachMicrophone();
+      } else {
+        void detachMicrophone();
+      }
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [microphoneEnabled]);
+
     useEffect(() => {
       // Reset video loaded state when connection params change
       setVideoLoaded(false);

package/src/index.ts

@@ -1,5 +1,5 @@
 export { RemoteControl } from './components/remote-control';
-export type { RemoteControlHandle } from './components/remote-control';
+export type { RemoteControlHandle, MicrophoneState } from './components/remote-control';
 
 // Accessibility / inspect-mode types and helpers. Exported so customers can
 // build their own side panels, search UIs, or agent-driven inspectors on top

package/vite.config.ts

@@ -11,15 +11,6 @@ export default defineConfig({
     lib: {
       entry: {
         index: resolve(__dirname, 'src/index.ts'),
-        'app-store-relay/index': resolve(__dirname, 'src/app-store-relay/index.ts'),
-        'app-store-relay/react': resolve(__dirname, 'src/app-store-relay/react.ts'),
-        'apple-credentials/index': resolve(__dirname, 'src/apple-credentials/index.ts'),
-        'device-build/index': resolve(__dirname, 'src/device-build/index.ts'),
-        'device-build/react': resolve(__dirname, 'src/device-build/react.ts'),
-        'device-install/index': resolve(__dirname, 'src/device-install/index.ts'),
-        'device-install/react': resolve(__dirname, 'src/device-install/react.ts'),
-        'play-publish/index': resolve(__dirname, 'src/play-publish/index.ts'),
-        'play-publish/react': resolve(__dirname, 'src/play-publish/react.ts'),
       },
       name: 'LimrunUI',
       formats: ['es', 'cjs'],