@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/cjs/cluster/ClusterTURN.d.ts

@@ -0,0 +1,63 @@
+import type { SignalingIceServer } from '../protocol/SignalingProtocol.js';
+import type { TURNServer, TURNServerLocation } from '../turn/TURNServer.js';
+import type { Cluster } from './Cluster.js';
+/**
+ * A TURN server of a node of a {@link Cluster}, as it tells the other nodes.
+ */
+export interface ClusterTURNServer extends TURNServerLocation {
+    /**
+     * The id of its node.
+     */
+    readonly node: string;
+    /**
+     * The labels of its node (a zone, a region).
+     */
+    readonly labels: Readonly<Record<string, string>>;
+    /**
+     * Its allocations in use.
+     */
+    readonly allocations: number;
+    /**
+     * Its allocations at most, if it has a limit.
+     */
+    readonly maxAllocations?: number;
+    /**
+     * How long its short-lived credentials are valid, in seconds.
+     */
+    readonly credentialTtl: number;
+}
+/**
+ * Chooses the TURN servers of the cluster given to a client (the `selectTURN` option of `Signaling` and `WHIP`).
+ * @param servers The TURN servers of the cluster.
+ * @param user The client: the member of the signaling, the stream of WHIP.
+ * @returns The servers given to it.
+ */
+export type TURNSelector = (servers: ClusterTURNServer[], user: string) => ClusterTURNServer[];
+/**
+ * The TURN servers the nodes of a cluster tell about
+ * @param cluster
+ */
+export declare function turnServersOf(cluster: Cluster): ClusterTURNServer[];
+/**
+ * The least loaded TURN servers that are not full, the servers equally loaded in a random order
+ * @param servers
+ */
+export declare function leastLoadedTURN(servers: ClusterTURNServer[]): ClusterTURNServer[];
+/**
+ * The ICE servers of a client: the ones of the TURN server of this node, then the ones of the TURN servers of the
+ * cluster chosen for it (with credentials of the secret shared by the TURN servers of the cluster, or else of the
+ * TURN server of this node), then the others given
+ * @param user The client.
+ * @param options The TURN server of this node, the cluster, the shared secret, how to choose, the other ICE servers.
+ * @returns The ICE servers, and how long their credentials are valid in seconds (0 without TURN).
+ */
+export declare function iceServersFor(user: string, options: {
+    turn?: TURNServer;
+    cluster?: Cluster;
+    secret?: string;
+    select?: TURNSelector;
+    iceServers: SignalingIceServer[];
+}): {
+    iceServers: SignalingIceServer[];
+    credentialTtl: number;
+};

