@yz-social/webrtc 0.0.4 → 0.1.0

package/README.md

@@ -0,0 +1,10 @@
+
+## Data channel name event
+
+RTCPeerConnection defines a 'datachannel' event, and RTCDataChannel defines an 'open' event, but it is difficult to use them correctly:
+- 'datachannel' fires only for one side of a connection, and only when negotiated:false. 
+- To listen for 'open', you must already have the data channel. Not all implementations fire a handler for this when assigned in a 'datachannel' handler, and it can fire multiple times for the same channel name when two sides initiate the channel simultaneously with negotiated:true.
+
+## close event
+
+RTCPeerConnection defines a 'signalingstatechange' event in which application handlers can fire code when aPeerConnection.readyState === 'closed', but this not particuarly convenient.

package/index.js

@@ -1,2 +1,268 @@
-export { WebRTCBase } from './lib/webrtcbase.js';
-export { WebRTC } from './lib/webrtc.js';
+//import wrtc from '#wrtc'; // fixme
+const wrtc = (typeof(process) === 'undefined') ? globalThis : (await import('#wrtc')).default;
+
+export class WebRTC {
+  static iceServers = [ // Some default stun and even turn servers.
+
+    { urls: 'stun:stun.l.google.com:19302'},
+    // https://freestun.net/  Currently 50 KBit/s. (2.5 MBit/s fors $9/month)
+    { urls: 'stun:freestun.net:3478' },
+
+    //{ urls: 'turn:freestun.net:3478', username: 'free', credential: 'free' },
+    // Presumably traffic limited. Can generate new credentials at https://speed.cloudflare.com/turn-creds
+    // Also https://developers.cloudflare.com/calls/ 1 TB/month, and $0.05 /GB after that.
+    { urls: 'turn:turn.speed.cloudflare.com:50000', username: '826226244cd6e5edb3f55749b796235f420fe5ee78895e0dd7d2baa45e1f7a8f49e9239e78691ab38b72ce016471f7746f5277dcef84ad79fc60f8020b132c73', credential: 'aba9b169546eb6dcc7bfb1cdf34544cf95b5161d602e3b5fa7c8342b2e9802fb' }
+
+    // See also:
+    // https://fastturn.net/ Currently 500MB/month? (25 GB/month for $9/month)
+    // 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
+  ];
+  constructor({configuration = {iceServers: WebRTC.iceServers}, ...properties}) {
+    Object.assign(this, properties);
+
+    this.pc = new wrtc.RTCPeerConnection(configuration);
+    const {promise, resolve} = Promise.withResolvers(); // To indicate when closed.
+    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;
+      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.connectionStartTime = Date.now();
+    this.makingOffer = false;
+    this.ignoreOffer = false;
+
+    this.pc.onicecandidate = e => {
+      if (!e.candidate) return;
+      //if (this.pc.connectionState === 'connected') return; // Don't waste messages.  FIXME
+      this.signal({ candidate: e.candidate });
+    };
+    this.pc.ondatachannel = e => this.ondatachannel(e.channel);
+    this.pc.onnegotiationneeded = async () => {
+      try {
+        this.makingOffer = true;
+        this.log('creating offer in state:', this.pc.signalingState);
+	const offer = await this.pc.createOffer(); // The current wrtc for NodeJS doesn't yet support setLocalDescription with no arguments.
+	if (this.pc.signalingState != "stable") return; // https://blog.mozilla.org/webrtc/perfect-negotiation-in-webrtc/
+	this.log('setting local offer in state:', this.pc.signalingState);
+        await this.pc.setLocalDescription(offer)
+	  .catch(e => console.log(this.name, 'ignoring error in setLocalDescription of original offer while in state', this.pc.signalingState, e));
+        this.signal({ description: this.pc.localDescription });
+      } finally {
+        this.makingOffer = false;
+      }
+    };
+  }
+  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.)
+    return this.closed;
+  }
+  flog(...rest) {
+    console.log(new Date(), this.name, ...rest);
+  }
+  log(...rest) {
+    if (this.debug) this.flog(...rest);
+  }
+  static delay(ms, value) {
+    return new Promise(resolve => setTimeout(resolve, ms, value));
+  }
+
+  // Must include NodeJS, and must not include Chrome/Edge. Safari and Firefox can be either.
+  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 (description) {
+      const offerCollision =
+        description.type === "offer" &&
+            (this.makingOffer || (this.pc.signalingState !== "stable" && !this.settingRemote));
+
+      this.ignoreOffer = !this.polite && offerCollision;
+      this.log('onSignal', description.type, this.pc.signalingState, 'making:', this.makingOffer, 'collision:', offerCollision, 'ignore:', this.ignoreOffer, 'settingRemote:', this.settingRemote);
+
+      if (this.ignoreOffer) {
+        this.log("ignoring offer (collision)");
+        return;
+      }
+
+      if (this.explicitRollback && offerCollision) {
+	// The current wrtc for NodeJS doesn't yet support automatic rollback. We need to make it explicit.
+	await Promise.all([ // See https://blog.mozilla.org/webrtc/perfect-negotiation-in-webrtc/
+          this.pc.setLocalDescription({type: 'rollback'})
+	    .then(() => this.log('rollback ok'), e => this.log(this.name, 'ignoring error in rollback', e)),
+          this.pc.setRemoteDescription(description)
+	    .then(() => this.log('set offer ok'), e => this.log(this.name, 'ignoring error setRemoteDescription with rollback', e))
+	]);
+	this.rolledBack = true; // For diagnostics.
+	this.log('rolled back. producing answer');
+      } else {
+	this.settingRemote = true;
+	try {
+	  await this.pc.setRemoteDescription(description)
+	    .catch(e => this[offerCollision ? 'log' : 'flog'](this.name, 'ignoring error in setRemoteDescription while in state', this.pc.signalingState, e));
+	  if (offerCollision) this.rolledBack = true;
+	} finally {
+	  this.settingRemote = false;
+	}
+      }
+
+      if (description.type === "offer") {
+	const answer = await this.pc.createAnswer();
+        await this.pc.setLocalDescription(answer)
+	  .catch(e => this.flog(this.name, 'ignoring error setLocalDescription of answer', e));
+        this.signal({ description: this.pc.localDescription });
+      }
+
+    } else if (candidate) {
+      //this.log('add ice');
+      if (this.pc.connectionState === 'closed' || !this.pc.remoteDescription?.type) { // Adding ice without a proceessed offer/answer will crash. Log and drop the candidate.
+	this.log('icecandidate, connection:', this.pc.connectionState, 'signaling:', this.pc.signalingState, 'ice connection:', this.pc.iceConnectionState, 'gathering:', this.pc.iceGatheringState);
+	return;
+      }
+      await this.pc.addIceCandidate(candidate)
+	.catch(e => {
+	  if (!this.ignoreOffer && this.pc.connectionState !== 'closed') throw e;
+	});
+    }
+  }
+
+  async onSignals(signals) { // Apply a list of signals. Do not wait for a response.
+    for (const signal of signals) {
+      await this.onSignal(signal); // Wait for, e.g., offer/answer to be processed before adding the next.
+    }
+  }
+  signalsReadyResolver = null;
+  pendingSignals = [];
+  responseSerializer = Promise.resolve();
+  async respond(signals = []) { // Apply a list of signals, and promise a list of responding signals as soon as any are available, or empty list when connected
+    // This is used by a peer that is receiving signals in an out-of-band network request, and witing for a response. (Compare transferSignals.)
+    return this.responseSerializer = this.responseSerializer.then(async () => {
+      this.log('respond', signals.length, 'signals');
+      const {promise, resolve} = Promise.withResolvers;
+      this.signalsReadyResolver = resolve;
+      await this.onSignals(signals);
+      await promise;
+      this.signalsReadyResolver = null;
+      return this.collectPendingSignals();
+    });
+  }
+  collectPendingSignals() { // Return any pendingSignals and reset them.
+    // We do not assume a promise can resolve to them because more could be added between the resolve and the (await promise).
+    const signals = this.pendingSignals;
+    this.pendingSignals = [];
+    return signals;
+  }
+  signal(signal) { // Deal with a new signal on this peer.
+    // If this peer is responding to the other side, we arrange our waiting respond() to continue with data for the other side.
+    //
+    // Otherwise, if this side is allowed to initiate an outbound network request, then this side must define transferSignals(signals)
+    // to promise otherSide.respond(signals). If so, we call it with all pending signals (including the new one) and handle the the
+    // response. (Which latter may trigger more calls to signal() on our side.)
+    //
+    // Otherwise, we just remember the signal for some future respond() on our side.
+    //
+    // Note that this is compatible with both initiating and responding. E.g., both sides could attempt to transfserSignals()
+    // at the same time, in overlapping requests. Both will resolve.
+    this.log('signal', signal.description?.type || 'icecandidate', 'waiting:', !!this.signalsReadyResolver, 'has transfer:', !!this.transferSignals, 'on pending:', this.pendingSignals.length);
+    this.pendingSignals.push(signal);
+    const waiting = this.signalsReadyResolver; // As maintained and used by respond()
+    if (waiting) {
+      waiting();
+      return;
+    }
+    if (!this.transferSignals) return; // Just keep collecting until the next call to respond();
+    this.sendPending();
+  }
+  followupTimer = null;
+  sendPending(force = false) { // Send over any signals we have, and process the response.
+    this.lastOutboundSignal = Date.now();
+    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);
+	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);
+      });
+    });
+  }
+  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;
+    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]);
+    };
+    if (dc.readyState === 'open') dc.onopen();
+    return dc;
+  }
+  ondatachannel(dc) {
+    // Fires only on the answer side if the offer side opened with negotiated:false
+    // This our chance to setupChannel, just as if we had called createChannel
+    this.log('ondatachannel:', dc.label, dc.id, dc.readyState, dc.negotiated);
+    this.setupChannel(dc);
+    dc.onopen(); // It had been opened before we setup, so invoke handler now.
+  }
+  channelId = 128; // Non-negotiated channel.id get assigned at open by the peer, starting with 0. This avoids conflicts.
+  createChannel(name = 'data', {negotiated = false, id = this.channelId++, ...options} = {}) { // Explicitly create channel and set it up.
+    return this.setupChannel(this.pc.createDataChannel(name, {negotiated, id, ...options}));
+  }
+  dataChannelPromises = {};
+  getDataChannelPromise(name = 'data') { // Promise to resolve when opened, WITHOUT actually creating one.
+    const {promise, resolve, reject} = Promise.withResolvers();
+    Object.assign(promise, {resolve, reject});
+    return this.dataChannelPromises[name] = promise;
+  }
+
+  async reportConnection(doLogging = false) { // Update self with latest wrtc stats (and log them if doLogging true). See Object.assign for properties.
+    const stats = await this.pc.getStats();
+    let transport;
+    for (const report of stats.values()) {
+      if (report.type === 'transport') {
+	transport = report;
+	break;
+      }
+    }
+    let candidatePair = transport && stats.get(transport.selectedCandidatePairId);
+    if (!candidatePair) { // Safari doesn't follow the standard.
+      for (const report of stats.values()) {
+	if ((report.type === 'candidate-pair') && report.selected) {
+	  candidatePair = report;
+	  break;
+	}
+      }
+    }
+    if (!candidatePair) {
+      console.warn(this.label, 'got stats without candidatePair', Array.from(stats.values()));
+      return;
+    }
+    const remote = stats.get(candidatePair.remoteCandidateId);
+    const {protocol, candidateType} = remote;
+    const now = Date.now();
+    const statsElapsed = now - this.connectionStartTime;
+    Object.assign(this, {stats, transport, candidatePair, remote, protocol, candidateType, statsTime: now, statsElapsed});
+    if (doLogging) console.info(this.name, 'connected', protocol, candidateType, (statsElapsed/1e3).toFixed(1));
+  }
+}
+

