npm - @yz-social/webrtc - Versions diffs - 0.0.5 → 0.1.0 - Mend

@yz-social/webrtc 0.0.5 → 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (22) hide show

package/README.md +10 -0
package/index.js +268 -2
package/jasmine-standalone-5.7.1/LICENSE +21 -0
package/jasmine-standalone-5.7.1/SpecRunner.html +28 -0
package/jasmine-standalone-5.7.1/lib/jasmine-5.7.1/boot0.js +66 -0
package/jasmine-standalone-5.7.1/lib/jasmine-5.7.1/boot1.js +134 -0
package/jasmine-standalone-5.7.1/lib/jasmine-5.7.1/jasmine-html.js +971 -0
package/jasmine-standalone-5.7.1/lib/jasmine-5.7.1/jasmine.css +301 -0
package/jasmine-standalone-5.7.1/lib/jasmine-5.7.1/jasmine.js +11399 -0
package/jasmine-standalone-5.7.1/lib/jasmine-5.7.1/jasmine_favicon.png +0 -0
package/jasmine-standalone-5.7.1/spec/PlayerSpec.js +58 -0
package/jasmine-standalone-5.7.1/spec/SpecHelper.js +15 -0
package/jasmine-standalone-5.7.1/src/Player.js +22 -0
package/jasmine-standalone-5.7.1/src/Song.js +6 -0
package/package.json +2 -5
package/spec/test.html +14 -0
package/spec/webrtcSpec.js +198 -143
package/lib/datachannels.js +0 -144
package/lib/peerevents.js +0 -56
package/lib/utilities.js +0 -92
package/lib/webrtc.js +0 -57
package/lib/webrtcbase.js +0 -42

package/jasmine-standalone-5.7.1/lib/jasmine-5.7.1/jasmine_favicon.png ADDED Viewed

Binary file

package/jasmine-standalone-5.7.1/spec/PlayerSpec.js ADDED Viewed

@@ -0,0 +1,58 @@
+describe('Player', function() {
+  let player;
+  let song;
+  beforeEach(function() {
+    player = new Player();
+    song = new Song();
+  });
+  it('should be able to play a Song', function() {
+    player.play(song);
+    expect(player.currentlyPlayingSong).toEqual(song);
+    // demonstrates use of custom matcher
+    expect(player).toBePlaying(song);
+  });
+  describe('when song has been paused', function() {
+    beforeEach(function() {
+      player.play(song);
+      player.pause();
+    });
+    it('should indicate that the song is currently paused', function() {
+      expect(player.isPlaying).toBeFalsy();
+      // demonstrates use of 'not' with a custom matcher
+      expect(player).not.toBePlaying(song);
+    });
+    it('should be possible to resume', function() {
+      player.resume();
+      expect(player.isPlaying).toBeTruthy();
+      expect(player.currentlyPlayingSong).toEqual(song);
+    });
+  });
+  // demonstrates use of spies to intercept and test method calls
+  it('tells the current song if the user has made it a favorite', function() {
+    spyOn(song, 'persistFavoriteStatus');
+    player.play(song);
+    player.makeFavorite();
+    expect(song.persistFavoriteStatus).toHaveBeenCalledWith(true);
+  });
+  //demonstrates use of expected exceptions
+  describe('#resume', function() {
+    it('should throw an exception if song is already playing', function() {
+      player.play(song);
+      expect(function() {
+        player.resume();
+      }).toThrowError('song is already playing');
+    });
+  });
+});

package/jasmine-standalone-5.7.1/spec/SpecHelper.js ADDED Viewed

@@ -0,0 +1,15 @@
+beforeEach(function () {
+  jasmine.addMatchers({
+    toBePlaying: function () {
+      return {
+        compare: function (actual, expected) {
+          const player = actual;
+          return {
+            pass: player.currentlyPlayingSong === expected && player.isPlaying
+          };
+        }
+      };
+    }
+  });
+});

package/jasmine-standalone-5.7.1/src/Player.js ADDED Viewed

@@ -0,0 +1,22 @@
+class Player {
+  play(song) {
+    this.currentlyPlayingSong = song;
+    this.isPlaying = true;
+  }
+  pause() {
+    this.isPlaying = false;
+  }
+  resume() {
+    if (this.isPlaying) {
+      throw new Error('song is already playing');
+    }
+    this.isPlaying = true;
+  }
+  makeFavorite() {
+    this.currentlyPlayingSong.persistFavoriteStatus(true);
+  }
+}

