L’éditeur d’expériences

Une expérience est un test écrit comme un graphe : des nœuds qui envoient (une requête HTTP, un message OSC, une publication MQTT…), attendent une réponse, vérifient ce qui est revenu, jouent l’autre côté ou coupent le réseau sur commande, reliés par des fils qui disent ce qui s’exécute ensuite. Une exécution démarre à Début, suit les fils et réussit quand elle atteint Fin avec chaque étape réussie. Vous la construisez sur l’écran Expériences, l’exécutez là, et exécutez le même fichier depuis la ligne de commande ou un serveur.

L’éditeur contient une seule expérience à la fois et l’enregistre au fur et à mesure de votre travail. Pour en garder plusieurs, exportez des instantanés ou ouvrez-en une autre depuis un fichier (voir Enregistrement et fichiers).

Chaque type de nœud, ses champs et ses sorties sont dans la référence des nœuds. La façon dont les valeurs circulent entre les nœuds est Données et modèles ; les branches parallèles, les boucles, les réessais et les répétitions sont Flux.

L’écran

Zone	Ce qu’elle contient
Barre d’outils (haut)	Le nom de l’expérience et son état d’enregistrement, l’ajout de nœuds, les paramètres, les profils, les volets, le mode focus, le plein écran et Exécuter
Barre du canevas	Annuler et rétablir, le chercheur de nœuds, Organiser et le zoom
Canevas	Le graphe : les nœuds, les fils, et la progression de l’exécution dessinée dessus
Propriétés (droite)	Les champs du nœud sélectionné, son aperçu et Envoyer maintenant ; ou ce que plusieurs nœuds sélectionnés ou un fil sélectionné permettent
Chronologie de l’exécution (bas)	Les étapes de l’exécution en cours ou de la dernière, son résultat, son rapport et sa graine

Le volet des propriétés et la chronologie ont une poignée sur leur bord intérieur : faites-la glisser, ou placez-y le focus avec Tab et utilisez les flèches (Shift pour de plus grands pas) ; un double-clic ou Enter rend au volet sa taille par défaut. Les tailles sont conservées pour la prochaine fois. La chronologie reste repliée jusqu’à ce que la première exécution l’ouvre.

La barre d’outils

Contrôle	Ce qu’il fait
☰ Expériences	Ouvre les modèles, l’ouverture d’un fichier JSON et l’export (Enregistrement et fichiers)
Nom de l’expérience	Le nom de l’expérience ; une exécution en a besoin. Les rapports d’exécution l’enregistrent, et Comparer retrouve les exécutions précédentes par lui
Enregistré / Enregistrement… / Échec de l’enregistrement	Si la dernière modification est sur le disque
⚠ Complétez le graphe	Affiché tant que l’expérience ne peut pas s’exécuter ; son info-bulle dit pourquoi, un clic sélectionne le nœud concerné (Validation)
＋ Ajouter un nœud	Ouvre le menu d’ajout, après le nœud sélectionné quand il y en a un (A)
Profil	Le profil avec lequel s’exécutent l’aperçu et Envoyer maintenant ; affiché quand l’expérience a des profils. ⚠ marque un profil qui ne s’exécuterait pas
{ } Paramètres	Les paramètres, les profils, la graine, les cookies et les secrets (Données et modèles)
☷ Propriétés	Affiche ou masque le volet des propriétés
▢ Mode focus	Masque la barre latérale, l’en-tête et le panneau inférieur (Mode focus et plein écran)
⛶ Plein écran	La fenêtre en plein écran, avec le mode focus
Exécuter l’expérience	Vérifie, enregistre et exécute l’expérience ; pendant l’exécution, le bouton est Arrêter
▾ Exécuter avec…	Une exécution avec un autre profil, d’autres valeurs de paramètres ou une graine donnée, sans changer l’expérience

Se déplacer sur le canevas