package/jasmine-standalone-5.7.1/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2008-2019 Pivotal Labs
+Copyright (c) 2008-2025 The Jasmine developers
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/jasmine-standalone-5.7.1/SpecRunner.html

@@ -0,0 +1,28 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Jasmine Spec Runner v5.7.1</title>
+
+  <link rel="shortcut icon" type="image/png" href="lib/jasmine-5.7.1/jasmine_favicon.png">
+  <link rel="stylesheet" href="lib/jasmine-5.7.1/jasmine.css">
+
+  <script src="lib/jasmine-5.7.1/jasmine.js"></script>
+  <script src="lib/jasmine-5.7.1/jasmine-html.js"></script>
+  <script src="lib/jasmine-5.7.1/boot0.js"></script>
+  <!-- optional: include a file here that configures the Jasmine env -->
+  <script src="lib/jasmine-5.7.1/boot1.js"></script>
+
+  <!-- include source files here... -->
+  <script src="src/Player.js"></script>
+  <script src="src/Song.js"></script>
+
+  <!-- include spec files here... -->
+  <script src="spec/SpecHelper.js"></script>
+  <script src="spec/PlayerSpec.js"></script>
+
+</head>
+
+<body>
+</body>
+</html>

package/jasmine-standalone-5.7.1/lib/jasmine-5.7.1/boot0.js

