shogun-core 4.0.3 → 4.0.5

package/dist/browser/shogun-core.js

@@ -86304,6 +86304,322 @@ module.exports = webpackEmptyContext;
 }());
 
 
+/***/ }),
+
+/***/ "./node_modules/gun/lib/axe.js":
+/*!*************************************!*\
+  !*** ./node_modules/gun/lib/axe.js ***!
+  \*************************************/
+/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
+
+/* provided dependency */ var process = __webpack_require__(/*! process/browser */ "./node_modules/process/browser.js");
+// I don't quite know where this should go yet, so putting it here
+// what will probably wind up happening is that minimal AXE logic added to end of gun.js
+// and then rest of AXE logic (here) will be moved back to gun/axe.js
+// but for now... I gotta rush this out!
+var Gun = ( true)? window.Gun : 0, u;
+Gun.on('opt', function(at){ start(at); this.to.next(at) }); // make sure to call the "next" middleware adapter.
+// TODO: BUG: panic test/panic/1 & test/panic/3 fail when AXE is on.
+function start(root){
+	if(root.axe){ return }
+	var opt = root.opt, peers = opt.peers;
+	if(false === opt.axe){ return }
+	if((typeof process !== "undefined") && 'false' === ''+(opt.env=process.env||'').AXE){ return }
+	Gun.log.once("AXE", "AXE relay enabled!");
+	var axe = root.axe = {}, tmp, id;
+	var mesh = opt.mesh = opt.mesh || Gun.Mesh(root); // DAM!
+	var dup = root.dup;
+
+	mesh.way = function(msg){
+		if(!msg){ return }
+		//relayUp(msg); // TEMPORARY!!!
+		if(msg.get){ return GET(msg) }
+		if(msg.put){ return }
+		fall(msg);
+	}
+
+	function GET(msg){
+		if(!msg){ return }
+		var via = (msg._||'').via, soul, has, tmp, ref;
+		if(!via || !via.id){ return fall(msg) }
+		// SUBSCRIPTION LOGIC MOVED TO GET'S ACK REPLY.
+		if(!(ref = REF(msg)._)){ return fall(msg) }
+		ref.asked = +new Date;
+		GET.turn(msg, ref.route, 0);
+	}
+	GET.turn = function(msg, route, turn){
+		var tmp = msg['#'], tag = dup.s[tmp], next; 
+		if(!tmp || !tag){ return } // message timed out, GUN may require us to relay, tho AXE does not like that. Rethink?
+		// TOOD: BUG! Handle edge case where live updates occur while these turn hashes are being checked (they'll never be consistent), but we don't want to degrade to O(N), if we know the via asking peer got an update, then we should do something like cancel these turns asking for data.
+		// Ideas: Save a random seed that sorts the route, store it and the index. // Or indexing on lowest latency is probably better.
+		clearTimeout(tag.lack);
+		if(tag.ack && (tmp = tag['##']) && msg['##'] === tmp){ return } // hashes match, stop asking other peers!
+		next = (Object.maps(route||opt.peers)).slice(turn = turn || 0);
+		if(!next.length){
+			if(!route){ return } // asked all peers, stop asking!
+			GET.turn(msg, u, 0); // asked all subs, now now ask any peers. (not always the best idea, but stays )
+			return;
+		}
+		setTimeout.each(next, function(id){
+			var peer = opt.peers[id]; turn++;
+			if(!peer || !peer.wire){ route && route.delete(id); return } // bye! // TODO: CHECK IF 0 OTHER PEERS & UNSUBSCRIBE
+			if(mesh.say(msg, peer) === false){ return } // was self
+			if(0 == (turn % 3)){ return 1 }
+		}, function(){
+			tag['##'] = msg['##']; // should probably set this in a more clever manner, do live `in` checks ++ --, etc. but being lazy for now. // TODO: Yes, see `in` TODO, currently this might match against only in-mem cause no other peers reply, which is "fine", but could cause a false positive.
+			tag.lack = setTimeout(function(){ GET.turn(msg, route, turn) }, 25);
+		}, 3);
+	}
+	function fall(msg){ mesh.say(msg, opt.peers) }
+	function REF(msg){
+		var ref = '', soul, has, tmp;
+		if(!msg || !msg.get){ return ref }
+		if('string' == typeof (soul = msg.get['#'])){ ref = root.$.get(soul) }
+		if('string' == typeof (tmp = msg.get['.'])){ has = tmp } else { has = '' }
+
+		var via = (msg._||'').via, sub = (via.sub || (via.sub = new Object.Map)); (sub.get(soul) || (sub.set(soul, tmp = new Object.Map) && tmp)).set(has, 1); // {soul: {'':1, has: 1}} // TEMPORARILY REVERT AXE TOWER TYING TO SUBSCRIBING TO EVERYTHING. UNDO THIS!
+		via.id && ref._ && (ref._.route || (ref._.route = new Object.Map)).set(via.id, via); // SAME AS ^
+
+		return ref;
+	}
+	function LEX(lex){ return (lex = lex || '')['='] || lex['*'] || lex['>'] || lex }
+	
+	root.on('in', function(msg){ var to = this.to, tmp;
+		if((tmp = msg['@']) && (tmp = dup.s[tmp])){
+			tmp.ack = (tmp.ack || 0) + 1; // count remote ACKs to GET. // TODO: If mismatch, should trigger next asks.
+			if(tmp.it && tmp.it.get && msg.put){ // WHEN SEEING A PUT REPLY TO A GET...
+				var get = tmp.it.get||'', ref = REF(tmp.it)._, via = (tmp.it._||'').via||'', sub;
+				if(via && ref){ // SUBSCRIBE THE PEER WHO ASKED VIA FOR IT:
+					//console.log("SUBSCRIBING", Object.maps(ref.route||''), "to", LEX(get['#']));
+					via.id && (ref.route || (ref.route = new Object.Map)).set(via.id, via);
+					sub = (via.sub || (via.sub = new Object.Map));
+					ref && (sub.get(LEX(get['#'])) || (sub.set(LEX(get['#']), sub = new Object.Map) && sub)).set(LEX(get['.']), 1); // {soul: {'':1, has: 1}}
+
+					via = (msg._||'').via||'';
+					if(via){ // BIDIRECTIONAL SUBSCRIBE: REPLIER IS NOW SUBSCRIBED. DO WE WANT THIS?
+						via.id && (ref.route || (ref.route = new Object.Map)).set(via.id, via);
+						sub = (via.sub || (via.sub = new Object.Map));
+						if(ref){
+							var soul = LEX(get['#']), sift = sub.get(soul), has = LEX(get['.']);
+							if(has){
+								(sift || (sub.set(soul, sift = new Object.Map) && sift)).set(has, 1);
+							} else
+							if(!sift){
+								sub.set(soul, sift = new Object.Map);
+								sift.set('', 1);
+							}
+						}
+					}
+				}
+			}
+			if((tmp = tmp.back)){ // backtrack OKs since AXE splits PUTs up.
+				setTimeout.each(Object.keys(tmp), function(id){
+					to.next({'#': msg['#'], '@': id, ok: msg.ok});
+				});
+				return;
+			}
+		}
+		to.next(msg);
+	});
+
+	root.on('create', function(root){
+		this.to.next(root);
+		var Q = {};
+		root.on('put', function(msg){
+			var eve = this, at = eve.as, put = msg.put, soul = put['#'], has = put['.'], val = put[':'], state = put['>'], q, tmp;
+			eve.to.next(msg);
+			if(msg['@']){ return } // acks send existing data, not updates, so no need to resend to others.
+			if(!soul || !has){ return }
+			var ref = root.$.get(soul)._, route = (ref||'').route;
+			if(!route){ return }
+			if(ref.skip && ref.skip.has == has){ ref.skip.now = msg['#']; return }
+			(ref.skip = {now: msg['#'], has: has}).to = setTimeout(function(){
+			setTimeout.each(Object.maps(route), function(pid){ var peer, tmp;
+				var skip = ref.skip||''; ref.skip = null;
+				if(!(peer = route.get(pid))){ return }
+				if(!peer.wire){ route.delete(pid); return } // bye!
+				var sub = (peer.sub || (peer.sub = new Object.Map)).get(soul);
+				if(!sub){ return }
+				if(!sub.get(has) && !sub.get('')){ return }
+				var put = peer.put || (peer.put = {});
+				var node = root.graph[soul], tmp;
+				if(node && u !== (tmp = node[has])){
+					state = state_is(node, has);
+					val = tmp;
+				}
+				put[soul] = state_ify(put[soul], has, state, val, soul);
+				tmp = dup.track(peer.next = peer.next || String.random(9));
+				(tmp.back || (tmp.back = {}))[''+(skip.now||msg['#'])] = 1;
+				if(peer.to){ return }
+				peer.to = setTimeout(function(){ flush(peer) }, opt.gap);
+			}) }, 9);
+		});
+	});
+
+	function flush(peer){
+		var msg = {'#': peer.next, put: peer.put, ok: {'@': 3, '/': mesh.near}}; // BUG: TODO: sub count!
+		// TODO: what about DAM's >< dedup? Current thinking is, don't use it, however, you could store first msg# & latest msg#, and if here... latest === first then likely it is the same >< thing, so if(firstMsg['><'][peer.id]){ return } don't send.
+		peer.next = peer.put = peer.to = null;
+		mesh.say(msg, peer);
+	}
+	var state_ify = Gun.state.ify, state_is = Gun.state.is;
+
+	function relayUp(msg){
+		mesh.say(msg, axe.up);
+	}
+
+	;(function(){ // THIS IS THE UP MODULE;
+		axe.up = {};
+		var hi = mesh.hear['?']; // lower-level integration with DAM! This is abnormal but helps performance.
+		mesh.hear['?'] = function(msg, peer){ var p; // deduplicate unnecessary connections:
+			hi(msg, peer);
+			if(!peer.pid){ return }
+			if(peer.pid === opt.pid){ mesh.bye(peer); return } // if I connected to myself, drop.
+			if(p = axe.up[peer.pid]){ // if we both connected to each other...
+				if(p === peer){ return } // do nothing if no conflict,
+				if(opt.pid > peer.pid){ // else deterministically sort
+					p = peer; // so we will wind up choosing the same to keep
+					peer = axe.up[p.pid]; // and the same to drop.
+				}
+				p.url = p.url || peer.url; // copy if not
+				mesh.bye(peer); // drop
+				axe.up[p.pid] = p; // update same to be same.
+				return;
+			}
+			if(!peer.url){ return }
+			axe.up[peer.pid] = peer;
+			if(axe.stay){ axe.stay() }
+		};
+
+		mesh.hear['opt'] = function(msg, peer){
+			if(msg.ok){ return }
+			var tmp = msg.opt;
+			if(!tmp){ return }
+			tmp = tmp.peers;
+			if(!tmp || 'string' != typeof tmp){ return }
+			if(99 <= Object.keys(axe.up).length){ return } // 99 TEMPORARILY UNTIL BENCHMARKED!
+			mesh.hi({id: tmp, url: tmp, retry: 9});
+			if(peer){ mesh.say({dam: 'opt', ok: 1, '@': msg['#']}, peer) }
+		}
+
+		axe.stay = function(){
+			clearTimeout(axe.stay.to);
+			axe.stay.to = setTimeout(function(tmp, urls){
+				if(!(tmp = root.stats && root.stats.stay)){ return }
+				urls = {}; Object.keys(axe.up||'').forEach(function(p){
+					p = (axe.up||'')[p]; if(p.url){ urls[p.url] = {} }
+				});
+				(tmp.axe = tmp.axe || {}).up = urls;
+			}, 1000 * 9);//1000 * 60);
+		};
+		setTimeout(function(tmp){
+			if(!(tmp = root.stats && root.stats.stay && root.stats.stay.axe)){ return }
+			if(!(tmp = tmp.up)){ return }
+			if(!(tmp instanceof Array)){ tmp = Object.keys(tmp) }
+			setTimeout.each(tmp||[], function(url){ mesh.hear.opt({opt: {peers: url}}) });
+		},1000);
+	}());
+
+	setTimeout(function(){ __webpack_require__(/*! ./service */ "./node_modules/gun/lib/service.js")(root) },9);
+
+	;(function(){ // THIS IS THE MOB MODULE;
+		//return; // WORK IN PROGRESS, TEST FINALIZED, NEED TO MAKE STABLE.
+		/*
+			AXE should have a couple of threshold items...
+			let's pretend there is a variable max peers connected
+			mob = 10000
+			if we get more peers than that...
+			we should start sending those peers a remote command
+			that they should connect to this or that other peer
+			and then once they (or before they do?) drop them from us.
+			sake of the test... gonna set that peer number to 1.
+			The mob threshold might be determined by other factors,
+			like how much RAM or CPU stress we have.
+		*/
+		opt.mob = opt.mob || parseFloat((opt.env||'').MOB) || 999999; // should be based on ulimit, some clouds as low as 10K.
+
+		// handle rebalancing a mob of peers:
+		root.on('hi', function(peer){
+			this.to.next(peer);
+			if(peer.url){ return } // I am assuming that if we are wanting to make an outbound connection to them, that we don't ever want to drop them unless our actual config settings change.
+			var count = /*Object.keys(opt.peers).length ||*/ mesh.near; // TODO: BUG! This is slow, use .near, but near is buggy right now, fix in DAM.
+			//console.log("are we mobbed?", opt.mob, Object.keys(opt.peers).length, mesh.near);
+			if(opt.mob >= count){ return }  // TODO: Make dynamic based on RAM/CPU also. Or possibly even weird stuff like opt.mob / axe.up length?
+			var peers = {};Object.keys(axe.up).forEach(function(p){ p = axe.up[p]; p.url && (peers[p.url]={}) });
+			// TODO: BUG!!! Infinite reconnection loop happens if not enough relays, or if some are missing. For instance, :8766 says to connect to :8767 which then says to connect to :8766. To not DDoS when system overload, figure clever way to tell peers to retry later, that network does not have enough capacity?
+			mesh.say({dam: 'mob', mob: count, peers: peers}, peer);
+			setTimeout(function(){ mesh.bye(peer) }, 9); // something with better perf?
+		});
+		root.on('bye', function(peer){
+			this.to.next(peer);
+		});
+
+	}());
+
+	;(function(){ // THIS IS THE UNIVERSAL NOTIFICATION MODULE
+		var to = {}, key = {}, email = __webpack_require__(/*! ./email */ "./node_modules/gun/lib/email.js");
+		if(email.err){ return }
+		mesh.hear['tag'] = function(msg, peer, who){
+			if(who = key[msg.key]){ who.rate = Math.max(msg.rate||1000*60*15, 1000*60); return }
+			if(!msg.src || !msg.email){ return }
+			if(+new Date < peer.emailed + 1000*60*2){ mesh.say({dam:'tag',err:'too fast'},peer); return } // peer can only send notifications > 2min
+			var src; try{ src = new URL(msg.src = msg.src.split(/\s/)[0]); } catch(e){ return } // throws if invalid URL.
+			(who = (to[msg.email] = to[msg.email] || {go:{}})).go[''+src] = 1; // we're keeping in-memory for now, maybe will "stay" to disk in future.
+			peer.emailed = +new Date;
+			if(who.batch){ return }
+			key[who.key = Math.random().toString(36).slice(2)] = who;
+			who.batch = setTimeout(function(){
+				email.send({
+					from: process.env.EMAIL,
+					to: msg.email,
+					subject: "Notification:",
+					text: 'Someone or a bot tagged you at: (⚠️ only click link if you recognize & trust it ⚠️)\n'+
+						'[use #'+who.key+' to unsubscribe please mute this thread by tapping the top most "⋮" button and clicking mute]\n\n' +
+						Object.keys(who.go).join('\n'), // TODO: NEEDS TO BE CPU SCHEDULED
+					headers: {'message-id': '<123456789.8765@example.com>'} // hardcode id so all batches also group into the same email thread to reduce clutter.
+				}, function(err, r){
+					who.batch = null; who.go = {};
+					err && console.log("email TAG:", err);
+				});
+			}, who.rate || (1000*60*60*24)); // default to 1 day
+		};
+	}());
+};
+
+;(function(){
+	var from = Array.from;
+	Object.maps = function(o){
+		if(from && o instanceof Map){ return from(o.keys()) }
+		if(o instanceof Object.Map){ o = o.s }
+		return Object.keys(o);
+	}
+	if(from){ return Object.Map = Map }
+	(Object.Map = function(){ this.s = {} }).prototype = {set:function(k,v){this.s[k]=v;return this},get:function(k){return this.s[k]},delete:function(k){delete this.s[k]}};
+}());
+
+
+/***/ }),
+
+/***/ "./node_modules/gun/lib/email.js":
+/*!***************************************!*\
+  !*** ./node_modules/gun/lib/email.js ***!
+  \***************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+/* provided dependency */ var process = __webpack_require__(/*! process/browser */ "./node_modules/process/browser.js");
+;(function(){
+	var email, fail = {send: function(opt, cb){ cb && cb("You do not have email installed.") } };
+	if(!process.env.EMAIL){ return module.exports = fail }
+	try{ email = __webpack_require__(Object(function webpackMissingModule() { var e = new Error("Cannot find module 'emailjs'"); e.code = 'MODULE_NOT_FOUND'; throw e; }())) }catch(e){};
+	if(!email){ return module.exports = fail }
+	return module.exports = email.server.connect({
+	  user: process.env.EMAIL,
+	  password: process.env.EMAIL_KEY,
+	  host: process.env.EMAIL_HOST || "smtp.gmail.com",
+	  ssl: process.env.EMAIL_SSL || true
+	});
+}());
+
 /***/ }),
 
 /***/ "./node_modules/gun/lib/radisk.js":
