@epfml/discojs 2.1.1 → 2.1.2-p20240506085037.0

package/dist/client/decentralized/peer.js

@@ -0,0 +1,189 @@
+import { List, Map, Range, Seq } from 'immutable';
+import wrtc from 'isomorphic-wrtc';
+import SimplePeer from 'simple-peer';
+// message id + (chunk counter == 0) + chunk count
+const FIRST_HEADER_SIZE = 2 + 1 + 1;
+// message id + chunk counter
+const HEADER_SIZE = 2 + 1;
+// at which interval to poll
+const TICK = 10;
+// Peer wraps a SimplePeer, adding message fragmentation
+//
+// WebRTC implementations have various maximum message size
+// but with huge models, our messages might be bigger.
+// We split messages by chunks and reconstruct these
+// on the other side.
+//
+// As the WebRTC's DataChannel is not a stream, we need
+// reorder messages, so we use a header on each chunk
+// with a message id and chunk counter. The first chunk
+// (chunk counter == 0), also add the total number of chunk.
+//
+// see feross/simple-peer#393 for more info
+export class Peer {
+    id;
+    peer;
+    bufferSize;
+    sendCounter = 0;
+    sendQueue = List();
+    receiving = Map();
+    constructor(id, initiator = false) {
+        this.id = id;
+        this.peer = new SimplePeer({ wrtc, initiator });
+    }
+    send(msg) {
+        const chunks = this.chunk(msg);
+        this.sendQueue = this.sendQueue.concat(chunks);
+        this.flush();
+    }
+    flush() {
+        if (this.bufferSize === undefined) {
+            throw new Error('flush without known buffer size');
+        }
+        const chunk = this.sendQueue.first();
+        if (chunk === undefined) {
+            return; // nothing to flush
+        }
+        const remainingBufferSize = this.bufferSize - this.peer.bufferSize;
+        if (chunk.length > remainingBufferSize) {
+            setTimeout(() => { this.flush(); }, TICK);
+            return;
+        }
+        this.sendQueue = this.sendQueue.shift();
+        this.peer.send(chunk);
+        // and loop
+        this.flush();
+    }
+    get maxChunkSize() {
+        if (this.bufferSize === undefined) {
+            throw new Error('chunk without known buffer size');
+        }
+        // in the perfect world of bug-free implementations
+        // we would return this.bufferSize
+        // sadly, we are not there yet
+        //
+        // based on MDN, taking 16K seems to be a pretty safe
+        // and widely supported buffer size
+        return 16 * (1 << 10);
+    }
+    chunk(b) {
+        const messageID = this.sendCounter;
+        this.sendCounter++;
+        if (this.sendCounter > 0xFFFF) {
+            throw new Error('too much messages sent to this peer');
+        }
+        // special case as Range(1, 0) yields a value
+        let tail = Seq.Indexed([]);
+        if (b.length > this.maxChunkSize) {
+            tail = Range(this.maxChunkSize - FIRST_HEADER_SIZE, b.length, this.maxChunkSize - HEADER_SIZE).map((offset) => b.subarray(offset, offset + this.maxChunkSize - HEADER_SIZE));
+        }
+        const totalChunkCount = 1 + tail.count();
+        if (totalChunkCount > 0xFF) {
+            throw new Error('too big message to even chunk it');
+        }
+        const firstChunk = Buffer.alloc((b.length > this.maxChunkSize - FIRST_HEADER_SIZE)
+            ? this.maxChunkSize
+            : FIRST_HEADER_SIZE + b.length);
+        firstChunk.writeUint16BE(messageID);
+        firstChunk.writeUint8(0, 2);
+        firstChunk.writeUint8(totalChunkCount, 3);
+        b.copy(firstChunk, FIRST_HEADER_SIZE, 0, this.maxChunkSize - FIRST_HEADER_SIZE);
+        return Seq.Indexed([firstChunk])
+            .concat(Range(1).zip(tail)
+            .map(([id, raw]) => {
+            const chunk = Buffer.alloc(HEADER_SIZE + raw.length);
+            chunk.writeUint16BE(messageID);
+            chunk.writeUint8(id, 2);
+            raw.copy(chunk, HEADER_SIZE, 0);
+            return chunk;
+        }));
+    }
+    async destroy() {
+        return new Promise((resolve, reject) => {
+            this.peer.once('error', reject);
+            this.peer.once('close', resolve);
+            this.peer.destroy();
+        });
+    }
+    signal(signal) {
+        // extract max buffer size
+        if (signal.type === 'offer' || signal.type === 'answer') {
+            if (signal.sdp === undefined) {
+                throw new Error('signal answer|offer without session description');
+            }
+            if (this.bufferSize !== undefined) {
+                throw new Error('buffer size set twice');
+            }
+            const match = signal.sdp.match(/a=max-message-size:(\d+)/);
+            if (match === null) {
+                // TODO default value instead?
+                throw new Error('no max-message-size found in signal');
+            }
+            const max = parseInt(match[1], 10);
+            if (isNaN(max)) {
+                throw new Error(`unable to parse max-message-size as int: ${match[1]}`);
+            }
+            this.bufferSize = max;
+        }
+        this.peer.signal(signal);
+    }
+    on(event, listener) {
+        if (event !== 'data') {
+            this.peer.on(event, listener);
+            return;
+        }
+        // gotta help typescript here
+        const dataListener = listener;
+        this.peer.on('data', (data) => {
+            if (!Buffer.isBuffer(data) || data.length < HEADER_SIZE) {
+                throw new Error('received invalid message type');
+            }
+            const messageID = data.readUint16BE();
+            const chunkID = data.readUint8(2);
+            const received = this.receiving.get(messageID, {
+                total: undefined,
+                chunks: Map()
+            });
+            let total = received.total;
+            const chunks = received.chunks;
+            if (chunks.has(chunkID)) {
+                throw new Error(`chunk ${messageID}:${chunkID} already received`);
+            }
+            let chunk;
+            if (chunkID !== 0) {
+                chunk = Buffer.alloc(data.length - HEADER_SIZE);
+                data.copy(chunk, 0, HEADER_SIZE);
+            }
+            else {
+                if (data.length < FIRST_HEADER_SIZE) {
+                    throw new Error('received invalid message type');
+                }
+                if (total !== undefined) {
+                    throw new Error('first header received twice');
+                }
+                const readTotal = data.readUint8(3);
+                total = readTotal;
+                chunk = Buffer.alloc(data.length - FIRST_HEADER_SIZE);
+                data.copy(chunk, 0, FIRST_HEADER_SIZE);
+                if (chunks.keySeq().some((id) => id > readTotal)) {
+                    throw new Error('received total of chunk but got now-out-of-bound chunks');
+                }
+            }
+            this.receiving = this.receiving.set(messageID, {
+                total,
+                chunks: chunks.set(chunkID, chunk)
+            });
+            const readyMessages = this.receiving
+                .filter(({ total, chunks }) => total !== undefined && chunks.size === total)
+                .sort()
+                .map(({ chunks }) => chunks.entrySeq().toList().sortBy(([id, _]) => id))
+                .map((chunks) => Buffer.concat(chunks.map(([_, b]) => b).toArray()));
+            this.receiving = this.receiving.deleteAll(readyMessages.keys());
+            readyMessages
+                .forEach((message) => {
+                // TODO debug
+                dataListener(message);
+            });
+        });
+    }
+}