• Déplacer : faites glisser le canevas vide, ou faites défiler.
• Zoomer : Ctrl et la molette de la souris zooment autour du pointeur ; − et ＋ dans la barre du canevas avancent de 10 %. Le zoom va de 15 % à 200 % ; le pourcentage entre les boutons indique où vous êtes.
• 1:1 (Réinitialiser le zoom, Ctrl+1) revient à 100 %.
• ⊡ Ajuster le graphe (Ctrl+0) montre tout le graphe, à 100 % au plus.
• Trouver un nœud : Nœuds dans la barre du canevas (il indique combien de nœuds il y a) ou Ctrl+F. Tapez des mots du nom du nœud, de son résumé (une URL, une adresse, un topic) ou de son id ; ↑↓ choisissent, Enter sélectionne le nœud et l’amène dans la vue (zoomé à au moins 80 %), Esc ferme.

Il n’y a pas de mini-carte : Ajuster le graphe et le chercheur font son travail.

Nœuds et fils

Un nœud montre son type, un résumé d’une ligne de ce qu’il fait, et des pastilles pour ses réglages : ↻ et un nombre pour Réessai, × et un compte (ou une durée) pour Répétition, ⚡ pour Charge. Son entrée est à gauche — chaque nœud sauf Début en a une — et ses sorties à droite :

Sortie	Sur	Suivie quand
Sortie	La plupart des nœuds	L’étape a réussi
Oui / Non	Branche sur statut, Branche sur valeur	La comparaison est vérifiée / ne l’est pas
Branche 1 / Branche 2	Branche parallèle	Toujours, les deux à la fois
Reçu / Expiré	Les attentes	Un message correspondant est arrivé / aucun à temps
Corps / Terminé / Limite	Boucle	Une autre itération / la boucle est finie / elle a épuisé ses itérations

Une sortie peut avoir plusieurs fils. Le premier fil continue la branche ; chaque fil suivant démarre une branche parallèle avec une copie des variables connues à ce moment-là. Un nœud Jonction de branches attend chaque fil qui y mène. Les détails sont dans Flux.

Expiré et Limite sont facultatifs : laissés non reliés, un délai d’attente ou un épuisement des itérations fait échouer l’étape. Chaque autre sortie doit avoir un fil avant que l’expérience puisse s’exécuter.

Le fil qui va du corps d’une Boucle jusqu’à elle est dessiné comme un arc au-dessus du corps ; c’est le seul fil qui peut aller vers l’arrière.

Ajouter des nœuds

Le menu d’ajout

Le menu d’ajout liste chaque type de nœud par groupe — Actions, Observation, Émulation, Défaillances, Données, Vérifications, Flux — et ensuite Signaux enregistrés : les signaux de votre bibliothèque qui peuvent devenir un nœud (OSC, HTTP, UDP avec une charge utile texte, MQTT), avec leurs champs remplis.

Son champ de recherche a le focus à l’ouverture. Tapez quelques lettres : chaque mot doit apparaître dans le nom du nœud, sa description ou son type (http, wait_osc) ; un signal est trouvé par son nom, son dossier, son transport ou sa cible. ↑ ↓ choisissent, Enter ajoute, Esc ferme. La ligne en haut indique où va le nœud : après un nœud, ou en parallèle d’un autre.

Un nouveau nœud est sélectionné, le volet des propriétés s’ouvre, et son champ principal — l’ URL, l’adresse, le topic, le délai — a le focus avec son texte sélectionné, pour que vous puissiez taper tout de suite. Esc dans un champ vous ramène au nœud sur le canevas, prêt pour le prochain A.

Après le nœud sélectionné

A, ＋ Ajouter un nœud dans la barre d’outils et ＋ Ajouter à la suite dans le volet des propriétés ajoutent l’étape suivante après le nœud sélectionné :

• Il se rattache à la première sortie du nœud qui n’a pas encore de fil (le Non libre d’un Branche sur statut, par exemple), sinon à sa première sortie.
• Si cette sortie a déjà un fil, le nouveau nœud y est inséré (dans le premier, s’il y en a plusieurs) : le fil passe désormais par le nouveau nœud, et tout ce qui suit se décale à droite pour faire de la place.
• Avec Fin sélectionné, le nœud va avant lui, quand un fil y mène.
• Avec rien de sélectionné, le nœud atterrit au milieu de la vue, sans fils.