@@ -0,0 +1,66 @@
+/*
+Copyright (c) 2008-2019 Pivotal Labs
+Copyright (c) 2008-2025 The Jasmine developers
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+/**
+ This file starts the process of "booting" Jasmine. It initializes Jasmine,
+ makes its globals available, and creates the env. This file should be loaded
+ after `jasmine.js` and `jasmine_html.js`, but before `boot1.js` or any project
+ source files or spec files are loaded.
+ */
+(function() {
+  const jasmineRequire = window.jasmineRequire || require('./jasmine.js');
+
+  /**
+   * ## Require & Instantiate
+   *
+   * Require Jasmine's core files. Specifically, this requires and attaches all of Jasmine's code to the `jasmine` reference.
+   */
+  const jasmine = jasmineRequire.core(jasmineRequire),
+    global = jasmine.getGlobal();
+  global.jasmine = jasmine;
+
+  /**
+   * Since this is being run in a browser and the results should populate to an HTML page, require the HTML-specific Jasmine code, injecting the same reference.
+   */
+  jasmineRequire.html(jasmine);
+
+  /**
+   * Create the Jasmine environment. This is used to run all specs in a project.
+   */
+  const env = jasmine.getEnv();
+
+  /**
+   * ## The Global Interface
+   *
+   * Build up the functions that will be exposed as the Jasmine public interface. A project can customize, rename or alias any of these functions as desired, provided the implementation remains unchanged.
+   */
+  const jasmineInterface = jasmineRequire.interface(jasmine, env);
+
+  /**
+   * Add all of the Jasmine global/public interface to the global scope, so a project can use the public interface directly. For example, calling `describe` in specs instead of `jasmine.getEnv().describe`.
+   */
+  for (const property in jasmineInterface) {
+    global[property] = jasmineInterface[property];
+  }
+})();