package/dist/client/decentralized/peer_pool.d.ts

@@ -0,0 +1,12 @@
+import { Map, type Set } from 'immutable';
+import { type SignalData } from './peer.js';
+import { type NodeID } from '../types.js';
+import { PeerConnection, type EventConnection } from '../event_connection.js';
+export declare class PeerPool {
+    private readonly id;
+    private peers;
+    constructor(id: NodeID);
+    shutdown(): Promise<void>;
+    signal(peerId: NodeID, signal: SignalData): void;
+    getPeers(peersToConnect: Set<NodeID>, signallingServer: EventConnection, clientHandle: (connections: Map<NodeID, PeerConnection>) => void): Promise<Map<NodeID, PeerConnection>>;
+}

package/dist/client/decentralized/peer_pool.js

@@ -0,0 +1,44 @@
+import { Map } from 'immutable';
+import { Peer } from './peer.js';
+import { PeerConnection } from '../event_connection.js';
+// TODO cleanup old peers
+export class PeerPool {
+    id;
+    peers = Map();
+    constructor(id) {
+        this.id = id;
+    }
+    async shutdown() {
+        console.info(`[${this.id}] shutdown their peers`);
+        await Promise.all(this.peers.valueSeq().map((peer) => peer.disconnect()));
+        this.peers = Map();
+    }
+    signal(peerId, signal) {
+        console.info(`[${this.id}] signals for`, peerId);
+        const peer = this.peers.get(peerId);
+        if (peer === undefined) {
+            throw new Error(`received signal for unknown peer: ${peerId}`);
+        }
+        peer.signal(signal);
+    }
+    async getPeers(peersToConnect, signallingServer, 
+    // TODO as event?
+    clientHandle) {
+        if (peersToConnect.contains(this.id)) {
+            throw new Error('peers to connect contains our id');
+        }
+        console.info(`[${this.id}] is connecting peers:`, peersToConnect.toJS());
+        const newPeers = Map(peersToConnect
+            .filter((id) => !this.peers.has(id))
+            .map((id) => [id, new Peer(id, id < this.id)]));
+        console.info(`[${this.id}] asked to connect new peers:`, newPeers.keySeq().toJS());
+        const newPeersConnections = newPeers.map((peer) => new PeerConnection(this.id, peer, signallingServer));
+        // adding peers to pool before connecting them because they must be set to call signal on them
+        this.peers = this.peers.merge(newPeersConnections);
+        clientHandle(this.peers);
+        await Promise.all(newPeersConnections.valueSeq().map((conn) => conn.connect()));
+        console.info(`[${this.id}] knowns connected peers:`, this.peers.keySeq().toJS());
+        return this.peers
+            .filter((_, id) => peersToConnect.has(id));
+    }
+}

