aotrautils 0.0.1803 → 0.0.1806

aotrautils/aotrautils.build.js

@@ -1,6 +1,6 @@
 
 
-/*utils COMMONS library associated with aotra version : «1_29072022-2359 (11/11/2025-18:19:16)»*/
+/*utils COMMONS library associated with aotra version : «1_29072022-2359 (01/03/2026-01:46:57)»*/
 /*-----------------------------------------------------------------------------*/
 
 
@@ -945,11 +945,8 @@ aotest.run=function(testName=null,scenarioName=null){
 				}
 			});
 			
-			
 		}
 		
-		
-		
 		let currentExecutedTest=window.aotestAllTestsManager[chosenTestParam.name];
 		var functionDefinition=currentExecutedTest.functionDefinition;
 
@@ -1068,9 +1065,6 @@ aotest.run=function(testName=null,scenarioName=null){
 				}
 			}
 
-			
-			
-
 			// *****************************************
 			// We check function/methods calls here :
 			// (overrides all other previous test result calculations)
@@ -1133,7 +1127,6 @@ aotest.run=function(testName=null,scenarioName=null){
 //				
 //			}
 
-
 			// Execution measurment end :
 			scenarioResultObjLocal.global.executionEndTime=getNow();
 
@@ -1178,23 +1171,18 @@ aotest.run=function(testName=null,scenarioName=null){
 				}
 			}
 			
-			
 			// There can be no other case if we are in UI tests case.
 		}
 		
-		
-		
 		// States comparison test handling :
 		// (overrides all other previous test result calculations)
 		if( // (to avoid calculating more if test has already failed :)
 				!scenarioResultObjLocal.global.isFailed 
 				&& !isChosenScenarioParamArray 
 				&& chosenScenarioParam.after){
-
 			
 			let beforeResultFlat=currentExecutedTest.oldResultFlat; 		// expected result
 			
-			
 			// At this point, we already have applied the method to the input object, in order to compare it with the output object, if necessary.
 			let actualInstanceFlat=(actualInstance!=null?getAsFlatStructure(actualInstance):null);	// actual instance (after execution)
 			let actualArgsFlat=(functionParametersPopulated!=null?getAsFlatStructure(functionParametersPopulated):null);	// actual arguments (after execution)
@@ -1246,17 +1234,13 @@ aotest.run=function(testName=null,scenarioName=null){
 				
 			}
 			
-			
-			
 			// DBG
 			console.log("³³³³³³ areEquivalentInstances",areEquivalentInstances);
 			console.log("³³³³³³ areEquivalentArgs",areEquivalentArgs);
 			console.log("³³³³³³ areEquivalentResults",areEquivalentResults);
 			
-			
 		}
 		
-		
 		// We check sub-scenarii here :
 		var subScenariiList=null;
 		if(!isChosenScenarioParamArray)
