@yz-social/civildefense.io 4.4.1 → 4.4.4

package/index.js

@@ -1,2 +1,4 @@
 export { P2PWebNetwork } from "./public/javascripts/p2pWebNetwork.js";
 export { agentTopic, alertTopic, canonicalTag } from "./public/javascripts/versions.js";
+export { getContainingCells } from "./public/javascripts/s2.js";
+export { location } from "./server/getLocation.js";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@yz-social/civildefense.io",
   "description": "Browser app to safely share live sightings on a map.",
-  "version": "4.4.1",
+  "version": "4.4.4",
   "keywords": [
     "map",
     "browser",

package/public/index.html

@@ -29,11 +29,8 @@
 	  "leaflet": "./leaflet/leaflet-src.esm.js",
 	  "minidenticons": "./minidenticons/minidenticons.min.js",
 	  "@axona/protocol": "./axona-protocol/src/index.js",
-	  "@axona/protocol/std": "./axona-protocol/std/index.js",
-	  "@axona/protocol/transport/web/index.js": "./axona-protocol/src/transport/web/index.js",
-          "@yz-social/kdht": "./kdht/index.js",
-	  "@yz-social/webrtc": "./webrtc/index.js",
-	  "scripting": "./javascripts/scripting.js"
+          "@axona/protocol/std": "./axona-protocol/std/index.js",
+	  "@axona/protocol/connect.js": "./axona-protocol/src/connect.js"
         }
       }
     </script>

package/public/javascripts/agent.js

@@ -136,7 +136,7 @@ export class Agent {
       // Our downsampling is such that we do not need to chunkify.
       // if (type === 'avatar') {
       // 	const blob = await P2PWebNetwork.dataURL2blob(value);
-      // 	payload = await contact.chunkifyBlob({blob, region});
+      // 	payload = (await contact.chunkifyBlob({blob, region})).topic;
       // }
       return contact.publish({eventName, region, owner, payload});
     }

package/public/javascripts/main.js

@@ -41,6 +41,7 @@ export function tooltip(elementOrQuerySelector, text) { // Add plain tooltip tex
 }
 export function clickTip(elementOrQuerySelector, text, clickHandler) { // tooltip and onclick in one step.
   const element = asElement(elementOrQuerySelector);
+  if (element.id === 'downloadUpdates2') console.log('assigning title', text, 'and', clickHandler, 'to', element);
   tooltip(element, text);
   element.onclick = clickHandler;
 }
@@ -363,6 +364,7 @@ document.querySelector('head > title').innerHTML = titleElement.textContent;
 function initText(selector, content = selector) {
   const element = document.querySelector(selector);
   const text = Int([content]);
+  if (element.id === 'downloadUpdates2') console.log('assigning', text, 'to', element);
   element.textContent = text;
 }
 initText('#aboutReport');

package/public/javascripts/map.js

