@thumbmarkjs/thumbmarkjs 1.3.3 → 1.4.0

package/src/components/mathml/index.ts

@@ -1,5 +1,7 @@
 import { componentInterface } from '../../factory';
 import { hash } from '../../utils/hash';
+import { ephemeralIFrame } from '../../utils/ephemeralIFrame';
+import { stableStringify } from '../../utils/stableStringify';
 
 const BLACKBOARD_BOLD = ['\uD835\uDD04', '\uD835\uDD05', '\u212D', '\uD835\uDD07', '\uD835\uDD08', '\uD835\uDD09', '\uD835\uDD38', '\uD835\uDD39', '\u2102', '\uD835\uDD3B', '\uD835\uDD3C', '\uD835\uDD3D'];
 const GREEK_SYMBOLS = ['\u03B2', '\u03C8', '\u03BB', '\u03B5', '\u03B6', '\u03B1', '\u03BE', '\u03BC', '\u03C1', '\u03C6', '\u03BA', '\u03C4', '\u03B7', '\u03C3', '\u03B9', '\u03C9', '\u03B3', '\u03BD', '\u03C7', '\u03B4', '\u03B8', '\u03C0', '\u03C5', '\u03BF'];
@@ -7,33 +9,58 @@ const GREEK_SYMBOLS = ['\u03B2', '\u03C8', '\u03BB', '\u03B5', '\u03B6', '\u03B1
 export default async function getMathML(): Promise<componentInterface | null> {
   return new Promise((resolve) => {
     try {
-      if (!isMathMLSupported()) {
-        resolve({
-          supported: false,
-          error: 'MathML not supported'
-        });
-        return;
-      }
+      ephemeralIFrame(async ({ iframe }) => {
+        try {
+          if (!isMathMLSupported(iframe)) {
+            resolve({
+              supported: false,
+              error: 'MathML not supported'
+            });
+            return;
+          }
 
-      const structures = [
-        createMathML('integral', '<msubsup><mo>\u222B</mo><mi>a</mi><mi>b</mi></msubsup><mfrac><mrow><mi>f</mi><mo>(</mo><mi>x</mi><mo>)</mo></mrow><mrow><mi>g</mi><mo>(</mo><mi>x</mi><mo>)</mo></mrow></mfrac><mi>dx</mi>'),
-        createMathML('fraction', '<mfrac><mrow><mi>\u03C0</mi><mo>\u00D7</mo><msup><mi>r</mi><mn>2</mn></msup></mrow><mrow><mn>2</mn><mi>\u03C3</mi></mrow></mfrac>'),
-        createMathML('matrix', '<mo>[</mo><mtable><mtr><mtd><mi>\u03B1</mi></mtd><mtd><mi>\u03B2</mi></mtd></mtr><mtr><mtd><mi>\u03B3</mi></mtd><mtd><mi>\u03B4</mi></mtd></mtr></mtable><mo>]</mo>'),
-        createComplexNestedStructure(),
-        ...createSymbolStructures()
-      ];
-
-      const measurements: any = {};
-      structures.forEach((struct, i) => {
-        measurements[`struct_${i}`] = measureMathMLStructure(struct);
-      });
+          const structures = [
+            createMathML('integral', '<msubsup><mo>\u222B</mo><mi>a</mi><mi>b</mi></msubsup><mfrac><mrow><mi>f</mi><mo>(</mo><mi>x</mi><mo>)</mo></mrow><mrow><mi>g</mi><mo>(</mo><mi>x</mi><mo>)</mo></mrow></mfrac><mi>dx</mi>'),
+            createMathML('fraction', '<mfrac><mrow><mi>\u03C0</mi><mo>\u00D7</mo><msup><mi>r</mi><mn>2</mn></msup></mrow><mrow><mn>2</mn><mi>\u03C3</mi></mrow></mfrac>'),
+            createMathML('matrix', '<mo>[</mo><mtable><mtr><mtd><mi>\u03B1</mi></mtd><mtd><mi>\u03B2</mi></mtd></mtr><mtr><mtd><mi>\u03B3</mi></mtd><mtd><mi>\u03B4</mi></mtd></mtr></mtable><mo>]</mo>'),
+            createComplexNestedStructure(),
+            ...createSymbolStructures()
+          ];
 
-      resolve({
-        //supported: true,
-        //measurements,
-        hash: hash(JSON.stringify(measurements))
-      });
+          const dimensionsArray: any[] = [];
+          let fontStyleHash: string = '';
+
+          structures.forEach((struct, i) => {
+            const measurement = measureMathMLStructure(struct, iframe);
+            // Extract dimensions for this structure
+            dimensionsArray.push({
+              width: measurement.dimensions.width,
+              height: measurement.dimensions.height
+            });
+            // Capture font style hash from the first structure (it's the same for all)
+            if (i === 0 && measurement.fontInfo) {
+              fontStyleHash = hash(stableStringify(measurement.fontInfo));
+            }
+          });
 
+          const details = {
+            fontStyleHash,
+            dimensions: dimensionsArray
+          };
+
+          resolve({
+            //supported: true,
+            details,
+            hash: hash(stableStringify(details))
+          });
+
+        } catch (error) {
+          resolve({
+            supported: false,
+            error: `MathML error: ${(error as Error).message}`
+          });
+        }
+      });
     } catch (error) {
       resolve({
         supported: false,
@@ -43,17 +70,17 @@ export default async function getMathML(): Promise<componentInterface | null> {
   });
 }
 
-function isMathMLSupported(): boolean {
+function isMathMLSupported(iframe: Document): boolean {
   try {
-    const testElement = document.createElement('math');
+    const testElement = iframe.createElement('math');
     testElement.innerHTML = '<mrow><mi>x</mi></mrow>';
     testElement.style.position = 'absolute';
     testElement.style.visibility = 'hidden';
-    
-    document.body.appendChild(testElement);
+
+    iframe.body.appendChild(testElement);
     const rect = testElement.getBoundingClientRect();
-    document.body.removeChild(testElement);
-    
+    iframe.body.removeChild(testElement);
+
     return rect.width > 0 && rect.height > 0;
   } catch {
     return false;
@@ -66,7 +93,7 @@ function createMathML(name: string, content: string): string {
 
 function createComplexNestedStructure(): string {
   let nestedContent = '<mo>\u220F</mo>'; // Product symbol (∏)
-  
+
   // Add all symbol combinations inside the main structure
   BLACKBOARD_BOLD.forEach((bbSymbol, bbIndex) => {
     const startIdx = bbIndex * 2;
@@ -76,7 +103,7 @@ function createComplexNestedStructure(): string {
       nestedContent += `<mmultiscripts><mi>${bbSymbol}</mi><none/><mi>${greekSet[1]}</mi><mprescripts></mprescripts><mi>${greekSet[0]}</mi><none/></mmultiscripts>`;
     }
   });
-  
+
   return createMathML('complex_nested',
     `<munderover><mmultiscripts>${nestedContent}</mmultiscripts></munderover>`
   );
@@ -84,7 +111,7 @@ function createComplexNestedStructure(): string {
 
 function createSymbolStructures(): string[] {
   const structures: string[] = [];
-  
+
   // Use blackboard bold as base symbols with Greek symbols as subscripts/superscripts
   BLACKBOARD_BOLD.forEach((bbSymbol, bbIndex) => {
     // Get 2 Greek symbols for this blackboard bold symbol (lower left, top right)
@@ -97,29 +124,30 @@ function createSymbolStructures(): string[] {
       ));
     }
   });
-  
+
   return structures;
 }
 
-function measureMathMLStructure(mathml: string): any {
+function measureMathMLStructure(mathml: string, iframe: Document): any {
   try {
-    const mathElement = document.createElement('math');
+    const mathElement = iframe.createElement('math');
     mathElement.innerHTML = mathml.replace(/<\/?math>/g, '');
     mathElement.style.whiteSpace = 'nowrap';
     mathElement.style.position = 'absolute';
     mathElement.style.visibility = 'hidden';
     mathElement.style.top = '-9999px';
-    
-    document.body.appendChild(mathElement);
-    
+
+    iframe.body.appendChild(mathElement);
+
     const rect = mathElement.getBoundingClientRect();
-    const computedStyle = window.getComputedStyle(mathElement);
-    
+    const iframeWindow = iframe.defaultView || window;
+    const computedStyle = iframeWindow.getComputedStyle(mathElement);
+
     const measurements = {
       dimensions: {
         width: rect.width,
         height: rect.height,
-        
+
       },
       fontInfo: {
         fontFamily: computedStyle.fontFamily,
@@ -129,7 +157,7 @@ function measureMathMLStructure(mathml: string): any {
         lineHeight: computedStyle.lineHeight,
         // Enhanced font properties for better system detection
         fontVariant: computedStyle.fontVariant || 'normal',
-        fontStretch: computedStyle.fontStretch || 'normal', 
+        fontStretch: computedStyle.fontStretch || 'normal',
         fontSizeAdjust: computedStyle.fontSizeAdjust || 'none',
         textRendering: computedStyle.textRendering || 'auto',
         fontFeatureSettings: computedStyle.fontFeatureSettings || 'normal',
@@ -137,10 +165,10 @@ function measureMathMLStructure(mathml: string): any {
         fontKerning: computedStyle.fontKerning || 'auto'
       }
     };
-    
-    document.body.removeChild(mathElement);
+
+    iframe.body.removeChild(mathElement);
     return measurements;
-    
+
   } catch (error) {
     return {
       error: (error as Error).message

package/src/components/permissions/index.ts

@@ -25,13 +25,18 @@ const defaultPermissionKeys: PermissionName[] = [
 ] as PermissionName[];
 
 export default async function getPermissions(options?: optionsInterface): Promise<componentInterface> {
-    let permission_keys = options?.permissions_to_check || defaultPermissionKeys;
+    const permission_keys = options?.permissions_to_check || defaultPermissionKeys;
     const retries = 3;
-    const permissionPromises: Promise<componentInterface>[] = Array.from({length: retries}, () => getBrowserPermissionsOnce(permission_keys) );
-    return Promise.all(permissionPromises).then((resolvedPermissions) => {
-        const permission = mostFrequentValuesInArrayOfDictionaries(resolvedPermissions, permission_keys);
-        return permission;
-    });
+
+    // Run permission checks multiple times
+    const results = await Promise.all(
+        Array.from({ length: retries }, () => getBrowserPermissionsOnce(permission_keys))
+    );
+
+    // Get most frequent values across all retries
+    const permissionStatus = mostFrequentValuesInArrayOfDictionaries(results, permission_keys);
+
+    return permissionStatus;
 }
 
 async function getBrowserPermissionsOnce(permission_keys: PermissionName[]): Promise<componentInterface> {

package/src/components/speech/index.ts

@@ -0,0 +1,104 @@
+import { componentInterface } from '../../factory';
+import { hash } from '../../utils/hash';
+import { stableStringify } from '../../utils/stableStringify';
+
+const VOICE_LOAD_TIMEOUT = 800; // milliseconds to wait for voices to load
+
+export default async function getSpeech(): Promise<componentInterface | null> {
+  return new Promise((resolve) => {
+    try {
+      // Check if Speech Synthesis API is available
+      if (typeof window === 'undefined' || !window.speechSynthesis || typeof window.speechSynthesis.getVoices !== 'function') {
+        resolve({
+          supported: false,
+          error: 'Speech Synthesis API not supported'
+        });
+        return;
+      }
+
+      let voicesResolved = false;
+      let timeoutHandle: ReturnType<typeof setTimeout> | null = null;
+
+      const processVoices = (voices: SpeechSynthesisVoice[]) => {
+        if (voicesResolved) return;
+        voicesResolved = true;
+
+        // Clear timeout if it exists
+        if (timeoutHandle) {
+          clearTimeout(timeoutHandle);
+        }
+
+        try {
+          // Collect voice signatures
+          const voiceSignatures = voices.map((voice) => {
+            // Escape commas and backslashes in voice properties
+            const escapeValue = (value: string): string => {
+              return value.replace(/\\/g, '\\\\').replace(/,/g, '\\,');
+            };
+
+            // Format: voiceURI,name,lang,localService,default
+            const signature = [
+              escapeValue(voice.voiceURI || ''),
+              escapeValue(voice.name || ''),
+              escapeValue(voice.lang || ''),
+              voice.localService ? '1' : '0',
+              voice.default ? '1' : '0'
+            ].join(',');
+
+            return signature;
+          });
+
+          // Sort alphabetically for consistent ordering
+          voiceSignatures.sort();
+
+          // Create details object with count and hash
+          const details = {
+            voiceCount: voices.length,
+            voicesHash: hash(stableStringify(voiceSignatures))
+          };
+
+          resolve({
+            details,
+            hash: hash(stableStringify(details))
+          });
+
+        } catch (error) {
+          resolve({
+            supported: true,
+            error: `Voice processing failed: ${(error as Error).message}`
+          });
+        }
+      };
+
+      // Try to get voices immediately
+      const voices = window.speechSynthesis.getVoices();
+
+      // If voices are available immediately, process them
+      if (voices.length > 0) {
+        processVoices(voices);
+        return;
+      }
+
+      // Set up timeout in case voices never load
+      timeoutHandle = setTimeout(() => {
+        const voices = window.speechSynthesis.getVoices();
+        processVoices(voices);
+      }, VOICE_LOAD_TIMEOUT);
+
+      // Listen for voiceschanged event (for browsers that load voices asynchronously)
+      const onVoicesChanged = () => {
+        window.speechSynthesis.removeEventListener('voiceschanged', onVoicesChanged);
+        const voices = window.speechSynthesis.getVoices();
+        processVoices(voices);
+      };
+
+      window.speechSynthesis.addEventListener('voiceschanged', onVoicesChanged);
+
+    } catch (error) {
+      resolve({
+        supported: false,
+        error: `Speech Synthesis error: ${(error as Error).message}`
+      });
+    }
+  });
+}

package/src/components/webrtc/index.ts

@@ -1,5 +1,6 @@
 import { componentInterface } from '../../factory';
 import { hash } from '../../utils/hash';
+import { stableStringify } from '../../utils/stableStringify';
 
 export default async function getWebRTC(): Promise<componentInterface | null> {
   return new Promise((resolve) => {
@@ -29,7 +30,7 @@ export default async function getWebRTC(): Promise<componentInterface | null> {
           await connection.setLocalDescription(offer);
 
           const sdp = offer.sdp || '';
-          
+
           // Extract RTP extensions
           const extensions = [...new Set((sdp.match(/extmap:\d+ [^\n\r]+/g) || []).map((x: string) => x.replace(/extmap:\d+ /, '')))].sort();
 
@@ -64,9 +65,19 @@ export default async function getWebRTC(): Promise<componentInterface | null> {
             }).filter(Boolean);
           };
 
-          const codecsSdp = {
-            audio: constructDescriptions('audio', getDescriptors('audio')),
-            video: constructDescriptions('video', getDescriptors('video'))
+          const audioCodecs = constructDescriptions('audio', getDescriptors('audio'));
+          const videoCodecs = constructDescriptions('video', getDescriptors('video'));
+
+          const compressedData = {
+            audio: {
+              count: audioCodecs.length,
+              hash: hash(stableStringify(audioCodecs))
+            },
+            video: {
+              count: videoCodecs.length,
+              hash: hash(stableStringify(videoCodecs))
+            },
+            extensionsHash: hash(stableStringify(extensions))
           };
 
           // Set up for ICE candidate collection with timeout
@@ -74,10 +85,9 @@ export default async function getWebRTC(): Promise<componentInterface | null> {
             const timeout = setTimeout(() => {
               connection.removeEventListener('icecandidate', onIceCandidate);
               connection.close();
-              resolveResult({ 
+              resolveResult({
                 supported: true,
-                codecsSdp, 
-                extensions: extensions as string[],
+                ...compressedData,
                 timeout: true
               });
             }, 3000);
@@ -90,10 +100,9 @@ export default async function getWebRTC(): Promise<componentInterface | null> {
               connection.removeEventListener('icecandidate', onIceCandidate);
               connection.close();
 
-              resolveResult({ 
+              resolveResult({
                 supported: true,
-                codecsSdp, 
-                extensions: extensions as string[],
+                ...compressedData,
                 candidateType: candidateObj.type || ''
               });
             };
@@ -102,7 +111,8 @@ export default async function getWebRTC(): Promise<componentInterface | null> {
           });
 
           resolve({
-            hash: hash(JSON.stringify(result)),
+            details: result,
+            hash: hash(stableStringify(result)),
           });
 
         } catch (error) {

package/src/factory.ts

@@ -23,6 +23,7 @@ import getWebGL from "./components/webgl";
 // Import experimental component functions
 import getWebRTC from "./components/webrtc";
 import getMathML from "./components/mathml";
+import getSpeech from "./components/speech";
 
 /**
  * @description key->function map of built-in components. Do not call the function here.
@@ -46,7 +47,8 @@ export const tm_component_promises = {
  */
 export const tm_experimental_component_promises = {
     'webrtc': getWebRTC,
-    'mathml': getMathML
+    'mathml': getMathML,
+    'speech': getSpeech
 };
 
 // the component interface is the form of the JSON object the function's promise must return

package/src/functions/api.ts

@@ -1,8 +1,9 @@
-import { optionsInterface, API_ENDPOINT } from '../options';
+import { optionsInterface, DEFAULT_API_ENDPOINT } from '../options';
 import { componentInterface } from '../factory';
 import { getVisitorId, setVisitorId } from '../utils/visitorId';
 import { getVersion } from "../utils/version";
 import { hash } from '../utils/hash';
+import { stableStringify } from '../utils/stableStringify';
 
 // ===================== Types & Interfaces =====================
 
@@ -37,6 +38,7 @@ interface apiResponse {
     version?: string;
     components?: componentInterface;
     visitorId?: string;
+    thumbmark?: string;
 }
 
 // ===================== API Call Logic =====================
@@ -63,18 +65,19 @@ export const getApiPromise = (
     }
 
     // 3. Otherwise, initiate a new API call with timeout.
-    const endpoint = `${API_ENDPOINT}/thumbmark`;
+    const apiEndpoint = options.api_endpoint || DEFAULT_API_ENDPOINT;
+    const endpoint = `${apiEndpoint}/thumbmark`;
     const visitorId = getVisitorId();
-    const requestBody: any = { 
-        components, 
-        options, 
-        clientHash: hash(JSON.stringify(components)), 
+    const requestBody: any = {
+        components,
+        options,
+        clientHash: hash(stableStringify(components)),
         version: getVersion()
     };
     if (visitorId) {
         requestBody.visitorId = visitorId;
     }
-    
+
     const fetchPromise = fetch(endpoint, {
         method: 'POST',
         headers: {

package/src/functions/index.ts

@@ -7,13 +7,13 @@
  */
 
 import { defaultOptions, optionsInterface } from "../options";
-import { 
-    timeoutInstance,
-    componentInterface,
-    tm_component_promises,
-    customComponents,
-    tm_experimental_component_promises,
-    includeComponent as globalIncludeComponent
+import {
+  timeoutInstance,
+  componentInterface,
+  tm_component_promises,
+  customComponents,
+  tm_experimental_component_promises,
+  includeComponent as globalIncludeComponent
 } from "../factory";
 import { hash } from "../utils/hash";
 import { raceAllPerformance } from "../utils/raceAll";
@@ -21,20 +21,21 @@ import { getVersion } from "../utils/version";
 import { filterThumbmarkData } from './filterComponents'
 import { logThumbmarkData } from '../utils/log';
 import { getApiPromise, infoInterface } from "./api";
+import { stableStringify } from "../utils/stableStringify";
 
 
 /**
  * Final thumbmark response structure
  */
 interface thumbmarkResponse {
-    components: componentInterface,
-    info: { [key: string]: any },
-    version: string,
-    thumbmark: string,
-    visitorId?: string,
-    elapsed?: any;
-    error?: string;
-    experimental?: componentInterface;
+  components: componentInterface,
+  info: { [key: string]: any },
+  version: string,
+  thumbmark: string,
+  visitorId?: string,
+  elapsed?: any;
+  error?: string;
+  experimental?: componentInterface;
 }
 
 /**
@@ -44,66 +45,73 @@ interface thumbmarkResponse {
  * @returns thumbmarkResponse (elapsed is present only if options.performance is true)
  */
 export async function getThumbmark(options?: optionsInterface): Promise<thumbmarkResponse> {
-    const _options = { ...defaultOptions, ...options };
-       
-    // Early logging decision
-    const shouldLog = (_options.logging && !sessionStorage.getItem("_tmjs_l") && Math.random() < 0.0001);
-    
-    // Merge built-in and user-registered components
-    const allComponents = { ...tm_component_promises, ...customComponents };
-    const { elapsed, resolvedComponents: clientComponentsResult } = await resolveClientComponents(allComponents, _options);
-
-    // Resolve experimental components only when logging
-    let experimentalComponents = {};
-    if (shouldLog || _options.experimental) {
-        const { resolvedComponents } = await resolveClientComponents(tm_experimental_component_promises, _options);
-        experimentalComponents = resolvedComponents;
-    }
+  const _options = { ...defaultOptions, ...options };
 
-    const apiPromise = _options.api_key ? getApiPromise(_options, clientComponentsResult) : null;
-    let apiResult = null;
-    
-    if (apiPromise) {
-        try {
-            apiResult = await apiPromise;
-        } catch (error) {
-            // Handle API key/quota errors
-            if (error instanceof Error && error.message === 'INVALID_API_KEY') {
-                return {
-                    error: 'Invalid API key or quota exceeded',
-                    components: {},
-                    info: {},
-                    version: getVersion(),
-                    thumbmark: ''
-                };
-            }
-            throw error; // Re-throw other errors
-        }
-    }
+  // Early logging decision
+  const shouldLog = (_options.logging && !sessionStorage.getItem("_tmjs_l") && Math.random() < 0.0001);
+
+  // Merge built-in and user-registered components
+  const allComponents = { ...tm_component_promises, ...customComponents };
+  const { elapsed, resolvedComponents: clientComponentsResult } = await resolveClientComponents(allComponents, _options);
+
+  // Resolve experimental components only when logging
+  let experimentalComponents = {};
+  let experimentalElapsed = {};
+  if (shouldLog || _options.experimental) {
+    const { elapsed: expElapsed, resolvedComponents } = await resolveClientComponents(tm_experimental_component_promises, _options);
+    experimentalComponents = resolvedComponents;
+    experimentalElapsed = expElapsed;
+  }
+
+  const apiPromise = _options.api_key ? getApiPromise(_options, clientComponentsResult) : null;
+  let apiResult = null;
 
-    // Only add 'elapsed' if performance is true
-    const maybeElapsed = _options.performance ? { elapsed } : {};
-    const apiComponents = filterThumbmarkData(apiResult?.components || {}, _options);
-    const components = {...clientComponentsResult, ...apiComponents};
-    const info: infoInterface = apiResult?.info || { uniqueness: { score: 'api only' } };
-    const thumbmark = hash(JSON.stringify(components));
-    const version = getVersion();
-    // Only log to server when not in debug mode
-    if (shouldLog) {
-        logThumbmarkData(thumbmark, components, _options, experimentalComponents).catch(() => { /* do nothing */ });
+  if (apiPromise) {
+    try {
+      apiResult = await apiPromise;
+    } catch (error) {
+      // Handle API key/quota errors
+      if (error instanceof Error && error.message === 'INVALID_API_KEY') {
+        return {
+          error: 'Invalid API key or quota exceeded',
+          components: {},
+          info: {},
+          version: getVersion(),
+          thumbmark: ''
+        };
+      }
+      throw error; // Re-throw other errors
     }
-    
-    const result: thumbmarkResponse = {
-        ...(apiResult?.visitorId && { visitorId: apiResult.visitorId }),
-        thumbmark,
-        components: components,
-        info,
-        version,
-        ...maybeElapsed,
-        ...(Object.keys(experimentalComponents).length > 0 && _options.experimental && { experimental: experimentalComponents }),
-    };
-    
-    return result;
+  }
+
+  // Only add 'elapsed' if performance is true
+  const allElapsed = { ...elapsed, ...experimentalElapsed };
+  const maybeElapsed = _options.performance ? { elapsed: allElapsed } : {};
+  const apiComponents = filterThumbmarkData(apiResult?.components || {}, _options);
+  const components = { ...clientComponentsResult, ...apiComponents };
+  const info: infoInterface = apiResult?.info || { uniqueness: { score: 'api only' } };
+
+  // Use API thumbmark if available to ensure API/client sync, otherwise calculate locally
+  console.log(apiResult);
+  const thumbmark = apiResult?.thumbmark ?? hash(stableStringify(components));
+  const version = getVersion();
+
+  // Only log to server when not in debug mode
+  if (shouldLog) {
+    logThumbmarkData(thumbmark, components, _options, experimentalComponents).catch(() => { /* do nothing */ });
+  }
+
+  const result: thumbmarkResponse = {
+    ...(apiResult?.visitorId && { visitorId: apiResult.visitorId }),
+    thumbmark,
+    components: components,
+    info,
+    version,
+    ...maybeElapsed,
+    ...(Object.keys(experimentalComponents).length > 0 && _options.experimental && { experimental: experimentalComponents }),
+  };
+
+  return result;
 }
 
 // ===================== Component Resolution & Performance =====================