Un nœud à sortie unique qui est posé sur le Corps vide d’une Boucle — de cette façon ou sur un nouveau fil — est aussi relié en retour à elle, pour que le corps soit complet tout de suite.

Dans un fil

Chaque fil a un ＋ en son milieu (Insérer un nœud). Il ouvre le menu d’ajout, et le nœud que vous choisissez est inséré dans ce fil. Une Boucle insérée de cette façon continue le flux par son Terminé.

Sur un nouveau fil

Faites glisser un fil hors d’une sortie et relâchez sur le canevas vide : le menu d’ajout s’ouvre là, et le nouveau nœud va sur un nouveau fil de cette sortie — à côté des fils qu’elle a déjà, donc il s’exécute en parallèle avec eux. La même chose se produit quand vous cliquez une sortie puis le canevas vide, ou double-cliquez dessus.

N’importe où

Double-cliquez le canevas vide pour ajouter un nœud à cet endroit, sans fils.

Depuis d’autres écrans

• Ajouter à l’expérience sur les écrans OSC et HTTP ajoute ce que vous venez d’essayer comme étape suivante — juste avant Fin, quand un fil y mène — et bascule vers l’éditeur.
• Attendre ceci à côté d’un message dans le moniteur OSC ajoute une Attente OSC qui le reconnaît : son adresse et son texte, les arguments entiers et vrai/faux (les flottants sont des mesures qui changent, donc ils sont laissés de côté). Arrêtez le moniteur avant d’exécuter : l’exécution écoute elle-même sur ce port.
• Attendre ceci sur un topic de l’arbre MQTT ajoute une Attente MQTT sur ce topic, chez ce broker.

Pendant qu’une exécution est en cours, on ne peut pas ajouter de nœuds ; la console le dit.

Relier des nœuds

• Faites glisser d’une sortie vers un nœud. Relâcher à moins de 24 pixels d’un nœud suffit.
• Cliquez une sortie (ou placez-y le focus et appuyez sur Enter ou Space) : la barre du canevas indique Choisissez un port d’entrée. Cliquez un nœud ou son entrée pour relier ; cliquez le canevas vide pour y ajouter un nœud sur un nouveau fil ; Annuler ou Esc abandonne.

Un fil est refusé quand il créerait un cycle (autre que le chemin de retour d’une Boucle), quand il mène vers Début ou sort de Fin, ou quand il relierait un nœud à lui-même ; l’éditeur le dit. Tracer un fil qui existe déjà ne change rien.

Pour retirer un fil, cliquez-le — le volet des propriétés montre ce qu’il relie — et appuyez sur Delete, ou utilisez Supprimer la connexion là. Survoler un fil montre aussi un × au-dessus de son ＋. Les propriétés d’un nœud listent ses fils sortants, chacun avec × (Déconnecter).

Sélectionner plusieurs nœuds

Pour	Faites
Sélectionner un nœud	Cliquez-le, ou allez-y avec Tab
Ajouter un nœud à la sélection, ou l’en retirer	Shift ou Ctrl et un clic
Sélectionner au cadre	Shift et faites glisser sur le canevas vide : chaque nœud que le cadre touche rejoint la sélection
Sélectionner tous les nœuds	Ctrl+A
Vider la sélection	Cliquez le canevas vide ; Esc quand plusieurs sont sélectionnés
Les déplacer	Faites glisser l’un d’eux : ils bougent tous
Les décaler finement	Avec un nœud sous le focus, les flèches déplacent la sélection de 5 pixels, 20 avec Shift

Le volet des propriétés montre le dernier nœud choisi ; avec plusieurs sélectionnés, il montre combien, avec Copier, Dupliquer et Supprimer les nœuds.

Copier, couper et coller

Ctrl+C copie les nœuds sélectionnés et les fils entre eux sous forme de texte ; Ctrl+X les retire aussi ; Ctrl+V les colle — dans cette expérience, dans une autre ouverte plus tard, ou dans une autre fenêtre Signal Lab. Le texte est du JSON, donc vous pouvez aussi le garder dans un fichier ou un message.

