@weaveprotocol/core 0.1.1 → 0.2.0

package/dist/sync/sync-engine.js

@@ -1,40 +1,55 @@
-import { deserializeNode } from '../storage/mst.js';
-import { cidFromBytes } from '../utils/hash.js';
+import { cidDigest, cidOfDigest } from '../utils/hash.js';
+import { base64UrlDecode, base64UrlEncode, bytesToHex } from '../utils/encoding.js';
 import { createEmitter } from '../utils/events.js';
+import { createReconciler, fingerprintOf } from './negentropy.js';
 import { parseSyncMessage, SYNC_PROTOCOL_VERSION } from './sync-messages.js';
-import { differingEntries, unknownChildren, verifyNode } from './anti-entropy.js';
 /** At most this many records wait for what they depend on; the oldest give way */
 const MAX_WAITING = 1000;
+/** Refusals remembered, so reconciling doesn't ask a peer for the same bad version every round */
+const MAX_REFUSED = 10_000;
+/** Whether a collection is held, given what a node holds */
+export const holdsCollection = (holds, collection) => collection.startsWith('sys.') || holds === 'all' || holds.has(collection);
 /** Collection definitions first, then records by version — what others depend on comes first */
 const rank = (e) => (e?.collection === 'sys.collection' ? -1 : (e?.seq ?? 0));
-/** Nodes asked for in one message. Nodes are small; this keeps round trips few. */
-export const MAX_CIDS_PER_REQUEST = 64;
-/** Records asked for in one message. */
+/** Records asked for, or sent, in one message. */
 export const MAX_IDS_PER_REQUEST = 200;