package/dist/cjs/cluster/ClusterTURN.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.turnServersOf = turnServersOf;
+exports.leastLoadedTURN = leastLoadedTURN;
+exports.iceServersFor = iceServersFor;
+const TURNCredentials_js_1 = require("../turn/TURNCredentials.js");
+const TURNIceServers_js_1 = require("../turn/TURNIceServers.js");
+/**
+ * The TURN servers given to a client by default: the two least loaded that are not full
+ */
+const DEFAULT_COUNT = 2;
+/**
+ * The TURN servers the nodes of a cluster tell about
+ * @param cluster
+ */
+function turnServersOf(cluster) {
+    return cluster.nodes().flatMap((node) => {
+        const turn = node.services.turn;
+        if (!turn || typeof turn.address !== 'string' || typeof turn.port !== 'number')
+            return [];
+        return [{
+                node: node.id,
+                labels: node.labels,
+                address: turn.address,
+                port: turn.port,
+                udp: turn.udp === true,
+                tcp: turn.tcp === true,
+                ...typeof turn.tlsPort === 'number' ? { tlsPort: turn.tlsPort } : {},
+                allocations: typeof turn.allocations === 'number' ? turn.allocations : 0,
+                ...typeof turn.maxAllocations === 'number' ? { maxAllocations: turn.maxAllocations } : {},
+                credentialTtl: typeof turn.credentialTtl === 'number' ? turn.credentialTtl : 86400
+            }];
+    });
+}
+/**
+ * The least loaded TURN servers that are not full, the servers equally loaded in a random order
+ * @param servers
+ */
+function leastLoadedTURN(servers) {
+    const load = (server) => server.maxAllocations ? server.allocations / server.maxAllocations : server.allocations;
+    return servers
+        .filter((server) => server.maxAllocations === undefined || server.allocations < server.maxAllocations)
+        .map((server) => [server, Math.random()])
+        .sort(([x, xOrder], [y, yOrder]) => load(x) - load(y) || xOrder - yOrder)
+        .slice(0, DEFAULT_COUNT)
+        .map(([server]) => server);
+}
+/**
+ * The ICE servers of a client: the ones of the TURN server of this node, then the ones of the TURN servers of the
+ * cluster chosen for it (with credentials of the secret shared by the TURN servers of the cluster, or else of the
+ * TURN server of this node), then the others given
+ * @param user The client.
+ * @param options The TURN server of this node, the cluster, the shared secret, how to choose, the other ICE servers.
+ * @returns The ICE servers, and how long their credentials are valid in seconds (0 without TURN).
+ */
+function iceServersFor(user, options) {
+    const { turn, cluster, secret, select, iceServers } = options;
+    const servers = [];
+    const lifetimes = [];
+    if (turn) {
+        const credentials = turn.credentials(user);
+        servers.push(...(0, TURNIceServers_js_1.iceServersOfTURN)(turn.location, credentials));
+        lifetimes.push(credentials.ttl);
+    }
+    if (cluster && (secret || turn)) {
+        //The TURN server of this node is given already
+        const available = turnServersOf(cluster).filter((server) => !turn || server.node !== cluster.nodeId);
+        const chosen = available.length ? (select ?? leastLoadedTURN)(available, user) : [];
+        if (chosen.length) {
+            const ttl = Math.min(...chosen.map((server) => server.credentialTtl));
+            const credentials = secret ? (0, TURNCredentials_js_1.createTURNCredentials)(secret, user, ttl) : turn.credentials(user);
+            for (const server of chosen)
+                servers.push(...(0, TURNIceServers_js_1.iceServersOfTURN)(server, credentials));
+            lifetimes.push(credentials.ttl);
+        }
+    }
+    return { iceServers: [...servers, ...iceServers], credentialTtl: lifetimes.length ? Math.min(...lifetimes) : 0 };
+}

package/dist/cjs/cluster/Rendezvous.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The node responsible for a key among some nodes (rendezvous hashing): every node computes the same one, and only the
+ * keys of a node leaving or joining change hands
+ * @param key
+ * @param nodes The ids of the nodes.
+ * @returns The id of the node, undefined without nodes.
+ */
+export declare function rendezvous(key: string, nodes: readonly string[]): string | undefined;

package/dist/cjs/cluster/Rendezvous.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rendezvous = rendezvous;
+const node_crypto_1 = require("node:crypto");
+/**
+ * The node responsible for a key among some nodes (rendezvous hashing): every node computes the same one, and only the
+ * keys of a node leaving or joining change hands
+ * @param key
+ * @param nodes The ids of the nodes.
+ * @returns The id of the node, undefined without nodes.
+ */
+function rendezvous(key, nodes) {
+    let chosen;
+    let best = '';
+    for (const node of nodes) {
+        const score = (0, node_crypto_1.createHash)('sha1').update(key).update('\0').update(node).digest('hex');
+        if (score > best) {
+            best = score;
+            chosen = node;
+        }
+    }
+    return chosen;
+}

package/dist/cjs/cluster/transports/ClusterTransport.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The bus under a cluster: subjects that every subscriber receives the messages of, in the order of each publisher
+ */
+export interface ClusterTransport {
+    /**
+     * The size of a message at most, in bytes: the larger ones are sent in parts
+     */
+    readonly maxPayload: number;
+    /**
+     * Connect to the server
+     */
+    connect(): Promise<void>;
+    /**
+     * Publish a message, without waiting; one that cannot be sent is lost
+     * @param subject
+     * @param data
+     */
+    publish(subject: string, data: Uint8Array): void;
+    /**
+     * Receive the messages of a subject
+     * @param subject
+     * @param handler
+     */
+    subscribe(subject: string, handler: (data: Uint8Array) => void): Promise<void>;
+    /**
+     * Call a listener each time the connection comes back after it was lost (the messages meanwhile may be lost)
+     * @param listener
+     */
+    onReconnect(listener: () => void): void;
+    /**
+     * Close the connection, once the messages published are sent
+     */
+    close(): Promise<void>;
+}

