lecodes-sdk 2.2.7 → 2.2.8

package/dist/global.d.ts

@@ -58,6 +58,8 @@ declare global {
   const Material: typeof SDK.Material
   const MaterialHandle: typeof SDK.MaterialHandle
   const Mathf: typeof SDK.Mathf
+  const MediaStream: typeof SDK.MediaStream
+  const MediaStreamTrack: typeof SDK.MediaStreamTrack
   const Mesh: typeof SDK.Mesh
   const Model: typeof SDK.Model
   const MouseEnterEvent: typeof SDK.MouseEnterEvent
@@ -85,6 +87,15 @@ declare global {
   const QRScanner: typeof SDK.QRScanner
   const Quat: typeof SDK.Quat
   const REVERB_PRESETS: typeof SDK.REVERB_PRESETS
+  const RTCDataChannel: typeof SDK.RTCDataChannel
+  const RTCEventTarget: typeof SDK.RTCEventTarget
+  const RTCIceCandidate: typeof SDK.RTCIceCandidate
+  const RTCPeerConnection: typeof SDK.RTCPeerConnection
+  const RTCRtpReceiver: typeof SDK.RTCRtpReceiver
+  const RTCRtpSender: typeof SDK.RTCRtpSender
+  const RTCRtpTransceiver: typeof SDK.RTCRtpTransceiver
+  const RTCSessionDescription: typeof SDK.RTCSessionDescription
+  const RTCVideoView: typeof SDK.RTCVideoView
   const Ragdoll: typeof SDK.Ragdoll
   const Ray: typeof SDK.Ray
   const Replicated: typeof SDK.Replicated
@@ -193,6 +204,7 @@ declare global {
   const isRawCell: typeof SDK.isRawCell
   const localStorage: typeof SDK.localStorage
   const make: typeof SDK.make
+  const mediaDevices: typeof SDK.mediaDevices
   const openFilePicker: typeof SDK.openFilePicker
   const openURL: typeof SDK.openURL
   const packTile: typeof SDK.packTile
@@ -379,6 +391,9 @@ declare global {
   type MaterialDef = SDK.MaterialDef
   type MaterialHandle = SDK.MaterialHandle
   type MaterialParamValue = SDK.MaterialParamValue
+  type MediaStream = SDK.MediaStream
+  type MediaStreamConstraints = SDK.MediaStreamConstraints
+  type MediaStreamTrack = SDK.MediaStreamTrack
   type Mesh = SDK.Mesh
   type MeshDef = SDK.MeshDef
   type Model = SDK.Model
@@ -436,6 +451,25 @@ declare global {
   type PushStatus = SDK.PushStatus
   type QRScanner = SDK.QRScanner
   type Quat = SDK.Quat
+  type RTCConfiguration = SDK.RTCConfiguration
+  type RTCDataChannel = SDK.RTCDataChannel
+  type RTCDataChannelEvent = SDK.RTCDataChannelEvent
+  type RTCErrorEvent = SDK.RTCErrorEvent
+  type RTCEvent<T extends RTCEventTarget = RTCEventTarget> = SDK.RTCEvent<T>
+  type RTCEventListener<E> = SDK.RTCEventListener<E>
+  type RTCEventTarget = SDK.RTCEventTarget
+  type RTCIceCandidate = SDK.RTCIceCandidate
+  type RTCIceCandidateInit = SDK.RTCIceCandidateInit
+  type RTCMessageEvent = SDK.RTCMessageEvent
+  type RTCPeerConnection = SDK.RTCPeerConnection
+  type RTCPeerConnectionIceEvent = SDK.RTCPeerConnectionIceEvent
+  type RTCRtpReceiver = SDK.RTCRtpReceiver
+  type RTCRtpSender = SDK.RTCRtpSender
+  type RTCRtpTransceiver = SDK.RTCRtpTransceiver
+  type RTCSessionDescription = SDK.RTCSessionDescription
+  type RTCTrackEvent = SDK.RTCTrackEvent
+  type RTCVideoView = SDK.RTCVideoView
+  type RTCVideoViewOptions = SDK.RTCVideoViewOptions
   type Ragdoll = SDK.Ragdoll
   type RagdollActivateOptions = SDK.RagdollActivateOptions
   type RagdollDeactivateOptions = SDK.RagdollDeactivateOptions

package/dist/types/inject.d.ts

@@ -74,6 +74,7 @@ export { Geolocation, type GeoPosition, type GeoOptions, type GeoWatch } from ".
 export { MapView, type MapOptions, type MapStyle, type MapStyleName, type MapCamera, type MapTap, type LngLat, type CameraMove, type FitOptions, type MapPaddingValues, type MarkerItem, type MarkerTap, type MarkerLayer, type MarkerLayerOptions, type LineLayer, type LineLayerOptions, type UserLocationOptions, } from "./plugins/gen/map/sdk/map";
 export { Push, type PushPayload, type PushStatus, type PushRegisterOptions, type PushEvent } from "./plugins/gen/push/sdk/push";
 export { Browser, WebView, type BrowserOpenOptions, type WebViewParams, type WebViewEvents } from "./plugins/gen/browser/sdk/browser";
+export { RTCPeerConnection, MediaStream, MediaStreamTrack, RTCDataChannel, RTCRtpSender, RTCRtpReceiver, RTCRtpTransceiver, RTCSessionDescription, RTCIceCandidate, RTCEventTarget, mediaDevices, RTCVideoView, type RTCConfiguration, type RTCVideoViewOptions, type MediaStreamConstraints, type RTCIceCandidateInit, type RTCPeerConnectionIceEvent, type RTCTrackEvent, type RTCDataChannelEvent, type RTCMessageEvent, type RTCErrorEvent, type RTCEvent, type RTCEventListener, } from "./plugins/gen/webrtc/sdk/webrtc";
 export { Service } from "./plugins/service";
 export { defineScene, use, ref, make, SceneHandle } from "./scene/defineScene";
 export { defineMaterial, MaterialHandle } from "./scene/material";

package/dist/types/plugins/gen/webrtc/sdk/webrtc.RtcMedia.gen.d.ts

@@ -0,0 +1,55 @@
+import { ServiceChannel } from "../../../../plugin";
+import type { AudioOutput, DeviceInfo, MediaConstraints, RtcMediaEvents, RtcMediaParams, StreamInfo, TrackSettings, VideoConstraints } from "../contract";
+/** What the halves register under. */
+export declare const NAME = "rtcMedia";
+/** The contract's version: the highest `@since` of its members. */
+export declare const VERSION = 1;
+/** Capture: prompts for the permissions it needs, resolves with a stream of the new tracks.
+ *  Rejects with "denied" / "notFound" / "failed". */
+export declare const getUserMedia: (service: ServiceChannel<RtcMediaEvents>, constraints: MediaConstraints) => Promise<StreamInfo>;
+/** The devices the host can capture with (labels need a granted permission on the web). */
+export declare const enumerateDevices: (service: ServiceChannel<RtcMediaEvents>) => Promise<DeviceInfo[]>;
+/** A disabled track sends silence / black frames and stays in every connection.
+ *  Rejects with "notFound". */
+export declare const setTrackEnabled: (service: ServiceChannel<RtcMediaEvents>, trackId: string, enabled: boolean) => Promise<void>;
+/** Re-aim a local video track: the other camera, another size or rate. The track and its id
+ *  stay; every connection keeps sending it.
+ *  Rejects with "notFound" / "failed". */
+export declare const applyConstraints: (service: ServiceChannel<RtcMediaEvents>, trackId: string, constraints: VideoConstraints) => Promise<void>;
+/** Rejects with "notFound". */
+export declare const getTrackSettings: (service: ServiceChannel<RtcMediaEvents>, trackId: string) => Promise<TrackSettings>;
+/** End a track: the device is released once no track of it is left, every sender of it goes
+ *  quiet, the id is forgotten. A no-op for an unknown id. */
+export declare const stopTrack: (service: ServiceChannel<RtcMediaEvents>, trackId: string) => Promise<void>;
+/** Route the audio of the call: the earpiece (the default while a wired or Bluetooth headset is
+ *  not connected) or the loudspeaker. A no-op on the web. */
+export declare const setAudioOutput: (service: ServiceChannel<RtcMediaEvents>, output: AudioOutput) => Promise<void>;
+/** A method of the contract. */
+export type Method = "getUserMedia" | "enumerateDevices" | "setTrackEnabled" | "applyConstraints" | "getTrackSettings" | "stopTrack" | "setAudioOutput";
+/** Whether this host has the service "rtcMedia" — and, given a method, a half new enough for it
+ *  (a method added after the first version of the contract is tagged `@since`). */
+export declare const supports: (method?: Method) => boolean;
+/** The devices: capture, the device list, the audio route. One session for the app. */
+export declare class RtcMediaBase extends ServiceChannel<RtcMediaEvents> {
+    constructor(params?: RtcMediaParams);
+    /** Capture: prompts for the permissions it needs, resolves with a stream of the new tracks.
+     *  Rejects with "denied" / "notFound" / "failed". */
+    getUserMedia(constraints: MediaConstraints): Promise<StreamInfo>;
+    /** The devices the host can capture with (labels need a granted permission on the web). */
+    enumerateDevices(): Promise<DeviceInfo[]>;
+    /** A disabled track sends silence / black frames and stays in every connection.
+     *  Rejects with "notFound". */
+    setTrackEnabled(trackId: string, enabled: boolean): Promise<void>;
+    /** Re-aim a local video track: the other camera, another size or rate. The track and its id
+     *  stay; every connection keeps sending it.
+     *  Rejects with "notFound" / "failed". */
+    applyConstraints(trackId: string, constraints: VideoConstraints): Promise<void>;
+    /** Rejects with "notFound". */
+    getTrackSettings(trackId: string): Promise<TrackSettings>;
+    /** End a track: the device is released once no track of it is left, every sender of it goes
+     *  quiet, the id is forgotten. A no-op for an unknown id. */
+    stopTrack(trackId: string): Promise<void>;
+    /** Route the audio of the call: the earpiece (the default while a wired or Bluetooth headset is
+     *  not connected) or the loudspeaker. A no-op on the web. */
+    setAudioOutput(output: AudioOutput): Promise<void>;
+}

package/dist/types/plugins/gen/webrtc/sdk/webrtc.RtcPeerConnection.gen.d.ts

@@ -0,0 +1,121 @@
+import { ServiceChannel, type Json } from "../../../../plugin";
+import type { DataChannelInfo, DataChannelInit, IceCandidate, MediaKind, OfferOptions, RtcConfiguration, RtcPeerConnectionEvents, SenderInfo, SenderParameters, SessionDescription, TransceiverDirection, TransceiverInfo, TransceiverInit } from "../contract";
+/** What the halves register under. */
+export declare const NAME = "rtcPeerConnection";
+/** The contract's version: the highest `@since` of its members. */
+export declare const VERSION = 1;
+/** Rejects with "failed" / "closed". */
+export declare const createOffer: (service: ServiceChannel<RtcPeerConnectionEvents>, options?: OfferOptions) => Promise<SessionDescription>;
+/** Rejects with "failed" / "closed". */
+export declare const createAnswer: (service: ServiceChannel<RtcPeerConnectionEvents>) => Promise<SessionDescription>;
+/** Without a description: the implicit form — an answer when a remote offer is pending, an
+ *  offer otherwise. Resolves with the description now in force (the one to signal).
+ *  Rejects with "failed" / "closed". */
+export declare const setLocalDescription: (service: ServiceChannel<RtcPeerConnectionEvents>, description?: SessionDescription) => Promise<SessionDescription>;
+/** Rejects with "failed" / "closed". */
+export declare const setRemoteDescription: (service: ServiceChannel<RtcPeerConnectionEvents>, description: SessionDescription) => Promise<void>;
+/** Without a candidate: the end of the remote candidates.
+ *  Rejects with "failed" / "closed". */
+export declare const addIceCandidate: (service: ServiceChannel<RtcPeerConnectionEvents>, candidate?: IceCandidate) => Promise<void>;
+/** The next offer carries new ICE credentials. */
+export declare const restartIce: (service: ServiceChannel<RtcPeerConnectionEvents>) => Promise<void>;
+/** Rejects with "failed". */
+export declare const setConfiguration: (service: ServiceChannel<RtcPeerConnectionEvents>, configuration: RtcConfiguration) => Promise<void>;
+/** Send a local track, in the streams named (one is made up when none is).
+ *  Rejects with "notFound" / "failed" / "closed". */
+export declare const addTrack: (service: ServiceChannel<RtcPeerConnectionEvents>, trackId: string, streamIds?: string[]) => Promise<SenderInfo>;
+/** Rejects with "notFound" / "closed". */
+export declare const removeTrack: (service: ServiceChannel<RtcPeerConnectionEvents>, senderId: string) => Promise<void>;
+/** Swap what a sender sends without renegotiating; null = send nothing.
+ *  Rejects with "notFound" / "failed" / "closed". */
+export declare const replaceTrack: (service: ServiceChannel<RtcPeerConnectionEvents>, senderId: string, trackId: string | null) => Promise<void>;
+/** Rejects with "notFound". */
+export declare const getSenderParameters: (service: ServiceChannel<RtcPeerConnectionEvents>, senderId: string) => Promise<SenderParameters>;
+/** The encodings' active / bitrate / scale; the layers themselves are set at addTransceiver.
+ *  Rejects with "notFound" / "failed". */
+export declare const setSenderParameters: (service: ServiceChannel<RtcPeerConnectionEvents>, senderId: string, parameters: SenderParameters) => Promise<void>;
+/** Rejects with "notFound" / "failed" / "closed". */
+export declare const addTransceiver: (service: ServiceChannel<RtcPeerConnectionEvents>, kind: MediaKind, options?: TransceiverInit) => Promise<TransceiverInfo>;
+export declare const getTransceivers: (service: ServiceChannel<RtcPeerConnectionEvents>) => Promise<TransceiverInfo[]>;
+/** Rejects with "notFound" / "failed". */
+export declare const setTransceiverDirection: (service: ServiceChannel<RtcPeerConnectionEvents>, transceiverId: string, direction: TransceiverDirection) => Promise<void>;
+/** Rejects with "notFound". */
+export declare const stopTransceiver: (service: ServiceChannel<RtcPeerConnectionEvents>, transceiverId: string) => Promise<void>;
+/** The RTCStatsReport as an object: the stats id → the stats object (`type`, `timestamp` in ms,
+ *  the fields of its type). For one track's senders / receivers when `trackId` is given. */
+export declare const getStats: (service: ServiceChannel<RtcPeerConnectionEvents>, trackId?: string) => Promise<Json>;
+/** Rejects with "failed" / "closed". */
+export declare const createDataChannel: (service: ServiceChannel<RtcPeerConnectionEvents>, label: string, options?: DataChannelInit) => Promise<DataChannelInfo>;
+/** Rejects with "notFound" / "closed". */
+export declare const sendText: (service: ServiceChannel<RtcPeerConnectionEvents>, channelId: string, text: string) => Promise<void>;
+/** Rejects with "notFound" / "closed". */
+export declare const sendBinary: (service: ServiceChannel<RtcPeerConnectionEvents>, channelId: string, data: Uint8Array) => Promise<void>;
+/** Bytes queued and not yet sent.
+ *  Rejects with "notFound". */
+export declare const getBufferedAmount: (service: ServiceChannel<RtcPeerConnectionEvents>, channelId: string) => Promise<number>;
+/** Rejects with "notFound". */
+export declare const setBufferedAmountLowThreshold: (service: ServiceChannel<RtcPeerConnectionEvents>, channelId: string, threshold: number) => Promise<void>;
+/** A no-op for an unknown id. */
+export declare const closeDataChannel: (service: ServiceChannel<RtcPeerConnectionEvents>, channelId: string) => Promise<void>;
+/** A method of the contract. */
+export type Method = "createOffer" | "createAnswer" | "setLocalDescription" | "setRemoteDescription" | "addIceCandidate" | "restartIce" | "setConfiguration" | "addTrack" | "removeTrack" | "replaceTrack" | "getSenderParameters" | "setSenderParameters" | "addTransceiver" | "getTransceivers" | "setTransceiverDirection" | "stopTransceiver" | "getStats" | "createDataChannel" | "sendText" | "sendBinary" | "getBufferedAmount" | "setBufferedAmountLowThreshold" | "closeDataChannel";
+/** Whether this host has the service "rtcPeerConnection" — and, given a method, a half new enough for it
+ *  (a method added after the first version of the contract is tagged `@since`). */
+export declare const supports: (method?: Method) => boolean;
+/** One RTCPeerConnection: a session, created with its configuration, closed by the SDK's close(). */
+export declare class RtcPeerConnectionBase extends ServiceChannel<RtcPeerConnectionEvents> {
+    constructor(params?: RtcConfiguration);
+    /** Rejects with "failed" / "closed". */
+    createOffer(options?: OfferOptions): Promise<SessionDescription>;
+    /** Rejects with "failed" / "closed". */
+    createAnswer(): Promise<SessionDescription>;
+    /** Without a description: the implicit form — an answer when a remote offer is pending, an
+     *  offer otherwise. Resolves with the description now in force (the one to signal).
+     *  Rejects with "failed" / "closed". */
+    setLocalDescription(description?: SessionDescription): Promise<SessionDescription>;
+    /** Rejects with "failed" / "closed". */
+    setRemoteDescription(description: SessionDescription): Promise<void>;
+    /** Without a candidate: the end of the remote candidates.
+     *  Rejects with "failed" / "closed". */
+    addIceCandidate(candidate?: IceCandidate): Promise<void>;
+    /** The next offer carries new ICE credentials. */
+    restartIce(): Promise<void>;
+    /** Rejects with "failed". */
+    setConfiguration(configuration: RtcConfiguration): Promise<void>;
+    /** Send a local track, in the streams named (one is made up when none is).
+     *  Rejects with "notFound" / "failed" / "closed". */
+    addTrack(trackId: string, streamIds?: string[]): Promise<SenderInfo>;
+    /** Rejects with "notFound" / "closed". */
+    removeTrack(senderId: string): Promise<void>;
+    /** Swap what a sender sends without renegotiating; null = send nothing.
+     *  Rejects with "notFound" / "failed" / "closed". */
+    replaceTrack(senderId: string, trackId: string | null): Promise<void>;
+    /** Rejects with "notFound". */
+    getSenderParameters(senderId: string): Promise<SenderParameters>;
+    /** The encodings' active / bitrate / scale; the layers themselves are set at addTransceiver.
+     *  Rejects with "notFound" / "failed". */
+    setSenderParameters(senderId: string, parameters: SenderParameters): Promise<void>;
+    /** Rejects with "notFound" / "failed" / "closed". */
+    addTransceiver(kind: MediaKind, options?: TransceiverInit): Promise<TransceiverInfo>;
+    getTransceivers(): Promise<TransceiverInfo[]>;
+    /** Rejects with "notFound" / "failed". */
+    setTransceiverDirection(transceiverId: string, direction: TransceiverDirection): Promise<void>;
+    /** Rejects with "notFound". */
+    stopTransceiver(transceiverId: string): Promise<void>;
+    /** The RTCStatsReport as an object: the stats id → the stats object (`type`, `timestamp` in ms,
+     *  the fields of its type). For one track's senders / receivers when `trackId` is given. */
+    getStats(trackId?: string): Promise<Json>;
+    /** Rejects with "failed" / "closed". */
+    createDataChannel(label: string, options?: DataChannelInit): Promise<DataChannelInfo>;
+    /** Rejects with "notFound" / "closed". */
+    sendText(channelId: string, text: string): Promise<void>;
+    /** Rejects with "notFound" / "closed". */
+    sendBinary(channelId: string, data: Uint8Array): Promise<void>;
+    /** Bytes queued and not yet sent.
+     *  Rejects with "notFound". */
+    getBufferedAmount(channelId: string): Promise<number>;
+    /** Rejects with "notFound". */
+    setBufferedAmountLowThreshold(channelId: string, threshold: number): Promise<void>;
+    /** A no-op for an unknown id. */
+    closeDataChannel(channelId: string): Promise<void>;
+}

package/dist/types/plugins/gen/webrtc/sdk/webrtc.RtcVideo.gen.d.ts

@@ -0,0 +1,25 @@
+import { ViewChannel } from "../../../../plugin";
+import type { ObjectFit, RtcVideoEvents, RtcVideoParams } from "../contract";
+/** What the halves register under. */
+export declare const NAME = "rtcVideo";
+/** The contract's version: the highest `@since` of its members. */
+export declare const VERSION = 1;
+/** Draw another track; null = black.
+ *  Rejects with "notFound". */
+export declare const setTrack: (view: ViewChannel<RtcVideoEvents>, trackId: string | null) => Promise<void>;
+export declare const setObjectFit: (view: ViewChannel<RtcVideoEvents>, fit: ObjectFit) => Promise<void>;
+export declare const setMirror: (view: ViewChannel<RtcVideoEvents>, mirror: boolean) => Promise<void>;
+/** A method of the contract. */
+export type Method = "setTrack" | "setObjectFit" | "setMirror";
+/** Whether this host has the view "rtcVideo" — and, given a method, a half new enough for it
+ *  (a method added after the first version of the contract is tagged `@since`). */
+export declare const supports: (method?: Method) => boolean;
+/** A view drawing one video track, local or remote. */
+export declare class RtcVideoBase extends ViewChannel<RtcVideoEvents> {
+    constructor(params?: RtcVideoParams);
+    /** Draw another track; null = black.
+     *  Rejects with "notFound". */
+    setTrack(trackId: string | null): Promise<void>;
+    setObjectFit(fit: ObjectFit): Promise<void>;
+    setMirror(mirror: boolean): Promise<void>;
+}

package/dist/types/plugins/gen/webrtc/sdk/webrtc.d.ts

@@ -0,0 +1,328 @@
+import type { Listener, NativeView } from "../../../../plugin";
+import type { AudioConstraints, AudioOutput, DataChannelInit, DataChannelState, DeviceInfo, Encoding, FacingMode, IceCandidate, IceConnectionState, IceGatheringState, IceServer, MediaKind, ObjectFit, OfferOptions, PeerConnectionState, RtcConfiguration, RtcVideoEvents, SdpType, SenderParameters, SessionDescription, SignalingState, TrackSettings, TransceiverDirection, TransceiverInit, VideoConstraints } from "../contract";
+export type { AudioConstraints, AudioOutput, DataChannelInit, DataChannelState, DeviceInfo, Encoding, FacingMode, IceCandidate, IceConnectionState, IceGatheringState, IceServer, MediaKind, ObjectFit, OfferOptions, PeerConnectionState, RtcConfiguration, RtcVideoEvents, SdpType, SenderParameters, SessionDescription, SignalingState, TrackSettings, TransceiverDirection, TransceiverInit, VideoConstraints, };
+/** A listener of one event type; it gets the event, which carries `type` and `target`. */
+export type RTCEventListener<E> = (event: E) => void;
+/** What every object of the API emits from: `addEventListener` / `removeEventListener`, and the
+ *  `on<type>` properties the subclasses declare. */
+export declare class RTCEventTarget {
+    private readonly _listeners;
+    addEventListener<E = any>(type: string, listener: RTCEventListener<E>): void;
+    removeEventListener<E = any>(type: string, listener: RTCEventListener<E>): void;
+}
+export interface RTCPeerConnectionIceEvent {
+    type: "icecandidate";
+    candidate: RTCIceCandidate | null;
+    target: RTCPeerConnection;
+}
+export interface RTCTrackEvent {
+    type: "track";
+    track: MediaStreamTrack;
+    streams: MediaStream[];
+    receiver: RTCRtpReceiver;
+    transceiver: RTCRtpTransceiver;
+    target: RTCPeerConnection;
+}
+export interface RTCDataChannelEvent {
+    type: "datachannel";
+    channel: RTCDataChannel;
+    target: RTCPeerConnection;
+}
+export interface RTCMessageEvent {
+    type: "message";
+    data: string | ArrayBuffer;
+    target: RTCDataChannel;
+}
+export interface RTCErrorEvent {
+    type: "error";
+    message: string;
+    target: RTCDataChannel;
+}
+export interface RTCEvent<T extends RTCEventTarget = RTCEventTarget> {
+    type: string;
+    target: T;
+}
+/** One track of audio or video, local (`mediaDevices.getUserMedia`) or received (`pc.ontrack`). */
+export declare class MediaStreamTrack extends RTCEventTarget {
+    readonly id: string;
+    readonly kind: MediaKind;
+    readonly label: string;
+    private _enabled;
+    private _muted;
+    private _state;
+    onended: RTCEventListener<RTCEvent<MediaStreamTrack>> | null;
+    onmute: RTCEventListener<RTCEvent<MediaStreamTrack>> | null;
+    onunmute: RTCEventListener<RTCEvent<MediaStreamTrack>> | null;
+    /** A disabled track sends silence / black frames and stays in every connection. */
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    /** A received track the other side is not sending on. */
+    get muted(): boolean;
+    get readyState(): "live" | "ended";
+    /** End the track: a local one releases its device (once no track of it is left). */
+    stop(): void;
+    /** Re-aim a local video track: the other camera (`facingMode`), another size or rate. */
+    applyConstraints(constraints?: VideoConstraints): Promise<void>;
+    /** What a local video track captures with (a promise: the host knows). */
+    getSettings(): Promise<TrackSettings>;
+    /** The same track object (a track is a handle, not a buffer). */
+    clone(): MediaStreamTrack;
+}
+/** A group of tracks: what `getUserMedia` resolves with, what a `track` event names, what
+ *  `addTrack` associates a track with. The id is a label on the wire. */
+export declare class MediaStream extends RTCEventTarget {
+    readonly id: string;
+    private readonly _tracks;
+    onaddtrack: RTCEventListener<{
+        type: "addtrack";
+        track: MediaStreamTrack;
+        target: MediaStream;
+    }> | null;
+    onremovetrack: RTCEventListener<{
+        type: "removetrack";
+        track: MediaStreamTrack;
+        target: MediaStream;
+    }> | null;
+    constructor(tracks?: MediaStreamTrack[] | MediaStream, id?: string);
+    /** Whether a track of it is live. */
+    get active(): boolean;
+    getTracks(): MediaStreamTrack[];
+    getAudioTracks(): MediaStreamTrack[];
+    getVideoTracks(): MediaStreamTrack[];
+    getTrackById(id: string): MediaStreamTrack | null;
+    addTrack(track: MediaStreamTrack): void;
+    removeTrack(track: MediaStreamTrack): void;
+    clone(): MediaStream;
+}
+/** The constraints of `getUserMedia`, the browser's: `true` for the default device, an object to say which. */
+export interface MediaStreamConstraints {
+    audio?: boolean | AudioConstraints;
+    video?: boolean | VideoConstraints;
+}
+declare class MediaDevices extends RTCEventTarget {
+    ondevicechange: RTCEventListener<RTCEvent<MediaDevices>> | null;
+    /** Whether this host registered the "rtcMedia" service — the devices. */
+    get isSupported(): boolean;
+    /** Capture: asks for the permissions it needs, resolves with a stream of the new tracks. Rejects
+     *  with "denied" / "notFound" / "failed". */
+    getUserMedia(constraints?: MediaStreamConstraints): Promise<MediaStream>;
+    /** The devices the host can capture with (their labels need a granted permission on the web). */
+    enumerateDevices(): Promise<DeviceInfo[]>;
+    /** Where the call's audio plays on a phone: the earpiece or the loudspeaker. A no-op on the web. */
+    setAudioOutput(output: AudioOutput): Promise<void>;
+}
+/** `navigator.mediaDevices` of the browser: the capture and the device list. Host-optional —
+ *  `mediaDevices.isSupported` before offering a call. */
+export declare const mediaDevices: MediaDevices;
+/** The browser's RTCSessionDescription: `{ type, sdp }`, as it is signaled. */
+export declare class RTCSessionDescription implements SessionDescription {
+    readonly type: SdpType;
+    readonly sdp: string;
+    constructor(init: SessionDescription);
+    toJSON(): SessionDescription;
+}
+/** The browser's RTCIceCandidate: what `icecandidate` carries and `addIceCandidate` takes. */
+export declare class RTCIceCandidate implements IceCandidate {
+    readonly candidate: string;
+    readonly sdpMid: string | null;
+    readonly sdpMLineIndex: number | null;
+    readonly usernameFragment: string | undefined;
+    constructor(init: RTCIceCandidateInit);
+    toJSON(): IceCandidate;
+}
+export interface RTCIceCandidateInit {
+    candidate?: string;
+    sdpMid?: string | null;
+    sdpMLineIndex?: number | null;
+    usernameFragment?: string;
+}
+/** The sending half of a transceiver: the track it sends and its encodings. */
+export declare class RTCRtpSender {
+    private readonly _pc;
+    private _track;
+    /** What it sends; null = nothing. */
+    get track(): MediaStreamTrack | null;
+    /** Swap the track without renegotiating; null = send nothing. */
+    replaceTrack(track: MediaStreamTrack | null): Promise<void>;
+    /** The encodings (a promise: the host holds them). */
+    getParameters(): Promise<SenderParameters>;
+    /** The encodings' active / bitrate / scale. */
+    setParameters(parameters: SenderParameters): Promise<void>;
+    /** The stats of this sender. */
+    getStats(): Promise<Map<string, any>>;
+}
+/** The receiving half of a transceiver: its track exists from the start, media arrives into it. */
+export declare class RTCRtpReceiver {
+    readonly track: MediaStreamTrack;
+    private readonly _pc;
+    getStats(): Promise<Map<string, any>>;
+}
+/** One m-line of the session: a sender and a receiver, a direction, a mid once negotiated. */
+export declare class RTCRtpTransceiver {
+    readonly sender: RTCRtpSender;
+    readonly receiver: RTCRtpReceiver;
+    private readonly _pc;
+    private _mid;
+    private _direction;
+    private _currentDirection;
+    private _stopped;
+    /** The m-line's id once a description named it. */
+    get mid(): string | null;
+    /** The direction wanted; setting it takes effect at the next negotiation. */
+    get direction(): TransceiverDirection;
+    set direction(value: TransceiverDirection);
+    /** The direction negotiated; null before the first answer. */
+    get currentDirection(): TransceiverDirection | null;
+    get stopped(): boolean;
+    /** Stop sending and receiving on it; the next negotiation removes the m-line. */
+    stop(): void;
+}
+/** A data channel: strings and bytes, ordered and reliable unless said otherwise. */
+export declare class RTCDataChannel extends RTCEventTarget {
+    readonly label: string;
+    readonly ordered: boolean;
+    readonly maxPacketLifeTime: number | null;
+    readonly maxRetransmits: number | null;
+    readonly protocol: string;
+    readonly negotiated: boolean;
+    /** Bytes arrive as an ArrayBuffer (the browser's "blob" is not a thing here). */
+    binaryType: "arraybuffer";
+    private readonly _pc;
+    private _streamId;
+    private _state;
+    private _threshold;
+    /** What was sent before the host made the channel. */
+    private _queue;
+    onopen: RTCEventListener<RTCEvent<RTCDataChannel>> | null;
+    onclose: RTCEventListener<RTCEvent<RTCDataChannel>> | null;
+    onerror: RTCEventListener<RTCErrorEvent> | null;
+    onmessage: RTCEventListener<RTCMessageEvent> | null;
+    onbufferedamountlow: RTCEventListener<RTCEvent<RTCDataChannel>> | null;
+    /** The SCTP stream id; null until the transport assigned one. */
+    get id(): number | null;
+    get readyState(): DataChannelState;
+    /** Bytes queued and not yet sent (a promise: the host counts them). */
+    getBufferedAmount(): Promise<number>;
+    get bufferedAmountLowThreshold(): number;
+    set bufferedAmountLowThreshold(value: number);
+    /** Send a string or bytes. Throws when the channel is closing or closed. */
+    send(data: string | ArrayBuffer | ArrayBufferView): void;
+    private _send;
+    close(): void;
+}
+/** `RTCConfiguration` of the browser, with `iceServers[].urls` as one URL or several. */
+export interface RTCConfiguration extends Omit<RtcConfiguration, "iceServers"> {
+    iceServers?: {
+        urls: string | string[];
+        username?: string;
+        credential?: string;
+    }[];
+}
+/** A connection to one peer: the browser's RTCPeerConnection. The session with the host opens on
+ *  the first call and closes with `close()`. Signaling — carrying the descriptions and the
+ *  candidates to the other side — is the app's. */
+export declare class RTCPeerConnection extends RTCEventTarget {
+    /** Whether this host registered the "rtcPeerConnection" service. */
+    static get isSupported(): boolean;
+    private _configuration;
+    private _local;
+    private _remote;
+    private _signaling;
+    private _gathering;
+    private _ice;
+    private _connection;
+    private readonly _transceivers;
+    private readonly _channels;
+    private readonly _remoteTracks;
+    /** While a local description is being set, its candidates wait: the browser delivers them
+     *  after the promise, and the app's signaling expects the description first. */
+    private _settingLocal;
+    private _heldCandidates;
+    onnegotiationneeded: RTCEventListener<RTCEvent<RTCPeerConnection>> | null;
+    onicecandidate: RTCEventListener<RTCPeerConnectionIceEvent> | null;
+    onsignalingstatechange: RTCEventListener<RTCEvent<RTCPeerConnection>> | null;
+    onicegatheringstatechange: RTCEventListener<RTCEvent<RTCPeerConnection>> | null;
+    oniceconnectionstatechange: RTCEventListener<RTCEvent<RTCPeerConnection>> | null;
+    onconnectionstatechange: RTCEventListener<RTCEvent<RTCPeerConnection>> | null;
+    ontrack: RTCEventListener<RTCTrackEvent> | null;
+    ondatachannel: RTCEventListener<RTCDataChannelEvent> | null;
+    constructor(configuration?: RTCConfiguration);
+    get localDescription(): RTCSessionDescription | null;
+    get remoteDescription(): RTCSessionDescription | null;
+    get currentLocalDescription(): RTCSessionDescription | null;
+    get currentRemoteDescription(): RTCSessionDescription | null;
+    get signalingState(): SignalingState;
+    get iceGatheringState(): IceGatheringState;
+    get iceConnectionState(): IceConnectionState;
+    get connectionState(): PeerConnectionState;
+    createOffer(options?: OfferOptions): Promise<RTCSessionDescription>;
+    createAnswer(): Promise<RTCSessionDescription>;
+    /** Without a description: the implicit form — an answer to a pending remote offer, an offer
+     *  otherwise. `localDescription` holds what is in force after. */
+    setLocalDescription(description?: SessionDescription | RTCSessionDescription | {
+        type: SdpType;
+        sdp?: string;
+    }): Promise<void>;
+    setRemoteDescription(description: SessionDescription | RTCSessionDescription | {
+        type: SdpType;
+        sdp?: string;
+    }): Promise<void>;
+    /** A candidate of the other side; none (or an empty one) = the end of its candidates. */
+    addIceCandidate(candidate?: RTCIceCandidateInit | RTCIceCandidate | null): Promise<void>;
+    /** The next offer carries new ICE credentials. */
+    restartIce(): void;
+    getConfiguration(): RTCConfiguration;
+    setConfiguration(configuration: RTCConfiguration): Promise<void>;
+    /** Send a local track, in the streams named (the browser's `addTrack(track, ...streams)`). The
+     *  sender is known once the host made it: a promise, where the browser answers at once. */
+    addTrack(track: MediaStreamTrack, ...streams: MediaStream[]): Promise<RTCRtpSender>;
+    removeTrack(sender: RTCRtpSender): Promise<void>;
+    /** Add an m-line: for a kind, or for a track to send on it. A promise, where the browser answers at once. */
+    addTransceiver(trackOrKind: MediaStreamTrack | MediaKind, init?: Omit<TransceiverInit, "trackId" | "streamIds"> & {
+        streams?: MediaStream[];
+    }): Promise<RTCRtpTransceiver>;
+    /** The transceivers as last synced (after every description, on every `track` event). */
+    getTransceivers(): RTCRtpTransceiver[];
+    getSenders(): RTCRtpSender[];
+    getReceivers(): RTCRtpReceiver[];
+    /** The RTCStatsReport: a Map of the stats id → the stats object (`type`, `timestamp` in ms, the
+     *  fields of its type), for the whole connection or one track's senders / receivers. */
+    getStats(selector?: MediaStreamTrack | null): Promise<Map<string, any>>;
+    /** Open a data channel. The channel is "connecting" until the host and the other side are ready;
+     *  what is sent before counts as queued. */
+    createDataChannel(label: string, init?: DataChannelInit): RTCDataChannel;
+    /** Close the connection: the session with the host ends, every received track ends, every
+     *  channel closes. */
+    close(): void;
+    private _transceiverOf;
+    private _syncTransceivers;
+    private _onTrack;
+}
+export interface RTCVideoViewOptions {
+    /** The track to draw; none = black. */
+    track?: MediaStreamTrack | null;
+    /** Default "cover". */
+    objectFit?: ObjectFit;
+    /** Flip horizontally — the front camera's preview. Default false. */
+    mirror?: boolean;
+}
+/** A tree node that draws one video track: embed it among a screen's children (sized by its
+ *  styles) or present it fullscreen (`open()`). `track` may change at any time. */
+export interface RTCVideoView extends NativeView {
+    /** The track drawn; null = black. */
+    track: MediaStreamTrack | null;
+    objectFit: ObjectFit;
+    mirror: boolean;
+    /** `resize`: the first frame, and every change of the picture's size. */
+    on<K extends keyof RtcVideoEvents & string>(event: K, callback: Listener<RtcVideoEvents, K>): this;
+    off<K extends keyof RtcVideoEvents & string>(event: K, callback: Listener<RtcVideoEvents, K>): this;
+}
+/**
+ * Create a video view. `RTCVideoView.isSupported` reports whether this host has the capability —
+ * check it before offering the feature (a view no host registered mounts nothing).
+ */
+export declare const RTCVideoView: {
+    (options?: RTCVideoViewOptions): RTCVideoView;
+    /** Whether this host registered an "rtcVideo" view. */
+    readonly isSupported: boolean;
+};

package/dist/types/version.d.ts

@@ -1,4 +1,4 @@
-export declare const SDK_VERSION = "2.2.7";
+export declare const SDK_VERSION = "2.2.8";
 /** The major of a semver string, or null when it is not one. */
 export declare const sdkMajor: (version: string | null | undefined) => number | null;
 /** The `// sdk: <version>` line of a compiled bundle's header (sdk/src/compile/header.ts), read from