@yz-social/webrtc 0.1.0 → 0.1.2

package/.github/workflows/ci.yml

@@ -0,0 +1,27 @@
+name: CI/CD Build and Test
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+  workflow_dispatch: # Allows manual running
+
+jobs:
+  build-and-test:
+    runs-on: ubuntu-latest # Uses the latest Ubuntu runner
+
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v5 # Action to check out your repository code
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4 # Action to set up Node.js environment
+        with:
+          node-version: '22.x'
+
+      - name: Install Dependencies
+        run: npm i # Some folks recommend 'npm ci', but I don't like the required package lock.
+
+      - name: Run Tests
+        run: npm test # Executes the 'test' script defined in your package.json

package/index.js

@@ -18,6 +18,19 @@ export class WebRTC {
     // https://xirsys.com/pricing/ 500 MB/month (50 GB/month for $33/month)
     // Also https://www.npmjs.com/package/node-turn or https://meetrix.io/blog/webrtc/coturn/installation.html
   ];
+  cleanup() { // Attempt to allow everything to be garbage-collected.
+    if (!this.pc) return;
+    this.pc.onicecandidate = this.pc.ondatachannel = this.pc.onnegotiationneeded = this.pc.onconnectionstatechange = null;
+    delete this.pc;
+    delete this.dataChannelPromises;
+    delete this.dataChannelOursPromises;
+    delete this.dataChannelTheirsPromises;
+  }
+
+  // Number of instances at a time (if previous have been garbage collected), as of 1/27/26:
+  static suggestedInstancesLimit = globalThis.navigator.vendor?.startsWith('Apple') ? 95 : // Seems to be hardcoded?
+    globalThis.navigator.userAgent?.includes('Firefox') ? 190 :
+    200;
   constructor({configuration = {iceServers: WebRTC.iceServers}, ...properties}) {
     Object.assign(this, properties);
 
@@ -26,14 +39,17 @@ export class WebRTC {
     promise.resolve = resolve;
     this.closed = promise;
     // Safari doesn't fire signalingstatechange for closing activity.
-    this.pc.addEventListener('connectionstatechange', () => { // Only fires by action from other side.
-      const state = this.pc.connectionState;
+    this.pc.onconnectionstatechange = () => { // Only fires by action from other side.
+      const pc = this.pc;
+      if (!pc) return null;
+      const state = pc.connectionState;
       if (state === 'connected') return this.signalsReadyResolver?.();
       if (['new', 'connecting'].includes(state)) return null;
       // closed, disconnected, failed: resolve this.closed promise.
-      this.log('connectionstatechange signaling/connection:', this.pc.signalingState, state);
-      return resolve(this.pc);
-    });
+      this.log('connectionstatechange signaling/connection:', pc.signalingState, state);
+      this.cleanup();
+      return resolve(pc);
+    };
 
     this.connectionStartTime = Date.now();
     this.makingOffer = false;
@@ -62,8 +78,11 @@ export class WebRTC {
   }
   async close() {
     // Do not try to close or wait for data channels. It confuses Safari.
-    this.pc.close();
-    this.closed.resolve(this.pc); // We do not automatically receive 'connectionstatechange' when our side explicitly closes. (Only if the other does.)
+    const pc = this.pc;
+    if (!pc) return null;
+    pc.close();
+    this.closed.resolve(pc); // We do not automatically receive 'connectionstatechange' when our side explicitly closes. (Only if the other does.)
+    this.cleanup();
     return this.closed;
   }
   flog(...rest) {
@@ -80,6 +99,7 @@ export class WebRTC {
   explicitRollback = typeof(globalThis.process) !== 'undefined';
   async onSignal({ description, candidate }) {
     // Most of this and onnegotiationneeded is from https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API/Perfect_negotiation
+    if (!this.pc) return;
     if (description) {
       const offerCollision =
         description.type === "offer" &&
@@ -181,40 +201,44 @@ export class WebRTC {
     if (!this.transferSignals) return; // Just keep collecting until the next call to respond();
     this.sendPending();
   }
-  followupTimer = null;
+  //followupTimer = null;
   sendPending(force = false) { // Send over any signals we have, and process the response.
     this.lastOutboundSignal = Date.now();
-    clearTimeout(this.followupTimer);
+    //clearTimeout(this.followupTimer);
     this.transferSerializer = this.transferSerializer.then(() => {
       const signals = this.collectPendingSignals();
       if (!force && !signals.length) return null; // A stack of pending signals got rolled together and pending is now empty.
       this.lastOutboundSend = Date.now();
       this.log('sending', signals.length, 'signals');
       return this.transferSignals(signals).then(async response => {
-	clearTimeout(this.followupTimer);
+	//clearTimeout(this.followupTimer);
 	this.lastResponse = Date.now();
 	await this.onSignals(response);
-	if (this.pc.connectionState === 'connected') return;
-	this.followupTimer = setTimeout(() => { // We may have sent everything we had, but still need to poke in order to get more ice from them.
-	  if (this.pc.connectionState === 'connected') return;
-	  this.log('************** nothing new to send', this.pc.connectionState, ' ************************');
-	  this.sendPending(true);
-	}, 500);
+	// if (this.pc.connectionState === 'connected') return;
+	// this.followupTimer = setTimeout(() => { // We may have sent everything we had, but still need to poke in order to get more ice from them.
+	//   if (this.pc.connectionState === 'connected') return;
+	// Note: if we bring this back, stop after closed!
+	//   this.log('************** nothing new to send', this.pc.connectionState, ' ************************');
+	//   this.sendPending(true);
+	// }, 500);
       });
     });
   }
   transferSerializer = Promise.resolve();
 
-  dataChannels = {};
-  setupChannel(dc) { // Given an open or connecting channel, set it up in a unform way.
-    this.log('setup:', dc.label, dc.id, dc.readyState, 'negotiated:', dc.negotiated, 'exists:', !!this[dc.label]);
-    this[dc.label] = this.dataChannels[dc.label] = dc;
+  setupChannel(dc) { // Arrange for the data channel promise to resolve open, and do other setup.
+    // Called by explicit createChannel ('ours' opened) and also by ondatachannel ('theirs' opened).
+    const { label, readyState } = dc;
+    const isTheirs = readyState === 'open'; // Came via ondatachannel.
+    this.log('setupChannel:', label, dc.id, readyState, 'negotiated:', dc.negotiated);
+    const kind = isTheirs ? 'Theirs' : 'Ours';
     dc.webrtc = this;
-    dc.onopen = async () => {
-      this.log('channel onopen:', dc.label, dc.id, dc.readyState, 'negotiated:', dc.negotiated);
-      this.dataChannelPromises[dc.label]?.resolve(this[dc.label]);
+    dc.onopen = async () => { // Idempotent (except for logging), if we do not bash dataChannePromises[label] multiple times.
+      this.log('channel onopen:', label, dc.id, readyState, 'negotiated:', dc.negotiated);
+      this[this.restrictablePromiseKey()][label]?.resolve(dc);
+      this[this.restrictablePromiseKey(kind)][label]?.resolve(dc);
     };
-    if (dc.readyState === 'open') dc.onopen();
+    if (isTheirs) dc.onopen();
     return dc;
   }
   ondatachannel(dc) {
@@ -229,10 +253,18 @@ export class WebRTC {
     return this.setupChannel(this.pc.createDataChannel(name, {negotiated, id, ...options}));
   }
   dataChannelPromises = {};
-  getDataChannelPromise(name = 'data') { // Promise to resolve when opened, WITHOUT actually creating one.
+  dataChannelOursPromises = {};
+  dataChannelTheirsPromises = {};  
+  restrictablePromiseKey(restriction = '') { // The property in which store dataChannel promises of the specified restriction.
+    return `dataChannel${restriction}Promises`;
+  }
+  getDataChannelPromise(name = 'data', restriction = '') { // Promise to resolve when opened, WITHOUT actually creating one.
+    // The application can restrict this to being only a channel of 'ours' or 'theirs' (see setupChannel), which is useful for
+    // non-negotiated channels.
+    const key = this.restrictablePromiseKey(restriction);
     const {promise, resolve, reject} = Promise.withResolvers();
     Object.assign(promise, {resolve, reject});
-    return this.dataChannelPromises[name] = promise;
+    return this[key][name] = promise;
   }
 
   async reportConnection(doLogging = false) { // Update self with latest wrtc stats (and log them if doLogging true). See Object.assign for properties.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yz-social/webrtc",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Streamlined portable webrtc management of p2p and client2server.",
   "keywords": [
     "webrtc",

package/spec/portal.js

@@ -0,0 +1,64 @@
+import process from 'node:process';
+import cluster from 'node:cluster';
+import express from 'express';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { WebRTC } from '../index.js';
+
+// A minimal webrtc web portal server.
+// Peers may POST signals to /join/<n> in order to connect (one at a time!) to a WebRTC node running at id <n>.
+// Two such POSTs are typically required.
+// The WebRTC does nothing except say 'Welcome!' on the data channel opened by the client.
+// For a more complete example, see https://github.com/YZ-social/kdht/blob/main/spec/portal.js
+
+const nPortals = parseInt(process.argv[2] || WebRTC.suggestedInstancesLimit);
+
+if (cluster.isPrimary) { // Parent process with portal webserver through which clienta can bootstrap
+  process.title = 'webrtc-test-portal';
+  const app = express();  
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = path.dirname(__filename);
+  console.log('launching', nPortals, 'portals');
+  for (let i = 0; i < nPortals; i++) {
+    const worker = cluster.fork();
+    worker.on('message', signals => { // Message from a worker, in response to a POST.
+      worker.requestResolver?.(signals);
+    });
+  }
+  const workers = Object.values(cluster.workers);
+  app.use(express.json());
+  app.use(express.static(path.resolve(__dirname, '..'))); // Serve files needed for testing browsers.
+  app.post('/join/:to', async (req, res, next) => { // Handler for JSON POST requests that provide an array of signals and get signals back.
+    const {params, body} = req;
+    // Find the specifed worker, or pick one at random. TODO CLEANUP: Remove. We now use as separate /name/:label to pick one.
+    const worker = workers[params.to];
+    if (!worker) {
+      console.warn('no worker', params.to);
+      return res.sendStatus(404);
+    }
+
+    // Pass the POST body to the worker and await the response.
+    const promise = new Promise(resolve => worker.requestResolver = resolve);
+    worker.send(body, undefined, undefined, error =>
+      error && console.log(`Error communicating with portal worker ${worker.id}:`, error));
+    let response = await promise;
+    delete worker.requestResolver; // Now that we have the response.
+
+    return res.send(response);
+  });
+  app.listen(3000);
+} else {
+  process.title = 'webrtc-test-bot-' + cluster.worker.id;
+  let portal;
+  process.on('message', async incomingSignals => { // Signals from a sender through the server.
+    const response = await portal.respond(incomingSignals);
+    process.send(response);
+  });
+  function setup() {
+    console.log(new Date(), 'launched bot', cluster.worker.id);
+    portal = new WebRTC({name: 'portal'});
+    portal.getDataChannelPromise('data').then(dc => dc.send('Welcome!'));
+    portal.closed.then(setup); // Without any explicit message, this is 15 seconds after the other end goes away.
+  }
+  setup();
+}

package/spec/test.html

@@ -9,6 +9,7 @@
     <script src="../jasmine-standalone-5.7.1/lib/jasmine-5.7.1/boot1.js"></script>
     <script type="module">
       import './webrtcSpec.js';
+      import './webrtcCapacitySpec.js';      
     </script>
   </head>
 </html>

package/spec/webrtcCapacitySpec.js

@@ -0,0 +1,68 @@
+const { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach} = globalThis; // For linters.
+import { WebRTC } from '../index.js';
+
+describe("WebRTC capacity", function () {
+  let nNodes = 20; // When running all webrtc tests at once, it is important to keep this low. (Memory leak?)
+
+  // Uncomment this line if running a stand-alone capacity test.
+  // (And also likely comment out the import './webrtcSpec.js' in test.html.)
+  // nNodes = WebRTC.suggestedInstancesLimit;
+
+  const isNodeJS = typeof(globalThis.process) !== 'undefined';
+  let nodes = [];
+  beforeAll(async function () {
+
+    if (isNodeJS) {
+      const { spawn } = await import('node:child_process');
+      const path = await import('path');
+      const { fileURLToPath } = await import('url');
+
+      const __filename = fileURLToPath(import.meta.url);
+      const __dirname = path.dirname(__filename);
+      function echo(data) { data = data.slice(0, -1); console.log(data.toString()); }
+      const portalProcess = spawn('node', [path.resolve(__dirname, 'portal.js'), nNodes]);
+      portalProcess.stdout.on('data', echo);
+      portalProcess.stderr.on('data', echo);
+      await new Promise(resolve => setTimeout(resolve, 6e3));
+    }
+
+    console.log(new Date(), 'creating', nNodes, 'nodes');
+    for (let index = 0; index < nNodes; index++) {
+      const node = nodes[index] = new WebRTC({name: 'node'});
+      node.transferSignals = messages => fetch(`http://localhost:3000/join/${index}`, {
+	method: 'POST',
+	headers: { 'Content-Type': 'application/json', 'Connection': 'close' },
+	body: JSON.stringify(messages)
+      }).then(response => response.json());
+      node.closed.then(() => console.log('closed', index)); // Just for debugging.
+      const dataOpened = node.getDataChannelPromise('data')
+	    .then(dc => node.dataReceived = new Promise(resolve => dc.onmessage = event => resolve(event.data)));
+      node.createChannel('data', {negotiated: false});      
+      await dataOpened;
+      console.log('opened', index);
+    }
+    console.log(new Date(), 'finished setup');
+  }, Math.max(20e3, nNodes * (500 + 300)));
+  for (let index = 0; index < nNodes; index++) {
+    it('opened connection ' + index, function () {      
+      expect(nodes[index].pc.connectionState).toBe('connected');
+    });
+    it('got data ' + index, async function () {
+      expect(await nodes[index].dataReceived).toBe('Welcome!');
+    });
+  }
+  afterAll(async function () {
+    console.log(new Date(), 'starting teardown');
+    for (let index = 0; index < nNodes; index++) {
+      const node = nodes[index];
+      expect(node.pc.connectionState).toBe('connected');
+      await node.close().then(pc =>
+	expect(pc.connectionState).toBe('closed'));
+      delete nodes[index];
+    }
+    if (isNodeJS) {
+      const { exec } = await import('node:child_process');      
+      exec('pkill webrtc-test-');
+    }
+  });
+});

package/spec/webrtcSpec.js

@@ -3,11 +3,6 @@ import { WebRTC } from '../index.js';
 
 describe("WebRTC", function () {
   const isBrowser = typeof(process) === 'undefined';
-  // maximums
-  // 1 channel pair, without negotiated on first signal: nodejs:83, firefox:150+, safari:85+ but gets confused with closing, chrome/edge:50(?)
-  // 50 works across the board with one channel pair
-  // On Safari (only), anything more than 32 pair starts to loose messages on the SECOND channel.
-  const nPairs = 32; //32;
   let connections = [];
   describe("direct in-process signaling", function () {
     function makePair({debug = false, delay = 0, index = 0} = {}) {
@@ -15,25 +10,13 @@ describe("WebRTC", function () {
       const configuration = { iceServers: WebRTC.iceServers };
       const A = new WebRTC({name: `A (impolite) ${index}`, polite: false, debug, configuration});
       const B = new WebRTC({name: `B (polite) ${index}`, polite: true, debug, configuration});
-      async function sendingSetup(dc) { // Given an open channel, set up to receive a message and then send a test message.
-        const webrtc = dc.webrtc;
-        webrtc.receivedMessageCount = webrtc.sentMessageCount = 0;
-	webrtc.gotData = new Promise(resolve => {
-          dc.onmessage = e => {
-            webrtc.receivedMessageCount++;
-            webrtc.log('got message on', dc.label, dc.id, e.data);
-	    resolve(e.data);
-          };
-	});
-        webrtc.sentMessageCount++;
-
         // Subtle:
         //
         // An explicit createChannel() arranges for the promise created by getDataChannelPromise() of the same name to
         // resolve on that side of the connection when the channel is open. The other side will internally receive a
         // datachannel event and we arrange for that side to then also resolve a getDataChannelPromise for that name.
         //
-        // If only wide side creates the channel, things work out smoothly. Each side ends up resolving the promise for a
+        // If only one side creates the channel, things work out smoothly. Each side ends up resolving the promise for a
         // channel of the given name. The id is as defaulted or specified if negotiated:true, else an internally determined
         // unique id is used.
         //
@@ -41,24 +24,47 @@ describe("WebRTC", function () {
         // are overlappaing offers. One side backs down and there ends up being one channel with the specified id. (The default
         // id will be the same on both sides IFF any multiple data channels are created in the same order on both sides.)
         //
-        // However, when negotiated:false, and both sides call createChannel simultaneously, things get complex. Counterintuitively,
-        // RTCPeerConnection arranges for the internall determined id to be unique between the two sides, so both get
+        // However, when negotiated:FALSE, and both sides call createChannel with a delay in betwen, things get complex. Counterintuitively,
+        // RTCPeerConnection arranges for the internally determined id to be unique between the two sides, so both get
         // two channels with the same name and different id. There will be two internal open events on each side: first for the
-        // channel that it created, and second for one that the other side created. There isn't any reason to do this (as
+        // channel that it created, and second for one that the other side created. (There likely isn't any reason to do this, as
         // opposed to specifying negotiated:true, unless the application needs each side to listen on one channel and send
-        // on the other. However, getDataChannelPromise return a promise based on the specified name alone, and it only
-        // resolves once. For compatibility with the single-sided case, we resolve the first channel (on each side, which
-        // are different ids). Thus we must attach onmessage to one channel and send on the other. On both sides, the
-        // first channel is what the promise resolves to, but after a delay, the second channel is available on webrtc[channelName].
-
-        if (!delay) return dc.send(`Hello from ${webrtc.name}`);
+        // on the other.)
+      async function receivingSetup(dc) {
+        const webrtc = dc.webrtc;
+        webrtc.log('got open recieving channel', dc.label, dc.id);
+	webrtc.ours = dc;
+	webrtc.receivedMessageCount = 0;
+	webrtc.gotData = new Promise(resolve => webrtc.gotDataResolver = resolve);
+        dc.onmessage = e => {
+          webrtc.receivedMessageCount++;
+          webrtc.log('got message on', dc.label, dc.id, e.data);
+	  webrtc.gotDataResolver(e.data);
+	};
+	return dc;
+      }
+      async function sendingSetup(dc) {
+        const webrtc = dc.webrtc;
+	webrtc.log('got open sending channel', dc.label, dc.id);
+	webrtc.theirs = dc;
+        webrtc.sentMessageCount ||= 0;
+	webrtc.sentMessageCount++;
         await WebRTC.delay(delay);
-        webrtc.data.send(`Hello from ${webrtc.name}`);
-        return null;
+	dc.send(`Hello from ${webrtc.name}`);
+	return dc;
+      }
+      const promises = [];
+      if (!delay) {
+	promises.push(A.getDataChannelPromise('data').then(receivingSetup).then(sendingSetup));
+	promises.push(B.getDataChannelPromise('data').then(receivingSetup).then(sendingSetup));
+      } else {
+	promises.push(A.getDataChannelPromise('data', 'Ours').then(receivingSetup));
+	promises.push(B.getDataChannelPromise('data', 'Ours').then(receivingSetup));
+	promises.push(A.getDataChannelPromise('data', 'Theirs').then(sendingSetup));
+	promises.push(B.getDataChannelPromise('data', 'Theirs').then(sendingSetup));
       }
-      const aOpen = A.getDataChannelPromise('data').then(sendingSetup);
-      const bOpen = B.getDataChannelPromise('data').then(sendingSetup);
-      const direct = false; // Does signal work direct/one-sided to the other? False makes a request that waits for a response.
+	
+      const direct = true; // Does signal work direct/one-sided to the other? False makes a request that waits for a response.
       if (direct) {
 	A.signal = message => B.onSignal(message);
 	B.signal = message => A.onSignal(message);
@@ -66,12 +72,27 @@ describe("WebRTC", function () {
 	A.transferSignals = messages => B.respond(messages);
 	B.transferSignals = messages => A.respond(messages);
       }
-      return connections[index] = {A, B, bothOpen: Promise.all([aOpen, bOpen])};
+      return connections[index] = {A, B, bothOpen: Promise.all(promises)};
     }
-    function standardBehavior(setup, {includeConflictCheck = isBrowser, includeSecondChannel = true} = {}) {
+    function standardBehavior(setup, {includeConflictCheck = isBrowser, includeSecondChannel = false} = {}) {
+      // The nPairs does NOT seem to be a reliable way to determine how many webrtc peers can be active in the same Javascript.
+      // I have had numbers that work for every one of the cases DESCRIBEd below, and even in combinations,      
+      // but it seems to get upset when all are run together, and it seemms to depend on the state of the machine or phases of the moon.
+      // When it fails, it just locks up with no indication of what is happening.
+      // Maybe a memory / memory-leak issue?
+      //
+      // Some observed behaviors, at some point in time, include:
+      // 1 channel pair, without negotiated on first signal: nodejs:83, firefox:150+, safari:85+ but gets confused with closing, chrome/edge:50(?)
+      // 50 works across the board with one channel pair
+      // On Safari (only), anything more than 32 pair starts to loose messages on the SECOND channel.
+      // In NodeJS with includeSecondChannel: 32
+      // In NodeJS witout includeSecondChannel: 62, 75, even 85, but not consistently.
+      //
+      // webrtcCapacitySpec.js may be a better test for capacity.
+      const nPairs = 10;
       beforeAll(async function () {
         const start = Date.now();
-        console.log('start setup');
+        console.log(new Date(), 'start setup', nPairs, 'pairs');
         for (let index = 0; index < nPairs; index++) {
           await setup({index});
         }
@@ -81,8 +102,10 @@ describe("WebRTC", function () {
       for (let index = 0; index < nPairs; index++) {
         it(`connects ${index}.`, function () {
           const {A, B} = connections[index];
-          expect(A.data.readyState).toBe('open');
-          expect(B.data.readyState).toBe('open');
+          expect(A.ours.readyState).toBe('open');
+          expect(B.ours.readyState).toBe('open');
+          expect(A.theirs.readyState).toBe('open');
+          expect(B.theirs.readyState).toBe('open');
         });
         it(`receives ${index}.`, async function () {
           const {A, B} = connections[index];    
@@ -132,8 +155,9 @@ describe("WebRTC", function () {
             expect(apc.signalingState).toBe('closed');
 	    const bpc = await B.closed; // Waiting for B to notice.
 	    await B.close(); // Resources are not necessarilly freed when the other side closes. An explicit close() is needed.
-            expect(['closed', 'disconnected', 'failed']).toContain(B.pc.connectionState);
-	    expect(bpc.signalingState).toBe('closed');
+            expect(['closed', 'disconnected', 'failed']).toContain(bpc.connectionState);
+	    expect(['closed', 'stable']).toContain(bpc.signalingState);
+	    delete connections[index];
 	  });
           promises.push(promise);
         }
@@ -143,6 +167,7 @@ describe("WebRTC", function () {
     }
     describe("one side opens", function () {
       describe('non-negotiated', function () {
+	beforeAll(function () {console.log('one-sided non-negotiated'); });
         standardBehavior(async function ({index}) {
           const {A, B, bothOpen} = makePair({index});
           A.createChannel('data', {negotiated: false});
@@ -150,6 +175,7 @@ describe("WebRTC", function () {
         }, {includeConflictCheck: false, includeSecondChannel: false});
       });
       describe("negotiated on first signal", function () {
+	beforeAll(function () {console.log('one-sided negotiated'); });
         standardBehavior(async function ({index}) {
           const {A, B, bothOpen} = makePair({index});
           // There isn't really a direct, automated way to have one side open another with negotiated:true,
@@ -173,6 +199,7 @@ describe("WebRTC", function () {
     describe("simultaneous two-sided", function () {
       describe("negotiated single full-duplex-channel", function () {
         describe("impolite first", function () {
+	  beforeAll(function () {console.log('two-sided negotiated impolite-first'); });
           standardBehavior(async function ({index}) {
             const {A, B, bothOpen} = makePair({index});     
             A.createChannel("data", {negotiated: true});
@@ -181,6 +208,7 @@ describe("WebRTC", function () {
           });
         });
         describe("polite first", function () {
+	  beforeAll(function () {console.log('two-sided negotiated polite-first');});
           standardBehavior(async function ({index}) {
             const {A, B, bothOpen} = makePair({index});
             B.createChannel("data", {negotiated: true});
@@ -190,18 +218,21 @@ describe("WebRTC", function () {
         });
       });
       describe("non-negotiated dual half-duplex channels", function () {
-        const delay = 10;
+        const delay = 200;
+	const debug = false;
         describe("impolite first", function () {
+	  beforeAll(function () {console.log('two-sided non-negotiated impolite-first');});
           standardBehavior(async function ({index}) {
-            const {A, B, bothOpen} = makePair({delay, index});
+            const {A, B, bothOpen} = makePair({delay, index, debug});
             A.createChannel("data", {negotiated: false});
             B.createChannel("data", {negotiated: false});
             await bothOpen;
           });
         });
         describe("polite first", function () {
+	  beforeAll(function () {console.log('two-sided non-negotiated polite-first');});
           standardBehavior(async function ({index}) {
-            const {A, B, bothOpen} = makePair({delay, index});
+            const {A, B, bothOpen} = makePair({delay, index, debug});
             B.createChannel("data", {negotiated: false});
             A.createChannel("data", {negotiated: false});
             await bothOpen;