• Début et Fin sont uniques : ils ne sont jamais copiés.
• Les fils entre un nœud copié et le reste du graphe ne sont pas copiés ; reliez la copie vous-même.
• Chaque nœud collé reçoit un nouvel id.
• Un nœud qui en nomme un autre — Changer la dégradation, Émulateur en panne/en service, Envoi WebSocket, Attente WebSocket, Fermeture WebSocket — nomme la copie quand elle a été copiée aussi ; sinon il continue de nommer l’original s’il est dans cette expérience, ou le premier nœud de ce type ici.
• Un Émulateur ou Dégradation collé dont le port est déjà écouté par cette expérience passe au port libre suivant. Ce qui envoie à l’original continue de le faire.
• La copie atterrit 32 pixels à droite et une ligne sous l’endroit d’où elle vient, plus bas jusqu’à ne couvrir aucun nœud, et est sélectionnée.

Ctrl+D (Dupliquer) fait la même chose sans le presse-papiers.

Supprimer

Delete ou Backspace (Supprimer le nœud, Supprimer les nœuds) retire les nœuds sélectionnés et leurs fils. Un nœud qui avait exactement un fil entrant et un fil sortant laisse un fil à sa place, du nœud avant lui au nœud après lui, pour qu’une chaîne reste connectée. Début et Fin ne peuvent pas être supprimés.

Annuler et rétablir

Ctrl+Z annule ; Ctrl+Shift+Z ou Ctrl+Y rétablit (↶ ↷ dans la barre du canevas). Un glisser, une série de décalages au clavier ou la saisie dans un champ est une étape. Les 100 dernières étapes sont conservées tant que l’application est ouverte, à travers les changements d’écran ; ouvrir une autre expérience est aussi une étape, donc Ctrl+Z ramène la précédente. Annuler et rétablir attendent pendant qu’une exécution est en cours.

Disposer

Organiser dispose le graphe de gauche à droite : chaque nœud dans la colonne après le dernier nœud qui y mène, le corps d’une Boucle dans sa rangée — puis ajuste la vue. C’est une étape de l’historique. Un brouillon avec un cycle qui n’est pas celui d’une boucle est laissé tel quel.

Le volet des propriétés

Avec un nœud sélectionné, le volet montre, de haut en bas :

