lecodes-sdk 2.2.7 → 2.2.9

package/package.json

@@ -45,7 +45,7 @@
     "marcidb-embedded": "^0.15.0",
     "sharp": "^0.35.2"
   },
-  "version": "2.2.7",
+  "version": "2.2.9",
   "files": [
     "src",
     "dist",

package/src/chisel.ts

@@ -118,7 +118,7 @@ export const chiselVocab: ChiselVocab = {
     },
     leaves: [
       "UIText", "UIImage", "UIVideo", "UIInput", "UITextArea", "UISpacer",
-      "UITabs", "UIVirtualizedList", "NativeView", "CameraView", "MapView", "QRScanner", "WebView",
+      "UITabs", "UIVirtualizedList", "NativeView", "CameraView", "MapView", "QRScanner", "WebView", "RTCVideoView",
     ],
     containers: [ "UIColumn", "UIRow", "UIBox", "UIButton", "UIScrollable", "UIScreen", "UIWidget" ],
     text: "UIText",
@@ -133,7 +133,7 @@ export const chiselVocab: ChiselVocab = {
       "append", "insert", "remove", "setContent", "widgets", "keepAlive", "url",
       "detents", "dismissible", "transition", "setSourceRect",
       "push", "pop", "popToRoot", "replace", "select",
-      // UITabs / UIVirtualizedList's hand feed / the native views (NativeView, CameraView, MapView, QRScanner)
+      // UITabs / UIVirtualizedList's hand feed / the native views (NativeView, CameraView, MapView, QRScanner, WebView, RTCVideoView)
       "badge", "setData", "update", "prepend", "removeByKey",
       "on", "off", "onReady", "onError", "onTap", "onMove", "onScan",
       "flyTo", "jumpTo", "fitPoints", "setPadding", "setUserLocation",

package/src/inject.ts

@@ -152,6 +152,13 @@ export {
 } 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"
 
 // ---- scenes as data (.scene.ts files — see src/scene/defineScene.ts) ----

package/src/plugins/gen/webrtc/contract.d.ts

@@ -0,0 +1,342 @@
+// GENERATED by scripts/vendor-plugins.ts from lecodes-plugins/plugins/webrtc/contract.d.ts — do not edit here.
+// Change it in the plugin repo and run `bun run vendor:plugins`; `bun run check:plugins` fails when this copy is stale.
+// webrtc — real-time audio, video and data between peers, over libwebrtc on iOS and Android and
+// the browser's own stack on the web. The wire is the W3C API, cut at the objects: a peer
+// connection is a SESSION of the "rtcPeerConnection" service (its params are the configuration,
+// the SDK's close() is RTCPeerConnection.close()), the media devices are the "rtcMedia" service,
+// and a track is drawn by the "rtcVideo" view. Tracks, senders, transceivers and data channels
+// live in the host; what crosses is an id the host allocated. A remote track (the `track` event)
+// is a track like any other: the view shows it, another connection can forward it.
+//
+// Signaling is NOT here: the app carries the descriptions and the candidates over its own
+// channel (a WebSocket). The halves are dumb on purpose — no room, no call, no server — so that a
+// client of an SFU (mediasoup-client, LiveKit's) can run in the app's bundle over this wire.
+//
+// The app-facing API (sdk/) is the browser's: RTCPeerConnection, MediaStream, MediaStreamTrack,
+// RTCDataChannel, mediaDevices.getUserMedia(), plus RTCVideoView for the picture.
+
+import type { Json, Service, View, f64, i32 } from "../../../plugin"
+
+// ---- media ----------------------------------------------------------------------------------------
+
+export type MediaKind = "audio" | "video"
+/** The browser's facingMode values: "user" is the front camera, "environment" the back one. */
+export type FacingMode = "user" | "environment"
+export type DeviceKind = "audioinput" | "audiooutput" | "videoinput"
+/** Where the call's audio plays on a phone. */
+export type AudioOutput = "earpiece" | "speaker"
+
+export interface AudioConstraints {
+  /** A device of enumerateDevices(); the default input when absent. */
+  deviceId?: string
+  /** Default true. */
+  echoCancellation?: boolean
+  /** Default true. */
+  noiseSuppression?: boolean
+  /** Default true. */
+  autoGainControl?: boolean
+}
+
+export interface VideoConstraints {
+  /** A device of enumerateDevices(); wins over facingMode. */
+  deviceId?: string
+  /** Default "user". */
+  facingMode?: FacingMode
+  /** The capture size wanted; the host picks the closest format the camera has. Default 1280×720. */
+  width?: i32
+  height?: i32
+  /** Default 30. */
+  frameRate?: f64
+}
+
+/** What to capture: a kind present = wanted (the wrapper turns the browser's `audio: true` into `{}`). */
+export interface MediaConstraints {
+  audio?: AudioConstraints
+  video?: VideoConstraints
+}
+
+export interface TrackInfo {
+  /** The host's id of the track — what every call names it by. */
+  id: string
+  kind: MediaKind
+  /** The device's name for a local track, the remote msid for a received one. */
+  label: string
+  enabled: boolean
+  /** A received track the sender has muted (no media is arriving). Default false. */
+  muted?: boolean
+}
+
+export interface StreamInfo {
+  id: string
+  tracks: TrackInfo[]
+}
+
+export interface DeviceInfo {
+  deviceId: string
+  kind: DeviceKind
+  label: string
+  /** A camera's side, when the platform tells. */
+  facing?: FacingMode
+}
+
+/** What a local video track captures with, after the constraints were applied. */
+export interface TrackSettings {
+  deviceId?: string
+  facingMode?: FacingMode
+  width?: i32
+  height?: i32
+  frameRate?: f64
+}
+
+export interface RtcMediaParams {}
+
+export interface RtcMediaEvents {
+  /** A device was plugged in or removed (a headset, a camera). */
+  deviceChange: void
+  /** A local track ended on its own: the OS took the device (a call came in, the camera was claimed). */
+  trackEnded: { trackId: string }
+}
+
+/** The devices: capture, the device list, the audio route. One session for the app. */
+export interface RtcMedia extends Service<"rtcMedia", RtcMediaParams, RtcMediaEvents> {
+  /** Capture: prompts for the permissions it needs, resolves with a stream of the new tracks.
+   *  @rejects 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 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 notFound failed */
+  applyConstraints(trackId: string, constraints: VideoConstraints): Promise<void>
+  /** @rejects 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>
+}
+
+// ---- the peer connection --------------------------------------------------------------------------
+
+export interface IceServer {
+  urls: string[]
+  username?: string
+  credential?: string
+}
+
+export type IceTransportPolicy = "all" | "relay"
+export type BundlePolicy = "balanced" | "max-compat" | "max-bundle"
+
+/** The RTCConfiguration — the params of a session, and what setConfiguration takes. */
+export interface RtcConfiguration {
+  iceServers?: IceServer[]
+  /** Default "all". */
+  iceTransportPolicy?: IceTransportPolicy
+  /** Default "balanced". */
+  bundlePolicy?: BundlePolicy
+  /** Default 0. */
+  iceCandidatePoolSize?: i32
+}
+
+export type SdpType = "offer" | "answer" | "pranswer" | "rollback"
+
+export interface SessionDescription {
+  type: SdpType
+  sdp: string
+}
+
+export interface IceCandidate {
+  candidate: string
+  sdpMid: string | null
+  sdpMLineIndex: i32 | null
+  usernameFragment?: string
+}
+
+export interface OfferOptions {
+  iceRestart?: boolean
+  offerToReceiveAudio?: boolean
+  offerToReceiveVideo?: boolean
+}
+
+export type SignalingState = "stable" | "have-local-offer" | "have-remote-offer" | "have-local-pranswer" | "have-remote-pranswer" | "closed"
+export type IceGatheringState = "new" | "gathering" | "complete"
+export type IceConnectionState = "new" | "checking" | "connected" | "completed" | "failed" | "disconnected" | "closed"
+export type PeerConnectionState = "new" | "connecting" | "connected" | "disconnected" | "failed" | "closed"
+export type TransceiverDirection = "sendrecv" | "sendonly" | "recvonly" | "inactive" | "stopped"
+
+/** One encoding of a sender (a simulcast layer when there are several, each with a `rid`). */
+export interface Encoding {
+  rid?: string
+  /** Default true. */
+  active?: boolean
+  /** Bits per second. */
+  maxBitrate?: i32
+  maxFramerate?: f64
+  /** 2 = half the width and the height. */
+  scaleResolutionDownBy?: f64
+}
+
+export interface SenderParameters {
+  encodings: Encoding[]
+}
+
+export interface TransceiverInit {
+  /** Default "sendrecv". */
+  direction?: TransceiverDirection
+  /** A local track to send from the start. */
+  trackId?: string
+  streamIds?: string[]
+  /** The simulcast layers (an SFU client's): one encoding each, with a rid. */
+  sendEncodings?: Encoding[]
+}
+
+export interface SenderInfo {
+  id: string
+  trackId: string | null
+}
+
+export interface TransceiverInfo {
+  id: string
+  mid: string | null
+  direction: TransceiverDirection
+  currentDirection: TransceiverDirection | null
+  sender: SenderInfo
+  /** The receiver's track exists from the start (before any media arrives). */
+  receiverTrack: TrackInfo
+  stopped: boolean
+}
+
+export interface DataChannelInit {
+  /** Default true. */
+  ordered?: boolean
+  maxPacketLifeTime?: i32
+  maxRetransmits?: i32
+  /** Default "". */
+  protocol?: string
+  /** Default false. */
+  negotiated?: boolean
+  /** The SCTP stream id of a negotiated channel. */
+  id?: i32
+}
+
+export type DataChannelState = "connecting" | "open" | "closing" | "closed"
+
+export interface DataChannelInfo {
+  /** The host's id of the channel — what every call names it by. */
+  id: string
+  label: string
+  ordered: boolean
+  maxPacketLifeTime: i32 | null
+  maxRetransmits: i32 | null
+  protocol: string
+  negotiated: boolean
+  /** The SCTP stream id; null until the transport assigned one. */
+  streamId: i32 | null
+  readyState: DataChannelState
+}
+
+export interface RtcPeerConnectionEvents {
+  negotiationNeeded: void
+  /** A local candidate for the other side; null = the gathering of this round is complete. */
+  iceCandidate: { candidate: IceCandidate | null }
+  signalingStateChange: { state: SignalingState }
+  iceGatheringStateChange: { state: IceGatheringState }
+  iceConnectionStateChange: { state: IceConnectionState }
+  connectionStateChange: { state: PeerConnectionState }
+  /** A remote track arrived: the receiver's track of `transceiverId`, in the streams the other
+   *  side put it in. */
+  track: { track: TrackInfo, streamIds: string[], transceiverId: string }
+  /** A received track went mute (nothing arrives) or came back. */
+  trackMute: { trackId: string, muted: boolean }
+  /** A received track ended: the other side removed it, or the connection closed. */
+  trackEnded: { trackId: string }
+  /** The other side opened a data channel. */
+  dataChannel: DataChannelInfo
+  dataChannelStateChange: { id: string, state: DataChannelState }
+  /** One message: `text` for a string, `binary` for bytes — exactly one of the two. */
+  dataChannelMessage: { id: string, text?: string, binary?: Uint8Array }
+  dataChannelError: { id: string, message: string }
+  /** The buffered amount fell to the threshold or under it. */
+  dataChannelBufferedAmountLow: { id: string }
+}
+
+/** One RTCPeerConnection: a session, created with its configuration, closed by the SDK's close(). */
+export interface RtcPeerConnection extends Service<"rtcPeerConnection", RtcConfiguration, RtcPeerConnectionEvents> {
+  /** @rejects failed closed */
+  createOffer(options?: OfferOptions): Promise<SessionDescription>
+  /** @rejects 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 failed closed */
+  setLocalDescription(description?: SessionDescription): Promise<SessionDescription>
+  /** @rejects failed closed */
+  setRemoteDescription(description: SessionDescription): Promise<void>
+  /** Without a candidate: the end of the remote candidates. @rejects failed closed */
+  addIceCandidate(candidate?: IceCandidate): Promise<void>
+  /** The next offer carries new ICE credentials. */
+  restartIce(): Promise<void>
+  /** @rejects failed */
+  setConfiguration(configuration: RtcConfiguration): Promise<void>
+  /** Send a local track, in the streams named (one is made up when none is). @rejects notFound failed closed */
+  addTrack(trackId: string, streamIds?: string[]): Promise<SenderInfo>
+  /** @rejects notFound closed */
+  removeTrack(senderId: string): Promise<void>
+  /** Swap what a sender sends without renegotiating; null = send nothing. @rejects notFound failed closed */
+  replaceTrack(senderId: string, trackId: string | null): Promise<void>
+  /** @rejects notFound */
+  getSenderParameters(senderId: string): Promise<SenderParameters>
+  /** The encodings' active / bitrate / scale; the layers themselves are set at addTransceiver. @rejects notFound failed */
+  setSenderParameters(senderId: string, parameters: SenderParameters): Promise<void>
+  /** @rejects notFound failed closed */
+  addTransceiver(kind: MediaKind, options?: TransceiverInit): Promise<TransceiverInfo>
+  getTransceivers(): Promise<TransceiverInfo[]>
+  /** @rejects notFound failed */
+  setTransceiverDirection(transceiverId: string, direction: TransceiverDirection): Promise<void>
+  /** @rejects 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 failed closed */
+  createDataChannel(label: string, options?: DataChannelInit): Promise<DataChannelInfo>
+  /** @rejects notFound closed */
+  sendText(channelId: string, text: string): Promise<void>
+  /** @rejects notFound closed */
+  sendBinary(channelId: string, data: Uint8Array): Promise<void>
+  /** Bytes queued and not yet sent. @rejects notFound */
+  getBufferedAmount(channelId: string): Promise<f64>
+  /** @rejects notFound */
+  setBufferedAmountLowThreshold(channelId: string, threshold: f64): Promise<void>
+  /** A no-op for an unknown id. */
+  closeDataChannel(channelId: string): Promise<void>
+}
+
+// ---- the picture ----------------------------------------------------------------------------------
+
+export type ObjectFit = "cover" | "contain"
+
+export interface RtcVideoParams {
+  /** The track to draw; none = black. */
+  trackId?: string
+  /** Default "cover". */
+  objectFit?: ObjectFit
+  /** Flip horizontally — the front camera's preview. Default false. */
+  mirror?: boolean
+}
+
+export interface RtcVideoEvents {
+  /** The first frame was drawn, and every change of the picture's size after. */
+  resize: { width: i32, height: i32 }
+}
+
+/** A view drawing one video track, local or remote. */
+export interface RtcVideo extends View<"rtcVideo", RtcVideoParams, RtcVideoEvents> {
+  /** Draw another track; null = black. @rejects notFound */
+  setTrack(trackId: string | null): Promise<void>
+  setObjectFit(fit: ObjectFit): Promise<void>
+  setMirror(mirror: boolean): Promise<void>
+}

package/src/plugins/gen/webrtc/sdk/webrtc.RtcMedia.gen.ts

@@ -0,0 +1,86 @@
+// GENERATED by scripts/vendor-plugins.ts from lecodes-plugins/plugins/webrtc/sdk/webrtc.RtcMedia.gen.ts — do not edit here.
+// Change it in the plugin repo and run `bun run vendor:plugins`; `bun run check:plugins` fails when this copy is stale.
+// GENERATED by `lecodes plugin gen` from contract.d.ts — do not edit.
+// webrtc: the service "rtcMedia", contract version 1.
+
+import { ServiceChannel } from "../../../../plugin"
+import type { AudioOutput, DeviceInfo, MediaConstraints, RtcMediaEvents, RtcMediaParams, StreamInfo, TrackSettings, VideoConstraints } from "../contract"
+
+/** What the halves register under. */
+export const NAME = "rtcMedia"
+/** The contract's version: the highest `@since` of its members. */
+export const VERSION = 1
+
+// ---- the wire, call by call ----------------------------------------------------------------------
+
+/** Capture: prompts for the permissions it needs, resolves with a stream of the new tracks.
+ *  Rejects with "denied" / "notFound" / "failed". */
+export const getUserMedia = (service: ServiceChannel<RtcMediaEvents>, constraints: MediaConstraints): Promise<StreamInfo> =>
+  service._call("getUserMedia", [constraints])
+
+/** The devices the host can capture with (labels need a granted permission on the web). */
+export const enumerateDevices = (service: ServiceChannel<RtcMediaEvents>): Promise<DeviceInfo[]> =>
+  service._call("enumerateDevices", [])
+
+/** A disabled track sends silence / black frames and stays in every connection.
+ *  Rejects with "notFound". */
+export const setTrackEnabled = (service: ServiceChannel<RtcMediaEvents>, trackId: string, enabled: boolean): Promise<void> =>
+  service._call("setTrackEnabled", [trackId, enabled])
+
+/** 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 const applyConstraints = (service: ServiceChannel<RtcMediaEvents>, trackId: string, constraints: VideoConstraints): Promise<void> =>
+  service._call("applyConstraints", [trackId, constraints])
+
+/** Rejects with "notFound". */
+export const getTrackSettings = (service: ServiceChannel<RtcMediaEvents>, trackId: string): Promise<TrackSettings> =>
+  service._call("getTrackSettings", [trackId])
+
+/** 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 const stopTrack = (service: ServiceChannel<RtcMediaEvents>, trackId: string): Promise<void> =>
+  service._call("stopTrack", [trackId])
+
+/** 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 const setAudioOutput = (service: ServiceChannel<RtcMediaEvents>, output: AudioOutput): Promise<void> =>
+  service._call("setAudioOutput", [output])
+
+// ---- what the host's half has --------------------------------------------------------------------
+
+/** 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 const supports = (method?: Method): boolean =>
+  ServiceChannel.supports(NAME)   // every method is of version 1
+
+// ---- the client -----------------------------------------------------------------------------------
+
+/** The devices: capture, the device list, the audio route. One session for the app. */
+export class RtcMediaBase extends ServiceChannel<RtcMediaEvents> {
+  constructor(params: RtcMediaParams = {}) { super("RtcMedia", NAME, params) }
+
+  /** 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> { return getUserMedia(this, constraints) }
+  /** The devices the host can capture with (labels need a granted permission on the web). */
+  enumerateDevices(): Promise<DeviceInfo[]> { return enumerateDevices(this) }
+  /** A disabled track sends silence / black frames and stays in every connection.
+   *  Rejects with "notFound". */
+  setTrackEnabled(trackId: string, enabled: boolean): Promise<void> { return setTrackEnabled(this, trackId, enabled) }
+  /** 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> { return applyConstraints(this, trackId, constraints) }
+  /** Rejects with "notFound". */
+  getTrackSettings(trackId: string): Promise<TrackSettings> { return getTrackSettings(this, trackId) }
+  /** 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> { return stopTrack(this, trackId) }
+  /** 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> { return setAudioOutput(this, output) }
+}

package/src/plugins/gen/webrtc/sdk/webrtc.RtcPeerConnection.gen.ts

@@ -0,0 +1,184 @@
+// GENERATED by scripts/vendor-plugins.ts from lecodes-plugins/plugins/webrtc/sdk/webrtc.RtcPeerConnection.gen.ts — do not edit here.
+// Change it in the plugin repo and run `bun run vendor:plugins`; `bun run check:plugins` fails when this copy is stale.
+// GENERATED by `lecodes plugin gen` from contract.d.ts — do not edit.
+// webrtc: the service "rtcPeerConnection", contract version 1.
+
+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 const NAME = "rtcPeerConnection"
+/** The contract's version: the highest `@since` of its members. */
+export const VERSION = 1
+
+// ---- the wire, call by call ----------------------------------------------------------------------
+
+/** Rejects with "failed" / "closed". */
+export const createOffer = (service: ServiceChannel<RtcPeerConnectionEvents>, options?: OfferOptions): Promise<SessionDescription> =>
+  service._call("createOffer", [options])
+
+/** Rejects with "failed" / "closed". */
+export const createAnswer = (service: ServiceChannel<RtcPeerConnectionEvents>): Promise<SessionDescription> =>
+  service._call("createAnswer", [])
+
+/** 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 const setLocalDescription = (service: ServiceChannel<RtcPeerConnectionEvents>, description?: SessionDescription): Promise<SessionDescription> =>
+  service._call("setLocalDescription", [description])
+
+/** Rejects with "failed" / "closed". */
+export const setRemoteDescription = (service: ServiceChannel<RtcPeerConnectionEvents>, description: SessionDescription): Promise<void> =>
+  service._call("setRemoteDescription", [description])
+
+/** Without a candidate: the end of the remote candidates.
+ *  Rejects with "failed" / "closed". */
+export const addIceCandidate = (service: ServiceChannel<RtcPeerConnectionEvents>, candidate?: IceCandidate): Promise<void> =>
+  service._call("addIceCandidate", [candidate])
+
+/** The next offer carries new ICE credentials. */
+export const restartIce = (service: ServiceChannel<RtcPeerConnectionEvents>): Promise<void> =>
+  service._call("restartIce", [])
+
+/** Rejects with "failed". */
+export const setConfiguration = (service: ServiceChannel<RtcPeerConnectionEvents>, configuration: RtcConfiguration): Promise<void> =>
+  service._call("setConfiguration", [configuration])
+
+/** Send a local track, in the streams named (one is made up when none is).
+ *  Rejects with "notFound" / "failed" / "closed". */
+export const addTrack = (service: ServiceChannel<RtcPeerConnectionEvents>, trackId: string, streamIds?: string[]): Promise<SenderInfo> =>
+  service._call("addTrack", [trackId, streamIds])
+
+/** Rejects with "notFound" / "closed". */
+export const removeTrack = (service: ServiceChannel<RtcPeerConnectionEvents>, senderId: string): Promise<void> =>
+  service._call("removeTrack", [senderId])
+
+/** Swap what a sender sends without renegotiating; null = send nothing.
+ *  Rejects with "notFound" / "failed" / "closed". */
+export const replaceTrack = (service: ServiceChannel<RtcPeerConnectionEvents>, senderId: string, trackId: string | null): Promise<void> =>
+  service._call("replaceTrack", [senderId, trackId])
+
+/** Rejects with "notFound". */
+export const getSenderParameters = (service: ServiceChannel<RtcPeerConnectionEvents>, senderId: string): Promise<SenderParameters> =>
+  service._call("getSenderParameters", [senderId])
+
+/** The encodings' active / bitrate / scale; the layers themselves are set at addTransceiver.
+ *  Rejects with "notFound" / "failed". */
+export const setSenderParameters = (service: ServiceChannel<RtcPeerConnectionEvents>, senderId: string, parameters: SenderParameters): Promise<void> =>
+  service._call("setSenderParameters", [senderId, parameters])
+
+/** Rejects with "notFound" / "failed" / "closed". */
+export const addTransceiver = (service: ServiceChannel<RtcPeerConnectionEvents>, kind: MediaKind, options?: TransceiverInit): Promise<TransceiverInfo> =>
+  service._call("addTransceiver", [kind, options])
+
+export const getTransceivers = (service: ServiceChannel<RtcPeerConnectionEvents>): Promise<TransceiverInfo[]> =>
+  service._call("getTransceivers", [])
+
+/** Rejects with "notFound" / "failed". */
+export const setTransceiverDirection = (service: ServiceChannel<RtcPeerConnectionEvents>, transceiverId: string, direction: TransceiverDirection): Promise<void> =>
+  service._call("setTransceiverDirection", [transceiverId, direction])
+
+/** Rejects with "notFound". */
+export const stopTransceiver = (service: ServiceChannel<RtcPeerConnectionEvents>, transceiverId: string): Promise<void> =>
+  service._call("stopTransceiver", [transceiverId])
+
+/** 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 const getStats = (service: ServiceChannel<RtcPeerConnectionEvents>, trackId?: string): Promise<Json> =>
+  service._call("getStats", [trackId])
+
+/** Rejects with "failed" / "closed". */
+export const createDataChannel = (service: ServiceChannel<RtcPeerConnectionEvents>, label: string, options?: DataChannelInit): Promise<DataChannelInfo> =>
+  service._call("createDataChannel", [label, options])
+
+/** Rejects with "notFound" / "closed". */
+export const sendText = (service: ServiceChannel<RtcPeerConnectionEvents>, channelId: string, text: string): Promise<void> =>
+  service._call("sendText", [channelId, text])
+
+/** Rejects with "notFound" / "closed". */
+export const sendBinary = (service: ServiceChannel<RtcPeerConnectionEvents>, channelId: string, data: Uint8Array): Promise<void> =>
+  service._call("sendBinary", [channelId, data])
+
+/** Bytes queued and not yet sent.
+ *  Rejects with "notFound". */
+export const getBufferedAmount = (service: ServiceChannel<RtcPeerConnectionEvents>, channelId: string): Promise<number> =>
+  service._call("getBufferedAmount", [channelId])
+
+/** Rejects with "notFound". */
+export const setBufferedAmountLowThreshold = (service: ServiceChannel<RtcPeerConnectionEvents>, channelId: string, threshold: number): Promise<void> =>
+  service._call("setBufferedAmountLowThreshold", [channelId, threshold])
+
+/** A no-op for an unknown id. */
+export const closeDataChannel = (service: ServiceChannel<RtcPeerConnectionEvents>, channelId: string): Promise<void> =>
+  service._call("closeDataChannel", [channelId])
+
+// ---- what the host's half has --------------------------------------------------------------------
+
+/** 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 const supports = (method?: Method): boolean =>
+  ServiceChannel.supports(NAME)   // every method is of version 1
+
+// ---- the client -----------------------------------------------------------------------------------
+
+/** One RTCPeerConnection: a session, created with its configuration, closed by the SDK's close(). */
+export class RtcPeerConnectionBase extends ServiceChannel<RtcPeerConnectionEvents> {
+  constructor(params: RtcConfiguration = {}) { super("RtcPeerConnection", NAME, params) }
+
+  /** Rejects with "failed" / "closed". */
+  createOffer(options?: OfferOptions): Promise<SessionDescription> { return createOffer(this, options) }
+  /** Rejects with "failed" / "closed". */
+  createAnswer(): Promise<SessionDescription> { return createAnswer(this) }
+  /** 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> { return setLocalDescription(this, description) }
+  /** Rejects with "failed" / "closed". */
+  setRemoteDescription(description: SessionDescription): Promise<void> { return setRemoteDescription(this, description) }
+  /** Without a candidate: the end of the remote candidates.
+   *  Rejects with "failed" / "closed". */
+  addIceCandidate(candidate?: IceCandidate): Promise<void> { return addIceCandidate(this, candidate) }
+  /** The next offer carries new ICE credentials. */
+  restartIce(): Promise<void> { return restartIce(this) }
+  /** Rejects with "failed". */
+  setConfiguration(configuration: RtcConfiguration): Promise<void> { return setConfiguration(this, configuration) }
+  /** 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> { return addTrack(this, trackId, streamIds) }
+  /** Rejects with "notFound" / "closed". */
+  removeTrack(senderId: string): Promise<void> { return removeTrack(this, senderId) }
+  /** Swap what a sender sends without renegotiating; null = send nothing.
+   *  Rejects with "notFound" / "failed" / "closed". */
+  replaceTrack(senderId: string, trackId: string | null): Promise<void> { return replaceTrack(this, senderId, trackId) }
+  /** Rejects with "notFound". */
+  getSenderParameters(senderId: string): Promise<SenderParameters> { return getSenderParameters(this, senderId) }
+  /** The encodings' active / bitrate / scale; the layers themselves are set at addTransceiver.
+   *  Rejects with "notFound" / "failed". */
+  setSenderParameters(senderId: string, parameters: SenderParameters): Promise<void> { return setSenderParameters(this, senderId, parameters) }
+  /** Rejects with "notFound" / "failed" / "closed". */
+  addTransceiver(kind: MediaKind, options?: TransceiverInit): Promise<TransceiverInfo> { return addTransceiver(this, kind, options) }
+  getTransceivers(): Promise<TransceiverInfo[]> { return getTransceivers(this) }
+  /** Rejects with "notFound" / "failed". */
+  setTransceiverDirection(transceiverId: string, direction: TransceiverDirection): Promise<void> { return setTransceiverDirection(this, transceiverId, direction) }
+  /** Rejects with "notFound". */
+  stopTransceiver(transceiverId: string): Promise<void> { return stopTransceiver(this, transceiverId) }
+  /** 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> { return getStats(this, trackId) }
+  /** Rejects with "failed" / "closed". */
+  createDataChannel(label: string, options?: DataChannelInit): Promise<DataChannelInfo> { return createDataChannel(this, label, options) }
+  /** Rejects with "notFound" / "closed". */
+  sendText(channelId: string, text: string): Promise<void> { return sendText(this, channelId, text) }
+  /** Rejects with "notFound" / "closed". */
+  sendBinary(channelId: string, data: Uint8Array): Promise<void> { return sendBinary(this, channelId, data) }
+  /** Bytes queued and not yet sent.
+   *  Rejects with "notFound". */
+  getBufferedAmount(channelId: string): Promise<number> { return getBufferedAmount(this, channelId) }
+  /** Rejects with "notFound". */
+  setBufferedAmountLowThreshold(channelId: string, threshold: number): Promise<void> { return setBufferedAmountLowThreshold(this, channelId, threshold) }
+  /** A no-op for an unknown id. */
+  closeDataChannel(channelId: string): Promise<void> { return closeDataChannel(this, channelId) }
+}