dandelion-mesh 1.0.0

package/build/main/mesh/DandelionMesh.js

@@ -0,0 +1,368 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DandelionMesh = void 0;
+const CryptoService_1 = require("../crypto/CryptoService");
+const RaftNode_1 = require("../raft/RaftNode");
+const InMemoryRaftLog_1 = require("../raft/log/InMemoryRaftLog");
+/**
+ * DandelionMesh — a fault-tolerant P2P mesh network for browser applications.
+ *
+ * Combines three layers:
+ * - **Transport** (default: PeerJS) — handles peer-to-peer WebRTC connections.
+ * - **Crypto** — RSA-OAEP + AES-256-GCM hybrid encryption for private messages.
+ * - **Raft consensus** — leader election and totally-ordered log replication.
+ *
+ * All application messages (public broadcasts and encrypted private messages)
+ * flow through the Raft log, guaranteeing every peer sees the same events in
+ * the same order. Non-leader peers forward proposals to the current leader.
+ *
+ * ## Events
+ *
+ * | Event            | Payload                              | When                                       |
+ * |------------------|--------------------------------------|---------------------------------------------|
+ * | `ready`          | `localPeerId: string`                | Transport is open and Raft has started       |
+ * | `message`        | `MeshMessage<T>, replay: boolean`    | A committed log entry is delivered           |
+ * | `peersChanged`   | `peers: string[]`                    | A peer connects or disconnects               |
+ * | `leaderChanged`  | `leaderId: string \| null`           | Raft leader changes                          |
+ * | `error`          | `Error`                              | Transport-level error                        |
+ *
+ * @typeParam T - The application-level payload type for messages.
+ *
+ * @example
+ * ```ts
+ * const transport = new PeerJSTransport({ peerId: 'alice' });
+ * const mesh = new DandelionMesh<GameAction>(transport, {
+ *   bootstrapPeers: ['bob', 'charlie'],
+ * });
+ *
+ * mesh.on('ready', (id) => console.log('My ID:', id));
+ * mesh.on('message', (msg) => {
+ *   if (msg.type === 'public')  console.log(msg.sender, msg.data);
+ *   if (msg.type === 'private') console.log('secret from', msg.sender);
+ * });
+ *
+ * await mesh.sendPublic({ action: 'bet', amount: 100 });
+ * await mesh.sendPrivate('bob', { cards: ['Ah', 'Kd'] });
+ * ```
+ *
+ * @example Providing a pre-generated crypto key bundle
+ * ```ts
+ * const bundle = await generateKeyBundle(2048);
+ * const mesh = new DandelionMesh(transport, { cryptoKeyBundle: bundle });
+ * ```
+ */
+class DandelionMesh {
+    constructor(transport, options) {
+        var _a, _b, _c, _d;
+        this.raftNode = null;
+        this.cryptoBundle = null;
+        this.peerPublicKeys = new Map();
+        this.pendingKeyWaiters = new Map();
+        this.lastAppliedIndex = 0;
+        this.listeners = {
+            ready: new Set(),
+            message: new Set(),
+            peersChanged: new Set(),
+            leaderChanged: new Set(),
+            error: new Set(),
+        };
+        // --- Transport event handlers ---
+        this.onTransportOpen = (peerId) => {
+            this.localPeerId = peerId;
+            // Connect to bootstrap peers
+            for (const bp of this.bootstrapPeers) {
+                if (bp !== peerId) {
+                    this.transport.connect(bp);
+                }
+            }
+            // Initialize Raft node
+            this.raftNode = new RaftNode_1.RaftNode(peerId, this.raftLog, this.raftOptions);
+            this.raftNode.sendMessage = (toPeerId, message) => {
+                this.transport
+                    .send(toPeerId, this.wireMessage('raft', message))
+                    .catch(() => {
+                    // Peer may have disconnected; non-fatal
+                });
+            };
+            this.raftNode.on('committed', this.onRaftCommitted);
+            this.raftNode.on('leaderChanged', (leaderId) => {
+                this.emit('leaderChanged', leaderId);
+            });
+            // Start Raft with currently connected peers
+            this.raftNode.start(this.transport.connectedPeers);
+            this.emit('ready', peerId);
+            // Propose our public key through Raft so all peers (including
+            // those joining later) receive it via log replay.
+            this.proposePublicKey();
+        };
+        this.onPeerConnected = (_remotePeerId) => {
+            var _a;
+            // Update Raft cluster membership
+            (_a = this.raftNode) === null || _a === void 0 ? void 0 : _a.updatePeers(this.transport.connectedPeers);
+            this.emit('peersChanged', this.peers);
+        };
+        this.onPeerDisconnected = (_remotePeerId) => {
+            var _a;
+            (_a = this.raftNode) === null || _a === void 0 ? void 0 : _a.updatePeers(this.transport.connectedPeers);
+            this.emit('peersChanged', this.peers);
+        };
+        this.onTransportMessage = (fromPeerId, data) => {
+            var _a;
+            const wire = data;
+            if (!wire || !wire.channel)
+                return;
+            if (wire.channel === 'raft') {
+                (_a = this.raftNode) === null || _a === void 0 ? void 0 : _a.handleMessage(fromPeerId, wire.payload);
+            }
+            else if (wire.channel === 'control') {
+                this.handleControlMessage(wire.payload);
+            }
+        };
+        this.onTransportError = (error) => {
+            this.emit('error', error);
+        };
+        // --- Raft commit handler ---
+        this.onRaftCommitted = (entry, index) => {
+            const isReplay = index <= this.lastAppliedIndex;
+            const cmd = entry.command;
+            switch (cmd._meshType) {
+                case 'public':
+                    this.emit('message', {
+                        type: 'public',
+                        sender: cmd.sender,
+                        data: cmd.data,
+                    }, isReplay);
+                    break;
+                case 'encrypted':
+                    this.handleEncryptedCommit(cmd, isReplay);
+                    break;
+                case 'publicKey': {
+                    if (!this.peerPublicKeys.has(cmd.peerId)) {
+                        const keyPromise = (0, CryptoService_1.importPublicKey)(cmd.jwk);
+                        this.peerPublicKeys.set(cmd.peerId, keyPromise);
+                        // Notify any pending sendPrivate calls waiting for this key
+                        const waiters = this.pendingKeyWaiters.get(cmd.peerId);
+                        if (waiters) {
+                            for (const resolve of waiters) {
+                                resolve(keyPromise);
+                            }
+                            this.pendingKeyWaiters.delete(cmd.peerId);
+                        }
+                    }
+                    break;
+                }
+            }
+            if (!isReplay) {
+                this.lastAppliedIndex = index;
+            }
+        };
+        this.transport = transport;
+        this.modulusLength = (_a = options === null || options === void 0 ? void 0 : options.modulusLength) !== null && _a !== void 0 ? _a : 4096;
+        this.raftOptions = (_b = options === null || options === void 0 ? void 0 : options.raft) !== null && _b !== void 0 ? _b : {};
+        this.raftLog =
+            (_c = options === null || options === void 0 ? void 0 : options.raftLog) !== null && _c !== void 0 ? _c : new InMemoryRaftLog_1.InMemoryRaftLog();
+        this.bootstrapPeers = (_d = options === null || options === void 0 ? void 0 : options.bootstrapPeers) !== null && _d !== void 0 ? _d : [];
+        this.lastAppliedIndex = this.raftLog.length();
+        // Use provided key bundle or generate a new one
+        this.cryptoReady = ((options === null || options === void 0 ? void 0 : options.cryptoKeyBundle)
+            ? Promise.resolve(options.cryptoKeyBundle)
+            : (0, CryptoService_1.generateKeyBundle)(this.modulusLength)).then((bundle) => {
+            this.cryptoBundle = bundle;
+            return bundle;
+        });
+        // Wire up transport events
+        this.transport.on('open', this.onTransportOpen);
+        this.transport.on('peerConnected', this.onPeerConnected);
+        this.transport.on('peerDisconnected', this.onPeerDisconnected);
+        this.transport.on('message', this.onTransportMessage);
+        this.transport.on('error', this.onTransportError);
+    }
+    // --- Public API ---
+    /** Send a public (broadcast) message through the Raft cluster */
+    async sendPublic(data) {
+        if (!this.raftNode || !this.localPeerId)
+            return false;
+        const entry = {
+            _meshType: 'public',
+            sender: this.localPeerId,
+            data,
+        };
+        if (this.raftNode.isLeader()) {
+            return this.raftNode.propose(entry);
+        }
+        // Forward to leader
+        const leaderId = this.raftNode.getLeaderId();
+        if (!leaderId)
+            return false;
+        const propose = { _meshType: 'propose', command: entry };
+        await this.transport.send(leaderId, this.wireMessage('control', propose));
+        return true;
+    }
+    /** Send an encrypted private message through the Raft cluster */
+    async sendPrivate(recipientPeerId, data) {
+        if (!this.raftNode || !this.localPeerId)
+            return false;
+        const recipientKey = await this.getOrAwaitPublicKey(recipientPeerId);
+        const plaintext = new TextEncoder().encode(JSON.stringify(data));
+        const payload = await (0, CryptoService_1.encrypt)(plaintext, recipientKey);
+        const entry = {
+            _meshType: 'encrypted',
+            sender: this.localPeerId,
+            recipient: recipientPeerId,
+            payload,
+        };
+        if (this.raftNode.isLeader()) {
+            return this.raftNode.propose(entry);
+        }
+        // Forward to leader
+        const leaderId = this.raftNode.getLeaderId();
+        if (!leaderId)
+            return false;
+        const propose = { _meshType: 'propose', command: entry };
+        await this.transport.send(leaderId, this.wireMessage('control', propose));
+        return true;
+    }
+    /** Get all connected peer IDs (including self) */
+    get peers() {
+        const connected = [...this.transport.connectedPeers];
+        if (this.localPeerId)
+            connected.unshift(this.localPeerId);
+        return connected;
+    }
+    /** Get the current Raft leader ID */
+    get leaderId() {
+        var _a, _b;
+        return (_b = (_a = this.raftNode) === null || _a === void 0 ? void 0 : _a.getLeaderId()) !== null && _b !== void 0 ? _b : null;
+    }
+    /** Whether this node is the Raft leader */
+    get isLeader() {
+        var _a, _b;
+        return (_b = (_a = this.raftNode) === null || _a === void 0 ? void 0 : _a.isLeader()) !== null && _b !== void 0 ? _b : false;
+    }
+    /** The local peer ID (available after 'ready') */
+    get peerId() {
+        return this.localPeerId;
+    }
+    /** Register an event listener */
+    on(event, listener) {
+        this.listeners[event].add(listener);
+    }
+    /** Remove an event listener */
+    off(event, listener) {
+        this.listeners[event].delete(listener);
+    }
+    /** Shut down the mesh: stop Raft, close transport */
+    close() {
+        var _a;
+        (_a = this.raftNode) === null || _a === void 0 ? void 0 : _a.destroy();
+        this.transport.off('open', this.onTransportOpen);
+        this.transport.off('peerConnected', this.onPeerConnected);
+        this.transport.off('peerDisconnected', this.onPeerDisconnected);
+        this.transport.off('message', this.onTransportMessage);
+        this.transport.off('error', this.onTransportError);
+        this.transport.close();
+    }
+    // --- Control message handling ---
+    handleControlMessage(msg) {
+        var _a;
+        switch (msg._meshType) {
+            case 'propose': {
+                // A non-leader peer is forwarding a command to us (the leader)
+                if ((_a = this.raftNode) === null || _a === void 0 ? void 0 : _a.isLeader()) {
+                    this.raftNode.propose(msg.command);
+                }
+                break;
+            }
+        }
+    }
+    async handleEncryptedCommit(cmd, isReplay) {
+        if (!this.localPeerId)
+            return;
+        // Only the intended recipient decrypts
+        if (cmd.recipient !== this.localPeerId)
+            return;
+        if (!this.cryptoBundle) {
+            await this.cryptoReady;
+        }
+        try {
+            const plaintext = await (0, CryptoService_1.decrypt)(cmd.payload, this.cryptoBundle.privateKey);
+            const data = JSON.parse(new TextDecoder().decode(plaintext));
+            this.emit('message', {
+                type: 'private',
+                sender: cmd.sender,
+                recipient: cmd.recipient,
+                data,
+            }, isReplay);
+        }
+        catch (err) {
+            // Not for us or decryption failed — this is expected for other recipients
+        }
+    }
+    // --- Key management ---
+    async proposePublicKey() {
+        if (!this.cryptoBundle) {
+            await this.cryptoReady;
+        }
+        if (!this.localPeerId || !this.cryptoBundle || !this.raftNode)
+            return;
+        // Wait until a leader is available
+        if (!this.raftNode.isLeader() && !this.raftNode.getLeaderId()) {
+            await new Promise((resolve) => {
+                const onLeader = (leaderId) => {
+                    if (leaderId) {
+                        this.off('leaderChanged', onLeader);
+                        resolve();
+                    }
+                };
+                this.on('leaderChanged', onLeader);
+            });
+        }
+        if (!this.raftNode)
+            return;
+        const announcement = {
+            _meshType: 'publicKey',
+            peerId: this.localPeerId,
+            jwk: this.cryptoBundle.publicKeyJwk,
+        };
+        if (this.raftNode.isLeader()) {
+            this.raftNode.propose(announcement);
+        }
+        else {
+            const leaderId = this.raftNode.getLeaderId();
+            if (!leaderId)
+                return;
+            const propose = {
+                _meshType: 'propose',
+                command: announcement,
+            };
+            this.transport
+                .send(leaderId, this.wireMessage('control', propose))
+                .catch(() => { });
+        }
+    }
+    async getOrAwaitPublicKey(peerId) {
+        const existing = this.peerPublicKeys.get(peerId);
+        if (existing)
+            return existing;
+        // Wait for the key to arrive via Raft commit
+        return new Promise((resolve) => {
+            let waiters = this.pendingKeyWaiters.get(peerId);
+            if (!waiters) {
+                waiters = [];
+                this.pendingKeyWaiters.set(peerId, waiters);
+            }
+            waiters.push((keyPromise) => resolve(keyPromise));
+        });
+    }
+    // --- Helpers ---
+    wireMessage(channel, payload) {
+        return { channel, payload };
+    }
+    emit(event, ...args) {
+        for (const listener of this.listeners[event]) {
+            listener(...args);
+        }
+    }
+}
+exports.DandelionMesh = DandelionMesh;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"DandelionMesh.js","sourceRoot":"","sources":["../../../src/mesh/DandelionMesh.ts"],"names":[],"mappings":";;;AAAA,2DAMiC;AACjC,+CAA6D;AAC7D,iEAA8D;AAuC9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,MAAa,aAAa;IA2BxB,YAAY,SAAoB,EAAE,OAA8B;;QAxBxD,aAAQ,GAAuC,IAAI,CAAC;QAIpD,iBAAY,GAA2B,IAAI,CAAC;QACnC,mBAAc,GAAG,IAAI,GAAG,EAA8B,CAAC;QACvD,sBAAiB,GAAG,IAAI,GAAG,EAGzC,CAAC;QAKI,qBAAgB,GAAG,CAAC,CAAC;QAEZ,cAAS,GAAmB;YAC3C,KAAK,EAAE,IAAI,GAAG,EAAE;YAChB,OAAO,EAAE,IAAI,GAAG,EAAE;YAClB,YAAY,EAAE,IAAI,GAAG,EAAE;YACvB,aAAa,EAAE,IAAI,GAAG,EAAE;YACxB,KAAK,EAAE,IAAI,GAAG,EAAE;SACjB,CAAC;QAoIF,mCAAmC;QAE3B,oBAAe,GAAG,CAAC,MAAc,EAAQ,EAAE;YACjD,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC;YAE1B,6BAA6B;YAC7B,KAAK,MAAM,EAAE,IAAI,IAAI,CAAC,cAAc,EAAE;gBACpC,IAAI,EAAE,KAAK,MAAM,EAAE;oBACjB,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;iBAC5B;aACF;YAED,uBAAuB;YACvB,IAAI,CAAC,QAAQ,GAAG,IAAI,mBAAQ,CAC1B,MAAM,EACN,IAAI,CAAC,OAAO,EACZ,IAAI,CAAC,WAAW,CACjB,CAAC;YACF,IAAI,CAAC,QAAQ,CAAC,WAAW,GAAG,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE;gBAChD,IAAI,CAAC,SAAS;qBACX,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;qBACjD,KAAK,CAAC,GAAG,EAAE;oBACV,wCAAwC;gBAC1C,CAAC,CAAC,CAAC;YACP,CAAC,CAAC;YACF,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,WAAW,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC;YACpD,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,eAAe,EAAE,CAAC,QAAQ,EAAE,EAAE;gBAC7C,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,QAAQ,CAAC,CAAC;YACvC,CAAC,CAAC,CAAC;YAEH,4CAA4C;YAC5C,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,cAA0B,CAAC,CAAC;YAE/D,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;YAE3B,8DAA8D;YAC9D,kDAAkD;YAClD,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAC1B,CAAC,CAAC;QAEM,oBAAe,GAAG,CAAC,aAAqB,EAAQ,EAAE;;YACxD,iCAAiC;YACjC,MAAA,IAAI,CAAC,QAAQ,0CAAE,WAAW,CAAC,IAAI,CAAC,SAAS,CAAC,cAA0B,CAAC,CAAC;YACtE,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;QACxC,CAAC,CAAC;QAEM,uBAAkB,GAAG,CAAC,aAAqB,EAAQ,EAAE;;YAC3D,MAAA,IAAI,CAAC,QAAQ,0CAAE,WAAW,CAAC,IAAI,CAAC,SAAS,CAAC,cAA0B,CAAC,CAAC;YACtE,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;QACxC,CAAC,CAAC;QAEM,uBAAkB,GAAG,CAAC,UAAkB,EAAE,IAAa,EAAQ,EAAE;;YACvE,MAAM,IAAI,GAAG,IAAmB,CAAC;YACjC,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,OAAO;gBAAE,OAAO;YAEnC,IAAI,IAAI,CAAC,OAAO,KAAK,MAAM,EAAE;gBAC3B,MAAA,IAAI,CAAC,QAAQ,0CAAE,aAAa,CAC1B,UAAU,EACV,IAAI,CAAC,OAAyC,CAC/C,CAAC;aACH;iBAAM,IAAI,IAAI,CAAC,OAAO,KAAK,SAAS,EAAE;gBACrC,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,OAAgC,CAAC,CAAC;aAClE;QACH,CAAC,CAAC;QAEM,qBAAgB,GAAG,CAAC,KAAY,EAAQ,EAAE;YAChD,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QAC5B,CAAC,CAAC;QAgBF,8BAA8B;QAEtB,oBAAe,GAAG,CACxB,KAAkC,EAClC,KAAa,EACP,EAAE;YACR,MAAM,QAAQ,GAAG,KAAK,IAAI,IAAI,CAAC,gBAAgB,CAAC;YAChD,MAAM,GAAG,GAAG,KAAK,CAAC,OAAO,CAAC;YAC1B,QAAQ,GAAG,CAAC,SAAS,EAAE;gBACrB,KAAK,QAAQ;oBACX,IAAI,CAAC,IAAI,CACP,SAAS,EACT;wBACE,IAAI,EAAE,QAAQ;wBACd,MAAM,EAAE,GAAG,CAAC,MAAM;wBAClB,IAAI,EAAE,GAAG,CAAC,IAAI;qBACG,EACnB,QAAQ,CACT,CAAC;oBACF,MAAM;gBAER,KAAK,WAAW;oBACd,IAAI,CAAC,qBAAqB,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;oBAC1C,MAAM;gBAER,KAAK,WAAW,CAAC,CAAC;oBAChB,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE;wBACxC,MAAM,UAAU,GAAG,IAAA,+BAAe,EAAC,GAAG,CAAC,GAAG,CAAC,CAAC;wBAC5C,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;wBAEhD,4DAA4D;wBAC5D,MAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;wBACvD,IAAI,OAAO,EAAE;4BACX,KAAK,MAAM,OAAO,IAAI,OAAO,EAAE;gCAC7B,OAAO,CAAC,UAAU,CAAC,CAAC;6BACrB;4BACD,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;yBAC3C;qBACF;oBACD,MAAM;iBACP;aACF;YAED,IAAI,CAAC,QAAQ,EAAE;gBACb,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;aAC/B;QACH,CAAC,CAAC;QAlQA,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3B,IAAI,CAAC,aAAa,GAAG,MAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,aAAa,mCAAI,IAAI,CAAC;QACpD,IAAI,CAAC,WAAW,GAAG,MAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,IAAI,mCAAI,EAAE,CAAC;QACvC,IAAI,CAAC,OAAO;YACV,MAAC,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,OAAsC,mCAChD,IAAI,iCAAe,EAAqB,CAAC;QAC3C,IAAI,CAAC,cAAc,GAAG,MAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,cAAc,mCAAI,EAAE,CAAC;QACpD,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;QAE9C,gDAAgD;QAChD,IAAI,CAAC,WAAW,GAAG,CACjB,CAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,eAAe;YACtB,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,eAAe,CAAC;YAC1C,CAAC,CAAC,IAAA,iCAAiB,EAAC,IAAI,CAAC,aAAa,CAAC,CAC1C,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE;YAChB,IAAI,CAAC,YAAY,GAAG,MAAM,CAAC;YAC3B,OAAO,MAAM,CAAC;QAChB,CAAC,CAAC,CAAC;QAEH,2BAA2B;QAC3B,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC;QAChD,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,eAAe,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC;QACzD,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,kBAAkB,EAAE,IAAI,CAAC,kBAAkB,CAAC,CAAC;QAC/D,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,SAAS,EAAE,IAAI,CAAC,kBAAkB,CAAC,CAAC;QACtD,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,IAAI,CAAC,gBAAgB,CAAC,CAAC;IACpD,CAAC;IAED,qBAAqB;IAErB,iEAAiE;IACjE,KAAK,CAAC,UAAU,CAAC,IAAO;QACtB,IAAI,CAAC,IAAI,CAAC,QAAQ,IAAI,CAAC,IAAI,CAAC,WAAW;YAAE,OAAO,KAAK,CAAC;QAEtD,MAAM,KAAK,GAA0B;YACnC,SAAS,EAAE,QAAQ;YACnB,MAAM,EAAE,IAAI,CAAC,WAAW;YACxB,IAAI;SACL,CAAC;QAEF,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,EAAE;YAC5B,OAAO,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;SACrC;QAED,oBAAoB;QACpB,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC;QAC7C,IAAI,CAAC,QAAQ;YAAE,OAAO,KAAK,CAAC;QAE5B,MAAM,OAAO,GAAsB,EAAE,SAAS,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;QAC5E,MAAM,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,CAAC;QAC1E,OAAO,IAAI,CAAC;IACd,CAAC;IAED,iEAAiE;IACjE,KAAK,CAAC,WAAW,CAAC,eAAuB,EAAE,IAAO;QAChD,IAAI,CAAC,IAAI,CAAC,QAAQ,IAAI,CAAC,IAAI,CAAC,WAAW;YAAE,OAAO,KAAK,CAAC;QAEtD,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,mBAAmB,CAAC,eAAe,CAAC,CAAC;QACrE,MAAM,SAAS,GAAG,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;QACjE,MAAM,OAAO,GAAG,MAAM,IAAA,uBAAO,EAAC,SAAS,EAAE,YAAY,CAAC,CAAC;QAEvD,MAAM,KAAK,GAA4B;YACrC,SAAS,EAAE,WAAW;YACtB,MAAM,EAAE,IAAI,CAAC,WAAW;YACxB,SAAS,EAAE,eAAe;YAC1B,OAAO;SACR,CAAC;QAEF,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,EAAE;YAC5B,OAAO,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;SACrC;QAED,oBAAoB;QACpB,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC;QAC7C,IAAI,CAAC,QAAQ;YAAE,OAAO,KAAK,CAAC;QAE5B,MAAM,OAAO,GAAsB,EAAE,SAAS,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;QAC5E,MAAM,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,CAAC;QAC1E,OAAO,IAAI,CAAC;IACd,CAAC;IAED,kDAAkD;IAClD,IAAI,KAAK;QACP,MAAM,SAAS,GAAG,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC;QACrD,IAAI,IAAI,CAAC,WAAW;YAAE,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAC1D,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,qCAAqC;IACrC,IAAI,QAAQ;;QACV,OAAO,MAAA,MAAA,IAAI,CAAC,QAAQ,0CAAE,WAAW,EAAE,mCAAI,IAAI,CAAC;IAC9C,CAAC;IAED,2CAA2C;IAC3C,IAAI,QAAQ;;QACV,OAAO,MAAA,MAAA,IAAI,CAAC,QAAQ,0CAAE,QAAQ,EAAE,mCAAI,KAAK,CAAC;IAC5C,CAAC;IAED,kDAAkD;IAClD,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IAED,iCAAiC;IACjC,EAAE,CACA,KAAQ,EACR,QAAmC;QAElC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAoC,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IAC1E,CAAC;IAED,+BAA+B;IAC/B,GAAG,CACD,KAAQ,EACR,QAAmC;QAElC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAoC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IAC7E,CAAC;IAED,qDAAqD;IACrD,KAAK;;QACH,MAAA,IAAI,CAAC,QAAQ,0CAAE,OAAO,EAAE,CAAC;QACzB,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC;QACjD,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,eAAe,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC;QAC1D,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,kBAAkB,EAAE,IAAI,CAAC,kBAAkB,CAAC,CAAC;QAChE,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,SAAS,EAAE,IAAI,CAAC,kBAAkB,CAAC,CAAC;QACvD,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,OAAO,EAAE,IAAI,CAAC,gBAAgB,CAAC,CAAC;QACnD,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC;IACzB,CAAC;IAuED,mCAAmC;IAE3B,oBAAoB,CAAC,GAA0B;;QACrD,QAAQ,GAAG,CAAC,SAAS,EAAE;YACrB,KAAK,SAAS,CAAC,CAAC;gBACd,+DAA+D;gBAC/D,IAAI,MAAA,IAAI,CAAC,QAAQ,0CAAE,QAAQ,EAAE,EAAE;oBAC7B,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;iBACpC;gBACD,MAAM;aACP;SACF;IACH,CAAC;IAkDO,KAAK,CAAC,qBAAqB,CACjC,GAA4B,EAC5B,QAAiB;QAEjB,IAAI,CAAC,IAAI,CAAC,WAAW;YAAE,OAAO;QAE9B,uCAAuC;QACvC,IAAI,GAAG,CAAC,SAAS,KAAK,IAAI,CAAC,WAAW;YAAE,OAAO;QAE/C,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE;YACtB,MAAM,IAAI,CAAC,WAAW,CAAC;SACxB;QACD,IAAI;YACF,MAAM,SAAS,GAAG,MAAM,IAAA,uBAAO,EAC7B,GAAG,CAAC,OAAO,EACX,IAAI,CAAC,YAAa,CAAC,UAAU,CAC9B,CAAC;YACF,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,CAAM,CAAC;YAClE,IAAI,CAAC,IAAI,CACP,SAAS,EACT;gBACE,IAAI,EAAE,SAAS;gBACf,MAAM,EAAE,GAAG,CAAC,MAAM;gBAClB,SAAS,EAAE,GAAG,CAAC,SAAS;gBACxB,IAAI;aACa,EACnB,QAAQ,CACT,CAAC;SACH;QAAC,OAAO,GAAG,EAAE;YACZ,0EAA0E;SAC3E;IACH,CAAC;IAED,yBAAyB;IAEjB,KAAK,CAAC,gBAAgB;QAC5B,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE;YACtB,MAAM,IAAI,CAAC,WAAW,CAAC;SACxB;QACD,IAAI,CAAC,IAAI,CAAC,WAAW,IAAI,CAAC,IAAI,CAAC,YAAY,IAAI,CAAC,IAAI,CAAC,QAAQ;YAAE,OAAO;QAEtE,mCAAmC;QACnC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,WAAW,EAAE,EAAE;YAC7D,MAAM,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE;gBAClC,MAAM,QAAQ,GAAG,CAAC,QAAuB,EAAE,EAAE;oBAC3C,IAAI,QAAQ,EAAE;wBACZ,IAAI,CAAC,GAAG,CAAC,eAAe,EAAE,QAAQ,CAAC,CAAC;wBACpC,OAAO,EAAE,CAAC;qBACX;gBACH,CAAC,CAAC;gBACF,IAAI,CAAC,EAAE,CAAC,eAAe,EAAE,QAAQ,CAAC,CAAC;YACrC,CAAC,CAAC,CAAC;SACJ;QAED,IAAI,CAAC,IAAI,CAAC,QAAQ;YAAE,OAAO;QAE3B,MAAM,YAAY,GAA0B;YAC1C,SAAS,EAAE,WAAW;YACtB,MAAM,EAAE,IAAI,CAAC,WAAW;YACxB,GAAG,EAAE,IAAI,CAAC,YAAY,CAAC,YAAY;SACpC,CAAC;QAEF,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,EAAE;YAC5B,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;SACrC;aAAM;YACL,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC;YAC7C,IAAI,CAAC,QAAQ;gBAAE,OAAO;YACtB,MAAM,OAAO,GAAsB;gBACjC,SAAS,EAAE,SAAS;gBACpB,OAAO,EAAE,YAAY;aACtB,CAAC;YACF,IAAI,CAAC,SAAS;iBACX,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;iBACpD,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;SACpB;IACH,CAAC;IAEO,KAAK,CAAC,mBAAmB,CAAC,MAAc;QAC9C,MAAM,QAAQ,GAAG,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACjD,IAAI,QAAQ;YAAE,OAAO,QAAQ,CAAC;QAE9B,6CAA6C;QAC7C,OAAO,IAAI,OAAO,CAAY,CAAC,OAAO,EAAE,EAAE;YACxC,IAAI,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;YACjD,IAAI,CAAC,OAAO,EAAE;gBACZ,OAAO,GAAG,EAAE,CAAC;gBACb,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;aAC7C;YACD,OAAO,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC;QACpD,CAAC,CAAC,CAAC;IACL,CAAC;IAED,kBAAkB;IAEV,WAAW,CACjB,OAA2B,EAC3B,OAAgB;QAEhB,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC;IAC9B,CAAC;IAEO,IAAI,CACV,KAAQ,EACR,GAAG,IAA2C;QAE9C,KAAK,MAAM,QAAQ,IAAI,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE;YAC3C,QAAkE,CACjE,GAAG,IAAI,CACR,CAAC;SACH;IACH,CAAC;CACF;AA/YD,sCA+YC"}

