@lakutata/webrtc 3.1.4 → 3.1.6

package/dist/cjs/sfu/SFUWorkers.js

@@ -449,7 +449,9 @@ class SFUWorkers {
         //Running once it says so: a thread failing to start is not started again
         slot.ran = false;
         const resourceLimits = this.#host.resourceLimits;
-        const worker = new node_worker_threads_1.Worker(SFUWorkerCode_js_1.sfuWorkerCode, { eval: true, workerData: this.#data[slot.index], ...resourceLimits ? { resourceLimits: resourceLimits } : {} });
+        //Without the options of the command line of the process, which a worker inherits: with --input-type=module, its code
+        //(CommonJS) would run as an ES module
+        const worker = new node_worker_threads_1.Worker(SFUWorkerCode_js_1.sfuWorkerCode, { eval: true, execArgv: [], workerData: this.#data[slot.index], ...resourceLimits ? { resourceLimits: resourceLimits } : {} });
         slot.worker = worker;
         slot.channel = new SFUWorkerChannel_js_1.SFUWorkerChannel(worker, (message) => this.#handle(slot, message));
         slot.ready = new Promise((resolve, reject) => {

package/dist/cjs/shared/SignalingSession.js

@@ -21,6 +21,7 @@ const MAX_REJOIN_DELAY = 10000;
  */
 function randomSession() {
     const bytes = new Uint8Array(12);
+    //node-compat: crypto (global) (the browsers; on Node.js, SignalingClient gives the session itself)
     globalThis.crypto.getRandomValues(bytes);
     return Array.from(bytes, (byte) => byte.toString(16).padStart(2, '0')).join('');
 }

package/dist/cjs/shared/Transports.d.ts

@@ -60,7 +60,7 @@ export interface SocketIOSocketLike {
     off(event: string, listener?: (...args: any[]) => void): unknown;
 }
 /**
- * What the signaling needs of a WebSocket (`WebSocket` of the browsers, of Node.js 22 and of Bun) speaking JSON-RPC to
+ * What the signaling needs of a WebSocket (`WebSocket` of the browsers, of Node.js 22 and of Bun, of the package `ws`) speaking JSON-RPC to
  * the server; its client id is the `id` query parameter of its URL.
  */
 export interface WebSocketLike {

package/dist/cjs/turn/TURNWorkers.js

@@ -165,7 +165,9 @@ class TURNWorkers {
             port: this.#port,
             ...data.options.tls && this.#tlsPort !== undefined ? { tls: { ...data.options.tls, port: this.#tlsPort } } : {}
         };
-        const worker = new node_worker_threads_1.Worker(TURNWorkerCode_js_1.turnWorkerCode, { eval: true, workerData: { ...data, options: options } });
+        //Without the options of the command line of the process, which a worker inherits: with --input-type=module, its code
+        //(CommonJS) would run as an ES module
+        const worker = new node_worker_threads_1.Worker(TURNWorkerCode_js_1.turnWorkerCode, { eval: true, execArgv: [], workerData: { ...data, options: options } });
         slot.worker = worker;
         if ((0, log_js_1.hasDebugHandler)())
             worker.postMessage({ type: 'debug', enabled: true });

package/dist/esm/exceptions/SignalingConnectionException.js

@@ -2,7 +2,7 @@ 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'`.
+ * Bun) or the package `ws`. Its `errno` is `'E_SIGNALING_CONNECTION'`.
  */
 export class SignalingConnectionException extends Exception {
     constructor() {

package/dist/esm/lib/ice/dns/lookup.js

@@ -40,8 +40,13 @@ export class DnsLookup {
     constructor() {
         this.cache = new Map();
         const lookupWorkerFunction = () => {
-            const worker_thread = global.require('worker_threads');
-            const { lookup } = global.require('dns');
+            //The modules of Node.js: process.getBuiltinModule where there is one (Bun has no global.require), else the
+            //require of the script (Node.js before 20.16). No require is named in the function, whose text runs in the
+            //worker: a bundler would rewrite it
+            //node-compat: process.getBuiltinModule (checked first, global.require where it is missing)
+            const load = (id) => typeof process.getBuiltinModule === 'function' ? process.getBuiltinModule(id) : global.require(id);
+            const worker_thread = load('worker_threads');
+            const { lookup } = load('dns');
             const dnsLookup = (host) => lookup(host, (err, address, family) => {
                 const res = {
                     err: err?.message,
@@ -59,7 +64,10 @@ export class DnsLookup {
         };
         const lookupEval = `(${lookupWorkerFunction})()`;
         this.thread = new worker_thread.Worker(lookupEval, {
-            eval: true
+            eval: true,
+            //Without the options of the command line of the process, which a worker inherits: with --input-type=module, its code
+            //(CommonJS) would run as an ES module
+            execArgv: []
         });
         this.thread.setMaxListeners(100);
     }

package/dist/esm/lib/peer/peerConnection.js

@@ -1396,8 +1396,10 @@ export class RTCPeerConnection extends EventTarget {
         return buildStatsReport(stats, this.transceiverManager.getStatsRootIds(selector));
     }
     async close() {
-        if (this.isClosed)
-            return;
+        this.closing ??= this.closeOnce();
+        return this.closing;
+    }
+    async closeOnce() {
         this.isClosed = true;
         this.pendingRemoteCandidates.length = 0;
         this.setSignalingState('closed');

package/dist/esm/peer/PeerThreads.js

@@ -7,7 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { availableParallelism } from 'node:os';
+import os from 'node:os';
 import { Worker } from 'node:worker_threads';
 import { Component, DTO } from '@lakutata/core';
 import { Configurable, Singleton } from '@lakutata/core/decorator/di';
@@ -20,6 +20,13 @@ const log = debug('webrtc/peer/threads');
  * How long a thread asked to stop has to close its connections, in milliseconds
  */
 const STOP_TIMEOUT = 5000;
+/**
+ * The parallelism the system advises: os.availableParallelism (Node.js 18.14, 19.4), else the cores
+ */
+function parallelism() {
+    //node-compat: os.availableParallelism
+    return typeof os.availableParallelism === 'function' ? os.availableParallelism() : Math.max(1, os.cpus().length);
+}
 /**
  * Worker threads serving connections, to use more cores: a {@link PeerConnection} given the name of this component
  * (its `threads` option) runs its ICE, DTLS, SCTP and SRTP there, while its object, its events and the messages of its
@@ -63,7 +70,7 @@ let PeerThreads = class PeerThreads extends Component {
     async init() {
         if (!peerWorkerCode)
             throw new Error('The code of the worker threads of the connections is not built (scripts/workers.mjs)');
-        const count = this.threads ?? Math.max(1, availableParallelism() - 1);
+        const count = this.threads ?? Math.max(1, parallelism() - 1);
         this.#slots = Array.from({ length: count }, (_, index) => ({ index: index, connections: new Map(), opening: 0 }));
         debugHandlerWatchers.add(this.#debugging);
     }
@@ -162,6 +169,9 @@ let PeerThreads = class PeerThreads extends Component {
             return slot.ready;
         const worker = new Worker(peerWorkerCode, {
             eval: true,
+            //Without the options of the command line of the process, which a worker inherits: with --input-type=module, its code
+            //(CommonJS) would run as an ES module
+            execArgv: [],
             workerData: { thread: slot.index },
             ...this.resourceLimits ? { resourceLimits: this.resourceLimits } : {}
         });