@lakutata/webrtc 0.0.0-stage → 3.1.1

package/dist/esm/cluster/ClusterTURN.js

@@ -0,0 +1,73 @@
+import { createTURNCredentials } from '../turn/TURNCredentials.js';
+import { iceServersOfTURN } from '../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
+ */
+export 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
+ */
+export 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).
+ */
+export function iceServersFor(user, options) {
+    const { turn, cluster, secret, select, iceServers } = options;
+    const servers = [];
+    const lifetimes = [];
+    if (turn) {
+        const credentials = turn.credentials(user);
+        servers.push(...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 ? createTURNCredentials(secret, user, ttl) : turn.credentials(user);
+            for (const server of chosen)
+                servers.push(...iceServersOfTURN(server, credentials));
+            lifetimes.push(credentials.ttl);
+        }
+    }
+    return { iceServers: [...servers, ...iceServers], credentialTtl: lifetimes.length ? Math.min(...lifetimes) : 0 };
+}

package/dist/esm/cluster/Rendezvous.js

@@ -0,0 +1,20 @@
+import { createHash } from '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.
+ */
+export function rendezvous(key, nodes) {
+    let chosen;
+    let best = '';
+    for (const node of nodes) {
+        const score = createHash('sha1').update(key).update('\0').update(node).digest('hex');
+        if (score > best) {
+            best = score;
+            chosen = node;
+        }
+    }
+    return chosen;
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,44 @@
+import { isPackaged } from '@lakutata/core';
+import { ClusterTransportNotFoundException } from '../../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': () => import('ioredis'),
+    'nats': () => import('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.
+ */
+export 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 = isPackaged() ?
+        new 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('Package "{packageName}" is required for this transport of the cluster. Run "npm install {packageName}".', { packageName: packageName });
+    exception.cause = missing;
+    throw exception;
+}

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

@@ -0,0 +1,43 @@
+/**
+ * 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)
+ */
+export 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);
+        }
+    }
+}

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

@@ -0,0 +1,66 @@
+import { loadClient } from './LoadClient.js';
+/**
+ * The bus on a NATS server: its core subjects (no JetStream)
+ */
+export class NATSClusterTransport {
+    #reconnectListeners;
+    #connection;
+    constructor(options) {
+        this.options = options;
+        this.maxPayload = 1024 * 1024;
+        this.#reconnectListeners = [];
+    }
+    async connect() {
+        const nats = await 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());
+        }
+    }
+}

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

@@ -0,0 +1,73 @@
+import { loadClient } from './LoadClient.js';
+/**
+ * The bus on a Redis server: its channels (publish and subscribe), on two connections
+ */
+export 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 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);
+    }
+}

package/dist/esm/exceptions/ClusterRequestException.js

@@ -0,0 +1,14 @@
+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 class ClusterRequestException extends Exception {
+    constructor() {
+        super(...arguments);
+        /**
+         * `'E_CLUSTER_REQUEST'`.
+         */
+        this.errno = 'E_CLUSTER_REQUEST';
+    }
+}

package/dist/esm/exceptions/ClusterTimeoutException.js

@@ -0,0 +1,13 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown by `Cluster.request()` when the node does not answer in time. Its `errno` is `'E_CLUSTER_TIMEOUT'`.
+ */
+export class ClusterTimeoutException extends Exception {
+    constructor() {
+        super(...arguments);
+        /**
+         * `'E_CLUSTER_TIMEOUT'`.
+         */
+        this.errno = 'E_CLUSTER_TIMEOUT';
+    }
+}

package/dist/esm/exceptions/ClusterTransportNotFoundException.js

@@ -0,0 +1,14 @@
+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 class ClusterTransportNotFoundException extends Exception {
+    constructor() {
+        super(...arguments);
+        /**
+         * `'E_CLUSTER_TRANSPORT_NOT_FOUND'`.
+         */
+        this.errno = 'E_CLUSTER_TRANSPORT_NOT_FOUND';
+    }
+}

package/dist/esm/exceptions/SignalingClientRequiredException.js

@@ -0,0 +1,15 @@
+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 class SignalingClientRequiredException extends Exception {
+    constructor() {
+        super(...arguments);
+        /**
+         * `'E_SIGNALING_CLIENT_REQUIRED'`.
+         */
+        this.errno = 'E_SIGNALING_CLIENT_REQUIRED';
+    }
+}

package/dist/esm/exceptions/SignalingConnectionException.js