package/build/main/mesh/types.d.ts

@@ -0,0 +1,58 @@
+import { EncryptedPayload } from '../crypto/CryptoService';
+export interface PublicMessage<T = unknown> {
+    type: 'public';
+    sender: string;
+    data: T;
+}
+export interface PrivateMessage<T = unknown> {
+    type: 'private';
+    sender: string;
+    recipient: string;
+    data: T;
+}
+export type MeshMessage<T = unknown> = PublicMessage<T> | PrivateMessage<T>;
+/** Broadcast of a peer's RSA public key */
+export interface PublicKeyAnnouncement {
+    _meshType: 'publicKey';
+    peerId: string;
+    jwk: JsonWebKey;
+}
+/** An encrypted private message (the Raft log entry payload for private messages) */
+export interface EncryptedPrivateMessage {
+    _meshType: 'encrypted';
+    sender: string;
+    recipient: string;
+    payload: EncryptedPayload;
+}
+/** A public message log entry */
+export interface PublicMessageEntry<T = unknown> {
+    _meshType: 'public';
+    sender: string;
+    data: T;
+}
+/** Union of all Raft log command types */
+export type MeshLogCommand<T = unknown> = PublicMessageEntry<T> | EncryptedPrivateMessage | PublicKeyAnnouncement;
+/** A proposal forwarded from a non-leader to the leader */
+export interface ProposeMessage<T = unknown> {
+    _meshType: 'propose';
+    command: MeshLogCommand<T>;
+}
+/** Internal transport-level messages (not replicated via Raft) */
+export type MeshControlMessage<T = unknown> = ProposeMessage<T>;
+/** Wrapper to distinguish Raft messages from mesh control messages on the wire */
+export interface WireMessage {
+    channel: 'raft' | 'control';
+    payload: unknown;
+}
+export interface DandelionMeshEvents<T = unknown> {
+    /** Local peer is ready */
+    ready: (localPeerId: string) => void;
+    /** A message was committed and delivered */
+    message: (message: MeshMessage<T>, replay: boolean) => void;
+    /** The set of connected peer IDs changed */
+    peersChanged: (peers: string[]) => void;
+    /** The cluster leader changed */
+    leaderChanged: (leaderId: string | null) => void;
+    /** An error occurred */
+    error: (error: Error) => void;
+}