package/dist/cjs/cluster/transports/ClusterTransport.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/cluster/transports/LoadClient.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Load the client package of a transport (an optional dependency)
+ * @param member A member of its API, to find it in the ESM namespace or the CommonJS exports.
+ * @param packageName The package.
+ */
+export declare function loadClient<T = any>(member: string, packageName: string): Promise<T>;

package/dist/cjs/cluster/transports/LoadClient.js

@@ -0,0 +1,80 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadClient = loadClient;
+const core_1 = require("@lakutata/core");
+const ClusterTransportNotFoundException_js_1 = require("../../exceptions/ClusterTransportNotFoundException.js");
+/**
+ * The client packages of the transports (optional dependencies), imported by their names written out: the bundlers
+ * follow them (a name given at run time is not bundled, the bundle has no node_modules to load it from)
+ */
+const CLIENTS = {
+    'ioredis': () => Promise.resolve().then(() => __importStar(require('ioredis'))),
+    'nats': () => Promise.resolve().then(() => __importStar(require('nats')))
+};
+/**
+ * Whether an error reports the package itself as missing
+ * @param error The error of the import.
+ * @param packageName The package imported.
+ */
+function isPackageMissing(error, packageName) {
+    const { code, message } = error;
+    if (code !== 'ERR_MODULE_NOT_FOUND' && code !== 'MODULE_NOT_FOUND')
+        return false;
+    return !!message && (message.includes(`'${packageName}'`) || message.includes(`"${packageName}"`));
+}
+/**
+ * Load the client package of a transport (an optional dependency)
+ * @param member A member of its API, to find it in the ESM namespace or the CommonJS exports.
+ * @param packageName The package.
+ */
+async function loadClient(member, packageName) {
+    let missing;
+    try {
+        const client = await CLIENTS[packageName]();
+        return (client[member] === undefined && client.default ? client.default : client);
+    }
+    catch (e) {
+        if (!isPackageMissing(e, packageName))
+            throw e;
+        missing = e;
+    }
+    //A bundled application has the packages installed when it was bundled
+    const exception = (0, core_1.isPackaged)() ?
+        new ClusterTransportNotFoundException_js_1.ClusterTransportNotFoundException('Package "{packageName}" is required for this transport of the cluster, and was not installed when the application was bundled: install it in the project, then bundle the application again.', { packageName: packageName }) :
+        new ClusterTransportNotFoundException_js_1.ClusterTransportNotFoundException('Package "{packageName}" is required for this transport of the cluster. Run "npm install {packageName}".', { packageName: packageName });
+    exception.cause = missing;
+    throw exception;
+}

package/dist/cjs/cluster/transports/MemoryClusterTransport.d.ts

@@ -0,0 +1,13 @@
+import type { ClusterTransport } from './ClusterTransport.js';
+/**
+ * The bus in the memory of the process: the clusters of the same prefix in one process (the applications of a test)
+ */
+export declare class MemoryClusterTransport implements ClusterTransport {
+    #private;
+    readonly maxPayload: number;
+    connect(): Promise<void>;
+    publish(subject: string, data: Uint8Array): void;
+    subscribe(subject: string, handler: (data: Uint8Array) => void): Promise<void>;
+    onReconnect(): void;
+    close(): Promise<void>;
+}

