@thumbmarkjs/thumbmarkjs 1.8.1 → 1.9.1

package/src/components/webgl/index.test.ts

@@ -0,0 +1,223 @@
+import getWebGL, { __resetWebGLCache, __getWebGLCache } from './index';
+
+// ---------------------------------------------------------------------------
+// Mock ImageData — jsdom does not provide a real implementation
+// ---------------------------------------------------------------------------
+class MockImageData {
+    data: Uint8ClampedArray;
+    width: number;
+    height: number;
+
+    constructor(dataOrWidth: Uint8ClampedArray | number, widthOrUndefined?: number, height?: number) {
+        if (dataOrWidth instanceof Uint8ClampedArray) {
+            this.data = dataOrWidth;
+            this.width = widthOrUndefined ?? 1;
+            this.height = height ?? 1;
+        } else {
+            const w = dataOrWidth as number;
+            const h = widthOrUndefined ?? 1;
+            this.data = new Uint8ClampedArray(w * h * 4);
+            this.width = w;
+            this.height = h;
+        }
+    }
+}
+(global as any).ImageData = MockImageData;
+
+// ---------------------------------------------------------------------------
+// WebGL mock factory — returns an object satisfying setupWebGL() and renderImage()
+// ---------------------------------------------------------------------------
+function makeGlMock(overrides: Partial<WebGLRenderingContext> = {}): WebGLRenderingContext {
+    const gl: any = {
+        VERTEX_SHADER: 35633,
+        FRAGMENT_SHADER: 35632,
+        ARRAY_BUFFER: 34962,
+        COMPILE_STATUS: 35713,
+        LINK_STATUS: 35714,
+        RGBA: 6408,
+        UNSIGNED_BYTE: 5121,
+        COLOR_BUFFER_BIT: 16384,
+        FLOAT: 5126,
+        LINES: 1,
+        drawingBufferWidth: 200,
+        drawingBufferHeight: 100,
+        createShader: jest.fn().mockReturnValue({}),
+        shaderSource: jest.fn(),
+        compileShader: jest.fn(),
+        getShaderParameter: jest.fn().mockReturnValue(true),
+        createProgram: jest.fn().mockReturnValue({}),
+        attachShader: jest.fn(),
+        linkProgram: jest.fn(),
+        getProgramParameter: jest.fn().mockReturnValue(true),
+        createBuffer: jest.fn().mockReturnValue({}),
+        bindBuffer: jest.fn(),
+        bufferData: jest.fn(),
+        useProgram: jest.fn(),
+        getAttribLocation: jest.fn().mockReturnValue(0),
+        enableVertexAttribArray: jest.fn(),
+        vertexAttribPointer: jest.fn(),
+        viewport: jest.fn(),
+        clearColor: jest.fn(),
+        clear: jest.fn(),
+        drawArrays: jest.fn(),
+        readPixels: jest.fn(),
+        ...overrides,
+    };
+    return gl as WebGLRenderingContext;
+}
+
+// ---------------------------------------------------------------------------
+// Suite setup
+// ---------------------------------------------------------------------------
+let originalGetContext: any;
+
+beforeAll(() => {
+    originalGetContext = HTMLCanvasElement.prototype.getContext;
+});
+
+afterAll(() => {
+    HTMLCanvasElement.prototype.getContext = originalGetContext;
+});
+
+beforeEach(() => {
+    __resetWebGLCache();
+});
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe('webgl component — context-loss recovery', () => {
+
+    // Happy path: cache is populated after first successful call
+    test('first getWebGL() call populates the cache', async () => {
+        HTMLCanvasElement.prototype.getContext = jest.fn().mockReturnValue(makeGlMock()) as any;
+
+        await getWebGL();
+
+        expect(__getWebGLCache()).not.toBeNull();
+    });
+
+    // Cache reuse: two calls share the same canvas object
+    test('two consecutive getWebGL() calls reuse the same cached canvas', async () => {
+        HTMLCanvasElement.prototype.getContext = jest.fn().mockReturnValue(makeGlMock()) as any;
+
+        await getWebGL();
+        const cacheAfterFirst = __getWebGLCache();
+        expect(cacheAfterFirst).not.toBeNull();
+
+        await getWebGL();
+        const cacheAfterSecond = __getWebGLCache();
+
+        // Same object reference — no new canvas was created
+        expect(cacheAfterSecond).toBe(cacheAfterFirst);
+        // getContext called exactly once (canvas created once)
+        expect(HTMLCanvasElement.prototype.getContext).toHaveBeenCalledTimes(1);
+    });
+
+    // Context-loss listener: dispatching webglcontextlost clears the cache
+    test('webglcontextlost event clears the cache', async () => {
+        HTMLCanvasElement.prototype.getContext = jest.fn().mockReturnValue(makeGlMock()) as any;
+
+        await getWebGL();
+        const cacheBeforeLoss = __getWebGLCache();
+        expect(cacheBeforeLoss).not.toBeNull();
+
+        // Fire the context-lost event on the cached canvas
+        cacheBeforeLoss!.canvas.dispatchEvent(new Event('webglcontextlost', { cancelable: true }));
+
+        expect(__getWebGLCache()).toBeNull();
+    });
+
+    // Context-loss listener: event.preventDefault() is called
+    test('webglcontextlost listener calls event.preventDefault()', async () => {
+        HTMLCanvasElement.prototype.getContext = jest.fn().mockReturnValue(makeGlMock()) as any;
+
+        await getWebGL();
+        const cache = __getWebGLCache();
+        expect(cache).not.toBeNull();
+
+        const lostEvent = new Event('webglcontextlost', { cancelable: true });
+        const preventDefaultSpy = jest.spyOn(lostEvent, 'preventDefault');
+
+        cache!.canvas.dispatchEvent(lostEvent);
+
+        expect(preventDefaultSpy).toHaveBeenCalledTimes(1);
+    });
+
+    // After context loss, next getWebGL() call creates a NEW canvas
+    test('getWebGL() after context loss rebuilds the cache via a new canvas', async () => {
+        const gl = makeGlMock();
+        HTMLCanvasElement.prototype.getContext = jest.fn().mockReturnValue(gl) as any;
+
+        await getWebGL();
+        const firstCache = __getWebGLCache();
+        expect(firstCache).not.toBeNull();
+
+        // Simulate context loss
+        firstCache!.canvas.dispatchEvent(new Event('webglcontextlost', { cancelable: true }));
+        expect(__getWebGLCache()).toBeNull();
+
+        // Reset mock call count, re-install for rebuild
+        HTMLCanvasElement.prototype.getContext = jest.fn().mockReturnValue(gl) as any;
+
+        await getWebGL();
+        const secondCache = __getWebGLCache();
+        expect(secondCache).not.toBeNull();
+        // A fresh cache object is created — different reference from the lost one
+        expect(secondCache).not.toBe(firstCache);
+        // getContext called once for the rebuild (new canvas)
+        expect(HTMLCanvasElement.prototype.getContext).toHaveBeenCalledTimes(1);
+    });
+
+    // once: true — the listener fires at most once per canvas
+    test('webglcontextlost listener fires only once (once:true)', async () => {
+        HTMLCanvasElement.prototype.getContext = jest.fn().mockReturnValue(makeGlMock()) as any;
+
+        await getWebGL();
+        const firstCache = __getWebGLCache();
+        const canvas = firstCache!.canvas;
+
+        // First dispatch: clears cache
+        canvas.dispatchEvent(new Event('webglcontextlost', { cancelable: true }));
+        expect(__getWebGLCache()).toBeNull();
+
+        // Second dispatch on the same canvas — listener already removed (once:true),
+        // so _cache remains null (unchanged) and no throw occurs
+        expect(() => {
+            canvas.dispatchEvent(new Event('webglcontextlost', { cancelable: true }));
+        }).not.toThrow();
+        expect(__getWebGLCache()).toBeNull();
+    });
+
+    // renderImage catch block: render failure clears the cache
+    test('render failure (useProgram throws) clears the cache', async () => {
+        HTMLCanvasElement.prototype.getContext = jest.fn().mockReturnValue(makeGlMock()) as any;
+
+        // First call populates cache
+        await getWebGL();
+        expect(__getWebGLCache()).not.toBeNull();
+
+        // Patch the cached gl to throw on the next render
+        const cache = __getWebGLCache()!;
+        (cache as any).gl.useProgram = jest.fn().mockImplementation(() => {
+            throw new Error('WebGL context lost');
+        });
+
+        // The call should not throw; it should return the 'unsupported' fallback
+        const result = await getWebGL();
+        expect(result).toEqual({ webgl: 'unsupported' });
+
+        // Cache must have been cleared by the catch block
+        expect(__getWebGLCache()).toBeNull();
+    });
+
+    // Graceful degradation: getContext returns null → returns 'unsupported'
+    test('getWebGL() returns unsupported when WebGL context is unavailable', async () => {
+        HTMLCanvasElement.prototype.getContext = jest.fn().mockReturnValue(null) as any;
+
+        const result = await getWebGL();
+
+        expect(result).toEqual({ webgl: 'unsupported' });
+        expect(__getWebGLCache()).toBeNull();
+    });
+});

