@limrun/ui 0.9.0-rc.11 → 0.9.0-rc.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@limrun/ui",
-  "version": "0.9.0-rc.11",
+  "version": "0.9.0-rc.13",
   "publishConfig": {
     "access": "public"
   },

package/src/components/remote-control.tsx

@@ -140,6 +140,35 @@ interface RemoteControlProps {
    * @default 2000
    */
   axMaxBackoffMs?: number;
+
+  /**
+   * Optional outbound camera input.
+   *
+   * When provided, every video track on this `MediaStream` is forwarded
+   * up the same `RTCPeerConnection` that already carries the device
+   * screen downstream. On iOS instances, the limulator-side injector
+   * splices those frames into apps that use AVFoundation, so the user's
+   * browser camera becomes the iOS camera (`AVCaptureDevice.default(for:
+   * .video)`).
+   *
+   * Today this is only honored by iOS instances launched with the
+   * camera runtime; Android instances ignore it.
+   *
+   * Lifecycle expectations:
+   * - Pass `null`/`undefined` to skip outbound camera (default).
+   * - Pass a `MediaStream` obtained from
+   *   `navigator.mediaDevices.getUserMedia({ video: true })` (or any
+   *   other source — screen capture, virtual camera, etc.).
+   * - Changing the `MediaStream.id` triggers a connection restart so
+   *   the new track is included in the SDP offer. The reference itself
+   *   is allowed to be unstable across renders — we key the reconnect
+   *   on `id`, not object identity, so memoization isn't required.
+   * - Stopping the tracks (e.g. `track.stop()`) on the parent side is
+   *   sufficient to cut the outbound feed without restarting; the peer
+   *   connection just stops getting frames on that track. To fully
+   *   detach the track from the SDP, swap the prop to `null`.
+   */
+  cameraStream?: MediaStream | null;
 }
 
 interface ScreenshotData {
@@ -338,6 +367,7 @@ export const RemoteControl = forwardRef<RemoteControlHandle, RemoteControlProps>
       onAxStatusChange,
       axPollIntervalMs,
       axMaxBackoffMs,
+      cameraStream,
     }: RemoteControlProps,
     ref,
   ) => {
@@ -363,6 +393,13 @@ export const RemoteControl = forwardRef<RemoteControlHandle, RemoteControlProps>
     // Mirrored to a ref so stale closures in event handlers see the latest value.
     const autoReconnectRef = useRef(autoReconnect);
     autoReconnectRef.current = autoReconnect;
+    // Outbound camera input. Held in a ref so the deferred WebRTC setup
+    // path picks up the latest stream even if React re-renders between
+    // the connection effect firing and `startAttempt` reaching the
+    // `addTrack` step. Reconnects are keyed on `MediaStream.id`, not
+    // reference identity (see the connection effect's deps).
+    const cameraStreamRef = useRef<MediaStream | null>(cameraStream ?? null);
+    cameraStreamRef.current = cameraStream ?? null;
     const firstFrameShownRef = useRef(false);
     const pendingScreenshotResolversRef = useRef<
       Map<string, (value: ScreenshotData | PromiseLike<ScreenshotData>) => void>
@@ -1644,6 +1681,27 @@ export const RemoteControl = forwardRef<RemoteControlHandle, RemoteControlProps>
         peerConnection.addTransceiver('audio', { direction: 'recvonly' });
         const videoTransceiver = peerConnection.addTransceiver('video', { direction: 'recvonly' });
 
+        // Outbound camera input — splice the parent-provided MediaStream's
+        // video tracks into the same PC. `addTrack` creates an implicit
+        // sendonly transceiver and lands the track in the SDP offer; the
+        // limulator side picks it up via `peerConnection(_:didAdd:)` and
+        // forwards every frame into the camera-injector IOSurface ring.
+        // We pass the original MediaStream so the answerer can recover
+        // the parent stream id if it cares; today nothing does, but it
+        // costs nothing to be correct.
+        const outboundCamera = cameraStreamRef.current;
+        if (outboundCamera) {
+          for (const track of outboundCamera.getVideoTracks()) {
+            peerConnection.addTrack(track, outboundCamera);
+          }
+          debugLog(
+            'Attached outbound camera tracks:',
+            outboundCamera.getVideoTracks().length,
+            'streamId:',
+            outboundCamera.id,
+          );
+        }
+
         // 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,
@@ -2080,7 +2138,13 @@ export const RemoteControl = forwardRef<RemoteControlHandle, RemoteControlProps>
         stop();
         document.removeEventListener('visibilitychange', handleVisibilityChange);
       };
-    }, [url, token, propSessionId]);
+      // We key reconnects on `MediaStream.id` rather than the prop's
+      // object identity so callers don't have to memoize the stream —
+      // turning the camera on/off swaps the underlying MediaStream and
+      // its id, but rerenders that happen to re-create the parent's
+      // wrapping object don't trigger churn.
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [url, token, propSessionId, cameraStream?.id]);
 
     // Recompute the inspect-overlay geometry (container-local pixel rect of
     // the actually-rendered video content) from the current mapping context.