@yz-social/civildefense.io 4.5.28 → 5.0.0

package/public/javascripts/pubsub.js

@@ -1,88 +1,72 @@
-// In memory pubsub, for either client-only testing, or server-websocket testing
-const { v4:uuidv4 } = await import('uuid');
+// Centralized pubsub, for either client-only testing, or server-websocket testing.
+import { v4 as uuidv4 } from 'uuid';
+// CivilDefense dht=-1 has no networking at all and loads this in browser, but isn't running when push would fire.
+const { push } = globalThis.process ? await import('./push.js') : {};
 const { TextEncoder, crypto, Buffer } = globalThis;
-const publicationRolloverLimit = 1000;
-
-function setBucket(collection, type, topicId, subject, value) { // Set value in the collection.
-  const bucket = collection[type][topicId] ||= {};
-  if ((collection === data) && (type === 'pub')) {
-    const keys = Object.keys(bucket);
-    const size = keys.length;
-    if (size >= publicationRolloverLimit) {
-      console.warn('Over pub limit on topic', topicId, size); // TODO: rotate out the earliest received.
-      delete bucket[keys[0]];
-    }
-  }
-  bucket[subject] = value;
-}
-function removeBucket(collection, type, topicId, subject) { // Return the value and stop storing it.
-  const bucket = collection[type][topicId];
-  if (!bucket) return null;
-  const value = bucket[subject];
-  delete bucket[subject];
-  if (!Object.keys(bucket).length) delete collection[type][topicId];
-  return value;
-}
 
-const SUBSCRIPTION_TIMEOUT = 0; // No need, because we run deleteSubscriber on disconnect.
-const PUBLISH_TIMEOUT = 24 * 60 * 60e3;      // Delete after 24 hours.
-const timeouts = {pub: {}, sub: {}};
-function expire(type, topicId, subject, remover, timeout) { // Cancellably schedule remover() to fire at timeout.
-  if (!timeout) return;
-  setBucket(timeouts, type, topicId, subject, setTimeout(() => { remover(); cancel(type, topicId, subject); }, timeout));
-}
-function cancel(type, topicId, subject) { // Cancel a sheduled expiration.
-  clearTimeout(removeBucket(timeouts, type, topicId, subject));
+const hasBuffer = typeof Buffer !== 'undefined';
+let toHex = hasBuffer ? u8 => Buffer.from(u8).toString('hex') : u8 => u8.toHex();
+async function hash2Hex(text) { // Promise hex-coded SHA256(text).
+  const hash = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(text));
+  return toHex(new Uint8Array(hash));
 }
+export async function resolveTopic(descriptor) {  // Normalize like axona.
+  if (typeof(descriptor) !== 'object') return {topicId: descriptor};
+  let {name, region, owner = null, write = owner ? 'owner' : 'open'} = descriptor;
+  if (typeof(region) === 'string') region = parseInt(region);;
+  const normalized = {name, region, owner, write};
+  const topicId = await hash2Hex(JSON.stringify(normalized));
+  return {name, region, owner, write, topicId};
+};
+// Promise a string.
+export const deriveTopicId = descriptor => resolveTopic(descriptor).then(resolved => resolved.topicId);
 
-// pub maps eventName => {[subject]: storageItem, ...}, where subject is the message id. Entries purged after PUBLISH_TIMEOUT.
-// sub maps  eventName => {[subject]: ws, ...}, where subject is the subscriber id. Entries purged after SUBSCRIPTION_TIMEOUT.
-const data = {pub: {}, sub: {}};
-function getDataValues(type, topicId) { // For all subjects
-  return Object.values(data[type][topicId] || {});
-}
-function getDataEntries(type, topicId) {
-  return Object.entries(data[type][topicId] || {});
-}
 