package/dist/client/event_connection.d.ts

@@ -0,0 +1,34 @@
+import type { Peer, SignalData } from './decentralized/peer.js';
+import { type NodeID } from './types.js';
+import { type, type NarrowMessage, type Message } from './messages.js';
+import { EventEmitter } from '../utils/event_emitter.js';
+export interface EventConnection {
+    on: <K extends type>(type: K, handler: (event: NarrowMessage<K>) => void) => void;
+    once: <K extends type>(type: K, handler: (event: NarrowMessage<K>) => void) => void;
+    send: <T extends Message>(msg: T) => void;
+    disconnect: () => Promise<void>;
+}
+export declare function waitMessage<T extends type>(connection: EventConnection, type: T): Promise<NarrowMessage<T>>;
+export declare function waitMessageWithTimeout<T extends type>(connection: EventConnection, type: T, timeoutMs?: number): Promise<NarrowMessage<T>>;
+export declare class PeerConnection extends EventEmitter<{
+    [K in type]: NarrowMessage<K>;
+}> implements EventConnection {
+    private readonly _ownId;
+    private readonly peer;
+    private readonly signallingServer;
+    constructor(_ownId: NodeID, peer: Peer, signallingServer: EventConnection);
+    connect(): Promise<void>;
+    signal(signal: SignalData): void;
+    send<T extends Message>(msg: T): void;
+    disconnect(): Promise<void>;
+}
+export declare class WebSocketServer extends EventEmitter<{
+    [K in type]: NarrowMessage<K>;
+}> implements EventConnection {
+    private readonly socket;
+    private readonly validateSent?;
+    private constructor();
+    static connect(url: URL, validateReceived: (msg: unknown) => msg is Message, validateSent: (msg: Message) => boolean): Promise<WebSocketServer>;
+    disconnect(): Promise<void>;
+    send(msg: Message): void;
+}

package/dist/client/event_connection.js

