Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

refactor(webrtc): derive peer method options before native state

ldm08acdc4ba7d7f
diff --git a/moli-renderer-v8/src/context_bootstrap/webrtc.rs b/moli-renderer-v8/src/context_bootstrap/webrtc.rs
index 54629c3cf..106b39245 100644
--- a/moli-renderer-v8/src/context_bootstrap/webrtc.rs
+++ b/moli-renderer-v8/src/context_bootstrap/webrtc.rs
@@ -3,6 +3,7 @@ use crate::util::{
callback_data_index_value, callback_data_item, get_private_value, set_private_value,
};
use crate::web_api_interfaces;
+use crate::webidl::{self, WebIdlDictionarySerialize};
use moli_webapi_declare::{WebApiFunctionTemplate, WebApiObject};
mod configuration;
@@ -11,6 +12,7 @@ mod events;
mod ice_candidate;
mod ice_candidate_parser;
mod ice_error_event;
+mod peer_options;
mod session_description;
pub(in crate::context_bootstrap) use events::{
rtc_data_channel_event_constructor_callback, rtc_error_event_constructor_callback,
@@ -101,18 +103,6 @@ struct RtcPeerConnectionObjectDeclaration<'scope> {
struct RtcDataChannelObjectDeclaration<'scope> {
#[webapi(slot = RTC_DATA_CHANNEL_LABEL_SLOT)]
label: v8::Local<'scope, v8::String>,
- #[webapi(slot = RTC_DATA_CHANNEL_ORDERED_SLOT, init = true)]
- ordered: (),
- #[webapi(slot = RTC_DATA_CHANNEL_MAX_PACKET_LIFETIME_SLOT, init = "null")]
- max_packet_lifetime: (),
- #[webapi(slot = RTC_DATA_CHANNEL_MAX_RETRANSMITS_SLOT, init = "null")]
- max_retransmits: (),
- #[webapi(slot = RTC_DATA_CHANNEL_PROTOCOL_SLOT, init = "")]
- protocol: (),
- #[webapi(slot = RTC_DATA_CHANNEL_NEGOTIATED_SLOT, init = false)]
- negotiated: (),
- #[webapi(slot = RTC_DATA_CHANNEL_ID_SLOT, init = "null")]
- id: (),
#[webapi(slot = RTC_DATA_CHANNEL_READY_STATE_SLOT, init = string("connecting"))]
ready_state: (),
#[webapi(slot = RTC_DATA_CHANNEL_BUFFERED_AMOUNT_SLOT, init = 0)]
@@ -157,9 +147,9 @@ struct RtcPeerConnectionPrototypeDeclaration {
set_configuration: (),
#[webapi(method = "createDataChannel", length = 1, callback = rtc_peer_connection_create_data_channel_callback)]
create_data_channel: (),
- #[webapi(method = "createOffer", length = 0, callback = rtc_peer_connection_create_offer_callback)]
+ #[webapi(method = "createOffer", length = 0, callback = rtc_peer_connection_create_offer_callback, returns_promise)]
create_offer: (),
- #[webapi(method = "setLocalDescription", length = 0, callback = rtc_peer_connection_set_local_description_callback)]
+ #[webapi(method = "setLocalDescription", length = 0, callback = rtc_peer_connection_set_local_description_callback, returns_promise)]
set_local_description: (),
#[webapi(method, length = 0, callback = rtc_peer_connection_close_callback)]
close: (),
@@ -302,23 +292,45 @@ fn rtc_peer_connection_description_getter<'s>(
rv.set(get_private_value(scope, args.this(), slot).unwrap_or_else(|| v8::null(scope).into()));
}
+fn ensure_peer_open<'s>(scope: &mut v8::PinScope<'s, '_>, peer: v8::Local<'s, v8::Object>) -> bool {
+ let closed = get_private_value(scope, peer, RTC_PEER_CONNECTION_SIGNALING_STATE_SLOT)
+ .is_some_and(|value| value.strict_equals(v8str(scope, "closed").into()));
+ if closed {
+ crate::native_bridge::throw_dom_exception(
+ scope,
+ "InvalidStateError",
+ 11,
+ "RTCPeerConnection is closed.",
+ );
+ }
+ !closed
+}
+
fn rtc_peer_connection_create_data_channel_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
- if args.length() == 0 {
- throw_type_error(
- scope,
- "Failed to execute 'createDataChannel' on 'RTCPeerConnection': 1 argument required, but only 0 present.",
- );
+ let Some(parsed) = webidl::parse_args::<peer_options::DataChannelArgs>(scope, &args) else {
+ return;
+ };
+ if !ensure_peer_open(scope, args.this()) {
return;
}
- let Some(label) = args.get(0).to_string(scope) else {
+ let options = &parsed.options;
+ if parsed.label.len() > 65535
+ || options.protocol.len() > 65535
+ || options.id == Some(65535)
+ || (options.negotiated && options.id.is_none())
+ || (options.max_packet_lifetime.is_some() && options.max_retransmits.is_some())
+ {
+ throw_type_error(scope, "Invalid RTCDataChannel options.");
+ return;
+ }
+ let Some(label) = v8_string(scope, &parsed.label) else {
return;
};
- let Some(channel) = build_rtc_data_channel(scope, label) else {
- rv.set_undefined();
+ let Some(channel) = build_rtc_data_channel(scope, label, options) else {
return;
};
set_private_value(
@@ -335,20 +347,30 @@ fn rtc_peer_connection_create_offer_callback<'s>(
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
- let options = v8::Local::<v8::Object>::try_from(args.get(0)).ok();
- let audio = options
- .and_then(|options| options.get(scope, v8str(scope, "offerToReceiveAudio").into()))
- .is_some_and(|value| value.boolean_value(scope));
- let video = options
- .and_then(|options| options.get(scope, v8str(scope, "offerToReceiveVideo").into()))
- .is_some_and(|value| value.boolean_value(scope));
+ let Some(parsed) = webidl::parse_args::<peer_options::OfferArgs>(scope, &args) else {
+ return;
+ };
+ if !ensure_peer_open(scope, args.this()) {
+ return;
+ }
+ let audio = parsed.options.offer_to_receive_audio.unwrap_or(-1);
+ let video = parsed.options.offer_to_receive_video.unwrap_or(-1);
+ if !(-1..=1).contains(&audio) || !(-1..=1).contains(&video) {
+ crate::native_bridge::throw_dom_exception(
+ scope,
+ "InvalidAccessError",
+ 15,
+ "Invalid offer receive count.",
+ );
+ return;
+ }
let data = get_private_value(
scope,
args.this(),
RTC_PEER_CONNECTION_HAS_DATA_CHANNEL_SLOT,
)
.is_some_and(|value| value.boolean_value(scope));
- let sdp = build_signaling_only_offer(audio, video, data);
+ let sdp = build_signaling_only_offer(audio == 1, video == 1, data);
let Some(sdp) = v8_string(scope, &sdp) else {
rv.set_undefined();
return;
@@ -364,15 +386,29 @@ fn rtc_peer_connection_set_local_description_callback<'s>(
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
- let Ok(description) = v8::Local::<v8::Object>::try_from(args.get(0)) else {
- let reason = v8::Exception::type_error(
+ let Some(parsed) = webidl::parse_args::<peer_options::LocalDescriptionArgs>(scope, &args)
+ else {
+ return;
+ };
+ if !ensure_peer_open(scope, args.this()) {
+ return;
+ }
+ let kind = parsed
+ .description
+ .r#type
+ .unwrap_or(session_description::SdpType::Offer);
+ let mut sdp = parsed.description.sdp.into_value(scope);
+ if kind == session_description::SdpType::Offer && sdp.length() == 0 {
+ let data = get_private_value(
scope,
- v8str(
- scope,
- "Failed to execute 'setLocalDescription' on 'RTCPeerConnection': The provided value is not a session description.",
- ),
- );
- set_rejected_promise(scope, &mut rv, reason);
+ args.this(),
+ RTC_PEER_CONNECTION_HAS_DATA_CHANNEL_SLOT,
+ )
+ .is_some_and(|value| value.is_true());
+ sdp = v8_string(scope, &build_signaling_only_offer(false, false, data))
+ .expect("default offer SDP");
+ }
+ let Some(description) = session_description::native_description(scope, kind, sdp) else {
return;
};
set_private_value(
@@ -481,12 +517,16 @@ fn rtc_data_channel_send_callback<'s>(
fn build_rtc_data_channel<'s>(
scope: &mut v8::PinScope<'s, '_>,
label: v8::Local<'s, v8::String>,
+ options: &peer_options::DataChannelInit,
) -> Option<v8::Local<'s, v8::Object>> {
- let prototype = global_constructor_prototype(scope, "RTCDataChannel")?;
- let channel = v8::Object::new(scope);
+ let prototype =
+ exposed_interfaces::ensure_intrinsic_interface_prototype(scope, "RTCDataChannel").ok()?;
+ let channel =
+ exposed_interfaces::build_intrinsic_interface_instance(scope, "RTCDataChannel").ok()?;
if channel.set_prototype(scope, prototype.into()) != Some(true) {
return None;
}
+ options.initialize_snapshot(scope, channel)?;
RtcDataChannelObjectDeclaration::new(label)
.initialize(scope, channel)
.ok()?;
@@ -516,20 +556,6 @@ fn set_resolved_promise<'s>(
rv.set(promise.into());
}
-fn set_rejected_promise<'s>(
- scope: &mut v8::PinScope<'s, '_>,
- rv: &mut v8::ReturnValue<'_, v8::Value>,
- reason: v8::Local<'s, v8::Value>,
-) {
- let Some(resolver) = v8::PromiseResolver::new(scope) else {
- rv.set_undefined();
- return;
- };
- let promise = resolver.get_promise(scope);
- let _ = resolver.reject(scope, reason);
- rv.set(promise.into());
-}
-
fn build_signaling_only_offer(audio: bool, video: bool, data: bool) -> String {
let mut mids = Vec::new();
if audio {
diff --git a/moli-renderer-v8/src/context_bootstrap/webrtc/peer_options.rs b/moli-renderer-v8/src/context_bootstrap/webrtc/peer_options.rs
new file mode 100644
index 000000000..f5f6960d7
--- /dev/null
+++ b/moli-renderer-v8/src/context_bootstrap/webrtc/peer_options.rs
@@ -0,0 +1,62 @@
+use super::*;
+use crate::webidl;
+
+#[derive(webidl::WebIdlDictionary)]
+#[webidl(prefix = "RTCOfferAnswerOptions")]
+pub(super) struct OfferAnswerOptions {
+ #[webidl(default = true)]
+ #[webidl(name = "voiceActivityDetection")]
+ _voice_activity_detection: bool,
+}
+
+#[derive(webidl::WebIdlDictionary)]
+#[webidl(prefix = "RTCOfferOptions")]
+pub(super) struct OfferOptions {
+ #[webidl(inherit)]
+ _base: OfferAnswerOptions,
+ #[webidl(default = false)]
+ #[webidl(name = "iceRestart")]
+ _ice_restart: bool,
+ pub(super) offer_to_receive_audio: Option<i32>,
+ pub(super) offer_to_receive_video: Option<i32>,
+}
+
+#[derive(webidl::WebIdlArgs)]
+#[webidl(prefix = "RTCPeerConnection.createOffer")]
+pub(super) struct OfferArgs {
+ #[webidl(dictionary)]
+ pub(super) options: OfferOptions,
+}
+
+#[derive(webidl::WebIdlArgs)]
+#[webidl(prefix = "RTCPeerConnection.setLocalDescription")]
+pub(super) struct LocalDescriptionArgs<'s> {
+ #[webidl(dictionary)]
+ pub(super) description: session_description::SessionDescriptionInit<'s>,
+}
+
+#[derive(webidl::WebIdlDictionary)]
+#[webidl(prefix = "RTCDataChannelInit", snapshot)]
+pub(super) struct DataChannelInit {
+ #[webidl(nullable, converter = "enforce_range_unsigned_short", snapshot_slot = RTC_DATA_CHANNEL_ID_SLOT)]
+ pub(super) id: Option<u16>,
+ #[webidl(name = "maxPacketLifeTime", snapshot_slot = RTC_DATA_CHANNEL_MAX_PACKET_LIFETIME_SLOT, snapshot_default = v8::null(scope).into())]
+ pub(super) max_packet_lifetime: Option<u16>,
+ #[webidl(snapshot_slot = RTC_DATA_CHANNEL_MAX_RETRANSMITS_SLOT, snapshot_default = v8::null(scope).into())]
+ pub(super) max_retransmits: Option<u16>,
+ #[webidl(default = false, snapshot_slot = RTC_DATA_CHANNEL_NEGOTIATED_SLOT)]
+ pub(super) negotiated: bool,
+ #[webidl(default = true, snapshot_slot = RTC_DATA_CHANNEL_ORDERED_SLOT)]
+ ordered: bool,
+ #[webidl(default = "", converter = "usv_string", snapshot_slot = RTC_DATA_CHANNEL_PROTOCOL_SLOT)]
+ pub(super) protocol: String,
+}
+
+#[derive(webidl::WebIdlArgs)]
+#[webidl(prefix = "RTCPeerConnection.createDataChannel")]
+pub(super) struct DataChannelArgs {
+ #[webidl(required, converter = "usv_string")]
+ pub(super) label: String,
+ #[webidl(dictionary)]
+ pub(super) options: DataChannelInit,
+}
diff --git a/moli-renderer-v8/src/context_bootstrap/webrtc/session_description.rs b/moli-renderer-v8/src/context_bootstrap/webrtc/session_description.rs
index aaf5999e0..788e5faed 100644
--- a/moli-renderer-v8/src/context_bootstrap/webrtc/session_description.rs
+++ b/moli-renderer-v8/src/context_bootstrap/webrtc/session_description.rs
@@ -13,9 +13,9 @@ const DESCRIPTION_TYPE_SLOT: &str = "__moliRtcSessionDescriptionType";
const DESCRIPTION_SDP_SLOT: &str = "__moliRtcSessionDescriptionSdp";
const DESCRIPTION_SLOTS: &[&str] = &[DESCRIPTION_TYPE_SLOT, DESCRIPTION_SDP_SLOT];
-#[derive(Clone, Copy, webidl::WebIdlEnum)]
+#[derive(Clone, Copy, PartialEq, Eq, webidl::WebIdlEnum)]
#[webidl(name = "RTCSdpType", rename_all = "kebab-case")]
-enum SdpType {
+pub(super) enum SdpType {
Offer,
Pranswer,
Answer,
@@ -23,14 +23,14 @@ enum SdpType {
}
// The deprecated data-model constructor allows an omitted type. PeerConnection
-// description algorithms retain their own required description constraints.
+// description algorithms retain their own state and SDP constraints.
#[derive(webidl::WebIdlDictionary)]
#[webidl(prefix = "RTCSessionDescriptionInit")]
-struct SessionDescriptionInit<'s> {
+pub(super) struct SessionDescriptionInit<'s> {
#[webidl(converter = "raw", default = DictionaryDomString::default())]
- sdp: DictionaryDomString<'s>,
+ pub(super) sdp: DictionaryDomString<'s>,
#[webidl(converter = "enum")]
- r#type: Option<SdpType>,
+ pub(super) r#type: Option<SdpType>,
}
#[derive(webidl::WebIdlArgs)]
@@ -103,6 +103,29 @@ pub(in crate::context_bootstrap) fn rtc_session_description_constructor_callback
rv.set(args.this().into());
}
+pub(super) fn native_description<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ kind: SdpType,
+ sdp: v8::Local<'s, v8::String>,
+) -> Option<v8::Local<'s, v8::Object>> {
+ let object = super::super::exposed_interfaces::build_intrinsic_interface_instance(
+ scope,
+ "RTCSessionDescription",
+ )
+ .ok()?;
+ let prototype = super::super::exposed_interfaces::ensure_intrinsic_interface_prototype(
+ scope,
+ "RTCSessionDescription",
+ )
+ .ok()?;
+ object.set_prototype(scope, prototype.into())?;
+ let kind = v8str(scope, webidl::WebIdlEnumSnapshot::snapshot_token(&kind));
+ SessionDescriptionObjectDeclaration::new(kind.into(), sdp)
+ .initialize(scope, object)
+ .ok()?;
+ Some(object)
+}
+
fn description_attribute_getter<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/mod.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/mod.rs
index 4327737dc..7959e74a8 100644
--- a/moli-renderer-v8/src/script_vm/tests/browser_api/mod.rs
+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/mod.rs
@@ -59,6 +59,7 @@ mod promise_rejection;
mod request_init;
mod rtc_dictionary_init;
mod rtc_error;
+mod rtc_peer_dictionary;
mod security_policy;
mod security_policy_event_init;
mod service_worker_drain;
diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/rtc_peer_dictionary.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/rtc_peer_dictionary.rs
new file mode 100644
index 000000000..50478d345
--- /dev/null
+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/rtc_peer_dictionary.rs
@@ -0,0 +1,33 @@
+use super::*;
+
+#[test]
+fn rtc_peer_methods_convert_complete_dictionaries_before_native_state() {
+ let mut vm = new_storage_html_test_vm("https://rtc-peer-dictionary.test/");
+ vm.eval(&format!("globalThis.rtcPeerResult='pending'; ({}).then(value=>rtcPeerResult=value,error=>rtcPeerResult=String(error.stack||error));",include_str!("../../../../tests/fixtures/rtc-peer-dictionaries.js"))).unwrap();
+ vm.eval("0").unwrap();
+ assert_eq!(vm.eval("String(rtcPeerResult)").unwrap(), "true");
+}
+
+#[test]
+fn rtc_local_description_retains_native_snapshot_without_author_aliases() {
+ let mut vm = new_storage_html_test_vm("https://rtc-local-snapshot.test/");
+ vm.eval(r#"
+ globalThis.snapshotResult='pending';
+ (async()=>{
+ const peer=new RTCPeerConnection(), input={type:'offer',sdp:'native SDP\ud800'};
+ await peer.setLocalDescription(input);
+ input.sdp='changed'; input.type='answer';
+ const native=peer.localDescription;
+ if(!(native instanceof RTCSessionDescription) || native===input || native.sdp!=='native SDP\ud800' || native.type!=='offer') throw Error('snapshot');
+ const marker={};let caught;
+ try{await peer.setLocalDescription({get sdp(){throw marker;}});}catch(e){caught=e;}
+ if(caught!==marker || peer.localDescription!==native) throw Error('failed conversion changed state');
+ const original=globalThis.RTCSessionDescription;
+ try{globalThis.RTCSessionDescription=function(){throw Error('public constructor');};await peer.setLocalDescription({type:'offer',sdp:'second'});}finally{globalThis.RTCSessionDescription=original;}
+ if(peer.localDescription.sdp!=='second') throw Error('intrinsic snapshot');
+ peer.close();return true;
+ })().then(value=>snapshotResult=value,error=>snapshotResult=String(error.stack||error));
+ "#).unwrap();
+ vm.eval("0").unwrap();
+ assert_eq!(vm.eval("String(snapshotResult)").unwrap(), "true");
+}
diff --git a/moli-renderer-v8/src/script_vm/tests/declarative_receivers.rs b/moli-renderer-v8/src/script_vm/tests/declarative_receivers.rs
index 98b924c08..a029282d0 100644
--- a/moli-renderer-v8/src/script_vm/tests/declarative_receivers.rs
+++ b/moli-renderer-v8/src/script_vm/tests/declarative_receivers.rs
@@ -29,9 +29,12 @@ fn webrtc_declarations_validate_foreign_receivers_before_converting_arguments()
const channel = pc.createDataChannel('foreign');
getters(realm, 'RTCPeerConnection', pc, ['signalingState', 'iceGatheringState', 'iceConnectionState',
'connectionState', 'localDescription', 'currentLocalDescription', 'pendingLocalDescription']);
- for (const name of ['getConfiguration', 'setConfiguration', 'createDataChannel', 'createOffer', 'setLocalDescription', 'close']) {
+ for (const name of ['getConfiguration', 'setConfiguration', 'createDataChannel', 'close']) {
check(realm, pc, realm.RTCPeerConnection.prototype[name]);
}
+ for (const name of ['createOffer', 'setLocalDescription']) {
+ check(realm, pc, realm.RTCPeerConnection.prototype[name], true);
+ }
assert(realm.RTCPeerConnection.prototype.createDataChannel.call(pc, 'borrowed').label === 'borrowed', 'foreign peer method');
getters(realm, 'RTCDataChannel', channel, ['label', 'ordered', 'maxPacketLifeTime', 'maxRetransmits',
'protocol', 'negotiated', 'id', 'readyState', 'bufferedAmount', 'binaryType']);
diff --git a/moli-renderer-v8/tests/fixtures/rtc-peer-dictionaries.js b/moli-renderer-v8/tests/fixtures/rtc-peer-dictionaries.js
new file mode 100644
index 000000000..5f32a4571
--- /dev/null
+++ b/moli-renderer-v8/tests/fixtures/rtc-peer-dictionaries.js
@@ -0,0 +1,44 @@
+(async () => {
+ const assert=(value,label)=>{if(!value)throw Error(label);};
+ const peer=new RTCPeerConnection();peer.close();
+ const cases=[
+ ['createOffer',x=>peer.createOffer(x),['voiceActivityDetection','iceRestart','offerToReceiveAudio','offerToReceiveVideo'],true],
+ ['setLocalDescription',x=>peer.setLocalDescription(x),['sdp','type'],true],
+ ['createDataChannel',x=>peer.createDataChannel('label',x),['id','maxPacketLifeTime','maxRetransmits','negotiated','ordered','protocol'],false]
+ ];
+ for(const [name,call,members,promised] of cases) {
+ for(const key of members)for(const sentinel of [{},null,undefined,7]){
+ const reads=[];let caught=Symbol(),returned=false;
+ try{const value=call(new Proxy({}, {get(_,member){reads.push(member);if(member===key)throw sentinel;return undefined;},has(){throw Error('Get required');}}));returned=value instanceof Promise;await value;}catch(e){caught=e;}
+ assert(returned===promised && caught===sentinel,name+'/'+key+' error boundary');
+ assert(reads.join()===members.slice(0,members.indexOf(key)+1).join(),name+'/'+key+' conversion order');
+ }
+ const reads=[];let caught;
+ try{await call(new Proxy({}, {get(_,key){reads.push(key);return undefined;}}));}catch(e){caught=e;}
+ assert(caught?.name==='InvalidStateError' && reads.join()===members.join(),name+' full conversion before closed state');
+ for(const value of [1,true,'options',1n,Symbol()]){
+ let caught;try{await call(value);}catch(e){caught=e;}
+ assert(caught instanceof TypeError,name+' primitive dictionary');
+ }
+ }
+ for(const key of ['offerToReceiveAudio','offerToReceiveVideo']){
+ const sentinel={};let caught;
+ try{await peer.createOffer({[key]:{valueOf(){throw sentinel;}}});}catch(e){caught=e;}
+ assert(caught===sentinel,'offer long conversion');
+ }
+ const live=new RTCPeerConnection();
+ try{
+ const channel=live.createDataChannel('\ud800',{ordered:false,negotiated:true,id:7,protocol:'\ud800',maxRetransmits:null});
+ assert(channel.label==='\ufffd' && channel.protocol==='\ufffd' && !channel.ordered && channel.negotiated && channel.id===7 && channel.maxRetransmits===0 && channel.maxPacketLifeTime===null,'native channel options');
+ channel.close();
+ const wrapped=live.createDataChannel('wrapped',{maxPacketLifeTime:65536});
+ assert(wrapped.maxPacketLifeTime===0,'ordinary ushort wraps');wrapped.close();
+ for(const init of [{id:-1},{id:65536},{id:65535},{negotiated:true},{maxPacketLifeTime:1,maxRetransmits:1}]){
+ let caught;try{live.createDataChannel('bad',init);}catch(e){caught=e;}
+ assert(caught instanceof TypeError,'invalid channel options');
+ }
+ let caught;try{await live.createOffer({offerToReceiveAudio:2});}catch(e){caught=e;}
+ assert(caught?.name==='InvalidAccessError','unsupported offer receive count');
+ }finally{live.close();}
+ return true;
+})()