@@ -0,0 +1,15 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown when `SignalingClient` cannot use the transport of its URL: Socket.IO (an `http:` or `https:` URL) needs the
+ * package `socket.io-client`, JSON-RPC (a `ws:` or `wss:` URL) needs the global `WebSocket` (Node.js 22 and later,
+ * Bun). Its `errno` is `'E_SIGNALING_CONNECTION'`.
+ */
+export class SignalingConnectionException extends Exception {
+    constructor() {
+        super(...arguments);
+        /**
+         * `'E_SIGNALING_CONNECTION'`.
+         */
+        this.errno = 'E_SIGNALING_CONNECTION';
+    }
+}

package/dist/esm/exceptions/SignalingDeniedException.js

@@ -0,0 +1,14 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown when the `authorize` option of the `Signaling` component refuses a member the room it asks to join. Its
+ * `errno` is `'E_SIGNALING_DENIED'`.
+ */
+export class SignalingDeniedException extends Exception {
+    constructor() {
+        super(...arguments);
+        /**
+         * `'E_SIGNALING_DENIED'`.
+         */
+        this.errno = 'E_SIGNALING_DENIED';
+    }
+}

package/dist/esm/exceptions/SignalingLimitException.js

@@ -0,0 +1,14 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown when a member goes over a limit of the `Signaling` component: the size of a message, the messages per
+ * second, the members of a room. Its `errno` is `'E_SIGNALING_LIMIT'`.
+ */
+export class SignalingLimitException extends Exception {
+    constructor() {
+        super(...arguments);
+        /**
+         * `'E_SIGNALING_LIMIT'`.
+         */
+        this.errno = 'E_SIGNALING_LIMIT';
+    }
+}

package/dist/esm/exceptions/SignalingNotAMemberException.js

@@ -0,0 +1,14 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown when a member sends a signal in a room it has not joined, or to a member who is not in it. Its `errno` is
+ * `'E_SIGNALING_NOT_A_MEMBER'`.
+ */
+export class SignalingNotAMemberException extends Exception {
+    constructor() {
+        super(...arguments);
+        /**
+         * `'E_SIGNALING_NOT_A_MEMBER'`.
+         */
+        this.errno = 'E_SIGNALING_NOT_A_MEMBER';
+    }
+}

package/dist/esm/exceptions/WHEPDeniedException.js

@@ -0,0 +1,18 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown when the `authorize` option of the `WHEP` component refuses a stream to its viewer (an HTTP 401). Its
+ * `errno` is `'E_WHEP_DENIED'`.
+ */
+export class WHEPDeniedException extends Exception {
+    constructor() {
+        super(...arguments);
+        /**
+         * `'E_WHEP_DENIED'`.
+         */
+        this.errno = 'E_WHEP_DENIED';
+        /**
+         * The HTTP status of the response: 401.
+         */
+        this.statusCode = 401;
+    }
+}

package/dist/esm/exceptions/WHEPLimitException.js

@@ -0,0 +1,18 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown when the `WHEP` component has as many sessions as its `maxSessions` option allows (an HTTP 503). Its
+ * `errno` is `'E_WHEP_LIMIT'`.
+ */
+export class WHEPLimitException extends Exception {
+    constructor() {
+        super(...arguments);
+        /**
+         * `'E_WHEP_LIMIT'`.
+         */
+        this.errno = 'E_WHEP_LIMIT';
+        /**
+         * The HTTP status of the response: 503.
+         */
+        this.statusCode = 503;
+    }
+}

package/dist/esm/exceptions/WHEPMediaTypeException.js

@@ -0,0 +1,18 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown when the body of a request to `WHEPController` is not `application/sdp` (a POST) or
+ * `application/trickle-ice-sdpfrag` (a PATCH): an HTTP 415. Its `errno` is `'E_WHEP_MEDIA_TYPE'`.
+ */
+export class WHEPMediaTypeException extends Exception {
+    constructor() {
+        super(...arguments);
+        /**
+         * `'E_WHEP_MEDIA_TYPE'`.
+         */
+        this.errno = 'E_WHEP_MEDIA_TYPE';
+        /**
+         * The HTTP status of the response: 415.
+         */
+        this.statusCode = 415;
+    }
+}

package/dist/esm/exceptions/WHEPOfferException.js

@@ -0,0 +1,19 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown when the offer of a viewer is not one the `WHEP` component can answer: not an SDP offer, without audio
+ * or video, of a room the media server does not serve, or refused by the connection; or when the fragment of a PATCH
+ * has no ICE or is refused (an HTTP 400). Its `errno` is `'E_WHEP_OFFER'`.
+ */
+export class WHEPOfferException extends Exception {
+    constructor() {
+        super(...arguments);
+        /**
+         * `'E_WHEP_OFFER'`.
+         */
+        this.errno = 'E_WHEP_OFFER';
+        /**
+         * The HTTP status of the response: 400.
+         */
+        this.statusCode = 400;
+    }
+}