package/dist/cjs/cluster/transports/MemoryClusterTransport.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryClusterTransport = void 0;
+/**
+ * The subscribers of each subject in the process
+ */
+const subscribers = new Map();
+/**
+ * The bus in the memory of the process: the clusters of the same prefix in one process (the applications of a test)
+ */
+class MemoryClusterTransport {
+    constructor() {
+        this.maxPayload = Number.POSITIVE_INFINITY;
+        this.#subscriptions = [];
+        this.#closed = false;
+    }
+    #subscriptions;
+    #closed;
+    async connect() {
+        this.#closed = false;
+    }
+    publish(subject, data) {
+        if (this.#closed)
+            return;
+        const copy = Uint8Array.from(data);
+        //Delivered later, in the order published, as a server would
+        setImmediate(() => subscribers.get(subject)?.forEach((handler) => handler(copy)));
+    }
+    async subscribe(subject, handler) {
+        if (!subscribers.has(subject))
+            subscribers.set(subject, new Set());
+        subscribers.get(subject).add(handler);
+        this.#subscriptions.push([subject, handler]);
+    }
+    onReconnect() {
+        //Never lost
+    }
+    async close() {
+        this.#closed = true;
+        for (const [subject, handler] of this.#subscriptions.splice(0)) {
+            subscribers.get(subject)?.delete(handler);
+            if (!subscribers.get(subject)?.size)
+                subscribers.delete(subject);
+        }
+    }
+}
+exports.MemoryClusterTransport = MemoryClusterTransport;

package/dist/cjs/cluster/transports/NATSClusterTransport.d.ts

@@ -0,0 +1,23 @@
+import type { NatsConnection } from 'nats';
+import type { ClusterNATSTransportOptions } from '../Cluster.js';
+import type { ClusterTransport } from './ClusterTransport.js';
+/**
+ * The bus on a NATS server: its core subjects (no JetStream)
+ */
+export declare class NATSClusterTransport implements ClusterTransport {
+    #private;
+    protected readonly options: Omit<ClusterNATSTransportOptions, 'type'>;
+    maxPayload: number;
+    constructor(options: Omit<ClusterNATSTransportOptions, 'type'>);
+    connect(): Promise<void>;
+    publish(subject: string, data: Uint8Array): void;
+    subscribe(subject: string, handler: (data: Uint8Array) => void): Promise<void>;
+    onReconnect(listener: () => void): void;
+    close(): Promise<void>;
+    /**
+     * Tell the listeners when the connection comes back
+     * @param connection
+     * @protected
+     */
+    protected watch(connection: NatsConnection): Promise<void>;
+}

package/dist/cjs/cluster/transports/NATSClusterTransport.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NATSClusterTransport = void 0;
+const LoadClient_js_1 = require("./LoadClient.js");
+/**
+ * The bus on a NATS server: its core subjects (no JetStream)
+ */
+class NATSClusterTransport {
+    #reconnectListeners;
+    #connection;
+    constructor(options) {
+        this.options = options;
+        this.maxPayload = 1024 * 1024;
+        this.#reconnectListeners = [];
+    }
+    async connect() {
+        const nats = await (0, LoadClient_js_1.loadClient)('connect', 'nats');
+        this.#connection = await nats.connect({
+            servers: this.options.servers ?? '127.0.0.1:4222',
+            user: this.options.user,
+            pass: this.options.pass,
+            token: this.options.token,
+            name: this.options.name,
+            //A node of a cluster waits for its server as long as it runs
+            maxReconnectAttempts: -1
+        });
+        this.maxPayload = this.#connection.info?.max_payload ?? this.maxPayload;
+        void this.watch(this.#connection);
+    }
+    publish(subject, data) {
+        if (this.#connection.isClosed())
+            return;
+        try {
+            this.#connection.publish(subject, data);
+        }
+        catch {
+            //Lost, as when the server cannot be reached
+        }
+    }
+    async subscribe(subject, handler) {
+        this.#connection.subscribe(subject, {
+            callback: (error, message) => {
+                if (!error)
+                    handler(message.data);
+            }
+        });
+        await this.#connection.flush();
+    }
+    onReconnect(listener) {
+        this.#reconnectListeners.push(listener);
+    }
+    async close() {
+        if (!this.#connection || this.#connection.isClosed())
+            return;
+        await this.#connection.flush().catch(() => undefined);
+        await this.#connection.close();
+    }
+    /**
+     * Tell the listeners when the connection comes back
+     * @param connection
+     * @protected
+     */
+    async watch(connection) {
+        for await (const status of connection.status()) {
+            if (status.type === 'reconnect')
+                this.#reconnectListeners.forEach((listener) => listener());
+        }
+    }
+}
+exports.NATSClusterTransport = NATSClusterTransport;

package/dist/cjs/cluster/transports/RedisClusterTransport.d.ts