package/jasmine-standalone-5.7.1/lib/jasmine-5.7.1/boot1.js

@@ -0,0 +1,134 @@
+/*
+Copyright (c) 2008-2019 Pivotal Labs
+Copyright (c) 2008-2025 The Jasmine developers
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+/**
+ This file finishes 'booting' Jasmine, performing all of the necessary
+ initialization before executing the loaded environment and all of a project's
+ specs. This file should be loaded after `boot0.js` but before any project
+ source files or spec files are loaded. Thus this file can also be used to
+ customize Jasmine for a project.
+
+ If a project is using Jasmine via the standalone distribution, this file can
+ be customized directly. If you only wish to configure the Jasmine env, you
+ can load another file that calls `jasmine.getEnv().configure({...})`
+ after `boot0.js` is loaded and before this file is loaded.
+ */
+
+(function() {
+  const env = jasmine.getEnv();
+
+  /**
+   * ## Runner Parameters
+   *
+   * More browser specific code - wrap the query string in an object and to allow for getting/setting parameters from the runner user interface.
+   */
+
+  const queryString = new jasmine.QueryString({
+    getWindowLocation: function() {
+      return window.location;
+    }
+  });
+
+  const filterSpecs = !!queryString.getParam('spec');
+
+  const config = {
+    stopOnSpecFailure: queryString.getParam('stopOnSpecFailure'),
+    stopSpecOnExpectationFailure: queryString.getParam(
+      'stopSpecOnExpectationFailure'
+    ),
+    hideDisabled: queryString.getParam('hideDisabled')
+  };
+
+  const random = queryString.getParam('random');
+
+  if (random !== undefined && random !== '') {
+    config.random = random;
+  }
+
+  const seed = queryString.getParam('seed');
+  if (seed) {
+    config.seed = seed;
+  }
+
+  /**
+   * ## Reporters
+   * The `HtmlReporter` builds all of the HTML UI for the runner page. This reporter paints the dots, stars, and x's for specs, as well as all spec names and all failures (if any).
+   */
+  const htmlReporter = new jasmine.HtmlReporter({
+    env: env,
+    navigateWithNewParam: function(key, value) {
+      return queryString.navigateWithNewParam(key, value);
+    },
+    addToExistingQueryString: function(key, value) {
+      return queryString.fullStringWithNewParam(key, value);
+    },
+    getContainer: function() {
+      return document.body;
+    },
+    createElement: function() {
+      return document.createElement.apply(document, arguments);
+    },
+    createTextNode: function() {
+      return document.createTextNode.apply(document, arguments);
+    },
+    timer: new jasmine.Timer(),
+    filterSpecs: filterSpecs
+  });
+
+  /**
+   * The `jsApiReporter` also receives spec results, and is used by any environment that needs to extract the results  from JavaScript.
+   */
+  env.addReporter(jsApiReporter);
+  env.addReporter(htmlReporter);
+
+  /**
+   * Filter which specs will be run by matching the start of the full name against the `spec` query param.
+   */
+  const specFilter = new jasmine.HtmlSpecFilter({
+    filterString: function() {
+      return queryString.getParam('spec');
+    }
+  });
+
+  config.specFilter = function(spec) {
+    return specFilter.matches(spec.getFullName());
+  };
+
+  env.configure(config);
+
+  /**
+   * ## Execution
+   *
+   * Replace the browser window's `onload`, ensure it's called, and then run all of the loaded specs. This includes initializing the `HtmlReporter` instance and then executing the loaded Jasmine environment. All of this will happen after all of the specs are loaded.
+   */
+  const currentWindowOnload = window.onload;
+
+  window.onload = function() {
+    if (currentWindowOnload) {
+      currentWindowOnload();
+    }
+    htmlReporter.initialize();
+    setTimeout(() => env.execute(), 1e3);
+  };
+})();