package/build/main/mesh/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbWVzaC90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/build/main/raft/RaftNode.d.ts

@@ -0,0 +1,87 @@
+import { RaftLog } from './log/RaftLog';
+import { RaftMessage, RaftNodeEvents, RaftRole } from './types';
+export interface RaftNodeOptions {
+    /** Minimum election timeout in ms (default 2000) */
+    electionTimeoutMin?: number;
+    /** Maximum election timeout in ms (default 4000) */
+    electionTimeoutMax?: number;
+    /** Heartbeat interval in ms (default 400) */
+    heartbeatInterval?: number;
+}
+/**
+ * Core Raft consensus node.
+ *
+ * This class implements the Raft algorithm for leader election and log
+ * replication. It is transport-agnostic — the caller must wire up
+ * `sendMessage` to deliver RPCs, and call `handleMessage` when RPCs arrive.
+ *
+ * Log indices are 1-based per the Raft paper.
+ */
+export declare class RaftNode<T = unknown> {
+    readonly id: string;
+    private role;
+    private currentTerm;
+    private votedFor;
+    private leaderId;
+    private commitIndex;
+    private lastApplied;
+    private nextIndex;
+    private matchIndex;
+    private electionTimer;
+    private heartbeatTimer;
+    private readonly electionTimeoutMin;
+    private readonly electionTimeoutMax;
+    private readonly heartbeatInterval;
+    private peers;
+    private votesReceived;
+    private readonly log;
+    /** Called by the node to send an RPC to a peer — must be wired up externally */
+    sendMessage: (toPeerId: string, message: RaftMessage<T>) => void;
+    private readonly eventListeners;
+    private destroyed;
+    constructor(id: string, log: RaftLog<T>, options?: RaftNodeOptions);
+    /** Start the node (begin election timer as follower) */
+    start(peerIds: string[]): void;
+    /** Update the cluster membership dynamically (e.g. when peers join/leave) */
+    updatePeers(peerIds: string[]): void;
+    /** Submit a command to be replicated. Only succeeds on the leader. */
+    propose(command: T): boolean;
+    /** Handle an incoming Raft RPC message from a peer */
+    handleMessage(fromPeerId: string, message: RaftMessage<T>): void;
+    /** Get current role */
+    getRole(): RaftRole;
+    /** Get current term */
+    getCurrentTerm(): number;
+    /** Get the current leader ID (null if unknown) */
+    getLeaderId(): string | null;
+    /** Get the commit index */
+    getCommitIndex(): number;
+    /** Check if this node is the leader */
+    isLeader(): boolean;
+    /** Register an event listener */
+    on<E extends keyof RaftNodeEvents<T>>(event: E, listener: RaftNodeEvents<T>[E]): void;
+    /** Remove an event listener */
+    off<E extends keyof RaftNodeEvents<T>>(event: E, listener: RaftNodeEvents<T>[E]): void;
+    /** Stop all timers and clean up */
+    destroy(): void;
+    private becomeFollower;
+    private becomeCandidate;
+    private becomeLeader;
+    private handleRequestVote;
+    private handleRequestVoteResult;
+    /** Check if a candidate's log is at least as up-to-date as ours */
+    private isLogUpToDate;
+    private handleAppendEntries;
+    private handleAppendEntriesResult;
+    private sendAppendEntriesToAll;
+    private sendAppendEntriesTo;
+    /** Advance commitIndex if a majority of matchIndex values allow it */
+    private advanceCommitIndex;
+    /** Apply all committed but not-yet-applied entries */
+    private applyCommitted;
+    private resetElectionTimer;
+    private clearElectionTimer;
+    private clearHeartbeatTimer;
+    private persistState;
+    private emit;
+}