@@ -486,7 +486,7 @@ export class Marker { // A wrapper around L.marker
     inputElement.querySelector('md-filled-icon-button').toggleAttribute('disabled', true);
     const contact = await networkPromise;
     if (files.length) {
-      const file = await contact.chunkifyBlob({blob: files[0], region});
+      const {topic:file} = await contact.chunkifyBlob({blob: files[0], region});
       payload = {message: payload, file};
     }
     await contact.publish({eventName: subject, region, payload}); // Publish the new reply.
@@ -502,7 +502,7 @@ export class Marker { // A wrapper around L.marker
     const formatReply = ({subject, payload, ...rest}) => {
       const {message = payload, file, name} = payload;
       let text = message
-	  .replace(/https?:\/\/\S+\.(mp3|aac|ogg|oga|opus|m4a|m3u8|mpd)$/ig, url => `<audio controls src="${url}"></audio>`) // show audio urls as players
+	  .replace(/https?:\/\/\S+\.(mp3|aac|ogg|oga|opus|m4a|m3u8|m3u|mpu|mpd)$/ig, url => `<audio controls src="${url}"></audio>`) // show audio urls as players
 	  .replace(/https?:\/\/\S+\.(mp4|mov|webm)$/ig, url => `<video controls src="${url}"></video>`) // show video urls as players
 	  .replace(/(?<!")https?:\/\/\S+/g, url => `<a href="${url}" target="yz.sidebar">${url}</a>`); // show urls as links
       let attachment = '';

package/public/javascripts/p2pWebNetwork.js

@@ -1,7 +1,7 @@
 import { v4 as uuidv4 } from 'uuid';
-import { AxonaPeer, AxonaDomain, NeuronNode, createNodeIdentity, createAuthorIdentity, geoCellId, geoCellCenter, WIRE_VERSION, KERNEL_VERSION } from '@axona/protocol';
+import { createNodeIdentity, createAuthorIdentity, geoCellId, geoCellCenter, WIRE_VERSION, KERNEL_VERSION } from '@axona/protocol';
 import { stringToBytes, bytesToString, publishChunkedBytes, receiveChunkedBytes } from '@axona/protocol/std';
-import { webTransport } from '@axona/protocol/transport/web/index.js';
+import { connect } from '@axona/protocol/connect.js';
 globalThis.RTCPeerConnection ||= await import('node-datachannel/polyfill').then(ndc => ndc.RTCPeerConnection);
 const { BigInt, URL, File, pica } = globalThis;
 
@@ -20,60 +20,36 @@ export class P2PWebNetwork {
   static setSessionRegion = resolveSessionRegion;
   static sessionRegion = sessionRegionPromise;
   static async create({infoLogger = console.log, debugLogger,
-		       region, identity, bridgeUrl = 'wss://bridge.axona.net',
-		       synapseCount = 4, timeoutMs = 10e3} = {}) {
+		       region = this.sessionRegion, bridgeUrl = 'wss://bridge.axona.net',
+		      } = {}) {
     // Promise a ready-to-use network peer.
-    // Complex region/identity behavior: Must pass either identity or region (either can be a promise), or will wait for setSessionRegion() to be called.
-    if (!identity) region ||= this.canonicalizeRegion(await (region || this.sessionRegion));
-    identity ||= createNodeIdentity(region);
-    identity = await identity;
-    region ||= identity.region;
-
-    const transport = webTransport({bridgeUrl, identity});
-    const node = new NeuronNode({lat: region.lat, lng: region.lng, id: BigInt('0x' + identity.id)});
-    node.transport = transport; // FIXME: pass in to constructor?
-    const domain   = new AxonaDomain({ k: 20 }); // FIXME: can't this be defaulted in AxonaPeer?
-    const peer = new  AxonaPeer({domain, node, identity, transport});
+    const { peer, nodeIdentity, status, disconnect } = await connect({
+      bridge: bridgeUrl,
+      location: await region,
+      author: false
+    });
 
     const network = new this();
-    Object.assign(network, {infoLogger, debugLogger, identity, transport, node, peer});
+    Object.assign(network, {infoLogger, debugLogger, /*identity, transport, node,*/ disconnector: disconnect, identity: nodeIdentity, peer});
     network.resetStatePromises();
-    network.info('Created network node for kernel', this.kernelVersion);
-    await network.connect({synapseCount, timeoutMs});
+    network.info(`Created network node for kernel ${this.kernelVersion} region 0x${this.regionCode(region.lat, region.lng).toString(16)}.`);
+    const { peers, ms } = status;
+    network.info(`Connected ${peers} connections in ${ms.toLocaleString()} ms.`);
+    network.attached(network);
     return network;
   }
   
-  async connect({synapseCount = 4, timeoutMs = 10e3} = {}) {
-    // Returned promise resolves when ready for use. Can be cycled through disconnect()/connect().
-    await this.transport.start(this.identity.id);
-    await this.join();
-    this.debug('Joined', this.health().synaptomeSize, 'connections.');
-    if (parseInt(this.constructor.kernelVersion) < 4) {
-      const t0 = Date.now();
-      while (Date.now() - t0 < timeoutMs) {
-	const size = this.synaptomeSize;
-	if (size >= synapseCount) break;
-	await this.constructor.delay(200);
-      }
-    } else {
-      await this.peer.ready({ minPeers: synapseCount, timeoutMs });
-    }
-    this.info('Connected', this.health().synaptomeSize, 'connections.');
-    this.attached(this);
-    return this;
-  }
   async disconnect() { // Politely close network connection.
-    const health = this.health();
-    await this.leave();
+    const health = this.peer.health();
+    await this.disconnector();
     this.info(`disconnected with ${health.peers.length} connections and ${health.axonRoles.length} axons.`);
-    await this.stop();
     this.resetStatePromises();
   }
   async replicateStorage() { // Let the network know that we might go away without further notice.
     // FIXME. It would be great if we could remove ourselves from any non-leaf positions in the Axon, but stay subscribed.
   }
   fastDisconnect() { // Synchronous attempt to be polite to those connected.
-    this.leave(); // Execution is asynchronous. Will not finish -- or perhaps even really start -- within the call.
+    this.peer.leave(); // Execution is asynchronous. Will not finish -- or perhaps even really start -- within the call.
   }
 
   async chunkifyString({string, region, signWith = this.constructor.currentPublishIdentity, owner = signWith.authorId}) {
@@ -88,7 +64,7 @@ export class P2PWebNetwork {
     return bytesToString(data.bytes);
   }
 
-  static getCanvas(file) { // Promise a Canvas from a File of type image/*.
+  static getCanvas(file) { // Promise a Canvas from a File of type image/*. ONLY IN BROWSERS!
     return new Promise((resolve, reject) => {
       const img = new Image();
       const canvas = document.createElement('canvas');
@@ -104,7 +80,7 @@ export class P2PWebNetwork {
       img.src = URL.createObjectURL(file);
     });
   }
-  static  async downsampledBlob({blob, outputType = 'image/jpeg', maxDimension = 1024}) {
+  static  async downsampledBlob({blob, outputType = 'image/jpeg', maxDimension = 1024}) { // ONLY IN BROWSERS!
     // Promise a reasonably sized Blob (or File) for a given Blob of type image/*, else blob unchanged.
     if (!blob.type.startsWith('image/')) return blob;
 
@@ -152,22 +128,24 @@ export class P2PWebNetwork {
     return new File([blob], filename, {type: blob.type});
   }
   async chunkifyBlob({blob, region, signWith = this.constructor.currentPublishIdentity, owner = signWith.authorId, maxDimension = 1024, ...rest}) {
-    // Publish Blob (or File) and answer an identifier that can be used to re-assemble.
+    // Publish Blob (or File) and answer an identifier that can be used to re-assemble. Truthy maxDimension works only in browsers!
     if (!blob.size) throw new Error(`Cannot chunkify empty Blob.`);
     if (maxDimension) blob = await this.constructor.downsampledBlob({blob, maxDimension});
     const {type:mime, name} = blob;
     const topic = {name: uuidv4(), region, owner};
     const buffer = await blob.arrayBuffer();
     const u8 = new Uint8Array(buffer);
-    console.log('blob', blob.size, u8.length);
+    //console.log('blob', blob.size, u8.length);
     const data = await publishChunkedBytes(this.peer, u8, {topic, signWith, mime, name, ...rest});
-    return data.topic;
+    this.debug('chunked', data);
+    return data;
   }
   async assembleChunkedDataURL(topic) { // Promise {bytes, mime, name, dataURL} that was chunkified to topic.
     const data = await receiveChunkedBytes(this.peer, topic, {/*, onProgress: console.log*/});
     // Using dataURL is not terribly efficient, but it is convenient, because formatReplies can return HTML strings with all the data in them,
     // instead of, e.g., needing javascript to later set properties of elements to createObjectURL of a Blob.
     data.dataURL = this.constructor.u82dataURL(data.bytes, data.mime);
+    this.debug('assembled', topic);
     return data;
   }
 
@@ -181,7 +159,7 @@ export class P2PWebNetwork {
     if (handler) {
       const callback = async envelope => {
 	const {message, deleted, msgId, signerPubkey, topic, ts} = envelope;
-	//console.log('fired', {msgId, topic, ts, signerPubkey, deleted, message});
+	this.debug('received', {msgId, topic, ts, signerPubkey, deleted, message});
 	if (deleted) {
 	  handler({subject: msgId, payload: null, agent: signerPubkey, topic, ts}); // fixme remove topic, ts here and below.
 	  return;
@@ -200,17 +178,26 @@ export class P2PWebNetwork {
     const topic = {region, name: eventName};
     if (owner) topic.owner = owner;
     const options = {signWith};
-    //console.log({topic, subject, payload, issuedTime, rest, signWith});
+    this.debug('published', {topic, subject, payload, issuedTime, rest, signWith});
     if (payload) return await this.peer.pub(topic, {issuedTime, payload, ...rest}, options);
     // The next would not normally happen, but until since:'latest' works, we need a way to send a null payload and have the handler delete the entry.
     if (!subject) return await this.peer.pub(topic, {issuedTime, payload, ...rest}, options);
     return await this.peer.kill(topic, subject, options);
   }
 
+  host() {
+    return this.peer.host();
+  }
+  unhost() {
+    return this.peer.unhost();
+  }
   // Mostly internal stuff.
   static regionCode(lat, lng) { // Answer containing region code.
     return geoCellId(lat, lng);
   }
+  static regionCenter(regionCode) {
+    return geoCellCenter(regionCode);
+  }
   static delay(ms, result) { // Promise result after ms milliseconds.
     return new Promise(resolve => setTimeout(resolve, ms, result));
   }
@@ -224,12 +211,9 @@ export class P2PWebNetwork {
   static canonicalizeRegion(lat, lng) {
     // Answer a {lat, lng} that is the center of a top-level Axona region containing the given {lat, lng}.
     // E.g., a precise location gets anonymized to containing top-level cell center.
-    return geoCellCenter(geoCellId(lat, lng));
-  }
-  get synaptomeSize() { // Safely answer the number of connections.
-    return this.node.synaptome?.size ?? 0;
+    return this.regionCenter(this.regionCode(lat, lng));
   }
-  // TODO: Integrate with AxonaPeer's complex logging.
+  // Todo: Integrate with AxonaPeer's complex logging.
   debug(...rest) { // Add debug logspam.
     this.debugLogger?.(this.identity.id, ...rest);
   }
@@ -238,8 +222,3 @@ export class P2PWebNetwork {
   }
 }
 export default P2PWebNetwork;
-
-// For now, we want to override publish and subscribe, but that conflicts with internal messages on AxonaPeer.
-// Thus P2PWebNetwork has an AxonaPeer, instead of inheriting from it. And thus we need forwarding messages.
-['join', 'leave', 'stop', 'health', 'host', 'unhost']
-  .forEach(methodName => P2PWebNetwork.prototype[methodName] = function (...rest) {return this.peer[methodName](...rest);});

package/public/javascripts/service-manager.js

@@ -71,7 +71,10 @@ function newVersionAvailable(newVersion) {
   updateText.textContent = `${Int`Version`} ${newVersion} ${Int`available`}.`;
   openDisplay('updateContainer');
 }
-async function installUpdate(newVersion) {
+async function installUpdate(event, newVersion) {
+  event.stopPropagation();
+  event.target.textContent = "Installing..."; // In case there is some delay, tell the user what we're trying to do. Will be cleared with reload.
+  event.target.disabled = true;
   await caches.delete(appVersion); // Must be before cacheSource, or we'll just recache the same files!
   await cacheSource(newVersion);
   // Reload, but convince all browsers to re-"fetch" (through the new service worker that is now running).
@@ -91,11 +94,9 @@ await navigator.serviceWorker
     let serviceVersion;
     // No need to reset button/status on click, because we will be reloading.
     const installText = Int`Update to a new version of this app.`;
-    clickTip(downloadButton, installText, () => installUpdate(serviceVersion));
-    clickTip(downloadButton2, installText, () => event => {
-      event.stopPropagation();
-      installUpdate(serviceVersion);
-    });
+    const installHandler = event => installUpdate(event, serviceVersion);
+    clickTip(downloadButton, installText, installHandler);
+    clickTip(downloadButton2, installText, installHandler);
     clickTip(checkButton, Int`Check to see if a new version of the app is available.`, async event => {
       resetInactivityTimer();
       event.stopPropagation();

package/public/javascripts/translations.js

@@ -71,7 +71,7 @@ const translations = {
   ['#newVersionHeader']: {en: "New version available", es: "Nueva versión disponible"},
   ['#updateNowQuestion']: {en: "Would you like to update now?", es: "¿Le gustaría actualizar ahora?"},
   ['#updateReload']: {en: "All CivilDefense.io tabs will reload.", es: "Todas las pestañas de CivilDefense.io se recargarán."},
-  ['#updateDefer']: {en: "Alternatively, you can update later through the button in About.", es: "Alternativamente, puede actualizar más tarde a través del botón en «Acerca de»."},
+  ['#updateDefer']: {en: 'Alternatively, you can update later through the "CD" button again.', es: 'Alternativamente, puede actualizar más tarde utilizando nuevamente el botón "CD".'},
   ['#downloadUpdates2']: {en: "yes, update", es: "Sí, actualizar."},
   ['#downloadDefer']: {en: "no, not yet", es: "No, todavía no."},
   ['No update at']: {es: "No hay actualizaciones a las"},

package/public/service-worker.js

@@ -1,6 +1,6 @@
 const { Request, Response, URL, clients} = self;
 // Little point in trying to automatically pull this through package.json, as we need a byte change in THIS file to trigger a new worker.
-const serviceVersion = '4.4.1';
+const serviceVersion = '4.4.4';
 
 async function cacheFirst({request, event}) {
   // Handle request from any cache, else fetch and store it in serviceCache.

package/server/app.js

@@ -99,10 +99,9 @@ if (cluster.isPrimary) { // Parent process with portal webserver through which c
   for (let i = 0; i < argv.nPortals; i++) cluster.fork();
 } else {
   process.title = 'axona-starting';
-  const { P2PWebNetwork } = await import('../public/javascripts/p2pWebNetwork.js');
+  const { P2PWebNetwork, location } = await import('../index.js');
   await P2PWebNetwork.delay(cluster.worker?.id * 1e3); // One second between startups.
-  const { location:region } = await import('./getLocation.js');  // First invocation caches.
-  const network = await P2PWebNetwork.create({region});
+  const network = await P2PWebNetwork.create({region: location});
   process.title = 'axona-' + network.identity.id;
   let update = null//setInterval(() => network.info(network.health().axonRoles.map(role => role.topic)), 5e3);
   process.on('SIGINT', async () => { // Leave the network politely.

package/server/getLocation.js

@@ -6,7 +6,8 @@ import fs from 'fs/promises';
 import { resolve } from './dirname.js';
 const filename = './location.json';
 export const data = await import(filename, {with: { type: 'json' }})
-  .catch(async () => {
+  .catch(async error => {
+    console.log(error);
     const response = await fetch('https://ipinfo.io/json');
     const string = await response.text();
     console.log('Estimating location as', string);

package/server/location.json

@@ -1,12 +1,7 @@
 {
-  "ip": "99.122.55.96",
-  "hostname": "99-122-55-96.lightspeed.sntcca.sbcglobal.net",
-  "city": "Redwood City",
-  "region": "California",
-  "country": "US",
-  "loc": "37.4852,-122.2364",
-  "org": "AS7018 AT&T Enterprises, LLC",
-  "postal": "94061",
-  "timezone": "America/Los_Angeles",
-  "readme": "https://ipinfo.io/missingauth"
-}
+  "uswest/80": "37.4852,-122.2364",
+  "useast/89": "40,-75",
+  "uscentle/88": "35,-83",
+  "easteu/47": "50,17",  
+  "loc": "37.4852,-122.2364"
+}

package/spec/axonSpec.js

@@ -21,76 +21,43 @@
   David will join and subscribe after publications.
 */
 const { describe, it, expect, beforeAll, afterAll, BigInt } = globalThis;
-import { AxonaPeer, AxonaDomain, NeuronNode, createNodeIdentity, createAuthorIdentity, regionCenter, geoCellId, geoCellCenter, WIRE_VERSION, KERNEL_VERSION, deriveTopicId, metricTopic } from '@axona/protocol';
-
-// TODO: What is the right way to use Axona web transport. It doesn't seem to provide either a functioning export nor declare its dependencies.
-import { webTransport } from '@axona/protocol/transport/web/index.js';
+import { createAuthorIdentity, regionCenter, geoCellId, geoCellCenter, WIRE_VERSION, KERNEL_VERSION, deriveTopicId, metricTopic } from '@axona/protocol';
+import { connect } from '@axona/protocol/connect.js';
 globalThis.RTCPeerConnection ||= await import('node-datachannel/polyfill').then(ndc => ndc.RTCPeerConnection);
 
 class Node {  // Stuff we have to do every time. TODO: build something like this into Axona.
   static version = KERNEL_VERSION;
   log(...rest) {
-    console.log(new Date(), this.label, this.transportIdentity.id.slice(0, 10), ...rest);
+    console.log(new Date(), this.label, this.nodeIdentity.id.slice(0, 10), ...rest);
   }
-  static async create({location, transportIdentity, bridgeUrl = 'wss://testnet.axona.net',
-		       label = 'network', store, authorIdentity, 
-		       synapseCount = 4, timeoutMs = 10e3, ...rest} = {}) {
+  static async create({location, bridgeUrl = 'wss://testnet.axona.net',
+		       label = 'network', authorIdentity, store,
+		       ...rest} = {}) {
     // Promise a ready-to-use network peer.
-
-    const start = Date.now();
-    // Complex location/identity behavior: Must pass either identity or location {lat/lng} (either can be a promise).
-    if (!transportIdentity) location ||= this.canonicalizeRegion(await location);
-    transportIdentity ||= createNodeIdentity(location);
-    transportIdentity = await transportIdentity;
-    location ||= transportIdentity.region; // TODO: don't use the same term 'region' in different ways.
-
     if (typeof(authorIdentity) === 'string') // TODO: this is pretty awkward.
       authorIdentity = createAuthorIdentity({persistAs: label, store: {get() { return authorIdentity; }}});
     authorIdentity ||= createAuthorIdentity({persistAs: label, store});
     authorIdentity = await authorIdentity;
 
-    // FIXME: sometimes fails with "UpgradeRequiredError: bridge closed socket before handshake completed"
-    const transport = webTransport({bridgeUrl, identity: transportIdentity});
-    const node = new NeuronNode({lat: location.lat, lng: location.lng, id: BigInt('0x' + transportIdentity.id)});
-    node.transport = transport; // TODO: pass in to constructor?
-    const domain   = new AxonaDomain({ k: 20 }); // TODO: can't this be defaulted in AxonaPeer?
-    const peer = new  AxonaPeer({domain, node, identity: transportIdentity, transport});
+    const { peer, nodeIdentity, status, disconnect } = await connect({
+      bridge: bridgeUrl,
+      location: await location,
+      author: authorIdentity
+    });
 
     const self = new this();
-    Object.assign(self, {transportIdentity, transport, node, peer, label, authorIdentity, ...rest});
-    self.log(`created with kernel version ${this.version} in ${(Date.now() - start).toLocaleString()} ms.`);    
-    await self.connect({synapseCount, timeoutMs});
+    Object.assign(self, {peer, label, authorIdentity, nodeIdentity, disconnector: disconnect, ...rest});
+    self.log(`created with kernel version ${this.version}.`);
+    const { peers, ms } = status;
+    self.log(`connected ${peers} connections in ${ms.toLocaleString()} ms.`);
+
     return self;
   }
-  async connect({synapseCount = 4, timeoutMs = 10e3} = {}) {
-    // Returned promise resolves when ready for use.
-    // TODO: Currently, one cannot disconnect() and then later connect() - one is likely to get TransportError: bridge socket closed before open.
-    // So as it stands there's not really any point in this being a separate method from create().
-    const start = Date.now();
-    await this.transport.start(this.transportIdentity.id);
-    await this.peer.join();
-    if (parseInt(this.constructor.version) < 4) {
-      const t0 = Date.now();
-      while (Date.now() - t0 < timeoutMs) {
-	const size = this.synaptomeSize;
-	if (size >= synapseCount) break;
-	await this.constructor.delay(200);
-      }
-    } else {
-      await this.peer.ready({ minPeers: synapseCount, timeoutMs });
-    }
-    const elapsed = Date.now() - start;
-    // FIXME: most of the time, this completes in under two seconds. But not infrequently, it is much more.
-    // I've see it take 30 seconds -- even when there are nearby nodes standing by.
-    this.log(`connected to ${this.synaptomeSize} nodes in ${elapsed.toLocaleString()} ms${elapsed < 2e3 ? '.' : '!!!!!!!!!!!!!!!!'}`);
-    return this;
-  }
   async disconnect() { // Politely close network connection.
     const start = Date.now();
-    const health = this.health();
-    await this.peer.leave();
+    const health = this.peer.health();
+    await this.disconnector();
     this.log(`disconnected with ${health.peers.length} connections and ${health.axonRoles.length} axons in ${(Date.now() - start).toLocaleString()} ms.`);
-    await this.peer.stop();
   }
   async subscribe({eventName, region, owner, since = 'all', handler}) { // Assign handler for eventName, or remove any handler if falsy.
     const topic = {region, name: eventName};
@@ -133,12 +100,6 @@ class Node {  // Stuff we have to do every time. TODO: build something like this
   static delay(ms, result) { // Promise result after ms milliseconds.
     return new Promise(resolve => setTimeout(resolve, ms, result));
   }
-  get synaptomeSize() { // Safely answer the number of connections.
-    return this.node.synaptome?.size ?? 0;
-  }
-  health() { // from peer
-    return this.peer.health();
-  }
   host() { // through peer
     return this.peer.host();
   }