@@ -87172,6 +87488,64 @@ if (navigator.storage && navigator.storage.estimate) {
 
 /***/ }),
 
+/***/ "./node_modules/gun/lib/service.js":
+/*!*****************************************!*\
+  !*** ./node_modules/gun/lib/service.js ***!
+  \*****************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var __dirname = "/";
+/* provided dependency */ var process = __webpack_require__(/*! process/browser */ "./node_modules/process/browser.js");
+module.exports = function(root){
+	var mesh = root.opt.mesh, cmd = {}, run = Object(function webpackMissingModule() { var e = new Error("Cannot find module 'child_process'"); e.code = 'MODULE_NOT_FOUND'; throw e; }()), fs = __webpack_require__(Object(function webpackMissingModule() { var e = new Error("Cannot find module 'fs'"); e.code = 'MODULE_NOT_FOUND'; throw e; }())), home = (__webpack_require__(/*! os */ "./node_modules/os-browserify/main.js").homedir)(), examp = (__webpack_require__(/*! path */ "./node_modules/path-browserify/index.js").resolve)(__dirname, '../examples');
+	mesh.hear['service'] = function(msg, peer){
+		if(!fs.existsSync('/lib/systemd/system/relay.service')){
+			mesh.say({dam: '!', err: "Not serviced."});
+			return;
+		}
+		try{ (cmd[msg.try]||cmd.any)(msg, peer); }catch(err){ mesh.say({dam: '!', err: "service error: "+err}) }
+	}
+	cmd.https = function(msg, peer){ var log;
+		if(!msg.email || !msg.domain){
+			mesh.say({dam: '!', err: 'Domain/email missing, use `location.hostname`!'});
+			return;
+		}
+		if(fs.existsSync(home+'/cert.pem')){
+			mesh.say({dam: '!', err: 'Cert already exists.'});
+			return;
+		}
+		fs.writeFile(examp+'/../email', msg.email, function(){});
+		run("bash "+examp+"/https.sh", {env: {'EMAIL': msg.email, 'WEB': examp, 'DOMAIN':  msg.domain}}, function(e, out, err){
+			log = "|"+e+"|"+out+"|"+err;
+			mesh.say({dam: '!', log: ''+log}, peer);
+			setTimeout(function(){ process.exit() },999);
+		});
+	}
+	cmd.update = function(msg, peer){ var log, pass;
+		try{ pass = (''+fs.readFileSync(home+'/pass')).trim() }catch(e){}
+		if(!pass || (msg.pass||'').trim() != pass){ return }
+		root.stats.stay.updated = +new Date;
+		run("bash "+examp+"/install.sh", {env: {VERSION: msg.version||''}}, function(e, out, err){
+			log = e+"|"+out+"|"+err;
+			mesh.say({dam: '!', log: ''+log}, peer);
+			setTimeout(function(){ process.exit() },999);
+		});
+	}
+	;(function update(){ var last;
+		if(!fs.existsSync(home+'/cert.pem')){ return }
+		setTimeout(update, 1000*60*60*24);
+		last = root.stats.stay.updated || 0;
+		if(+new Date - last < 1000*60*60*24*15){ return }
+		root.stats.stay.updated = +new Date;
+		run("bash "+examp+"/install.sh", {}, function(){});
+	}());
+
+	cmd.any = function(){};
+
+};
+
+/***/ }),
+
 /***/ "./node_modules/gun/lib/store.js":
 /*!***************************************!*\
   !*** ./node_modules/gun/lib/store.js ***!
@@ -87506,6 +87880,108 @@ Gun.chain.then = function(cb) {
 }());
 
 
+/***/ }),
+
+/***/ "./node_modules/gun/lib/wire.js":
+/*!**************************************!*\
+  !*** ./node_modules/gun/lib/wire.js ***!
+  \**************************************/
+/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
+
+var Gun = __webpack_require__(/*! ../gun */ "./node_modules/gun/gun.js");
+
+/*
+	An Ad-Hoc Mesh-Network Daisy-Chain
+	should work even if humans are
+	communicating with each other blind.
+
+	To prevent infinite broadcast loops,
+	we use a deduplication process
+	based on the message's identifier.
+	This is currently implemented in core.
+
+	However, because this still creates a
+	N*2 (where N is the number of connections)
+	flood, it is not scalable for traditional
+	services that have a hub network topology.
+
+	Does this mean we have to abandon mesh
+	algorithms? No, we can simply layer more
+	efficient optimizations in based on constraints.
+	If these constraints exist, it automatically
+	upgrades, but if not, it falls back to the
+	brute-force mesh based robust algorithm.
+	A simple example is to limit peer connections
+	and rely upon daisy chaining to relay messages.
+
+	Another example, is if peers are willing to
+	identify themselves, then we can improve the
+	efficiency of the network by having each peer
+	include the names of peers it is connected in
+	each message. Then each subsequent peer will
+	not relay it to them, since it is unnecessary.
+	This should create N (where N is the number of
+	peers) messages (or possibly N+ if there is a
+	common peer of uncommon peers that receives it
+	and relays at exact latency timings), which is
+	optimal.
+
+	Since computer networks aren't actually blind,
+	we will implement the above method to improve
+	the performance of the ad-hoc mesh network.
+
+	But why not have every message contain the
+	whole history of peers that it relayed through?
+	Because in sufficiently large enough networks,
+	with extensive daisy chaining, this will cause
+	the message to become prohibitively slow and
+	increase indefinitely in size.
+
+*/
+
+Gun.on('opt', function (root) {
+	var opt = root.opt;
+	if (false === opt.ws || opt.once) {
+		this.to.next(root);
+		return;
+	}
+	opt.mesh = opt.mesh || Gun.Mesh(root);
+	opt.WebSocket = opt.WebSocket || __webpack_require__(Object(function webpackMissingModule() { var e = new Error("Cannot find module 'ws'"); e.code = 'MODULE_NOT_FOUND'; throw e; }()));
+	var ws = opt.ws = opt.ws || {};
+	ws.path = ws.path || '/gun';
+	// if we DO need an HTTP server, then choose ws specific one or GUN default one.
+	if (!opt.web || ws.noServer) {
+		this.to.next(root);
+		return;// no server no sockets
+	}
+	ws.noServer = true;//workaround for ws.path
+	ws.web = ws.web || new opt.WebSocket.Server(ws);
+	opt.web.on('upgrade', (req, socket, head) => {
+		opt.web.host = opt.web.host || (req.headers||'').origin || (req.headers||'').host; 
+		if (req.url == ws.path) {
+			ws.web.handleUpgrade(req, socket, head, function done(ws) {
+				open(ws, req);
+			});
+		}
+	});
+	function open(wire, req) {
+		var peer;
+		wire.headers = wire.headers || (req || '').headers || '';
+		console.STAT && ((console.STAT.sites || (console.STAT.sites = {}))[wire.headers.origin] = 1);
+		opt.mesh.hi(peer = { wire: wire });
+		wire.on('message', function (msg) {
+			opt.mesh.hear(msg.data || msg, peer);
+		});
+		wire.on('close', function () {
+			opt.mesh.bye(peer);
+		});
+		wire.on('error', function (e) { });
+		setTimeout(function heart() { if (!opt.peers[peer.id]) { return } try { wire.send("[]") } catch (e) { }; setTimeout(heart, 1000 * 20) }, 1000 * 20); // Some systems, like Heroku, require heartbeats to not time out. // TODO: Make this configurable? // TODO: PERF: Find better approach than try/timeouts?
+	}
+	this.to.next(root);
+});
+
+
 /***/ }),
 
 /***/ "./node_modules/gun/lib/yson.js":