package/dist/esm/exceptions/WHEPSessionNotFoundException.js

@@ -0,0 +1,18 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown when a request to `WHEPController` names a session the `WHEP` component does not have (an HTTP 404). Its
+ * `errno` is `'E_WHEP_SESSION_NOT_FOUND'`.
+ */
+export class WHEPSessionNotFoundException extends Exception {
+    constructor() {
+        super(...arguments);
+        /**
+         * `'E_WHEP_SESSION_NOT_FOUND'`.
+         */
+        this.errno = 'E_WHEP_SESSION_NOT_FOUND';
+        /**
+         * The HTTP status of the response: 404.
+         */
+        this.statusCode = 404;
+    }
+}

package/dist/esm/exceptions/WHIPDeniedException.js

@@ -0,0 +1,18 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown when the `authorize` option of the `WHIP` component refuses a stream to its publisher (an HTTP 401). Its
+ * `errno` is `'E_WHIP_DENIED'`.
+ */
+export class WHIPDeniedException extends Exception {
+    constructor() {
+        super(...arguments);
+        /**
+         * `'E_WHIP_DENIED'`.
+         */
+        this.errno = 'E_WHIP_DENIED';
+        /**
+         * The HTTP status of the response: 401.
+         */
+        this.statusCode = 401;
+    }
+}

package/dist/esm/exceptions/WHIPLimitException.js

@@ -0,0 +1,18 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown when the `WHIP` component has as many sessions as its `maxSessions` option allows (an HTTP 503). Its
+ * `errno` is `'E_WHIP_LIMIT'`.
+ */
+export class WHIPLimitException extends Exception {
+    constructor() {
+        super(...arguments);
+        /**
+         * `'E_WHIP_LIMIT'`.
+         */
+        this.errno = 'E_WHIP_LIMIT';
+        /**
+         * The HTTP status of the response: 503.
+         */
+        this.statusCode = 503;
+    }
+}

package/dist/esm/exceptions/WHIPMediaTypeException.js

@@ -0,0 +1,18 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown when the body of a request to `WHIPController` is not `application/sdp` (a POST) or
+ * `application/trickle-ice-sdpfrag` (a PATCH): an HTTP 415. Its `errno` is `'E_WHIP_MEDIA_TYPE'`.
+ */
+export class WHIPMediaTypeException extends Exception {
+    constructor() {
+        super(...arguments);
+        /**
+         * `'E_WHIP_MEDIA_TYPE'`.
+         */
+        this.errno = 'E_WHIP_MEDIA_TYPE';
+        /**
+         * The HTTP status of the response: 415.
+         */
+        this.statusCode = 415;
+    }
+}

package/dist/esm/exceptions/WHIPOfferException.js

@@ -0,0 +1,19 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown when the offer of a publisher is not one the `WHIP` component can answer: not an SDP offer, without audio
+ * or video, of a room the media server does not serve, or refused by the connection; or when the fragment of a PATCH
+ * has no ICE or is refused (an HTTP 400). Its `errno` is `'E_WHIP_OFFER'`.
+ */
+export class WHIPOfferException extends Exception {
+    constructor() {
+        super(...arguments);
+        /**
+         * `'E_WHIP_OFFER'`.
+         */
+        this.errno = 'E_WHIP_OFFER';
+        /**
+         * The HTTP status of the response: 400.
+         */
+        this.statusCode = 400;
+    }
+}

package/dist/esm/exceptions/WHIPSessionNotFoundException.js

@@ -0,0 +1,18 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown when a request to `WHIPController` names a session the `WHIP` component does not have (an HTTP 404). Its
+ * `errno` is `'E_WHIP_SESSION_NOT_FOUND'`.
+ */
+export class WHIPSessionNotFoundException extends Exception {
+    constructor() {
+        super(...arguments);
+        /**
+         * `'E_WHIP_SESSION_NOT_FOUND'`.
+         */
+        this.errno = 'E_WHIP_SESSION_NOT_FOUND';
+        /**
+         * The HTTP status of the response: 404.
+         */
+        this.statusCode = 404;
+    }
+}

package/dist/esm/exports/Client.js

@@ -0,0 +1,5 @@
+export * from '../client/SignalingConnection.js';
+export * from '../protocol/SignalingProtocol.js';
+export { SignalingRequestError } from '../shared/SignalingError.js';
+export { ChunkedChannel } from '../shared/ChunkedChannel.js';
+export { PeerServiceProxy, PeerServiceError } from '../shared/PeerServiceProxy.js';