@yz-social/civildefense.io 4.4.3 → 4.5.4

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,38 @@ 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 = globalThis.process?.env.BRIDGE_URL || '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});
+    region = await region;
+    const { peer, nodeIdentity, transport, status, disconnect } = await connect({
+      bridge: bridgeUrl,
+      location: region,
+      author: false
+    });
 
     const network = new this();
-    Object.assign(network, {infoLogger, debugLogger, identity, transport, node, peer});
+    Object.assign(network, {infoLogger, debugLogger, disconnector: disconnect, transport, nodeIdentity, peer});
     network.resetStatePromises();
     network.info(`Created network node for kernel ${this.kernelVersion} region 0x${this.regionCode(region.lat, region.lng).toString(16)}.`);
-    await network.connect({synapseCount, timeoutMs});
+    const { peers, ms } = status;
+    network.info(`Connected ${peers} connections through ${bridgeUrl} 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 +66,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 +82,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,7 +130,7 @@ 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;
@@ -160,13 +138,16 @@ export class P2PWebNetwork {
     const buffer = await blob.arrayBuffer();
     const u8 = new Uint8Array(buffer);
     //console.log('blob', blob.size, u8.length);
-    return await publishChunkedBytes(this.peer, u8, {topic, signWith, mime, name, ...rest});
+    const data = await publishChunkedBytes(this.peer, u8, {topic, signWith, mime, name, ...rest});
+    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;
   }
 
@@ -180,7 +161,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;
@@ -199,13 +180,19 @@ 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);
@@ -228,20 +215,12 @@ export class P2PWebNetwork {
     // E.g., a precise location gets anonymized to containing top-level cell center.
     return this.regionCenter(this.regionCode(lat, lng));
   }
-  get synaptomeSize() { // Safely answer the number of connections.
-    return this.node.synaptome?.size ?? 0;
-  }
-  // 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);
+    this.debugLogger?.(this.nodeIdentity.id, ...rest);
   }
   info(...rest) { // Add debug logspam.
-    (this.infoLogger || this.debugLogger)?.(this.identity.id, ...rest);
+    (this.infoLogger || this.debugLogger)?.(this.nodeIdentity.id, ...rest);
   }
 }
 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

@@ -2,7 +2,7 @@ const { Request, Response, URL, localStorage, BroadcastChannel } = globalThis;
 import { appVersion } from './versions.js';
 import { resetInactivityTimer, clickTip } from './main.js';
 import { openDisplay } from './display.js';
-import { go } from './map.js';
+import { go } from './alert.js';
 import { Int } from './translations.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.3';
+const serviceVersion = '4.5.4';
 
 async function cacheFirst({request, event}) {
   // Handle request from any cache, else fetch and store it in serviceCache.
@@ -82,7 +82,9 @@ async function cacheSource(version, event) { // Cache source in the given versio
     "javascripts/versions.js",
     "javascripts/main.js",
     "javascripts/display.js",
-    "javascripts/map.js",
+    "javascripts/conversation.js",
+    "javascripts/alert.js",    
+    "javascripts/map.js",    
     "javascripts/hashtags.js",
     "javascripts/s2.js",
     "javascripts/agent.js",
@@ -163,6 +165,7 @@ async function cacheSource(version, event) { // Cache source in the given versio
 
     // TODO: the libraries
   ].map(name => new Request(name, {cache: 'no-store'}))); // Might not be necessary, but if any browsers insist on their own caching...
+
   await Promise.all([
     // These are referenced within material web, but missing. Turns out we don't need them,
     // but let's cache empty responses to keep the console cleaner.

package/server/app.js

@@ -18,7 +18,7 @@ const argv = yargs(hideBin(process.argv))
       .option('nPortals', {
 	alias: 'p',
 	type: 'number',
-	default: logicalCores,
+	default: Math.min(logicalCores, 5),
 	description: "The number of steady nodes that handle initial connections."
       })
       .option('baseURL', {
@@ -82,7 +82,6 @@ if (cluster.isPrimary) { // Parent process with portal webserver through which c
   // expressWs(app);
   // const Yz = await import('./routes/index.js');
 
-  //console.log(`${cpus()[0].model}, ${logicalCores} logical cores. Starting ${argv.nPortals}.`);
   app.use(express.json());
 
   app.use('/images', express.static(resolve('../public/images'), {
@@ -96,18 +95,19 @@ if (cluster.isPrimary) { // Parent process with portal webserver through which c
 
   app.listen(port);
   console.log('Listening on', port, 'and starting', argv.nPortals, 'nodes.');
-  for (let i = 0; i < argv.nPortals; i++) cluster.fork();
+  for (let i = 0; i < argv.nPortals; i++) {
+    cluster.fork();
+    await new Promise(resolve => setTimeout(resolve, 1e3));
+  }
 } else {
   process.title = 'axona-starting';
-  const { P2PWebNetwork } = await import('../public/javascripts/p2pWebNetwork.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});
-  process.title = 'axona-' + network.identity.id;
-  let update = null//setInterval(() => network.info(network.health().axonRoles.map(role => role.topic)), 5e3);
+  const { P2PWebNetwork, location } = await import('../index.js');
+  const network = await P2PWebNetwork.create({region: location});
+  process.title = 'axona-' + network.nodeIdentity.id;
+  //let update = setInterval(() => network.info(network.peer.health().axonRoles.length, 'axons'), 10e3);
   process.on('SIGINT', async () => { // Leave the network politely.
     console.log(process.title, 'Shutdown for Ctrl+C');
-    clearInterval(update)
+    //clearInterval(update)
     await network.disconnect();
     process.exit(0);
 });

package/server/getLocation.js

@@ -14,6 +14,6 @@ export const data = await import(filename, {with: { type: 'json' }})
     await fs.writeFile(resolve(filename), string, 'utf8');
     return {default: JSON.parse(string)};
   });
-export const [lat, lng] = data.default.loc.split(',').map(parseFloat);
+export const [lat, lng] = (globalThis.process?.env.LAT_LNG || data.default.loc).split(',').map(parseFloat);
 export const location = {lat, lng};
 

package/server/location.json

@@ -2,6 +2,6 @@
   "uswest/80": "37.4852,-122.2364",
   "useast/89": "40,-75",
   "uscentle/88": "35,-83",
-  "easteu/47": "50,17",  
-  "loc": "37.4852,-122.2364"
+  "easteu/47": "50,17",
+  "loc": "37,-122"
 }

package/spec/axonSpec.js

@@ -1,96 +1,61 @@
 /*
   FIXME: Things that either don't pass, or require undocumented workarounds.
   TODO: Things that ought to be dealt with at some point, but can be deferred until later.
-  CURRENTLY:
-  - This passes (with the FIXMEs in place) in main/3.8.0
-  - This usually fails to receive some of the expected subscription callbacks in testnet/4.3.2, and thus hangs.
 
   To RUN, e.g., in NodeJS:
   - You may need to adjust the path to webTransport. See the first TODO entry.
-  - To switch between them, don't forget to change the wss url a few lines down from hehre.
+  - To switch between them, don't forget to change the wss url a few lines down from here.
   - Have jasmine or the like installed and initialized, and then e.g., npx jasmine spec/axonSpec.js.
 
   It is worth running this several times. It sometimes works once, and then fails or has enormous connect times on another run.
 
   The logging tells the story.
-  Alice, Bob, and Carol are Node instances. (Defined below, followed by the Jasmine test suite.)
+  Alice, Bob, Carol, David, and Emma are Node instances. (Defined below, followed by the Jasmine test suite.)
   Alice and Bob will subscribe and publish to an open/since:'all' topic.
   Carol will join and subscribe between the previous subscriptions and their publications.
   After publications, Bob will politely disconnect, and then restart and subscribe again to get same results.
   Carol will restart without an explicit disconnect, and subscribe again after publications.
   David will join and subscribe after publications.
+  Alice kills her publication and Emma joins.
 */
 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.
+class Node {  // Stuff we have to do every time.
   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 +98,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();
   }
@@ -171,10 +130,6 @@ describe("CivilDefense", function () {
       return this.ready = new Promise(resolve => {
 	const handlerTime = Date.now();
 	this.handler = ({message, receiver, ts:pubTime}) => { // Ensure that the receiver's events[currentOperation] is a list, and push message on to it.
-	  // FIXME: ts is undefined for a kill, which is weird:
-	  // 1. I would think that Axona needs the time in order to dedupe and order properly?
-	  // 2. The app may need the time, especially since we are not reliably getting events in ts order. (See "wrong order" comment, below.)
-	  pubTime ||= 0;
 	  const start = Math.max(pubTime, handlerTime);
 	  const elapsed = Date.now() - start;
 	  const data = receiver.events[currentOperation] ||= [];
@@ -214,8 +169,8 @@ describe("CivilDefense", function () {
     currentOperation = 'initial';
     // 'alice pub' starts and completes before 'bob pub' starts.
     aliceKillTag = await alice.publish({message: 'alice pub'});
-    await TestNode.delay(500); // FIXME: without this delay, subscription handlers are called in the wrong order.
     console.log('alice published');
+    await TestNode.delay(500); // FIXME: without this delay, subscription handlers are called in the wrong order.
     await   bob.publish({message: '  bob pub'});
     console.log('bob published');
     //alice.subscribeOpenMetrics({eventName, region:regionCode, handler: envelope => console.log('*** fixme got metrics', envelope)});

package/spec/conversationSpec.js

@@ -0,0 +1,116 @@
+const { describe, it, expect, beforeAll, afterAll, BigInt } = globalThis;
+import { Conversation } from '../public/javascripts/conversation.js';
+
+describe("Conversation", function () {
+  let agent;
+  let conversation;
+  const tag = '123';
+  const payload = 'cake';
+  beforeAll(function () {
+    agent = {handle: 'alice'};
+    conversation = Conversation.ensure({tag, payload, agent});
+  });
+  describe("creation", function () {
+    it("initializes properties.", function () {
+      expect(conversation.agent).toBe(agent);
+      expect(conversation.payload).toBe(payload);
+    });
+    it("remembers conversations with the same tag.", function () {
+      expect(Conversation.ensure({tag, payload, agent})).toBe(conversation);
+    });
+    it("Properties can be ommitted for existing tag.", function () {
+      expect(Conversation.ensure({tag, payload})).toBe(conversation);
+    });
+    it("rejects changes by default.", function () {
+      expect(() => Conversation.ensure({tag, payload: 'other', agent})).toThrow();
+    });
+    describe("caching", function () {
+      let keep = true;
+      let tag = "caching";
+      class CacheConversation extends Conversation {
+	update() { return keep && this; }
+	initialize() { return keep && this; }
+      }
+      it("ends with explicit removal.", function () {
+	let initial = Conversation.ensure({tag, agent, payload});
+	expect(initial).toBeTruthy();
+	expect(Conversation.getItem(tag)).toBe(initial);
+	expect(Conversation.removeItem(tag)).toBe(initial);
+	expect(Conversation.getItem(tag)).toBeFalsy();
+      });
+      describe("deleting data", function () {
+	it("keeps new if not deleting.", function () {
+	  tag = 'keep';
+	  let initial = Conversation.ensure({tag, agent, payload});
+	  expect(initial).toBeTruthy();
+	  expect(Conversation.ensure({tag, agent, payload})).toBe(initial);
+	  expect(Conversation.getItem(tag)).toBe(initial);
+	});
+	it("is skipped if delete data.", function () {
+	  tag = 'skip';	  
+	  let initial = Conversation.ensure({tag, agent});
+	  expect(initial).toBeFalsy();
+	  expect(Conversation.getItem(tag)).toBeFalsy();
+	});
+	it("is removed if delete data.", function () {
+	  tag = 'skip';	  
+	  let initial = Conversation.ensure({tag, agent, payload});
+	  expect(initial).toBeTruthy();
+	  expect(Conversation.getItem(tag)).toBeTruthy();
+	  Conversation.ensure({tag, agent});
+	  expect(Conversation.getItem(tag)).toBeFalsy();
+	});
+      });
+      describe("null/item caching convention", function () {
+	// Do we really need/want this convetion?
+	it("keeps if initialize answers conversation.", function () {
+	  keep = true;
+	  tag = 'keepA';
+	  let initial = CacheConversation.ensure({tag, agent, payload});
+	  expect(initial).toBeTruthy();
+	  expect(CacheConversation.ensure({tag, agent, payload})).toBe(initial);
+	  expect(CacheConversation.getItem(tag)).toBe(initial);
+	});
+	it("is skipped if initialize answers falsy.", function () {
+	  keep = false;
+	  tag = 'skipA';	  
+	  let initial = CacheConversation.ensure({tag, agent, payload});
+	  expect(initial).toBeFalsy();
+	  expect(CacheConversation.getItem(tag)).toBeFalsy();
+	});
+	it("keeps existing if update answers conversation.", function () {
+	  keep = true;
+	  tag = 'keepB';
+	  let initial = CacheConversation.ensure({tag, agent, payload});
+	  expect(CacheConversation.ensure({tag, agent, payload})).toBe(initial);
+	  expect(CacheConversation.ensure({tag, agent, payload})).toBe(initial);
+	  expect(CacheConversation.getItem(tag)).toBe(initial);
+	});
+	it("destroys existing if update answers falsy.", function () {
+	  keep = true;
+	  tag = 'skipB';
+	  let initial = CacheConversation.ensure({tag, agent, payload});
+	  expect(CacheConversation.ensure({tag, agent, payload})).toBe(initial);
+	  keep = false;
+	  expect(CacheConversation.ensure({tag, agent, payload})).toBeFalsy();
+	  expect(CacheConversation.getItem(tag)).toBeFalsy();
+	});
+      });
+    });
+  });
+
+  describe("replies", function () {
+    beforeAll(function () {
+      conversation.ensure({payload: "second", issuedTime: 3, tag: 'z'});
+      conversation.ensure({payload: "deleted", issuedTime: 2, tag: 'y'});
+      conversation.ensure({payload: "first", issuedTime: 1, tag: 'x'});
+      conversation.ensure({payload: null, issuedTime: 4, tag: 'y'});
+    });
+    it("adds replies in timestamp order.", function () {
+      expect(conversation.items.map(reply => reply.payload)).toEqual(["first", "second"]);
+    });
+    it("removes deleted replies.", function () { // fixme eachReply
+      expect(conversation.items.find(reply => !reply.payload)).toBeFalsy();
+    });
+  });
+});