@polycode-projects/the-mechanical-code-talker 5.0.2 → 5.0.4

package/src/services/p2p-room.mjs

@@ -30,7 +30,13 @@ import {
   WAVED_PREDICATE,
 } from "../domain/p2p/facts.mjs";
 import { generateNodeId } from "../domain/p2p/peer-id.mjs";
-import { appendFacts, loadMemory, loadNodeId, saveNodeId, readFactRows, normFactTerm, FACT_CLASS } from "../adapters/memory/core.mjs";
+import {
+  RETRACTION_PREDICATE, encodeRetractionValue, decodeRetractionValue,
+} from "../domain/memory/retraction.mjs";
+import {
+  appendFacts, appendRetractions, loadMemory, loadNodeId, saveNodeId,
+  readFactRows, readRetractions, normFactTerm, factGroupId, factRecordIdForTag, FACT_CLASS,
+} from "../adapters/memory/core.mjs";
 
 export const ROOM_IDLE = "idle";
 export const ROOM_SHARING = "sharing";
@@ -156,6 +162,40 @@ const toWireFacts = (row, identity, fallbackTimestamp) => {
     }));
 };
 
+/** The record ids one provenance string keys once its tags have been relabelled
+ *  for the wire. Two stores file one assertion under two ids — here under the
+ *  chat session that taught it, at the peer under the node that sent it — so a
+ *  retraction that named only the ids it sees locally would bite on one store
+ *  and miss the other. Naming both is what makes it land either way. */
+function broadcastRecordIds(groupId, provenance, identity, fallbackTimestamp) {
+  const ids = [];
+  for (const { tag } of wireProvenanceTags(provenance, identity, fallbackTimestamp)) {
+    if (tag) ids.push(factRecordIdForTag(groupId, tag));
+  }
+  return ids;
+}
+
+/** A retraction goes out as ONE fact carrying every tag, not one per tag. The
+ *  per-tag split exists because appendFacts unions an incoming tag against the
+ *  ones it stores; a retraction merges through its own union instead, and the
+ *  tags it carries are already relabel fixpoints. */
+const toWireRetraction = (record, identity, fallbackTimestamp) => {
+  const groupId = factGroupId(record.subject);
+  const { retractedAt, ids } = decodeRetractionValue(record.object);
+  const tags = wireProvenanceTags(record.provenance, identity, fallbackTimestamp)
+    .map(({ tag }) => tag)
+    .filter(Boolean);
+  return {
+    subject: record.subject,
+    predicate: RETRACTION_PREDICATE,
+    object: encodeRetractionValue(retractedAt, [
+      ...ids,
+      ...broadcastRecordIds(groupId, record.provenance, identity, fallbackTimestamp),
+    ]),
+    provenance: tags.join(" | "),
+  };
+};
+
 /** A room: one shared world, one local fact store, and however many direct
  *  peer connections have been made into it.
  *
@@ -219,6 +259,14 @@ export function createP2pRoom({
   // fact that arrived from a peer being re-broadcast as if we had authored it.
   const seenProvenanceById = new Map();
   let cachedRows = [];
+  // A retraction is not a fact row — readFactRows can never return one, because
+  // the whole point of the record is that the rows it names are gone. So it
+  // gets its own cache and its own diff, keyed on what it actually carries: the
+  // ids it suppressed. Those grow by union as peers merge, and a grown record
+  // is a change worth broadcasting even though its provenance never moved.
+  let cachedRetractions = [];
+  const seenRetractionValueById = new Map();
+  const retractionDiffValue = (fact) => `${fact.provenance}${fact.object}`;
 
   // Store-touching work runs one job at a time, in arrival order. Every path
   // that reads or writes memoryDir/seenProvenanceById/cachedRows crosses at
@@ -263,10 +311,53 @@ export function createP2pRoom({
   }
 
   async function refreshRows() {
-    cachedRows = readFactRows(await loadMemory(memoryDir));
+    const memory = await loadMemory(memoryDir);
+    cachedRows = readFactRows(memory);
+    cachedRetractions = readRetractions(memory);
     return cachedRows;
   }
 
+  const toWire = (row, identity, timestamp) => (row.predicate === RETRACTION_PREDICATE
+    ? [toWireRetraction(row, identity, timestamp)]
+    : toWireFacts(row, identity, timestamp));
+
+  /** Fold the broadcast form of this node's own retractions back into the store.
+   *  A retraction made here names the ids this store files the assertion under;
+   *  a peer relaying that same assertion back sends it under the id the RELABEL
+   *  produces. Merging the broadcast form in is what makes the local refusal
+   *  cover it, and it is a union, so it settles after one pass. */
+  async function alignOwnRetractions() {
+    if (!cachedRetractions.length) return;
+    const identity = wireIdentity();
+    const timestamp = now();
+    const expanded = cachedRetractions.map((record) => toWireRetraction(record, identity, timestamp));
+    if (expanded.every((wire, i) => wire.object === cachedRetractions[i].object)) return;
+    await appendRetractions(memoryDir, expanded);
+    await refreshRows();
+  }
+
+  /** The other side of the same re-keying: a retraction that names this node's
+   *  broadcast id for an assertion also names whatever id this store files that
+   *  same assertion under. Without it a peer could retract a fact it learned
+   *  from here and the origin would keep reading its own copy. */
+  function localiseRetraction(fact) {
+    const groupId = factGroupId(fact.subject);
+    const { retractedAt, ids } = decodeRetractionValue(fact.object);
+    const named = new Set(ids);
+    const row = cachedRows.find((r) => r.id === groupId);
+    if (!row) return fact;
+    const identity = wireIdentity();
+    const timestamp = now();
+    const alsoNamed = [];
+    for (const assertion of row.assertions || []) {
+      if (named.has(assertion.id)) continue;
+      const asBroadcast = broadcastRecordIds(groupId, assertion.provenance, identity, timestamp);
+      if (asBroadcast.some((id) => named.has(id))) alsoNamed.push(assertion.id);
+    }
+    if (!alsoNamed.length) return fact;
+    return { ...fact, object: encodeRetractionValue(retractedAt, [...ids, ...alsoNamed]) };
+  }
+
   /** readFactRows walks `individuals` in array order and the fold reads them in
    *  that order, so two peers holding an identical fact set can still fold it
    *  differently while their arrival orders differ. Sorting the Fact
@@ -293,6 +384,7 @@ export function createP2pRoom({
   async function baselineSeen() {
     await refreshRows();
     for (const row of cachedRows) seenProvenanceById.set(row.id, row.provenance);
+    for (const fact of cachedRetractions) seenRetractionValueById.set(fact.id, retractionDiffValue(fact));
   }
 
   async function ensureStarted() {
@@ -322,17 +414,24 @@ export function createP2pRoom({
   async function flushLocalChange() {
     await ensureStarted();
     await refreshRows();
+    await alignOwnRetractions();
     const changed = [];
     for (const row of cachedRows) {
       if (seenProvenanceById.get(row.id) === row.provenance) continue;
       seenProvenanceById.set(row.id, row.provenance);
       changed.push(row);
     }
+    for (const fact of cachedRetractions) {
+      const value = retractionDiffValue(fact);
+      if (seenRetractionValueById.get(fact.id) === value) continue;
+      seenRetractionValueById.set(fact.id, value);
+      changed.push(fact);
+    }
     if (!changed.length) return { broadcast: 0 };
     const targets = connectedPeers();
     if (!targets.length) return { broadcast: 0 };
     const timestamp = now();
-    const facts = changed.flatMap((row) => toWireFacts(row, wireIdentity(), timestamp));
+    const facts = changed.flatMap((row) => toWire(row, wireIdentity(), timestamp));
     broadcast(opMessage({ from: myPeerId, facts }));
     return { broadcast: changed.length };
   }
@@ -343,7 +442,17 @@ export function createP2pRoom({
     // Flush first: a local fact still waiting to be diffed would otherwise be
     // recorded as merged below and never leave this browser.
     await flushLocalChange();
-    const { ids } = await appendFacts(memoryDir, accepted.map((f) => ({
+    // Retractions land BEFORE the assertions in the same batch, so a peer
+    // sending both the fact and the record that suppresses it lands them in the
+    // order that leaves the fact out. Either order converges — the read fold
+    // strips a record a retraction covers however late the retraction arrives —
+    // but doing it this way keeps a suppressed record from being written at all.
+    const retractions = accepted.filter((f) => f.predicate === RETRACTION_PREDICATE);
+    if (retractions.length) await appendRetractions(memoryDir, retractions.map(localiseRetraction));
+    const assertions = retractions.length
+      ? accepted.filter((f) => f.predicate !== RETRACTION_PREDICATE)
+      : accepted;
+    const { ids } = assertions.length ? await appendFacts(memoryDir, assertions.map((f) => ({
       subject: f.subject,
       predicate: f.predicate,
       object: f.object,
@@ -353,15 +462,21 @@ export function createP2pRoom({
       // this is the passthrough that lets a dated taught fact's wire fact
       // reach it at all.
       ...(typeof f.observedAt === "string" && f.observedAt ? { observedAt: f.observedAt } : {}),
-    })));
+    }))) : { ids: [] };
     await sortFactIndividualsById();
     await refreshRows();
     const mergedIds = new Set(ids);
     for (const row of cachedRows) {
       if (mergedIds.has(row.id)) seenProvenanceById.set(row.id, row.provenance);
     }
-    emit(factsListeners, { merged: ids.length, rows: cachedRows });
-    return { merged: ids.length };
+    // Same reason the fact baseline above exists: a retraction that arrived
+    // from a peer must not go back out as though this node had authored it.
+    // Every peer broadcasts its OWN record when it makes one, so the union each
+    // peer ends up with is reached from the originals rather than from relays.
+    for (const fact of cachedRetractions) seenRetractionValueById.set(fact.id, retractionDiffValue(fact));
+    const merged = ids.length + retractions.length;
+    emit(factsListeners, { merged, rows: cachedRows });
+    return { merged };
   }
 
   function registerPeer(peerId, peerDisplayName, transport) {
@@ -436,8 +551,10 @@ export function createP2pRoom({
       case "sync-request": {
         const facts = await withStore(async () => {
           await refreshRows();
+          await alignOwnRetractions();
           const timestamp = now();
-          return syncableFacts(cachedRows).flatMap((row) => toWireFacts(row, wireIdentity(), timestamp));
+          return syncableFacts([...cachedRows, ...cachedRetractions])
+            .flatMap((row) => toWire(row, wireIdentity(), timestamp));
         });
         send(transport, syncResponseMessage({ facts }));
         return;
@@ -644,7 +761,9 @@ export function createP2pRoom({
       // from reading to every peer as a brand-new node.
       nodeId = await resolveStoreNodeId(memoryDir, nodeId || myNodeId);
       seenProvenanceById.clear();
+      seenRetractionValueById.clear();
       cachedRows = [];
+      cachedRetractions = [];
       const timestamp = now();
       const identity = [];
       if (worldId && worldName) identity.push(worldNameFact(worldId, worldName, timestamp));
@@ -655,11 +774,13 @@ export function createP2pRoom({
       }
       await refreshRows();
       for (const row of cachedRows) seenProvenanceById.set(row.id, row.provenance);
+      for (const fact of cachedRetractions) seenRetractionValueById.set(fact.id, retractionDiffValue(fact));
       const targets = connectedPeers();
       let pushed = 0;
       if (targets.length) {
         const wireTimestamp = now();
-        const facts = syncableFacts(cachedRows).flatMap((row) => toWireFacts(row, wireIdentity(), wireTimestamp));
+        const facts = syncableFacts([...cachedRows, ...cachedRetractions])
+          .flatMap((row) => toWire(row, wireIdentity(), wireTimestamp));
         pushed = facts.length;
         if (facts.length) broadcast(opMessage({ from: myPeerId, facts }));
         broadcast(syncRequestMessage());