@limrun/ui 0.18.2 → 0.20.0

package/dist/core/stream-options.d.ts

@@ -0,0 +1,62 @@
+import { AxSnapshot } from './ax-tree';
+import { AndroidElementTreeOptions, AxStatus } from './ax-fetcher';
+import { CameraCaptureInfo } from './camera';
+import { DuoState } from './duo';
+import { PlaybackStats } from './playback-stats';
+import { CameraStreamStats, MicrophoneState, RemoteControlConnectionState } from './stream-types';
+export type StreamDisplay = 'primary' | 'inner';
+export interface DeviceFrameSink {
+    /** The source is borrowed for this call. Copy it before returning if retaining a frame. */
+    present(source: CanvasImageSource, width: number, height: number, display: StreamDisplay): void;
+}
+export interface DeviceStreamState {
+    connection: RemoteControlConnectionState | 'idle';
+    videoReady: boolean;
+    controlReady: boolean;
+    duo: boolean;
+    duoState: DuoState | null;
+    duoError?: string;
+}
+export interface DeviceStreamTransport {
+    /** Return a fresh, unopened or open WebSocket for each attempt. The client owns its lifetime. */
+    connect(): WebSocket | Promise<WebSocket>;
+    /** Optional authoritative lifecycle check. Omit when the proxy cannot distinguish termination. */
+    isTerminated?(): Promise<boolean>;
+}
+/** Options that can change without replacing the connection. */
+export interface DeviceStreamLiveOptions {
+    /** Applied on the next connection attempt. */
+    openUrl?: string;
+    axPollIntervalMs?: number;
+    axMaxBackoffMs?: number;
+    androidElementTreeOptions?: AndroidElementTreeOptions;
+    autoReconnect?: boolean;
+    jitterBufferTargetMs?: number | null;
+    microphoneEnabled?: boolean;
+    inspectMode?: boolean | 'hover-only';
+    onStateChange?: (state: DeviceStreamState) => void;
+    onConnectionStateChange?: (state: RemoteControlConnectionState) => void;
+    onTerminated?: () => void;
+    onPlaybackStats?: (stats: PlaybackStats | null) => void;
+    onTrace?: (message: Record<string, unknown>) => void;
+    onAxSnapshotChange?: (snapshot: AxSnapshot | null) => void;
+    onAxStatusChange?: (status: AxStatus, error?: string) => void;
+    onCameraDemandChange?: (active: boolean, granted?: boolean, camera?: CameraCaptureInfo) => void;
+    onCameraStats?: (stats: CameraStreamStats | null) => void;
+    onMicrophoneStateChange?: (state: MicrophoneState) => void;
+}
+export type DeviceStreamOptions = DeviceStreamLiveOptions & {
+    sessionId?: string;
+    /** Required with proxy transports; direct instance URLs can supply the platform implicitly. */
+    platform?: 'ios' | 'android';
+    deviceModel?: 'iphone-duo';
+} & ({
+    url: string;
+    token: string;
+    transport?: never;
+} | {
+    transport: DeviceStreamTransport;
+    platform: 'ios' | 'android';
+    url?: never;
+    token?: never;
+});

package/dist/core/stream-types.d.ts

@@ -0,0 +1,66 @@
+/**
+ * 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;
+}
+/**
+ * Live outbound-camera quality snapshot. Derived from
+ * `RTCPeerConnection.getStats()` and rate-derived deltas, sampled
+ * once per second while the camera is sending. All fields optional:
+ * some browsers omit fields (Safari rarely reports
+ * `encoderImplementation`), and the first sample after camera start
+ * has no delta-derived numbers yet.
+ */
+export interface CameraStreamStats {
+    /** "H264", "HEVC"/"H265", "VP9", "VP8", "AV1", etc. (uppercased). */
+    codec?: string;
+    /** e.g. "VideoToolbox" (hw), "OpenH264" (sw), "ExternalEncoder". */
+    encoderImplementation?: string;
+    /**
+     * Browser-reported hardware-acceleration hint. Some Chromium
+     * versions expose this via `powerEfficientEncoder`; we mirror it
+     * here so consumers don't have to know the spec quirk.
+     */
+    hardwareAccelerated?: boolean;
+    /** Outbound encoded fps over the last sample window. */
+    framesPerSecond?: number;
+    /** Cumulative encoded frame count. */
+    framesEncoded?: number;
+    /** Outbound encoded bitrate (bits/s) over the last window. */
+    bitrateBps?: number;
+    /** Width/height the encoder is currently producing. */
+    width?: number;
+    height?: number;
+    /**
+     * One of `'none' | 'cpu' | 'bandwidth' | 'other'`. Mirrors
+     * Meet/Zoom's "limited by …" banners. Anything other than
+     * `'none'` means the encoder dropped resolution to keep up.
+     */
+    qualityLimitationReason?: string;
+    /** Round-trip time in milliseconds, from the matching RTCP. */
+    rttMs?: number;
+    /** Packet-loss percentage over the last sample window (0..100). */
+    packetsLostPct?: number;
+}
+export interface ScreenshotData {
+    dataUri: string;
+}
+export interface ImperativeKeyboardEvent {
+    type: 'keydown' | 'keyup';
+    code: string;
+    shiftKey?: boolean;
+    altKey?: boolean;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+}
+export type RemoteControlConnectionState = 'connecting' | 'connected' | 'reconnecting' | 'failed' | 'terminated';

package/dist/core/stream-utils.d.ts

@@ -0,0 +1,6 @@
+export declare const debugLog: (...args: any[]) => void;
+export declare const debugWarn: (...args: any[]) => void;
+export declare const safeInvoke: <Args extends unknown[]>(label: string, fn: ((...args: Args) => unknown) | undefined, ...args: Args) => void;
+export type DevicePlatform = 'ios' | 'android';
+export declare const detectPlatform: (url: string) => DevicePlatform;
+export declare const withAuthenticationToken: (url: string, token: string) => string;

package/dist/core/use-playback-stats.d.ts

@@ -0,0 +1,4 @@
+import { PlaybackStats } from './playback-stats';
+import { PlaybackConnection } from './playback-subscription';
+export type { PlaybackConnection } from './playback-subscription';
+export declare function usePlaybackStats(connection: PlaybackConnection | null, callback: ((stats: PlaybackStats | null) => void) | undefined, target: number | null | undefined): void;