package/src/components/webgl/index.ts

@@ -1,146 +1,188 @@
-import { componentInterface, includeComponent } from '../../factory'
-import { hash } from '../../utils/hash'
-import { getCommonPixels } from '../../utils/commonPixels';
-import { getBrowser } from '../system/browser';
-
-const _RUNS = (getBrowser().name !== 'SamsungBrowser') ? 1 : 3;
-let canvas: HTMLCanvasElement
-let gl: WebGLRenderingContext | null = null;
-
-function initializeCanvasAndWebGL() {
-  if (typeof document !== 'undefined') {
-    canvas = document.createElement('canvas');
-    canvas.width = 200;
-    canvas.height = 100;
-    gl = canvas.getContext('webgl');
-  }
-}
-
-export default async function getWebGL(): Promise<componentInterface> {
-  initializeCanvasAndWebGL();
-  
-  try {
-
-    if (!gl) {
-        throw new Error('WebGL not supported');
-    }
-
-
-    const imageDatas: ImageData[] = Array.from({length: _RUNS}, () => createWebGLImageData() );
-    // and then checking the most common bytes for each channel of each pixel
-    const commonImageData = getCommonPixels(imageDatas, canvas.width, canvas.height);
-    //const imageData = createWebGLImageData()
-
-    return {
-      'commonPixelsHash': hash(commonImageData.data.toString()).toString(),
-    }
-  } catch (error) {
-    return {
-      'webgl': 'unsupported'
-    }
-  }
-}
-
-function createWebGLImageData(): ImageData {
-  try {
-
-      if (!gl) {
-          throw new Error('WebGL not supported');
-      }
-
-      const vertexShaderSource = `
-          attribute vec2 position;
-          void main() {
-              gl_Position = vec4(position, 0.0, 1.0);
-          }
-      `;
-
-      const fragmentShaderSource = `
-          precision mediump float;
-          void main() {
-              gl_FragColor = vec4(0.812, 0.195, 0.553, 0.921); // Set line color
-          }
-      `;
-
-      const vertexShader = gl.createShader(gl.VERTEX_SHADER);
-      const fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);
-
-      if (!vertexShader || !fragmentShader) {
-          throw new Error('Failed to create shaders');
-      }
-
-      gl.shaderSource(vertexShader, vertexShaderSource);
-      gl.shaderSource(fragmentShader, fragmentShaderSource);
-
-      gl.compileShader(vertexShader);
-      if (!gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS)) {
-          throw new Error('Vertex shader compilation failed: ' + gl.getShaderInfoLog(vertexShader));
-      }
-
-      gl.compileShader(fragmentShader);
-      if (!gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS)) {
-          throw new Error('Fragment shader compilation failed: ' + gl.getShaderInfoLog(fragmentShader));
-      }
-
-      const shaderProgram = gl.createProgram();
-
-      if (!shaderProgram) {
-          throw new Error('Failed to create shader program');
-      }
-
-      gl.attachShader(shaderProgram, vertexShader);
-      gl.attachShader(shaderProgram, fragmentShader);
-      gl.linkProgram(shaderProgram);
-      if (!gl.getProgramParameter(shaderProgram, gl.LINK_STATUS)) {
-          throw new Error('Shader program linking failed: ' + gl.getProgramInfoLog(shaderProgram));
-      }
-
-      gl.useProgram(shaderProgram);
-
-      // Set up vertices to form lines
-      const numSpokes: number = 137;
-      const vertices = new Float32Array(numSpokes * 4);
-      const angleIncrement = (2 * Math.PI) / numSpokes;
-
-      for (let i = 0; i < numSpokes; i++) {
-          const angle = i * angleIncrement;
-
-          // Define two points for each line (spoke)
-          vertices[i * 4] = 0; // Center X
-          vertices[i * 4 + 1] = 0; // Center Y
-          vertices[i * 4 + 2] = Math.cos(angle) * (canvas.width / 2); // Endpoint X
-          vertices[i * 4 + 3] = Math.sin(angle) * (canvas.height / 2); // Endpoint Y
-      }
-
-      const vertexBuffer = gl.createBuffer();
-      gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer);
-      gl.bufferData(gl.ARRAY_BUFFER, vertices, gl.STATIC_DRAW);
-
-      const positionAttribute = gl.getAttribLocation(shaderProgram, 'position');
-      gl.enableVertexAttribArray(positionAttribute);
-      gl.vertexAttribPointer(positionAttribute, 2, gl.FLOAT, false, 0, 0);
-
-      // Render
-      gl.viewport(0, 0, canvas.width, canvas.height);
-      gl.clearColor(0.0, 0.0, 0.0, 1.0);
-      gl.clear(gl.COLOR_BUFFER_BIT);
-      gl.drawArrays(gl.LINES, 0, numSpokes * 2);
-
-      const pixelData = new Uint8ClampedArray(canvas.width * canvas.height * 4);
-      gl.readPixels(0, 0, canvas.width, canvas.height, gl.RGBA, gl.UNSIGNED_BYTE, pixelData);
-      const imageData = new ImageData(pixelData, canvas.width, canvas.height);
-
-      return imageData;
-  } catch (error) {
-      //console.error(error);
-      return new ImageData(1, 1);
-  } finally {
-    if (gl) {
-      // Reset WebGL state
-      gl.bindBuffer(gl.ARRAY_BUFFER, null);
-      gl.useProgram(null);
-      gl.viewport(0, 0, gl.drawingBufferWidth, gl.drawingBufferHeight);
-      gl.clearColor(0.0, 0.0, 0.0, 0.0);
-    }
-  }
-}
+import { componentInterface } from '../../factory'
+import { hash } from '../../utils/hash'
+import { getCommonPixels } from '../../utils/commonPixels';
+import { getBrowser } from '../system/browser';
+
+const _RUNS = (getBrowser().name !== 'SamsungBrowser') ? 1 : 3;
+const _USE_CACHE = getBrowser().name !== 'Brave';
+
+// Canvas and viewport dimensions — part of the fingerprint signal, do not change.
+const _CANVAS_W = 200;
+const _CANVAS_H = 100;
+const _NUM_SPOKES = 137;
+
+// Shader sources are constant — hoist to module scope to avoid per-call string allocation.
+const _VERTEX_SHADER_SRC = `
+    attribute vec2 position;
+    void main() {
+        gl_Position = vec4(position, 0.0, 1.0);
+    }
+`;
+
+const _FRAGMENT_SHADER_SRC = `
+    precision mediump float;
+    void main() {
+        gl_FragColor = vec4(0.812, 0.195, 0.553, 0.921); // Set line color
+    }
+`;
+
+// Precompute the spoke vertices once at module load. The values are determined
+// solely by _NUM_SPOKES, _CANVAS_W, and _CANVAS_H — all module constants —
+// so they are identical to what the old per-call computation produced.
+const _VERTICES: Float32Array = (() => {
+    const v = new Float32Array(_NUM_SPOKES * 4);
+    const angleIncrement = (2 * Math.PI) / _NUM_SPOKES;
+    for (let i = 0; i < _NUM_SPOKES; i++) {
+        const angle = i * angleIncrement;
+        v[i * 4]     = 0;                                  // Center X
+        v[i * 4 + 1] = 0;                                  // Center Y
+        v[i * 4 + 2] = Math.cos(angle) * (_CANVAS_W / 2); // Endpoint X
+        v[i * 4 + 3] = Math.sin(angle) * (_CANVAS_H / 2); // Endpoint Y
+    }
+    return v;
+})();
+
+interface WebGLCache {
+    canvas: HTMLCanvasElement;
+    gl: WebGLRenderingContext;
+    program: WebGLProgram;
+    buffer: WebGLBuffer;
+}
+
+// Module-scope cache — only populated when _USE_CACHE is true (non-Brave).
+let _cache: WebGLCache | null = null;
+
+/** Test-only: reset the module-scope cache between test runs. */
+export function __resetWebGLCache(): void {
+    _cache = null;
+}
+
+/** Test-only: read the current cache reference without mutating it. */
+export function __getWebGLCache(): WebGLCache | null {
+    return _cache;
+}
+
+/**
+ * Create a canvas, compile shaders, link program, and upload vertex data.
+ * Returns null if any step fails so callers can degrade gracefully.
+ */
+function setupWebGL(): WebGLCache | null {
+    try {
+        if (typeof document === 'undefined') return null;
+
+        const canvas = document.createElement('canvas');
+        canvas.width = _CANVAS_W;
+        canvas.height = _CANVAS_H;
+
+        const gl = canvas.getContext('webgl');
+        if (!gl) return null;
+
+        // When the browser invalidates GPU resources it fires webglcontextlost.
+        // Null the cache so the next getOrInitCache() rebuilds via a fresh setupWebGL().
+        // { once: true } ensures the listener self-removes after firing so the old
+        // canvas does not keep the WebGLCache object alive after recovery.
+        canvas.addEventListener('webglcontextlost', (event) => {
+            event.preventDefault();
+            _cache = null;
+        }, { once: true });
+
+        const vertexShader = gl.createShader(gl.VERTEX_SHADER);
+        const fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);
+        if (!vertexShader || !fragmentShader) return null;
+
+        gl.shaderSource(vertexShader, _VERTEX_SHADER_SRC);
+        gl.compileShader(vertexShader);
+        if (!gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS)) return null;
+
+        gl.shaderSource(fragmentShader, _FRAGMENT_SHADER_SRC);
+        gl.compileShader(fragmentShader);
+        if (!gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS)) return null;
+
+        const program = gl.createProgram();
+        if (!program) return null;
+
+        gl.attachShader(program, vertexShader);
+        gl.attachShader(program, fragmentShader);
+        gl.linkProgram(program);
+        if (!gl.getProgramParameter(program, gl.LINK_STATUS)) return null;
+
+        const buffer = gl.createBuffer();
+        if (!buffer) return null;
+
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        gl.bufferData(gl.ARRAY_BUFFER, _VERTICES, gl.STATIC_DRAW);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+
+        return { canvas, gl, program, buffer };
+    } catch (_) {
+        return null;
+    }
+}
+
+/**
+ * For non-Brave browsers: lazily initialise once and reuse.
+ * For Brave: always create fresh (Brave farbles WebGL per-context, preserving
+ * the noise signal that today's per-call setup drives).
+ */
+function getOrInitCache(): WebGLCache | null {
+    if (_USE_CACHE) {
+        if (!_cache) _cache = setupWebGL();
+        return _cache;
+    }
+    // Brave path: fresh context every call, byte-identical behaviour to pre-cache code.
+    return setupWebGL();
+}
+
+/**
+ * Execute one render pass on the shared (or fresh) WebGL context and return
+ * the raw pixel data as an ImageData. Returns a 1×1 blank ImageData on error.
+ */
+function renderImage(cache: WebGLCache): ImageData {
+    const { canvas, gl, program, buffer } = cache;
+    try {
+        gl.useProgram(program);
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+
+        const positionAttribute = gl.getAttribLocation(program, 'position');
+        gl.enableVertexAttribArray(positionAttribute);
+        gl.vertexAttribPointer(positionAttribute, 2, gl.FLOAT, false, 0, 0);
+
+        gl.viewport(0, 0, canvas.width, canvas.height);
+        gl.clearColor(0.0, 0.0, 0.0, 1.0);
+        gl.clear(gl.COLOR_BUFFER_BIT);
+        gl.drawArrays(gl.LINES, 0, _NUM_SPOKES * 2);
+
+        const pixelData = new Uint8ClampedArray(canvas.width * canvas.height * 4);
+        gl.readPixels(0, 0, canvas.width, canvas.height, gl.RGBA, gl.UNSIGNED_BYTE, pixelData);
+        return new ImageData(pixelData, canvas.width, canvas.height);
+    } catch (_) {
+        // Belt-and-suspenders: any render failure (context loss, GPU driver glitch, etc.)
+        // invalidates the cache so the next call rebuilds rather than retrying with a stale context.
+        _cache = null;
+        return new ImageData(1, 1);
+    } finally {
+        // Reset WebGL state to match pre-cache behaviour.
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        gl.useProgram(null);
+        gl.viewport(0, 0, gl.drawingBufferWidth, gl.drawingBufferHeight);
+        gl.clearColor(0.0, 0.0, 0.0, 0.0);
+    }
+}
+
+export default async function getWebGL(): Promise<componentInterface> {
+    const cache = getOrInitCache();
+
+    if (!cache) {
+        return { 'webgl': 'unsupported' };
+    }
+
+    try {
+        const imageDatas: ImageData[] = Array.from({ length: _RUNS }, () => renderImage(cache));
+        const commonImageData = getCommonPixels(imageDatas, cache.canvas.width, cache.canvas.height);
+        return {
+            'commonPixelsHash': hash(commonImageData.data.toString()).toString(),
+        };
+    } catch (_) {
+        return { 'webgl': 'unsupported' };
+    }
+}

