@lakutata/webrtc 0.0.0-stage → 3.1.1

package/dist/cjs/sfu/SFUWorkers.d.ts

@@ -0,0 +1,247 @@
+import { type HeapInfo } from 'node:v8';
+import { type ResourceLimits, Worker } from 'node:worker_threads';
+import type { EndpointLeg } from '../peer/Endpoints.js';
+import { type MediaTrack } from '../peer/MediaTrack.js';
+import type { SignalingDescription, SignalingPeer } from '../protocol/SignalingProtocol.js';
+import type { Signaling } from '../signaling/Signaling.js';
+import type { SFUTrack } from './SFU.js';
+import type { SFUOfferedTrack, SFUServedRoom, SFUViewerSelect } from './SFURoom.js';
+import type { SFUWorkerData } from './SFUWorker.js';
+import { type SFUFromWorker, type SFUToWorker, SFUWorkerChannel, type SFUWorkerMedia } from './SFUWorkerChannel.js';
+/**
+ * What the worker threads need of the media server
+ */
+export interface SFUWorkersHost {
+    readonly id: string;
+    readonly signaling: Signaling;
+    readonly select?: (subscriber: SignalingPeer, track: SFUTrack) => boolean;
+    emit(event: string, ...args: unknown[]): unknown;
+    emptied(room: SFUServedRoom): void;
+    lost(room: SFUServedRoom): void;
+    sourced?(viewerId: string, source: string | undefined): void;
+    readonly resourceLimits?: ResourceLimits;
+}
+/**
+ * A worker thread, and the rooms it forwards
+ */
+interface Slot {
+    readonly index: number;
+    readonly rooms: Map<number, SFUWorkerRoom>;
+    worker?: Worker;
+    channel?: SFUWorkerChannel<SFUFromWorker, SFUToWorker>;
+    ready: Promise<void>;
+    started?: {
+        resolve(): void;
+        reject(error: Error): void;
+    };
+    ran: boolean;
+    dead: boolean;
+}
+/**
+ * What a room in a worker thread needs of the pool
+ */
+interface RoomLink {
+    readonly id: string;
+    readonly slot: Slot;
+    readonly legs: Map<string, WorkerLeg>;
+    readonly choosers: Map<string, SFUViewerSelect>;
+    emit(event: string, ...args: unknown[]): unknown;
+}
+/**
+ * The connection of a session of WHIP or WHEP in a worker thread
+ */
+declare class WorkerLeg implements EndpointLeg {
+    #private;
+    /**
+     * The answer, with all the candidates.
+     */
+    readonly answer: SignalingDescription;
+    /**
+     * Keep a leg.
+     * @param link The pool.
+     * @param id The id of its member or viewer.
+     * @param answer The answer.
+     * @param source The source of a viewer.
+     */
+    constructor(link: RoomLink, id: string, answer: SignalingDescription, source?: string);
+    /**
+     * The source of a viewer of WHEP.
+     */
+    source(): string | undefined;
+    /**
+     * The source of a viewer changed.
+     * @param source
+     */
+    sourced(source: string | undefined): void;
+    /**
+     * Apply a PATCH in the worker thread.
+     * @param fragment
+     * @param restart
+     */
+    patch(fragment: string, restart: boolean): Promise<string | undefined | null>;
+    /**
+     * Call a listener once the leg ends.
+     * @param listener
+     */
+    ended(listener: () => void): void;
+    /**
+     * Close the connection.
+     */
+    close(): void;
+    /**
+     * The connection is gone.
+     */
+    end(): void;
+}
+/**
+ * A room forwarded in a worker thread, from the main thread: its members, its tracks and its viewers as the thread
+ * tells them, the tracks read here, and its sessions of WHIP and WHEP
+ */
+export declare class SFUWorkerRoom implements SFUServedRoom {
+    #private;
+    /**
+     * The name of the room.
+     */
+    readonly name: string;
+    /**
+     * Resolves once the server is in the room.
+     */
+    readonly ready: Promise<void>;
+    /**
+     * Open a room in a worker thread.
+     * @param link The pool.
+     * @param ref The number of the room in the pool.
+     * @param name The room.
+     */
+    constructor(link: RoomLink, ref: number, name: string);
+    /**
+     * Whether the server left the room.
+     */
+    get closed(): boolean;
+    /**
+     * The ids of the members.
+     */
+    get members(): string[];
+    /**
+     * The tracks published.
+     */
+    get tracks(): SFUTrack[];
+    /**
+     * The number of the viewers of WHEP.
+     */
+    get viewers(): number;
+    /**
+     * A track published: its packets come from the worker thread while they are read, or sent on, here.
+     * @param peerId
+     * @param trackId
+     */
+    track(peerId: string, trackId: string): MediaTrack | undefined;
+    /**
+     * A stream published with WHIP joins the room.
+     * @param id
+     * @param offer
+     */
+    publish(id: string, offer: SignalingDescription): Promise<EndpointLeg>;
+    /**
+     * A viewer of WHEP receives a member of the room.
+     * @param id
+     * @param offer
+     * @param select
+     */
+    play(id: string, offer: SignalingDescription, select?: SFUViewerSelect): Promise<EndpointLeg & {
+        source(): string | undefined;
+    }>;
+    /**
+     * Leave the room.
+     */
+    close(): Promise<void>;
+    /**
+     * Its thread stopped: the room is closed, its tracks unpublished.
+     */
+    lose(): void;
+    /**
+     * An event of the room: the tracks published are kept.
+     * @param event
+     * @param args
+     * @param media The track of the engine of a track published.
+     */
+    emitted(event: string, args: unknown[], media?: SFUWorkerMedia): void;
+    /**
+     * The tracks of the other nodes of the room changed: the ones gone end here.
+     * @param tracks
+     */
+    knew(tracks: SFUOfferedTrack[]): void;
+    /**
+     * The members and the number of the viewers changed.
+     * @param members
+     * @param viewers
+     */
+    state(members: string[], viewers: number): void;
+    /**
+     * A packet of a track read here.
+     * @param peerId
+     * @param trackId
+     * @param packet
+     * @param extensions
+     */
+    received(peerId: string, trackId: string, packet: Uint8Array, extensions?: Record<string, unknown>): void;
+}
+/**
+ * The worker threads of a media server: each forwards the rooms placed in it, the one forwarding the fewest members
+ * and viewers taking the next room. A thread stopping (a bug) loses its rooms; it is started again.
+ */
+export declare class SFUWorkers {
+    #private;
+    /**
+     * Start the threads.
+     * @param host The media server.
+     * @param data What each thread is started with.
+     * @throws {Error} When the code of the threads was not built.
+     */
+    constructor(host: SFUWorkersHost, data: SFUWorkerData[]);
+    /**
+     * Resolves once all the threads run.
+     * @throws {Error} When one fails to start.
+     */
+    get ready(): Promise<void>;
+    /**
+     * Open a room in the thread forwarding the fewest members and viewers.
+     * @param name The room.
+     * @returns The room.
+     */
+    room(name: string): SFUWorkerRoom;
+    /**
+     * The number of rooms of each thread.
+     * @returns The numbers, in the order of the threads.
+     */
+    get rooms(): number[];
+    /**
+     * Stop the threads (their rooms closed before).
+     */
+    stop(): Promise<void>;
+    /**
+     * The thread forwarding a room.
+     * @param name The room.
+     * @returns The index of the thread, or undefined when no thread forwards the room.
+     */
+    threadOf(name: string): number | undefined;
+    /**
+     * Stop a thread now, as a bug would (to test what follows).
+     * @param index The thread.
+     * @internal
+     */
+    crash(index: number): Promise<void>;
+    /**
+     * The heap of each thread (to measure the memory of the threads).
+     * @returns The statistics of the heap of each thread running, by its index.
+     * @internal
+     */
+    heaps(): Promise<(HeapInfo | undefined)[]>;
+    /**
+     * The limits each thread runs with.
+     * @returns The limits of each thread running, by its index.
+     * @internal
+     */
+    limits(): (ResourceLimits | undefined)[];
+}
+export {};