@@ -101160,6 +101636,547 @@ parseKeys.signature = asn1.signature;
 module.exports = parseKeys;
 
 
+/***/ }),
+
+/***/ "./node_modules/path-browserify/index.js":
+/*!***********************************************!*\
+  !*** ./node_modules/path-browserify/index.js ***!
+  \***********************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+/* provided dependency */ var process = __webpack_require__(/*! process/browser */ "./node_modules/process/browser.js");
+// 'path' module extracted from Node.js v8.11.1 (only the posix part)
+// transplited with Babel
+
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+
+function assertPath(path) {
+  if (typeof path !== 'string') {
+    throw new TypeError('Path must be a string. Received ' + JSON.stringify(path));
+  }
+}
+
+// Resolves . and .. elements in a path with directory names
+function normalizeStringPosix(path, allowAboveRoot) {
+  var res = '';
+  var lastSegmentLength = 0;
+  var lastSlash = -1;
+  var dots = 0;
+  var code;
+  for (var i = 0; i <= path.length; ++i) {
+    if (i < path.length)
+      code = path.charCodeAt(i);
+    else if (code === 47 /*/*/)
+      break;
+    else
+      code = 47 /*/*/;
+    if (code === 47 /*/*/) {
+      if (lastSlash === i - 1 || dots === 1) {
+        // NOOP
+      } else if (lastSlash !== i - 1 && dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 /*.*/ || res.charCodeAt(res.length - 2) !== 46 /*.*/) {
+          if (res.length > 2) {
+            var lastSlashIndex = res.lastIndexOf('/');
+            if (lastSlashIndex !== res.length - 1) {
+              if (lastSlashIndex === -1) {
+                res = '';
+                lastSegmentLength = 0;
+              } else {
+                res = res.slice(0, lastSlashIndex);
+                lastSegmentLength = res.length - 1 - res.lastIndexOf('/');
+              }
+              lastSlash = i;
+              dots = 0;
+              continue;
+            }
+          } else if (res.length === 2 || res.length === 1) {
+            res = '';
+            lastSegmentLength = 0;
+            lastSlash = i;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          if (res.length > 0)
+            res += '/..';
+          else
+            res = '..';
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0)
+          res += '/' + path.slice(lastSlash + 1, i);
+        else
+          res = path.slice(lastSlash + 1, i);
+        lastSegmentLength = i - lastSlash - 1;
+      }
+      lastSlash = i;
+      dots = 0;
+    } else if (code === 46 /*.*/ && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+
+function _format(sep, pathObject) {
+  var dir = pathObject.dir || pathObject.root;
+  var base = pathObject.base || (pathObject.name || '') + (pathObject.ext || '');
+  if (!dir) {
+    return base;
+  }
+  if (dir === pathObject.root) {
+    return dir + base;
+  }
+  return dir + sep + base;
+}
+
+var posix = {
+  // path.resolve([from ...], to)
+  resolve: function resolve() {
+    var resolvedPath = '';
+    var resolvedAbsolute = false;
+    var cwd;
+
+    for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+      var path;
+      if (i >= 0)
+        path = arguments[i];
+      else {
+        if (cwd === undefined)
+          cwd = process.cwd();
+        path = cwd;
+      }
+
+      assertPath(path);
+
+      // Skip empty entries
+      if (path.length === 0) {
+        continue;
+      }
+
+      resolvedPath = path + '/' + resolvedPath;
+      resolvedAbsolute = path.charCodeAt(0) === 47 /*/*/;
+    }
+
+    // At this point the path should be resolved to a full absolute path, but
+    // handle relative paths to be safe (might happen when process.cwd() fails)
+
+    // Normalize the path
+    resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
+
+    if (resolvedAbsolute) {
+      if (resolvedPath.length > 0)
+        return '/' + resolvedPath;
+      else
+        return '/';
+    } else if (resolvedPath.length > 0) {
+      return resolvedPath;
+    } else {
+      return '.';
+    }
+  },
+
+  normalize: function normalize(path) {
+    assertPath(path);
+
+    if (path.length === 0) return '.';
+
+    var isAbsolute = path.charCodeAt(0) === 47 /*/*/;
+    var trailingSeparator = path.charCodeAt(path.length - 1) === 47 /*/*/;
+
+    // Normalize the path
+    path = normalizeStringPosix(path, !isAbsolute);
+
+    if (path.length === 0 && !isAbsolute) path = '.';
+    if (path.length > 0 && trailingSeparator) path += '/';
+
+    if (isAbsolute) return '/' + path;
+    return path;
+  },
+
+  isAbsolute: function isAbsolute(path) {
+    assertPath(path);
+    return path.length > 0 && path.charCodeAt(0) === 47 /*/*/;
+  },
+
+  join: function join() {
+    if (arguments.length === 0)
+      return '.';
+    var joined;
+    for (var i = 0; i < arguments.length; ++i) {
+      var arg = arguments[i];
+      assertPath(arg);
+      if (arg.length > 0) {
+        if (joined === undefined)
+          joined = arg;
+        else
+          joined += '/' + arg;
+      }
+    }
+    if (joined === undefined)
+      return '.';
+    return posix.normalize(joined);
+  },
+
+  relative: function relative(from, to) {
+    assertPath(from);
+    assertPath(to);
+
+    if (from === to) return '';
+
+    from = posix.resolve(from);
+    to = posix.resolve(to);
+
+    if (from === to) return '';
+
+    // Trim any leading backslashes
+    var fromStart = 1;
+    for (; fromStart < from.length; ++fromStart) {
+      if (from.charCodeAt(fromStart) !== 47 /*/*/)
+        break;
+    }
+    var fromEnd = from.length;
+    var fromLen = fromEnd - fromStart;
+
+    // Trim any leading backslashes
+    var toStart = 1;
+    for (; toStart < to.length; ++toStart) {
+      if (to.charCodeAt(toStart) !== 47 /*/*/)
+        break;
+    }
+    var toEnd = to.length;
+    var toLen = toEnd - toStart;
+
+    // Compare paths to find the longest common path from root
+    var length = fromLen < toLen ? fromLen : toLen;
+    var lastCommonSep = -1;
+    var i = 0;
+    for (; i <= length; ++i) {
+      if (i === length) {
+        if (toLen > length) {
+          if (to.charCodeAt(toStart + i) === 47 /*/*/) {
+            // We get here if `from` is the exact base path for `to`.
+            // For example: from='/foo/bar'; to='/foo/bar/baz'
+            return to.slice(toStart + i + 1);
+          } else if (i === 0) {
+            // We get here if `from` is the root
+            // For example: from='/'; to='/foo'
+            return to.slice(toStart + i);
+          }
+        } else if (fromLen > length) {
+          if (from.charCodeAt(fromStart + i) === 47 /*/*/) {
+            // We get here if `to` is the exact base path for `from`.
+            // For example: from='/foo/bar/baz'; to='/foo/bar'
+            lastCommonSep = i;
+          } else if (i === 0) {
+            // We get here if `to` is the root.
+            // For example: from='/foo'; to='/'
+            lastCommonSep = 0;
+          }
+        }
+        break;
+      }
+      var fromCode = from.charCodeAt(fromStart + i);
+      var toCode = to.charCodeAt(toStart + i);
+      if (fromCode !== toCode)
+        break;
+      else if (fromCode === 47 /*/*/)
+        lastCommonSep = i;
+    }
+
+    var out = '';
+    // Generate the relative path based on the path difference between `to`
+    // and `from`
+    for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
+      if (i === fromEnd || from.charCodeAt(i) === 47 /*/*/) {
+        if (out.length === 0)
+          out += '..';
+        else
+          out += '/..';
+      }
+    }
+
+    // Lastly, append the rest of the destination (`to`) path that comes after
+    // the common path parts
+    if (out.length > 0)
+      return out + to.slice(toStart + lastCommonSep);
+    else {
+      toStart += lastCommonSep;
+      if (to.charCodeAt(toStart) === 47 /*/*/)
+        ++toStart;
+      return to.slice(toStart);
+    }
+  },
+
+  _makeLong: function _makeLong(path) {
+    return path;
+  },
+
+  dirname: function dirname(path) {
+    assertPath(path);
+    if (path.length === 0) return '.';
+    var code = path.charCodeAt(0);
+    var hasRoot = code === 47 /*/*/;
+    var end = -1;
+    var matchedSlash = true;
+    for (var i = path.length - 1; i >= 1; --i) {
+      code = path.charCodeAt(i);
+      if (code === 47 /*/*/) {
+          if (!matchedSlash) {
+            end = i;
+            break;
+          }
+        } else {
+        // We saw the first non-path separator
+        matchedSlash = false;
+      }
+    }
+
+    if (end === -1) return hasRoot ? '/' : '.';
+    if (hasRoot && end === 1) return '//';
+    return path.slice(0, end);
+  },
+
+  basename: function basename(path, ext) {
+    if (ext !== undefined && typeof ext !== 'string') throw new TypeError('"ext" argument must be a string');
+    assertPath(path);
+
+    var start = 0;
+    var end = -1;
+    var matchedSlash = true;
+    var i;
+
+    if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {
+      if (ext.length === path.length && ext === path) return '';
+      var extIdx = ext.length - 1;
+      var firstNonSlashEnd = -1;
+      for (i = path.length - 1; i >= 0; --i) {
+        var code = path.charCodeAt(i);
+        if (code === 47 /*/*/) {
+            // If we reached a path separator that was not part of a set of path
+            // separators at the end of the string, stop now
+            if (!matchedSlash) {
+              start = i + 1;
+              break;
+            }
+          } else {
+          if (firstNonSlashEnd === -1) {
+            // We saw the first non-path separator, remember this index in case
+            // we need it if the extension ends up not matching
+            matchedSlash = false;
+            firstNonSlashEnd = i + 1;
+          }
+          if (extIdx >= 0) {
+            // Try to match the explicit extension
+            if (code === ext.charCodeAt(extIdx)) {
+              if (--extIdx === -1) {
+                // We matched the extension, so mark this as the end of our path
+                // component
+                end = i;
+              }
+            } else {
+              // Extension does not match, so our result is the entire path
+              // component
+              extIdx = -1;
+              end = firstNonSlashEnd;
+            }
+          }
+        }
+      }
+
+      if (start === end) end = firstNonSlashEnd;else if (end === -1) end = path.length;
+      return path.slice(start, end);
+    } else {
+      for (i = path.length - 1; i >= 0; --i) {
+        if (path.charCodeAt(i) === 47 /*/*/) {
+            // If we reached a path separator that was not part of a set of path
+            // separators at the end of the string, stop now
+            if (!matchedSlash) {
+              start = i + 1;
+              break;
+            }
+          } else if (end === -1) {
+          // We saw the first non-path separator, mark this as the end of our
+          // path component
+          matchedSlash = false;
+          end = i + 1;
+        }
+      }
+
+      if (end === -1) return '';
+      return path.slice(start, end);
+    }
+  },
+
+  extname: function extname(path) {
+    assertPath(path);
+    var startDot = -1;
+    var startPart = 0;
+    var end = -1;
+    var matchedSlash = true;
+    // Track the state of characters (if any) we see before our first dot and
+    // after any path separator we find
+    var preDotState = 0;
+    for (var i = path.length - 1; i >= 0; --i) {
+      var code = path.charCodeAt(i);
+      if (code === 47 /*/*/) {
+          // If we reached a path separator that was not part of a set of path
+          // separators at the end of the string, stop now
+          if (!matchedSlash) {
+            startPart = i + 1;
+            break;
+          }
+          continue;
+        }
+      if (end === -1) {
+        // We saw the first non-path separator, mark this as the end of our
+        // extension
+        matchedSlash = false;
+        end = i + 1;
+      }
+      if (code === 46 /*.*/) {
+          // If this is our first dot, mark it as the start of our extension
+          if (startDot === -1)
+            startDot = i;
+          else if (preDotState !== 1)
+            preDotState = 1;
+      } else if (startDot !== -1) {
+        // We saw a non-dot and non-path separator before our dot, so we should
+        // have a good chance at having a non-empty extension
+        preDotState = -1;
+      }
+    }
+
+    if (startDot === -1 || end === -1 ||
+        // We saw a non-dot character immediately before the dot
+        preDotState === 0 ||
+        // The (right-most) trimmed path component is exactly '..'
+        preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+      return '';
+    }
+    return path.slice(startDot, end);
+  },
+
+  format: function format(pathObject) {
+    if (pathObject === null || typeof pathObject !== 'object') {
+      throw new TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof pathObject);
+    }
+    return _format('/', pathObject);
+  },
+
+  parse: function parse(path) {
+    assertPath(path);
+
+    var ret = { root: '', dir: '', base: '', ext: '', name: '' };
+    if (path.length === 0) return ret;
+    var code = path.charCodeAt(0);
+    var isAbsolute = code === 47 /*/*/;
+    var start;
+    if (isAbsolute) {
+      ret.root = '/';
+      start = 1;
+    } else {
+      start = 0;
+    }
+    var startDot = -1;
+    var startPart = 0;
+    var end = -1;
+    var matchedSlash = true;
+    var i = path.length - 1;
+
+    // Track the state of characters (if any) we see before our first dot and
+    // after any path separator we find
+    var preDotState = 0;
+
+    // Get non-dir info
+    for (; i >= start; --i) {
+      code = path.charCodeAt(i);
+      if (code === 47 /*/*/) {
+          // If we reached a path separator that was not part of a set of path
+          // separators at the end of the string, stop now
+          if (!matchedSlash) {
+            startPart = i + 1;
+            break;
+          }
+          continue;
+        }
+      if (end === -1) {
+        // We saw the first non-path separator, mark this as the end of our
+        // extension
+        matchedSlash = false;
+        end = i + 1;
+      }
+      if (code === 46 /*.*/) {
+          // If this is our first dot, mark it as the start of our extension
+          if (startDot === -1) startDot = i;else if (preDotState !== 1) preDotState = 1;
+        } else if (startDot !== -1) {
+        // We saw a non-dot and non-path separator before our dot, so we should
+        // have a good chance at having a non-empty extension
+        preDotState = -1;
+      }
+    }
+
+    if (startDot === -1 || end === -1 ||
+    // We saw a non-dot character immediately before the dot
+    preDotState === 0 ||
+    // The (right-most) trimmed path component is exactly '..'
+    preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+      if (end !== -1) {
+        if (startPart === 0 && isAbsolute) ret.base = ret.name = path.slice(1, end);else ret.base = ret.name = path.slice(startPart, end);
+      }
+    } else {
+      if (startPart === 0 && isAbsolute) {
+        ret.name = path.slice(1, startDot);
+        ret.base = path.slice(1, end);
+      } else {
+        ret.name = path.slice(startPart, startDot);
+        ret.base = path.slice(startPart, end);
+      }
+      ret.ext = path.slice(startDot, end);
+    }
+
+    if (startPart > 0) ret.dir = path.slice(0, startPart - 1);else if (isAbsolute) ret.dir = '/';
+
+    return ret;
+  },
+
+  sep: '/',
+  delimiter: ':',
+  win32: null,
+  posix: null
+};
+
+posix.posix = posix;
+
+module.exports = posix;
+
+
 /***/ }),
 
 /***/ "./node_modules/pbkdf2/browser.js":