-/** A real tree of a billion entries is about seven deep. Anything past this is hostile. */
-const MAX_DEPTH = 32;
-/** Nodes one walk may fetch before it is abandoned as runaway. */
-const MAX_NODES_PER_WALK = 200_000;
-/** A walk that has heard nothing for this long is given up on. */
-const STALE_WALK_MS = 30_000;
+/** Largest Negentropy message, in bytes before base64. Stays well inside a data channel's limit. */
+export const FRAME_SIZE_LIMIT = 32_000;
+/** Collections one hello may name. Past this it is hostile, not big. */
+const MAX_COLLECTIONS = 1000;
+/** Rounds one reconciliation may take before it is given up as runaway. */
+const MAX_ROUNDS = 64;
+/** A session that has heard nothing for this long is given up on. */
+const STALE_MS = 30_000;
 /**
  * Creates a sync engine orchestrator.
  * @param config Sync engine configuration.
  * @returns A sync engine instance.
  */
 export function createSyncEngine(config) {
-    const { storageProvider, sendToPeer, heartbeatInterval = 30000, validate } = config;
+    const { storageProvider: storage, sendToPeer, heartbeatInterval = 30000, validate, self } = config;
+    const ourHolds = config.holds ?? (() => 'all');
+    /** Peers to say hello to and push to */
     const peers = new Set();
-    const walks = new Map();
+    /** What's in flight with each peer */
+    const states = new Map();
     let intervalId = null;
-    let nextRequestId = 1;
+    let nextId = 1;
     const { on, off, emit } = createEmitter();
     const stamp = (msg) => ({ v: SYNC_PROTOCOL_VERSION, ...msg });
     const send = (peerId, msg) => sendToPeer(peerId, stamp(msg));
-    const broadcast = (msg) => {
-        for (const peer of peers)
-            sendToPeer(peer, stamp(msg));
-    };
+    const stateOf = (peerId) => states.get(peerId) ?? states.set(peerId, { sessions: new Map(), wants: new Map(), holds: 'all' }).get(peerId);
+    // ─── Taking in versions ────────────────────────────────────────────
+    /** Records that could not be judged yet — tried again whenever something new is admitted */
+    const waiting = new Map();
+    /**
+     * Versions the gatekeeper refused, as `peer + id`, oldest first. By peer,
+     * not by id alone: an id doesn't cover the signature, so a stranger's
+     * mangled copy shares the real record's id — refusing it must not stop us
+     * fetching the real one from someone else.
+     */
+    const refused = new Set();
+    const refusal = (peerId, id) => `${peerId}\n${id}`;
     /**
      * Commits an expression from a peer, but only if the gatekeeper allows it.
      * @returns Whether the expression was accepted
@@ -49,18 +64,19 @@ export function createSyncEngine(config) {
                         waiting.delete(waiting.keys().next().value);
                 }
                 else {
+                    refused.add(refusal(peerId, expression.id));
+                    if (refused.size > MAX_REFUSED)
+                        refused.delete(refused.values().next().value);
                     emit('rejected', peerId, expression, verdict.reason);
                 }
                 return false;
             }
         }
         waiting.delete(expression.id);
-        await storageProvider.addExpression(expression);
+        await storage.addExpression(expression);
         emit('expression-received', expression);
         return true;
     };
-    /** Records that could not be judged yet — tried again whenever something new is admitted */
-    const waiting = new Map();
     const retryWaiting = async () => {
         let progressed = true;
         while (progressed && waiting.size > 0) {
@@ -72,163 +88,266 @@ export function createSyncEngine(config) {
             }
         }
     };
-    // ─── The walk ──────────────────────────────────────────────────────
-    const finish = (peerId, walk) => {
-        walks.delete(peerId);
-        emit('synced', peerId);
-        if (walk.next !== null && walk.next !== walk.remoteRoot)
-            void pull(peerId, walk.next);
+    /**
+     * Admits a batch: definitions and first versions before what depends on
+     * them, so little has to wait. Versions of collections this node doesn't
+     * hold are passed over. The peer is told which it now has.
+     */
+    const admitAll = async (peerId, expressions) => {
+        const holds = ourHolds();
+        const stored = [];
+        for (const expression of [...expressions].sort((a, b) => rank(a) - rank(b))) {
+            if (!expression || typeof expression !== 'object' || typeof expression.collection !== 'string')
+                continue;
+            if (!holdsCollection(holds, expression.collection))
+                continue;
+            if (await admit(peerId, expression))
+                stored.push(expression.id);
+        }
+        if (stored.length > 0) {
+            send(peerId, { type: 'stored', ids: stored });
+            await retryWaiting();
+        }
     };
-    /** Sends whatever is queued, or moves on to records once the tree is done. */
-    const advance = (peerId, walk) => {
-        walk.touchedAt = Date.now();
-        while (walk.queue.length > 0) {
-            const batch = walk.queue.splice(0, MAX_CIDS_PER_REQUEST);
-            const id = nextRequestId++;
-            walk.nodeBatches.set(id, batch);
-            send(peerId, { type: 'node-request', id, cids: batch });
+    // ─── Hello ─────────────────────────────────────────────────────────
+    /** A fingerprint of each collection held and kept, hex */
+    const ourSums = async (holds) => {
+        const out = {};
+        for (const [collection, sum] of await storage.sums()) {
+            if (holdsCollection(holds, collection))
+                out[collection] = bytesToHex(await fingerprintOf(sum));
         }
-        if (walk.nodeBatches.size > 0)
+        return out;
+    };
+    const hello = async (peerId, reply = false) => {
+        const holds = ourHolds();
+        send(peerId, { type: 'hello', holds: holds === 'all' ? 'all' : [...holds], sums: await ourSums(holds), ...(reply ? { reply } : {}) });
+    };
+    /** What a hello says the peer holds; anything malformed counts as holding nothing past `sys.*` */
+    const readHolds = (value) => {
+        if (value === undefined || value === 'all')
+            return 'all';
+        if (!Array.isArray(value) || value.length > MAX_COLLECTIONS)
+            return new Set();
+        return new Set(value.filter((c) => typeof c === 'string'));
+    };
+    const onHello = async (peerId, theirs, theirHolds, reply) => {
+        if (typeof theirs !== 'object' || theirs === null)
             return;
-        // The tree is walked. Ask for the records it named that are not here.
-        if (walk.missing.size > 0 && walk.idBatches.size === 0) {
-            const ids = [...walk.missing];
-            walk.missing.clear();
-            for (let i = 0; i < ids.length; i += MAX_IDS_PER_REQUEST) {
-                const batch = ids.slice(i, i + MAX_IDS_PER_REQUEST);
-                const id = nextRequestId++;
-                walk.idBatches.set(id, batch);
-                send(peerId, { type: 'diff-request', id, missingIds: batch });
-            }
+        const names = Object.keys(theirs);
+        if (names.length > MAX_COLLECTIONS)
             return;
-        }
-        if (walk.idBatches.size === 0)
-            finish(peerId, walk);
-    };
-    /** Pulls a peer's tree, given its root. */
-    const pull = async (peerId, remoteRoot) => {
-        const current = walks.get(peerId);
-        if (current && Date.now() - current.touchedAt < STALE_WALK_MS) {
-            // One walk per peer at a time; a newer root is pulled when this one ends.
-            if (current.remoteRoot !== remoteRoot)
-                current.next = remoteRoot;
+        const state = stateOf(peerId);
+        state.holds = readHolds(theirHolds);
+        const holds = ourHolds();
+        const ours = await ourSums(holds);
+        // Everything either side names, and every collection this node holds even if it has none of it yet.
+        const named = new Set([...names, ...Object.keys(ours), ...(holds === 'all' ? [] : holds)]);
+        const shared = [...named].filter((c) => holdsCollection(holds, c) && holdsCollection(state.holds, c));
+        const differing = shared.filter((c) => theirs[c] !== ours[c]);
+        for (const c of shared)
+            if (theirs[c] === ours[c])
+                emit('level', peerId, c, state.holds === 'all');
+        if (differing.length === 0) {
+            if (!busy(peerId))
+                emit('synced', peerId, state.holds === 'all');
             return;
         }
-        walks.delete(peerId);
-        if (remoteRoot === null) {
-            emit('synced', peerId);
+        if (self !== undefined && self > peerId) {
+            // The other side starts. It may not have heard from us yet: tell it.
+            if (!reply)
+                await hello(peerId, true);
             return;
         }
-        const localRoot = await storageProvider.getRootCid();
-        if (await storageProvider.getAdapter().has(remoteRoot)) {
-            // A tree this store holds, or has moved past: nothing to pull.
-            emit('synced', peerId);
+        for (const collection of differing)
+            await begin(peerId, collection);
+    };
+    // ─── Reconciling, as initiator ─────────────────────────────────────
+    const busy = (peerId) => {
+        const state = states.get(peerId);
+        return !!state && (state.sessions.size > 0 || state.wants.size > 0);
+    };
+    const settleIfDone = (peerId) => {
+        if (!busy(peerId))
+            emit('synced', peerId, states.get(peerId)?.holds === 'all');
+    };
+    const begin = async (peerId, collection) => {
+        if (typeof collection !== 'string')
+            return;
+        const state = stateOf(peerId);
+        const current = state.sessions.get(collection);
+        if (current && Date.now() - current.touchedAt < STALE_MS) {
+            current.again = true;
             return;
         }
-        const walk = {
-            remoteRoot,
-            localRoot,
-            depth: new Map([[remoteRoot, 0]]),
-            queue: [remoteRoot],
-            nodeBatches: new Map(),
-            missing: new Set(),
-            idBatches: new Map(),
-            fetched: 0,
-            touchedAt: Date.now(),
-            next: null,
-        };
-        walks.set(peerId, walk);
-        advance(peerId, walk);
+        const reconciler = createReconciler(await storage.items(collection), { initiator: true, frameSizeLimit: FRAME_SIZE_LIMIT });
+        const session = { id: nextId++, collection, reconciler, rounds: 0, touchedAt: Date.now(), again: false, handled: new Set() };
+        state.sessions.set(collection, session);
+        send(peerId, { type: 'reconcile', id: session.id, collection, message: base64UrlEncode(await reconciler.initiate()) });
     };
-    const onNodes = async (peerId, requestId, nodes) => {
-        const walk = walks.get(peerId);
-        const batch = walk?.nodeBatches.get(requestId);
-        if (!walk || !batch)
-            return; // not ours, or already answered
-        const asked = new Set(batch);
-        const adapter = storageProvider.getAdapter();
-        for (const { cid, node: sent } of nodes) {
-            if (typeof cid !== 'string' || !asked.has(cid))
-                continue;
-            const node = await verifyNode(cid, sent);
-            if (!node)
-                continue; // malformed, or not the node that CID names
-            if (++walk.fetched > MAX_NODES_PER_WALK) {
-                walks.delete(peerId);
-                emit('error', new Error(`Sync with ${peerId} abandoned: more than ${MAX_NODES_PER_WALK} nodes`));
+    /**
+     * A collection's session and every request it made are over: level with the
+     * peer, as far as could be. The peer is told where things stand now, so it
+     * knows it is level too — marked a reply, so it never starts another round.
+     */
+    const levelIfDone = (peerId, collection) => {
+        const state = states.get(peerId);
+        if (!state || state.sessions.has(collection))
+            return;
+        for (const want of state.wants.values())
+            if (want.collection === collection)
                 return;
-            }
-            for (const id of await differingEntries(adapter, walk.localRoot, node))
-                walk.missing.add(id);
-            const depth = walk.depth.get(cid) ?? 0;
-            if (depth >= MAX_DEPTH)
-                continue;
-            for (const child of await unknownChildren(adapter, node)) {
-                if (walk.depth.has(child))
-                    continue; // already queued — a cycle, or a shared subtree
-                walk.depth.set(child, depth + 1);
-                walk.queue.push(child);
-            }
-        }
-        // Asked-for nodes the peer did not send are simply not followed: a peer can
-        // legitimately have compacted a node away between its root and our request.
-        // Marked answered only now, so a reply processed alongside this one cannot
-        // decide the tree is finished while this one's children are still unqueued.
-        walk.nodeBatches.delete(requestId);
-        advance(peerId, walk);
+        emit('level', peerId, collection, state.holds === 'all');
+        void hello(peerId, true).catch((err) => emit('error', err));
     };
-    const onRecords = async (peerId, requestId, expressions) => {
-        const walk = walks.get(peerId);
-        const asked = walk?.idBatches.get(requestId);
-        // Only records this node asked for are considered; anything else was not
-        // requested and is not taken on trust as a side effect.
-        const wanted = asked ? new Set(asked) : null;
-        // Definitions and first versions before what depends on them, so little has to wait.
-        const ordered = [...expressions].sort((a, b) => rank(a) - rank(b));
-        let admitted = false;
-        for (const expression of ordered) {
-            if (wanted?.has(expression?.id) && (await admit(peerId, expression)))
-                admitted = true;
+    const onReconciled = async (peerId, id, message, held) => {
+        const state = states.get(peerId);
+        const session = state && [...state.sessions.values()].find((s) => s.id === id);
+        if (!state || !session)
+            return; // not ours, or already over
+        session.touchedAt = Date.now();
+        const end = () => {
+            state.sessions.delete(session.collection);
+            if (session.again)
+                void begin(peerId, session.collection).catch((err) => emit('error', err));
+        };
+        if (!held) {
+            // They don't hold it after all — they changed what they hold since their hello.
+            end();
+            return settleIfDone(peerId);
         }
-        if (admitted)
-            await retryWaiting();
-        if (!walk || !asked)
+        let round;
+        try {
+            round = await session.reconciler.reconcile(base64UrlDecode(message));
+        }
+        catch (err) {
+            end();
+            emit('error', new Error(`Sync with ${peerId} abandoned: ${err.message}`));
+            return settleIfDone(peerId);
+        }
+        // What they lack goes now; what we lack is asked for.
+        const fresh = (id) => !session.handled.has(id) && !!session.handled.add(id);
+        const have = round.have.map(cidOfDigest).filter(fresh);
+        for (let i = 0; i < have.length; i += MAX_IDS_PER_REQUEST) {
+            const versions = (await Promise.all(have.slice(i, i + MAX_IDS_PER_REQUEST).map((v) => storage.getExpression(v)))).filter((v) => v !== null);
+            if (versions.length > 0)
+                send(peerId, { type: 'versions', versions });
+        }
+        const need = round.need.map(cidOfDigest).filter((v) => fresh(v) && !refused.has(refusal(peerId, v)));
+        for (let i = 0; i < need.length; i += MAX_IDS_PER_REQUEST) {
+            const ids = need.slice(i, i + MAX_IDS_PER_REQUEST);
+            const wantId = nextId++;
+            state.wants.set(wantId, { ids: new Set(ids), collection: session.collection });
+            send(peerId, { type: 'want', id: wantId, ids });
+        }
+        if (round.message && ++session.rounds < MAX_ROUNDS) {
+            send(peerId, { type: 'reconcile', id: session.id, collection: session.collection, message: base64UrlEncode(round.message) });
             return;
-        walk.idBatches.delete(requestId);
-        advance(peerId, walk);
+        }
+        if (round.message)
+            emit('error', new Error(`Sync with ${peerId} abandoned: more than ${MAX_ROUNDS} rounds`));
+        end();
+        levelIfDone(peerId, session.collection);
+        settleIfDone(peerId);
     };
-    // ─── Serving ───────────────────────────────────────────────────────
-    const serveNodes = async (peerId, requestId, cids) => {
-        const adapter = storageProvider.getAdapter();
-        const nodes = [];
-        for (const cid of cids.slice(0, MAX_CIDS_PER_REQUEST)) {
-            if (typeof cid !== 'string')
-                continue;
-            const bytes = await adapter.get(cid);
-            // Only content-addressed tree nodes leave this store — never another key
-            // that happens to share the namespace.
-            if (bytes && (await cidFromBytes(bytes)) === cid)
-                nodes.push({ cid, node: deserializeNode(bytes) });
+    // ─── Answering ─────────────────────────────────────────────────────
+    const onReconcile = async (peerId, id, collection, message) => {
+        if (typeof collection !== 'string' || typeof message !== 'string')
+            return;
+        if (!holdsCollection(ourHolds(), collection)) {
+            send(peerId, { type: 'reconciled', id, message: '', held: false });
+            return;
         }
-        send(peerId, { type: 'node-response', id: requestId, nodes });
+        const responder = createReconciler(await storage.items(collection), { initiator: false, frameSizeLimit: FRAME_SIZE_LIMIT });
+        const round = await responder.reconcile(base64UrlDecode(message));
+        send(peerId, { type: 'reconciled', id, message: base64UrlEncode(round.message) });
     };
-    const serveRecords = async (peerId, requestId, ids) => {
-        const expressions = [];
-        for (const id of ids.slice(0, MAX_IDS_PER_REQUEST)) {
-            const expression = typeof id === 'string' ? await storageProvider.getExpression(id) : null;
+    const serveWant = async (peerId, id, ids) => {
+        const versions = [];
+        for (const v of ids.slice(0, MAX_IDS_PER_REQUEST)) {
+            const expression = typeof v === 'string' && cidDigest(v) ? await storage.getExpression(v) : null;
             if (expression)
-                expressions.push(expression);
+                versions.push(expression);
         }
         // Always answered, even empty: the asker counts replies to know it is done.
-        send(peerId, { type: 'diff-response', id: requestId, expressions });
+        send(peerId, { type: 'versions', id, versions });
     };
+    const onVersions = async (peerId, id, versions) => {
+        const state = states.get(peerId);
+        if (id === undefined) {
+            // Sent because we lacked them. Nothing is taken on trust: each passes the gatekeeper.
+            await admitAll(peerId, versions.slice(0, MAX_IDS_PER_REQUEST));
+            return;
+        }
+        const asked = state?.wants.get(id);
+        if (!state || !asked)
+            return;
+        // Only versions asked for are considered.
+        await admitAll(peerId, versions.filter((v) => asked.ids.has(v?.id)));
+        state.wants.delete(id);
+        levelIfDone(peerId, asked.collection);
+        settleIfDone(peerId);
+    };
+    // ─── Housekeeping ──────────────────────────────────────────────────
+    /** Drops sessions and requests a peer stopped answering, so a lost message can't wedge sync */
+    const sweep = () => {
+        const now = Date.now();
+        for (const state of states.values()) {
+            for (const [collection, session] of state.sessions)
+                if (now - session.touchedAt > STALE_MS)
+                    state.sessions.delete(collection);
+        }
+    };
+    /** Handles one message from a peer; anything that is not a sync message this peer speaks is ignored */
+    const handle = async (peerId, message) => {
+        try {
+            const msg = parseSyncMessage(message);
+            // Malformed, a protocol version this peer does not speak, or a peer not
+            // added yet: an answer to it would have no way back and be lost, leaving
+            // a session waiting. Each side says hello once it adds the other, so
+            // nothing said before then is needed.
+            if (!msg || !peers.has(peerId))
+                return;
+            switch (msg.type) {
+                case 'hello':
+                    await onHello(peerId, msg.sums, msg.holds, msg.reply === true);
+                    break;
+                case 'reconcile':
+                    await onReconcile(peerId, msg.id, msg.collection, msg.message);
+                    break;
+                case 'reconciled':
+                    await onReconciled(peerId, msg.id, msg.message, msg.held !== false);
+                    break;
+                case 'want':
+                    await serveWant(peerId, msg.id, Array.isArray(msg.ids) ? msg.ids : []);
+                    break;
+                case 'versions':
+                    await onVersions(peerId, msg.id, Array.isArray(msg.versions) ? msg.versions : []);
+                    break;
+                case 'push-update':
+                    if (msg.expression && typeof msg.expression === 'object')
+                        await admitAll(peerId, [msg.expression]);
+                    break;
+                case 'stored':
+                    if (Array.isArray(msg.ids))
+                        emit('stored', peerId, msg.ids.filter((v) => typeof v === 'string').slice(0, 10 * MAX_IDS_PER_REQUEST));
+                    break;
+            }
+        }
+        catch (err) {
+            emit('error', err);
+        }
+    };
+    /** Where each peer's messages are up to */
+    const inOrder = new Map();
     return {
         start() {
             if (intervalId !== null)
                 return;
-            intervalId = setInterval(async () => {
-                const rootCid = await storageProvider.getRootCid();
-                broadcast({ type: 'sync-request', rootCid });
+            intervalId = setInterval(() => {
+                sweep();
+                for (const peer of peers)
+                    void hello(peer).catch((err) => emit('error', err));
             }, heartbeatInterval);
         },
         stop() {
@@ -236,71 +355,35 @@ export function createSyncEngine(config) {
                 clearInterval(intervalId);
                 intervalId = null;
             }
-            walks.clear();
+            states.clear();
         },
-        async handleMessage(peerId, message) {
-            try {
-                const msg = parseSyncMessage(message);
-                if (!msg)
-                    return; // malformed, or a protocol version this peer does not speak
-                switch (msg.type) {
-                    case 'sync-request': {
-                        const localRoot = await storageProvider.getRootCid();
-                        const differs = localRoot !== msg.rootCid;
-                        send(peerId, { type: 'sync-response', rootCid: localRoot, hasChanges: differs });
-                        // They will pull ours from the response; we pull theirs.
-                        if (differs)
-                            await pull(peerId, msg.rootCid);
-                        break;
-                    }
-                    case 'sync-response': {
-                        if (msg.hasChanges)
-                            await pull(peerId, msg.rootCid);
-                        else
-                            emit('synced', peerId);
-                        break;
-                    }
-                    case 'node-request':
-                        await serveNodes(peerId, msg.id, Array.isArray(msg.cids) ? msg.cids : []);
-                        break;
-                    case 'node-response':
-                        await onNodes(peerId, msg.id, Array.isArray(msg.nodes) ? msg.nodes : []);
-                        break;
-                    case 'diff-request':
-                        await serveRecords(peerId, msg.id, Array.isArray(msg.missingIds) ? msg.missingIds : []);
-                        break;
-                    case 'diff-response':
-                        await onRecords(peerId, msg.id, Array.isArray(msg.expressions) ? msg.expressions : []);
-                        break;
-                    case 'push-update':
-                        await admit(peerId, msg.expression);
-                        break;
-                }
-            }
-            catch (err) {
-                emit('error', err);
-            }
+        handleMessage(peerId, message) {
+            // One peer's messages are handled in the order they came: a hello saying
+            // where things stand must not overtake the versions sent before it.
+            const run = (inOrder.get(peerId) ?? Promise.resolve()).then(() => handle(peerId, message));
+            inOrder.set(peerId, run);
+            void run.finally(() => {
+                if (inOrder.get(peerId) === run)
+                    inOrder.delete(peerId);
+            });
+            return run;
         },
         notifyPeers(peerIds) {
-            storageProvider.getRootCid().then(rootCid => {
-                for (const peer of peerIds) {
-                    if (peers.has(peer))
-                        send(peer, { type: 'sync-request', rootCid });
-                }
-            }).catch(err => emit('error', err));
+            for (const peer of peerIds)
+                if (peers.has(peer))
+                    void hello(peer).catch((err) => emit('error', err));
         },
         onLocalChange(expression) {
-            storageProvider.getRootCid().then(newRootCid => {
-                broadcast({ type: 'push-update', expression, newRootCid: newRootCid || '' });
-            }).catch(err => emit('error', err));
+            for (const peer of peers)
+                send(peer, { type: 'push-update', expression });
         },
         addPeer(peerId) {
             peers.add(peerId);
         },
         removePeer(peerId) {
+            // A dropped peer must not leave half-finished sessions holding memory.
             peers.delete(peerId);
-            // A dropped peer must not leave a half-finished walk holding memory.
-            walks.delete(peerId);
+            states.delete(peerId);
         },
         on,
         off,