aotrautils-srv 0.0.1840 → 0.0.1846

aotrautils-srv/aotrautils-srv.build.js

@@ -1,6 +1,6 @@
 
 
-/*utils COMMONS library associated with aotra version : «1_29072022-2359 (09/04/2026-01:44:45)»*/
+/*utils COMMONS library associated with aotra version : «1_29072022-2359 (02/06/2026-01:06:15)»*/
 /*-----------------------------------------------------------------------------*/
 
 
@@ -35,7 +35,7 @@ PERFORM_TESTS_ON_LIBRARY=false;
 
 const ROOT_UUID="00000000-0000-0000-0000-000000000000";
 const DEFAULT_UUID_ATTR_NAME="JSONid";/* Yet Another UUID */
-const DEFAULT_CLASSNAME_ATTR_NAME="JSONtype";/* Yet Another Classname */
+const DEFAULT_CLASSNAME_ATTR_NAME="JSONtype";/* Yet Another ClassName */
 const DEFAULT_POINTER_TO_ATTR_NAME="JSONref";/* Yet Another PointerTo */
 
 //=========================================================================
@@ -1760,7 +1760,7 @@ function encodeXORNoPattern(strToEncode,key){
 
 // CAUTION : This method is declared this way because it's also used in a nodejs context!
 // TODO : FIXME : DO THIS FOR ALL OF THESE COMMON METHODS AND FUNCTIONS !
-generateRandomString=function(length,/*NULLABLE*/mode=null){
+generateRandomString=function(length,/*NULLABLE*/mode=null, separator="~>"){
 	
 	// This list must be very conservative, because  we want to be able to pass it through GET URLs !
 	// OLD (not enough conservative ?) : const ALLOWED_CHARS="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0912346789_-£¢¤¬²³¼½¾";
@@ -1768,7 +1768,7 @@ generateRandomString=function(length,/*NULLABLE*/mode=null){
 	
 	
 	if(typeof(length)==="string"){
-		if(contains(length,"->")){
+		if(contains(length,"~>")){
 			length=Math.getRandomInRange(length);
 		}else{
 			length=64;
@@ -2049,7 +2049,7 @@ window.nothing=function(nullable, insist=false){
 }
 
 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.
+	// BECAUSE CAUTION : We don't allow to specify a default initialization value as parameter, because 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;
@@ -2085,6 +2085,7 @@ window.getOrCreateEmptyAttribute=function(parentObject, attributeNameOrAttribute
 	return null; // (case no child was found or it could be not created.)
 }
 
+// ( Equivalent to syntax:	value??defaultValue )
 window.nonull=function(value,defaultValue){
 	if(value===false)	return value;
 	if(nothing(value))	return defaultValue;
@@ -2153,7 +2154,7 @@ window.pushInArrayAsQueue=function(array, maxSize, item){
 /*KNOWN LIMITATIONS : You will have an incomplete browsing loop if there are the string values "break" or "continue" in your array or associative array !*/
 // (Alternatively, you can use this instead :  for (const key of Object.keys(obj)) { const item=obj[key]; ... })
 // CAUTION : Only use «return foreach» syntax in client code loops with SINGLE-LEVEL nested loops ONLY !
-window.foreach=function(arrayOfValues,doOnEachFunction,
+window.foreach=function(arrayOfValues, doOnEachFunction,
 	/*OPTIONAL*/filterFunction=null,
 	// CAUTION ! Javascript sort compare function result is the same as in Java :
 //   0: if(a==b)
@@ -3693,7 +3694,7 @@ Math.coerceInRange=window.aotest({
 }, !PERFORM_TESTS_ON_LIBRARY);
 
 
-Math.getMinMax=function(strMinMaxRange, separator="->"){
+Math.getMinMax=function(strMinMaxRange, separator="¬>"){
 	if(strMinMaxRange && isString(strMinMaxRange) && contains(strMinMaxRange,separator)){
 		let splits=strMinMaxRange.split(separator);
 		let min=parseInt(splits[0]);
@@ -3704,7 +3705,7 @@ Math.getMinMax=function(strMinMaxRange, separator="->"){
 }
 
 
-Math.isInMinMax=function(minMaxRange,value,mode="][",separator="->"){
+Math.isInMinMax=function(minMaxRange,value,mode="][",separator="¬>"){
 	let minMax=null;
 	
 	if(minMaxRange){
@@ -3727,7 +3728,7 @@ Math.isInMinMax=function(minMaxRange,value,mode="][",separator="->"){
 }
 
 
-Math.getRandomInRange=function(str, separator="->"){
+Math.getRandomInRange=function(str, separator="~>"){
 	if(str && isString(str) && contains(str,separator)){
 		let splits=Math.getMinMax(str,separator);
 		let minValue=splits.min;
@@ -3912,7 +3913,10 @@ window.isBoolean=function(b){
 	return typeof b === "boolean";
 }
 window.isFunction=function(functionToCheck){
-	return (functionToCheck && {}.toString.call(functionToCheck) === "[object Function]");
+	return (functionToCheck && (isAsyncFunction(functionToCheck) || {}.toString.call(functionToCheck) === "[object Function]"));
+}
+window.isAsyncFunction=function(functionToCheck){
+	return (functionToCheck && functionToCheck.constructor && functionToCheck.constructor.name==="AsyncFunction");
 }
 window.isPrimitive=function(p){
 	return (isNumber(p) || isString(p) || isBoolean(p));
@@ -3920,6 +3924,8 @@ window.isPrimitive=function(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]";
@@ -3928,9 +3934,19 @@ window.isClassObject=function(o){
   return isObject(o) && !isNativeClass(o);
 }
 window.getClassName=function(obj){
-	if(!obj)	return null;
+	if((typeof obj === "undefined") || obj==null)	return null;
 	if(!obj.constructor)	return null;
-	return obj.constructor.name;
+//if(!empty(Object.getPrototypeOf(obj).constructor.name))
+//	return Object.getPrototypeOf(obj).constructor.name;
+	if(!empty(obj.constructor.name)){
+		return obj.constructor.name;
+	}else{
+		//TRACE
+		lognow("WARN : Object is an instance of an anonymous class ! Cannot infer its class name ! Please fix its class definition ! obj:", obj);
+	}
+	// WORKAROUND
+	if(!empty(obj[CLASSNAME_ATTRIBUTE_NAME]))	return obj[CLASSNAME_ATTRIBUTE_NAME];
+  return Object.prototype.toString.call(obj).match(/^\[object\s(.*)\]$/)[1];
 }
 window.isNativeClass=function(obj){
 	let className=getClassName(obj);
@@ -4097,8 +4113,12 @@ getUUID=function(mode=null){
 }
 
 
+
+window.CLASSNAME_ATTRIBUTE_NAME="__className";
+
+
 // JSON
-window.instanciate=function(className=null){
+window.instantiate=function(className=null){
 	let newObj={};
 	
 	if(!className || !isString(className))	return newObj;
@@ -4116,7 +4136,9 @@ window.instanciate=function(className=null){
 	// If class name is a simple array, a simple «[]» is enough :
 	if(className==="Array")	return [];
 
+
 	
+
 	let classInWindow=globalThis[className];
 	if(typeof(classInWindow)=="undefined"){
 		// TRACE
@@ -4130,14 +4152,27 @@ window.instanciate=function(className=null){
 				classInWindow=global[className];
 				if(!classInWindow){
 					// TRACE
-					lognow(`ERROR : CAUTION : «${className}» class does not seem to be registered in the global object. Cannot instanciate it.`);
-					return newObj;
+					lognow(`ERROR : CAUTION : «${className}» class does not seem to be registered in the global object. Cannot instantiate it.`);
+					
+					// DEBUG
+					// TODO : FIXME : I don't like that at all, to use eval(...), but on today I know of no other solution... :
+					newObj=eval("new "+className+"();");
+					
 				}
 			}else{
-				// TRACE
-				lognow(`ERROR : CAUTION : «${className}» class does not seem to be accessible in the globalThis nor window object, and global object does not exist. Cannot instanciate it.`);
-				return newObj;
+				// TRACEfireNewPuff()
+				lognow(`ERROR : CAUTION : «${className}» class does not seem to be accessible in the globalThis nor window object, and global object does not exist. Cannot instantiate it.`);
+
+				// DEBUG
+				// TODO : FIXME : I don't like that at all, to use eval(...), but on today I know of no other solution... :
+				newObj=eval("new "+className+"();");
+			
 			}
+			
+			// WORKAROUND
+			newObj[CLASSNAME_ATTRIBUTE_NAME]=className;
+			
+			return newObj;
 		}
 	}
 
@@ -4147,21 +4182,21 @@ window.instanciate=function(className=null){
 //			newObj=Reflect.construct(classInWindow);
 //		}catch(e1){
 ////			// TRACE
-////			console.log("WARN : Could not instanciate class «"+className+"». (Maybe class is undefined or default constructor doesn't exist !)");
+////			console.log("WARN : Could not instantiate class «"+className+"». (Maybe class is undefined or default constructor doesn't exist !)");
 //			// TODO : FIXME : I don't like that at all, to use eval(...), but on today I know of no other solution... :
 //			newObj=eval("new "+className+"();");
 //		}
 //	}catch(e2){
 ////		// TRACE
-////		console.log("ERROR : Could not instanciate class «"+className+"» with eval. (Maybe class is undefined or default constructor doesn't exist !)");
+////		console.log("ERROR : Could not instantiate class «"+className+"» with eval. (Maybe class is undefined or default constructor doesn't exist !)");
 //		try{
 ////		// TODO : FIXME : I don't like that at all, to use eval(...), but on today I know of no other solution... :
 ////		newObj=eval("new window."+className+"();");
 //			newObj=Reflect.construct(classInWindow);
 //		}catch(e3){
 ////			// TRACE
-////			console.log("ERROR : Could not instanciate class «"+className+"» with eval and «window.». (Maybe class is undefined or default constructor doesn't exist !)");
-////			console.log("ERROR : Could not instanciate class «"+className+"» with Reflect and «window.». (Maybe class is undefined or default constructor doesn't exist !)");
+////			console.log("ERROR : Could not instantiate class «"+className+"» with eval and «window.». (Maybe class is undefined or default constructor doesn't exist !)");
+////			console.log("ERROR : Could not instantiate class «"+className+"» with Reflect and «window.». (Maybe class is undefined or default constructor doesn't exist !)");
 //			// TODO : FIXME : This is the most performance-costing fallback :
 //			try{
 //				if(classInWindow){
@@ -4173,7 +4208,7 @@ window.instanciate=function(className=null){
 //				}
 //			}catch(e4){
 ////				// TRACE
-////				console.log("ERROR : Could not instanciate class «"+className+"» with prototype affectation.");
+////				console.log("ERROR : Could not instantiate class «"+className+"» with prototype affectation.");
 ////				console.log("ERROR : Returning plain object since all instantiation methods have failed for class «"+className+"».");
 //			}
 //		}
@@ -4181,17 +4216,17 @@ window.instanciate=function(className=null){
 
 	// NEW :
 	newObj=new classInWindow();
+	
+	// WORKAROUND
+	newObj[CLASSNAME_ATTRIBUTE_NAME]=className;
+	
 	return newObj;
 };
 
 
 
-
-
-
-
 JSON.stringifyDecycle=function(obj){
-	let decycled=JSON.decycle(obj,null,"$className");
+	let decycled=JSON.decycle(obj,null,CLASSNAME_ATTRIBUTE_NAME);
 	// CANNOT USE stringifyObject(...) function because we are in a common, lower-level library !
 	return stringifyObject(decycled);
 }
@@ -4199,6 +4234,8 @@ JSON.stringifyDecycle=function(obj){
 
 JSON.parseRecycle=function(str){
 	
+	const attributeClassName=CLASSNAME_ATTRIBUTE_NAME;
+	
 	const parsedDecycled=parseJSON(str);
 	let restoreClass=function(objParam){
 		
@@ -4208,11 +4245,11 @@ JSON.parseRecycle=function(str){
 		if(isArray(objParam)){
 			newObj=[];
 		}else{
-			let className=objParam["$className"];
+			let className=objParam[attributeClassName];
 			if(!className || isNativeClassName(className)){
 				newObj= {};
 			}else{
-				newObj=instanciate(className);
+				newObj=instantiate(className);
 			}
 		}
 		
@@ -4242,8 +4279,11 @@ JSON.parseRecycle=function(str){
 		,(itemOrAttr)=>{		return !isFunction(itemOrAttr);	}
 		);
 		
-		if(destination["$className"]){
-			delete destination["$className"];
+		// However we have to keep the class information attribute for further house !
+		if(destination[attributeClassName]
+			//...except if the object is a simple object :
+			 && destination[attributeClassName]=="Object"){
+			delete destination[attributeClassName];
 		}
 		
 	};
@@ -4261,6 +4301,7 @@ JSON.parseRecycle=function(str){
 
 
 window.clone=function(obj){
+	if(obj==null)	return null;
 	// OLD :
 	const str=JSON.stringifyDecycle(obj);
 	const newObj=JSON.parseRecycle(str);
@@ -4733,7 +4774,7 @@ window.isFlatMap=function(obj){
 
 window.getAsFlatStructure=function(rawObject
 		,UUID_ATTR_NAME=DEFAULT_UUID_ATTR_NAME/* Yet Another UUID */
-		,CLASSNAME_ATTR_NAME=DEFAULT_CLASSNAME_ATTR_NAME/* Yet Another Classname */
+		,CLASSNAME_ATTR_NAME=DEFAULT_CLASSNAME_ATTR_NAME/* Yet Another ClassName */
 		,POINTER_TO_ATTR_NAME=DEFAULT_POINTER_TO_ATTR_NAME/* Yet Another PointerTo */
 		){
 // Flattening :
@@ -4784,7 +4825,7 @@ function flattenGraph(root, UUID_ATTR_NAME, CLASSNAME_ATTR_NAME, POINTER_TO_ATTR
 
 window.getAsTreeStructure=function(oldMap, keepClassName=false
 		,UUID_ATTR_NAME=DEFAULT_UUID_ATTR_NAME/* Yet Another UUID */
-		,CLASSNAME_ATTR_NAME=DEFAULT_CLASSNAME_ATTR_NAME/* Yet Another Classname */
+		,CLASSNAME_ATTR_NAME=DEFAULT_CLASSNAME_ATTR_NAME/* Yet Another ClassName */
 		,POINTER_TO_ATTR_NAME=DEFAULT_POINTER_TO_ATTR_NAME/* Yet Another PointerTo */
 ){
 
@@ -4806,7 +4847,7 @@ window.restoreGraph=(flatData, keepClassName=false, UUID_ATTR_NAME, CLASSNAME_AT
 
     const objData = flatData[id];
     const className = objData[CLASSNAME_ATTR_NAME];
-    const newInstance = instanciate(className);
+    const newInstance = instantiate(className);
 
     restoredObjects[id]=newInstance; // Assign ID early to handle circular references
 
@@ -5171,7 +5212,7 @@ window.getMonoThreadedTimeout=function(actuator=null){
 
 // ======================== Routine ========================
 
-window.MonoThreadedRoutine=class {
+window.MonoThreadedRoutine=class MonoThreadedRoutine{
 	constructor(actuator,refreshMillis=null,startDependsOnParentOnly=false){
 
 		this.actuator=actuator;
@@ -5181,15 +5222,21 @@ window.MonoThreadedRoutine=class {
 		this.time=getNow();
 		this.refreshMillis=refreshMillis;
 		
-		this.durationTimeFactorHolder={durationTimeFactor:1};
+		this.managedTimeFactor=1;
 		// Three-states : started, paused, stopped.
 
 	}
 	
-	setDurationTimeFactorHolder(durationTimeFactorHolder){
-		this.durationTimeFactorHolder=durationTimeFactorHolder;
+	registerToTimeFactorManager(timeFactorManager){
+		timeFactorManager.registerTimeFactorManagee(this);
 		return this;
 	}
+	
+	changeManagedTimeFactor(newManagedTimeFactor){
+		this.managedTimeFactor=newManagedTimeFactor;
+		return this;
+	}
+	
 	isStarted(){
 		return this.started || this.startDependsOnParentOnly;
 	}
@@ -5226,7 +5273,7 @@ window.MonoThreadedRoutine=class {
 		if(!this.isStarted() || this.paused)	return;
 		// Looping index with a delay :
 		
-		const delayHasPassed=hasDelayPassed(this.time, this.refreshMillis*this.durationTimeFactorHolder.getDurationTimeFactor());
+		const delayHasPassed=hasDelayPassed(this.time, this.refreshMillis*this.managedTimeFactor);
 		if(!this.refreshMillis || delayHasPassed){
 			if(this.refreshMillis && delayHasPassed){
 				this.time=getNow();
@@ -5236,7 +5283,8 @@ window.MonoThreadedRoutine=class {
 				this.stop(args);
 				return;
 			}
-			if(this.actuator.doOnEachStep)	this.actuator.doOnEachStep(args);
+			if(this.actuator.doOnEachStep)
+				this.actuator.doOnEachStep(args);
 		}
 		
 	}
@@ -5265,19 +5313,27 @@ window.MonoThreadedGoToGoal=class {
 		this.time=getNow();
 		this.refreshMillis=refreshMillis;
 		
-		this.durationTimeFactorHolder={durationTimeFactor:1};
+		this.managedTimeFactor=1;
+		
 	
 		// Three-states : started, paused, stopped.
 	}
-	setDurationTimeFactorHolder(durationTimeFactorHolder){
-		this.durationTimeFactorHolder=durationTimeFactorHolder;
+
+	registerToTimeFactorManager(timeFactorManager){
+		timeFactorManager.registerTimeFactorManagee(this);
+		return this;
+	}
+	
+	changeManagedTimeFactor(newManagedTimeFactor){
+		this.managedTimeFactor=newManagedTimeFactor;
 		
 		// We recalculate total time-dependent values :
-		this.totalTimeMillis=this.totalTimeMillis*this.durationTimeFactorHolder.getDurationTimeFactor();
+		this.totalTimeMillis=this.totalTimeMillis*this.managedTimeFactor;
 		this.stepValue=((this.refreshMillis*(this.goalValue-this.actualValue))/this.totalTimeMillis);
 
 		return this;
 	}
+	
 	isStarted(){
 		return this.started || this.startDependsOnParentOnly;
 	}
@@ -5289,7 +5345,7 @@ window.MonoThreadedGoToGoal=class {
 	setNewGoal(goalValue, refreshMillisParam=null, totalTimeMillis=null){
 		if(Math.round(this.value)===Math.round(goalValue))	return;
 		if(refreshMillisParam)	this.refreshMillis=refreshMillisParam;
-		if(totalTimeMillis)			this.totalTimeMillis=totalTimeMillis*this.durationTimeFactorHolder.getDurationTimeFactor();
+		if(totalTimeMillis)			this.totalTimeMillis=totalTimeMillis*this.managedTimeFactor;
 
 		this.goalValue=goalValue;
 		this.stepValue=((this.refreshMillis*(this.goalValue-this.value))/this.totalTimeMillis);
@@ -5376,7 +5432,7 @@ window.MonoThreadedGoToGoal=class {
 	}
 	
 	hasDelayPassed(){
-		return (!this.time || hasDelayPassed(this.time, this.refreshMillis*this.durationTimeFactorHolder.getDurationTimeFactor()));
+		return (!this.time || hasDelayPassed(this.time, this.refreshMillis*this.managedTimeFactor));
 	}
 
 	
@@ -5402,7 +5458,7 @@ AOTRAUTILS_LIB_IS_LOADED=true;
 
 	
 
-/*utils AI library associated with aotra version : «1_29072022-2359 (09/04/2026-01:44:45)»*/
+/*utils AI library associated with aotra version : «1_29072022-2359 (02/06/2026-01:06:15)»*/
 /*-----------------------------------------------------------------------------*/
 
 
@@ -5548,11 +5604,383 @@ getOpenAIAPIClient=(modelName, apiURL, agentRole, defaultPrompt)=>{
 
 
 
-/*utils CONSOLE library associated with aotra version : «1_29072022-2359 (09/04/2026-01:44:45)»*/
+/*utils CONSOLE library associated with aotra version : «1_29072022-2359 (02/06/2026-01:06:15)»*/
 /*-----------------------------------------------------------------------------*/
 
 
-/* ## Utility methods in a javascript, for AORTAC subsystem (server & client)
+/* ## Utility methods in a javascript, for AORTAC subsystem (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.
+ * 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;	
+
+
+
+
+// ==================================================================================================================
+
+
+// AORTAC CLIENT
+
+
+
+//*********************************** AUTO-ORGANIZING REAL-TIME AORTAC CLUSTERIZATION (AORTAC) *********************************** */
+
+const AORTAC_CLIENT_FORCE_SSL_USAGE=true;
+
+// New implementation :
+
+class AORTACClientCell{
+	
+	constructor(serverCellOrigin, model, view, isNodeContext=false){
+		
+		this.clientId=getUUID();
+
+		this.model=model;
+		this.view=view;
+		this.isNodeContext=isNodeContext;
+		
+		const infos=splitURL(serverCellOrigin);
+
+		this.protocol=nonull(infos.protocol,"ws");
+		this.host=nonull(infos.host,"localhost");
+		this.port=nonull(infos.port,"30000");
+		this.usesSSL=AORTAC_CLIENT_FORCE_SSL_USAGE;
+		
+		this.startTime=null;
+		
+		this.initialClientInstance=null;
+		this.clientInstances={};
+		
+		
+		
+		this.ready=false;
+		
+		this.lobuleZone=new ClientLobule();
+
+		
+	}
+	
+	
+	start(manifestationZone){
+		
+		const self=this;
+
+
+		this.manifestationZone=manifestationZone;
+		this.startTime=getNow();
+
+		
+				
+		return new Promise((resolve,reject)=>{
+			
+			
+			// 1) Initial connection
+			self.initialClientInstance=initClient(self.isNodeContext, false, (socketToServerClientInstance, initialClientInstanceLocal)=>{
+			
+				// DBG
+				lognow("DEBUG : Starting client...");
+				
+				initialClientInstanceLocal.socketToServerClientInstance=socketToServerClientInstance;
+				
+				// INITIATE CLIENT HELLO SEQUENCE
+				self.initiateClientHelloSequence();
+				
+				// HANDLE CLIENT HELLO SEQUENCE
+				self.handleClientHelloSequence(resolve);
+
+				
+			}, self.protocol+"://"+self.host, self.port, self.usesSSL);
+			self.initialClientInstance.client.start();
+		
+		});
+	}
+	
+
+	// ===================================================================================================
+	// SEQUENCES
+	// ===================================================================================================
+
+	
+	// ==========================================================
+	// CLIENT HELLO SEQUENCE
+	
+	// 1) We send a client hello request
+	//	2) Server cell receives it and asks the blob for all servers which this client must reconnect to
+	//	(also server sends its objects corresponding to zone, if it has some of them)
+	// 3) We receive the confirmation and reconnect to all the indicated servers
+	//	4) Each concerned server cell receives it and registers the client and sends the hello confirmation
+	//	(and also the objects in the zone it had stored when trying to know if it's a concerned server or not)
+	// 5) We have all the objects, we can initialize the client model.
+	
+	
+	/*private*/initiateClientHelloSequence(){
+		// 1- We want to present ourselves to server cell :
+		const clientHelloRequest={
+			clientId:this.clientId,
+			type:"clientHello",
+			manifestationZone:this.manifestationZone
+		};
+		this.initialClientInstance.socketToServerClientInstance.send("protocol", clientHelloRequest);
+	}
+
+	/*private*/handleClientHelloSequence(resolve){
+		
+		const self=this;
+		this.initialClientInstance.socketToServerClientInstance.receive("protocol", (messageParam, clientSocket)=>{
+			
+			const message=JSON.recycle(messageParam);
+			
+			const servers=message.servers;
+			// CAUTION : THE QLC ALWAYS SENDS AT LEAST THE ROOTCONTAINER (during the «client hello» phase) !!!
+			const objects=message.objects;
+
+			lognow("DEBUG : Client received its servers :",servers);
+			lognow("DEBUG : Client received some objects :",objects);
+
+			
+			self.lobuleZone.resetServersNumbers();
+			self.lobuleZone.append(servers, "serversBag");
+			// CAUTION : THE QLC ALWAYS SENDS AT LEAST ITS ROOTCONTAINER (during the «client hello» phase) !!!
+			self.lobuleZone.append(objects);
+
+			const lobuleObjects=self.lobuleZone.getObjects();
+			if(!servers || empty(servers)){
+				// TRACE
+				lognow("ERROR : Servers blob sent no servers to reconnect to. Aborting.");
+				// (We only return the structural object, ie. the root container :)
+				resolve(lobuleObjects);
+				return;
+			}
+			
+			if(empty(servers)){
+				// TRACE
+				lognow("ERROR : No servers to connect to. Aborting (not initiaing the reconnection sequence).");
+				// (We only return the structural object, ie. the root container :)
+				resolve(lobuleObjects);
+				return;
+			}
+			
+			// 2) Re-connections :
+			foreach(servers, serverOrigin=>{
+				
+				const infos=splitURL(serverOrigin);
+
+				const protocol=nonull(infos.protocol,"ws");
+				const host=nonull(infos.host,"localhost");
+				const port=nonull(infos.port,"30000");
+				const usesSSL=AORTAC_CLIENT_FORCE_SSL_USAGE;
+				
+				const reconnectedClientInstance=initClient(self.isNodeContext, false, (socketToServerClientInstance, reconnectedClientInstanceLocal)=>{
+				
+					// DBG
+					lognow("DEBUG : Starting reconnected client...");
+					
+					reconnectedClientInstanceLocal.socketToServerClientInstance=socketToServerClientInstance;
+					
+					// INITIATE CLIENT RECONNECTED HELLO SEQUENCE
+					self.initiateReconnectedClientHelloSequence(reconnectedClientInstance);
+					
+					// HANDLE CLIENT RECONNECTED HELLO SEQUENCE
+					self.handleReconnectedClientHelloSequence(reconnectedClientInstance, resolve)
+	
+					
+				}, protocol+"://"+host, port, usesSSL);
+				
+				self.clientInstances[serverOrigin]=reconnectedClientInstance;
+				reconnectedClientInstance.client.start();
+			});
+			
+			
+		},{listenerMessageType:"clientHello.response"});
+
+	}
+	
+	// ----
+	// RECONNECTED CLIENT HELLO SEQUENCE
+	
+
+	/*private*/initiateReconnectedClientHelloSequence(clientInstance){
+		
+		// We want to present ourselves to server cell :
+		const reconnectedClientHelloRequest={
+			clientId:this.clientId,
+			type:"reconnectedClientHello"
+		};
+		clientInstance.client.socketToServerClientInstance.send("protocol", reconnectedClientHelloRequest);
+		
+	}
+						
+	/*private*/handleReconnectedClientHelloSequence(clientInstance, resolve){
+		
+
+		const self=this;
+
+		clientInstance.client.socketToServerClientInstance.receive("protocol", (messageParam, clientSocket)=>{
+			
+			const message=JSON.recycle(messageParam);
+
+			const objects=message.objects;
+			
+			if(!objects || empty(objects)){
+				// TRACE
+				lognow("ERROR : This server cell sent no objects. Continuing.");
+				
+				// DBG
+				lognow("DEBUG : !!!!!!!!!!!!! message:",message);
+				
+			}
+			
+			lognow("DEBUG : Client received some objects :",objects);
+			
+			// We accumulate the received objects in the lobule zone :
+			self.lobuleZone.append(objects, "objectsBag");
+			
+			self.lobuleZone.incrementContactedServersNumber();
+			
+			
+			// DBG
+			lognow("DEBUG : !!!!!!!!!!!!! self.lobuleZone.getObjects():",self.lobuleZone.getObjects());
+
+			
+			if(self.lobuleZone.hasReceivedFromAllServers()){
+				
+				const lobuleObjects=self.lobuleZone.getObjects();
+				if(!lobuleObjects || empty(lobuleObjects)){
+					// TRACE
+					lognow("ERROR : No objects at all accumulated from server cells blob. Aborting.");
+					resolve(null);
+					return;
+				}
+				
+//			const allClientModelObjectsByClassName=self.sortByClassName(lobuleObjects);
+				const allClientModelObjects=lobuleObjects;
+	
+				//DBG
+//			lognow("DEBUG : allClientModelObjectsByClassName : ",allClientModelObjectsByClassName);
+				lognow("DEBUG : allClientModelObjects : ",allClientModelObjects);
+
+				if(empty(allClientModelObjects)){
+					// TRACE
+					lognow("ERROR : Servers blob sent no game level. Aborting.");
+					resolve(allClientModelObjects);
+					return;
+				}
+				
+				// DBG
+				lognow("DEBUG : Client received its model objects:",message.objects);
+//			lognow("DEBUG : Client received its model objects (after sorting):",allClientModelObjectsByClassName);
+				
+				// DBG
+				lognow("DEBUG : Client has received all its objects from the servers cells blob: ");
+				
+				resolve(allClientModelObjects);
+			}
+
+			
+		},{listenerMessageType:"reconnectedClientHello.response"});
+
+	}
+	
+	
+	
+	// ================================================================================
+
+	
+
+	
+}
+
+
+
+
+class ClientLobule{
+	
+	constructor(){
+		this.serversBag=null;
+		this.objectsBag=null;
+		this.numberOfContactedServers=0;
+		this.totalNumberOfServersToContact=0;
+		this.clear();
+	}
+	append(objs, attributeName="objectsBag"){
+		const self=this;
+		if(!this[attributeName])
+			this[attributeName]=[];
+		foreach(objs,obj=>{
+			self[attributeName].push(obj);
+		},(obj)=>(!contains(this[attributeName], obj)));
+		if(attributeName=="serversBag")
+			this.totalNumberOfServersToContact+=objs.length;
+	}
+	getObjects(filterFunction=null){
+		if(!filterFunction)	return this.objectsBag;
+		if(!this.objectsBag)	return null;
+		const results=[];
+		foreach(this.objectsBag, (obj)=>{
+			results.push(obj);
+		},filterFunction);
+		return results;
+	}
+	getServers(){
+		if(!this.serversBag)	return null;
+		return this.serversBag;
+	}
+	clear(attributeName=null){
+		if(!attributeName){
+			this.serversBag=[];
+			this.objectsBag=[];
+		}else{
+			this[attributeName]=[];
+		}
+		this.resetServersNumbers();
+		return this;
+	}
+	resetServersNumbers(){
+		this.numberOfContactedServers=0;
+		this.totalNumberOfServersToContact=0;
+	}
+	incrementContactedServersNumber(increment=1){
+		this.numberOfContactedServers+=increment;
+	}
+	hasReceivedFromAllServers(){
+		return (this.totalNumberOfServersToContact<=this.numberOfContactedServers);
+	}
+}
+
+
+
+
+
+
+window.getAORTACClient=function(serverCellOrigin="ws://127.0.0.1:40000", model, view, isNodeContext=false){
+	if(nothing(serverCellOrigin)){
+		// TRACE
+		lognow("ERROR : No known server node, cannot connect to servers cells blob. Aborting AORTAC client setup.");
+		return null;
+	}
+	return new AORTACClientCell(serverCellOrigin, model, view, isNodeContext);
+}
+
+
+
+/* ## Utility methods in a javascript, for AORTAC subsystem (server)
  *
  * 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.
@@ -5585,8 +6013,8 @@ if(typeof(window)==="undefined")	window=global;
 
 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}){
@@ -5599,14 +6027,14 @@ class AORTACServerCell{
 		const infos=splitURL(this.selfOrigin);
 		
 		//DBG
-		lognow("infos:::::::::::::",infos);
+		lognow("(SERVER) infos:::::::::::::",infos);
 		
 		this.protocol=nonull(infos.protocol,"ws");
 		this.host=nonull(infos.host,"localhost");
 		this.port=nonull(infos.port,"30000");
 		this.sslConfig=sslConfig;
 
-		this.server=null;
+		this.serverWrapper=null;
 		this.incomingCells={};
 		
 		this.outcomingCellsOrigins=outcomingCellsOrigins;
@@ -5624,20 +6052,26 @@ class AORTACServerCell{
 		};
 
 		this.cellsOverview={};
+		this.numberOfPartitions=null;
+		this.partitionId=null;
+		
+		this.isServerCellQuorumLastCell=false;
 		
 		this.startTime=null;
 		
 		this.quorumIsReachedSequenceIsInitiated=false;
 //	this.quorumCells=null; // (CAUTION : only the latest ready cell when quorum is reached has this attribute populated)
 
-		this.liveModelObjects={};
+		this.lobuleZone=new ServerCellLobule();
+		
+		this.clients={};
 
 	}
 
 	start(){
 
 		this.startTime=getNow();
-		this.server=this.launchServerForIncomingConnections();
+		this.serverWrapper=this.launchServerForIncomingConnections();
 
 		if(empty(this.outcomingCellsOrigins) || (getArraySize(this.outcomingCellsOrigins)==1 && contains(this.outcomingCellsOrigins, this.selfOrigin))){
 			// TRACE
@@ -5654,37 +6088,72 @@ class AORTACServerCell{
 		return this;
 	}
 	
+	
+	// ===================================================================================================
+	// SERVER CELL CORE
+	// ===================================================================================================
+	
 	/*private*/launchServerForIncomingConnections(){
 		const self=this;
 		
-		const server=initNodeServerInfrastructureWrapper(
+		const serverWrapper=initNodeServerInfrastructureWrapper(
 			// On each client connection :
 			null,
 			// On client finalization :
 			function(server){
 				
+				
+				const channelsNames=[];
+				foreach(Object.keys(self.onReceiveMessageListeners["incoming"]), channelName=>{channelsNames.push(channelName);}, channelName=>!contains(channelsNames,channelName));
+				foreach(Object.keys(self.onReceiveMessageListeners["both"]), channelName=>{channelsNames.push(channelName);}, channelName=>!contains(channelsNames,channelName));
+				
+				
 				// 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=>{
+				foreach(channelsNames, channelName=>{
 					server.receive(channelName, (message, clientSocket)=>{
+
+						// DBG
+						lognow("DEBUG : Server cell receives message from incoming...");
+						
+						self.executeListeners("incoming", channelName, message, clientSocket);
+
+						// DBG
+						lognow("DEBUG : Server cell receives message from both (in)...");
+						
 						self.executeListeners("both",channelName, message, clientSocket);
 					});
 				});
 				
 				
-				// HANDLE HELLO SEQUENCE
-				self.handleHelloSequence();
+				// HANDLE SERVER CELL HELLO SEQUENCE
+				self.handleServerCellHelloSequence();
+				
+				
+				// ******************************************
+				// CLIENT
 				
-		}, this.port, this.sslConfig.certPath, this.sslConfig.keyPath);
-		server.serverManager.start();
-		return server;
+				// HANDLE CLIENT HELLO SEQUENCE
+				self.handleClientHelloSequence();
+				
+				
+		},
+		// On client connection lost :
+		(clientId)=>{
+			lognow(`INFO : Connection to client id «${clientId}» was lost.`);
+			// TRACE
+			lognow(`INFO : Removing client information for client id «${clientId}».`);
+			self.lobuleZone.remove(clientId);
+		},
+		this.port, this.sslConfig.certPath, this.sslConfig.keyPath);
+
+		serverWrapper.serverManager.start();
+		return serverWrapper;
 	}
 	
 	/*private*/probeOutcomingNetwork(){
+		
+		const self=this;
+		
 		const numberOfTotalServers=getArraySize(this.outcomingCells);
 		let numberOfConnectedOutcomingServers=0;
 		foreach(this.outcomingCells, outcomingCell=>{
@@ -5706,7 +6175,6 @@ class AORTACServerCell{
 			return;
 		}
 
-		const self=this;
 		
 		// We try to connect to all outcoming cells : 
 		foreach(this.outcomingCells, (outcomingCell, outcomingCellOrigin)=>{
@@ -5718,20 +6186,29 @@ class AORTACServerCell{
 			
 			const clientInstance=initClient(true, false, (socketToServerClientInstance)=>{
 				
+				
+				const channelsNames=[];
+				foreach(Object.keys(self.onReceiveMessageListeners["outcoming"]), channelName=>{channelsNames.push(channelName);}, channelName=>!contains(channelsNames,channelName));
+				foreach(Object.keys(self.onReceiveMessageListeners["both"]), channelName=>{channelsNames.push(channelName);}, channelName=>!contains(channelsNames,channelName));
+
+				
 				// On-receive message listeners handling ;
-				foreach(Object.keys(self.onReceiveMessageListeners["outcoming"]), channelName=>{
+				foreach(channelsNames, channelName=>{
 					socketToServerClientInstance.receive(channelName, (message, clientSocket)=>{
+
+						// DBG
+						lognow("DEBUG : Server cell receives message from outcoming...");
+
 						self.executeListeners("outcoming",channelName, message, clientSocket);
-					});
-				});
-				foreach(Object.keys(self.onReceiveMessageListeners["both"]), channelName=>{
-					socketToServerClientInstance.receive(channelName, (message, clientSocket)=>{
+
+						// DBG
+						lognow("DEBUG : Server cell receives message from both (out)...");
+
 						self.executeListeners("both",channelName, message, clientSocket);
 					});
 				});
-
 				
-				// INITIATE HELLO SEQUENCE
+				// INITIATE SERVER CELL HELLO SEQUENCE
 				self.initiateHelloSequence(socketToServerClientInstance);
 
 				// We are connected: 				
@@ -5755,47 +6232,68 @@ class AORTACServerCell{
 		
 	}
 	
-	
 	/*private*/handleCommonListeners(){
-		
 		// HANDLE CELL IS READY SEQUENCE
 		this.handleCellIsReadySequence();
-		
 		// HANDLE PARTITION SEQUENCE
 		this.handlePartitionSequence();
 		
-	}
+		
+		// ******************************************
+		// CLIENT
+		// HANDLE CLIENT MODEL INITIAL POPULATION SEQUENCE
+		this.handleGetServersForZoneRequest();
+		
+		// HANDLE RECONNECTED CLIENT HELLO SEQUENCE
+		this.handleReconnectedClientHelloSequence();
 
+	}
+	
 	
 	/*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));
-		});
-		
+		const self=this;
+		foreach(onReceiveMessageListeners, (listener, listenerMessageType)=>{
+			listener.execute(self, message, self.serverWrapper, clientSocket);
+		},(listener)=>(message.type===listener.listenerMessageType));
+		
+	}
+	
+	
+	/*private*/replyToBlobRequest(channelName, originalMessage, message){
+		if(!message.originatingCellOrigin)
+			message.originatingCellOrigin=originalMessage.originatingCellOrigin;
+		if(!message.originatingPartitionId)
+			message.originatingPartitionId=originalMessage.originatingPartitionId;
+		if(!message.clientId)
+			message.clientId=originalMessage.clientId;
+		return this.sendMessageToBlob(channelName, message, 
+						{
+							isOriginatingCell:false,
+							destinationCellsOrigins:[originalMessage.originatingCellOrigin],
+							excludeIncomingServersCellsAndClientsInTransmission:true,
+							isRequest:false
+						},
+						originalMessage.type+".response");
 	}
 	
 	
 	/*private*/sendMessageToBlob(channelName, message, 
-				broadcastConfig={isOriginatingCell:false, destinationCellsOrigins:null, includeIncomingConnectionInTransmission:false, isRequest:false}){
+				broadcastConfig={
+					isOriginatingCell:false,
+					destinationCellsOrigins:null,
+					excludeIncomingServersCellsAndClientsInTransmission:true, 
+					isRequest:false,
+					contactAllQuorumBlob:false
+				},
+				overridingMessageType=null){
 	
-		const self=this;
-			
 		if(broadcastConfig){
 			if(broadcastConfig.isOriginatingCell){
 				message.originatingCellOrigin=this.selfOrigin;
+				message.originatingPartitionId=this.partitionId;
 			}
 			if(broadcastConfig.isRequest){
 				message.isRequest=true;
@@ -5808,10 +6306,36 @@ class AORTACServerCell{
 		if(!message.visitedCells)
 			message.visitedCells=[];
 		else if(contains(message.visitedCells,this.selfOrigin))
-			return;
+			return null;
 		message.visitedCells.push(this.selfOrigin);
 		
-		if(broadcastConfig && broadcastConfig.includeIncomingConnectionInTransmission){
+
+		// AUTOMATIC LISTENER SETUP :
+		const messageTypeForResponse=nonull(overridingMessageType, message.type+".response");
+		let blobResponseListener=null;
+		// We only add a result listener for the one cell which sent the request message (we skip the listener adding for the others in this case) :
+		if(message.isRequest && message.originatingCellOrigin==this.selfOrigin 
+			//&& (typeof(message.result)=="undefined" || message.result==null)
+		){
+			// To emulate a promise-like behavior :
+			blobResponseListener=this.getBlobResponseListenerForRequest(message, channelName, broadcastConfig, messageTypeForResponse);
+		
+			const outletName=nonull(blobResponseListener.outletName,"both");
+			if(!this.onReceiveMessageListeners[outletName][channelName][blobResponseListener.listenerMessageType]){
+				this.onReceiveMessageListeners[outletName][channelName][blobResponseListener.listenerMessageType]=blobResponseListener;
+				// TRACE
+				lognow("INFO : Added automatic listener for message type «"+blobResponseListener.listenerMessageType+"».");
+			}else{
+				// TRACE
+				lognow("INFO : Listener for message type «"+blobResponseListener.listenerMessageType+"» already existed. Done nothing.");
+			}
+		}else{
+			// TRACE
+			lognow(`INFO : No listener to setup, because broadcast is not a request, or cell is not the originating cell !`);
+		}
+		
+		// SENDING
+		if(broadcastConfig && !broadcastConfig.excludeIncomingServersCellsAndClientsInTransmission){
 			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);
@@ -5819,7 +6343,6 @@ class AORTACServerCell{
 						(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);
@@ -5827,49 +6350,84 @@ class AORTACServerCell{
 					(outcomingCell.connected && !contains(message.visitedCells, outcomingCellOrigin))
 		);
 		
+		return blobResponseListener;
+	}
+	
+	
+	/*private*/getBlobResponseListenerForRequest(message, channelName, broadcastConfig, messageTypeForResponse){
+	
+		const outletName="both"; // «incoming» & «outcoming»
+		// We want to monitor when the server cell receives the RESPONSE of the message it sent as request !!!
+	
+		// First we check if the listener for request already exists :
+		let blobResponseListener=this.onReceiveMessageListeners[outletName][channelName][messageTypeForResponse];
+		if(blobResponseListener){
+			// TRACE
+			lognow(`INFO : Blob response listener for cell ${this.selfOrigin} on channel ${channelName} for message type «${messageTypeForResponse}» already exists.`);
+			return blobResponseListener;
+		}
 		
-		// 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);
+	
+		blobResponseListener={
+			broadcastConfig:broadcastConfig,
+			thenCallback:null,
+			allBlobHasBeenContactedCallback:null,
+			hasAllBlobBeenContacted:false,
+			// We use the partition ids to know which server cells have been contacted :
+			partitionIdsThatCouldBeContacted:[],
+			// This message will be the RESPONSE to the REQUEST (ti will be of type «<messageTypeForResponse>», meaning the request message type + «.response» !!)
+			outletName:outletName,
+			listenerMessageType:messageTypeForResponse,
+			execute:(selfParam, messageParam, serverWrapper, clientSocket)=>{
+				
+				// This is what the requesting cell does every time any cell that is not the requesting cell sends back a response to its request to blob :
+				
+				// When we have received the message  :
+				if(blobResponseListener.thenCallback)	blobResponseListener.thenCallback(selfParam, messageParam);
+				
+				// We try to determine if the whole blob has been contacted or not :
+				if(blobResponseListener.broadcastConfig.contactAllQuorumBlob && !blobResponseListener.hasAllBlobBeenContacted){
 					
-					// We need to remove the result listener once it is completed though. 
-					delete blobResponseListeners["forRequestsIssuedBySelf"];
-				},
-				then:(thenCallback)=>{
-					this.thenCallback=thenCallback;
+					if(!contains(blobResponseListener.partitionIdsThatCouldBeContacted, messageParam.originatingPartitionId))
+						blobResponseListener.partitionIdsThatCouldBeContacted.push(messageParam.originatingPartitionId);
+					// We need to exclude the current serevr cell itself :
+					if(selfParam.numberOfPartitions-1<=blobResponseListener.partitionIdsThatCouldBeContacted.length){
+						if(blobResponseListener.allBlobHasBeenContactedCallback)
+							blobResponseListener.allBlobHasBeenContactedCallback(selfParam, messageParam);
+						blobResponseListener.hasAllBlobBeenContacted=true;
+					}
 				}
-			};
-			blobResponseListeners["forRequestsIssuedBySelf"]=blobResponseListener;
-			
-			return blobResponseListener;
-		}else{
-			return null;
-		}
+				
+				// We need to remove the result listener once it has been completed though. 
+				if(!blobResponseListener.broadcastConfig.contactAllQuorumBlob || blobResponseListener.hasAllBlobBeenContacted){
+					//UNUSEFUL : delete blobResponseListeners[listenerTypeForRequest];
+					delete selfParam.onReceiveMessageListeners[outletName][channelName][messageTypeForResponse];
+				}
+				
+			},
+			thenOnAnyResponseFromBlobRequestingCellOnly:(thenCallback)=>{
+				blobResponseListener.thenCallback=thenCallback;
+				return blobResponseListener;
+			},
+			doOnceAllBlobHasBeenContacted:(allBlobHasBeenContactedCallback)=>{
+				blobResponseListener.allBlobHasBeenContactedCallback=allBlobHasBeenContactedCallback;
+				return blobResponseListener;
+			},
+		};
 		
+		
+		
+		return blobResponseListener;
 	}
+
+
 	
+	// ===================================================================================================
+	// SERVER CELLS
+	// ===================================================================================================
 	
 	// ==========================================================
-	// HELLO SEQUENCE
+	// SERVER CELL HELLO SEQUENCE
 	
 	/*private*/initiateHelloSequence(socketToServerClientInstance){
 
@@ -5882,28 +6440,30 @@ class AORTACServerCell{
 	}
 
 
-	/*private*/handleHelloSequence(){
+	/*private*/handleServerCellHelloSequence(){
 		
 		// 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)=>{
+		this.onReceiveMessageListeners["both"]["protocol"]["helloRequest"]={
+			execute:(selfParam, messageParam, serverWrapper, clientSocket)=>{
 	
-				const cellOriginToCheck=message.originatingCellOrigin;
+				const cellOriginToCheck=messageParam.originatingCellOrigin;
 					
 				// TRACE
-				lognow(`INFO : Incoming node ${cellOriginToCheck} has said hello. Updating its local information...`);
+				lognow(`INFO : (handleServerCellHelloSequence()) Incoming node ${cellOriginToCheck} has said hello. Updating its local information...`);
 		
 					
 				selfParam.incomingCells[cellOriginToCheck]={
 					connected:true,
-					server:server,
+					server:serverWrapper.server,
 					// DO NOT USE TO SEND/RECEIVE ANYTHINIG !
 					// For this, use the server attribute (+ the clientSocket as argument) instead.
 					clientSocket:clientSocket,
 				};
 
-						},
+				
+				// NO SERVER CELL HELLO CONFIRMATION SENT BACK TO THE OTHER SERVER CELL (to save time)
+				
+			},
 			listenerMessageType:"helloRequest"
 		};
 		
@@ -5928,18 +6488,14 @@ class AORTACServerCell{
 	}
 
 	/*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);
+		this.onReceiveMessageListeners["both"]["protocol"]["cellIsReady"]={
+
+			execute:(selfParam, messageParam, serverWrapper, clientSocket)=>{
+
+				selfParam.cellsOverview[messageParam.originatingCellOrigin]={ready:true,startTime:messageParam.startTime};
 				
-//			// 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));
+				selfParam.sendMessageToBlob("protocol",messageParam);
 				
 				// INITIATE QUORUM IS REACHED SEQUENCE
 				selfParam.initiateQuorumIsReachedSequenceIfNecessary();
@@ -5965,11 +6521,11 @@ class AORTACServerCell{
 		const quorumCells=copy(this.cellsOverview);
 		
 		// TRACE
-		lognow("INFO : Quorum is reached and this is the latest started cell. quorumCells :",quorumCells);
-		
-		this.initializeModel(quorumCells);
-		
-		
+		lognow("INFO : Quorum is reached and this is the latest started cell (QLC). quorumCells:",quorumCells);
+
+		this.isServerCellQuorumLastCell=true;
+
+		this.launchModelPartitionBlobSequence(quorumCells);
 
 	}
 	
@@ -5980,249 +6536,694 @@ class AORTACServerCell{
 	// ==========================================================
 	// MODEL MANAGEMENT
 
-	/*private*/initializeModel(quorumCells){
-		
-		const self=this;
-		
-		const numberOfPartitions=getArraySize(quorumCells);
+	/*private*/async launchModelPartitionBlobSequence(quorumCells){
+		
+		const self=this;
+		
+		this.numberOfPartitions=getArraySize(quorumCells);
+		
+		const controller=this.controller;
+//		const model=this.model;
+		
+		const partitionsInstantiationZones=controller.getPartitionsZones(this.numberOfPartitions);
+
+		const firstPartitionZone=getAt(partitionsInstantiationZones,0);
+		
+		// We populate and initialize the server cell model, using the first partition zone :
+		const model=await this.doOnModelZonePartitionReception(firstPartitionZone, this.selfOrigin);
+		
+		// DBG
+		lognow("DEBUG : MODEL WAS JUST CREATED.");
+
+		// We send the models partition zones objects to the required cells :
+		const qlcRootContainer=self.partiallyPopulatedRootContainer();
+		
+		let i=1;
+		foreach(quorumCells, (quorumCell, quorumCellOrigin)=>{
+
+			const modelPartitionZone=getAt(partitionsInstantiationZones,i);
+			
+			const message={qlcOrigin: self.selfOrigin, qlcRootContainer:qlcRootContainer, type:"modelPartitionZone", partitionZone:modelPartitionZone};
+
+			// TRACE
+			lognow(`INFO : Server cell ${self.selfOrigin} is sending a partition zone to server cell ${quorumCellOrigin}...`, message);
+			
+			self.sendMessageToBlob("protocol", message, 
+							{isOriginatingCell:true, destinationCellsOrigins:[quorumCellOrigin],
+							excludeIncomingServersCellsAndClientsInTransmission:true, 
+							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(){
+		
+		// CAUTION : For *non-QLC* server cells only :
+		
+		// 2- We wait to receive the hello request of the incoming cell connection :
+		this.onReceiveMessageListeners["both"]["protocol"]["modelPartitionZone"]={
+			execute:(selfParam, messageParam, serverWrapper, 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)){
+					
+					// We populate and initialize the server cell model :
+					selfParam.doOnModelZonePartitionReception(messageParam.partitionZone, messageParam.qlcOrigin, messageParam.qlcRootContainer).then(model=>{
+						
+					});
+				}	
+
+			},
+			listenerMessageType:"modelPartitionZone"
+		};
+		
+	}
+	
+	
+	/*private*/doOnModelZonePartitionReception(partitionZone, qlcOrigin, qlcRootContainer=null){
+
+		return new Promise((resolve,reject)=>{
+			
+			// TRACE
+			lognow(`INFO : Applying partition zone for cell ${this.selfOrigin}. Updating local server model...`);
+			lognow(`DEBUG : partitionZone:`, partitionZone);
+			
+			this.partitionId=partitionZone.id;
+	
+			// TRACE
+			lognow("INFO : Populating model for this partition zone...");
+			
+			if(this.isServerCellQuorumLastCell){ // Case QLC :
+			
+				// DBG			
+				lognow("DEBUG : (this cell is the last quorum server cell (QLC)) ");
+						
+				// We initialize the portion of the model :
+				// (controller will handle if a persisted model already exists)
+				// (in this particular case, qlcOrigin and this.selfOrigin is exactly the same !)
+				this.controller.populateModelInZone(this.model, partitionZone, getHashedString(qlcOrigin), getHashedString(this.selfOrigin) ).then((model)=>{
+		
+					// DBG
+					lognow("DEBUG : model is populated in QLC server cell.");
+					
+					resolve(model);
+				});
+				
+			}else{ // Case NON-QLC :
+				
+					
+				// BASICALLY IT'S THE EXACT SAME TREATMENT AS FOR A BLOB CLIENT !
+				
+				// DBG			
+				lognow("DEBUG : (this cell is *NOT* last quorum server cell (NON-QLC)) ");
+				
+				
+				// We initialize the portion of the model :
+				// (controller will handle if a persisted model already exists)
+				this.controller.populateModelInZone(this.model, partitionZone, getHashedString(qlcOrigin), getHashedString(this.selfOrigin), qlcRootContainer ).then((model)=>{
+
+					// DBG			
+					lognow("DEBUG : model is populated in NON-QLC server cell.");
+					
+					resolve(model);
+				});
+				
+			}
+			
+		
+		});
+
+	}
+
+
+	// ===================================================================================================
+	// CLIENT
+	// ===================================================================================================
+
+	// ==========================================================
+	// HANDLE CLIENT HELLO SEQUENCE
+
+	handleClientHelloSequence(){
+		
+			// We wait to receive the hello request of the incoming client connection :
+			this.onReceiveMessageListeners["incoming"]["protocol"]["clientHello"]={
+				execute:(selfParam, messageParam, serverWrapper, clientSocket)=>{
+
+					const clientId=messageParam.clientId;
+					const manifestationZone=messageParam.manifestationZone;
+
+					// TRACE
+					lognow(`INFO : (handleClientHelloSequence()) Incoming client ${clientId} has said hello. Starting its reconnection sequence...`);
+
+					// We send the servers on which the client must reconnect to :
+					
+					// Init lobule :
+					selfParam.lobuleZone.clear(clientId);
+					selfParam.lobuleZone.setClientConnectionInfo(clientId, serverWrapper, clientSocket);
+					
+					// Caution : client must ignore this server cell if it has no objects for it !
+					let allObjectsCorrespondingToZoneInServerCell=[];
+					try{
+						selfParam.model.checkAllMethodsCustomModelClassPrerequisites();
+						allObjectsCorrespondingToZoneInServerCell=selfParam.model.getAllPartitionnableObjectsInZone(manifestationZone);
+					}catch(e){
+						//TRACE
+						lognow(e);
+					}
+					
+					if(!empty(allObjectsCorrespondingToZoneInServerCell)){
+						selfParam.lobuleZone.append(clientId, [selfParam.selfOrigin], "serversBag");
+						selfParam.lobuleZone.append(clientId, allObjectsCorrespondingToZoneInServerCell);
+					}else{
+						// TRACE
+						lognow("INFO : Server cell has no relevant objects to send to client");
+					}
+
+					// The QLC in all cases, sends its structural objects to client :
+					if(selfParam.isServerCellQuorumLastCell){
+						// Case this server cell is the QLC :
+						const rootContainer=selfParam.partiallyPopulatedRootContainer(allObjectsCorrespondingToZoneInServerCell);
+						// Then we send the structure and, if any, the concerned objects in client manifestation zone of this server cell :
+						selfParam.lobuleZone.append(clientId, [rootContainer]);
+					}
+					
+					// At this point , in the QLC server cell's lobule zone for this client we have : 
+					// (- maybe its concerned zone objects.)
+					// - its root container
+					
+
+					// We ask the blob
+					selfParam.sendMessageToBlob("protocol", {type:"getServersForZone", clientId:clientId, manifestationZone:manifestationZone}, 
+									{isOriginatingCell:true,
+									excludeIncomingServersCellsAndClientsInTransmission:true,
+									isRequest:true,
+									contactAllQuorumBlob:true})
+					.thenOnAnyResponseFromBlobRequestingCellOnly((selfParam2, messageParamLocal)=>{
+						// Triggered every time this server cell receives a response to its request from blob :
+						
+						const clientIdLocal=messageParamLocal.clientId;
+						const answeringServerOrigin=messageParamLocal.answeringServerOrigin;
+						const objectsCount=messageParamLocal.objectsCount;
+						
+						// DBG
+						lognow("DEBUG : This server cell has received a response from another server cell : answeringServerOrigin:",answeringServerOrigin);
+						
+						// When another server cells answers to this server cell :
+						
+						if(!objectsCount || objectsCount<=0){
+							// TRACE
+							lognow("INFO : No objects corresponding to this zone to send to collector server cell. This server cell must be ignored.");
+						}else{
+							// We accumulate the server origin in the lobule :
+							selfParam2.lobuleZone.append(clientIdLocal, [answeringServerOrigin], "serversBag");
+						}
+						
+						
+					}).doOnceAllBlobHasBeenContacted((selfParam2, messageParamLocal)=>{
+						
+						// Triggered once the requesting server cell has received the response from the last possible other server cell, according to the partition ids !
+						
+						const clientIdLocal=messageParamLocal.clientId;
+						
+						// At this point we should have all the needed servers in the lobule :
+						const servers=selfParam2.lobuleZone.getServers(clientIdLocal);
+						// CAUTION : THE QLC ALWAYS SENDS AT LEAST THE ROOTCONTAINER (during the «client hello» phase) !!!
+						const objects=selfParam2.lobuleZone.getObjects(clientIdLocal);
+
+						// ???
+//					if(!empty(objects)){
+//						selfParam2.removeLinks(objects);
+//					}
+
+						// CAUTION : THE QLC ALWAYS SENDS AT LEAST THE ROOTCONTAINER (during the «client hello» phase) !!!
+						const messageWrapped=JSON.decycle({type:"clientHello.response", servers:servers, objects:objects});
 
-		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);
+						// DBG
+						lognow("DEBUG : All blob has been contacted : messageWrapped:",messageWrapped);
+						
+						// We send back all the collected servers to the requesting client :
+						const clientConnectionInfo=selfParam2.lobuleZone.getClientConnectionInfo(clientIdLocal);
+						clientConnectionInfo.serverWrapper.server.send("protocol", messageWrapped, null, clientConnectionInfo.clientSocket);
 
-		// 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)=>{
+						selfParam2.lobuleZone.clear(clientIdLocal);
+						
+					});
+					
 
-			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});
+				},
+				listenerMessageType:"clientHello"
+			};
 			
-			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(){
+	// This is what other cells do when they receive a request for «getServersForZone» from a cell in the blob
+	/*private*/handleGetServersForZoneRequest(){
 		
-		// 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)=>{
+		this.onReceiveMessageListeners["both"]["protocol"]["getServersForZone"]={
+			execute:(selfParam, messageParam, serverWrapper, clientSocket)=>{
+				
+				// DBG
+				lognow("DEBUG : handleGetServersForZoneRequest() : messageParam", messageParam);
+				
+				const clientId=messageParam.clientId;
+				const manifestationZone=messageParam.manifestationZone;
+				
+				// When we receive a request from a server cell :
+				let allObjectsCorrespondingToZoneInServerCell=[];
+				try{
+					selfParam.model.checkAllMethodsCustomModelClassPrerequisites();
+					allObjectsCorrespondingToZoneInServerCell=selfParam.model.getAllPartitionnableObjectsInZone(manifestationZone);
+				}catch(e){
+					// TRACE
+					lognow(e);
+				}
+				
+				// We store the objects for this client, because we know it will very soon ask them :
+				// Init lobule :
+				selfParam.lobuleZone.clear(clientId);
+				selfParam.lobuleZone.setClientConnectionInfo(clientId, serverWrapper, clientSocket);
+				
+				selfParam.lobuleZone.append(clientId, allObjectsCorrespondingToZoneInServerCell);
+				
 
-				// 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);
+				const message={type:"getServersForZone.response", objectsCount:allObjectsCorrespondingToZoneInServerCell.length, answeringServerOrigin:selfParam.selfOrigin};
 				
-				if(contains(messageParam.destinationCellsOrigins,selfParam.selfOrigin)){
-					
-					const message=JSON.recycle(messageParam);
-					
-					selfParam.doOnModelPartitionReception(message.partition);
-					
-				}	
+				// TRACE
+				lognow(`INFO : Server cell ${selfParam.selfOrigin} is sending its origin to server cell ${messageParam.originatingCellOrigin}...: message:`, message);
 
-			},
-			listenerMessageType:"modelPartition"
+				selfParam.replyToBlobRequest("protocol", messageParam, message);
+			},listenerMessageType:"getServersForZone"
 		};
 		
 	}
 	
 	
-	/*private*/doOnModelPartitionReception(partition){
-
-		// TRACE
-		lognow(`INFO : Incoming partition for cell ${this.selfOrigin}. Updating local model...`,partition);
-		lognow(`>>>>`,stringifyObject(JSON.decycle(partition.objects),1));
+	// ----
+	// HANDLE RECONNECTED CLIENT HELLO SEQUENCE
+	handleReconnectedClientHelloSequence(){
 		
+		// Here we only want to collect the servers on which to reconnect to later :
 		
+		// 2- We wait to receive the hello request of the incoming client connection :
+		this.onReceiveMessageListeners["incoming"]["protocol"]["reconnectedClientHello"]={
+			execute:(selfParam, messageParam, serverWrapper, clientSocket)=>{
+
+				const clientId=messageParam.clientId;
+					
+				// TRACE
+				lognow(`INFO : Incoming reconnected client ${clientId} has said hello. Updating its local information...`);
+
+				selfParam.clients[clientId]={
+					connected:true,
+					server:serverWrapper,
+					// DO NOT USE TO SEND/RECEIVE ANYTHINIG !
+					// For this, use the server attribute (+ the clientSocket as argument) instead.
+					clientSocket:clientSocket,
+				};
+
+				const objects=selfParam.lobuleZone.getObjects(clientId);
+									
+				// RECONNECTED CLIENT HELLO CONFIRMATION
+				
+				
+				const messageResponse={type:"reconnectedClientHello.response", objects:objects};
+				const messageResponseWrapped=JSON.decycle(messageResponse);
+
+				// DBG
+				lognow("DEBUG : Sending «reconnectedClientHello.response»...");
+								
+				serverWrapper.server.send("protocol", messageResponseWrapped, null, clientSocket);
+
+				selfParam.lobuleZone.clear(clientId);
+				
+			},
+			listenerMessageType:"reconnectedClientHello"
+		};
+			
 		
 	}
 	
 
-	/*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){
+
+	// 	???
+	//	/*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)));
+	//	}
 		
-		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){
+	// **********************************************************************
+	
+	/*private*/partiallyPopulatedRootContainer(allObjectsCorrespondingToZoneInServerCell=[]){
 		
-		////
-		lognow("DEBUG : collectDependencies()...",inputObjects);
+		const rootContainerLocal=this.model.getRootContainer();
 		
+		const rootContainer=this.model.populateRootContainerWithObjectsSubset(rootContainerLocal, allObjectsCorrespondingToZoneInServerCell, true);
+		rootContainer.isRootContainer=true;
 		
+		return rootContainer;
 	}
-	
-	/*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));
+
+
+
+class ServerCellLobule{
 	
-	return clonedObject;
-};
+	constructor(){
+		this.serversBag=null;
+		this.objectsBag=null;
+		this.clear();
+		this.clientsConnectionsInfos={};
+	}
+	append(clientId, objs, attributeName="objectsBag"){
+		const self=this;
+		if(!this[attributeName][clientId])
+			this[attributeName][clientId]=[];
+		foreach(objs,obj=>{
+			self[attributeName][clientId].push(obj);
+		},(obj)=>(!contains(this[attributeName][clientId], obj)));
+	}
+	getObjects(clientId, filterFunction=null){
+		if(!filterFunction)	return this.objectsBag[clientId];
+		if(!this.objectsBag[clientId])	return null;
+		const results=[];
+		foreach(this.objectsBag[clientId], (obj)=>{
+			results.push(obj);
+		},filterFunction);
+		return results;
+	}
+	getServers(clientId){
+		if(!this.serversBag[clientId])	return null;
+		return this.serversBag[clientId];
+	}
+	clear(clientId=null, attributeName=null){
+		if(!attributeName){
+			if(!clientId){
+				this.serversBag={};
+				this.objectsBag={};
+			}else{
+				this.serversBag[clientId]=[];
+				this.objectsBag[clientId]=[];
+				delete this.clientsConnectionsInfos[clientId];
+			}
+		}else{
+			if(!clientId){
+				this[attributeName]={};
+			}else{
+				this[attributeName][clientId]=[];
+				delete this.clientsConnectionsInfos[clientId];
+			}
+		}
+
+		//DBG
+		if(clientId)	lognow("DEBUG : CLEAR() FOR clientId:",clientId);
+		
+		return this;
+	}
+	remove(clientId){
+		delete this.serversBag[clientId];
+		delete this.objectsBag[clientId];
+		delete this.clientsConnectionsInfos[clientId];
+	}
+	getClientConnectionInfo(clientId){
+		return this.clientsConnectionsInfos[clientId];
+	}
+	setClientConnectionInfo(clientId, serverWrapper, clientSocket){
+		this.clientsConnectionsInfos[clientId]={serverWrapper:serverWrapper, clientSocket:clientSocket};
+	}
+}
 
 
 
-window.getAORTACServerNode=function(quorumNumber=1, selfOrigin="ws://127.0.0.1:40000", outcomingCellsOrigins=[], model, controller){
+window.getAORTACServerCell=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){
+	if(window.aortacCServerCellInstance){
 		// TRACE
-		throw new Error("ERROR : The AORTACCServerNode singleton instance already exists. It cannot be instantiated again in the same process. Aborting.");
+		throw new Error("ERROR : The aortacCServerCellInstance 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; 
+	window.aortacCServerCellInstance=new AORTACServerCell(quorumNumber, selfOrigin, outcomingCellsOrigins, model, controller);
+	return window.aortacCServerCellInstance; 
 }
 
 
 
 
+// ===============================================================================================================================
+// ===============================================================================================================================
+// UTILITY METHODS
 
 
+// USAGE EXAMPLE :
 
-// ==================================================================================================================
 
+// 4 tests only :
+//class PricingService {
+//  constructor(currency) {
+//    this.currency = currency;
+//    this.callCount = 0;
+//  }
+//
+//  getPrice(eventId) {
+//    this.callCount++;
+//    return { eventId, amount: 89.99, currency: this.currency };
+//  }
+//
+//  async updatePrice(eventId, amount) {
+//    await new Promise(r => setTimeout(r, 10)); // simulate async
+//    return { eventId, amount, saved: true };
+//  }
+//}
+//
+//proxyClass(PricingService);
+//const proxiedClassInstance=new PricingService("CAD");
+//proxiedClassInstance.currency;                          // [GET]  PricingService.currency{ value: "CAD" }
+//proxiedClassInstance.currency="USD";                 // [SET]  PricingService.currency{ value: "USD" }
+//proxiedClassInstance.getPrice("evt-42");              // [CALL] PricingService.getPrice(){ args: ["evt-42"], result:{...} }
+//proxiedClassInstance.callCount;                         // [GET]  PricingService.callCount{ value: 1 }
+//await proxiedClassInstance.updatePrice("evt-42", 120); // [CALL] PricingService.updatePrice(){ args: [...], result:{...} }
+//restoreNonProxiedClass(PricingService); // undo — new PricingService() works normally again
 
-// AORTAC CLIENT
 
+window.proxyClass=function(classToProxy, 
+	doOnAccess=(className, propertyName, parameter)=>{lognow(`Accessing ${className}.${propertyName}:`,parameter);}){
 
+  const className=classToProxy.name;
 
-//*********************************** AUTO-ORGANIZING REAL-TIME AORTAC CLUSTERIZATION (AORTAC) *********************************** */
+  // Build the Proxy handler
+  const proxyHandler={
 
-// New implementation :
+    // Intercepts: obj.property  AND  obj.method()
+    get(concernedObject, property, thisArg){
+      const value=Reflect.get(concernedObject, property, thisArg);
 
-class AORTACClientCell{
+      // We skip symbols (ex. Symbol.toPrimitive) — not meaningful to intercept
+      if(typeof(property)!=="string") return value;
+
+      if(typeof(value)==="function"){
+				
+        // Return a wrapper so we can intercept args + return value at call time
+        return function(...args){
+          const result=value.apply(concernedObject, args); // `concernedObject` keeps correct `this`
+
+          if(result instanceof Promise){
+            // Async method — intercept after the promise settles
+            return result
+              .then(v=>{  doOnAccess(className, property, { args, result: v });  return v; })
+              .catch(e=>{ doOnAccess(className, property, { args, error:  e }); 	throw e; });
+          }
+
+          // Sync method — intercept immediately
+          doOnAccess(className, property, { args, result }/*(SYNTAX : Equivalent to { args:args, result:result })*/);
+          return result;
+        };
+      }
+
+      // Plain attribute read
+      doOnAccess(className, property, { value });
+      return value;
+    },
+
+    // Intercepts: obj.property=value
+    set(concernedObject, property, valueToSet, thisArg){
+      if(typeof(property)==="string")
+        doOnAccess(className, property, { valueToSet });
+      return Reflect.set(concernedObject, property, valueToSet, thisArg);
+    },
+  };
+
+  // Patch the constructor
+  // Save the original so we can restore later
+  const originalConstructor=classToProxy.prototype.constructor;
+	classToProxy.prototype.originalConstructor=originalConstructor;
+
+  // Override the constructor: it runs first, then we wrap `this` in a Proxy
+  classToProxy.prototype.constructor=function(...args){
+    classToProxy.prototype.originalConstructor.apply(this, args);  // run original setup
+    return new Proxy(this, proxyHandler);        // return proxy instead of raw `this`
+  };
+
+  // Keep the name and prototype intact so instanceof still works
+  Object.defineProperty(classToProxy.prototype.constructor, "name", { value: className });
+  classToProxy.prototype.constructor.prototype=classToProxy.prototype;
+
+	return classToProxy;
+};
+
+// Return a restore function
+window.restoreNonProxiedClass=function(classToProxy){
+	if(!classToProxy.prototype.originalConstructor){
+		// TRACE
+		lognow("WARN : Class has not been proxied. We do nothing. Concerned class:",classToProxy);
+		return;
+	}
+  classToProxy.prototype.constructor=classToProxy.prototype.originalConstructor;
+};
+
+
+
+
+// ******************************************************************
+
+window.getCurrentLevelConfigForAORTACServerCell=()=>{
+	const allPrototypesConfig=PROTOTYPES_CONFIG.allPrototypes;
+	const levelConfig=allPrototypesConfig.GameLevel;
+
+	const currentLevelPrototypeName=getCurrentLevelPrototypeNameForAORTACServerCell();
+	if(nothing(currentLevelPrototypeName)){
+		// TRACE
+		lognow("WARN : No currentLevelPrototypeName found. Aborting.");
+		return null;
+	}
+	const referenceCurrentLevelConfig=levelConfig[currentLevelPrototypeName];
+	return referenceCurrentLevelConfig;
+};
+
+window.getCurrentLevelPrototypeNameForAORTACServerCell=()=>{
 	
-	constructor(serverNodeOrigin, model, view, isNodeContext=false){
+	const	aortacConfig=GAME_CONFIG.aortac;
+	if(nothing(aortacConfig)){
+		// TRACE
+		lognow("WARN : No AORTAC config, Aborting..");
+		return null;
+	}
 		
+	const allPrototypesConfig=PROTOTYPES_CONFIG.allPrototypes;
+	const levelConfig=allPrototypesConfig.GameLevel;
+	
+	let currentLevelPrototypeName=aortacConfig.startingLevelPrototypeName;
+	if(nothing(currentLevelPrototypeName)){
+		currentLevelPrototypeName=getKeyAt(levelConfig,0);
+		// TRACE
+		lognow("WARN : No startingLevelPrototypeName specified in AORTAC config, using first level name as default «"+currentLevelPrototypeName+"».");
 	}
 	
-}
+	return currentLevelPrototypeName;
+};
 
 
 
 
-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);
-}
 
+//
+//// Public static hydration method :
+//window.ao=(incompleteModelObjectToDecorate)=>{
+//	
+//	const localServerCell=window.aortacCServerCellInstance;
+//	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;
+//};
 
 
 
@@ -6938,7 +7939,7 @@ WebsocketImplementation={
 		},
 		
 		
-		/*private*/getMessageDataBothImplementations:(eventOrMessageParam)=>{
+		/*public*//*static*/getMessageDataBothImplementations:(eventOrMessageParam)=>{
 			
 				const eventOrMessage=(!WebsocketImplementation.useSocketIOImplementation?eventOrMessageParam.data:eventOrMessageParam);
 			
@@ -7135,12 +8136,11 @@ WebsocketImplementation={
 
 
 
-launchNodeHTTPServer=function(port, doOnConnect=null, doOnFinalizeServer=null, /*OPTIONAL*/sslOptions=null, httpHandlerParam=null, addCORSHeader=ADD_CORS_HEADER){
+launchNodeHTTPServer=function(port, doOnConnect=null, doOnFinalizeServer=null, doOnConnectionLost=null, /*OPTIONAL*/sslOptions=null, httpHandlerParam=null, addCORSHeader=ADD_CORS_HEADER){
 	
 	const EXCLUDED_FILENAMES_PARTS=[".keyHash.",".pem"];
 	
 	
-	
 	if(typeof(https)==="undefined"){
 		// TRACE
 		console.log("«https» SERVER library not called yet, calling it now.");
@@ -7232,8 +8232,6 @@ launchNodeHTTPServer=function(port, doOnConnect=null, doOnFinalizeServer=null, /
 	
 	const handler=nonull(httpHandlerParam, DEFAULT_HANDLER);
 	
-	
-	
 	let listenableServer;
 	if(sslOptions){
 		let httpsServer=https.createServer(sslOptions, handler).listen(port);
@@ -7254,7 +8252,7 @@ launchNodeHTTPServer=function(port, doOnConnect=null, doOnFinalizeServer=null, /
 	// CAUTION : MUST BE CALLED ONLY ONCE !
 	server.onConnectionToClient((serverParam, clientSocketParam)=>{
 		if(doOnConnect) doOnConnect(serverParam, clientSocketParam);
-	});
+	}, doOnConnectionLost);
 
 
 	server.onFinalize((serverParam)=>{
@@ -7269,15 +8267,13 @@ launchNodeHTTPServer=function(port, doOnConnect=null, doOnFinalizeServer=null, /
 	// TRACE
 	console.log("INFO : SERVER : Generic Nodejs server launched and listening on port:" + port + "!");
 	
-	
-	
 
 
 	return server;
 }
 
 
-initNodeServerInfrastructureWrapper=function(doOnClientConnection=null, doOnFinalizeServer=null,
+initNodeServerInfrastructureWrapper=function(doOnClientConnection=null, doOnFinalizeServer=null, doOnConnectionLost=null,
 			 /*OPTIONAL*/portParam,
 			 /*OPTIONAL*/certPathParam,
 			 /*OPTIONAL*/keyPathParam){
@@ -7330,13 +8326,11 @@ initNodeServerInfrastructureWrapper=function(doOnClientConnection=null, doOnFina
 
 
 
-
-
 	const aotraNodeServer={config:serverConfig};
 	aotraNodeServer.serverManager={ start:()=>{/*DEFAULT START FUNCTION, WILL BE OVERRIDEN LATER*/}};
 
 	if(isHashAsked){
-		// We instanciate a temporary persister just to read the key hash file:
+		// We instantiate a temporary persister just to read the key hash file:
 		const persister=getPersister("./");
 		let persisterIdSplits=persisterId.split("@");
 		if(empty(persisterIdSplits) || persisterIdSplits.length!=2){
@@ -7419,9 +8413,9 @@ initNodeServerInfrastructureWrapper=function(doOnClientConnection=null, doOnFina
 			}
 		}
 		
-		aotraNodeServer.server=launchNodeHTTPServer(port, doOnClientConnection, doOnFinalizeServer, sslOptions);
+		aotraNodeServer.server=launchNodeHTTPServer(port, doOnClientConnection, doOnFinalizeServer, doOnConnectionLost, sslOptions);
+		
 		
-
 		return aotraNodeServer;
 	};
 
@@ -7484,7 +8478,10 @@ initNodeServerInfrastructureWrapper=function(doOnClientConnection=null, doOnFina
 //			},REFRESH_SCREENSHOTS_MILLIS);
 //			
 //			
-//		},portParam,certPathParam,keyPathParam);
+//		},
+//		// On client connection lost :
+//		(clientId)=>{lognow(`INFO : Connection to client id «${clientId}» was lost.`);},
+//		portParam,certPathParam,keyPathParam);
 //
 //
 // //	const doOnConnect=(serverParam, clientSocketParam)=>{
@@ -7952,8 +8949,8 @@ initClient=function(isNodeContext=true, useSocketIOImplementation=/*DEBUG*/false
 		// CAUTION : MUST BE CALLED ONLY ONCE !
 		socketToServerClientInstance.onConnectionToServer(()=>{
 			if(doOnServerConnection){
-				if(selfParam)	doOnServerConnection.apply(selfParam,[socketToServerClientInstance]);
-				else				  doOnServerConnection(socketToServerClientInstance);
+				if(selfParam)	doOnServerConnection.apply(selfParam,[socketToServerClientInstance, aotraClient]);
+				else				  doOnServerConnection(socketToServerClientInstance, aotraClient);
 			}
 		
 			
@@ -8050,8 +9047,9 @@ class ClientReceptionEntryPoint{
 		
 
 		// We check if the message matches the required message type :
-		if(		this.listenerConfig && this.listenerConfig.listenerMessageType && dataWrapped.type
-			 && this.listenerConfig.listenerMessageType!==dataWrapped.type){
+		if(		this.listenerConfig && this.listenerConfig.listenerMessageType
+			 && dataWrapped.data
+			 && dataWrapped.data.type && this.listenerConfig.listenerMessageType!==dataWrapped.data.type){
 			return;
 		}
 		
@@ -8075,8 +9073,12 @@ class ClientReceptionEntryPoint{
 		if(this.listenerConfig && this.listenerConfig.destroyListenerAfterReceiving)
 			remove(clientReceptionEntryPoints, this);
 		
-		if(this.doOnIncomingMessage)
-			this.doOnIncomingMessage(dataLocal, clientSocket);
+		if(this.doOnIncomingMessage){
+			
+			const dataRestored=restoreClassesInformation(dataLocal);
+
+			this.doOnIncomingMessage(dataRestored, clientSocket);
+		}
 			
 	}
 	
@@ -8119,7 +9121,9 @@ class ClientInstance{
 				// I-
 				//
 				self.receive(channelNameForResponse, doOnIncomingMessageForResponse,
-						clientsRoomsTag, listenerId, {messageId:messageId, destroyListenerAfterReceiving:true});
+						{messageId:messageId, destroyListenerAfterReceiving:true},
+						clientsRoomsTag, listenerId,
+					);
 				//
 				
 				return resultPromise;
@@ -8134,7 +9138,7 @@ class ClientInstance{
 	}
 	
 	// II-
-	receive(channelNameParam, doOnIncomingMessage, clientsRoomsTag=null, entryPointId=null, listenerConfig={destroyListenerAfterReceiving:false}){
+	receive(channelNameParam, doOnIncomingMessage, listenerConfig={destroyListenerAfterReceiving:false, listenerMessageType:null}, clientsRoomsTag=null, entryPointId=null){
 		const self=this;
 		
 //	// DBG
@@ -8174,8 +9178,11 @@ class ClientInstance{
 		if(!WebsocketImplementation.isInRoom(clientSocket,clientsRoomsTag)) return;
 
 		// Channel information is stored in exchanged data :
-	  let dataWrapped={channelName:channelNameParam, data:data};
-    
+	  let dataWrapped=saveClassesInformation({channelName:channelNameParam, data:data});
+		
+		// CAUTION : WE CAN ONLY SEND STRINGS !!!
+		// (or else we'll have TypeError [ERR_INVALID_ARG_TYPE]: The first argument must be of type string or an instance of Buffer, ArrayBuffer, or Array or an Array-like Object. Received an instance of Object)
+		// (Don't worry, the underlying sub-system will turn it back into Objects without you need to do anything!)					
 		dataWrapped=stringifyObject(dataWrapped);
    	
 		// TODO : FIXME : Use one single interface !
@@ -8307,8 +9314,9 @@ class ServerReceptionEntryPoint{
 		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){
+		if(		this.listenerConfig && this.listenerConfig.listenerMessageType
+ 				&& dataWrapped.data
+			 && dataWrapped.data.type && this.listenerConfig.listenerMessageType!==dataWrapped.data.type){
 			return;
 		}
 
@@ -8316,7 +9324,11 @@ class ServerReceptionEntryPoint{
 //		// DBG
 //		lognow("(SERVER) this.doOnIncomingMessage:");
 
-			this.doOnIncomingMessage(dataWrapped.data, clientSocketParam);
+			const dataLocal=dataWrapped.data;
+
+			const dataRestored=restoreClassesInformation(dataLocal);
+
+			this.doOnIncomingMessage(dataRestored, clientSocketParam);
 		}
 				
 	}
@@ -8364,13 +9376,10 @@ class NodeServerInstance{
 		});
 	}
 
-
-
 	// TODO : DEVELOP...				
 	//sendChainable(channelNameParam, data, clientsRoomsTag=null){
 	//}
 
-
 	receive(channelNameParam, doOnIncomingMessage, listenerConfig=null, clientsRoomsTag=null){
 			
 		// DBG
@@ -8418,14 +9427,16 @@ class NodeServerInstance{
 			   	if(!WebsocketImplementation.isInRoom(clientSocket,clientsRoomsTag)) return;
 	
 		      // Channel information is stored in exchanged data :
-			   	let dataWrapped={channelName:channelName, data:data};
-	      	
-		      
+			   	let dataWrapped=saveClassesInformation({channelName:channelName, data:data});
+					
+					// CAUTION : WE CAN ONLY SEND STRINGS !!!
+					// (or else we'll have TypeError [ERR_INVALID_ARG_TYPE]: The first argument must be of type string or an instance of Buffer, ArrayBuffer, or Array or an Array-like Object. Received an instance of Object)
+					// (Don't worry, the underlying sub-system will turn it back into Objects without you need to do anything!)					
 					dataWrapped=stringifyObject(dataWrapped);
 					
 					// TODO : FIXME : Use one single interface !
 	      	if(!WebsocketImplementation.useSocketIOImplementation)	clientSocket.send(dataWrapped);
-		      else																										clientSocket.emit(channelName,dataWrapped);
+		      else																										clientSocket.emit(channelName, dataWrapped);
 	
 		    });
 		
@@ -8445,12 +9456,12 @@ class NodeServerInstance{
 	    if(!WebsocketImplementation.isInRoom(clientSocket,clientsRoomsTag)) return;
 	
 	  	// Channel information is stored in exchanged data :
-	    let dataWrapped={channelName:channelName, data:data};
-			dataWrapped=stringifyObject(dataWrapped);
+	    let dataWrapped=saveClassesInformation({channelName:channelName, data:data});
 			
-			
-			// DBG
-			lognow("(SERVER) WebsocketImplementation.useSocketIOImplementation:"+WebsocketImplementation.useSocketIOImplementation);
+			// CAUTION : WE CAN ONLY SEND STRINGS !!!
+			// (or else we'll have TypeError [ERR_INVALID_ARG_TYPE]: The first argument must be of type string or an instance of Buffer, ArrayBuffer, or Array or an Array-like Object. Received an instance of Object)
+			// (Don't worry, the underlying sub-system will turn it back into Objects without you need to do anything!)					
+			dataWrapped=stringifyObject(dataWrapped);
 			
 			
 			// TODO : FIXME : Use one single interface !
@@ -8463,8 +9474,8 @@ class NodeServerInstance{
 		return this;
 	}
 					
-					
-	onConnectionToClient(doOnConnection){
+
+	onConnectionToClient(doOnConnection, doOnConnectionLost=null){
 		const self=this;
 		
 		
@@ -8473,7 +9484,6 @@ class NodeServerInstance{
 		
 			// DBG
 			console.log("SERVER : ON CONNECTION !");
-			
 
 			const clientId="autogeneratedid_"+getUUID();
 			
@@ -8524,6 +9534,9 @@ class NodeServerInstance{
 			    	
 			    	
   				 	clearInterval(clientSocket.stateCheckInterval);
+
+						if(doOnConnectionLost)	doOnConnectionLost(clientSocket.clientId);
+
 			    	return;
 			    }
 			    
@@ -8582,7 +9595,71 @@ class NodeServerInstance{
 
 
 
+window.saveClassesInformation=(obj, visitedObjects=[])=>{
+	
+	const attributeClassName=CLASSNAME_ATTRIBUTE_NAME;
+
+	if(contains(visitedObjects, obj))	return obj;
+	visitedObjects.push(obj);
+
+	const className=getClassName(obj);
+	if(className!="Object"){
+		// We do the save :
+		obj[attributeClassName]=className;
+		
+		// DBG
+		lognow("0 saving class name : :",obj);
+
+	}
+	
+	foreach(obj, (attr, attrName)=>{
+		const className=getClassName(attr);
+		
+		// DBG
+		if(attrName=="position")	lognow("1 attr:",attr);
+		
+		if(className!="Object"){
+			saveClassesInformation(attr, visitedObjects);
+		}
+		
+		// DBG
+		if(attrName=="position")	lognow("2 attr:",attr);
+		
+	},(attr, attrName)=>
+		attr &&
+		// DEBUG ONLY
+		(attrName=="position" || (		
+		 isObject(attr) && !attr[attributeClassName]
+	 ))
+	 );
+	
+	return obj;
+};
+
+
+window.restoreClassesInformation=(obj, visitedObjects=[])=>{
+	
+	const attributeClassName=CLASSNAME_ATTRIBUTE_NAME;
+
+	if(contains(visitedObjects, obj))	return obj;
+	visitedObjects.push(obj);
+
+	const className=obj[attributeClassName];
+	if(className){
+		// We do the restore :
+		const blankInstance=instantiate(className);
+		obj=Object.assign(blankInstance, obj);
+	}
+
+	foreach(obj, (attr, attrName)=>{
+		const className=attr[attributeClassName];
+		if(className!="Object"){
+			obj[attrName]=restoreClassesInformation(attr, visitedObjects);
+		}
+	},attr=>attr && ((isObject(attr) && attr[attributeClassName]) || isArray(attr))  );
 
+	return obj;
+};