@@ -0,0 +1,23 @@
+import type { Redis } from 'ioredis';
+import type { ClusterRedisTransportOptions } from '../Cluster.js';
+import type { ClusterTransport } from './ClusterTransport.js';
+/**
+ * The bus on a Redis server: its channels (publish and subscribe), on two connections
+ */
+export declare class RedisClusterTransport implements ClusterTransport {
+    #private;
+    protected readonly options: Omit<ClusterRedisTransportOptions, 'type'>;
+    readonly maxPayload: number;
+    constructor(options: Omit<ClusterRedisTransportOptions, 'type'>);
+    connect(): Promise<void>;
+    publish(subject: string, data: Uint8Array): void;
+    subscribe(subject: string, handler: (data: Uint8Array) => void): Promise<void>;
+    onReconnect(listener: () => void): void;
+    close(): Promise<void>;
+    /**
+     * Connect a client, failing with the reason when the server cannot be reached; afterwards, it reconnects by itself
+     * @param client
+     * @protected
+     */
+    protected connected(client: Redis): Promise<void>;
+}

package/dist/cjs/cluster/transports/RedisClusterTransport.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisClusterTransport = void 0;
+const LoadClient_js_1 = require("./LoadClient.js");
+/**
+ * The bus on a Redis server: its channels (publish and subscribe), on two connections
+ */
+class RedisClusterTransport {
+    #handlers;
+    #reconnectListeners;
+    #publisher;
+    #subscriber;
+    constructor(options) {
+        this.options = options;
+        //Larger messages in parts: a subscriber whose output buffer grows past 32 MiB is disconnected by the server
+        this.maxPayload = 1024 * 1024;
+        this.#handlers = new Map();
+        this.#reconnectListeners = [];
+    }
+    async connect() {
+        const { Redis: Client } = await (0, LoadClient_js_1.loadClient)('Redis', 'ioredis');
+        const options = {
+            db: this.options.database,
+            username: this.options.username,
+            password: this.options.password,
+            //Connected below: a server unreachable when the component starts fails it
+            lazyConnect: true
+        };
+        const publisher = this.options.url
+            ? new Client(this.options.url, options)
+            : new Client({ ...options, host: this.options.host ?? '127.0.0.1', port: this.options.port ?? 6379, tls: this.options.tls ? {} : undefined });
+        await this.connected(publisher);
+        const subscriber = publisher.duplicate();
+        await this.connected(subscriber);
+        subscriber.on('messageBuffer', (channel, message) => this.#handlers.get(channel.toString())?.(message));
+        //Its first ready is the connection above; the next ones come after it was lost (the channels subscribed again)
+        subscriber.on('ready', () => this.#reconnectListeners.forEach((listener) => listener()));
+        this.#publisher = publisher;
+        this.#subscriber = subscriber;
+    }
+    publish(subject, data) {
+        this.#publisher.publish(subject, Buffer.from(data.buffer, data.byteOffset, data.byteLength)).catch(() => undefined);
+    }
+    async subscribe(subject, handler) {
+        this.#handlers.set(subject, handler);
+        await this.#subscriber.subscribe(subject);
+    }
+    onReconnect(listener) {
+        this.#reconnectListeners.push(listener);
+    }
+    async close() {
+        await Promise.allSettled([this.#subscriber, this.#publisher].filter((client) => !!client).map((client) => client.quit()));
+    }
+    /**
+     * Connect a client, failing with the reason when the server cannot be reached; afterwards, it reconnects by itself
+     * @param client
+     * @protected
+     */
+    async connected(client) {
+        let failure;
+        const remember = (error) => {
+            failure = error;
+        };
+        client.on('error', remember);
+        try {
+            await client.connect();
+        }
+        catch (error) {
+            client.disconnect();
+            //The error of the connection tells why (the rejection only that it is closed)
+            throw new Error(`The Redis server of the cluster cannot be reached: ${(failure ?? error).message}`, { cause: error });
+        }
+        client.off('error', remember);
+        client.on('error', () => undefined);
+    }
+}
+exports.RedisClusterTransport = RedisClusterTransport;

package/dist/cjs/exceptions/ClusterRequestException.d.ts

@@ -0,0 +1,11 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown by `Cluster.request()` when the request cannot be answered: the node is not in the cluster, it has no handler
+ * of the topic, or its handler failed. Its `errno` is `'E_CLUSTER_REQUEST'`.
+ */
+export declare class ClusterRequestException extends Exception {
+    /**
+     * `'E_CLUSTER_REQUEST'`.
+     */
+    errno: string | number;
+}

package/dist/cjs/exceptions/ClusterRequestException.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClusterRequestException = void 0;
+const core_1 = require("@lakutata/core");
+/**
+ * Thrown by `Cluster.request()` when the request cannot be answered: the node is not in the cluster, it has no handler
+ * of the topic, or its handler failed. Its `errno` is `'E_CLUSTER_REQUEST'`.
+ */
+class ClusterRequestException extends core_1.Exception {
+    constructor() {
+        super(...arguments);
+        /**
+         * `'E_CLUSTER_REQUEST'`.
+         */
+        this.errno = 'E_CLUSTER_REQUEST';
+    }
+}
+exports.ClusterRequestException = ClusterRequestException;

package/dist/cjs/exceptions/ClusterTimeoutException.d.ts

@@ -0,0 +1,10 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown by `Cluster.request()` when the node does not answer in time. Its `errno` is `'E_CLUSTER_TIMEOUT'`.
+ */
+export declare class ClusterTimeoutException extends Exception {
+    /**
+     * `'E_CLUSTER_TIMEOUT'`.
+     */
+    errno: string | number;
+}

package/dist/cjs/exceptions/ClusterTimeoutException.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClusterTimeoutException = void 0;
+const core_1 = require("@lakutata/core");
+/**
+ * Thrown by `Cluster.request()` when the node does not answer in time. Its `errno` is `'E_CLUSTER_TIMEOUT'`.
+ */
+class ClusterTimeoutException extends core_1.Exception {
+    constructor() {
+        super(...arguments);
+        /**
+         * `'E_CLUSTER_TIMEOUT'`.
+         */
+        this.errno = 'E_CLUSTER_TIMEOUT';
+    }
+}
+exports.ClusterTimeoutException = ClusterTimeoutException;

package/dist/cjs/exceptions/ClusterTransportNotFoundException.d.ts

@@ -0,0 +1,11 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown when the `Cluster` component starts with a transport whose client package is not installed (`nats` for NATS,
+ * `ioredis` for Redis). Its `errno` is `'E_CLUSTER_TRANSPORT_NOT_FOUND'`.
+ */
+export declare class ClusterTransportNotFoundException extends Exception {
+    /**
+     * `'E_CLUSTER_TRANSPORT_NOT_FOUND'`.
+     */
+    errno: string | number;
+}

package/dist/cjs/exceptions/ClusterTransportNotFoundException.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClusterTransportNotFoundException = void 0;
+const core_1 = require("@lakutata/core");
+/**
+ * Thrown when the `Cluster` component starts with a transport whose client package is not installed (`nats` for NATS,
+ * `ioredis` for Redis). Its `errno` is `'E_CLUSTER_TRANSPORT_NOT_FOUND'`.
+ */
+class ClusterTransportNotFoundException extends core_1.Exception {
+    constructor() {
+        super(...arguments);
+        /**
+         * `'E_CLUSTER_TRANSPORT_NOT_FOUND'`.
+         */
+        this.errno = 'E_CLUSTER_TRANSPORT_NOT_FOUND';
+    }
+}
+exports.ClusterTransportNotFoundException = ClusterTransportNotFoundException;

package/dist/cjs/exceptions/SignalingClientRequiredException.d.ts

@@ -0,0 +1,12 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown when a signaling request comes without a client id: the signaling pushes its events to the clients, so it
+ * needs a transport with clients (Socket.IO, JSON-RPC over WebSocket), not JSON-RPC over HTTP, nor the data channels
+ * of `webrtcServiceEntrypoint`. Its `errno` is `'E_SIGNALING_CLIENT_REQUIRED'`.
+ */
+export declare class SignalingClientRequiredException extends Exception {
+    /**
+     * `'E_SIGNALING_CLIENT_REQUIRED'`.
+     */
+    errno: string | number;
+}