@@ -145088,6 +146105,8 @@ __webpack_require__(/*! gun/lib/radisk */ "./node_modules/gun/lib/radisk.js");
 __webpack_require__(/*! gun/lib/store */ "./node_modules/gun/lib/store.js");
 __webpack_require__(/*! gun/lib/rindexed */ "./node_modules/gun/lib/rindexed.js");
 __webpack_require__(/*! gun/lib/webrtc */ "./node_modules/gun/lib/webrtc.js");
+__webpack_require__(/*! gun/lib/wire */ "./node_modules/gun/lib/wire.js");
+__webpack_require__(/*! gun/lib/axe */ "./node_modules/gun/lib/axe.js");
 const derive_1 = __importDefault(__webpack_require__(/*! ./derive */ "./src/gundb/derive.ts"));
 exports.derive = derive_1.default;
 const errorHandler_1 = __webpack_require__(/*! ../utils/errorHandler */ "./src/utils/errorHandler.ts");
@@ -145098,6 +146117,7 @@ const GunErrors = __importStar(__webpack_require__(/*! ./errors */ "./src/gundb/
 exports.GunErrors = GunErrors;
 const crypto = __importStar(__webpack_require__(/*! ./crypto */ "./src/gundb/crypto.ts"));
 exports.crypto = crypto;
+const shogun_relays_1 = __importStar(__webpack_require__(/*! shogun-relays */ "./node_modules/shogun-relays/index.js"));
 /**
  * Configuration constants for timeouts and security
  */
@@ -146865,11 +147885,30 @@ class DataBase {
     isAuthenticated() {
         return this.user?.is?.pub ? true : false;
     }
+    /**
+     *
+     * @returns Promise resolving with the list of relays
+     */
+    async getRelays() {
+        return (0, shogun_relays_1.default)();
+    }
+    /**
+     *
+     * @returns Promise resolving with the list of relays
+     */
+    async forceListUpdate() {
+        const freshRelays = await (0, shogun_relays_1.forceListUpdate)();
+        freshRelays.forEach((relay) => {
+            console.log("Adding relay:", relay);
+            this.addPeer(relay);
+        });
+        return freshRelays;
+    }
 }
 exports.DataBase = DataBase;
 // Errors
 DataBase.Errors = GunErrors;
-const createGun = (config, silent) => {
+const createGun = (config) => {
     const gunInstance = (0, gun_1.default)(config);
     return gunInstance;
 };
@@ -148120,10 +149159,13 @@ exports.AuthManager = AuthManager;
 /*!*****************************************!*\
   !*** ./src/managers/CoreInitializer.ts ***!
   \*****************************************/
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
 
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.CoreInitializer = void 0;
 const storage_1 = __webpack_require__(/*! ../storage/storage */ "./src/storage/storage.ts");
@@ -148133,7 +149175,7 @@ const web3ConnectorPlugin_1 = __webpack_require__(/*! ../plugins/web3/web3Connec
 const nostrConnectorPlugin_1 = __webpack_require__(/*! ../plugins/nostr/nostrConnectorPlugin */ "./src/plugins/nostr/nostrConnectorPlugin.ts");
 const zkProofPlugin_1 = __webpack_require__(/*! ../plugins/zkproof/zkProofPlugin */ "./src/plugins/zkproof/zkProofPlugin.ts");
 const gundb_1 = __webpack_require__(/*! ../gundb */ "./src/gundb/index.ts");
-const shogun_relays_1 = __webpack_require__(/*! shogun-relays */ "./node_modules/shogun-relays/index.js");
+const shogun_relays_1 = __importDefault(__webpack_require__(/*! shogun-relays */ "./node_modules/shogun-relays/index.js"));
 /**
  * Handles initialization of ShogunCore components
  */
@@ -148190,17 +149232,17 @@ class CoreInitializer {
     // Sì, è corretto.
     async initializeGun(config) {
         try {
-            let peers = await (0, shogun_relays_1.forceListUpdate)();
-            if (config.gunOptions?.peers &&
-                (config.gunOptions?.peers?.length === 0 || !config.gunOptions?.peers) &&
-                !config.gunInstance) {
+            let peers = await (0, shogun_relays_1.default)();
+            if (!config.gunOptions?.peers && !config.gunInstance) {
                 console.log("Using peers from forceListUpdate", peers);
                 config.gunOptions.peers = peers;
             }
             if (config.gunInstance) {
+                console.log("Using existing Gun instance:", config.gunInstance);
                 this.core._gun = config.gunInstance;
             }
             else if (config.gunOptions && config.gunInstance === undefined) {
+                console.log("Creating Gun instance with config:", config.gunOptions);
                 this.core._gun = (0, gundb_1.createGun)(config.gunOptions);
             }
             else if (config.gunInstance && config.gunOptions) {