@@ -0,0 +1,105 @@
+import WebSocket from 'isomorphic-ws';
+import msgpack from 'msgpack-lite';
+import * as decentralizedMessages from './decentralized/messages.js';
+import { type } from './messages.js';
+import { timeout } from './utils.js';
+import { EventEmitter } from '../utils/event_emitter.js';
+export async function waitMessage(connection, type) {
+    return await new Promise((resolve) => {
+        // "once" is important because we can't resolve the same promise multiple times
+        connection.once(type, (event) => {
+            resolve(event);
+        });
+    });
+}
+export async function waitMessageWithTimeout(connection, type, timeoutMs) {
+    return await Promise.race([waitMessage(connection, type), timeout(timeoutMs)]);
+}
+export class PeerConnection extends EventEmitter {
+    _ownId;
+    peer;
+    signallingServer;
+    constructor(_ownId, peer, signallingServer) {
+        super();
+        this._ownId = _ownId;
+        this.peer = peer;
+        this.signallingServer = signallingServer;
+    }
+    async connect() {
+        this.peer.on('signal', (signal) => {
+            const msg = {
+                type: type.SignalForPeer,
+                peer: this.peer.id,
+                signal
+            };
+            this.signallingServer.send(msg);
+        });
+        this.peer.on('data', (data) => {
+            const msg = msgpack.decode(data);
+            if (!decentralizedMessages.isPeerMessage(msg)) {
+                throw new Error(`invalid message received: ${JSON.stringify(msg)}`);
+            }
+            this.emit(msg.type, msg);
+        });
+        this.peer.on('close', () => { console.warn('peer', this.peer.id, 'closed connection'); });
+        await new Promise((resolve) => {
+            this.peer.on('connect', resolve);
+        });
+    }
+    signal(signal) {
+        this.peer.signal(signal);
+    }
+    send(msg) {
+        if (!decentralizedMessages.isPeerMessage(msg)) {
+            throw new Error(`can't send this type of message: ${JSON.stringify(msg)}`);
+        }
+        this.peer.send(msgpack.encode(msg));
+    }
+    async disconnect() {
+        await this.peer.destroy();
+    }
+}
+export class WebSocketServer extends EventEmitter {
+    socket;
+    validateSent;
+    constructor(socket, validateSent) {
+        super();
+        this.socket = socket;
+        this.validateSent = validateSent;
+    }
+    static async connect(url, validateReceived, validateSent) {
+        const ws = new WebSocket(url);
+        ws.binaryType = 'arraybuffer';
+        const server = new WebSocketServer(ws, validateSent);
+        ws.onmessage = (event) => {
+            if (!(event.data instanceof ArrayBuffer)) {
+                throw new Error('server did not send an ArrayBuffer');
+            }
+            const msg = msgpack.decode(new Uint8Array(event.data));
+            // Validate message format
+            if (!validateReceived(msg)) {
+                throw new Error(`invalid message received: ${JSON.stringify(msg)}`);
+            }
+            server.emit(msg.type, msg);
+        };
+        return await new Promise((resolve, reject) => {
+            ws.onerror = (err) => {
+                reject(new Error(`Server unreachable: ${err.message}`));
+            };
+            ws.onopen = () => { resolve(server); };
+        });
+    }
+    disconnect() {
+        return new Promise((resolve, reject) => {
+            this.socket.once('close', resolve);
+            this.socket.once('error', reject);
+            this.socket.close();
+        });
+    }
+    send(msg) {
+        if (this.validateSent !== undefined && !this.validateSent(msg)) {
+            throw new Error(`can't send this type of message: ${JSON.stringify(msg)}`);
+        }
+        this.socket.send(msgpack.encode(msg));
+    }
+}

package/dist/client/federated/base.d.ts

@@ -0,0 +1,54 @@
+import { Map } from "immutable";
+import { type MetadataKey, type MetadataValue, type WeightsContainer } from "../../index.js";
+import { type NodeID } from "../types.js";
+import { Base as Client } from "../base.js";
+/**
+ * Client class that communicates with a centralized, federated server, when training
+ * a specific task in the federated setting.
+ */
+export declare class Base extends Client {
+    /**
+     * Arbitrary node id assigned to the federated server which we are communicating with.
+     * Indeed, the server acts as a node within the network. In the federated setting described
+     * by this client class, the server is the only node which we are communicating with.
+     */
+    static readonly SERVER_NODE_ID = "federated-server-node-id";
+    /**
+     * Map of metadata values for each node id.
+     */
+    private metadataMap?;
+    /**
+     * Opens a new WebSocket connection with the server and listens to new messages over the channel
+     */
+    private connectServer;
+    /**
+     * Initializes the connection to the server and get our own node id.
+     * TODO: In the federated setting, should return the current server-side round
+     * for the task.
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnection process when user quits the task.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Send a message containing our local weight updates to the federated server.
+     * And waits for the server to reply with the most recent aggregated weights
+     * @param payload The weight updates to send
+     */
+    private sendPayloadAndReceiveResult;
+    /**
+     * Waits for the server's result for its current (most recent) round and add it to our aggregator.
+     * Updates the aggregator's round if it's behind the server's.
+     */
+    private receiveResult;
+    /**
+     * Fetch the metadata values maintained by the federated server, for a given metadata key.
+     * The values are indexed by node id.
+     * @param key The metadata key
+     * @returns The map of node id to metadata value
+     */
+    receiveMetadataMap(key: MetadataKey): Promise<Map<NodeID, MetadataValue> | undefined>;
+    onRoundBeginCommunication(): Promise<void>;
+    onRoundEndCommunication(weights: WeightsContainer, round: number): Promise<void>;
+}