-function deleteSub(topicId, subject) {
-  return removeBucket(data, 'sub', topicId, subject);
-}
-function normalizeTopic({name, region, owner, write = 'open'} = {}) {
-  if (typeof(region) === 'string') region = parseInt(region);;
-  return {name, region, owner, write};
-}
-function deriveTopicId(topic) {
-  return JSON.stringify(normalizeTopic(topic)); // No need to hash in this implementation.
-}
-function delay(ms = 0) {
-  return ms && new Promise(resolve => setTimeout(resolve, ms));
-}
+// All storage (the type -> topicId -> subject -> value buckets, and their
+// expiry) lives behind this interface. Swap the import below for a
+// different implementation of the same interface (e.g. store-memory.js for
+// local testing) -- nothing else in this file needs to change. Every store
+// call is awaited: that's a no-op for a synchronous backend and required
+// for an async one like Redis, so the same file works with either.
+const storeSource = globalThis.process?.env.REDIS_URL ? './store-redis.js' : './store-memory.js';
+const { store } = await import(storeSource);
+console.log('store source', storeSource);
+
+const SUBSCRIPTION_TIMEOUT = 0; // No need, because we run deleteSubscriber on disconnect.
+const PUBLISH_TIMEOUT = 24 * 60 * 60e3;      // Delete after 24 hours.
+const TRACK_TIMEOUT = PUBLISH_TIMEOUT;
 
 let invoke;