package/src/components/webrtc/index.ts

@@ -5,6 +5,7 @@ import { stableStringify } from '../../utils/stableStringify';
 
 export default async function getWebRTC(options?: optionsInterface): Promise<componentInterface | null> {
   return new Promise((resolve) => {
+    let connection: RTCPeerConnection | undefined;
     try {
       // Check if WebRTC is supported
       const RTCPeerConnection = (window as any).RTCPeerConnection || (window as any).webkitRTCPeerConnection || (window as any).mozRTCPeerConnection;
@@ -21,14 +22,17 @@ export default async function getWebRTC(options?: optionsInterface): Promise<com
         iceServers: []
       };
 
-      const connection = new RTCPeerConnection(config);
-      connection.createDataChannel(''); // trigger ICE gathering
+      connection = new RTCPeerConnection(config);
+      // Non-null assertion: connection was just assigned above; if the constructor
+      // had thrown we would not reach this line.
+      const conn: RTCPeerConnection = connection!;
+      conn.createDataChannel(''); // trigger ICE gathering
 
       const processOffer = async () => {
         try {
           const offerOptions = { offerToReceiveAudio: true, offerToReceiveVideo: true };
-          const offer = await connection.createOffer(offerOptions);
-          await connection.setLocalDescription(offer);
+          const offer = await conn.createOffer(offerOptions);
+          await conn.setLocalDescription(offer);
 
           const sdp = offer.sdp || '';
 
@@ -81,39 +85,11 @@ export default async function getWebRTC(options?: optionsInterface): Promise<com
             extensionsHash: hash(stableStringify(extensions))
           };
 
-          // Set up for ICE candidate collection with timeout
-          // Use 60% of the total timeout to ensure this completes before the global timeout
-          const totalTimeout = options?.timeout || 5000;
-          const iceTimeout = Math.floor(totalTimeout * 0.9);
-
-          const result = await new Promise<componentInterface>((resolveResult) => {
-            const timeout = setTimeout(() => {
-              connection.removeEventListener('icecandidate', onIceCandidate);
-              connection.close();
-              resolveResult({
-                supported: true,
-                ...compressedData,
-                timeout: true
-              });
-            }, iceTimeout);
-
-            const onIceCandidate = (event: RTCPeerConnectionIceEvent) => {
-              const candidateObj = event.candidate;
-              if (!candidateObj || !candidateObj.candidate) return;
-
-              clearTimeout(timeout);
-              connection.removeEventListener('icecandidate', onIceCandidate);
-              connection.close();
-
-              resolveResult({
-                supported: true,
-                ...compressedData,
-                candidateType: candidateObj.type || ''
-              });
-            };
-
-            connection.addEventListener('icecandidate', onIceCandidate);
-          });
+          // With iceServers:[] only "host" candidates are generated, so waiting for
+          // the icecandidate event adds latency without any entropy gain. Close
+          // immediately and hard-code the known value to keep the hash stable.
+          conn.close();
+          const result = { supported: true, ...compressedData, candidateType: 'host' };
 
           resolve({
             details: result,
@@ -121,7 +97,7 @@ export default async function getWebRTC(options?: optionsInterface): Promise<com
           });
 
         } catch (error) {
-          connection.close();
+          conn.close();
           resolve({
             supported: true,
             error: `WebRTC offer failed: ${(error as Error).message}`
@@ -132,6 +108,7 @@ export default async function getWebRTC(options?: optionsInterface): Promise<com
       processOffer();
 
     } catch (error) {
+      connection?.close();
       resolve({
         supported: false,
         error: `WebRTC error: ${(error as Error).message}`