package/jasmine-standalone-5.7.1/src/Song.js ADDED Viewed

@@ -0,0 +1,6 @@
+class Song {
+  persistFavoriteStatus(value) {
+    // something complicated
+    throw new Error('not yet implemented');
+  }
+}

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@yz-social/webrtc",
-  "version": "0.0.5",
+  "version": "0.1.0",
   "description": "Streamlined portable webrtc management of p2p and client2server.",
   "keywords": [
     "webrtc",
@@ -20,10 +20,7 @@
     "./router": "./routes/index.js"
   },
   "scripts": {
-    "test": "(npm run test-server &); npm run test-only; npm run stop-server",
-    "test-only": "npx jasmine",
-    "test-server": "node testServer.js",
-    "stop-server": "pkill webrtcTestServer"
+    "test": "npx jasmine"
   },
   "dependencies": {
     "@roamhq/wrtc": "^0.9.1"

package/spec/test.html ADDED Viewed

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <link rel="stylesheet" href="../jasmine-standalone-5.7.1/lib/jasmine-5.7.1/jasmine.css">
+    <script src="../jasmine-standalone-5.7.1/lib/jasmine-5.7.1/jasmine.js"></script>
+    <script src="../jasmine-standalone-5.7.1/lib/jasmine-5.7.1/jasmine-html.js"></script>
+    <script src="../jasmine-standalone-5.7.1/lib/jasmine-5.7.1/boot0.js"></script>
+    <!-- optional: include a file here that configures the Jasmine env -->
+    <script src="../jasmine-standalone-5.7.1/lib/jasmine-5.7.1/boot1.js"></script>
+    <script type="module">
+      import './webrtcSpec.js';
+    </script>
+  </head>
+</html>

package/spec/webrtcSpec.js CHANGED Viewed

@@ -1,158 +1,213 @@
 const { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach} = globalThis; // For linters.
-import { WebRTC, WebRTCBase } from '../index.js';
-class DirectSignaling extends WebRTCBase {
-  signal(type, message) { // Just invoke the method directly on the otherSide.
-    this.otherSide[type](message);
-  }
-  signals = [];
-}
-function delay(ms) {
-  return new Promise(resolve => setTimeout(resolve, ms));
-}
-async function fetchSignals(url, signalsToSend) {
-  const response = await fetch(url, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify(signalsToSend)
-  });
-  return await response.json();
-}
+import { WebRTC } from '../index.js';
 describe("WebRTC", function () {
-  describe("connection between two peers on the same computer", function () {
-    const channelName = 'test';
-    function test(Kind, connect) {
-      describe(Kind.name, function () {
-	let a = {}, b = {}; let calledCloseA = 0, calledCloseB = 0;
-	beforeAll(async function () {
-	  const debug = false;
-	  a.connection = Kind.ensure({serviceLabel: 'A'+Kind.name, debug});
-	  b.connection = Kind.ensure({serviceLabel: 'B'+Kind.name, debug});
-	  await connect(a, b);
+  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} = {}) {
+      //const configuration = { iceServers: [] };
+      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++;
-	  a.testChannel = await a.dataChannelPromise;
-	  b.testChannel = await b.dataChannelPromise;
-	  a.testChannel.addEventListener('close', () => { calledCloseA++; });
-	  b.testChannel.addEventListener('close', () => { calledCloseB++; });
+        // 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
+        // channel of the given name. The id is as defaulted or specified if negotiated:true, else an internally determined
+        // unique id is used.
+        //
+        // Things are also smooth if negotiated:true and both sides call createChannel simultaneously, such that there
+        // 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
+        // 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
+        // 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].
-	  await a.connection.reportConnection();
-	  await b.connection.reportConnection();
-	});
-	afterAll(async function () {
-	  a.connection.close();
-	  expect(a.connection.peer.connectionState).toBe('new');
-	  await delay(10); // Yield to allow the other side to close.
-	  expect(b.connection.peer.connectionState).toBe('new');
-	  expect(calledCloseA).toBe(1);
-	  expect(calledCloseB).toBe(1);
-	});
-	it("changes state appropriately.", async function () {
-	  expect(await a.dataChannelPromise).toBeTruthy();
-	  expect(await b.dataChannelPromise).toBeTruthy();
-	  expect(a.connection.peer.connectionState).toBe('connected');
-	  expect(b.connection.peer.connectionState).toBe('connected');
-	  expect(a.connection.protocol).toBe(b.connection.protocol);
-	  expect(a.connection.protocol).toBe('udp');
-	  // In this case, since both are on the same machine:
-	  expect(a.connection.candidateType).toBe(b.connection.candidateType);
-	  expect(a.connection.candidateType).toBe('host');
-	});
-	it("sends data over raw channel.", async function () {
-	  const aReceived = new Promise(resolve => a.testChannel.onmessage = event => resolve(event.data));
-	  const bReceived = new Promise(resolve => b.testChannel.onmessage = event => resolve(event.data));
-	  a.testChannel.send("forty-two");
-	  b.testChannel.send("17");
-	  expect(await aReceived).toBe("17");
-	  expect(await bReceived).toBe("forty-two");
-	});
-	describe("second channel", function () {
-	  beforeAll(async function () {
-	    const name2 = 'channel2';
-	    a.promise2 = a.connection.ensureDataChannel(name2);
-	    b.promise2 = b.connection.ensureDataChannel(name2);
-	    a.channel2 = await a.promise2;
-	    b.channel2 = await b.promise2;
+        if (!delay) return dc.send(`Hello from ${webrtc.name}`);
+        await WebRTC.delay(delay);
+        webrtc.data.send(`Hello from ${webrtc.name}`);
+        return null;
+      }
+      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.
+      if (direct) {
+	A.signal = message => B.onSignal(message);
+	B.signal = message => A.onSignal(message);
+      } else {
+	A.transferSignals = messages => B.respond(messages);
+	B.transferSignals = messages => A.respond(messages);
+      }
+      return connections[index] = {A, B, bothOpen: Promise.all([aOpen, bOpen])};
+    }
+    function standardBehavior(setup, {includeConflictCheck = isBrowser, includeSecondChannel = true} = {}) {
+      beforeAll(async function () {
+        const start = Date.now();
+        console.log('start setup');
+        for (let index = 0; index < nPairs; index++) {
+          await setup({index});
+        }
+	//await Promise.all(connections.map(connection => connection.bothOpen));
+        console.log('end setup', Date.now() - start);
+      }, nPairs * 1e3);
+      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');
+        });
+        it(`receives ${index}.`, async function () {
+          const {A, B} = connections[index];
+          await B.gotData;
+          expect(B.receivedMessageCount).toBe(A.sentMessageCount);
+          await A.gotData;
+          expect(A.receivedMessageCount).toBe(B.sentMessageCount);
+        });
+        it(`learns of one open ${index}.`, function () {
+          const {A, B} = connections[index];
+          expect(A.sentMessageCount).toBe(1);
+          expect(B.sentMessageCount).toBe(1);
+        });
+	if (includeSecondChannel) {
+	  it(`handles second channel ${index}.`, async function () {
+	    const {A, B} = connections[index];
+	    const aOpen = A.getDataChannelPromise('second');
+	    const bOpen = B.getDataChannelPromise('second');
+	    const a = A.createChannel('second', {negotiated: true});
+	    const b = B.createChannel('second', {negotiated: true});
+	    const dca = await aOpen;
+	    let gotit = new Promise(resolve => {
+	      dca.onmessage = event => resolve(event.data);
+	    });
+	    const dcb = await bOpen;
+	    const start = Date.now();
+	    dcb.send('message');
+	    expect(await Promise.race([gotit, WebRTC.delay(2e3, 'timeout')])).toBe('message');
 	  });
-	  afterAll(async function () {
-	    a.channel2.close();
+	}
+        if (includeConflictCheck) {
+          it(`politely ignores a conflict ${index}.`, function () {
+            const {A, B} = connections[index];
+            expect(A.rolledBack).toBeFalsy();
+            expect(B.rolledBack).toBeTruthy(); // timing dependent, but useful for debugging
+          });
+        }
+      }
+      afterAll(async function () {
+        const start = Date.now();
+        console.log('start teardown');
+        const promises = [];
+        for (let index = 0; index < nPairs; index++) {
+          const {A, B} = connections[index];
+	  let promise = A.close().then(async apc => {
+            expect(apc.connectionState).toBe('closed'); // Only on the side that explicitly closed.
+            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');
 	  });
-	  it("handles data.", async function () {
-	    const aReceived = new Promise(resolve => a.channel2.onmessage = event => resolve(event.data));
-	    const bReceived = new Promise(resolve => b.channel2.onmessage = event => resolve(event.data));
-	    a.channel2.send("red");
-	    b.channel2.send("blue");
-	    expect(await aReceived).toBe("blue");
-	    expect(await bReceived).toBe("red");
-	  }, 10e3);
-	});
-      });
+          promises.push(promise);
+        }
+        await Promise.all(promises);
+        console.log('end teardown', Date.now() - start);
+      }, Math.max(30e3, 1e3 * nPairs));
     }
-    test(DirectSignaling, async (a, b) => {
-      a.connection.otherSide = b.connection;
-      b.connection.otherSide = a.connection;
-      a.dataChannelPromise = a.connection.ensureDataChannel(channelName);
-      // Give the other side an empty list of signals (else we get two offers and no answer),
-      // but yield for the a's offer to be directly transmitted.
-      b.dataChannelPromise = b.connection.ensureDataChannel(channelName, {}, await []);
-    });
-    test(WebRTC, async (a, b) => {
-      a.dataChannelPromise = a.connection.ensureDataChannel(channelName);
-      await a.connection.signalsReady; // await for offer
-      b.dataChannelPromise = b.connection.ensureDataChannel(channelName, {}, a.connection.signals);
-      await b.connection.signalsReady; // await answer
-      await a.connection.connectVia(signals => b.connection.respond(signals)); // Transmits signals back and forth.
-    });
-  });
-  describe("connection to server", function () {
-    describe("using NG ICE", function () {
-      let connection, dataChannel;
-      beforeAll(async function () {
-	connection = WebRTC.ensure({serviceLabel: 'Client'});
-	const ready = connection.signalsReady;
-	const dataChannelPromise = connection.ensureDataChannel('echo');
-	await ready;
-	connection.connectVia(signals => fetchSignals("http://localhost:3000/test/data/echo/foo", signals));
-	dataChannel = await dataChannelPromise;
-      });
-      afterAll(function () {
-	connection.close();
+    describe("one side opens", function () {
+      describe('non-negotiated', function () {
+        standardBehavior(async function ({index}) {
+          const {A, B, bothOpen} = makePair({index});
+          A.createChannel('data', {negotiated: false});
+          await bothOpen;
+        }, {includeConflictCheck: false, includeSecondChannel: false});
       });
-      it("sends and receives data", async function () {
-	const echoPromise = new Promise(resolve => dataChannel.onmessage = event => resolve(event.data));
-	dataChannel.send('hello');
-	expect(await echoPromise).toBe('hello');
+      describe("negotiated on first signal", function () {
+        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,
+          // because the receiving RTCPeerConnection does not fire 'datachannel' when the sender was negotiated:true.
+          // However, what the app can do is wake up and create an explicit createChannel when it first receives an
+          // unsolicited offer.
+          let awake = false;
+          A.signal = async msg => {
+            if (!awake) {
+              awake = true;
+              B.createChannel("data", {negotiated: true});
+            }
+            B.onSignal(msg);
+          };
+          A.createChannel('data', {negotiated: true});
+          await bothOpen;
+        }, {includeConflictCheck: false});
       });
     });
-  });
-  describe("capacity", function () {
-    const pairs = [];
-    const nPairs = 76; // NodeJS fails after 152 webrtc peers (76 pairs) in series. In parallel, it is only up through 67 pairs.
-    beforeAll(async function () {
-      const promises = [];
-      for (let i = 0; i < nPairs; i++) {
-	const a = {}, b = {};
-	a.connection = new WebRTC({label: `initiator-${i}`});
-	b.connection = new WebRTC({label: `receiver-${i}`});
-	let aPromise = a.connection.signalsReady;
-	a.dataChannelPromise = a.connection.ensureDataChannel('capacity');
-	const aSignals = await aPromise;
-	await a.connection.connectVia(signals => b.connection.respond(signals))
-	  .then(() => pairs.push([a, b]));
-      }
-      await Promise.all(promises);
-    });
-    afterAll(async function () {
-      for (const [a] of pairs) a.connection.close();
-      await delay(2e3);
-    });
-    it("is pretty big.", function () {
-      expect(pairs.length).toBe(nPairs);
+    describe("simultaneous two-sided", function () {
+      describe("negotiated single full-duplex-channel", function () {
+        describe("impolite first", function () {
+          standardBehavior(async function ({index}) {
+            const {A, B, bothOpen} = makePair({index});
+            A.createChannel("data", {negotiated: true});
+            B.createChannel("data", {negotiated: true});
+            await bothOpen;
+          });
+        });
+        describe("polite first", function () {
+          standardBehavior(async function ({index}) {
+            const {A, B, bothOpen} = makePair({index});
+            B.createChannel("data", {negotiated: true});
+            A.createChannel("data", {negotiated: true});
+            await bothOpen;
+          });
+        });
+      });
+      describe("non-negotiated dual half-duplex channels", function () {
+        const delay = 10;
+        describe("impolite first", function () {
+          standardBehavior(async function ({index}) {
+            const {A, B, bothOpen} = makePair({delay, index});
+            A.createChannel("data", {negotiated: false});
+            B.createChannel("data", {negotiated: false});
+            await bothOpen;
+          });
+        });
+        describe("polite first", function () {
+          standardBehavior(async function ({index}) {
+            const {A, B, bothOpen} = makePair({delay, index});
+            B.createChannel("data", {negotiated: false});
+            A.createChannel("data", {negotiated: false});
+            await bothOpen;
+          });
+        });
+      });
     });
   });
 });

package/lib/datachannels.js DELETED Viewed

@@ -1,144 +0,0 @@
-import { WebRTCPeerEvents } from './peerevents.js';
-// Data Channels:
-// -
-// - Send/receive, including the break-up of long messages and re-assembly.
-export class WebRTCDataChannels extends WebRTCPeerEvents {
-  // Negotiated channels use specific integers on both sides, starting with this number.
-  // We do not start at zero because the non-negotiated channels (as used on server relays) generate their
-  // own ids starting with 0, and we don't want to conflict.
-  // The spec says these can go to 65,534, but I find that starting greater than the value here gives errors.
-  // As of 7/6/25, current evergreen browsers work with 1000 base, but Firefox fails in our case (10 negotatiated channels)
-  // if any ids are 256 or higher.
-  static BASE_CHANNEL_ID = 125;
-  channelId = this.constructor.BASE_CHANNEL_ID;
-  get hasStartedConnecting() {
-    return this.channelId > this.constructor.BASE_CHANNEL_ID;
-  }
-  async ensureDataChannel(channelName, channelOptions = {}, signals = null) { // Return a promise for an open data channel on this connection.
-    // Much of this machinery is for ealing with the first data channel on either side in the case that the connection as a whole
-    // has not yet been made.
-    const hasStartedConnecting = this.hasStartedConnecting; // True for first channel only. Must ask before incrementing id.
-    const id = this.channelId++; // This and everything leading up to it must be synchronous on this instance, so that id assignment is deterministic.
-    const negotiated = this.multiplex && hasStartedConnecting;
-    const allowOtherSideToCreate = !hasStartedConnecting /*!negotiated*/ && !!signals; // Only the 0th with signals waits passively.
-    // signals can be nullish, in which case the real signals will have to be assigned later. This allows the data channel to be started (and to consume
-    // a channelId) synchronously, but the promise won't resolve until the real signals are supplied later. This is
-    // useful in multiplexing an ordered series of data channels on an ANSWER connection, where the data channels must
-    // match up with an OFFER connection on a peer. This works because of the wonderful happenstance that answer connections
-    // getDataChannelPromise (which doesn't require the connection to yet be open) rather than createDataChannel (which would
-    // require the connection to already be open).
-    const useSignals = !hasStartedConnecting && signals?.length;
-    const options = negotiated ? {id, negotiated, ...channelOptions} : channelOptions;
-    this.log({label: this.label, channelName, multiplex: this.multiplex, hasStartedConnecting, id, negotiated, allowOtherSideToCreate, useSignals, options});
-    if (hasStartedConnecting) {
-      await this.connected; // Before creating promise.
-      // I sometimes encounter a bug in Safari in which ONE of the channels created soon after connection gets stuck in
-      // the connecting readyState and never opens. Experimentally, this seems to be robust.
-      //
-      // Note to self: If it should turn out that we still have problems, try serializing the calls to peer.createDataChannel
-      // so that there isn't more than one channel opening at a time.
-      await new Promise(resolve => setTimeout(resolve, 100));
-    } else if (useSignals) {
-      this.signals = signals;
-    }
-    const promise = allowOtherSideToCreate ?
-	  this.getDataChannelPromise(channelName) :
-	  this.createDataChannel(channelName, options);
-    return await promise;
-  }
-  createDataChannel(label = "data", channelOptions = {}) { // Promise resolves when the channel is open (which will be after any needed negotiation).
-    return new Promise(resolve => {
-      this.log('create data-channel', label, channelOptions);
-      let channel = this.peer.createDataChannel(label, channelOptions);
-      this.noteChannel(channel, 'explicit'); // Noted even before opened.
-      // The channel may have already been opened on the other side. In this case, all browsers fire the open event anyway,
-      // but wrtc (i.e., on nodeJS) does not. So we have to explicitly check.
-      switch (channel.readyState) {
-      case 'open':
-	setTimeout(() => resolve(channel), 10);
-	break;
-      case 'connecting':
-	channel.onopen = _ => resolve(channel);
-	break;
-      default:
-	throw new Error(`Unexpected readyState ${channel.readyState} for data channel ${label}.`);
-      }
-    });
-  }
-  waitingChannels = {}; // channelName => resolvers
-  getDataChannelPromise(label = "data") { // Resolves to an open data channel.
-    return new Promise(resolve => {
-      this.log('promise data-channel', label);
-      this.waitingChannels[label] = resolve;
-    });
-  }
-  resetPeer() { // Reset a 'connected' property that promised to resolve when opened, and track incoming datachannels.
-    super.resetPeer();
-    this.connected = new Promise(resolve => { // this.connected is a promise that resolves when we are.
-      this.peer.addEventListener('connectionstatechange', event => {
-	if (this.peer.connectionState === 'connected') {
-	  resolve(true);
-	}
-      });
-    });
-    this.peer.addEventListener('datachannel', event => { // Resolve promise made with getDataChannelPromise().
-      const channel = event.channel;
-      const label = channel.label;
-      const waiting = this.waitingChannels[label];
-      this.noteChannel(channel, 'datachannel event', waiting); // Regardless of whether we are waiting.
-      if (!waiting) return; // Might not be explicitly waiting. E.g., routers.
-      delete this.waitingChannels[label];
-      waiting(channel);
-    });
-  }
-  // TODO: (Optionaly?) Set up generic jsonrpc on each channel, along with serialization and fragmentation/assembly for long messages. (See collections/serializer)
-  // We need to know if there are open data channels. There is a proposal and even an accepted PR for RTCPeerConnection.getDataChannels(),
-  // https://github.com/w3c/webrtc-extensions/issues/110
-  // but it hasn't been deployed everywhere yet. So we'll need to keep our own count.
-  // Alas, a count isn't enough, because we can open stuff, and the other side can open stuff, but if it happens to be
-  // the same "negotiated" id, it isn't really a different channel. (https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/datachannel_event
-  dataChannels = new Map(); // channelName => Open channel objects.
-  reportChannels() { // Return a report string useful for debugging.
-    const entries = Array.from(this.dataChannels.entries());
-    const kv = entries.map(([k, v]) => `${k}:${v.id}`);
-    return `${this.dataChannels.size}/${kv.join(', ')}`;
-  }
-  noteChannel(channel, source, waiting) { // Bookkeep open channel and return it.
-    // Emperically, with multiplex false: //   18 occurrences, with id=null|0|1 as for eventchannel or createDataChannel
-    //   Apparently, without negotiation, id is initially null (regardless of options.id), and then assigned to a free value during opening
-    const key = channel.label; //fixme channel.id === null ? 1 : channel.id;
-    const existing = this.dataChannels.get(key);
-    this.log('got data-channel', source, key, channel.readyState, 'existing:', existing, 'waiting:', waiting);
-    this.dataChannels.set(key, channel);
-    channel.addEventListener('close', event => { // Close whole connection when no more data channels or streams.
-      this.dataChannels.delete(key);
-      // If there's nothing open, close the connection.
-      if (this.dataChannels.size) return;
-      if (this.peer.getSenders().length) return;
-      this.close();
-    });
-    return channel;
-  }
-  close(removeConnection = true) {
-    this.channelId = this.constructor.BASE_CHANNEL_ID;
-    super.close();
-    if (removeConnection) this.constructor.connections.delete(this.serviceLabel);
-    // If the webrtc implementation closes the data channels before the peer itself, then this.dataChannels will be empty.
-    // But if not (e.g., status 'failed' or 'disconnected' on Safari), then let us explicitly close them so that Synchronizers know to clean up.
-    for (const channel of this.dataChannels.values()) {
-      if (channel.readyState !== 'open') continue;
-      // It appears that in Safari (18.5) for a call to channel.close() with the connection already internally closed, Safari
-      // will set channel.readyState to 'closing', but NOT fire the closed or closing event. So we have to dispatch it ourselves.
-      //channel.close();
-      channel.dispatchEvent(new Event('close'));
-    }
-  }
-}