package/dist/client/federated/base.js

@@ -0,0 +1,151 @@
+import { Map } from "immutable";
+import { serialization, } from "../../index.js";
+import { Base as Client } from "../base.js";
+import { type } from "../messages.js";
+import { waitMessageWithTimeout, WebSocketServer, } from "../event_connection.js";
+import * as messages from "./messages.js";
+/**
+ * Client class that communicates with a centralized, federated server, when training
+ * a specific task in the federated setting.
+ */
+export class Base extends Client {
+    /**
+     * Arbitrary node id assigned to the federated server which we are communicating with.
+     * Indeed, the server acts as a node within the network. In the federated setting described
+     * by this client class, the server is the only node which we are communicating with.
+     */
+    static SERVER_NODE_ID = "federated-server-node-id";
+    /**
+     * Map of metadata values for each node id.
+     */
+    metadataMap;
+    /**
+     * Opens a new WebSocket connection with the server and listens to new messages over the channel
+     */
+    async connectServer(url) {
+        const server = await WebSocketServer.connect(url, messages.isMessageFederated, messages.isMessageFederated);
+        return server;
+    }
+    /**
+     * Initializes the connection to the server and get our own node id.
+     * TODO: In the federated setting, should return the current server-side round
+     * for the task.
+     */
+    async connect() {
+        const serverURL = new URL("", this.url.href);
+        switch (this.url.protocol) {
+            case "http:":
+                serverURL.protocol = "ws:";
+                break;
+            case "https:":
+                serverURL.protocol = "wss:";
+                break;
+            default:
+                throw new Error(`unknown protocol: ${this.url.protocol}`);
+        }
+        serverURL.pathname += `feai/${this.task.id}`;
+        this._server = await this.connectServer(serverURL);
+        this.aggregator.registerNode(Base.SERVER_NODE_ID);
+        const msg = {
+            type: type.ClientConnected,
+        };
+        this.server.send(msg);
+        const received = await waitMessageWithTimeout(this.server, type.AssignNodeID);
+        console.info(`[${received.id}] assign id generated by the server`);
+        this._ownId = received.id;
+    }
+    /**
+     * Disconnection process when user quits the task.
+     */
+    async disconnect() {
+        await this.server.disconnect();
+        this._server = undefined;
+        this._ownId = undefined;
+        this.aggregator.setNodes(this.aggregator.nodes.delete(Base.SERVER_NODE_ID));
+        return Promise.resolve();
+    }
+    /**
+     * Send a message containing our local weight updates to the federated server.
+     * And waits for the server to reply with the most recent aggregated weights
+     * @param payload The weight updates to send
+     */
+    async sendPayloadAndReceiveResult(payload) {
+        const msg = {
+            type: type.SendPayload,
+            payload: await serialization.weights.encode(payload),
+            round: this.aggregator.round,
+        };
+        this.server.send(msg);
+        // It is important than the client immediately awaits the server result or it may miss it
+        return await this.receiveResult();
+    }
+    /**
+     * Waits for the server's result for its current (most recent) round and add it to our aggregator.
+     * Updates the aggregator's round if it's behind the server's.
+     */
+    async receiveResult() {
+        try {
+            const { payload, round } = await waitMessageWithTimeout(this.server, type.ReceiveServerPayload);
+            const serverRound = round;
+            // Store the server result only if it is not stale
+            if (this.aggregator.round <= round) {
+                const serverResult = serialization.weights.decode(payload);
+                // Update the local round to match the server's
+                if (this.aggregator.round < serverRound) {
+                    this.aggregator.setRound(serverRound);
+                }
+                return serverResult;
+            }
+        }
+        catch (e) {
+            console.error(e);
+        }
+    }
+    /**
+     * Fetch the metadata values maintained by the federated server, for a given metadata key.
+     * The values are indexed by node id.
+     * @param key The metadata key
+     * @returns The map of node id to metadata value
+     */
+    async receiveMetadataMap(key) {
+        this.metadataMap = undefined;
+        const msg = {
+            type: type.ReceiveServerMetadata,
+            taskId: this.task.id,
+            nodeId: this.ownId,
+            round: this.aggregator.round,
+            key,
+        };
+        this.server.send(msg);
+        const received = await waitMessageWithTimeout(this.server, type.ReceiveServerMetadata);
+        if (received.metadataMap !== undefined) {
+            this.metadataMap = Map(received.metadataMap.filter(([_, v]) => v !== undefined));
+        }
+        return this.metadataMap;
+    }
+    onRoundBeginCommunication() {
+        // Prepare the result promise for the incoming round
+        this.aggregationResult = this.aggregator.receiveResult();
+        return Promise.resolve();
+    }
+    async onRoundEndCommunication(weights, round) {
+        // NB: For now, we suppose a fully-federated setting.
+        if (this.aggregationResult === undefined) {
+            throw new Error("local aggregation result was not set");
+        }
+        // Send our local contribution to the server
+        // and receive the most recent weights as an answer to our contribution
+        const serverResult = await this.sendPayloadAndReceiveResult(this.aggregator.makePayloads(weights).first());
+        if (serverResult !== undefined &&
+            this.aggregator.add(Base.SERVER_NODE_ID, serverResult, round, 0)) {
+            // Regular case: the server sends us its aggregation result which will serve our
+            // own aggregation result.
+        }
+        else {
+            // Unexpected case: for some reason, the server result is stale.
+            // We proceed to the next round without its result.
+            console.info(`[${this.ownId}] Server result is either stale or not received`);
+            this.aggregator.nextRound();
+        }
+    }
+}