@@ -1624,12 +1608,31 @@ aotest.profile=function(rootObject,methodName,visited=[]){
 
 window.sleep = (millis) => new Promise( resolve => setTimeout(resolve, millis) );
 
+window.PeriodicalExecuter=class PeriodicalExecuter{
+	constructor(callback, refreshRateMillis=1000, instance){
+		this.callback=callback;
+		this.refreshRateMillis=refreshRateMillis;
+		this.instance=instance;
+		const self=this;
+		this.intervalId=setInterval(()=>self.callback.apply(self.instance), this.refreshRateMillis);
+	}
+	stop(){
+		clearInterval(this.intervalId);
+	}
+	restart(){
+		const self=this;
+		this.intervalId=setInterval(()=>self.callback.apply(self.instance), this.refreshRateMillis);
+	}
+}
 
 
 //================================================================
 //================= Cryptography utility methods =================
 //================================================================
 
+// Node dependencies :
+if(typeof(require)!="undefined" && typeof(sjcl)=="undefined" )	sjcl = require("sjcl");
+
 
 // NOT AOTESTABLE !
 //TODO : develop :
@@ -1977,37 +1980,41 @@ window.nothing=function(nullable, insist=false){
 	return false;
 }
 
-window.getOrCreateSimpleObjectAttribute=function(parentObject, attributeNameOrAttributesName){
+window.getOrCreateEmptyAttribute=function(parentObject, attributeNameOrAttributesNames, 
+	// BECAUSE CAUTION : if we have defaultValue as parameter, sometimes because of the recursive call, it can refer to a persisting object ! Thus, creating a strange bug.
+	// (SO WE ALWAYS NEED TO START AS A BLANK STATE FOR DEFAULT VALUE !)
+	forceArrayAttributeDefaultValue=false){
 	if(nothing(parentObject))		return null;
-	if(nothing(attributeNameOrAttributesName))	return parentObject;
-	if(isString(attributeNameOrAttributesName) || (isArray(attributeNameOrAttributesName) && attributeNameOrAttributesName.length===1)){
-		const attributeName=(isArray(attributeNameOrAttributesName) && attributeNameOrAttributesName.length===1)?
-															attributeNameOrAttributesName[0]:attributeNameOrAttributesName;
+	if(nothing(attributeNameOrAttributesNames))	return parentObject;
+	if(isString(attributeNameOrAttributesNames) || (isArray(attributeNameOrAttributesNames) && attributeNameOrAttributesNames.length===1)){
+		const attributeName=(isArray(attributeNameOrAttributesNames) && attributeNameOrAttributesNames.length===1)?
+															attributeNameOrAttributesNames[0]:attributeNameOrAttributesNames;
 		if(parentObject[attributeName]==null){
 //		NO : parentObject[attributeName]=defaultValue;
 			// BECAUSE CAUTION : if we have defaultValue as parameter, sometimes because of the recursive call, it can refer to a persisting object ! Thus, creating a strange bug.
-			// (SO WE ALWAYS NEED TO START AS A BLANK STATE FOR DEFAULT VALUE OBJECTS !)
-			const DEFAULT_VALUE={};
+			// (SO WE ALWAYS NEED TO START AS A BLANK STATE FOR DEFAULT VALUE !)
+			const DEFAULT_VALUE=(forceArrayAttributeDefaultValue?[]:{});
 			parentObject[attributeName]=DEFAULT_VALUE;
 		}
 		let foundOrCreatedChild=parentObject[attributeName];
 		return foundOrCreatedChild;
 	}
-	if(isArray(attributeNameOrAttributesName)){
+	if(isArray(attributeNameOrAttributesNames)){
 
-		const attributeName=attributeNameOrAttributesName[0];
+		const attributeName=attributeNameOrAttributesNames[0];
 		if(parentObject[attributeName]==null){
 //		NO : parentObject[attributeName]=defaultValue;
 			// BECAUSE CAUTION : if we have defaultValue as parameter, sometimes because of the recursive call, it can refer to a persisting object ! Thus, creating a strange bug.
-			// (SO WE ALWAYS NEED TO START AS A BLANK STATE FOR DEFAULT VALUE OBJECTS !)
-			const DEFAULT_VALUE={};
+			// (SO WE ALWAYS NEED TO START AS A BLANK STATE FOR DEFAULT VALUE !)
+			const DEFAULT_VALUE=(forceArrayAttributeDefaultValue?[]:{});
 			parentObject[attributeName]=DEFAULT_VALUE;
 		}
-		const sliced=attributeNameOrAttributesName.slice(1);
-		let foundOrCreatedChild=getOrCreateSimpleObjectAttribute(parentObject[attributeName], sliced);
+		// We remove the just-created child to allow for the other children to be created on the parent object :
+		const slicedAttributesNames=attributeNameOrAttributesNames.slice(1);
+		let foundOrCreatedChild=getOrCreateEmptyAttribute(parentObject, slicedAttributesNames, forceArrayAttributeDefaultValue);
 		return foundOrCreatedChild;
 	}
-	return null; // (case no child found nor could be created.)
+	return null; // (case no child was found or it could be not created.)
 }
 
 window.nonull=function(value,defaultValue){
@@ -2209,6 +2216,14 @@ window.foreach=function(arrayOfValues,doOnEachFunction,
 	return null;
 }
 
+window.findInArray=function(collection, equalsFunction, returnFunction=null){
+	return !!foreach(collection, item=>{
+		if(returnFunction)
+			return returnFunction(item);
+		return item;
+	}, equalsFunction);
+}
+
 window.getKeyAt=function(associativeOrNormalArray,index){
 	return getAt(associativeOrNormalArray,index,true);
 }
@@ -2263,7 +2278,6 @@ window.getNow=function(){
 }
 
 
-
 // UNUSED:
 // CAUTION : this is a costly method...
 window.gotoValueLinearly=function(source, destination, doOnRefreshTreatment,/*OPTIONAL*/onEndMethod,/*OPTIONAL*/refreshingRateMillisParam,/*OPTIONAL*/
@@ -2823,7 +2837,6 @@ window.uncapitalize=function(str){
 window.copy=function(array){
 	var result=null;
 	
-	// if(!isAssociative){
 	if(array instanceof Array){
 	
 		result=new Array();
@@ -2831,7 +2844,6 @@ window.copy=function(array){
 			result.push(array[i]);
 	} else {
 		// Case of regular objects that are like associative arrays :
-	
 		result=new Object();
 		for (key in array){
 			if(!array.hasOwnProperty(key))
@@ -2946,10 +2958,15 @@ Math.productInArray=function(arrayOfValues){
 	return product;
 };
 
+Math.average=function(value1,value2){
+	return (value1+value2)*.5;
+};
+
+
 Math.averageInArray=function(arrayOfValues){
 	if(empty(arrayOfValues))
 		return null;
-	return Math.sumInArray(arrayOfValues) / arrayOfValues.length;
+	return Math.sumInArray(arrayOfValues)/arrayOfValues.length;
 };
 
 Math.maxInArray=function(arrayOfValues, returnKey=false){
@@ -3832,8 +3849,15 @@ window.isFunction=function(functionToCheck){
 window.isPrimitive=function(p){
 	return (isNumber(p) || isString(p) || isBoolean(p));
 }
-window.isObject=function(p){
-	return !isFunction(p) && !isPrimitive(p);
+window.isObject=function(o){ // (includes also plain objects)
+	return !isFunction(o) && !isPrimitive(o);
+}
+// NO : DOES NOT WORK !!!
+//window.isPlainObject=function(o){
+//  return Object.prototype.toString.call(o)==="[object Object]";
+//}
+window.isClassObject=function(o){
+  return isObject(o) && !isNativeClass(o);
 }
 window.getClassName=function(obj){
 	if(!obj)	return null;
@@ -4165,8 +4189,12 @@ JSON.parseRecycle=function(str){
 
 
 window.clone=function(obj){
+	// OLD :
 	const str=JSON.stringifyDecycle(obj);
 	const newObj=JSON.parseRecycle(str);
+	// DOES NOT WORK :
+//const newObj=deepClone(obj);
+//const newObj=structuredClone(obj);
 	return newObj;
 };
 
@@ -4696,9 +4724,9 @@ window.getAsTreeStructure=function(oldMap, keepClassName=false
 };
 
 
-function restoreGraph(flatData, keepClassName=false, UUID_ATTR_NAME, CLASSNAME_ATTR_NAME, POINTER_TO_ATTR_NAME) {
+window.restoreGraph=(flatData, keepClassName=false, UUID_ATTR_NAME, CLASSNAME_ATTR_NAME, POINTER_TO_ATTR_NAME)=>{
 
-  function revive(id, keepClassName, restoredObjects = {}) {
+  const revive=(id, keepClassName, restoredObjects = {})=>{
 	
     if(!id || typeof(flatData[id])==="undefined" || flatData[id]==null) return null;
     const found=restoredObjects[id];
@@ -5044,7 +5072,7 @@ AOTRAUTILS_LIB_IS_LOADED=true;
 
 	
 
-/*utils CLIENT library associated with aotra version : «1_29072022-2359 (11/11/2025-18:19:16)»*/
+/*utils CLIENT library associated with aotra version : «1_29072022-2359 (01/03/2026-01:46:57)»*/
 /*-----------------------------------------------------------------------------*/
 /* ## Utility global methods in a browser (htmljs) client environment.
  *
@@ -5064,8 +5092,6 @@ AOTRAUTILS_LIB_IS_LOADED=true;
  */
 
 
-// Node dependencies :
-if(typeof(require)!="undefined" && typeof(sjcl)=="undefined" )	sjcl = require("sjcl");
 
 
 // COMPATIBILITY browser javascript / nodejs environment :
@@ -6730,6 +6756,91 @@ function htmlColorCodeToDecimalArray(hexColorCodeParam){
 	return [ hex2dec(hexColorCode.substring(0, 2)), hex2dec(hexColorCode.substring(2, 4)), hex2dec(hexColorCode.substring(4, 6)) ];
 }
 
+window.ascii2RGBA=(rgbaWholeString, pixelIndex)=>{
+	const asciiValueRed = rgbaWholeString.charCodeAt(pixelIndex);
+	const r=asciiValueRed;
+	const asciiValueGreen = rgbaWholeString.charCodeAt(pixelIndex+1);
+	const g=asciiValueGreen;
+	const asciiValueBlue = rgbaWholeString.charCodeAt(pixelIndex+2);
+	const b=asciiValueBlue;
+	const asciiValueAlpha = rgbaWholeString.charCodeAt(pixelIndex+3);
+	const a=asciiValueAlpha;
+	return {r:r, g:g, b:b, a:a};
+}
+
+window.ascii2RGB=(rgbWholeString, pixelIndex=0)=>{
+	const asciiValueRed = rgbWholeString.charCodeAt(pixelIndex);
+	const r=asciiValueRed;
+	const asciiValueGreen = rgbWholeString.charCodeAt(pixelIndex+1);
+	const g=asciiValueGreen;
+	const asciiValueBlue = rgbWholeString.charCodeAt(pixelIndex+2);
+	const b=asciiValueBlue;
+	return {r:r, g:g, b:b};
+}
+
+// UNUSED
+window.asciiStringToNumber=(str)=>{
+  if(!str || empty(str)){
+    throw new Error("ERROR : String must not be empty. Aborting string conversion to number.");
+  }
+	
+	let result=0;
+	let shift=0;
+	for(let i=0;i<str.length;i++){
+	  // Get the ASCII (UTF-16 code unit) for each character
+	  const c = str.charCodeAt(i);
+	  if(255<c){
+	    throw new Error("Character «"+c+"» is outside the ASCII range (0-255). Aborting.");
+	  }
+	  // Combine them into a single number using bitwise shifts
+	  // char1 is shifted 16 bits to the left, char2 8 bits, and char3 remains in the lowest 8 bits.
+	  result=((c << shift) | result);
+		shift+=8;
+	}
+
+  return result;
+}
+
+window.convertBase255NumberRepresentedInUTF16tringToBase10Number=(str)=>{
+	const BASE = 255;
+
+	if(!str || empty(str))
+		return 0;
+
+	let result=0;
+	// We reverse the string digits order :
+	for(let i=str.length-1;0<=i;i--){
+		let charCode=str.charCodeAt(i);
+		// To handle the «modifier letter apostrophe» (UTF8 code 700)) sent as a replacement
+		// for the «single quote» character (ASCII base table code 39) that is invalid in JSON text :
+		if(charCode==700)	charCode=39;
+		result+=Math.pow(BASE, str.length-1-i)*charCode;
+		// // DBG
+		// lognow("int:" + str.charCodeAt(i) + ",char:" + str[i]+"|");
+	}
+
+	return result;
+};
+
+
+// UNUSED
+window.numberToAsciiString=(num, originalStringSize)=>{
+	if(!originalStringSize)
+		return "";
+	
+	let result="";
+	let shift=(originalStringSize-1)*8;
+	for(let i=0;i<originalStringSize;i++){
+		// Extract characters using bitwise shifts and masking
+		result+=String.fromCharCode((num >> shift) & 0xFF);
+	}
+
+  return result;
+}
+
+
+
+
 
 /*private*/function componentToHex(c){
   var hex=c.toString(16);
@@ -7987,8 +8098,12 @@ function filterPoints(allPoints ,ctx/*DBG*/){
 	
 	if(!isUserMediaAvailable()){
 		// TRACE
-		log("ERROR : User medias is not supported in your browser (or are you running in a non-https context ?). Aborting");
+		log("ERROR : User medias is not supported in your browser, or you are running in a non-https context, or you are running in a nodejs context. Aborting");
 		return Promise.resolve();
+	}else{
+		// TODO : FIXME :
+		// Use https://www.npmjs.com/package/node-webcam (based on fswebcam) or https://github.com/yocontra/camera (based on opencv4)
+		// to handle all the «nodejs context running»-like cases
 	}
 
 	return new Promise((accept,reject)=>{
@@ -8960,8 +9075,7 @@ function loadSoundsLoop(filesPaths,doOnLoaded=null,doOnEnded=null){
 	let audios=[];
 	let numberLoaded=0;
 	foreach(filesPaths,(filePath)=>{
-		audios.push( loadSound(filePath,function(selfParam/*UNUSED*/){
-			
+		const sound=loadSound2D(filePath,function(selfParam/*UNUSED*/){
 			numberLoaded++
 			if(doOnLoaded && numberLoaded==filesPaths.length){
 				
@@ -8971,10 +9085,9 @@ function loadSoundsLoop(filesPaths,doOnLoaded=null,doOnEnded=null){
 				// To prevent starting treatments after the loading has occurred after the loop has been stopped !
 				// (rare case when the loading is so long that the user has aborted the loop before all loop files has been loaded !)
 				if(!selfSoundsLoop.hasAbortedLooping)		doOnLoaded(selfSoundsLoop);
-				
 			}
-			
-		}) );
+		});
+		audios.push(sound);
 	});
 	
 	return selfSoundsLoop;
@@ -9190,7 +9303,7 @@ class Sound{
 }
 
 
-function loadSound(filePath,doOnLoaded=null,doOnEnded=null){
+function loadSound2D(filePath,doOnLoaded=null,doOnEnded=null){
 	
 	let self=new Sound(filePath,doOnEnded);
 
@@ -11663,19 +11776,19 @@ initClient=function(isNodeContext=true, useSocketIOImplementation=/*DEBUG*/false
 		// DBG
 		lognow("INFO : Setting up client :...");
 		
-		let socketToServer=WebsocketImplementation.getStatic(isNodeContext, useSocketIOImplementation).connectToServer(url, port, isSecure, timeout);
-		if(!socketToServer){
+		let socketToServerClientInstance=WebsocketImplementation.getStatic(isNodeContext, useSocketIOImplementation).connectToServer(url, port, isSecure, timeout);
+		if(!socketToServerClientInstance){
 			// TRACE
-			lognow("ERROR : CLIENT : Could not get socketToServer, aborting client connection.");
+			lognow("ERROR : CLIENT : Could not get socketToServerClientInstance, aborting client connection.");
 			return null;
 		}
 		
 		// When client is connected, we execute the callback :
 		// CAUTION : MUST BE CALLED ONLY ONCE !
-		socketToServer.onConnectionToServer(()=>{
+		socketToServerClientInstance.onConnectionToServer(()=>{
 			if(doOnServerConnection){
-				if(selfParam)	doOnServerConnection.apply(selfParam,[socketToServer]);
-				else				  doOnServerConnection(socketToServer);
+				if(selfParam)	doOnServerConnection.apply(selfParam,[socketToServerClientInstance]);
+				else				  doOnServerConnection(socketToServerClientInstance);
 			}
 		
 			
@@ -11696,18 +11809,18 @@ initClient=function(isNodeContext=true, useSocketIOImplementation=/*DEBUG*/false
 //				else					doOnError();
 //			};
 //			
-//			socketToServer.clientSocket.on("connect_error", errorMethod);
+//			socketToServerClientInstance.clientSocket.on("connect_error", errorMethod);
 //				
 ////			// DOES NOT SEEM TO WORK :
-////			socketToServer.on("connect_failed", errorMethod);
+////			socketToServerClientInstance.on("connect_failed", errorMethod);
 ////			// DOES NOT SEEM TO WORK :
-////			socketToServer.on("error", errorMethod);
+////			socketToServerClientInstance.on("error", errorMethod);
 //			
 //		}
 //
 //		// Data messages handling :
 //		if(doOnMessage){
-//			socketToServer.onIncomingMessage((message)=>{
+//			socketToServerClientInstance.onIncomingMessage((message)=>{
 //				if(selfParam)	doOnMessage.apply(selfParam,[message]);
 //				else				  doOnMessage(message);
 //			});
@@ -11723,7 +11836,7 @@ initClient=function(isNodeContext=true, useSocketIOImplementation=/*DEBUG*/false
 //		});
 
 		
-		aotraClient.client.socketToServer=socketToServer;
+		aotraClient.client.socketToServerClientInstance=socketToServerClientInstance;
 		
 		return aotraClient;
 	};
@@ -11739,20 +11852,18 @@ initClient=function(isNodeContext=true, useSocketIOImplementation=/*DEBUG*/false
 
 class VNCFrame2D{
 	
-	constructor(url, port=6080, isSecure=true, htmlConfig={parentElement:null,imageMode:"CSSBackground"}, mouseEventsRefreshMillis=100){
+	constructor(url, port=4000, htmlConfig={parentElement:null,imageMode:"CSSBackground"}, mouseEventsRefreshMillis=100){
 		
 		
 		this.url=url;
 		this.port=port;
-		this.isSecure=isSecure;
+		this.isSecure=(contains(url.toLowerCase(),"wss"));
 		this.parentElement=nonull(htmlConfig.parentElement, document.body);
 		this.imageMode=htmlConfig.imageMode;
 		this.mouseEventsRefreshMillis=mouseEventsRefreshMillis;
 
-		
 		this.fusrodaClient=null;
 		
-		
 		this.screenAndAudioConfig=null;
 		this.image=null;
 		self.audioCtx=null;
@@ -11784,7 +11895,6 @@ class VNCFrame2D{
 							// lognow("Image finished loading.");
 							
 							const image=event.target;
-							image.isImageLoading=false;
 							
 							if(!self.canvasSizeHasBeenSet){
 								self.canvas.width=image.width;
@@ -11793,25 +11903,25 @@ class VNCFrame2D{
 							}
 
 							self.canvas.getContext("2d").drawImage(image,0,0);
+							image.isImageLoading=false;
 
-							self.fusrodaClient.client.socketToServer.send("screenFrameRequest", {});
+							self.fusrodaClient.client.socketToServerClientInstance.send("screenFrameRequest", {});
 
 						});
 						
 					}
 
-					
-					self.audioCtx=new AudioContext({sampleRate: self.screenAndAudioConfig.sampleRate});
+					if(self.screenAndAudioConfig.sampleRate)
+						self.audioCtx=new AudioContext({sampleRate: self.screenAndAudioConfig.sampleRate});
 					
 				
 			},// doOnDataReception:
 				{
-				"image":(imageDataStr)=>{
-					
-					
+				/*DEPRECATED, NOT HANDLED ANYMORE*/"image64":(imageDataStr)=>{
 					const base64String="data:image/png;base64,"+imageDataStr;
 					if(self.imageMode=="canvas"){
 						if(self.image.complete){
+						if(self.image.isImageLoading)		return;
 							self.image.src=base64String;
 							self.image.isImageLoading=true;
 						}
@@ -11819,12 +11929,11 @@ class VNCFrame2D{
 						self.parentElement.style["background-image"]="url('"+base64String+"');";
 					}
 					
-					
 				},
 				"sound":(soundDataStr)=>{
 					const soundData=getDecodedArrayFromSoundDataString(soundDataStr);
 					playAudioData(soundData,self.audioCtx,self.screenAndAudioConfig.audioBufferSize,1,self.screenAndAudioConfig.sampleRate,()=>{
-						self.fusrodaClient.client.socketToServer.send("soundSampleRequest", {});
+						self.fusrodaClient.client.socketToServerClientInstance.send("soundSampleRequest", {});
 					});
 				}
 		}, this.url, this.port, this.isSecure);
@@ -11937,7 +12046,27 @@ class VNCFrame2D{
 }
 
 
-
+window.base64ToUint8ClampedArray=(base64String)=>{
+    const binaryString=window.atob(base64String);
+    
+    const pixelsNumber=(binaryString.length);
+    let bytes=new Uint8ClampedArray(pixelsNumber*4);
+    for (let i=0; i<pixelsNumber; i++) {
+	
+				let p=binaryString.charCodeAt(i);
+				let a=(p>>24) & 0xff;
+				let r=(p>>16) & 0xff;
+				let g=(p>>8) & 0xff;
+				let b=(p) & 0xff;
+	
+        bytes[i]=r;
+        bytes[i+1]=g;
+        bytes[i+2]=b;
+        bytes[i+3]=a;
+    }
+    
+    return bytes;
+};
 
 
 // ============================================== BROWSER CLIENTS ==============================================
@@ -11945,67 +12074,66 @@ class VNCFrame2D{
 
 // FUSRODA : 
 
-createFusrodaClient=function(doOnClientReady, doOnDataReception, urlParam=null, portParam=6080){
+createFusrodaClient=function(doOnClientReady, doOnDataReception, urlParam=null, portParam=4000){
  	// CAUTION : WORKS BETTER WHEN UNSECURE, BUT 'NEEDS CLIENT BROWSER TO ALLOW MIXED (SECURE/UNSECURE) CONTENT !
 	
-	const isSecure=(contains(urlParam.toLowerCase(),"https") || contains(urlParam.toLowerCase(),"wss"));
 	
+	const isSecure=(contains(urlParam.toLowerCase(),"https") || contains(urlParam.toLowerCase(),"wss"));
 	
-	const fusrodaClient=initClient(false,/*CAUTION : Fusroda Java server requires the SOcket IO websocket implementation !!*/true, /*doOnServerConnection*/(socketToServer)=>{
+	const fusrodaClient=initClient(false,
+		/*CAUTION : Fusroda Java server requires the Socket IO websocket implementation !!*/true,
+		/*doOnServerConnection:*/(socketToServerClientInstance)=>{
 		
 		// DBG
 		lognow("FUSRODA CLIENT : SETTING UP...");
 		
-
 		//0)
-		socketToServer.receive("protocolConfig", (messageConfig)=>{
+		socketToServerClientInstance.receive("protocolConfig", (messageConfig)=>{
 			
 			// DBG
 			lognow("(CLIENT) (DEBUG) Received protocol config from server : messageConfig:",messageConfig);
 			
-			//2)			
-			socketToServer.receive("imagePacket", (doOnDataReception && doOnDataReception["image"]?doOnDataReception["image"]:()=>{/*DO NOTHING*/}));
-			
-			// //DBG
-			// lognow("Initial image request.");
-			
 			// Initial frame request sending :
-			socketToServer.send("screenFrameRequest", {});
-
-			//2)			
-			socketToServer.receive("soundPacket", (doOnDataReception && doOnDataReception["sound"]?doOnDataReception["sound"]:()=>{/*DO NOTHING*/}));
+			socketToServerClientInstance.send("screenFrameRequest", {});
 			// Initial sound sample request sending :
-			socketToServer.send("soundSampleRequest", {});
-
+			socketToServerClientInstance.send("soundSampleRequest", {});
 
 			doOnClientReady(messageConfig);
 		});
+	
+		//2)
+		/*DEPRECATED, NOT HANDLED ANYMORE*/socketToServerClientInstance.receive("image64Packet", (doOnDataReception && doOnDataReception["image64"]?doOnDataReception["image64"]:()=>{/*DO NOTHING*/}));
+		socketToServerClientInstance.receive("imagePacket", (doOnDataReception && doOnDataReception["image"]?doOnDataReception["image"]:()=>{/*DO NOTHING*/}));
+		socketToServerClientInstance.receive("imageDiffPacket", (doOnDataReception && doOnDataReception["imageDiff"]?doOnDataReception["imageDiff"]:()=>{/*DO NOTHING*/}));
+		socketToServerClientInstance.receive("soundPacket", (doOnDataReception && doOnDataReception["sound"]?doOnDataReception["sound"]:()=>{/*DO NOTHING*/}));
+		
+		// DBG
+		lognow("(CLIENT) SENDING «hello» TO SERVER...");
 		
 		//1)
-		socketToServer.send("protocol", { type:"hello" });
+		socketToServerClientInstance.send("protocol", { type:"hello" });
 
 		
 	}, urlParam, portParam, isSecure);
 	
 	fusrodaClient.sendMouseMoveEvent=(mouseEvent)=>{
-		fusrodaClient.client.socketToServer.send("mouseMoveEvent", mouseEvent);
+		fusrodaClient.client.socketToServerClientInstance.send("mouseMoveEvent", mouseEvent);
 	};
-		
 	fusrodaClient.sendMouseClickEvent=(mouseEvent)=>{
-		fusrodaClient.client.socketToServer.send("mouseClickEvent", mouseEvent);
+		fusrodaClient.client.socketToServerClientInstance.send("mouseClickEvent", mouseEvent);
 	};
 	fusrodaClient.sendMouseReleasedEvent=(mouseEvent)=>{
-		fusrodaClient.client.socketToServer.send("mouseReleasedEvent", mouseEvent);
+		fusrodaClient.client.socketToServerClientInstance.send("mouseReleasedEvent", mouseEvent);
 	};
 	fusrodaClient.sendWheelEvent=(wheelEvent)=>{
-		fusrodaClient.client.socketToServer.send("wheelEvent", wheelEvent);
+		fusrodaClient.client.socketToServerClientInstance.send("wheelEvent", wheelEvent);
 	};
 
 	fusrodaClient.sendKeyboardPressedEvent=(keyboardEvent)=>{
-		fusrodaClient.client.socketToServer.send("keyboardPressedEvent", keyboardEvent);
+		fusrodaClient.client.socketToServerClientInstance.send("keyboardPressedEvent", keyboardEvent);
 	};
 	fusrodaClient.sendKeyboardReleasedEvent=(keyboardEvent)=>{
-		fusrodaClient.client.socketToServer.send("keyboardReleasedEvent", keyboardEvent);
+		fusrodaClient.client.socketToServerClientInstance.send("keyboardReleasedEvent", keyboardEvent);
 	};
 
 	
@@ -12189,7 +12317,7 @@ window.createOritaMainClient=function(
 
 
 
-	const oritaClient=initClient(false, false, /*doOnServerConnection*/(socketToServer)=>{
+	const oritaClient=initClient(false, false, /*doOnServerConnection*/(socketToServerClientInstance)=>{
 
 		// DBG
 		lognow("ORITA MAIN CLIENT : SETTING UP");
@@ -12216,7 +12344,7 @@ window.createOritaMainClient=function(
 				storeString(ORITA_HASH_STRING_NAME, calculatedHash);
 			
 				// TODO : FIXME : DUPLICATED CODE :
-				socketToServer.send("protocol", "request.register:mainClient:"+calculatedHash);
+				socketToServerClientInstance.send("protocol", "request.register:mainClient:"+calculatedHash);
 								
 			},()=>{
 				// TRACE
@@ -12225,7 +12353,7 @@ window.createOritaMainClient=function(
 		    
 		}else{
 			// TODO : FIXME : DUPLICATED CODE :
-			socketToServer.send("protocol", "request.register:mainClient:"+storedHashKey);
+			socketToServerClientInstance.send("protocol", "request.register:mainClient:"+storedHashKey);
 		}
 
 
@@ -12242,7 +12370,7 @@ window.createOritaMainClient=function(
 	
 		
 				
-		oritaClient.client.socketToServer.receive("protocol", (message)=>{
+		oritaClient.client.socketToServerClientInstance.receive("protocol", (message)=>{
 					
 					// TRACE
 					lognow("Mainclient received message from server:",message);
@@ -12260,7 +12388,7 @@ window.createOritaMainClient=function(
 						
 						
 						// Main client starts receiving :
-						oritaClient.client.socketToServer.receive("server.send.data", (receivedData)=>{
+						oritaClient.client.socketToServerClientInstance.receive("server.send.data", (receivedData)=>{
 		
 							
 							let microClientId=receivedData.microClientId;
@@ -12343,7 +12471,7 @@ window.createOritaMainClient=function(
 				
 	
 		
-		oritaClient.client.socketToServer.receive("communication", (message)=>{
+		oritaClient.client.socketToServerClientInstance.receive("communication", (message)=>{
 			
 			// DBG
 			lognow("MAIN CLIENT RECEIVED COMMUNICATION :",message);
@@ -12581,7 +12709,7 @@ const HALF_STEP_STEPPER_SEQUENCE = [
 
 
 
-createOritaMicroClient=function(url, port, isNode=false, staticMicroClientIdParam=null){
+createOritaMicroClient=function(url, port, isNode=false, staticMicroClientIdParam=null, videoDataHook=null){
 
 
 	let audioBufferSize = ORITA_CONSTANTS.AUDIO_BUFFER_SIZE;
@@ -12593,6 +12721,8 @@ createOritaMicroClient=function(url, port, isNode=false, staticMicroClientIdPara
 	const oritaClient={
 	
 		staticMicroClientId:staticMicroClientId,
+		videoDataHook:videoDataHook,
+//	audioDataHook:audioDataHook,// TODO !
 	
 		onRegistrationEventListeners:[],
 		onCommunicationEventListeners:[],
@@ -12663,10 +12793,8 @@ createOritaMicroClient=function(url, port, isNode=false, staticMicroClientIdPara
 				// TODO : FIXME : Utiliser initClient(...) au lieu de directement getStatic(...) avec le paramètre isNode transmis dans l'appel)
 				//oritaClient=initClient(isNode,false,doOnServerConnection=null, url, port);
 				oritaClient.client={};
-				oritaClient.client.socketToServer = WebsocketImplementation.getStatic(isNode).connectToServer(url, port);
-				oritaClient.client.socketToServer.onConnectionToServer(() => {
-
-
+				oritaClient.client.socketToServerClientInstance=WebsocketImplementation.getStatic(isNode).connectToServer(url, port);
+				oritaClient.client.socketToServerClientInstance.onConnectionToServer(() => {
 
 
 					// TRACE
@@ -12682,17 +12810,13 @@ createOritaMicroClient=function(url, port, isNode=false, staticMicroClientIdPara
 					lognow("INFO : (CLIENT) Microclient will now register to server with microClientId «" + microClientId + "».");
 
 
-					oritaClient.client.socketToServer.send("protocol", "request.register:microClient:" + microClientId);
-
-
-
+					oritaClient.client.socketToServerClientInstance.send("protocol", "request.register:microClient:" + microClientId);
 
 	
 	
-	
 					// ------------------------------ CONNECTION EVENTS REGISTRATION ------------------------------
 					
-					oritaClient.client.socketToServer.receive("protocol", (message) => {
+					oritaClient.client.socketToServerClientInstance.receive("protocol", (message) => {
 	
 						// TRACE
 						lognow("INFO : MICRO CLIENT : Server sent a message on the protocol channel : message:", stringifyObject(message));
@@ -12741,41 +12865,54 @@ createOritaMicroClient=function(url, port, isNode=false, staticMicroClientIdPara
 										//		console.log("INFO : MICRO CLIENT : videoData : ",videoData);
 	
 										if (videoData && videoData.data) {
-	
-											let videoRawData = videoData.data;
-	
-	
-											if (videoData.format !== "base64" && videoData.messWithAlpha) {
-												videoRawData = removeAlpha(videoRawData);
+
+											if(oritaClient.videoDataHook && oritaClient.videoDataHook.doVideoAnalysis){
+												data.videoAnalysis={
+													treatmentName:oritaClient.videoDataHook.doVideoAnalysis.treatmentName,
+													treatmentResult:(oritaClient.videoDataHook.doVideoAnalysis.doTreatment?
+																 oritaClient.videoDataHook.doVideoAnalysis.doTreatment(videoData)
+																:null),
+												};
+											}
+
+											
+											if(!oritaClient.videoDataHook || (oritaClient.videoDataHook && oritaClient.videoDataHook.doNotSendToServer!=true)){
+												
+												let videoRawData = videoData.data;
+
+												if (videoData.format !== "base64" && videoData.messWithAlpha) {
+													videoRawData = removeAlpha(videoRawData);
+												}
+												
+												//		// TRACE
+												//		lognow("CLIENT : getting to send : videoRawData.length:"+videoRawData.length);
+		
+												// Actually, only handles "LZW" compression, for now...
+		
+												let stringToSend;
+												if (ORITA_CONSTANTS.STRINGIFY_VIDEO_DATA) stringToSend = arrayToString(videoRawData, false, 1);
+												else stringToSend = videoRawData;
+		
+												// We set the Side is «left» or «right»
+												if (videoSide) data.videoSide = videoSide;
+		
+		
+												data.video = {
+													width: videoData.width,
+													height: videoData.height,
+													data: stringToSend,
+													messWithAlpha: videoData.messWithAlpha,
+													format: videoData.format,
+												};
+												data.compression = {
+													precision: 1,
+													//algorithm:"LZW"
+												};
+												
 											}
-	
-											// We set the Side is «left» or «right»
-											if (videoSide) data.videoSide = videoSide;
-	
-											//		// TRACE
-											//		lognow("CLIENT : getting to send : videoRawData.length:"+videoRawData.length);
-	
-											// Actually, only handles "LZW" compression, for now...
-	
-											let stringToSend;
-											if (ORITA_CONSTANTS.STRINGIFY_VIDEO_DATA) stringToSend = arrayToString(videoRawData, false, 1);
-											else stringToSend = videoRawData;
-	
-	
-	
-											data.video = {
-												width: videoData.width,
-												height: videoData.height,
-												data: stringToSend,
-												messWithAlpha: videoData.messWithAlpha,
-												format: videoData.format,
-											};
-											data.compression = {
-												precision: 1,
-												//algorithm:"LZW"
-											};
 	
 										}
+
 	
 									} else if (medias === "audio") {
 	
@@ -12803,6 +12940,7 @@ createOritaMicroClient=function(url, port, isNode=false, staticMicroClientIdPara
 										return;
 									}
 	
+									
 	
 									//	// TRACE
 									//	lognow("CLIENT : SENDING DATA TO SERVER :");
@@ -12813,12 +12951,11 @@ createOritaMicroClient=function(url, port, isNode=false, staticMicroClientIdPara
 									data.microClientId = oritaClient.microClientId;
 	
 									// Micro client starts sending :
-									oritaClient.client.socketToServer.send("microClient.send.data", data);
+									oritaClient.client.socketToServerClientInstance.send("microClient.send.data", data);
 	
 	
 	
-								}
-									, refreshingRateMillis); // SENDING LOOP
+								}, refreshingRateMillis); // SENDING LOOP
 								// *************************
 							}
 	
@@ -12836,7 +12973,7 @@ createOritaMicroClient=function(url, port, isNode=false, staticMicroClientIdPara
 	
 					});
 	
-					oritaClient.client.socketToServer.receive("communication", (message) => {
+					oritaClient.client.socketToServerClientInstance.receive("communication", (message) => {
 						// We execute eventual on message events listeners :
 						foreach(oritaClient.onCommunicationEventListeners, (e) => {
 							if (!e.condition || e.condition(message)) e.execute(message);
@@ -12902,7 +13039,6 @@ createOritaMicroClient=function(url, port, isNode=false, staticMicroClientIdPara
 					} else { // Case node micro client :
 
 
-
 						// DBG
 						console.log("mediaParameters", mediaParameters);
 						console.log("medias", medias);
@@ -12992,7 +13128,7 @@ createOritaMicroClient=function(url, port, isNode=false, staticMicroClientIdPara
 						// DBG
 						lognow("SIGNALING INPUTS");
 
-						oritaClient.client.socketToServer.send("communication", {
+						oritaClient.client.socketToServerClientInstance.send("communication", {
 							type: "request.microClient.appendInputs",
 							inputsGPIO: oritaClient.inputsGPIO,
 							microClientId: oritaClient.microClientId,
@@ -13004,7 +13140,7 @@ createOritaMicroClient=function(url, port, isNode=false, staticMicroClientIdPara
 						// DBG
 						lognow("SIGNALING OUTPUTS");
 
-						oritaClient.client.socketToServer.send("communication", {
+						oritaClient.client.socketToServerClientInstance.send("communication", {
 							type: "request.microClient.appendOutputs",
 							outputsGPIO: oritaClient.outputsGPIO,
 							microClientId: oritaClient.microClientId,
@@ -13055,7 +13191,7 @@ createOritaMicroClient=function(url, port, isNode=false, staticMicroClientIdPara
 		// 1-
 		oritaClient.onRegistrationEventListeners.push({
 			execute: (microClientId, message) => {
-				oritaClient.client.socketToServer.send("communication", {
+				oritaClient.client.socketToServerClientInstance.send("communication", {
 					type: "request.microClient.appendInputs",
 					inputsGPIO: oritaClient.inputsGPIO,
 					microClientId: oritaClient.microClientId,
@@ -13073,7 +13209,7 @@ createOritaMicroClient=function(url, port, isNode=false, staticMicroClientIdPara
 			});
 
 
-			oritaClient.client.socketToServer.send("communication", {
+			oritaClient.client.socketToServerClientInstance.send("communication", {
 				type: "request.microClient.updateInputsValues",
 				inputsGPIO: inputsGPIO,
 				microClientId: oritaClient.microClientId,
@@ -13260,7 +13396,7 @@ createOritaMicroClient=function(url, port, isNode=false, staticMicroClientIdPara
 		// 1-
 		oritaClient.onRegistrationEventListeners.push({
 			execute: (microClientId, message) => {
-				oritaClient.client.socketToServer.send("communication", {
+				oritaClient.client.socketToServerClientInstance.send("communication", {
 					type: "request.microClient.appendOutputs",
 					outputsGPIO: oritaClient.outputsGPIO,
 					microClientId: oritaClient.microClientId,
@@ -13354,7 +13490,7 @@ createOritaMicroClient=function(url, port, isNode=false, staticMicroClientIdPara
 				//				});
 
 				// 4-
-				oritaClient.client.socketToServer.send("communication", {
+				oritaClient.client.socketToServerClientInstance.send("communication", {
 					type: "response.microClient.outputChanged",
 					outputsGPIO: oritaClient.outputsGPIO,
 				});
@@ -13390,7 +13526,7 @@ createOritaMicroClient=function(url, port, isNode=false, staticMicroClientIdPara
 	oritaClient.sendCommand = (commandName, commandParameters = null) => {
 		const microClientId = oritaClient.microClientId;
 		const command = { microClientId: microClientId, type: "microClient.send.command", name: commandName, parameters: commandParameters };
-		oritaClient.client.socketToServer.send("communication", command);
+		oritaClient.client.socketToServerClientInstance.send("communication", command);
 		return oritaClient;
 	};
 
@@ -13401,253 +13537,10 @@ createOritaMicroClient=function(url, port, isNode=false, staticMicroClientIdPara
 
 
 
-//*********************************** AUTO-ORGANIZING REAL-TIME AORTAC CLUSTERIZATION (AORTAC) *********************************** */
-
-
-
-
-class AORTACClient{
-	
-		constructor(clientId, serverNodeOrigin, model, view, isNodeContext=true, sslConfig={/*OPTIONAL*/certPath:null,/*OPTIONAL*/keyPath:null}){
-			this.clientId=clientId;
-			this.serverNodeOrigin=serverNodeOrigin;
-			this.isNodeContext=isNodeContext;
-			this.sslConfig=sslConfig;
-			
-			this.model=model;						// must implement functions
-			this.view=view; 						// Must implement functions
-			this.view.setClient(this);
-			
-			this.clientInstanceToReferenceServerNode=null;
-			this.currentServersNodes={};
-			
-			
-			// TRACE
-			lognow(`AORTAC client created with id ${this.clientId}.`);
-			
-		}
-		
-		start(){
-		
-			const self=this;
-			
-			const splits=splitURL(this.serverNodeOrigin);
-			let protocol=nonull(splits.protocol,"ws"), host=nonull(splits.host,"localhost"), port=nonull(splits.port,"30000");
-			
-			
-			// THIS IS ON THE REFERENCE SERER NODE ONLY :
-			const clientInstanceToReferenceServerNode=initClient(this.isNodeContext, false, (socketToServer)=>{
-				
-				
-				// First client needs to register to its main reference serer node : 
-				// TRACE
-				lognow(`		(client ${self.clientId}) Sending client registering request to server node...`);
-				
-				const helloClientRequest={
-					clientId:self.clientId,
-					type:"request.register.client",
-					isReferenceNode:true,
-				};
-				socketToServer.send("protocol", helloClientRequest);
-				
-				// We place a listener from server on this client instance :
-				socketToServer.receive("protocol",(message)=>{
-					
-					
-					// Adding listeners :
-					if(message.type==="response.register.client"){
-						
-						// TRACE
-						lognow(`		(${self.clientId}) Receving registering response from reference server...`);
-						
-						// Case reference node:
-							
-						// Second, once client is registered at its refernce server, then it needs to know to which servers it needs to connect to : 
-						// TRACE
-						lognow("(client "+self.clientId+") Sending client interrogation request to server node...");
-						
-						const boundaries=self.view.getBoundaries();
-						const interrogationRequest={
-							clientId:self.clientId,
-							type:"request.interrogation.client",
-							boundaries:boundaries
-						};
-						socketToServer.send("protocol", interrogationRequest);
-					
-
-					}
-				});
-				
-				// We place a listener from server on this client instance :
-				socketToServer.receive("protocol",(message)=>{
-					if(message.type==="response.unregister.client"){
-						
-						// TRACE
-						lognow(`		(${self.clientId}) Receving unregistering response from reference server...`);
-						
-						// DO NOTHING
-						
-					}
-				});
-			 		
-				
-				// We place a listener from server on this client instance :
-				socketToServer.receive("protocol",(message)=>{
-					if(message.type==="response.interrogation.client"){
-						
-						// TRACE
-						lognow("!!!!!! ("+self.clientId+") Receving interrogation response from requested server...",message);
-						
-						// Now the client needs to know to which other nodes it needs to connect in order to get all its model objects :
-						const serversNodesIdsForModelObjectsForClient=message.serversNodesIdsForModelObjectsForClient;
-
-						// Now the client needs to know to which other nodes it needs to connect in order to get all its model objects :
-						
-						
-						// We connect (only) to the relevant servers directly :
-						foreach(serversNodesIdsForModelObjectsForClient,(nodeInfoAndObjectsIds, serverNodeId)=>{
-							
-							const splitsServerInfo=splitURL(nodeInfoAndObjectsIds.nodeServerInfo);
-							const clientInstanceToAuthorityServerNode=initClient(this.isNodeContext, false, (socketToServer)=>{
-							
-								// Then we register to them :
-								// TRACE
-								lognow(`			(client ${self.clientId}) Sending client registering request to authority server node...`);
-								
-								const helloToAuthorityClientRequest={
-									clientId:self.clientId,
-									type:"request.register.client",
-									isReferenceNode:false,
-								};
-								socketToServer.send("protocol", helloToAuthorityClientRequest);
-							
-							
-							}, splitsServerInfo.protocol+"://"+splitsServerInfo.host, splitsServerInfo.port, false);
-							self.currentServersNodes[serverNodeId]={clientInstance:clientInstanceToAuthorityServerNode};
-							clientInstanceToAuthorityServerNode.client.start();
-							
-							
-							clientInstanceToAuthorityServerNode.client.socketToServer.receive("protocol", (message)=>{
-								
-								// Adding listeners :
-								if(message.type==="response.register.client"){
-									// We place a listener from server on this client instance :
-									// Adding listeners :
-									
-									// Case non-reference authority node servers :
-									
-									// TRACE
-									lognow(`		(${self.clientId}) Receving registering response from reference server...`);
-									
-									// We merge our client's model with the partial model sent from the server it just registered to :
-									const partialModelString=message.partialModelString;
-									const partialModel=JSON.parseRecycle(partialModelString);
-									
-									// Merging means that all objects in partialModel not being in model must be added to model :
-									self.model.clientMergeWith(partialModel);
-									
-									// TRACE
-									lognow("(client "+self.clientId+") Client model has been merged with a partial model from a server node...",self.model);
-			
-								}
-								
-								
-							});
-							
-							
-							
-							clientInstanceToAuthorityServerNode.client.socketToServer.receive("inputs", (message)=>{
-								
-								// Adding listeners :
-								if(message.type==="response.objectsModifiedOrAdded.client"){
-									const modifiedOrAddedObjects=JSON.parseRecycle(message.objectsString);
-									
-									if(!message.isAddingObjects){
-										self.model.clientUpdateObjects(modifiedOrAddedObjects);
-									}else{
-										self.model.clientAddObjects(modifiedOrAddedObjects);
-									}
-									
-									// TRACE
-									lognow(`			(client ${self.clientId}) Receving modified or added objects after the inputs...modifiedOrAddedObjects=`,modifiedOrAddedObjects);
-									
-
-								}
-								
-								
-							});
-											
-							
-						});
-						
-					}
-				});
-				
-				
-				//self.addListeners();
-
-
-				
-			}, protocol+"://"+host, port, false);
-			clientInstanceToReferenceServerNode.client.start();
-			this.clientInstanceToReferenceServerNode={clientInstance:clientInstanceToReferenceServerNode};
-			
-			
-			return this;
-		}
-		
-
-		/*public*/sendInputs(inputs, subBoundaries=null){
-			
-			const self=this;
-
-
-			if(subBoundaries){
-				// We send client's inputs to ALL its currently connected servers :
-				const self=this;
-				foreach(this.currentServersNodes,(serversNode,serverNodeId)=>{
-					self.sendInputsToServer(serversNode, inputs, subBoundaries);
-				});
-			}else{
-				// If we have no boundaries set for these inputs, then we only send them to one server node at random :
-				const serversNode=Math.getRandomInArray(this.currentServersNodes);
-				this.sendInputsToServer(serversNode, inputs, subBoundaries);
-			}
-			
-			
-		}
-
-		/*private*/sendInputsToServer(serversNode, inputs, subBoundaries=null){
-			const clientInstance=serversNode.clientInstance;
-			
-			const inputsMessage={
-				clientId:this.clientId,
-				type:"request.inputs.client",
-				inputs:inputs,
-				subBoundaries:subBoundaries,
-			};
-				
-			clientInstance.client.socketToServer.send("inputs", inputsMessage);
-		}
-
-
-
-
-
-		
-}
-
-
-getAORTACClient=function(clientId=getUUID(), serverNodeOrigin="ws://127.0.0.1:40000", model, view, isNodeContext=true){
-	return new AORTACClient(clientId, serverNodeOrigin, model, view, isNodeContext);
-}
-
-
-
 
 
 
-/*utils GEOMETRY library associated with aotra version : «1_29072022-2359 (11/11/2025-18:19:16)»*/
+/*utils GEOMETRY library associated with aotra version : «1_29072022-2359 (01/03/2026-01:46:57)»*/
 /*-----------------------------------------------------------------------------*/
 
 
@@ -13792,6 +13685,30 @@ Math.rotateAround=function(angleRadians, xParam=0, yParam=0, xCenterParam=0, yCe
 	return point;
 };
 
+Math.rotatePointAround3D=function(angleRadiansOnY, angleRadiansOnZ, pointToRotate, rotationCenterPoint={x:0,y:0,z:0}){
+	const xy=Math.rotateAround(angleRadiansOnY, pointToRotate.x, pointToRotate.y, rotationCenterPoint.x, rotationCenterPoint.y);
+	const xz=Math.rotateAround(angleRadiansOnZ, pointToRotate.x, pointToRotate.z, rotationCenterPoint.x, rotationCenterPoint.z);
+	return {x: xy.x, y:xy.y, z:xz.y};
+}
+
+Math.addCoordinates=function(points, functionToApplyAtEachSum=null){
+	if(!points || empty(points))	return null;
+	const resultPoint={};
+	foreach(points, (point)=>{
+		foreach(point, (coordinateComponent,coordinateComponentName)=>{
+			const resultPointCoordinateComponent=resultPoint[coordinateComponentName];
+			if(typeof(resultPointCoordinateComponent)=="undefined" || resultPointCoordinateComponent==null)
+				resultPoint[coordinateComponentName]=0;
+			if(functionToApplyAtEachSum)
+				resultPoint[coordinateComponentName]=functionToApplyAtEachSum(resultPoint[coordinateComponentName]+coordinateComponent);
+			else
+				resultPoint[coordinateComponentName]+=coordinateComponent;
+		});
+	});
+	return resultPoint;
+}
+
+
 // UNUSED (AND UNUSEFUL) :
 //Math.getGluedPosition=function(referencePosition, relativePosition){
 //	const referenceAngleRadians=referencePosition.getAngle2D();
@@ -14026,7 +13943,7 @@ window.calculateLinearlyMovedPoint3DPolar=function(currentPoint, anglesRadians,
 //test();
 
 
-Math.coerceAngle=function(angle,isRadians=false,isOnlyPositive=false){
+Math.coerceAngle=function(angle, isRadians=false, isOnlyPositive=false){
 	const WHOLE_ARC=(isRadians?Math.TAU:360);
 	let result=0;
 	if(angle <= 0)	result=(WHOLE_ARC - Math.abs(angle % WHOLE_ARC)) % WHOLE_ARC;
@@ -14119,73 +14036,8 @@ function verticesToLinePoints(polygon, isLineKeptFunction=null){
     }
     return lines;
 }
-// helper: test line intersections
-// point object: {x:, y:}
-// p0 & p1 form one segment, p2 & p3 form the second segment
-// Get interseting point of 2 line segments (if any)
-// Attribution: http://paulbourke.net/geometry/pointlineplane/
-function lineSegmentsCollide(segment1Point1,segment1Point2,segment2Point1,segment2Point2) {
-
-	// ORIGINAL :
-	// var unknownA = (p3.x-p2.x) * (p0.y-p2.y) - (p3.y-p2.y) * (p0.x-p2.x);
-    // var unknownB = (p1.x-p0.x) * (p0.y-p2.y) - (p1.y-p0.y) * (p0.x-p2.x);
-    // var denominator  = (p3.y-p2.y) * (p1.x-p0.x) - (p3.x-p2.x) * (p1.y-p0.y);        
-	
-
-	let deltaXPoint1=segment1Point1.x-segment2Point1.x;
-	let deltaYPoint1=segment1Point1.y-segment2Point1.y;
-	let deltaYPoint2=segment2Point2.y-segment2Point1.y;
-
-	let deltaXSegment1Point2_1=segment1Point2.x-segment1Point1.x;
-	let deltaYSegment1Point2_1=segment1Point2.y-segment1Point1.y;
-	let deltaXSegment2Point2_1=segment2Point2.x-segment2Point1.x;
-
-    let numerator1 = (deltaXSegment2Point2_1 * deltaYPoint1) - (deltaYPoint2 * deltaXPoint1);
-    let numerator2 = (deltaXSegment1Point2_1 * deltaYPoint1) - (deltaYSegment1Point2_1 * deltaXPoint1);
-    let denominator = (deltaYPoint2 * deltaXSegment1Point2_1) - (deltaXSegment2Point2_1 * deltaYSegment1Point2_1);        
-
-    // Test if Coincident
-    // If the denominator and numerator for the ua and ub are 0
-    //    then the two lines are coincident.    
-    if(numerator1==0 && numerator2==0 && denominator==0)	return false;
-
-    // Test if Parallel 
-    // If the denominator for the equations for ua and ub is 0
-    //     then the two lines are parallel. 
-    if(denominator == 0) return false;
-
-    // test if line segments are colliding
-    numerator1 = numerator1/denominator;
-    numerator2 = numerator2/denominator;
-    return (numerator1>=0 && numerator1<=1 && numerator2>=0 && numerator2<=1);
-}
-
-
 
-// http://alienryderflex.com/polygon/
-// 1) We draw a line parallel to the X axis, at the Y coordinate of the tested point,
-// 2) And we collect all the intersection points (or nodes) with the polygon's sides.
-// (We exclude nodes that have the same coordinates as polygon vertices !)
-// 3) If there is an odd number (or 1) of nodes on each side (on the X axis) of the point, then the point is inside the polygon  
-
-function getSegmentEquationParameters(p1,p2){
-	const deltaX=p2.x-p1.x;
-	const deltaY=p2.y-p1.y;
-	if(deltaX==0)	return null;
-	if(deltaY==0)	return {slope:0, yOffset:p2.y};
-	const slope=(deltaX/deltaY);
-	const yOffset=-(slope*p1.x-p1.y);
-	return {slope:slope, yOffset:yOffset};
-}
 
-function getIntersectionPointOnSegmentAtY(p1,p2,yTarget){
-	if((yTarget<p1.y && yTarget<p2.y) || (p1.y<yTarget && p2.y<yTarget))	return null;
-	const equationParameters=getSegmentEquationParameters(p1,p2);
-	if(!equationParameters)	return null;
-	if(equationParameters.slope==0)	return null;
-	const xCollision=(yTarget-equationParameters.yOffset)/equationParameters.slope;
-	return {x:xCollision, y:yTarget};
-}
 
 Math.isPointInPolygon=function(point,polygon){
 
@@ -14271,6 +14123,137 @@ window.isOriented=function(orientation, width, height){
 
 
 
+// Lines
+
+// helper: test line intersections
+// point object: {x:, y:}
+// p0 & p1 form one segment, p2 & p3 form the second segment
+// Get interseting point of 2 line segments (if any)
+// Attribution: http://paulbourke.net/geometry/pointlineplane/
+function lineSegmentsCollide(segment1Point1,segment1Point2,segment2Point1,segment2Point2) {
+
+	// ORIGINAL :
+	// var unknownA = (p3.x-p2.x) * (p0.y-p2.y) - (p3.y-p2.y) * (p0.x-p2.x);
+    // var unknownB = (p1.x-p0.x) * (p0.y-p2.y) - (p1.y-p0.y) * (p0.x-p2.x);
+    // var denominator  = (p3.y-p2.y) * (p1.x-p0.x) - (p3.x-p2.x) * (p1.y-p0.y);        
+	
+
+	let deltaXPoint1=segment1Point1.x-segment2Point1.x;
+	let deltaYPoint1=segment1Point1.y-segment2Point1.y;
+	let deltaYPoint2=segment2Point2.y-segment2Point1.y;
+
+	let deltaXSegment1Point2_1=segment1Point2.x-segment1Point1.x;
+	let deltaYSegment1Point2_1=segment1Point2.y-segment1Point1.y;
+	let deltaXSegment2Point2_1=segment2Point2.x-segment2Point1.x;
+
+    let numerator1 = (deltaXSegment2Point2_1 * deltaYPoint1) - (deltaYPoint2 * deltaXPoint1);
+    let numerator2 = (deltaXSegment1Point2_1 * deltaYPoint1) - (deltaYSegment1Point2_1 * deltaXPoint1);
+    let denominator = (deltaYPoint2 * deltaXSegment1Point2_1) - (deltaXSegment2Point2_1 * deltaYSegment1Point2_1);        
+
+    // Test if Coincident
+    // If the denominator and numerator for the ua and ub are 0
+    //    then the two lines are coincident.    
+    if(numerator1==0 && numerator2==0 && denominator==0)	return false;
+
+    // Test if Parallel 
+    // If the denominator for the equations for ua and ub is 0
+    //     then the two lines are parallel. 
+    if(denominator == 0) return false;
+
+    // test if line segments are colliding
+    numerator1 = numerator1/denominator;
+    numerator2 = numerator2/denominator;
+    return (numerator1>=0 && numerator1<=1 && numerator2>=0 && numerator2<=1);
+}
+
+
+window.getIntersectionPointWithYHorizontalLineAndLineEquationParameters=function(slope,yOffset,yLineHeight){
+	if(slope==0)	return null;
+	return {x:(yLineHeight-yOffset)/slope,y:yLineHeight}; 
+}
+
+window.getIntersectionPointFrom2LinesEquationParameters=function(slope1,yOffset1,slope2,yOffset2){
+	const slopesDelta=slope1-slope2;
+	if(slopesDelta==0)	return null;
+	
+	const yOffsetsInverseDelta=yOffset2-yOffset1;
+	
+	const intersectionX=yOffsetsInverseDelta/slopesDelta;
+	const intersectionY=(slope1*yOffset2-slope2*yOffset1)/slopesDelta;
+	
+	return {x:intersectionX,y:intersectionY};
+}
+
+window.getSegmentEquationParameters=function(p1,p2){
+	const deltaX=p2.x-p1.x;
+	const deltaY=p2.y-p1.y;
+	if(deltaX==0)	return null;
+	if(deltaY==0)	return {slope:0, yOffset:p2.y};
+	const slope=(deltaX/deltaY);
+	const yOffset=-(slope*p1.x-p1.y);
+	return {slope:slope, yOffset:yOffset};
+}
+
+// http://alienryderflex.com/polygon/
+// 1) We draw a line parallel to the X axis, at the Y coordinate of the tested point,
+// 2) And we collect all the intersection points (or nodes) with the polygon's sides.
+// (We exclude nodes that have the same coordinates as polygon vertices !)
+// 3) If there is an odd number (or 1) of nodes on each side (on the X axis) of the point, then the point is inside the polygon  
+
+window.getIntersectionPointOnSegmentAtY=function(p1,p2,yTarget){
+	if((yTarget<p1.y && yTarget<p2.y) || (p1.y<yTarget && p2.y<yTarget))	return null;
+	const equationParameters=getSegmentEquationParameters(p1,p2);
+	if(!equationParameters)	return null;
+	if(equationParameters.slope==0)	return null;
+	const xCollision=(yTarget-equationParameters.yOffset)/equationParameters.slope;
+	return {x:xCollision, y:yTarget};
+}
+
+
+
+// Perspective
+
+
+// apparentCorner1----apparentCorner2
+//       |									|
+//       |									|
+//       |									|
+//       |									|
+// apparentCorner4----apparentCorner3
+window.getUntransformed2DCoordinatesInsidePerspectivedRectangle=function(apparentPoint,apparentCorner1,apparentCorner2,apparentCorner3,apparentCorner4){
+	
+	const minX=Math.minInArray([apparentCorner1.x,apparentCorner2.x,apparentCorner3.x,apparentCorner4.x]);
+	const minY=Math.minInArray([apparentCorner1.y,apparentCorner2.y,apparentCorner3.y,apparentCorner4.y]);
+	const maxX=Math.maxInArray([apparentCorner1.x,apparentCorner2.x,apparentCorner3.x,apparentCorner4.x]);
+	const maxY=Math.maxInArray([apparentCorner1.y,apparentCorner2.y,apparentCorner3.y,apparentCorner4.y]);
+	
+	const apparentSize={w:(maxX-minX),h:(maxY-minY)};
+	if(apparentSize.w==0)	return null;
+
+	const heightRatio=(apparentSize.w<apparentSize.h ? 1 : (apparentSize.h/apparentSize.w));
+	
+	const leftSideLineEquationParameters=getSegmentEquationParameters(apparentCorner1,apparentCorner4);
+	if(!leftSideLineEquationParameters)	return null;
+	const rightSideLineEquationParameters=getSegmentEquationParameters(apparentCorner2,apparentCorner3);
+	if(!rightSideLineEquationParameters)	return null;
+		
+	const perspectivePoint=getIntersectionPointFrom2LinesEquationParameters(
+														leftSideLineEquationParameters.slope,leftSideLineEquationParameters.yOffset,
+														rightSideLineEquationParameters.slope,rightSideLineEquationParameters.yOffset);
+	if(!perspectivePoint)	return null;
+
+	const perspetiveLine=getSegmentEquationParameters(apparentPoint,perspectivePoint);
+	if(!perspetiveLine)	return null;
+	
+	// (for the X coordinate only)
+	const untransformedPoint=getIntersectionPointWithYHorizontalLineAndLineEquationParameters(perspetiveLine.slope, perspetiveLine.yOffset, minY);
+	const x=untransformedPoint.x;
+	// (for the Y coordinate only)
+	const y=(apparentPoint.y*heightRatio);
+	
+	const result={x:x-minX, y:y-minY};
+	return result;
+}
 
 
 
@@ -14886,10 +14869,10 @@ function rayVsUnitSphereClosestPoint(p, r) {
 // MUST REMAIN AT THE END OF THIS LIBRARY FILE !
 
 AOTRAUTILS_GEOMETRY_LIB_IS_LOADED=true;
-/*utils 3D library associated with aotra version : «1_29072022-2359 (11/11/2025-18:19:16)»*/
+/*utils 3D library associated with aotra version : «1_29072022-2359 (01/03/2026-01:46:57)»*/
 /*-----------------------------------------------------------------------------*/
 
-/*utils AI library associated with aotra version : «1_29072022-2359 (11/11/2025-18:19:16)»*/
+/*utils AI library associated with aotra version : «1_29072022-2359 (01/03/2026-01:46:57)»*/
 /*-----------------------------------------------------------------------------*/
 
 
@@ -15035,11 +15018,11 @@ getOpenAIAPIClient=(modelName, apiURL, agentRole, defaultPrompt)=>{
 
 
 
-/*utils CONSOLE library associated with aotra version : «1_29072022-2359 (11/11/2025-18:19:16)»*/
+/*utils CONSOLE library associated with aotra version : «1_29072022-2359 (01/03/2026-01:46:57)»*/
 /*-----------------------------------------------------------------------------*/
 
 
-/* ## Utility global methods in a javascript, console (nodejs) or vanilla javascript with no browser environment.
+/* ## Utility methods in a javascript, for AORTAC subsystem (server & client)
  *
  * This set of methods gathers utility generic-purpose methods usable in any JS project.
  * Several authors of snippets published freely on the Internet contributed to this library.
@@ -15062,78 +15045,750 @@ getOpenAIAPIClient=(modelName, apiURL, agentRole, defaultPrompt)=>{
 if(typeof(window)==="undefined")	window=global;	
 
 
+// ==================================================================================================================
 
 
-// OLD : socket.io :
-// https://stackoverflow.com/questions/31156884/how-to-use-https-on-node-js-using-express-socket-io
-// https://stackoverflow.com/questions/6599470/node-js-socket-io-with-ssl
-// https://nodejs.org/api/https.html#https_https_createserver_options_requestlistener
-// https://socket.io/docs/v4/client-socket-instance/
+// AORTAC SERVER
 
-// NEW : ws :
-// https://github.com/websockets/ws#installing
-// https://github.com/websockets/ws/blob/master/doc/ws.md#event-message
-// ON BROWSER SIDE : Native Websockets :
-// https://developer.mozilla.org/en-US/docs/Web/API/WebSocket
-// https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API/Writing_WebSocket_client_applications
 
-// We have to import both implementations, regardless of which one is chosen :
-//Socket=require("socket.io");
-//WebSocket=require("ws");
+//*********************************** AUTO-ORGANIZING REAL-TIME AORTAC CLUSTERIZATION (AORTAC) *********************************** */
 
+AORTAC_OUTCOMING_SERVERS_CONNECTION_GLOBAL_TIMEOUT=30000;
 
+// New implementation :
+AORTAC_SERVER_CELL_PERIODICAL_CONNECTIVITY_CHECK_MILLIS=2000;
+class AORTACServerCell{
+	
+	constructor(quorumNumber=1, selfOrigin, outcomingCellsOrigins, model, controller, sslConfig={/*OPTIONAL*/certPath:null,/*OPTIONAL*/keyPath:null}){
 
+		this.model=model;
+		this.controller=controller;
+		
+		this.quorumNumber=quorumNumber;
+		this.selfOrigin=selfOrigin;
+		const splits=splitURL(this.selfOrigin);
+		this.protocol=nonull(splits.protocol,"ws");
+		this.host=nonull(splits.host,"localhost");
+		this.port=nonull(splits.port,"30000");
+		this.sslConfig=sslConfig;
 
-// =================================================================================
-// NODEJS UTILS
+		this.server=null;
+		this.incomingCells={};
+		
+		this.outcomingCellsOrigins=outcomingCellsOrigins;
+		this.outcomingCells={};
+		const self=this;
+		foreach(this.outcomingCellsOrigins,outcomingCellOrigin=>{
+			self.outcomingCells[outcomingCellOrigin]={connected:false,client:null};
+		});
+		this.outcomingNetworkProber=null;
+		
+		this.onReceiveMessageListeners={
+			"incoming":{"protocol":{}},
+			"outcoming":{"protocol":{}},
+			"both":{"protocol":{}},
+		};
 
-const FILE_ENCODING="utf8";
+		this.cellsOverview={};
+		
+		this.startTime=null;
+		
+		this.quorumIsReachedSequenceIsInitiated=false;
+//	this.quorumCells=null; // (CAUTION : only the latest ready cell when quorum is reached has this attribute populated)
 
-const ADD_CORS_HEADER=true;
+		this.liveModelObjects={};
 
+	}
 
+	start(){
 
+		this.startTime=getNow();
+		this.server=this.launchServerForIncomingConnections();
 
+		if(empty(this.outcomingCellsOrigins) || (getArraySize(this.outcomingCellsOrigins)==1 && contains(this.outcomingCellsOrigins, this.selfOrigin))){
+			// TRACE
+			lognow("ERROR : Server cell must have an outcoming link to at least one other server cell of the blob. Aborting outcoming network probing.");
+		}else{
+			this.outcomingNetworkProber=new PeriodicalExecuter(this.probeOutcomingNetwork, AORTAC_SERVER_CELL_PERIODICAL_CONNECTIVITY_CHECK_MILLIS, this);
+		}
 
-// Nodejs filesystem utils :
-if(typeof(fs)==="undefined"){
-	// TRACE
-	console.log("WARN : Could not find the nodejs dependency «fs», aborting persister setup.");
-	getPersister=()=>{	return null;	};
-	
-}else{
+		this.handleCommonListeners();
+		
+		return this;
+	}
 	
+	/*private*/launchServerForIncomingConnections(){
+		const self=this;
+		
+		const server=initNodeServerInfrastructureWrapper(
+			// On each client connection :
+			null,
+			// On client finalization :
+			function(server){
+				
+				// On-receive message listeners handling ;
+				foreach(Object.keys(self.onReceiveMessageListeners["incoming"]), channelName=>{
+					server.receive(channelName, (message, clientSocket)=>{
+						self.executeListeners("incoming",channelName, message, clientSocket);
+					});
+				});
+				foreach(Object.keys(self.onReceiveMessageListeners["both"]), channelName=>{
+					server.receive(channelName, (message, clientSocket)=>{
+						self.executeListeners("both",channelName, message, clientSocket);
+					});
+				});
+				
+				
+				// HANDLE HELLO SEQUENCE
+				self.handleHelloSequence();
+				
+		}, this.port, this.sslConfig.certPath, this.sslConfig.keyPath);
+		server.serverManager.start();
+		return server;
+	}
 	
-	getPersister=function(dataDirPath,prefix=""){
+	/*private*/probeOutcomingNetwork(){
+		const numberOfTotalServers=getArraySize(this.outcomingCells);
+		let numberOfConnectedOutcomingServers=0;
+		foreach(this.outcomingCells, outcomingCell=>{
+			numberOfConnectedOutcomingServers++
+		},outcomingCell=>outcomingCell.connected);
 		
-		let self={
+		// TRACE
+		lognow(`INFO : Number of connected outcoming servers : ${numberOfConnectedOutcomingServers}/${numberOfTotalServers}`);
 		
-			dataDirPath:dataDirPath,
-			prefix:prefix,
+		if(numberOfTotalServers<=numberOfConnectedOutcomingServers){
+			this.outcomingNetworkProber.stop();
 			
-			//FILE_NAME_PATTERN:"data.clientId.repositoryName.json",
-			/*private*/getPath:function(clientId="noclient", repositoryName="norepository"){
-		//	let path=self.FILE_NAME_PATTERN.replace(new RegExp("@clientId@","g"),clientId);
-				let path=`${self.dataDirPath}`
-								+ (blank(self.prefix)?"":(self.prefix+"."))
-								+`${clientId}.${repositoryName}.json`;
-				return path;
-			},
+			// TRACE
+			lognow(`INFO : All outcoming cells connected. Stopping outcoming network probing.`);
+
+			// INITIATE CELL IS READY SEQUENCE
+			this.initiateCellIsReadySequence();
+
+			return;
+		}
+
+		const self=this;
+		
+		// We try to connect to all outcoming cells : 
+		foreach(this.outcomingCells, (outcomingCell, outcomingCellOrigin)=>{
 			
-			readTreeObjectFromFile:function(clientId="noclient", repositoryName="norepository", keepClassName=false){
+			const splits=splitURL(outcomingCellOrigin);
+			const outcomingCellProtocol=nonull(splits.protocol,"ws");
+			const outcomingCellHost=nonull(splits.host,"localhost");
+			const outcomingCellPort=nonull(splits.port,"40000");
+			
+			const clientInstance=initClient(true, false, (socketToServerClientInstance)=>{
 				
-				let path=self.getPath(clientId,repositoryName);
-				let resultFlat=null;
-		
-				try{
-					resultFlat=fs.readFileSync(path, FILE_ENCODING);
-					
-				}catch(error){
-					// TRACE
-					console.log("ERROR : Could not read file «"+path+"».");
-		
-					return null;
-				}
+				// On-receive message listeners handling ;
+				foreach(Object.keys(self.onReceiveMessageListeners["outcoming"]), channelName=>{
+					socketToServerClientInstance.receive(channelName, (message, clientSocket)=>{
+						self.executeListeners("outcoming",channelName, message, clientSocket);
+					});
+				});
+				foreach(Object.keys(self.onReceiveMessageListeners["both"]), channelName=>{
+					socketToServerClientInstance.receive(channelName, (message, clientSocket)=>{
+						self.executeListeners("both",channelName, message, clientSocket);
+					});
+				});
+
+				
+				// INITIATE HELLO SEQUENCE
+				self.initiateHelloSequence(socketToServerClientInstance);
+
+				// We are connected: 				
+				outcomingCell.connected=true;
+				// Only used to identify the outcoming node, DO NOT USE TO SEND/RECEIVE ANYTHINIG !
+				outcomingCell.clientSocket=clientInstance.client.clientSocket;
+				// For this, use the socketToServerClientInstance attribute instead :
+				outcomingCell.socketToServerClientInstance=socketToServerClientInstance;
+				
+			}, outcomingCellProtocol+"://"+outcomingCellHost, outcomingCellPort, false);
+
+			clientInstance.client.start();
+
+			clientInstance.client.socketToServerClientInstance.onServerLostListeners.push({execute:(clientSocket)=>{
+				const foundOutcomingNode=findInArray(self.outcomingCells,outcomingCell=>outcomingCell.clientSocket==clientSocket);
+				if(foundOutcomingNode)	foundOutcomingNode.connected=false;
+			}});
+			
+						
+		},outcomingCell=>!outcomingCell.connected);
+		
+	}
+	
+	
+	/*private*/handleCommonListeners(){
+		
+		// HANDLE CELL IS READY SEQUENCE
+		this.handleCellIsReadySequence();
+		
+		// HANDLE PARTITION SEQUENCE
+		this.handlePartitionSequence();
+		
+	}
+
+	
+	/*private*/executeListeners(outletName, channelName, message, clientSocket){
+		const onReceiveMessageListeners=this.onReceiveMessageListeners[outletName][channelName];
+		if(!onReceiveMessageListeners)	return;
+
+		// OUTCOMING NODES LISTENERS HOOK :
+//	// TRACE
+//	lognow("INFO : SERVER : Received a "+channelName+" message: ", message);
+
+		foreach(onReceiveMessageListeners, (listeners,listenerMessageType)=>{
+			foreach(listeners, (listener)=>{
+//			// TRACE
+//			lognow(`INFO : SERVER : Executing a onReceiveMessageListeners for messageType ${listenerMessageType}.`);
+	
+				listener.execute(this, message, this.server, clientSocket);
+	
+			},(listener)=>(message.type===listener.listenerMessageType));
+		});
+		
+	}
+	
+	
+	/*private*/sendMessageToBlob(channelName, message, 
+				broadcastConfig={isOriginatingCell:false, destinationCellsOrigins:null, includeIncomingConnectionInTransmission:false, isRequest:false}){
+	
+		const self=this;
+			
+		if(broadcastConfig){
+			if(broadcastConfig.isOriginatingCell){
+				message.originatingCellOrigin=this.selfOrigin;
+			}
+			if(broadcastConfig.isRequest){
+				message.isRequest=true;
+			}
+			if(broadcastConfig.destinationCellsOrigins && !empty(broadcastConfig.destinationCellsOrigins)){
+				message.destinationCellsOrigins=broadcastConfig.destinationCellsOrigins;
+			}
+		}
+		
+		if(!message.visitedCells)
+			message.visitedCells=[];
+		else if(contains(message.visitedCells,this.selfOrigin))
+			return;
+		message.visitedCells.push(this.selfOrigin);
+		
+		if(broadcastConfig && broadcastConfig.includeIncomingConnectionInTransmission){
+			foreach(this.incomingCells,(incomingCell)=>{
+				// As a server, we send (forward) the message to the currently iterated upon client that is connected to us :
+				incomingCell.server.send(channelName, message, null, incomingCell.clientSocket);
+			},(incomingCell, incomingCellOrigin)=>
+						(incomingCell.connected && !contains(message.visitedCells, incomingCellOrigin))
+			);
+		}
+		
+		foreach(this.outcomingCells,(outcomingCell)=>{
+			// As a client, we send (forward) the message to the currently iterated upon server we are connected to :
+			outcomingCell.socketToServerClientInstance.send(channelName, message);
+		},(outcomingCell, outcomingCellOrigin)=>
+					(outcomingCell.connected && !contains(message.visitedCells, outcomingCellOrigin))
+		);
+		
+		
+		// We only add a result listener for the cell which sent the request message : 
+		if(message.isRequest && message.originatingCellOrigin==this.selfOrigin 
+			//&& (typeof(message.result)=="undefined" || message.result==null)
+		){
+
+			const outletName="both";
+			
+			// To emulate a promise-like behavior :
+			let blobResponseListeners=this.onReceiveMessageListeners[outletName][channelName][message.type];
+			if(blobResponseListeners && blobResponseListeners["forRequestsIssuedBySelf"]){
+				// TRACE
+				lognow(`INFO : Blob response «forRequestsIssuedBySelf» listener for cell ${this.selfOrigin} on channel ${channelName} for «${message.type}» already exists.`);
+				return blobResponseListeners["forRequestsIssuedBySelf"];
+			}else{
+				blobResponseListeners=getOrCreateEmptyAttribute(this.onReceiveMessageListeners[outletName][channelName],message.type);
+			}
+			
+			const blobResponseListener={
+				thenCallback:null,
+				execute:(self, message, server, clientSocket)=>{
+					// When we have received the message  :
+					this.thenCallback(message);
+					
+					// We need to remove the result listener once it is completed though. 
+					delete blobResponseListeners["forRequestsIssuedBySelf"];
+				},
+				then:(thenCallback)=>{
+					this.thenCallback=thenCallback;
+				}
+			};
+			blobResponseListeners["forRequestsIssuedBySelf"]=blobResponseListener;
+			
+			return blobResponseListener;
+		}else{
+			return null;
+		}
+		
+	}
+	
+	
+	// ==========================================================
+	// HELLO SEQUENCE
+	
+	/*private*/initiateHelloSequence(socketToServerClientInstance){
+
+		// 1- We want to present ourselves to other outcoming cells :
+		const helloRequest={
+			originatingCellOrigin:this.selfOrigin,
+			type:"helloRequest",
+		};
+		socketToServerClientInstance.send("protocol", helloRequest);
+	}
+
+
+	/*private*/handleHelloSequence(){
+		
+		// 2- We wait to receive the hello request of the incoming cell connection :
+		getOrCreateEmptyAttribute( 
+		this.onReceiveMessageListeners["both"]["protocol"],"helloRequest")["forRequestsIssuedByOthers"]={
+			execute:(selfParam, message, server, clientSocket)=>{
+	
+				const cellOriginToCheck=message.originatingCellOrigin;
+					
+				// TRACE
+				lognow(`INFO : Incoming node ${cellOriginToCheck} has said hello. Updating its local information...`);
+		
+					
+				selfParam.incomingCells[cellOriginToCheck]={
+					connected:true,
+					server:server,
+					// DO NOT USE TO SEND/RECEIVE ANYTHINIG !
+					// For this, use the server attribute (+ the clientSocket as argument) instead.
+					clientSocket:clientSocket,
+				};
+
+						},
+			listenerMessageType:"helloRequest"
+		};
+		
+	}
+	
+
+	// ==========================================================
+	// CELL IS READY SEQUENCE
+	
+	/*private*/initiateCellIsReadySequence(){
+		
+		// We update ourselve's status :
+		this.cellsOverview[this.selfOrigin]={ready:true,startTime:this.startTime};
+
+		// INITIATE QUORUM IS REACHED SEQUENCE
+		this.initiateQuorumIsReachedSequenceIfNecessary();
+
+		// We ask the others to update their status too :
+		this.sendMessageToBlob("protocol",
+			{type:"cellIsReady",startTime:this.startTime},
+			{isOriginatingCell:true});
+	}
+
+	/*private*/handleCellIsReadySequence(){
+		getOrCreateEmptyAttribute(
+		this.onReceiveMessageListeners["both"]["protocol"],"cellIsReady")["forRequestsIssuedByOthers"]={
+			execute:(selfParam, message, server, clientSocket)=>{
+
+				selfParam.cellsOverview[message.originatingCellOrigin]={ready:true,startTime:message.startTime};
+				
+				selfParam.sendMessageToBlob("protocol",message);
+				
+//			// TRACE
+//			lognow("INFO : Updated cells overview for this cell ("+selfParam.selfOrigin+") :",selfParam.cellsOverview);
+//			lognow("DEBUG : 	selfParam.outcomingCells :",Object.keys(selfParam.outcomingCells));
+//			lognow("DEBUG : 	selfParam.incomingCells :",Object.keys(selfParam.incomingCells));
+				
+				// INITIATE QUORUM IS REACHED SEQUENCE
+				selfParam.initiateQuorumIsReachedSequenceIfNecessary();
+				
+			},
+			listenerMessageType:"cellIsReady"	
+		};
+	}
+
+
+
+	// ==========================================================
+	// QUORUM IS REACHED SEQUENCE
+	
+	/*private*/initiateQuorumIsReachedSequenceIfNecessary(){
+		
+		if(getArraySize(this.cellsOverview) < this.quorumNumber)	return;
+		const lastStartedReadyCellOrigin=this.getLastStartedReadyCell();
+		if(this.selfOrigin!=lastStartedReadyCellOrigin)		return;
+		if(this.quorumIsReachedSequenceIsInitiated)	return;
+		this.quorumIsReachedSequenceIsInitiated=true;
+		
+		const quorumCells=copy(this.cellsOverview);
+		
+		// TRACE
+		lognow("INFO : Quorum is reached and this is the latest started cell. quorumCells :",quorumCells);
+		
+		this.initializeModel(quorumCells);
+		
+		
+
+	}
+	
+	/*private*/getLastStartedReadyCell(){
+		return foreach(this.cellsOverview,(cell,cellOrigin)=>cellOrigin,null,(c1,c2)=>(c1.startTime==c2.startTime?0:(c1.startTime<c2.startTime?1:-1)));
+	}
+	
+	// ==========================================================
+	// MODEL MANAGEMENT
+
+	/*private*/initializeModel(quorumCells){
+		
+		const self=this;
+		
+		const numberOfPartitions=getArraySize(quorumCells);
+
+		const controller=this.controller;
+		const model=this.model;
+		
+		
+		// We initialize the whole model :
+		// (controller will handle if a persisted model exists)
+		controller.initializeModelForAORTACNode(model);
+		
+		// This must return the asked number of partitions, indexed by partition id :
+		// CAUTION : The partition function MUST return ALL the objects in a partition, WHATEVER THEIR NESTING LEVEL !!!
+		const modelPartitions=model.getPartitions(numberOfPartitions);
+
+		// We exclude this cell from the partition sending, because we already have the model partition at hand.
+		this.removeLinks(modelPartitions[0].objects);
+		this.doOnModelPartitionReception(modelPartitions[0]);
+		
+		// We send the models objects to the required cells :
+		let i=1;
+		foreach(quorumCells, (quorumCell,quorumCellOrigin)=>{
+
+			const modelPartition=modelPartitions[i];
+			self.removeLinks(modelPartition.objects);
+			
+			const message=JSON.decycle({type:"modelPartition",partition:modelPartition});
+			
+			// TRACE
+			lognow(`INFO : Cell ${self.selfOrigin} is sending a partition to cell ${quorumCellOrigin}...`,message);
+			
+			self.sendMessageToBlob("protocol", message, 
+							{isOriginatingCell:true, destinationCellsOrigins:[quorumCellOrigin], includeIncomingConnectionInTransmission:false, isRequest:false});
+			
+			i++;
+		},(quorumCell,quorumCellOrigin)=>quorumCellOrigin!=self.selfOrigin);
+		
+		
+		// Each quorum member cell is responsible for a model partition
+		// Then the sattelite cells will be handling the duplication
+		
+	}
+
+	
+	// HANDLE PARTITION SEQUENCE
+	
+	/*private*/handlePartitionSequence(){
+		
+		// 2- We wait to receive the hello request of the incoming cell connection :
+		getOrCreateEmptyAttribute( 
+		this.onReceiveMessageListeners["both"]["protocol"],"modelPartition")["forRequestsIssuedByOthers"]={
+			execute:(selfParam, messageParam, server, clientSocket)=>{
+
+				// If this cell is in the destinations of this message, we pass it along and then we do what it says :
+				selfParam.sendMessageToBlob("protocol",messageParam);
+				
+				if(contains(messageParam.destinationCellsOrigins,selfParam.selfOrigin)){
+					
+					const message=JSON.recycle(messageParam);
+					
+					selfParam.doOnModelPartitionReception(message.partition);
+					
+				}	
+
+			},
+			listenerMessageType:"modelPartition"
+		};
+		
+	}
+	
+	
+	/*private*/doOnModelPartitionReception(partition){
+
+		// TRACE
+		lognow(`INFO : Incoming partition for cell ${this.selfOrigin}. Updating local model...`,partition);
+		lognow(`>>>>`,stringifyObject(JSON.decycle(partition.objects),1));
+		
+		
+		
+	}
+	
+
+	/*private*/removeLinks(linkedObjects, currentObject=null){
+		
+		const self=this;
+		
+		if(!currentObject){	
+			foreach(linkedObjects, obj=>{
+				self.removeLinksOnSingleObject(linkedObjects, obj);
+			});
+		}else{
+			self.removeLinksOnSingleObject(linkedObjects, currentObject);
+		}
+		
+		return linkedObjects;
+	}
+	
+	/*private*/removeLinksOnSingleObject(linkedObjects, currentObject){
+		
+		const self=this;
+		foreach(currentObject, (attr,attrNameOrIndex)=>{
+			// We only remove links to the objects not in the partition
+			if(isClassObject(attr)){
+				let aortacId=attr.aortacId;
+				if(!aortacId){
+					aortacId=getUUID();
+					attr.aortacId=aortacId;
+				}
+				if(!contains(linkedObjects,attr)){
+					currentObject[attrNameOrIndex]=aortacId+"@aortacId";
+					// CAUTION : No need for recursive call here, because the partition function returns ALL the objects in a partition,
+					// WHATEVER THEIR NESTING LEVEL !!!
+				}
+			}else{
+				// However, we need a recursive call for any simple object or array that may reference a class object in another partition :
+				self.removeLinksOnSingleObject(linkedObjects, attr);
+			}
+		},obj=>(isObject(obj) || isArray(obj)));
+	
+	}
+	
+	
+	// ******************************************************************
+
+	/*private*/collectDependencies(inputObjects){
+		
+		////
+		lognow("DEBUG : collectDependencies()...",inputObjects);
+		
+		
+	}
+	
+	/*private*/repercutChangesIfNeeded(inputObjects){
+
+		
+		////
+		lognow("DEBUG : repercutChangesIfNeeded()...",inputObjects);
+
+		
+	}
+	
+	
+}
+
+
+
+// ******************************************************************
+
+// Public static hydration method :
+window.ao=(incompleteModelObjectToDecorate)=>{
+	
+	const localServerCell=window.aortacCServerNodeInstance;
+	if(!localServerCell){
+		// TRACE
+		lognow("ERROR : No AORTACCServerNode singleton instance. Doing nothing on the model object.");
+		return incompleteModelObjectToDecorate;
+	}
+	
+	const liveModelObjects=localServerCell.liveModelObjects;
+	
+	// First we clone the object, for its attriutes values information :
+	const clonedObject=clone(incompleteModelObjectToDecorate);
+	
+	// Then we replace all its methods :
+	foreach(clonedObject, (method, methodName)=>{
+		clonedObject[methodName]=new Proxy(method, 
+			{
+		    apply: function(methodToEnhance, thisArg, argumentsList) {
+
+					const inputObjects=[thisArg];
+					inputObjects.push(...argumentsList);
+					localServerCell.collectDependencies(inputObjects);
+					
+//        // --- Treatment BEFORE function execution ---
+//        console.log(`Calling function "${methodToEnhance.name}" with arguments: ${argumentsList}`);
+	
+	        // Call the original function (target) with its intended 'this' context (thisArg) 
+	        // and arguments (argumentsList) using Reflect.apply
+	        const result = Reflect.apply(methodToEnhance, thisArg, argumentsList);
+	
+//        // --- Treatment AFTER function execution ---
+//        console.log(`Function "${methodToEnhance.name}" returned: ${result}`);
+	
+					inputObjects.push(result);
+					localServerCell.repercutChangesIfNeeded(inputObjects);
+
+	        return result;
+		    },
+			}
+		);
+	},attribute=>isFunction(attribute));
+	
+	return clonedObject;
+};
+
+
+
+window.getAORTACServerNode=function(quorumNumber=1,selfOrigin="ws://127.0.0.1:40000", outcomingCellsOrigins=[], model, controller){
+//return new AORTACServerNode("node_"+getUUID("short"), selfOrigin, outcomingCellsOrigins, model, controller);
+	if(window.aortacCServerNodeInstance){
+		// TRACE
+		throw new Error("ERROR : The AORTACCServerNode singleton instance already exists. It cannot be instantiated again in the same process. Aborting.");
+	}
+	window.aortacCServerNodeInstance=new AORTACServerCell(quorumNumber, selfOrigin, outcomingCellsOrigins, model, controller);
+	return window.aortacCServerNodeInstance; 
+}
+
+
+
+
+
+
+
+// ==================================================================================================================
+
+
+// AORTAC CLIENT
+
+
+
+//*********************************** AUTO-ORGANIZING REAL-TIME AORTAC CLUSTERIZATION (AORTAC) *********************************** */
+
+// New implementation :
+
+class AORTACClientCell{
+	
+	constructor(serverNodeOrigin, model, view, isNodeContext=false){
+		
+	}
+	
+}
+
+
+
+
+window.getAORTACClient=function(serverNodeOrigin="ws://127.0.0.1:40000", model, view, isNodeContext=false){
+//return new AORTACClient("client_"+getUUID(), serverNodeOrigin, model, view, isNodeContext);
+	return new AORTACClientCell(serverNodeOrigin, model, view, isNodeContext);
+}
+
+
+
+
+/* ## Utility global methods in a javascript, console (nodejs) or vanilla javascript with no browser environment.
+ *
+ * This set of methods gathers utility generic-purpose methods usable in any JS project.
+ * Several authors of snippets published freely on the Internet contributed to this library.
+ * Feel free to use/modify-enhance/publish them under the terms of its license.
+ * 
+ * # Library name : «aotrautils» 
+ * # Library license : HGPL(Help Burma) (see aotra README information for details : https://alqemia.com/aotra.js )
+ * # Author name : Jérémie Ratomposon (massively helped by his native country free education system)
+ * # Author email : info@alqemia.com
+ * # Organization name : Alqemia
+ * # Organization email : admin@alqemia.com
+ * # Organization website :  https://alqemia.com
+ * 
+ *  
+ */
+
+
+
+// COMPATIBILITY browser javascript / nodejs environment :
+if(typeof(window)==="undefined")	window=global;	
+
+
+
+
+// OLD : socket.io :
+// https://stackoverflow.com/questions/31156884/how-to-use-https-on-node-js-using-express-socket-io
+// https://stackoverflow.com/questions/6599470/node-js-socket-io-with-ssl
+// https://nodejs.org/api/https.html#https_https_createserver_options_requestlistener
+// https://socket.io/docs/v4/client-socket-instance/
+
+// NEW : ws :
+// https://github.com/websockets/ws#installing
+// https://github.com/websockets/ws/blob/master/doc/ws.md#event-message
+// ON BROWSER SIDE : Native Websockets :
+// https://developer.mozilla.org/en-US/docs/Web/API/WebSocket
+// https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API/Writing_WebSocket_client_applications
+
+// We have to import both implementations, regardless of which one is chosen :
+//Socket=require("socket.io");
+//WebSocket=require("ws");
+
+
+
+
+// =================================================================================
+// NODEJS UTILS
+
+const FILE_ENCODING="utf8";
+
+const ADD_CORS_HEADER=true;
+
+
+
+if(typeof(require)!="undefined" && typeof(fs)!="undefined" )
+	window.fs=require("fs");
+
+
+
+
+// Nodejs filesystem utils :
+if(typeof(fs)==="undefined"){
+	// TRACE
+	console.log("WARN : Could not find the nodejs dependency «fs», aborting persister setup.");
+	getPersister=()=>{	return null;	};
+	
+}else{
+	
+	
+	getPersister=function(dataDirPath,prefix=""){
+		
+		let self={
+		
+			dataDirPath:dataDirPath,
+			prefix:prefix,
+			
+			//FILE_NAME_PATTERN:"data.clientId.repositoryName.json",
+			/*private*/getPath:function(clientId="noclient", repositoryName="norepository"){
+		//	let path=self.FILE_NAME_PATTERN.replace(new RegExp("@clientId@","g"),clientId);
+				let path=`${self.dataDirPath}`
+								+ (blank(self.prefix)?"":(self.prefix+"."))
+								+`${clientId}.${repositoryName}.json`;
+				return path;
+			},
+			
+			readTreeObjectFromFile:function(clientId="noclient", repositoryName="norepository", keepClassName=false){
+				
+				let path=self.getPath(clientId,repositoryName);
+				let resultFlat=null;
+		
+				try{
+
+					resultFlat=fs.readFileSync(path, FILE_ENCODING);
+					
+				}catch(error){
+					// TRACE
+					console.log("ERROR : Could not read file «"+path+"».");
+		
+					return null;
+				}
 				
 				
 				let resultData={};
@@ -15153,8 +15808,6 @@ if(typeof(fs)==="undefined"){
 			
 			saveDataToFileForClient:function(clientId,repositoryName,dataFlatForClient,forceKeepUnflatten=false,doOnSuccess=null){
 				
-				
-				
 				if(!empty(dataFlatForClient) && !isFlatMap(dataFlatForClient) && !forceKeepUnflatten){
 					dataFlatForClient=getAsFlatStructure(dataFlatForClient);
 				}
@@ -15170,7 +15823,6 @@ if(typeof(fs)==="undefined"){
 				
 				
 				let path=self.getPath(clientId,repositoryName);
-				
 				fs.writeFile(path, dataFlatStr, FILE_ENCODING, (error) => {
 			    if(error){
 			    	// TRACE
@@ -15190,6 +15842,16 @@ if(typeof(fs)==="undefined"){
 }
 
 
+window.fileExists=(filePath)=>{
+	if(typeof(fs)=="undefined"){
+		// TRACE
+		lognow("ERROR : «fs» node dependency is not available ! Cannot test if file exists.");
+		return null;
+	}
+	return fs.existsSync(filePath);
+};
+
+
 
 // Nodejs server launching helper functions :
 //Networking management :
@@ -15267,6 +15929,47 @@ getConsoleParam=function(index=0, argsOffset=0){
 
 
 
+window.getConsoleCLI=(doOnCommands={"makeSandiwch":()=>{}}, promptText="Enter command> ")=>{
+
+	const readline = require("node:readline");
+
+	const cliInterface = readline.createInterface({
+	  input: process.stdin,
+	  output: process.stdout,
+	  prompt: nonoull(promptText,"Enter command> ")
+	});
+
+	cliInterface.prompt();
+
+	cliInterface.on("line", (line) => {
+	  const input = line.trim();
+	  switch (input) {
+	    case "quit":
+	      console.log("Bye!");
+	      cliInterface.close();
+	      break;
+	    case "help":
+	      console.log("Available commands: quit, help and :", Object.keys(doOnCommands));
+	      break;
+	    default:
+				if(doOnCommands)	doOnCommands[input]();
+	      break;
+	  }
+		
+		// Show the prompt again :
+	  cliInterface.prompt();
+		
+	}).on("close", () => {
+	  process.exit(0);
+	});
+	
+	return cliInterface
+};
+
+
+
+
+
 // NODE ONLY SERVER / CLIENTS : 
 WebsocketImplementation={
 
@@ -15409,9 +16112,8 @@ WebsocketImplementation={
 			
 			// Join room server part protocol :
 			nodeServerInstance.receive("protocol",(message, clientSocket)=>{
-				if(message.type!=="joinRoom" || !clientSocket)	return;
 				nodeServerInstance.addToRoom(clientSocket, message.clientRoomTag);
-			});
+			},{listenerMessageType:"joinRoom"});
 			
 			// To make the server aware of the clients connections states :
 			nodeServerInstance.serverSocket.on("close", function close() {
@@ -15465,6 +16167,12 @@ WebsocketImplementation={
 					rejectUnauthorized:false, // (THIS IS A KNOWN SECURITY BREACH)
 					secure: isSecure
 				});
+				
+				clientSocket.addEventListener("error", error=>{
+					// TRACE
+				  lognow("ERROR : (NODEJS) A WebSocket client error occurred while trying to connect to server:", error.message);
+				});
+				
 			}else{
 				// NOW : socket.io :
 				//client on server-side:
@@ -15475,6 +16183,12 @@ WebsocketImplementation={
 //				NO :	clientSocket=new Socket.Client(serverURL + ":" + port,{timeout: timeout, secure: isSecure});
 					clientSocket=io(serverURL + ":" + port,{timeout: timeout, secure: isSecure, autoConnect:true});
 					// UNUSEFUL (since we have the autoconnect:true option) : clientSocket.connect();
+					
+					clientSocket.on("connect_error", error=>{
+						// TRACE
+					  lognow("ERROR : (NODEJS) A SocketIO client error occurred while trying to connect to server:", error.message);
+					});
+
 				}
 			}
 			
@@ -15508,10 +16222,22 @@ WebsocketImplementation={
 				// - FIRST GO TO THE HTTPS:// SERVER ADDRESS WITH BROWSER
 				// - THEN ADD THE SECURITY EXCEPTION IN THE BROWSER !
 				clientSocket=new WebSocket(serverURL+":"+port,["ws","wss"]);
+				
+				clientSocket.addEventListener("error", error=>{
+					// TRACE
+				  lognow("ERROR : (BROWSER) A WebSocket client error occurred while trying to connect to server:", error.message);
+				});
+				
 			}else if(typeof(io)!=="undefined"){
-					// OLD SYNTAX :clientSocket=io.connect(serverURL + ":" + port,{timeout: timeout, secure: isSecure});
-					// ALTERNATIVE :
-					clientSocket=io(serverURL + ":" + port,{timeout: timeout, secure: isSecure});
+				// OLD SYNTAX :clientSocket=io.connect(serverURL + ":" + port,{timeout: timeout, secure: isSecure});
+				// ALTERNATIVE :
+				clientSocket=io(serverURL + ":" + port,{timeout: timeout, secure: isSecure});
+				
+				clientSocket.on("connect_error", error=>{
+					// TRACE
+				  lognow("ERROR : (BROWSER) A SocketIO client error occurred while trying to connect to server:", error.message);
+				});
+					
 			}
 			
 			// BROWSER CLIENT INSTANCE :
@@ -15817,7 +16543,7 @@ initNodeServerInfrastructureWrapper=function(doOnClientConnection=null, doOnFina
 // DOES NOT WORK : USE Java FusrodaServer instead :
 //
 ///*FUSRODA server stands from FSRD SERVER, for Fucking Simple Remote Desktop SERVER*/
-//createFusrodaServer=function(certPathParam=null,keyPathParam=null,portParam=6080){
+//createFusrodaServer=function(certPathParam=null,keyPathParam=null,portParam=4000){
 //	
 //	// https://www.npmjs.com/package/screenshot-desktop
 //	// https://github.com/octalmage/robotjs
@@ -15854,7 +16580,7 @@ initNodeServerInfrastructureWrapper=function(doOnClientConnection=null, doOnFina
 //			
 //				screenshot().then((img) => {
 //	
-//					const data={image:img,messageType:"imageData"};
+//					const data={image:img,listenerMessageType:"imageData"};
 //					serverParam.send("message", data, "clients");
 //					
 //					serverParam.isScreenshotStarted=false;		
@@ -15876,7 +16602,7 @@ initNodeServerInfrastructureWrapper=function(doOnClientConnection=null, doOnFina
 // //		/*DO NOTHING*/
 // //	};
 // //	const server={};
-// //	server.start=(port=6080)=>{
+// //	server.start=(port=4000)=>{
 // //		server.httpServer=launchNodeHTTPServer(port, doOnConnect, doOnFinalizeServer, sslOptions);
 // //	};
 //
@@ -16278,871 +17004,287 @@ appendGetParameters=function(apiURL, namedArgsParam){
 
 
 
-//*********************************** AUTO-ORGANIZING REAL-TIME AORTAC CLUSTERIZATION (AORTAC) *********************************** */
 
-AORTAC_OUTCOMING_SERVERS_CONNECTION_GLOBAL_TIMEOUT=30000;
-REQUESTS_IDS_HISTORY_SIZE=10;
 
-class AORTACNode{
-	
-	constructor(nodeId, selfOrigin="127.0.0.1:40000",outcomingNodesOrigins=[], model, controller, allowAnonymousNodes=true, sslConfig={/*OPTIONAL*/certPath:null,/*OPTIONAL*/keyPath:null}){
-		
-		this.nodeId=nodeId;
-		this.selfOrigin=selfOrigin;
-		this.sslConfig=sslConfig;
-		this.outcomingNodesOrigins=outcomingNodesOrigins;
-		this.allowAnonymousNodes=allowAnonymousNodes;
-		
-		this.model=model;						// must implement functions
-		this.controller=controller; // Must implement functions
-		
-		this.server=null;
-		this.clients={};
-		this.incomingServers={};
-		this.outcomingServers={};
-		this.authorizedNodesIds=[this.nodeId];
-		
-		this.listeners={"protocol":[],"cluster":[],"neighbors":[],"inputs":[]};
-	
-		this.executedRequestIdsHistory=[];
-		
-		this.isConnectedToCluster=false;
-		
-		this.modelObjectsDirectory={};
-		this.objectsIndexesForClients={};
 
-		this.addProtocolListeners();
 
-		// TRACE
-		lognow(`AORTAC node created with id ${this.nodeId}.`);
-	}
-	
-	start(){
 
-		const splits=splitURL(this.selfOrigin);
-		let port=nonull(splits.port,"40000");
-		
-		const self=this;
-		this.server = initNodeServerInfrastructureWrapper(
-			// On each client connection :
-			null,
-			// On client finalization :
-			function(server){
-				self.server=server;
-				
-				// Listeners handling ;
-				foreach(Object.keys(self.listeners), channelName=>{
-					self.server.receive(channelName, (message, clientSocket)=>{
-						
-						// INCOMING NODES LISTENERS HOOK :
-						// TRACE
-						console.log("INFO : SERVER : Client or incoming node has sent a "+channelName+" message: ", message);
-						foreach(self.listeners[channelName], listener => {
-							listener.execute(self, message, self.server, clientSocket);
-						},(listener)=>(message.type===listener.messageType));
-						
-					});
-				});
-				
-				// OLD : self.connectToOutcomingServers(self, server).then((server)=>{	self.doOnConnectedToCluster();	});
-				
-				
-		}, port, this.sslConfig.certPath, this.sslConfig.keyPath);
-		
-		this.server.serverManager.start();
-		
-		// TRACE
-		lognow(`AORTAC node started with id ${this.nodeId}.`);
+/* ## Utility network global methods in a javascript, console (nodejs), or vanilla javascript with no browser environment.
+ *
+ * This set of methods gathers utility generic-purpose methods usable in any JS project.
+ * Several authors of snippets published freely on the Internet contributed to this library.
+ * Feel free to use/modify-enhance/publish them under the terms of its license.
+ * 
+ * # Library name : «aotrautils» 
+ * # Library license : HGPL(Help Burma) (see aotra README information for details : https://alqemia.com/aotra.js )
+ * # Author name : Jérémie Ratomposon (massively helped by his native country free education system)
+ * # Author email : info@alqemia.com
+ * # Organization name : Alqemia
+ * # Organization email : admin@alqemia.com
+ * # Organization website :  https://alqemia.com
+ * 
+ *  
+ */
 
 
-		return this;
-	}
-	
-	
-	connect(){
-		
-		const self=this;
-		self.connectToOutcomingServers(self).then((server)=>{	self.doOnConnectedToCluster();	});
 
-		return this;		
-	}
-	
-	
-	
-	
-	/*private*/addProtocolListeners(){
-		
-		const self=this;
-		// ============== OTHER SERVER / CLIENT REGISTRATION PHASE ==============
-		// - OTHER SERVER REGISTRATION PHASE :
-		this.listeners["protocol"].push({
-			messageType:"request.register.server.incoming",
-			execute:(self, message, server, clientSocket)=>{
-				const incomingServerNodeId=message.nodeId;
-				
-				// TRACE
-				lognow(`	(${self.nodeId}) Receiving registering request from node ${incomingServerNodeId}...`);
-				
-				if(!self.allowAnonymousNodes && self.isInAuthorizedNodes(incomingServerNodeId)){
-					// TRACE
-					lognow("WARN : Cannot accept incoming server with node id «"+incomingServerNodeId+"» because it's not in the authorized nodes list.");
-					return;
-				}
-				if(!contains(self.authorizedNodesIds,incomingServerNodeId))	self.authorizedNodesIds.push(incomingServerNodeId);
-				
-				// TRACE
-				lognow(`	(${self.nodeId}) Adding registering node ${incomingServerNodeId} to incoming servers...`);
-				
-				self.incomingServers[incomingServerNodeId]={clientSocket:clientSocket};
-				
-				const welcomeResponse={
-					nodeId:self.nodeId, // MUST BE SELF ! ELSE THE REGISTERING CLIENT WON'T KNOW WHICH ID IT HAS BEEN REGISTERED TO !
-					type:"response.register.server.incoming",
-					authorizedNodesIds:self.authorizedNodesIds
-				};
-				server.send("protocol", welcomeResponse, null, clientSocket);
-				
-				// TRACE
-				lognow(`	(${self.nodeId}) Sent registering response to node ${incomingServerNodeId}.`);
-			}
-		});
-		
-		// - CLIENT REGISTRATION PHASE : (for clients to the server, NOT INCOMING NODES !)
-		this.handleClients();
-		
-	}
-	
-	/*private*/handleClients(){
-		const self=this;
-		
-		// --------- PROTOCOL HANDLING ---------
-		 
-		this.listeners["protocol"].push({
-			messageType:"request.register.client",
-			execute:(self, message, server, clientSocket)=>{
-				const clientId=message.clientId;
-				
-				self.clients[clientId]={clientSocket:clientSocket};
+// COMPATIBILITY browser javascript / nodejs environment :
+if(typeof(window)==="undefined")	window=global;	
 
-				// TRACE
-				lognow(`	(${self.nodeId}) Receiving non-cluster client registration request from client ${clientId}.`);
-				
-				const welcomeClientResponse={
-					nodeId:self.nodeId, // MUST BE SELF ! ELSE THE REGISTERING CLIENT WON'T KNOW WHICH ID IT HAS BEEN REGISTERED TO !
-					type:"response.register.client",
-					// If necessary we also send them our model part :
-					partialModelString:(message.isReferenceNode?null:JSON.stringifyDecycle(self.model)),
-					isReferenceNode:(!!message.isReferenceNode),
-				};
-				server.send("protocol", welcomeClientResponse, null, clientSocket);
-			}
-		});
-		
-		this.listeners["protocol"].push({
-			messageType:"request.unregister.client",
-			execute:(self, message, server, clientSocket)=>{
-				const clientId=message.clientId;
-				
-				delete self.clients[clientId];
 
-				// TRACE
-				lognow(`	(${self.nodeId}) Receiving non-cluster client unregistration request from client ${clientId}.`);
-				
-				const unwelcomeClientResponse={
-					nodeId:self.nodeId, // MUST BE SELF ! ELSE THE REGISTERING CLIENT WON'T KNOW WHICH ID IT HAS BEEN REGISTERED TO !
-					type:"response.unregister.client",
-				};
-				server.send("protocol", unwelcomeClientResponse, null, clientSocket);
-			}
-		});
-		
-		
-		this.listeners["protocol"].push({
-			messageType:"request.interrogation.client",
-			execute:(self, message, server, clientSocket)=>{
-				const clientId=message.clientId;
-				
-				// TRACE
-				lognow(`	(${self.nodeId}) Receiving non-cluster client interrogation request from client ${clientId}.`);
-				
-				const clientBoundaries=message.boundaries;
-				
-				// We ask the whole cluster to find the requested objects :
-				const modelSeekObjectsRequest={
-					type:"request.model.seekObjects",
-					originatingClientId:clientId,
-					clientBoundaries:clientBoundaries,
-				};
-				this.propagateToCluster(modelSeekObjectsRequest);
 
-				self.objectsIndexesForClients[clientId]={};
-				
-			}
-		});
-		
-		// --------- INPUTS HANDLING --------- 
-		
-		this.listeners["inputs"].push({
-			messageType:"request.inputs.client",
-			execute:(self, message, server, clientSocket)=>{
-				const clientId=message.clientId;
-				
-				// TRACE
-				lognow(`	(${self.nodeId}) Receiving non-cluster client inputs request from client ${clientId}.`);
-				
-				const clientInputs=message.inputs;
-				const clientSubBoundaries=message.subBoundaries;
+// ==================================================================================================================
 
-				
-				// We let the controller interpret these inputs :
-				const modifiedObjects=self.controller.interpretInputs(clientInputs, clientSubBoundaries);
-				
 
-			}
-		});
-		
+class ClientReceptionEntryPoint{
+	
+	constructor(channelNameParam, entryPointId, clientsRoomsTag, listenerConfig, doOnIncomingMessage){
+		this.channelName=channelNameParam;
+		this.entryPointId=entryPointId;
+		this.clientsRoomsTag=clientsRoomsTag;
+		this.listenerConfig=listenerConfig;
+		this.doOnIncomingMessage=doOnIncomingMessage;
 	}
-
-
-	/*private*/addPropagationForClientsListeners(){
-		
-		const self=this;
+	
+	// III-
+	execute(eventOrMessage, clientSocket, clientReceptionEntryPoints){
 		
-		// ------------------------------------- CLIENTS PROTOCOL HANDLING -------------------------------------
-		// Adding propagation listener :
-		this.setPropagation("cluster","request.model.seekObjects",(self, message, server, clientSocket)=>{
-			
-			// If we receive this request from cluster, then we try to find the requested objects
-			const relayNodeid=message.nodeId;
-			const originatingClientId=message.originatingClientId;
-			const clientBoundaries=message.clientBoundaries
-			const objectsIds=self.model.getObjectsIdsWithinBoundaries(clientBoundaries);
-
-			// If server has not the seeked objects, it answers with an empty array.			
-			
-			// TRACE
-			lognow(`(${self.nodeId}) Node receiving a seek objects request from relay node ${message.nodeId}...objectsIds=`,objectsIds);
-
+		if(!eventOrMessage){
 			// TRACE
-			lognow(`(${self.nodeId}) Sending objects ids to relay node ${relayNodeid}...`);
-			
-			const modelObjectsSeekResponse={
-				type:"response.model.seekObject",
-				originatingClientId:originatingClientId,
-				clientBoundaries:clientBoundaries,
-				objectsIds:objectsIds,
-				nodeServerInfo:self.selfOrigin
-			};
-			this.propagateToCluster(modelObjectsSeekResponse, relayNodeid/*destination node*/);
+			lognow("ERROR : No message received.");
+			return;
+		}
 
-		});
-		
-		// Adding propagation listener :
-		this.setPropagation("cluster","response.model.seekObject",(self, message, server, clientSocket)=>{
-			
-			// Here the relay server gathers the information from the other nodes, and sends it back to client ; 
-			
-			const referenceNodeId=self.nodeId;
-			const originatingClientId=message.originatingClientId;
-			const originatingNodeId=message.nodeId;
-			const clientBoundaries=message.clientBoundaries;
-			const objectsIds=message.objectsIds;
-			const nodeServerInfo=message.nodeServerInfo;
-			
+		if(!clientSocket){
 			// TRACE
-			lognow(`(${self.nodeId}) Node receiving a seek objects request from relay node ${message.nodeId}...objectsIds=`,objectsIds);
-			
-			// Here the currently answering node fills its information :
-			const objectsIndexForClient=self.objectsIndexesForClients[originatingClientId];
-			objectsIndexForClient[originatingNodeId]={nodeServerInfo:nodeServerInfo, objectsIds:objectsIds};
-			
-			
-			// We check if all known nodes have answered :
-			if(getArraySize(self.authorizedNodesIds)-1/*Because we exclude the reference node*/<=getArraySize(objectsIndexForClient)){
-
-				// The reference node also answers to the request to its direct client :
-				const objectsIdsFromReferenceNode=self.model.getObjectsIdsWithinBoundaries(clientBoundaries);
-				const referenceNodeServerInfo=self.selfOrigin;
-				objectsIndexForClient[referenceNodeId]={nodeServerInfo:referenceNodeServerInfo, objectsIds:objectsIdsFromReferenceNode};
-				
-				const client=self.clients[originatingClientId];
-				const clientSocket=client.clientSocket;
-
-				// TRACE
-				lognow(`(${self.nodeId}) Sending objects ids to the client ${originatingClientId}...objectsIndexForClient=`,objectsIndexForClient);
-				
-				// We filter all the index entries with an empty objetcs ids array :
-				const objectsIndexForClientWithoutEmptyObjects={};
-				foreach(objectsIndexForClient,(nodeInfoAndObjectsIds, serverNodeId)=>{
-					objectsIndexForClientWithoutEmptyObjects[serverNodeId]=nodeInfoAndObjectsIds;
-				},(nodeInfoAndObjectsIds,serverNodeId)=>(!empty(nodeInfoAndObjectsIds.objectsIds)));
-				
-				// We send the final result information (objects ids) to client :
-				const interrogationClientResponse={
-					nodeId:self.nodeId,
-					type:"response.interrogation.client",
-					serversNodesIdsForModelObjectsForClient:objectsIndexForClientWithoutEmptyObjects
-				};
-				self.server.send("protocol", interrogationClientResponse, null, clientSocket);
-			}
-			
-		});
-		
-		
-		// ------------------------------------- CLIENTS INPUTS HANDLING -------------------------------------
-		// Adding propagation listener :
-
-		
-		
-		// DBG
-		lognow(">>>>>>>>FOR CLIENTS this.listeners",this.listeners);
-		
-	}
-
-//	/*private*/getServersNodesIdsForModelObjectsForClient(clientObjectsIds){
-//		const serversNodesIdsForModelObjectsForClient={};
-//		const self=this;
-//		// TODO : FIXME : INEFFICIENT !!!
-//		foreach(clientObjectsIds,(objectId)=>{
-//			foreach(self.modelObjectsDirectory,(objectsInNode, nodeId)=>{
-//				if(contains(objectsInNode,objectId))
-//					serversNodesIdsForModelObjectsForClient[objectId]=nodeId;
-//			});
-//		});
-//		
-//		return serversNodesIdsForModelObjectsForClient;
-//	}
+			lognow("ERROR : No clientSocket to client ! Cannot do reception treatment.");
+			return;
+		}	
 
-	/*private*/connectToOutcomingServers(self){
-		
-		const server=self.server;
-	
-		const theoreticNumberOfOutcomingServers=getArraySize(self.outcomingNodesOrigins);
-		
-		return new Promise((resolve,error)=>{
-			
-			// In case we timeout :
-			setTimeout(()=>{
-				if(self.isConnectedToCluster)	return;
-				self.isConnectedToCluster=true;
-				resolve(server);
-			},AORTAC_OUTCOMING_SERVERS_CONNECTION_GLOBAL_TIMEOUT);
-		
-			// We try to connect to all the other outcoming servers :
-			
-			// Special case : if node has no outcoming serves, (it's the seed node), then 
-			// it should be considered as connected to cluster nonetheless :
-			if(empty(self.outcomingNodesOrigins)){
-				self.finalizeClusterConnection(self.nodeId);
-				resolve(server);
-				return;
-			}
-			
-			// We try to connect to all outcoming nodes : 
-			foreach(self.outcomingNodesOrigins, outcomingNodeOrigin=>{
-				
-				// TRACE
-				lognow(`	(${self.nodeId}) Sending registering response to node ${outcomingNodeOrigin}...`);
-				
-				const splits=splitURL(outcomingNodeOrigin);
-				const outcomingNodeProtocol=nonull(splits.protocol,"ws");
-				const outcomingNodeHost=nonull(splits.host,"localhost");
-				const outcomingNodePort=nonull(splits.port,"40000");
-				//const isSecure=splits.isSecure; // UNUSED
-				
-				const clientInstance=initClient(true, false, (socketToServer)=>{
-					
-					// TODO : FIXME : IF CONNECTION TO SERVER FAILS, IT MUST BE ABLE TO TRY AGAIN LATER !
-					
-					// TRACE
-					lognow(`		(${self.nodeId}) Sending registering request to outcoming node...`);
-					
-					const helloRequest={
-						nodeId:self.nodeId,
-						type:"request.register.server.incoming"
-					};
-					socketToServer.send("protocol", helloRequest);
-					
-					
-					// We place a listener from outcoming node on this client instance to this outcoming node :
-					socketToServer.receive("protocol",(message)=>{
-						if(message.type==="response.register.server.incoming"){
-							
-							// TRACE
-							lognow(`		(${self.nodeId}) Receving registering response from requested outcoming node...`);
-							
-							const welcomeNodeId=message.nodeId;
-							const duplicatesFreeAuthorizedNodesIds=[...new Set([...self.authorizedNodesIds, ...message.authorizedNodesIds, welcomeNodeId ])];
-							self.authorizedNodesIds=duplicatesFreeAuthorizedNodesIds;
-							
-							self.outcomingServers[welcomeNodeId]={clientInstance:clientInstance};
-							
-							// Once we have registered to all the outcoming nodes :
-							const currentNumberOfOutcomingServers=getArraySize(self.outcomingServers);
-							if(!self.isConnectedToCluster && theoreticNumberOfOutcomingServers<=currentNumberOfOutcomingServers){
-								//self.finalizeClusterConnection(welcomeNodeId);
-								self.finalizeClusterConnection(self.nodeId);
-								resolve(server);
-							}
-						}
-					});
-					
-					// Listeners handling ;
-					foreach(Object.keys(self.listeners), channelName=>{
-						socketToServer.receive(channelName, (message, clientSocket)=>{
-							
-							// OUTCOMING NODES LISTENERS HOOK :
-							// TRACE
-							console.log("INFO : SERVER : Outcoming node has sent a "+channelName+" message: ", message);
-							foreach(self.listeners[channelName], listener => {
-								listener.execute(self, message, self.server, clientSocket);
-							},(listener)=>(message.type===listener.messageType));
-							
-						});
-					});
-					
-					
-				}, outcomingNodeProtocol+"://"+outcomingNodeHost, outcomingNodePort, false);
-				clientInstance.client.start();
-				
-			});
-			
-		});
-	
-	}
-	
-	/*private*/finalizeClusterConnection(welcomeNodeId){
-		// TRACE
-		lognow(`		(${this.nodeId}) Propagating this new node to the whole cluster...`);
+		const dataWrapped=WebsocketImplementation.getMessageDataBothImplementations(eventOrMessage);
 		
-		// We propagate the new node id to the whole cluster :
-		const newNodeRequest={
-			nodeId:welcomeNodeId,
-			type:"request.node.new"
-		};
-		this.propagateToCluster(newNodeRequest);
+		// We check if the message is in the right channel (channel information is stored in exchanged wrapped data) :
+		const channelName=this.channelName;
+		if(dataWrapped.channelName && dataWrapped.channelName!==this.channelName){
+			return;
+		}
 		
-		this.isConnectedToCluster=true;
+		// We check if the message is in the right room (r)oom information is stored in client socket object) :
+		if(!WebsocketImplementation.isInRoom(clientSocket, this.clientsRoomsTag))	return;
 		
-		this.addPropagationListeners();
-		this.addPropagationForClientsListeners();
-	}
-								
-	
 
-	
-	/*public*/doOnConnectedToCluster(){
-			
-		// TRACE
-		lognow(`(${this.nodeId}) Node is connected to cluster...`);
-		
-		// The node asks the cluster for its model partition :
+		// We check if the message matches the required message type :
+		if(		this.listenerConfig && this.listenerConfig.listenerMessageType && dataWrapped.type
+			 && this.listenerConfig.listenerMessageType!==dataWrapped.type){
+			return;
+		}
 		
-		// At this point, the new node does not know the state of the model in the cluster, only cluster nodes know.
+		// We check if the message matches the condition :
+		const dataLocal=dataWrapped.data;
+		if(this.listenerConfig.condition && !this.istenerConfig.condition(dataLocal, clientSocket)){
+			return;
+		}
 		
-		// TRACE
-		lognow(`(${this.nodeId}) Node is asking to its model partition...`);
+		// We check if we have the same message id:
+		const messageIdLocal=this.listenerConfig.messageId;
+		if(messageIdLocal!==dataLocal.messageId){
+			return;
+		}
+
+		// At this point, message is the right one, so it can be processed :
+		// --------------------------------
 		
-		// New node asks for its model partition :
+		// We remove one-time usage listeners :
+		// We remove BEFORE executing doOnIncomingMessage(), because in this reception entry point function we can have other listener registration UNDER THE SAME ID !
+		if(this.listenerConfig && this.listenerConfig.destroyListenerAfterReceiving)
+			remove(clientReceptionEntryPoints, this);
 		
-		// - First we need to know which server has the biggest model :
-		const modelSizeRequest={
-			type:"request.model.getSize",
-		};
-		this.propagateToCluster(modelSizeRequest);
+		if(this.doOnIncomingMessage)
+			this.doOnIncomingMessage(dataLocal, clientSocket);
 			
 	}
 	
-	
-	/*private*/addPropagationListeners(){
-		
-		// Adding propagation listener for acknowledging new node added to cluster :
-		this.setPropagation("cluster","request.node.new", (self, message, server, clientSocket)=>{
-			const newNodeId=message.nodeId;
-			// TRACE
-			lognow(`		(${self.nodeId}) Acknowledging new node ${newNodeId} added to cluster...`);
-			if(!contains(self.authorizedNodesIds,newNodeId))	self.authorizedNodesIds.push(newNodeId);
-		});
-
-		// Adding propagation listener if a node receives a model size request :
-		this.setPropagation("cluster","request.model.getSize",(self, message, server, clientSocket)=>{
-			const modelSize=self.model.getModelSize();
-			// TRACE
-			lognow(`(${self.nodeId}) Node gives its model size to node ${message.nodeId}, modelSize=${modelSize}...`);
-			return modelSize;
-		},"response.model.getSize");
-		
-		// Adding propagation listener :
-		this.modelSizes={};
-		this.setPropagation("cluster","response.model.getSize",(self, message, server, clientSocket)=>{
-			
-			const modelSizes=self.modelSizes;
-			const currentClusterSize=getArraySize(self.authorizedNodesIds);
-			
-			const concernedNodeId=message.nodeId;
-			const modelSize=message.result;
-			
-			let currentNumberOfAnswers=getArraySize(modelSizes);
-
-			if(currentNumberOfAnswers<=currentClusterSize-1){// -1 because we want to exclude this node also !
-				modelSizes[concernedNodeId]=modelSize;
-			}
+}
 
-			currentNumberOfAnswers=getArraySize(modelSizes);
-			// TRACE
-			lognow(`(${self.nodeId}) Node receiving a model size from node ${message.nodeId}...currentClusterSize=${currentClusterSize} ; modelSizes:`,modelSizes);
-			if(currentClusterSize-1<=currentNumberOfAnswers){
-				const nodeIdWithBiggestModel=Math.maxInArray(modelSizes, true);
-				// TRACE
-				lognow(`(${self.nodeId}) Node with biggest model is nodeIdWithBiggestModel=${nodeIdWithBiggestModel}...`);
-				
-				const modelPartitionRequest={
-					type:"request.model.partition",
-				};
-				this.propagateToCluster(modelPartitionRequest, nodeIdWithBiggestModel);
-			}
-		});
-		
-		// Adding propagation listener :
-		// If a node receives a model partition request :
-		this.setPropagation("cluster","request.model.partition",(self, message, server, clientSocket)=>{
-			// Each node will give a little portion of its model, according to its size :					
-			// TRACE
-			lognow(`(${self.nodeId}) Node splits its model for node ${message.nodeId}...`);
-			
-			const ownModel=self.model;
-			const splittedModel=ownModel.split();
-			
-			// Node shares also its model objects directory with the newcomer node :
-			const ownModelObjectsIds=ownModel.getAllObjectsIds();
-			self.modelObjectsDirectory[self.nodeId]=ownModelObjectsIds;
-			
-			const modelString=JSON.stringifyDecycle(splittedModel);
-			const modelPartitionResponse={
-				type:"response.model.partition",
-				modelString:modelString,
-				modelObjectsDirectory:self.modelObjectsDirectory
-			};
-			this.propagateToCluster(modelPartitionResponse, message.nodeId);
-			
-			// This node also advertises that its model has changed to all other nodes (not the newcomer, because it's unnecessary) :
-			const updatemodelObjectsDirectoryRequest={
-				type:"request.update.modelObjectsDirectory",
-				ownModelObjectsIds:ownModelObjectsIds
-			};
-			this.propagateToCluster(updatemodelObjectsDirectoryRequest, null, [message.nodeId]);
-			
-		});
 
-		// Adding propagation listener :
-		this.setPropagation("cluster","response.model.partition",(self, message, server, clientSocket)=>{
-			// TRACE
-			lognow(`(${self.nodeId}) Node receives a model partition from node ${message.nodeId}...`,message);
-			
-			const newModel=JSON.parseRecycle(message.modelString);
-			self.model.replaceBy(newModel);
-			
-			// We initialize this node's model objects directory from the one froom the node tha provided it its model partition :
-			self.modelObjectsDirectory=message.modelObjectsDirectory;
-			
-			// Once this node has received its model partition, it updates its model objects directory
-			const ownModelObjectsIds=newModel.getAllObjectsIds();
-			self.modelObjectsDirectory[self.nodeId]=ownModelObjectsIds;
-			
-			// TRACE
-			lognow(`(${self.nodeId}) Node sends a model objects directory update request...ownModelObjectsIds=${ownModelObjectsIds}`);
-			
-			// And notifies the other nodes of the change :
-			const updatemodelObjectsDirectoryRequest={
-				type:"request.update.modelObjectsDirectory",
-				ownModelObjectsIds:ownModelObjectsIds
-			};
-			this.propagateToCluster(updatemodelObjectsDirectoryRequest);
+//
+// CLIENT INSTANCE :
+//
+class ClientInstance{
 
-		});
-		
-		this.addModelObjectsDirectoryListeners();
+	constructor(clientSocket){
 		
+		this.onServerLostListeners=[];
 		
-		// DBG
-		lognow(">>>>>>>>FOR OTHER NODES this.listeners",this.listeners);
+		this.clientSocket=clientSocket;
+		this.clientReceptionEntryPoints=[];
 		
 	}
 	
 	
-	
-	/*private*/addModelObjectsDirectoryListeners(){
-		
+	sendChainable(channelNameParam, data, clientsRoomsTag=null){
 		const self=this;
 		
-		// Adding propagation listener :
-		// If a node receives a model objects directory update request :
-		this.setPropagation("cluster","request.update.modelObjectsDirectory",(self, message, server, clientSocket)=>{
-			
-			// TRACE
-			lognow(`(${self.nodeId}) !!!!!! Node receives a model objects directory update request from node ${message.nodeId}...`,message);
-			
-			const modelObjectsIds=message.ownModelObjectsIds;
-			self.modelObjectsDirectory[message.nodeId]=modelObjectsIds;
-
-		});
+		// DBG
+		lognow(">>>>>>sendChainable CLIENT ("+channelNameParam+"):data:",data);
 		
-				
-		// Adding propagation listener :
-		// If a node receives a model objects directory update request :
-		this.setPropagation("cluster","request.add.modelObjectsDirectory",(self, message, server, clientSocket)=>{
-			
-			// TRACE
-			lognow(`(${self.nodeId}) !!!!!! Node receives a model objects directory add request from node ${message.nodeId}...`,message);
+		// We add a message id :
+		const messageId=getUUID();
+		data.messageId=messageId;
+		
+		// 1) We prepare the reception :
+		const resultPromise={
+			// CAUTION : CANNOT STORE ANYTHING IN THE resultPromise, FOR ASYNC CALLS MAKES ITS DATA INCONSISTENT IN TIME !
+			thenWhenReceiveMessageType:(channelNameForResponse, listenerConfig={listenerMessageType:"",condition:()=>true}, doOnIncomingMessageForResponse)=>{
 			
-			const newObjectsIds=message.newObjectsIds;
-			self.modelObjectsDirectory[message.nodeId].push(...newObjectsIds);
+				listenerConfig=nonull(listenerConfig,{listenerMessageType:"",condition:()=>true});
+				const listenerId=nonull(listenerConfig.listenerMessageType,"");
+				
+				// I-
+				//
+				self.receive(channelNameForResponse, doOnIncomingMessageForResponse,
+						clientsRoomsTag, listenerId, {messageId:messageId, destroyListenerAfterReceiving:true});
+				//
+				
+				return resultPromise;
+			}
+		};
 
-		});
+		// 2) We send the data :
+		this.send(channelNameParam, data, clientsRoomsTag);
 		
-	}
-	
-	
-	/*public*/sendUpdatedObjects(modifiedObjects, modifiedObjectsIds){
-				
-		if(empty(modifiedObjects))	return modifiedObjects;
 
-		// Then we send back the modified objects to all the concerned clients : (which are all clients connected to this node)
-		return this.sendObjectsUpdatesToClients(modifiedObjects);
+		return resultPromise;
 	}
 	
-	/*public*/sendNewObjects(newObjects, newObjectsIds){
+	// II-
+	receive(channelNameParam, doOnIncomingMessage, clientsRoomsTag=null, entryPointId=null, listenerConfig={destroyListenerAfterReceiving:false}){
+		const self=this;
 		
-		if(empty(newObjects))	return newObjects;
-
-		// At this point, node controller has already added the objects to its model.
-		// We just want to update the objects directories of all the nodes in the cluster:
+//	// DBG
+//	lognow("INFO : (CLIENT)  SETTING UP RECEIVE for :",channelNameParam);
 		
-		// !!! CAUTION : NOTE THAT THE EMITTER NODE IS ALWAYS INCLUDED IN THE THE VISITED NODES !!!
-		// So this is why ir needs to update its mode objects directory itself, before sending the add request to the cluster :
-		this.modelObjectsDirectory[this.nodeId].push(...newObjectsIds);
+		const clientReceptionEntryPoint=new ClientReceptionEntryPoint(channelNameParam, entryPointId, clientsRoomsTag, listenerConfig, doOnIncomingMessage);
+		if(!contains.filter((l)=>(
+					 l.entryPointId && clientReceptionEntryPoint.entryPointId 
+				&& l.entryPointId===clientReceptionEntryPoint.entryPointId
+			))(this.clientReceptionEntryPoints)){
+				
+			this.clientReceptionEntryPoints.push(clientReceptionEntryPoint);
+		}
 
-		// This node also advertises that its model has changed to all other nodes (not the newcomer, because it's unnecessary) :
-		const updatemodelObjectsDirectoryRequest={
-			type:"request.add.modelObjectsDirectory",
-			newObjectsIds:newObjectsIds
-		};
-		this.propagateToCluster(updatemodelObjectsDirectoryRequest);
-		
-		
-		// But we also want all the concerned clients to update their local models : (which are all clients connected to this node)
-		return this.sendObjectsUpdatesToClients(newObjects, true);
+		const clientSocket=this.clientSocket;
+	  if(WebsocketImplementation.useSocketIOImplementation){
+			// FOR THE SOCKETIO IMPLEMENTATION :
+			clientSocket.on(channelNameParam, (eventOrMessage)=>{
+				clientReceptionEntryPoint.execute(eventOrMessage, clientSocket, this.clientReceptionEntryPoints);
+			});
+		}
+			
+		return this;
 	}
+
 	
-	/*private*/sendObjectsUpdatesToClients(modifiedOrAddedObjects, isAddingObjects=false){
+	send(channelNameParam, data, clientsRoomsTag=null){
 		
-		const self=this;
-		foreach(this.clients, client=>{
-			const clientSocket=client.clientSocket;
-			const objectsModifiedOrAddedClientResponse={
-				nodeId:self.nodeId,
-				type:"response.objectsModifiedOrAdded.client",
-				objectsString:JSON.stringifyDecycle(modifiedOrAddedObjects),
-				isAddingObjects:isAddingObjects,
-			};
-			self.server.send("inputs", objectsModifiedOrAddedClientResponse, null, clientSocket);
-		});
+		// // DBG
+		// lognow("(CLIENT) CLIENT TRIES TO SEND !");
+		
+		const clientSocket=this.clientSocket;
+  	
+		if(!isConnected(clientSocket))	return;
+		
+		// Room information is stored in client socket object :
+		if(!WebsocketImplementation.isInRoom(clientSocket,clientsRoomsTag)) return;
 
-		return modifiedOrAddedObjects;
+		// Channel information is stored in exchanged data :
+	  let dataWrapped={channelName:channelNameParam, data:data};
+    
+		dataWrapped=stringifyObject(dataWrapped);
+   	
+		// TODO : FIXME : Use one single interface !
+		if(!WebsocketImplementation.useSocketIOImplementation)	clientSocket.send(dataWrapped);
+  	else																										clientSocket.emit(channelNameParam,dataWrapped);
+		
+		return this;
 	}
 	
 	
-	
-	
-	/*private*/getNeighborsNodesIds(){
-		const neighborsNodesIds=[];
-		foreach(this.incomingServers,(incomingServer,nodeId)=>{
-			neighborsNodesIds.push(nodeId);
-		});
-		foreach(this.outcomingServers,(outcomingServer,nodeId)=>{
-			neighborsNodesIds.push(nodeId);
-		});
-		return neighborsNodesIds;
+	join(clientRoomTag){
+		// Join room client part protocol :
+		const message={type:"joinRoom",clientRoomTag:clientRoomTag};
+		this.send("protocol",message);
 	}
+		
 	
-	/*private*/getLeastOccupiedNeighborNodeId(){
+	onConnectionToServer(doOnConnection){
 		const self=this;
-	
-		// We send the new objects to the neighbor node with the least amount of objects :
-		let leastOccupiedNodeId=null;
-		foreach(this.getNeighborsNodesIds(), (nodeId)=>{
-			const entry=self.modelObjectsDirectory[nodeId];
-			const numberOfObjects=getArraySize(entry);
-			if(!leastOccupiedNodeId || numberOfObjects<getArraySize(self.modelObjectsDirectory[leastOccupiedNodeId]))
-				leastOccupiedNodeId=nodeId;
-		});
 		
-		if(!leastOccupiedNodeId){
-			// TRACE
-			lognow("WARN : Cannot find the least occupied node. Aborting.");
-		}
-		return leastOccupiedNodeId;
-	}
-
+		// DBG
+		lognow("DEBUG : CLIENT : setting up onConnectionToServer.");
+		
+		const doAllOnConnection=()=>{
 
-	// ****************************************************************************************************
-	/*private*/setPropagation(channelName, requestType, doOnReception=null, responseRequestType=null, propagateToAllCluster=true){
-		const self=this;
-		this.setUniqueReceptionPoint(channelName, requestType, (self, message, server, clientSocket)=>{
+			// To avoid triggering this event several times, depending on the implementation : 
+			if(self.hasConnectEventFired)	return;
+			self.hasConnectEventFired=true;
 			
-			const requestId=message.requestId;
-			if(contains(self.executedRequestIdsHistory, requestId)){
-				// TRACE
-				lognow(`WARN : Request of type ${message.type} already answered. Aborting.`);
-				return;
-			}
-			if(message.visitedNodeIds){
-				if(contains(message.visitedNodeIds, self.nodeId)){
-					return;
-				}
-				message.visitedNodeIds.push(self.nodeId);
-			}
+			// DBG
+			lognow("DEBUG : CLIENT : doOnConnection !");
 			
-			const hasNoExclusionsOrExclusionDoesNotApplyOnThisNode=(!message.excludedNodesIds || !contains(message.excludedNodesIds,self.nodeId));
-			let response=null;
-			if(!message.destinationNodeId && hasNoExclusionsOrExclusionDoesNotApplyOnThisNode){
-				// Case broadcast message :
-				if(doOnReception)
-					response=doOnReception(self, message, server, clientSocket);
-				pushInArrayAsQueue(self.executedRequestIdsHistory, REQUESTS_IDS_HISTORY_SIZE, requestId);
-				if(propagateToAllCluster)	self.sendToOtherNodes(channelName, message);		
-			}else{
-				if(message.destinationNodeId===self.nodeId && hasNoExclusionsOrExclusionDoesNotApplyOnThisNode){
-					if(doOnReception)
-						response=doOnReception(self, message, server, clientSocket);
-					pushInArrayAsQueue(self.executedRequestIdsHistory, REQUESTS_IDS_HISTORY_SIZE, requestId);
-				}else{
-					if(propagateToAllCluster)	self.sendToOtherNodes(channelName, message);		
-				}
+			const clientSocket=self.clientSocket;
+		  if(!WebsocketImplementation.useSocketIOImplementation){
+				// FOR THE WEBSOCKET IMPLEMENTATION :
+				clientSocket.addEventListener("message", (eventOrMessage)=>{
+					foreach(self.clientReceptionEntryPoints,(clientReceptionEntryPoint)=>{
+						clientReceptionEntryPoint.execute(eventOrMessage, clientSocket, self.clientReceptionEntryPoints);
+					});
+				});
 			}
-			
-			// We send back the answer to the originating node :
-			if(response!=null && responseRequestType){
-				// TRACE
-				lognow(`(${self.nodeId}) Node sending back a response of type ${responseRequestType}...`);				
 
-				const clusterResponse={
-					type:responseRequestType,
-					result:response
-				};
-				const originNodeId=message.nodeId;
-				if(propagateToAllCluster)	self.propagateToCluster(clusterResponse, originNodeId);
-				else											self.propagateToSingleNeighbor(clusterResponse, originNodeId);
+			doOnConnection(self, clientSocket);
+		};
+		
+		
+		if(!WebsocketImplementation.useSocketIOImplementation){
+			// FOR THE WEBSOCKET IMPLEMENTATION :
+			this.clientSocket.addEventListener("open",doAllOnConnection);
+			
+			if(!empty(this.onServerLostListeners)){
+				this.clientSocket.addEventListener("close",()=>{
+					foreach(self.onServerLostListeners,l=>{l.execute(self.clientSocket);});
+				});
 			}
 			
-		});
-	}
-	// ****************************************************************************************************
-		
-	/*private*/propagateToCluster(request, destinationNodeId=null, excludedNodesIds=null){
-		request.requestId=getUUID();
-		const originNodeId=this.nodeId;
-		request.nodeId=originNodeId;
-		if(destinationNodeId)	request.destinationNodeId=destinationNodeId;
-		if(excludedNodesIds)	request.excludedNodesIds=excludedNodesIds;
-		request.visitedNodeIds=[originNodeId];
-		this.sendToOtherNodes("cluster",request);
-	}
-	
-	/*private*/propagateToNeighbors(request){
-		request.requestId=getUUID();
-		const originNodeId=this.nodeId;
-		request.nodeId=originNodeId;
-		this.sendToOtherNodes("neightbors", request);
-	}
-	/*private*/propagateToSingleNeighbor(request, destinationNodeId){
-		request.requestId=getUUID();
-		const originNodeId=this.nodeId;
-		request.nodeId=originNodeId;
-		request.destinationNodeId=destinationNodeId;
-		this.sendToOtherSingleNode("neightbors", request, destinationNodeId);
-	}
-	
-	// ****************************************************************************************************
-
-	/*private*/sendToOtherNodes(channelName, message){
-		let hasBeenSentIncoming=this.sendToIncomingServers(channelName, message);
-		let hasBeenSentOutcoming=this.sendToOutcomingServers(channelName, message);
-		return (hasBeenSentIncoming || hasBeenSentOutcoming);
-	}
-	/*private*/sendToIncomingServers(channelName, message){
-		const self=this;
-		let hasBeenSent=false;
-		foreach(this.incomingServers, (client)=>{
-			const clientSocket=client.clientSocket;
-			self.server.send(channelName, message, null, clientSocket);
-			hasBeenSent=true;
-		});
-		return hasBeenSent;
-	}
-	/*private*/sendToOutcomingServers(channelName, message){
-		let hasBeenSent=false;
-		foreach(this.outcomingServers, (client)=>{
-			const clientInstanceToOtherServer=client.clientInstance;
-			clientInstanceToOtherServer.client.socketToServer.send(channelName, message);
-			hasBeenSent=true;
-		});
-		return hasBeenSent;
-	}
-	/*private*/sendToOtherSingleNode(channelName, request, destinationNodeId){
-		const self=this;
-		let hasBeenSent=false;
-		foreach(this.incomingServers, (client)=>{
-			const clientSocket=client.clientSocket;
-			self.server.send(channelName, message, null, clientSocket);
-			hasBeenSent=true;
-		},(c, nodeId)=>(nodeId===destinationNodeId));
-		if(!hasBeenSent){
-			foreach(this.outcomingServers, (client)=>{
-				const clientInstanceToOtherServer=client.clientInstance;
-				clientInstanceToOtherServer.client.socketToServer.send(channelName, message);
-				hasBeenSent=true;
-			},(c, nodeId)=>(nodeId===destinationNodeId));
-		}
-		return hasBeenSent;
-	}
+		}else{
+			// FOR THE SOCKETIO IMPLEMENTATION :
+			this.clientSocket.on("connect",doAllOnConnection);
 
-	/*private*/setUniqueReceptionPoint(channelName, messageType, doOnReception){
-		const self=this;
-		const listeners=this.listeners[channelName];
-		if(foreach(listeners,listener=>{
-			if(listener.messageType===messageType)	return true;
-		}))	return;
-		listeners.push({
-			messageType:messageType,
-			execute:(self, message, server, clientSocket)=>{
-				doOnReception(self, message, server, clientSocket);
+			if(!empty(this.onServerLostListeners)){
+				this.clientSocket.on("close",()=>{
+					foreach(self.onServerLostListeners,l=>{l.execute(self.clientSocket);});
+				});
 			}
-		});
-	}
-	
-	// ****************************************************************************************************
 
-	/*private*/isInAuthorizedNodes(incomingServerNodeId){
-		return contains(this.authorizedNodesIds,incomingServerNodeId);
-	}
-	
-	/*public*/traceNode(){
-		// TRACE
-		lognow("-------------------------------------------------------------");
-		lognow(`(${this.nodeId}) :`,this);
-		lognow("-------------------------------------------------------------");
+			
+			// Client ping handling :
+			// (SocketIO implementation only, the websocket implementation sends back a hidden pong !)
+			// PING-PONG :
+			this.receive("protocol",(message)=>{
+				if(message.type!=="ping")	return;
+				self.send("protocol",{type:"pong"});
+				// // DBG
+				// lognow("DEBUG : CLIENT : Pong sent.");
+			});
+		}
+		
+		
+		
 	}
 	
-	
-	
 }
 
 
-getAORTACNode=function(nodeId=getUUID(), selfOrigin="ws://127.0.0.1:40000", outcomingNodesOrigins=[], model, controller){
-	return new AORTACNode(nodeId, selfOrigin, outcomingNodesOrigins, model, controller);
-}
-
 
 
 
@@ -17150,18 +17292,32 @@ getAORTACNode=function(nodeId=getUUID(), selfOrigin="ws://127.0.0.1:40000", outc
 
 class ServerReceptionEntryPoint{
 	
-	constructor(channelNameParam, clientsRoomsTag, doOnIncomingMessage){
+	constructor(channelNameParam, clientsRoomsTag, listenerConfig=null, doOnIncomingMessage){
 		this.channelName=channelNameParam;
 		this.clientsRoomsTag=clientsRoomsTag;
+		this.listenerConfig=listenerConfig;
 		this.doOnIncomingMessage=doOnIncomingMessage;
 	}
 	
 	execute(eventOrMessage, clientSocketParam){
 
+		if(!eventOrMessage){
+			// TRACE
+			lognow("ERROR : No message received.");
+			return;
+		}
+		
+		if(!clientSocketParam){
+			// TRACE
+			lognow("ERROR : No clientSocket to client ! Cannot do reception treatment.");
+			return;
+		}	
+		
+
 	  // With «ws» library we have no choive than register message events inside a «connection» event !
 
 		const dataWrapped=WebsocketImplementation.getMessageDataBothImplementations(eventOrMessage);
-	
+
 		// Channel information is stored in exchanged data :
 		if(dataWrapped.channelName!==this.channelName) return;
 										
@@ -17169,14 +17325,21 @@ class ServerReceptionEntryPoint{
 		// Room information is stored in client socket object :
 		const isClientInRoom=WebsocketImplementation.isInRoom(clientSocketParam, this.clientsRoomsTag);
 		
-		// DBG
-		lognow("(SERVER) isClientInRoom:",isClientInRoom);
+//	// DBG
+//	lognow("(SERVER) isClientInRoom:",isClientInRoom);
 		
 		if(!isClientInRoom) return;
+		
+		// We check if the message matches the required message type :
+		if(		this.listenerConfig && this.listenerConfig.listenerMessageType && dataWrapped.type
+			 && this.listenerConfig.listenerMessageType!==dataWrapped.type){
+			return;
+		}
 
 		if(this.doOnIncomingMessage){
-			// DBG
-			lognow("(SERVER) this.doOnIncomingMessage:");
+//		// DBG
+//		lognow("(SERVER) this.doOnIncomingMessage:");
+
 			this.doOnIncomingMessage(dataWrapped.data, clientSocketParam);
 		}
 				
@@ -17197,7 +17360,9 @@ class NodeServerInstance{
 		this.onClientLostListeners=[];
 		
 		this.clientPingIntervalMillis=5000;
+		
 		this.serverSocket=serverSocket;
+		
 		this.listenableServer=listenableServer;
 		this.serverReceptionEntryPoints=[];
 		
@@ -17230,13 +17395,12 @@ class NodeServerInstance{
 	//}
 
 
-	receive(channelNameParam, doOnIncomingMessage, clientsRoomsTag=null){
-		const self=this;
+	receive(channelNameParam, doOnIncomingMessage, listenerConfig=null, clientsRoomsTag=null){
 			
 		// DBG
 		lognow("(SERVER) Registering receive for «"+channelNameParam+"»...");
 		
-		const serverReceptionEntryPoint=new ServerReceptionEntryPoint(channelNameParam, clientsRoomsTag, doOnIncomingMessage);
+		const serverReceptionEntryPoint=new ServerReceptionEntryPoint(channelNameParam, clientsRoomsTag, listenerConfig, doOnIncomingMessage);
 		this.serverReceptionEntryPoints.push(serverReceptionEntryPoint);
 		
 		// SPECIAL FOR THE SOCKETIO IMPLEMENTATION :
@@ -17445,255 +17609,13 @@ class NodeServerInstance{
 
 
 
-/* ## Utility network global methods in a javascript, console (nodejs), or vanilla javascript with no browser environment.
- *
- * This set of methods gathers utility generic-purpose methods usable in any JS project.
- * Several authors of snippets published freely on the Internet contributed to this library.
- * Feel free to use/modify-enhance/publish them under the terms of its license.
- * 
- * # Library name : «aotrautils» 
- * # Library license : HGPL(Help Burma) (see aotra README information for details : https://alqemia.com/aotra.js )
- * # Author name : Jérémie Ratomposon (massively helped by his native country free education system)
- * # Author email : info@alqemia.com
- * # Organization name : Alqemia
- * # Organization email : admin@alqemia.com
- * # Organization website :  https://alqemia.com
- * 
- *  
- */
-
-
-
-// COMPATIBILITY browser javascript / nodejs environment :
-if(typeof(window)==="undefined")	window=global;	
-
-
-
-// ==================================================================================================================
-
-
-class ClientReceptionEntryPoint{
-	
-	constructor(channelNameParam, entryPointId, clientsRoomsTag, listenerConfig, doOnIncomingMessage){
-		this.channelName=channelNameParam;
-		this.entryPointId=entryPointId;
-		this.clientsRoomsTag=clientsRoomsTag;
-		this.listenerConfig=listenerConfig;
-		this.doOnIncomingMessage=doOnIncomingMessage;
-	}
-	
-	// III-
-	execute(eventOrMessage, clientSocket, clientReceptionEntryPoints){
-		
-
-		const dataWrapped=WebsocketImplementation.getMessageDataBothImplementations(eventOrMessage);
-		
-		// We check if the message is in the right channel (channel information is stored in exchanged wrapped data) :
-		const channelName=this.channelName;
-		if(dataWrapped.channelName && dataWrapped.channelName!==this.channelName){
-			return;
-		}
-		
-		// We check if the message is in the right room (r)oom information is stored in client socket object) :
-		if(!WebsocketImplementation.isInRoom(clientSocket, this.clientsRoomsTag)){
-			return;
-		}
-
-		// We check if the message matches the required message type :
-		if(		this.listenerConfig && this.listenerConfig.messageType && dataWrapped.type
-			 && this.listenerConfig.messageType!==dataWrapped.type){
-			return;
-		}
-		
-		// We check if the message matches the condition :
-		const dataLocal=dataWrapped.data;
-		if(this.listenerConfig.condition && !this.istenerConfig.condition(dataLocal, clientSocket)){
-			return;
-		}
-		
-		// We check if we have the same message id:
-		const messageIdLocal=this.listenerConfig.messageId;
-		if(messageIdLocal!==dataLocal.messageId){
-			return;
-		}
-
-		// At this point, message is the right one, so it can be processed :
-		// --------------------------------
-		
-		// We remove one-time usage listeners :
-		// We remove BEFORE executing doOnIncomingMessage(), because in this reception entry point function we can have other listener registration UNDER THE SAME ID !
-		if(this.listenerConfig && this.listenerConfig.destroyListenerAfterReceiving)
-			remove(clientReceptionEntryPoints, this);
-		
-		if(this.doOnIncomingMessage)
-			this.doOnIncomingMessage(dataLocal, clientSocket);
-			
-	}
-	
-}
-
-
-//
-// CLIENT INSTANCE :
-//
-class ClientInstance{
-
-	constructor(clientSocket){
-		this.clientSocket=clientSocket;
-		this.clientReceptionEntryPoints=[];
-		
-	}
-	
-	
-	sendChainable(channelNameParam, data, clientsRoomsTag=null){
-		const self=this;
-		
-		// DBG
-		lognow(">>>>>>sendChainable CLIENT ("+channelNameParam+"):data:",data);
-		
-		// We add a message id :
-		const messageId=getUUID();
-		data.messageId=messageId;
-		
-		// 1) We prepare the reception :
-		const resultPromise={
-			// CAUTION : CANNOT STORE ANYTHING IN THE resultPromise, FOR ASYNC CALLS MAKES ITS DATA INCONSISTENT IN TIME !
-			thenWhenReceiveMessageType:(channelNameForResponse, listenerConfig={messageType:"",condition:()=>true}, doOnIncomingMessageForResponse)=>{
-			
-				listenerConfig=nonull(listenerConfig,{messageType:"",condition:()=>true});
-				const listenerId=nonull(listenerConfig.messageType,"");
-				
-				// I-
-				//
-				self.receive(channelNameForResponse, doOnIncomingMessageForResponse
-				, clientsRoomsTag, listenerId, {messageId:messageId, destroyListenerAfterReceiving:true});
-				//
-				
-				return resultPromise;
-			}
-		};
-
-		// 2) We send the data :
-		this.send(channelNameParam, data, clientsRoomsTag);
-		
 
-		return resultPromise;
-	}
-	
-	// II-
-	receive(channelNameParam, doOnIncomingMessage, clientsRoomsTag=null, entryPointId=null, listenerConfig={destroyListenerAfterReceiving:false}){
-		const self=this;
-		
-		// DBG
-		lognow("INFO : (CLIENT)  SETTING UP RECEIVE for :",channelNameParam);
-		
-		const clientReceptionEntryPoint=new ClientReceptionEntryPoint(channelNameParam, entryPointId, clientsRoomsTag, listenerConfig, doOnIncomingMessage);
-		if(!contains.filter((l)=>(
-					 l.entryPointId && clientReceptionEntryPoint.entryPointId 
-				&& l.entryPointId===clientReceptionEntryPoint.entryPointId
-			))(this.clientReceptionEntryPoints)){
-				
-			this.clientReceptionEntryPoints.push(clientReceptionEntryPoint);
-		}
 
-		const clientSocket=this.clientSocket;
-	  if(WebsocketImplementation.useSocketIOImplementation){
-			// FOR THE SOCKETIO IMPLEMENTATION :
-			clientSocket.on(channelNameParam, (eventOrMessage)=>{
-				clientReceptionEntryPoint.execute(eventOrMessage, clientSocket, this.clientReceptionEntryPoints);
-			});
-		}
-			
-		return this;
-	}
 
-	
-		
-		
-	send(channelNameParam, data, clientsRoomsTag=null){
-		
-		// // DBG
-		// lognow("(CLIENT) CLIENT TRIES TO SEND !");
-		
-		const clientSocket=this.clientSocket;
-  	
-		if(!isConnected(clientSocket))	return;
-		
-		// Room information is stored in client socket object :
-		if(!WebsocketImplementation.isInRoom(clientSocket,clientsRoomsTag)) return;
 
-		// Channel information is stored in exchanged data :
-	  let dataWrapped={channelName:channelNameParam, data:data};
-    
-		dataWrapped=stringifyObject(dataWrapped);
-   	
-		// TODO : FIXME : Use one single interface !
-		if(!WebsocketImplementation.useSocketIOImplementation)	clientSocket.send(dataWrapped);
-  	else																										clientSocket.emit(channelNameParam,dataWrapped);
-		
-		return this;
-	}
-	
-	
-	join(clientRoomTag){
-		// Join room client part protocol :
-		const message={type:"joinRoom",clientRoomTag:clientRoomTag};
-		this.send("protocol",message);
-	}
-		
-	
-	onConnectionToServer(doOnConnection){
-		const self=this;
-		
-		// DBG
-		lognow("DEBUG : CLIENT : setting up onConnectionToServer.");
-		
-		const doAllOnConnection=()=>{
 
-			// To avoid triggering this event several times, depending on the implementation : 
-			if(self.hasConnectEventFired)	return;
-			self.hasConnectEventFired=true;
-			
-			// DBG
-			lognow("DEBUG : CLIENT : doOnConnection !");
-			
-			const clientSocket=self.clientSocket;
-		  if(!WebsocketImplementation.useSocketIOImplementation){
-				// FOR THE WEBSOCKET IMPLEMENTATION :
-				clientSocket.addEventListener("message", (eventOrMessage)=>{
-					foreach(self.clientReceptionEntryPoints,(clientReceptionEntryPoint)=>{
-						clientReceptionEntryPoint.execute(eventOrMessage, clientSocket, self.clientReceptionEntryPoints);
-					});
-				});
-			}
 
-			doOnConnection(self, clientSocket);
-		};
-		
-		
-		if(!WebsocketImplementation.useSocketIOImplementation){
-			// FOR THE WEBSOCKET IMPLEMENTATION :
-			this.clientSocket.addEventListener("open",doAllOnConnection);
-		}else{
-			// FOR THE SOCKETIO IMPLEMENTATION :
-			this.clientSocket.on("connect",doAllOnConnection);
 
-			// Client ping handling :
-			// (SocketIO implementation only, the websocket implementation sends back a hidden pong !)
-			// PING-PONG :
-			this.receive("protocol",(message)=>{
-				if(message.type!=="ping")	return;
-				self.send("protocol",{type:"pong"});
-				// // DBG
-				// lognow("DEBUG : CLIENT : Pong sent.");
-			});
-		}
-		
-		
-		
-	}
-	
-}
 
 
 /* INCLUDED EXTERNAL LIBRAIRIES