@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/esm/cluster/Cluster.js

@@ -0,0 +1,542 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { hostname } from 'node:os';
+import { randomBytes, randomUUID } from 'node:crypto';
+import { Component, DTO } from '@lakutata/core';
+import { Configurable, Singleton } from '@lakutata/core/decorator/di';
+import { ClusterRequestException } from '../exceptions/ClusterRequestException.js';
+import { ClusterTimeoutException } from '../exceptions/ClusterTimeoutException.js';
+import { FrameAssembler, framesOf } from './ClusterFrames.js';
+import { MemoryClusterTransport } from './transports/MemoryClusterTransport.js';
+import { NATSClusterTransport } from './transports/NATSClusterTransport.js';
+import { RedisClusterTransport } from './transports/RedisClusterTransport.js';
+/**
+ * The default id of a node: its host name made fit for the subjects, and a random suffix
+ */
+function defaultNodeId() {
+    const host = hostname().replace(/[^A-Za-z0-9_-]/g, '-').slice(0, 100) || 'node';
+    return `${host}-${randomBytes(4).toString('hex')}`;
+}
+/**
+ * A copy of a node for the listeners
+ * @param node
+ */
+function nodeOf(node) {
+    return { id: node.id, labels: { ...node.labels }, services: { ...node.services }, local: false };
+}
+/**
+ * The instances of an application working together: each instance is a node, and the nodes talk through a bus (NATS or
+ * Redis). The other components of the package use it when they are given its name (their `cluster` option): the
+ * signaling puts the members of all the nodes in the same rooms, the TURN servers tell the others their address and
+ * their load, the media servers of the nodes share the rooms, and a DELETE or a PATCH of a session of WHIP or WHEP is
+ * applied on the node holding the session. The application may use it too: messages to all the nodes (`publish`,
+ * `subscribe`), requests to one node or to all (`request`, `requestAll`, `handle`).
+ *
+ * Each node tells the others it is there every `heartbeatInterval`, with its labels and what it offers
+ * (`announce()`); the others take it as gone after three intervals without news of it, or at once when it stops. The
+ * component emits `node-up`, `node-down` and `node-update` with the {@link ClusterNode}. The bus carries only these
+ * messages: the media go directly between the clients and the nodes.
+ *
+ * Register it with {@link buildClusterOptions}; its `transport` is required.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildEntrypoints} from 'lakutata/com/entrypoint'
+ * import {socketIOServiceEntrypoint} from 'lakutata/adapter/socket.io'
+ * import {buildClusterOptions, buildSignalingOptions, SignalingController} from '@lakutata/webrtc'
+ *
+ * //Each pod of the deployment is a node; the members connected to any of them meet in the same rooms
+ * Application.run(() => ({
+ *     id: 'meet.app',
+ *     name: 'Meet',
+ *     components: {
+ *         cluster: buildClusterOptions({transport: {type: 'nats', servers: process.env.NATS_URL}}),
+ *         signaling: buildSignalingOptions({cluster: 'cluster'}),
+ *         entrypoint: buildEntrypoints({
+ *             controllers: [SignalingController],
+ *             service: socketIOServiceEntrypoint({port: 3000})
+ *         })
+ *     },
+ *     bootstrap: ['signaling', 'entrypoint']
+ * }))
+ * ```
+ */
+let Cluster = class Cluster extends Component {
+    #incarnation = randomUUID();
+    #nodes = new Map();
+    #services = {};
+    #listeners = new Map();
+    #handlers = new Map();
+    #pending = new Map();
+    #assembler = new FrameAssembler();
+    #bus;
+    #heartbeat;
+    #stopped = false;
+    /**
+     * Connect to the bus, and tell the other nodes this one is there.
+     * @protected
+     */
+    async init() {
+        const transport = this.transport;
+        this.#bus = transport.type === 'nats' ? new NATSClusterTransport(transport) : transport.type === 'redis' ? new RedisClusterTransport(transport) : new MemoryClusterTransport();
+        await this.#bus.connect();
+        const received = (data) => {
+            const message = this.#assembler.add(data);
+            if (!message)
+                return;
+            let envelope;
+            try {
+                envelope = JSON.parse(message.toString());
+            }
+            catch {
+                return;
+            }
+            this.receive(envelope);
+        };
+        await this.#bus.subscribe(this.subjectOf(), received);
+        await this.#bus.subscribe(this.subjectOf(this.nodeId), received);
+        //Back on the bus: the others may have taken this node as gone, and it may have missed their news
+        this.#bus.onReconnect(() => this.beat());
+        this.beat();
+        this.#heartbeat = setInterval(() => {
+            this.beat();
+            this.expire();
+        }, this.heartbeatInterval);
+        this.#heartbeat.unref();
+    }
+    /**
+     * Tell the other nodes this one stops, and close the connection to the bus.
+     * @protected
+     */
+    async destroy() {
+        this.#stopped = true;
+        clearInterval(this.#heartbeat);
+        for (const [id, pending] of [...this.#pending])
+            this.settle(id, pending, () => pending.reject(new ClusterRequestException('The cluster stopped')));
+        if (!this.#bus)
+            return;
+        this.send(undefined, { k: 'bye', n: this.nodeId, i: this.#incarnation });
+        await this.#bus.close();
+    }
+    /**
+     * The nodes of the cluster: this one first, then the others seen in the last three heartbeat intervals.
+     * @returns The nodes.
+     * @example
+     * ```typescript
+     * import type {Cluster, ClusterNode} from '@lakutata/webrtc'
+     *
+     * declare const cluster: Cluster
+     * //['meet-7c9f-a1b2c3d4', 'meet-7c9f-e5f60718']
+     * console.log(cluster.nodes().map((node: ClusterNode): string => node.id))
+     * ```
+     */
+    nodes() {
+        return [
+            { id: this.nodeId, labels: { ...this.labels }, services: { ...this.#services }, local: true },
+            ...[...this.#nodes.values()].map(nodeOf)
+        ];
+    }
+    /**
+     * Tell the other nodes what this node offers for a service (they see it in the `services` of its node); `undefined`
+     * withdraws it. A new or withdrawn service is sent at once, a changed one with the next heartbeat.
+     * @param service The service.
+     * @param info What the nodes get about it, as JSON.
+     * @example
+     * ```typescript
+     * import type {Cluster} from '@lakutata/webrtc'
+     *
+     * declare const cluster: Cluster
+     * cluster.announce('recorder', {disk: 0.42})
+     * ```
+     */
+    announce(service, info) {
+        const known = service in this.#services;
+        if (info === undefined) {
+            delete this.#services[service];
+        }
+        else {
+            this.#services[service] = info;
+        }
+        if (known !== (info !== undefined) && this.#bus && !this.#stopped)
+            this.beat();
+    }
+    /**
+     * Send a message to the other nodes: their listeners of the topic receive it (this node's do not).
+     * @param topic The topic.
+     * @param message The message, as JSON.
+     * @example
+     * ```typescript
+     * import type {Cluster} from '@lakutata/webrtc'
+     *
+     * declare const cluster: Cluster
+     * cluster.publish('announcements', {text: 'The meeting starts in 5 minutes'})
+     * ```
+     */
+    publish(topic, message) {
+        this.send(undefined, { k: 'msg', n: this.nodeId, t: topic, d: message });
+    }
+    /**
+     * Receive the messages of a topic from the other nodes.
+     * @param topic The topic.
+     * @param listener Called with the message and the id of the node sending it.
+     * @returns A function ending the subscription.
+     * @example
+     * ```typescript
+     * import type {Cluster} from '@lakutata/webrtc'
+     *
+     * declare const cluster: Cluster
+     * const unsubscribe: () => void = cluster.subscribe<{text: string}>('announcements', (message: {text: string}, from: string): void => console.log(from, message.text))
+     * ```
+     */
+    subscribe(topic, listener) {
+        if (!this.#listeners.has(topic))
+            this.#listeners.set(topic, new Set());
+        const listeners = this.#listeners.get(topic);
+        const added = (message, from) => listener(message, from);
+        listeners.add(added);
+        return () => {
+            listeners.delete(added);
+            if (!listeners.size)
+                this.#listeners.delete(topic);
+        };
+    }
+    /**
+     * Answer the requests of a topic (from `request()` and `requestAll()`), replacing the handler it had.
+     * @param topic The topic.
+     * @param handler Called with the message and the id of the node asking; what it returns (or resolves to) is the
+     * answer, as JSON, and what it throws fails the request.
+     * @returns A function removing the handler.
+     * @example
+     * ```typescript
+     * import type {Cluster} from '@lakutata/webrtc'
+     *
+     * declare const cluster: Cluster
+     * cluster.handle<{room: string}, number>('viewers', ({room}: {room: string}): number => room.length)
+     * ```
+     */
+    handle(topic, handler) {
+        const added = (message, from) => handler(message, from);
+        this.#handlers.set(topic, added);
+        return () => {
+            if (this.#handlers.get(topic) === added)
+                this.#handlers.delete(topic);
+        };
+    }
+    /**
+     * Ask a node, and wait for its answer. A request to this node calls its handler directly.
+     * @param node The id of the node.
+     * @param topic The topic of its handler.
+     * @param message The message, as JSON.
+     * @param options How long to wait.
+     * @returns The answer of its handler.
+     * @throws {ClusterRequestException} When the node is not in the cluster, has no handler of the topic, or its
+     * handler failed.
+     * @throws {ClusterTimeoutException} When it does not answer in time.
+     * @example
+     * ```typescript
+     * import type {Cluster} from '@lakutata/webrtc'
+     *
+     * declare const cluster: Cluster
+     * const viewers: number = await cluster.request<number>('meet-7c9f-e5f60718', 'viewers', {room: 'meeting'}, {timeout: 1000})
+     * ```
+     */
+    async request(node, topic, message, options = {}) {
+        if (node === this.nodeId) {
+            const handler = this.#handlers.get(topic);
+            if (!handler)
+                throw new ClusterRequestException('The node {node} has no handler of {topic}', { node: node, topic: topic });
+            return await handler(JSON.parse(JSON.stringify(message ?? null)), this.nodeId);
+        }
+        if (!this.#nodes.has(node))
+            throw new ClusterRequestException('The node {node} is not in the cluster', { node: node });
+        const id = randomUUID();
+        const timeout = options.timeout ?? this.requestTimeout;
+        return await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.settle(id, this.#pending.get(id), () => reject(new ClusterTimeoutException('The node {node} did not answer {topic} in {timeout} ms', { node: node, topic: topic, timeout: timeout })));
+            }, timeout);
+            this.#pending.set(id, { topic: topic, timer: timer, node: node, resolve: resolve, reject: reject });
+            this.send(node, { k: 'req', n: this.nodeId, id: id, t: topic, d: message });
+        });
+    }
+    /**
+     * Ask all the other nodes, and wait until each answered or the time is up.
+     * @param topic The topic of their handlers.
+     * @param message The message, as JSON.
+     * @param options How long to wait at most.
+     * @returns The answers of the nodes whose handler answered (not those without a handler of the topic, those whose
+     * handler failed, or those answering late).
+     * @example
+     * ```typescript
+     * import type {Cluster, ClusterReply} from '@lakutata/webrtc'
+     *
+     * declare const cluster: Cluster
+     * const replies: ClusterReply<number>[] = await cluster.requestAll<number>('viewers', {room: 'meeting'})
+     * const viewers: number = replies.reduce((sum: number, reply: ClusterReply<number>): number => sum + reply.result, 0)
+     * ```
+     */
+    async requestAll(topic, message, options = {}) {
+        const awaited = new Set(this.#nodes.keys());
+        if (!awaited.size)
+            return [];
+        const id = randomUUID();
+        const replies = [];
+        return await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.settle(id, this.#pending.get(id), () => resolve(replies));
+            }, options.timeout ?? this.requestTimeout);
+            this.#pending.set(id, { topic: topic, timer: timer, awaited: awaited, replies: replies, resolve: resolve, reject: reject });
+            this.send(undefined, { k: 'req', n: this.nodeId, id: id, t: topic, d: message });
+        });
+    }
+    /**
+     * The subject of a node, or of all the nodes
+     * @param node The id of the node; none for all the nodes.
+     * @protected
+     */
+    subjectOf(node) {
+        return node === undefined ? `${this.prefix}.all` : `${this.prefix}.node.${node}`;
+    }
+    /**
+     * Send an envelope to a node, or to all of them
+     * @param node The id of the node; none for all the nodes.
+     * @param envelope The message.
+     * @protected
+     */
+    send(node, envelope) {
+        if (!this.#bus)
+            return;
+        const subject = this.subjectOf(node);
+        for (const frame of framesOf(Buffer.from(JSON.stringify(envelope)), this.#bus.maxPayload))
+            this.#bus.publish(subject, frame);
+    }
+    /**
+     * Send a heartbeat to all the nodes
+     * @param node Only to this node (an answer to its first heartbeat).
+     * @protected
+     */
+    beat(node) {
+        if (this.#stopped)
+            return;
+        this.send(node, { k: 'hb', n: this.nodeId, i: this.#incarnation, iv: this.heartbeatInterval, l: this.labels, s: this.#services });
+    }
+    /**
+     * Take as gone the nodes without news for three of their heartbeat intervals
+     * @protected
+     */
+    expire() {
+        const now = Date.now();
+        for (const node of [...this.#nodes.values()]) {
+            if (now - node.lastSeen > node.interval * 3)
+                this.gone(node);
+        }
+    }
+    /**
+     * Forget a node: its requests fail, `requestAll()` stops waiting for it, `node-down` is emitted
+     * @param node The node.
+     * @protected
+     */
+    gone(node) {
+        if (this.#nodes.get(node.id) !== node)
+            return;
+        this.#nodes.delete(node.id);
+        for (const [id, pending] of [...this.#pending]) {
+            if (pending.node === node.id) {
+                this.settle(id, pending, () => pending.reject(new ClusterRequestException('The node {node} left the cluster', { node: node.id })));
+            }
+            else if (pending.awaited?.delete(node.id) && !pending.awaited.size) {
+                this.settle(id, pending, () => pending.resolve(pending.replies));
+            }
+        }
+        this.emit('node-down', nodeOf(node));
+    }
+    /**
+     * Remove a pending request and settle it
+     * @param id The id of the request.
+     * @param pending The request.
+     * @param settle Resolves or rejects it.
+     * @protected
+     */
+    settle(id, pending, settle) {
+        if (!pending || this.#pending.get(id) !== pending)
+            return;
+        clearTimeout(pending.timer);
+        this.#pending.delete(id);
+        settle();
+    }
+    /**
+     * Handle an envelope from the bus
+     * @param envelope The message.
+     * @protected
+     */
+    receive(envelope) {
+        if (this.#stopped || !envelope || typeof envelope.n !== 'string' || envelope.n === this.nodeId)
+            return;
+        const sender = this.#nodes.get(envelope.n);
+        if (sender)
+            sender.lastSeen = Date.now();
+        switch (envelope.k) {
+            case 'hb':
+                return this.heard(envelope);
+            case 'bye':
+                if (sender?.incarnation === envelope.i)
+                    this.gone(sender);
+                return;
+            case 'msg':
+                this.#listeners.get(envelope.t)?.forEach((listener) => {
+                    try {
+                        listener(envelope.d, envelope.n);
+                    }
+                    catch {
+                        //A listener failing does not stop the others
+                    }
+                });
+                return;
+            case 'req':
+                return void this.answer(envelope);
+            case 'res':
+                return this.answered(envelope);
+        }
+    }
+    /**
+     * Handle a heartbeat: a new node (or a node restarted) is up, a known one updated
+     * @param heartbeat The heartbeat.
+     * @protected
+     */
+    heard(heartbeat) {
+        const known = this.#nodes.get(heartbeat.n);
+        if (known && known.incarnation === heartbeat.i) {
+            const changed = JSON.stringify([known.labels, known.services]) !== JSON.stringify([heartbeat.l, heartbeat.s]);
+            known.interval = heartbeat.iv;
+            known.labels = heartbeat.l ?? {};
+            known.services = heartbeat.s ?? {};
+            if (changed)
+                this.emit('node-update', nodeOf(known));
+            return;
+        }
+        //Restarted with the same id: the node it was is gone
+        if (known)
+            this.gone(known);
+        const node = { id: heartbeat.n, incarnation: heartbeat.i, interval: heartbeat.iv, labels: heartbeat.l ?? {}, services: heartbeat.s ?? {}, lastSeen: Date.now() };
+        this.#nodes.set(node.id, node);
+        //It learns about this node at once rather than at the next heartbeat
+        this.beat(node.id);
+        this.emit('node-up', nodeOf(node));
+    }
+    /**
+     * Answer a request with its handler
+     * @param request The request.
+     * @protected
+     */
+    async answer(request) {
+        const handler = this.#handlers.get(request.t);
+        if (!handler)
+            return this.send(request.n, { k: 'res', n: this.nodeId, id: request.id, e: `The node ${this.nodeId} has no handler of ${request.t}` });
+        try {
+            const result = await handler(request.d, request.n);
+            this.send(request.n, { k: 'res', n: this.nodeId, id: request.id, d: result === undefined ? null : result });
+        }
+        catch (error) {
+            this.send(request.n, { k: 'res', n: this.nodeId, id: request.id, e: error?.message ?? String(error) });
+        }
+    }
+    /**
+     * Handle an answer to a request of this node
+     * @param response The answer.
+     * @protected
+     */
+    answered(response) {
+        const pending = this.#pending.get(response.id);
+        if (!pending)
+            return;
+        if (pending.awaited) {
+            pending.awaited.delete(response.n);
+            if (response.e === undefined)
+                pending.replies.push({ node: response.n, result: response.d });
+            if (!pending.awaited.size)
+                this.settle(response.id, pending, () => pending.resolve(pending.replies));
+            return;
+        }
+        if (pending.node !== response.n)
+            return;
+        this.settle(response.id, pending, () => response.e === undefined
+            ? pending.resolve(response.d)
+            : pending.reject(new ClusterRequestException('The node {node} failed to answer {topic}: {reason}', { node: response.n, topic: pending.topic, reason: response.e })));
+    }
+};
+__decorate([
+    Configurable(DTO.Alternatives(DTO.Object({ type: DTO.String().valid('memory').required() }), DTO.Object({
+        type: DTO.String().valid('nats').required(),
+        servers: DTO.Alternatives(DTO.String(), DTO.Array().items(DTO.String())).optional(),
+        user: DTO.String().optional(),
+        pass: DTO.String().optional(),
+        token: DTO.String().optional(),
+        name: DTO.String().optional()
+    }), DTO.Object({
+        type: DTO.String().valid('redis').required(),
+        url: DTO.String().optional(),
+        host: DTO.String().optional(),
+        port: DTO.Number().port().optional(),
+        database: DTO.Number().integer().min(0).optional(),
+        username: DTO.String().optional(),
+        password: DTO.String().optional(),
+        tls: DTO.Boolean().optional()
+    })).required()),
+    __metadata("design:type", Object)
+], Cluster.prototype, "transport", void 0);
+__decorate([
+    Configurable(DTO.String().pattern(/^[A-Za-z0-9_-]+(\.[A-Za-z0-9_-]+)*$/).optional().default('lakutata.webrtc')),
+    __metadata("design:type", String)
+], Cluster.prototype, "prefix", void 0);
+__decorate([
+    Configurable(DTO.String().pattern(/^[A-Za-z0-9_-]{1,128}$/).optional().default(() => defaultNodeId())),
+    __metadata("design:type", String)
+], Cluster.prototype, "nodeId", void 0);
+__decorate([
+    Configurable(DTO.Object().pattern(DTO.String(), DTO.String()).optional().default({})),
+    __metadata("design:type", Object)
+], Cluster.prototype, "labels", void 0);
+__decorate([
+    Configurable(DTO.Number().integer().min(100).optional().default(2000)),
+    __metadata("design:type", Number)
+], Cluster.prototype, "heartbeatInterval", void 0);
+__decorate([
+    Configurable(DTO.Number().integer().positive().optional().default(5000)),
+    __metadata("design:type", Number)
+], Cluster.prototype, "requestTimeout", void 0);
+Cluster = __decorate([
+    Singleton()
+], Cluster);
+export { Cluster };
+/**
+ * Build the options of a {@link Cluster} component, for the `components` of an application.
+ * @param options The bus (required), the prefix of its subjects, the id and the labels of this node, the intervals.
+ * @returns The component options.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildClusterOptions} from '@lakutata/webrtc'
+ *
+ * Application.run(() => ({
+ *     id: 'meet.app',
+ *     name: 'Meet',
+ *     components: {
+ *         cluster: buildClusterOptions({
+ *             transport: {type: 'redis', url: process.env.REDIS_URL},
+ *             nodeId: process.env.POD_NAME,
+ *             labels: {zone: process.env.ZONE ?? 'default'}
+ *         })
+ *     }
+ * }))
+ * ```
+ */
+export function buildClusterOptions(options) {
+    return { class: Cluster, ...options };
+}

package/dist/esm/cluster/ClusterFrames.js

@@ -0,0 +1,85 @@
+import { randomBytes } from 'node:crypto';
+/**
+ * A frame holding a whole message
+ */
+const WHOLE = 0;
+/**
+ * A frame holding a part of a message larger than the transport carries
+ */
+const PART = 1;
+/**
+ * The header of a part: its kind, the id of its message, its index, the number of parts
+ */
+const PART_HEADER = 1 + 16 + 4 + 4;
+/**
+ * The parts of a message at most (a frame claiming more is dropped)
+ */
+const MAX_PARTS = 65536;
+/**
+ * The frames carrying a message: the message itself, or its parts when it is larger than the transport carries
+ * @param message
+ * @param maxPayload
+ */
+export function framesOf(message, maxPayload) {
+    if (message.length + 1 <= maxPayload)
+        return [Buffer.concat([Buffer.of(WHOLE), message])];
+    const size = Math.max(1, maxPayload - PART_HEADER);
+    const id = randomBytes(16);
+    const count = Math.ceil(message.length / size);
+    const frames = [];
+    for (let index = 0; index < count; index++) {
+        const header = Buffer.alloc(PART_HEADER);
+        header[0] = PART;
+        id.copy(header, 1);
+        header.writeUInt32BE(index, 17);
+        header.writeUInt32BE(count, 21);
+        frames.push(Buffer.concat([header, message.subarray(index * size, (index + 1) * size)]));
+    }
+    return frames;
+}
+/**
+ * Puts the messages back together from their frames: the parts of a message arrive in order from its publisher, those
+ * of other messages may come between them
+ */
+export class FrameAssembler {
+    #partials = new Map();
+    /**
+     * @param timeout How long the parts of a message are kept, waiting for the rest, in milliseconds.
+     */
+    constructor(timeout = 30000) {
+        this.timeout = timeout;
+    }
+    /**
+     * Add a frame
+     * @param frame
+     * @returns The message, once it is whole.
+     */
+    add(frame) {
+        const buffer = Buffer.from(frame.buffer, frame.byteOffset, frame.byteLength);
+        if (buffer[0] === WHOLE)
+            return buffer.subarray(1);
+        if (buffer[0] !== PART || buffer.length < PART_HEADER)
+            return undefined;
+        const now = Date.now();
+        for (const [id, partial] of this.#partials)
+            if (partial.expiresAt < now)
+                this.#partials.delete(id);
+        const id = buffer.toString('hex', 1, 17);
+        const index = buffer.readUInt32BE(17);
+        const count = buffer.readUInt32BE(21);
+        if (count < 1 || count > MAX_PARTS || index >= count)
+            return undefined;
+        let partial = this.#partials.get(id);
+        if (!partial) {
+            partial = { parts: new Array(count), received: 0, expiresAt: now + this.timeout };
+            this.#partials.set(id, partial);
+        }
+        if (partial.parts.length !== count || partial.parts[index])
+            return undefined;
+        partial.parts[index] = Buffer.from(buffer.subarray(PART_HEADER));
+        if (++partial.received < count)
+            return undefined;
+        this.#partials.delete(id);
+        return Buffer.concat(partial.parts);
+    }
+}