package/dist/client/federated/index.d.ts

@@ -0,0 +1,2 @@
+export { Base as FederatedClient } from './base.js';
+export * as messages from './messages.js';

package/dist/client/federated/index.js

@@ -0,0 +1,2 @@
+export { Base as FederatedClient } from './base.js';
+export * as messages from './messages.js';

package/dist/client/federated/messages.d.ts

@@ -0,0 +1,30 @@
+import { type client, type MetadataKey, type MetadataValue } from '../../index.js';
+import { type weights } from '../../serialization/index.js';
+import { type, type AssignNodeID, type ClientConnected } from '../messages.js';
+export type MessageFederated = ClientConnected | SendPayload | ReceiveServerPayload | RequestServerStatistics | ReceiveServerStatistics | ReceiveServerMetadata | AssignNodeID;
+export interface SendPayload {
+    type: type.SendPayload;
+    payload: weights.Encoded;
+    round: number;
+}
+export interface ReceiveServerPayload {
+    type: type.ReceiveServerPayload;
+    payload: weights.Encoded;
+    round: number;
+}
+export interface RequestServerStatistics {
+    type: type.RequestServerStatistics;
+}
+export interface ReceiveServerStatistics {
+    type: type.ReceiveServerStatistics;
+    statistics: Record<string, number>;
+}
+export interface ReceiveServerMetadata {
+    type: type.ReceiveServerMetadata;
+    nodeId: client.NodeID;
+    taskId: string;
+    round: number;
+    key: MetadataKey;
+    metadataMap?: Array<[client.NodeID, MetadataValue | undefined]>;
+}
+export declare function isMessageFederated(raw: unknown): raw is MessageFederated;

package/dist/client/federated/messages.js

@@ -0,0 +1,24 @@
+import { type, hasMessageType } from '../messages.js';
+export function isMessageFederated(raw) {
+    if (!hasMessageType(raw)) {
+        return false;
+    }
+    switch (raw.type) {
+        case type.ClientConnected:
+            return true;
+        case type.SendPayload:
+            return true;
+        case type.ReceiveServerPayload:
+            return true;
+        case type.RequestServerStatistics:
+            return true;
+        case type.ReceiveServerStatistics:
+            return true;
+        case type.ReceiveServerMetadata:
+            return true;
+        case type.AssignNodeID:
+            return true;
+        default:
+            return false;
+    }
+}

package/dist/client/index.d.ts

@@ -0,0 +1,8 @@
+export { Base as Client } from './base.js';
+export * from './types.js';
+export * as aggregator from '../aggregator/index.js';
+export * as decentralized from './decentralized/index.js';
+export * as federated from './federated/index.js';
+export * as messages from './messages.js';
+export * as utils from './utils.js';
+export { Local } from './local.js';

package/dist/client/index.js

@@ -0,0 +1,8 @@
+export { Base as Client } from './base.js';
+export * from './types.js';
+export * as aggregator from '../aggregator/index.js';
+export * as decentralized from './decentralized/index.js';
+export * as federated from './federated/index.js';
+export * as messages from './messages.js';
+export * as utils from './utils.js';
+export { Local } from './local.js';

package/dist/client/local.d.ts

@@ -0,0 +1,3 @@
+import { Base } from './base.js';
+export declare class Local extends Base {
+}