1. Le nom du nœud (son info-bulle dit ce qu’il fait) et, quand l’expérience ne peut pas s’exécuter à cause de ce nœud, ce qui ne va pas.
2. Ses champs. Les champs qui prennent des modèles suggèrent des paramètres, des variables, des secrets et des générateurs au fur et à mesure que vous tapez {{, ou sur Ctrl+Space.
3. Ses réglages : envoyer sous charge sur une requête HTTP, répéter l’envoi sur les nœuds qui envoient, réessayer en cas d’échec sur les nœuds qui envoient ou écoutent, et attendre une réponse sur les messages OSC et UDP (voir Réglages des nœuds). La charge remplace la répétition et le réessai tant qu’elle est active.
4. Le résultat de charge de la dernière exécution, sur un nœud HTTP qui s’est exécuté sous charge.
5. L’aperçu — Sera envoyé, Attendra ou Comparera — quand le nœud a des modèles : ce qu’il enverrait, attendrait ou comparerait, résolu avec les paramètres actuels et les valeurs connues jusqu’ici (Envoyer maintenant et l’aperçu).
6. Envoyer maintenant ou Écouter maintenant, et ce qu’il a fait en dernier.
7. Ses fils sortants, chacun avec ×.
8. ⚡ Faire passer par une dégradation sur un message OSC ou UDP : une Dégradation est placée devant le nœud — écoutant sur un port de bouclage libre à partir de 9010, transmettant à la cible du nœud — et le nœud est pointé vers elle, pour que la prochaine exécution dégrade ce qu’il envoie (Défaillances).
9. ＋ Ajouter à la suite, Copier, Dupliquer et Supprimer le nœud.

Un double-clic sur un nœud ouvre le volet avec le curseur dans son champ principal. Avec plusieurs nœuds sélectionnés, le volet offre ce qui peut être fait à tous ; avec un fil sélectionné, ce qu’il relie et Supprimer la connexion. Pendant qu’une exécution est en cours, les champs sont verrouillés.

Envoyer maintenant et l’aperçu

Envoyer maintenant (Ctrl+Enter, aussi depuis l’intérieur des champs du nœud) envoie le nœud sélectionné tout seul, sans exécuter l’ expérience, par le même code qu’une exécution. Il est proposé sur Requête HTTP, Message TCP, Message OSC, Datagramme UDP, Publication MQTT, Connexion WebSocket et Envoi WebSocket. Sur une attente, c’est Écouter maintenant : l’attente écoute à partir de maintenant jusqu’à ce qu’un message corresponde ou que son délai d’attente se termine.

• Le nœud utilise le profil actif, les secrets enregistrés et les valeurs de variables connues jusqu’ici — de la dernière exécution et des résultats Envoyer maintenant précédents. Si un modèle nomme une valeur que personne n’a encore définie, rien n’est envoyé et les noms sont listés.
• Il est envoyé une fois : Réessai, Répétition et Charge ne s’appliquent pas, aucun cookie n’est conservé, et les émulateurs et relais de l’expérience ne sont pas démarrés.
• Un Envoi WebSocket ou Attente WebSocket ouvre la connexion que son Connexion WebSocket décrit, pour ce seul test.
• Sur une requête HTTP, la réponse est affichée — statut, durée, taille, et le corps, formaté en JSON. Les valeurs que les nœuds Extraire une valeur après la requête prendraient sont remplies aussitôt. Cliquez une valeur dans une réponse JSON pour ajouter un nœud Extraire une valeur pour elle juste après la requête, sa variable nommée et sa valeur connue. Émuler ceci transforme la réponse en route d’un émulateur.
• Le résultat est aussi écrit dans la console.

L’aperçu est résolu par le moteur aussi, environ un quart de seconde après une modification. Les valeurs de secrets ne sont jamais montrées, ni là ni ailleurs.

Validation

L’éditeur vérifie l’expérience au fur et à mesure, et une fois de plus quand vous appuyez sur Exécuter l’expérience :

• Une sortie qui a encore besoin d’un fil pulse en ambre.
• Un nœud qu’aucun fil depuis Début n’atteint est dessiné en pointillés ; son info-bulle le dit.
• Le nœud concerné par un problème est entouré, et le problème est écrit au-dessus de ses champs.
• ⚠ Complétez le graphe dans la barre d’outils nomme le problème ; un clic sélectionne le nœud.

Une expérience s’exécute quand, entre autres choses :

• elle a un nom, exactement un Début et un Fin, et au plus 64 nœuds ;
• chaque nœud est atteignable depuis Début et chaque sortie requise a un fil ;
• les seuls cycles sont les corps des nœuds Boucle qui y ramènent ;
• chaque vérification et Extraire une valeur a une requête HTTP avant elle sur chaque chemin (une sous charge ne compte pas : elle ne laisse pas de réponse) ;
• un Envoi WebSocket, Attente WebSocket ou Fermeture WebSocket vient après le Connexion WebSocket qu’il utilise ;
• chaque champ est rempli et dans les limites, et chaque modèle nomme quelque chose de connu à ce moment-là.

Les brouillons inachevés sont enregistrés quand même. Une exécution est refusée, avant tout trafic, quand un secret dont elle a besoin n’est pas enregistré. Chaque message est listé dans la référence des erreurs.

Exécuter

Exécuter l’expérience vérifie l’expérience, l’enregistre et la démarre. Si elle ne peut pas s’exécuter, le problème est montré et son nœud sélectionné. Sinon la chronologie s’ouvre et les nœuds s’allument au fur et à mesure que l’exécution les atteint : ● en cours, ✓ réussi, ✕ échoué, ↻ réessai, ⟳ répétition, ⚡ sous charge ; les fils qui ont porté le flux sont colorés aussi.

• Les attentes, les émulateurs et les relais de dégradation ouvrent leurs ports avant la première étape, pour que rien de ce qui arrive tôt ne soit manqué. Un port qui ne peut pas être ouvert (un autre programme le détient, par exemple) empêche l’exécution de démarrer, et le nœud qui en a besoin est montré.
• Arrêter met fin à l’exécution tout de suite : pauses, attentes et charges comprises. L’exécution est aussi une tâche dans le bandeau des tâches de la console, qui peut aussi l’arrêter.
• Une exécution qui dure plus de 300 secondes est arrêtée et échoue.
• Pendant qu’une exécution est en cours, l’expérience ne peut pas être modifiée ; déplacer, zoomer et sélectionner fonctionnent toujours.

▾ Exécuter avec… à côté du bouton exécute une fois avec un autre profil, d’autres valeurs de paramètres ou une graine donnée ; l’expérience elle-même n’est pas modifiée, et le formulaire garde ce que vous avez tapé jusqu’à la fermeture de l’application (Données et modèles).

La chronologie d’exécution

La Chronologie de l’exécution liste une ligne par étape : l’heure, le nœud et ce qui s’est passé — réussi, échoué et pourquoi, un réessai, la progression d’une répétition, les chiffres d’une charge une fois par seconde. Cliquez une ligne pour sélectionner son nœud sur le canevas.

Sa ligne de titre contient :

• le résultat : Réussi, Échoué avec la raison, ou Arrêté ;
• Rapport enregistré — le fichier de rapport de l’exécution (sur un serveur, un téléchargement) ;
• Comparer — cette exécution à côté d’une précédente de la même expérience ;
• le profil et les valeurs modifiées que l’exécution a utilisés, quand elle en avait ;
• la graine de l’exécution, avec Épingler pour la garder dans l’expérience afin que les exécutions suivantes tirent les mêmes valeurs aléatoires, ou Désépingler une fois qu’elle est épinglée.

Quand l’Inspecteur capturait, une attente (ou une réponse attendue) qui a correspondu renvoie à la trame qu’elle a fait correspondre ; un clic l’ouvre dans l’Inspecteur. Les rapports, les graines et la comparaison d’exécutions sont dans Exécutions et rapports.

Mode focus et plein écran

▢ Mode focus masque la barre latérale, l’en-tête et le panneau inférieur (console et Inspecteur), laissant l’écran à l’éditeur. ⛶ Plein écran met la fenêtre en plein écran et active le mode focus ; quitter le plein écran remet le mode focus comme il était. Passer à un autre écran quitte le mode focus.

Esc sur le canevas, quand rien d’autre n’est à fermer, quitte le plein écran puis le mode focus.

Enregistrement et fichiers

L’expérience s’enregistre d’elle-même, un moment après chaque modification, dans experiment.json dans le dossier de données (Documents/SignalLab sur un bureau ; un serveur a le sien — voir Fichiers et dossiers). Les brouillons qui ne peuvent pas encore s’exécuter sont enregistrés aussi. Une exécution enregistre d’abord, donc ce qui a été exécuté est ce qui est sur le disque.

Si ce fichier ne peut pas être lu — modifié à la main en JSON cassé, par exemple — l’éditeur dit quel fichier et pourquoi, et le laisse tranquille. Ouvrir une autre expérience depuis ☰ Expériences le remplace alors au prochain enregistrement.

☰ Expériences ouvre la boîte de dialogue des expériences :

• Modèles : choisissez-en un et appuyez sur Ouvrir une expérience. Ils utilisent tous des adresses de bouclage.
• Ouvrir un JSON… lit un fichier d’expérience — écrit par cette version de Signal Lab ou une précédente, jusqu’à 4 MiB — et montre son nom et combien de nœuds et de connexions il a avant que vous l’ouvriez. Les fichiers des versions précédentes sont mis à jour à l’ouverture. Un fichier qui ne s’analyse pas, ou qui ne serait pas une expérience valide, est refusé avec la raison, et l’expérience actuelle reste.
• Exporter le JSON actuel écrit un instantané de l’expérience actuelle — nœuds, fils, positions, paramètres et profils, jamais les valeurs de secrets — dans un nouveau fichier dans exports dans le dossier de données et montre son chemin ; sur un serveur, avec un lien Télécharger.
• Ouvrir une expérience remplace l’expérience actuelle par le modèle ou le fichier. Elle ne l’exécute pas, et Ctrl+Z ramène la précédente.

Modèle	Ce qu’il fait
Expérience vide	Début et Fin, pour votre propre flux
Vérification HTTP	Un GET vers http://127.0.0.1:8080/ et une vérification du statut 200 — l’expérience avec laquelle vous commencez
HTTP vers OSC	La même requête ; sur 200 un message OSC vers 127.0.0.1:9000, sinon un délai de 500 ms
Flux parallèles	Deux branches à la fois — une requête et une ligne de journal — jointes avant Fin
Ping OSC → réponse	Envoie /ping avec l’id de l’exécution vers 127.0.0.1:9000 et attend sur 127.0.0.1:9001 un /pong qui le rapporte
Interroger jusqu’à « ready »	Demande /status à un appareil toutes les 0,3 s jusqu’à ce qu’il réponde ready, dix fois au plus
Réessayer une API instable	Une API émulée qui échoue deux fois avant de répondre, et une boucle qui demande jusqu’à ce qu’elle réponde
Phases de défaillance	Des datagrammes vers un appareil émulé à travers un relais de dégradation pendant qu’une branche parallèle fait passer le réseau de propre à avec pertes, hors ligne, puis de nouveau propre
Panne d’une dépendance	Une API émulée mise en panne deux secondes par une branche parallèle, et un client qui continue de demander jusqu’à ce qu’elle réponde de nouveau
Écho WebSocket	Se connecte à un service d’écho à ws://127.0.0.1:9001/echo, envoie un ping JSON, s’attend à le recevoir inchangé, et ferme

Les mêmes fichiers s’exécutent sans l’éditeur : signallab run experiment.json — voir La ligne de commande.

Raccourcis clavier

Les touches seules agissent sur le canevas et sont laissées tranquilles pendant que vous tapez dans un champ. Sur un Mac, dans un navigateur, Cmd fonctionne là où Ctrl est écrit.

Touches	Action
A	Ajouter un nœud après celui sélectionné, ou au milieu de la vue quand rien n’est sélectionné
Ctrl+Enter	Envoyer maintenant, ou Écouter maintenant, sur le nœud sélectionné
Ctrl+Z	Annuler
Ctrl+Shift+Z, Ctrl+Y	Rétablir
Ctrl+A	Sélectionner tous les nœuds
Ctrl+C / Ctrl+X / Ctrl+V	Copier / couper / coller les nœuds sélectionnés et les fils entre eux
Ctrl+D	Dupliquer les nœuds sélectionnés
Delete, Backspace	Retirer le fil sélectionné, ou les nœuds sélectionnés
Flèches (un nœud sous le focus)	Déplacer les nœuds sélectionnés de 5 pixels ; avec Shift, 20
Ctrl+F	Trouver un nœud
Ctrl+0	Ajuster le graphe
Ctrl+1	Zoomer à 100 %
Ctrl + molette de la souris	Zoomer autour du pointeur
Shift + clic, Ctrl + clic	Ajouter un nœud à la sélection, ou l’en retirer
Shift + glisser sur le canevas vide	Sélectionner au cadre
Double-clic sur un nœud	Modifier ses champs
Double-clic sur le canevas vide	Y ajouter un nœud
Enter, Space sur une sortie sous le focus	Démarrer un fil depuis elle
{{ ou Ctrl+Space dans un champ	Suggérer des paramètres, des variables, des secrets et des générateurs
Esc dans un champ	Revenir au nœud sur le canevas
Esc sur le canevas	Fermer le menu d’ajout ; sinon annuler le fil en cours de tracé ; sinon relâcher le fil sélectionné ; sinon vider une sélection de plusieurs ; sinon quitter le plein écran ; sinon quitter le mode focus

Dans le menu d’ajout et le chercheur, ↑ ↓ choisissent, Enter prend le choix et Esc ferme. Tous les raccourcis de l’application sont dans Raccourcis clavier.