-export function setReceiver(receiver) {
-  invoke = receiver;
-}
-const throttleMS = 30; // Just to yield to other stuff.
-async function pauseInvoke(...rest) {
-  invoke(...rest);
-  await new Promise(resolve => setTimeout(resolve, throttleMS));
+export function setReceiver(receiver) { // Set the means by which we fire events over a connection.
+  invoke = receiver; // E.g. (nodeId, handlerId, envelope) => getSocket(nodeId).send(JSON.stringify([handlerId, envelope]));
+}
+async function fireEvent(...rest) { // Send envelope to a subscribed hander.
+  try {
+    invoke(...rest);
+  } catch (error) { // Error sending, e.g., nodeTag is gone and we had not yet noticed.
+    const [nodeTag, id, envelope] = rest;
+    await deleteSubscriber(nodeTag);
+    const subscription = await store.get('sub', await deriveTopicId(envelope.topic), id);
+    if (subscription) push(envelope, subscription, PUBLISH_TIMEOUT);
+  }
 }
 
-export function subscribe(topicName, nodeTag, {since = 'all'}) {
+export async function subscribe(topic, nodeTag, {since = 'all', pushData = null}) {
   // Axona allows multiple handlers on the same topic, but we don't use that in civildefense, and do not implement it here.
-  const topicId = deriveTopicId(topicName);
+
+  const {name, region, owner, write, topicId} = await resolveTopic(topic);
   const id = uuidv4();
-  cancel('sub', topicId, id);
-  expire('sub', topicId, id, () => deleteSub(topicId, id), SUBSCRIPTION_TIMEOUT);
-  setBucket(data, 'sub', topicId, nodeTag, id);
-  if (since) { // invoke handler on any sticky data, but only after we have told client the subscription id.
+  await store.set('sub', topicId, nodeTag, id, SUBSCRIPTION_TIMEOUT);
+  // If pushData, store it separately by nodeTag until it needs to be activated.
+  if (pushData) await store.set('track', topicId, nodeTag, pushData, TRACK_TIMEOUT);
+  else store.remove('track', topicId, nodeTag);
+  if (since) { // invoke handler on any sticky data, but only after we have told client the subscription id. TODO: is there a better way?
     setTimeout(async () => {
       let lastEnvelope = null, lastTime = 0;
-      for (const envelope of getDataValues('pub', topicId)) {
+      for (const envelope of await store.values('pub', topicId)) {
 	switch (since) {
 	case 'all':
-	  await pauseInvoke(nodeTag, id, envelope);
+	  await fireEvent(nodeTag, id, envelope);
 	  break;
 	case 'latest':
 	  if (envelope.ts > lastTime) {
@@ -91,56 +75,81 @@ export function subscribe(topicName, nodeTag, {since = 'all'}) {
 	  }
 	  break;
 	default: // Must be a timestamp
-	  if (envelope.ts === since) await pauseInvoke(nodeTag, id, envelope);
+	  if (envelope.ts === since) await fireEvent(nodeTag, id, envelope);
 	}
       }
-      if (lastEnvelope) invoke(nodeTag, id, lastEnvelope);
+      if (lastEnvelope) fireEvent(nodeTag, id, lastEnvelope);
     }, 100);
   }
-  return {topicName, topicId, id};
+  return {topicName: {name, region, owner, write}, topicId, id};
 }
 
-export function unsubscribe(topic, nodeTag, options) {
-  const topicId = deriveTopicId(topic);
-  cancel('sub', topicId, nodeTag);
-  const id = deleteSub(topicId, nodeTag);
-  return {ok: true, id}; // Axona doesn't return the id(s) of the subscription(s), but it is convenient for us to do so.
+export async function unsubscribe(topic, nodeTag, {pushId}) {
+  // Unsubscribe subscription and any unactivated tracking subscription from the specified node.
+  // Additionally, an activated sticky pushId will be removed if specified - it is the nodeTag from a previous session).
+
+  const topicId = await deriveTopicId(topic);
+  let id = await store.remove('sub', topicId, nodeTag);
+  // Also remove any sticky push subscription:
+  // If not yet promoted to sub, it's in track under our current, protectable nodeTag.
+  await store.remove('track', topicId, nodeTag);
+  // Otherwise, it might have been activated in sub under pushId (i.e., a previous session nodeTag).
+  // TODO: pushId should probably be a JWS that was signed in the subscribing node's previous session by the pushId,
+  // thus proving that the request actually came from the succcessor to that node.
+  if (pushId) pushId = await store.remove('sub', topicId, pushId);  // pushId must match that used during activation.
+  return {ok: !!id, id, pushId}; // Axona doesn't return the id(s) of the subscription(s), but it is convenient for us to do so.
 }
 
-export function deleteSubscriber(nodeTag) {
-  for (const topicId in data.sub)  {
-    const keySubs = data.sub[topicId];
-    for (const [subject, value] of Object.entries(keySubs)) {
-      if (nodeTag === subject) {
-	deleteSub(topicId, subject, keySubs);
-	cancel('sub', topicId, subject);
-      }
+export async function deleteSubscriber(nodeTag) {
+  // The node is gone: lost connection, or fireEvent failed.
+
+  for (const topicId of await store.topics('sub')) { // Remove in all topics.
+    await store.remove('sub', topicId, nodeTag);
+    // Activate pending push subscription, if any, by moving it from 'track' to active 'sub'.
+    const pushSubscription = await store.remove('track', topicId, nodeTag);
+    if (pushSubscription) {
+      //console.log('activiting', topicId, nodeTag, pushSubscription);
+      await store.set('sub', topicId, nodeTag, pushSubscription, TRACK_TIMEOUT);
     }
   }
 }
 
-const hasBuffer = typeof Buffer !== 'undefined';
-let toHex = hasBuffer ? u8 => Buffer.from(u8).toString('hex') : u8 => u8.toHex();
+function isConnectedSubscription(handlerInfo) { // True if a it's a direct-connect subscription, false if sticky (push).
+  return 'string' === typeof(handlerInfo);
+}
+async function handleEvents(topicId, envelope)  {
+  const subs = await store.entries('sub', topicId);
+  // Each sub's handlerInfo can be an ordinary subscription nodeId, or a sticky push subscription data.
+  return Promise.all(subs.map(([nodeTag, handlerInfo]) => {
+    if (isConnectedSubscription(handlerInfo)) { // nodeId
+      return fireEvent(nodeTag, handlerInfo, envelope);
+    } else { // activated sticky push subscription data object.
+      return push(envelope, handlerInfo, PUBLISH_TIMEOUT);
+    }
+  }));
+}
+
 export async function publish(topic, message, {signWith}) {
-  const topicId = deriveTopicId(topic);
+  // Publish message to any existing subscription.
+
+  const topicId = await deriveTopicId(topic);
   const signerPubkey = signWith?.authorId || undefined;
   const payload = JSON.stringify({message, publisher: signerPubkey});
-  const hash = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(payload));
-  const msgId = toHex(new Uint8Array(hash));
+  const msgId = await hash2Hex(payload);
   const envelope = {msgId, topic, ts: Date.now(), message, signerPubkey};
-  for (const [nodeTag, id] of getDataEntries('sub', topicId)) await pauseInvoke(nodeTag, id, envelope);
-  setBucket(data, 'pub', topicId, msgId, envelope);
-  expire('pub', topicId, msgId, () => removeBucket(data, 'pub', topicId, msgId), PUBLISH_TIMEOUT);
+  await store.set('pub', topicId, msgId, envelope, PUBLISH_TIMEOUT);
+  await handleEvents(topicId, envelope);
   return msgId;
 }
 
 export async function unpublish(topic, msgId, {signWith}) {
-  const topicId = deriveTopicId(topic);  
-  cancel('pub', topicId, msgId);
-  const envelope = removeBucket(data, 'pub', topicId, msgId);
+  // Kill a publication by removing it from persistence, and firing removal event for existing subs.
+
+  const topicId = await deriveTopicId(topic);
+  const envelope = await store.remove('pub', topicId, msgId);
   if (!envelope) return {ok: false}; // we didn't have it.
   envelope.deleted = true;
   envelope.message = null;
-  for (const [nodeTag, id] of getDataEntries('sub', topicId)) await pauseInvoke(nodeTag, id, envelope);
+  await handleEvents(topicId, envelope);
   return {ok: true};
 }

package/public/javascripts/push.js

@@ -0,0 +1,28 @@
+import webpush from 'web-push';
+// const vapidKeys = generateVAPIDKeys?.() || {};
+// console.log({vapidKeys});
+// setVapidDetails?.(
+//   'mailto:example@yourdomain.org',
+//   vapidKeys.publicKey,
+//   vapidKeys.privateKey
+// );
+export async function push(envelope, {applicationServerKey, applicationId, ...subscription}, TTLms) {
+  // Prepare and post eneelope to the push-service specified in the subscription data.
+  const options = {
+    // It would be nice to include a topic tag, but that is application-specific.
+    // Maybe it could be specified by pub options, but that's getting a bit weird.
+    // Besides, I bet some services don't even use it.
+    TTL: TTLms * 1e-3,
+    vapidDetails: {
+      subject: `mailto:${applicationId}@example.org`,
+      publicKey: applicationServerKey,
+      privateKey: applicationId
+    }
+  };
+  // Consider delaying this by a random amount, to make it that much harder for someone
+  // to correlate known topic activity with someone's push records obtained from the service.
+  const reply = await webpush.sendNotification?.(subscription, JSON.stringify(envelope), options)
+      .catch(error => console.error(`${error.message} for push ${subscription?.endpoint}.`));
+  //console.log('push', {envelope, subscription, options, reply});
+  return reply;
+}

package/public/javascripts/s2.js

@@ -1,5 +1,5 @@
-import { s2, s1, r1 } from 's2js';
-const { cellid, LatLng, Point, Cell, Cap, RegionCoverer } = s2;
+import { s2, s1, r1, geojson } from 's2js';
+const { cellid, LatLng, LatLngRect, Point, Cell, Cap, RegionCoverer } = s2;
 import { cellHex } from './versions.js';
 import { geoCellCenter/*, geoCellId*/ } from '@axona/protocol';
 const { BigInt } = globalThis;
@@ -55,6 +55,15 @@ export function getSmallestCellId(lat, lng, level = MAX_MAP_LEVEL) { // Answer s
   const userLocCellId = Cell.fromPoint(userPt).id; // This is at MAX_S2_LEVEL
   return cellid.parent(userLocCellId, level);
 }
+export function getCellCorners(cell) { // Corners of BigInt cell, as [...[lat, lng]]
+  const s2cell = cellFromCellID(cell);
+  const radiansToDegrees = 180 / Math.PI;
+  return Array.from({ length: 4 }, (_, i) => {
+    const point = s2cell.vertex(i);
+    const latLng = s2.LatLng.fromPoint(point);
+    return [latLng.lat * radiansToDegrees, latLng.lng * radiansToDegrees];
+  });
+}
 
 // Return a list of the cell ids that contain the point, from region to MAX_S2_LEVEL
 // Note that the first of the cells (the region
@@ -86,3 +95,16 @@ export function findCoverCellsByMinMaxLatLng({minLat, maxLat, minLng, maxLng, fu
   const coverer = new RegionCoverer({minLevel, maxLevel, maxCells});
   return coverer.covering(rect); // a CellUnion — array-like of bigint cell IDs, already normalized/minimal
 }
+
+export function getSmallestCellSurrounding(centerLat, centerLng, halfSizeDegrees = 0.05) {
+  // Returns the bigint cellid of the smallest single S2 cell that completely
+  // covers a size x size box centered on the given lat/lng.
+
+  const minLat = centerLat - halfSizeDegrees;
+  const maxLat = centerLat + halfSizeDegrees;
+  const minLng = centerLng - halfSizeDegrees;
+  const maxLng = centerLng + halfSizeDegrees;
+
+  // The center could be near a cell corner, so ask for up to four.
+  return findCoverCellsByMinMaxLatLng({minLat, maxLat, minLng, maxLng, options: {maxCells: 4}});
+}

package/public/javascripts/service-manager.js

@@ -43,13 +43,17 @@ import { Int } from './translations.js';
   If the user clears cache and reloads (even if there is no source/worker update, or a stale worker), they get the currently hosted versions.
 */
 
+export async function postServiceMessage(method, params) {
+  const registration = await navigator.serviceWorker.ready;
+  return registration.active.postMessage({method, params});
+}
+
 let resolveCached;
 async function cacheSource(version) {
   console.log(`service-manager ${appVersion} requesting service-worker to cache source in ${version}.`);
   const {promise, resolve} = Promise.withResolvers();
   resolveCached = resolve;
-  const registration = await navigator.serviceWorker.ready;
-  registration.active.postMessage({method: 'cacheSource', params: version});
+  await postServiceMessage('cacheSource', version);
   await promise;
   console.log(`source ${version} is cached.`);
 }
@@ -59,9 +63,9 @@ const updateText = document.getElementById('updateStatus');
 const downloadButton = document.getElementById('downloadUpdates');
 const downloadButton2 = document.getElementById('downloadUpdates2');
 
-function getServiceVersion(registration) { // Ask the service worker to send back it's version, which will trigger a compare.
+function getServiceVersion() { // Ask the service worker to send back it's version, which will trigger a compare.
   console.log('requesting service-worker version');
-  registration.active.postMessage({method: 'version', params: appVersion});
+  postServiceMessage('version', appVersion);
 }
 function newVersionAvailable(newVersion) {
   // Set up all the buttons and displays in case the user declines the popup,
@@ -111,14 +115,14 @@ await navigator.serviceWorker
 	console.log('statechange', newWorker.state, navigator.serviceWorker, navigator.serviceWorker.controller);
 	// We don't want to nag/confuse the user when installing fresh/first-time. There will not be a controller that time.
 	// if (newWorker.state === 'installed' && navigator.serviceWorker.controller) {
-	//   getServiceVersion(registration);
+	//   getServiceVersion();
 	// }
       };
     };
     navigator.serviceWorker.addEventListener('controllerchange', () => {
       console.log('controllerchange',  navigator.serviceWorker, navigator.serviceWorker.controller);
       if (!navigator.serviceWorker.controller) return;
-      getServiceVersion(registration);
+      getServiceVersion();
     });
     // addEventListener, allowing other code to listen for other messages.
     navigator.serviceWorker.addEventListener('message', async event => {
@@ -143,7 +147,7 @@ await navigator.serviceWorker
 	console.error('Unrecognized message from service worker', event.data);
       }
     });
-    navigator.serviceWorker.ready.then(getServiceVersion);
+    getServiceVersion();
   });
 new BroadcastChannel('site_control').onmessage = event => {
   const {method, params} = event.data;

package/public/javascripts/store-memory.js

@@ -0,0 +1,74 @@
+// In-memory implementation of the pubsub storage interface.
+//
+// Interface (all methods synchronous here, but callers should treat them as
+// potentially async-capable so a future backend, e.g. Redis, can be dropped
+// in without touching pubsub.js):
+//   set(type, topicId, subject, value, ttlMs)  -> void
+//   remove(type, topicId, subject)             -> value | null
+//   values(type, topicId)                      -> value[]
+//   entries(type, topicId)                     -> [subject, value][]
+//   topics(type)                               -> topicId[]
+//
+// `type` is always 'pub' or 'sub'. Expiry (ttlMs) is owned entirely by the
+// backend: this implementation uses setTimeout; a Redis backend would use
+// native key/field TTL (e.g. HEXPIRE) instead, and wouldn't need `timers`.
+
+const publicationRolloverLimit = 1000;
+
+const data = {pub: {}, sub: {}, track: {}};
+const timers = {pub: {}, sub: {}, track: {}};
+
+function bucketFor(collection, type, topicId) {
+  return collection[type][topicId] ||= {};
+}
+
+function cancelTimer(type, topicId, subject) {
+  const bucket = timers[type][topicId];
+  if (!bucket) return;
+  clearTimeout(bucket[subject]);
+  delete bucket[subject];
+  if (!Object.keys(bucket).length) delete timers[type][topicId];
+}
+
+function get(type, topicId, subject) {
+  return bucketFor(data, type, topicId)?.[subject];
+}
+function set(type, topicId, subject, value, ttlMs) {
+  cancelTimer(type, topicId, subject); // replacing a value resets its expiry
+  const bucket = bucketFor(data, type, topicId);
+  if (type === 'pub') {
+    const keys = Object.keys(bucket);
+    if (keys.length >= publicationRolloverLimit) {
+      console.warn('Over pub limit on topic', topicId, keys.length);
+      delete bucket[keys[0]];
+    }
+  }
+  bucket[subject] = value;
+  if (ttlMs) {
+    bucketFor(timers, type, topicId)[subject] = setTimeout(() => remove(type, topicId, subject), ttlMs);
+  }
+}
+
+function remove(type, topicId, subject) {
+  cancelTimer(type, topicId, subject);
+  const bucket = data[type][topicId];
+  if (!bucket) return null;
+  const value = bucket[subject];
+  delete bucket[subject];
+  if (!Object.keys(bucket).length) delete data[type][topicId];
+  return value ?? null;
+}
+
+function values(type, topicId) {
+  return Object.values(data[type][topicId] || {});
+}
+
+function entries(type, topicId) {
+  return Object.entries(data[type][topicId] || {});
+}
+
+function topics(type) {
+  return Object.keys(data[type]);
+}
+
+export const store = {set, get, remove, values, entries, topics};

package/public/javascripts/store-redis.js

@@ -0,0 +1,101 @@
+// Redis implementation of the pubsub storage interface (see store-memory.js
+// for the interface contract). Drop-in replacement: pubsub.js only needs to
+// change which of these two modules it imports `store` from.
+//
+// Design notes:
+// - Each (type, topicId, subject) item is its own Redis string key, so its
+//   24h (or whatever) expiry is native Redis key TTL (`PX`) -- Redis reclaims
+//   the memory itself, no client-side timers, no rehydration needed on
+//   restart of this process.
+// - A per-(type, topicId) sorted set (`idx:...`) tracks which subjects exist,
+//   scored by insertion time. This gives real, correctly-ordered "oldest
+//   first" eviction for the publication rollover limit.
+// - Reads (`values`/`entries`) tolerate the index referencing an item that
+//   has since expired: they filter it out and lazily prune the index entry.
+// - This intentionally avoids Redis 7.4+'s per-hash-field TTL (HEXPIRE), so
+//   it works on any reasonably recent Redis/Valkey. If you're guaranteed
+//   7.4+, storing each bucket as one hash with HEXPIRE per field is a viable
+//   alternative with fewer keys -- not needed here.
+
+import { createClient } from 'redis';
+
+const publicationRolloverLimit = 1000;
+
+const REDIS_URL = process.env.REDIS_URL || 'redis://localhost:6379';
+const client = createClient({ url: REDIS_URL });
+client.on('error', err => console.error('Redis client error', err));
+await client.connect();
+
+function itemKey(type, topicId, subject) {
+  return `civildefense.io:${type}:${topicId}:${subject}`;
+}
+function indexPrefix(type) {
+  return `civildefense.io:idx:${type}:`;
+}
+function indexKey(type, topicId) {
+  return `civildefense.io:idx:${type}:${topicId}`;
+}
+
+function get(type, topicId, subject) {
+  return client.get(itemKey(type, topicId, subject));
+}
+
+async function set(type, topicId, subject, value, ttlMs) {
+  const idxKey = indexKey(type, topicId);
+  if (type === 'pub') { // Limit pubs to rollover limit.
+    const size = await client.zCard(idxKey);
+    if (size >= publicationRolloverLimit) {
+      console.warn('Over pub limit on topic', topicId, size);
+      const oldest = await client.zPopMin(idxKey); // {value, score} for the lowest-scored (earliest) member
+      if (oldest?.value) await client.del(itemKey(type, topicId, oldest.value));
+    }
+  }
+  await client.set(itemKey(type, topicId, subject), JSON.stringify(value), ttlMs ? { PX: ttlMs } : undefined);
+  await client.zAdd(idxKey, { score: Date.now(), value: subject });
+}
+
+async function remove(type, topicId, subject) { // Returns old value, or null.
+  const idxKey = indexKey(type, topicId);
+  const key = itemKey(type, topicId, subject);
+  const raw = await client.get(key); // TODO: consider pipelining this and next to be atomic.
+  await client.del(key);
+  await client.zRem(idxKey, subject);
+  return raw == null ? null : JSON.parse(raw);
+}
+
+async function entries(type, topicId) {
+  const idxKey = indexKey(type, topicId);
+  const subjects = await client.zRange(idxKey, 0, -1); // TODO: consider pipelining this and following to be atomic.
+  if (!subjects.length) return [];
+  const raws = await client.mGet(subjects.map(subject => itemKey(type, topicId, subject)));
+  const result = [];
+  const stale = [];
+  subjects.forEach((subject, i) => {
+    if (raws[i] == null) stale.push(subject); // item's native TTL fired since we indexed it
+    else result.push([subject, JSON.parse(raws[i])]);
+  });
+  if (stale.length) await client.zRem(idxKey, stale);
+  return result;
+}
+
+async function values(type, topicId) {
+  return (await entries(type, topicId)).map(([, value]) => value);
+}
+
+async function topics(type) {
+  const prefix = indexPrefix(type);
+  const ids = [];
+  // scanIterator yields batches (arrays of keys), not individual keys, on
+  // this client version -- normalize so this works across client versions.
+  for await (const batch of client.scanIterator({ MATCH: `${prefix}*` })) {
+    for (const key of [].concat(batch)) ids.push(key.slice(prefix.length));
+  }
+  return ids;
+}
+
+export const store = { get, set, remove, values, entries, topics };
+
+// Not part of the shared interface -- useful for tests/graceful shutdown.
+export async function close() {
+  await client.quit();
+}

package/public/javascripts/translations.js

@@ -62,10 +62,6 @@ const translations = {
   ['#aboutReport']: {en: "Report immediate concerns to the public by tapping their location on the map.", es: "Informa de cualquier problema inmediato al público pulsando su ubicación en el mapa."},
   ['#aboutShared']: {en: "These locations are shared over anonymous p2p with other users in your area.", es: "Estas ubicaciones se comparten a través de redes P2P anónimas con otros usuarios de tu zona."},
   ['#aboutFade']: {en: "Reported concerns will fade away over 24 hours.", es: "Las preocupaciones manifestadas se disiparán en 24 horas."},
-  ['#aboutAnyone1']: {en: "A connected mirror of this app can be", es: "Una réplica conectada de esta aplicación puede ser"},
-  ['#aboutAnyone2']: {en: "run by anyone,", es: "administrado por cualquier persona,"},
-  ['#aboutAnyone3']: {en: "in case this site is taken down.", es: "en caso de que este sitio sea dado de baja."},
-  ['#learnMore']: {en: 'Learn More', es: "Más Información"},
   ['#version']: {en: "Version", es: "Versión"},
   ['#checkForUpdates']: {en: "check for updates", es: "Buscar actualizaciones"},
   ['#downloadUpdates']: {en: "install update", es: "Instalar actualización"},
@@ -104,7 +100,10 @@ const translations = {
   ['" alerts in the map. You can delete the topic altogether with the X.']: {es: "» en el mapa. Puedes eliminar el tema por completo con la X."},
 
   ['Click to see more information in another tab about what you can do with this app and how it is resistant to tracking, censorship, and takedown.']: {es: "Haz clic para ver más información en otra pestaña sobre lo que puedes hacer con esta aplicación y cómo resiste el rastreo, la censura y la retirada de contenido."},
-  ['Click to see the source code and documentation for serving copies of this app in another tab.']: {es: "Haz clic para ver el código fuente y la documentación para servir copias de esta aplicación en otra pestaña."},
+  ['Click to learn about receiving operating system notifications.']: {es: "Haz clic para obtener información sobre cómo recibir notificaciones del sistema operativo."},
+  ['Click to learn about how you can choose to label yourself and how to recognize other users.']: {es: "Haz clic para saber cómo puedes elegir etiquetarte y cómo reconocer a otros usuarios."},
+  ['Click to learn about installation, updates, and removal.']: {es: "Haga clic para obtener información sobre la instalación, las actualizaciones y la eliminación."},
+  
   ['Show conversation for this ']: {es: "Mostrar la conversación de esta alerta de "},
   [' alert.']: {es: "."},
   ['Click to download.']: {es: "Haz clic para descargar."},
@@ -140,5 +139,6 @@ const translations = {
 
 
   ['Too many posts. (5 allowed every 5 minutes.) Removing oldest from this period.']: {es: "Demasiadas publicaciones. (Se permiten 5 cada 5 minutos). Eliminando las más antiguas de este período."},
-  ['#wipe']: {en: "Wipe all CivilDefense.io data.", es: "Eliminar todos los datos de CivilDefense.io."}
+  ['#wipe']: {en: "Wipe all CivilDefense data.", es: "Eliminar todos los datos de CivilDefense."},
+  ['Installed']: {es: "Instalada"}
 };