@jshookmcp/jshook 0.2.1 → 0.2.3

package/dist/src/server/domains/browser/handlers/captcha-solver.js

@@ -2,7 +2,7 @@ import { argString, argNumber, argBool } from '../../../domains/shared/parse-arg
 import { logger } from '../../../../utils/logger.js';
 import { CAPTCHA_SOLVER_BASE_URL, CAPTCHA_SUBMIT_TIMEOUT_MS, CAPTCHA_POLL_INTERVAL_MS, CAPTCHA_RESULT_TIMEOUT_MS, CAPTCHA_DEFAULT_TIMEOUT_MS, CAPTCHA_MIN_TIMEOUT_MS, CAPTCHA_MAX_TIMEOUT_MS, CAPTCHA_MAX_RETRIES, CAPTCHA_DEFAULT_RETRIES, } from '../../../../constants.js';
 function sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
+    return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function toTextResponse(payload) {
     return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }] };
@@ -86,7 +86,7 @@ async function solveWith2Captcha(apiKey, params, timeoutMs) {
         body: JSON.stringify(submitBody),
         signal: AbortSignal.timeout(CAPTCHA_SUBMIT_TIMEOUT_MS),
     });
-    const submitData = await submitRes.json();
+    const submitData = (await submitRes.json());
     if (submitData.status !== 1) {
         throw new Error(`2captcha submit failed: ${JSON.stringify(submitData)}`);
     }
@@ -107,7 +107,7 @@ async function solveWith2Captcha(apiKey, params, timeoutMs) {
         const resultRes = await fetch(resultUrl.toString(), {
             signal: AbortSignal.timeout(CAPTCHA_RESULT_TIMEOUT_MS),
         });
-        const resultData = await resultRes.json();
+        const resultData = (await resultRes.json());
         if (resultData.status === 1) {
             return {
                 token: resultData.request,
@@ -235,20 +235,23 @@ export async function handleWidgetChallengeSolve(args, collector) {
     let siteKey = argString(args, 'siteKey');
     const pageUrl = argString(args, 'pageUrl', '') || page.url();
     if (!siteKey) {
-        siteKey = await page.evaluate(() => {
-            const el = document.querySelector('.cf-turnstile[data-sitekey], [data-sitekey]');
-            return el?.getAttribute('data-sitekey') ?? '';
-        }) || undefined;
+        siteKey =
+            (await page.evaluate(() => {
+                const el = document.querySelector('.cf-turnstile[data-sitekey], [data-sitekey]');
+                return el?.getAttribute('data-sitekey') ?? '';
+            })) || undefined;
     }
     if (!siteKey) {
         return toErrorResponse('widget_challenge_solve', new Error('Could not detect the widget siteKey. Provide it manually or ensure the page exposes a site key.'));
     }
     if (mode === 'hook') {
         const hookTimeoutMs = Math.min(timeoutMs, 30_000);
-        const token = await page.evaluate((hookTimeout) => {
+        const token = await page
+            .evaluate((hookTimeout) => {
             return new Promise((resolve, reject) => {
                 const timeout = setTimeout(() => reject(new Error('Hook timeout')), hookTimeout);
-                const origCallbacks = window.__turnstile_callbacks;
+                const origCallbacks = window
+                    .__turnstile_callbacks;
                 if (origCallbacks) {
                     for (const [key, cb] of Object.entries(origCallbacks)) {
                         origCallbacks[key] = (token) => {
@@ -263,7 +266,8 @@ export async function handleWidgetChallengeSolve(args, collector) {
                     reject(new Error('No widget callbacks found. Try external_service mode instead.'));
                 }
             });
-        }, hookTimeoutMs).catch(() => null);
+        }, hookTimeoutMs)
+            .catch(() => null);
         if (token) {
             return toTextResponse({
                 success: true,

package/dist/src/server/domains/browser/handlers/facade-initializer.d.ts

@@ -3,9 +3,9 @@ import type { PageController } from '../../../domains/shared/modules.js';
 import type { DOMInspector } from '../../../domains/shared/modules.js';
 import type { ScriptManager } from '../../../domains/shared/modules.js';
 import type { ConsoleMonitor } from '../../../domains/shared/modules.js';
-import { AICaptchaDetector } from '../../../domains/shared/modules.js';
-import { DetailedDataManager } from '../../../../utils/DetailedDataManager.js';
-import { CamoufoxBrowserManager } from '../../../domains/shared/modules.js';
+import { type AICaptchaDetector } from '../../../domains/shared/modules.js';
+import { type DetailedDataManager } from '../../../../utils/DetailedDataManager.js';
+import { type CamoufoxBrowserManager } from '../../../domains/shared/modules.js';
 import { BrowserControlHandlers } from '../../../domains/browser/handlers/browser-control.js';
 import { CamoufoxBrowserHandlers } from '../../../domains/browser/handlers/camoufox-browser.js';
 import { PageNavigationHandlers } from '../../../domains/browser/handlers/page-navigation.js';

package/dist/src/server/domains/browser/handlers/facade-initializer.js

@@ -1,3 +1,6 @@
+import {} from '../../../domains/shared/modules.js';
+import {} from '../../../../utils/DetailedDataManager.js';
+import {} from '../../../domains/shared/modules.js';
 import { BrowserControlHandlers } from '../../../domains/browser/handlers/browser-control.js';
 import { CamoufoxBrowserHandlers } from '../../../domains/browser/handlers/camoufox-browser.js';
 import { PageNavigationHandlers } from '../../../domains/browser/handlers/page-navigation.js';

package/dist/src/server/domains/browser/handlers/framework-state.js

@@ -1,4 +1,5 @@
 import { argString, argNumber } from '../../../domains/shared/parse-args.js';
+import { PrerequisiteError } from '../../../../errors/PrerequisiteError.js';
 export class FrameworkStateHandlers {
     deps;
     constructor(deps) {
@@ -10,7 +11,19 @@ export class FrameworkStateHandlers {
         const maxDepth = argNumber(args, 'maxDepth', 5);
         try {
             const page = (await this.deps.getActivePage());
-            const result = await page.evaluate((opts) => {
+            try {
+                const cdp = await page.createCDPSession();
+                await Promise.race([
+                    cdp.send('Runtime.evaluate', { expression: '1', returnByValue: true }),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error('cdp_unreachable')), 3000)),
+                ]);
+            }
+            catch {
+                throw new PrerequisiteError('CDP session unresponsive — the debugger may be blocking page evaluation. ' +
+                    'Call debugger_disable() before framework_state_extract, or run it before debugger_enable.');
+            }
+            const evalPromise = page.evaluate((opts) => {
+                const win = window;
                 function safeSerialize(val, depth = 0) {
                     if (depth > 4)
                         return '[deep]';
@@ -158,13 +171,200 @@ export class FrameworkStateHandlers {
                     visitVm(vm, 0);
                     return states;
                 };
+                const extractSvelte = () => {
+                    const states = [];
+                    const visited = new WeakSet();
+                    const svelteEls = document.querySelectorAll('[class]');
+                    const candidates = [getRootEl(), ...Array.from(svelteEls)];
+                    let foundAny = false;
+                    for (const el of candidates) {
+                        const obj = el;
+                        const keys = Object.keys(obj);
+                        const hasSvelte = keys.some((k) => k === '$$' || k === '__svelte_meta' || k.startsWith('__s'));
+                        if (!hasSvelte)
+                            continue;
+                        foundAny = true;
+                        const ctx = obj['$$'];
+                        if (!ctx || visited.has(ctx))
+                            continue;
+                        visited.add(ctx);
+                        const meta = obj['__svelte_meta'];
+                        const componentName = meta?.['loc']?.['file'];
+                        const ctxArray = ctx['ctx'];
+                        const stateObj = {};
+                        if (Array.isArray(ctxArray)) {
+                            let idx = 0;
+                            for (const val of ctxArray.slice(0, 20)) {
+                                if (val !== undefined && typeof val !== 'function') {
+                                    stateObj[`$${idx}`] = safeSerialize(val);
+                                }
+                                idx++;
+                            }
+                        }
+                        const fragment = ctx['fragment'];
+                        if (Object.keys(stateObj).length > 0 || fragment) {
+                            states.push({
+                                component: componentName ?? el.tagName?.toLowerCase() ?? 'svelte-component',
+                                state: [stateObj],
+                                ...(componentName ? { file: componentName } : {}),
+                            });
+                        }
+                        if (states.length >= 50)
+                            break;
+                    }
+                    return foundAny ? states : null;
+                };
+                const extractSolid = () => {
+                    const states = [];
+                    const dx = win['_$DX'];
+                    const hy = win['_$HY'];
+                    if (!dx && !hy) {
+                        const hydrationMarker = document.querySelector('[data-hk]');
+                        if (!hydrationMarker)
+                            return null;
+                        states.push({
+                            component: 'SolidRoot',
+                            state: [{ _note: 'Solid detected via hydration markers; install solid-devtools for full state extraction' }],
+                        });
+                        return states;
+                    }
+                    if (dx) {
+                        const roots = dx['roots'];
+                        if (roots && typeof roots === 'object') {
+                            const entries = roots instanceof Map ? Array.from(roots.values()) : Object.values(roots);
+                            let count = 0;
+                            for (const root of entries) {
+                                if (count++ >= opts.maxDepth * 10)
+                                    break;
+                                const name = root['name'] ?? 'SolidComponent';
+                                const value = root['value'] ?? root['state'];
+                                states.push({
+                                    component: name,
+                                    state: value ? [safeSerialize(value)] : [],
+                                });
+                            }
+                        }
+                    }
+                    if (hy && states.length === 0) {
+                        states.push({
+                            component: 'SolidHydration',
+                            state: [safeSerialize(hy)],
+                        });
+                    }
+                    return states.length > 0 ? states : null;
+                };
+                const extractPreact = () => {
+                    const rootEl = getRootEl();
+                    const rootObj = rootEl;
+                    const rootKeys = Object.keys(rootObj);
+                    if (rootKeys.some((k) => k.startsWith('__reactFiber') || k.startsWith('__reactInternalInstance'))) {
+                        return null;
+                    }
+                    const hasPreact = rootKeys.some((k) => k === '__k' || k === '__e' || k === '_dom');
+                    if (!hasPreact)
+                        return null;
+                    const states = [];
+                    const visited = new WeakSet();
+                    const visitVNode = (vnode, depth) => {
+                        if (!vnode || depth > opts.maxDepth || visited.has(vnode))
+                            return;
+                        visited.add(vnode);
+                        const component = vnode['__c'];
+                        if (component) {
+                            const compState = component['state'];
+                            const compProps = component['props'];
+                            const hooks = component['__H'];
+                            const hookStates = [];
+                            if (hooks) {
+                                const list = hooks['__'];
+                                if (Array.isArray(list)) {
+                                    for (const h of list.slice(0, 20)) {
+                                        const val = h['__'] ?? h['_value'];
+                                        if (val !== undefined)
+                                            hookStates.push(safeSerialize(val));
+                                    }
+                                }
+                            }
+                            const typeName = vnode['type'];
+                            const name = typeof typeName === 'function'
+                                ? typeName['displayName'] ?? typeName['name'] ?? 'PreactComponent'
+                                : typeof typeName === 'string'
+                                    ? typeName
+                                    : 'PreactComponent';
+                            if (compState || hookStates.length > 0) {
+                                states.push({
+                                    component: String(name),
+                                    state: hookStates.length > 0
+                                        ? hookStates
+                                        : compState
+                                            ? [safeSerialize(compState)]
+                                            : [],
+                                    ...(compProps ? { props: safeSerialize(compProps) } : {}),
+                                });
+                            }
+                        }
+                        const children = vnode['__k'];
+                        if (Array.isArray(children)) {
+                            for (const child of children) {
+                                if (child)
+                                    visitVNode(child, depth + 1);
+                            }
+                        }
+                    };
+                    const rootVNode = rootObj['__k'];
+                    if (Array.isArray(rootVNode)) {
+                        for (const vn of rootVNode) {
+                            if (vn)
+                                visitVNode(vn, 0);
+                        }
+                    }
+                    else if (rootObj['_children']) {
+                        const alt = rootObj['_children'];
+                        if (Array.isArray(alt)) {
+                            for (const vn of alt) {
+                                if (vn)
+                                    visitVNode(vn, 0);
+                            }
+                        }
+                    }
+                    return states.length > 0 ? states : null;
+                };
+                const extractMetaFramework = () => {
+                    const nextData = win['__NEXT_DATA__'];
+                    if (nextData) {
+                        return {
+                            framework: 'nextjs',
+                            route: nextData['page'],
+                            buildId: nextData['buildId'],
+                            runtimeConfig: safeSerialize(nextData['runtimeConfig']),
+                            props: safeSerialize(nextData['props']),
+                        };
+                    }
+                    const nuxt = win['__NUXT__'];
+                    if (nuxt) {
+                        const isNuxt3 = nuxt['config'] !== undefined || nuxt['_errors'] !== undefined;
+                        if (isNuxt3) {
+                            return {
+                                framework: 'nuxt3',
+                                state: safeSerialize(nuxt['state']),
+                                config: safeSerialize(nuxt['config']),
+                                payload: safeSerialize(nuxt['data']),
+                            };
+                        }
+                        return {
+                            framework: 'nuxt2',
+                            state: safeSerialize(nuxt['state']),
+                            serverRendered: nuxt['serverRendered'],
+                        };
+                    }
+                    return null;
+                };
                 const rootEl = getRootEl();
                 const rootObj = rootEl;
                 const keys = Object.keys(rootObj);
                 let detectedFramework = opts.framework;
                 if (detectedFramework === 'auto') {
-                    if (keys.some((k) => k.startsWith('__reactFiber') ||
-                        k.startsWith('__reactInternalInstance'))) {
+                    if (keys.some((k) => k.startsWith('__reactFiber') || k.startsWith('__reactInternalInstance'))) {
                         detectedFramework = 'react';
                     }
                     else if (keys.some((k) => k === '__vueParentComponent' || k === '__vue_app__')) {
@@ -173,25 +373,48 @@ export class FrameworkStateHandlers {
                     else if (keys.some((k) => k === '__vue__')) {
                         detectedFramework = 'vue2';
                     }
+                    else if (keys.some((k) => k === '$$' || k === '__svelte_meta' || k.startsWith('__s'))) {
+                        detectedFramework = 'svelte';
+                    }
+                    else if (win['_$DX'] || win['_$HY'] || document.querySelector('[data-hk]')) {
+                        detectedFramework = 'solid';
+                    }
+                    else if (!keys.some((k) => k.startsWith('__reactFiber')) &&
+                        keys.some((k) => k === '__k' || k === '__e' || k === '_dom')) {
+                        detectedFramework = 'preact';
+                    }
                 }
                 let states = null;
                 if (detectedFramework === 'react' || detectedFramework === 'auto') {
                     states = extractReact();
                 }
-                if (!states &&
-                    (detectedFramework === 'vue3' || detectedFramework === 'auto')) {
+                if (!states && (detectedFramework === 'vue3' || detectedFramework === 'auto')) {
                     states = extractVue3();
                 }
-                if (!states &&
-                    (detectedFramework === 'vue2' || detectedFramework === 'auto')) {
+                if (!states && (detectedFramework === 'vue2' || detectedFramework === 'auto')) {
                     states = extractVue2();
                 }
+                if (!states && (detectedFramework === 'svelte' || detectedFramework === 'auto')) {
+                    states = extractSvelte();
+                }
+                if (!states && (detectedFramework === 'solid' || detectedFramework === 'auto')) {
+                    states = extractSolid();
+                }
+                if (!states && (detectedFramework === 'preact' || detectedFramework === 'auto')) {
+                    states = extractPreact();
+                }
+                const meta = extractMetaFramework();
                 return {
                     detected: detectedFramework,
                     states: states ?? [],
                     found: states !== null && states.length > 0,
+                    ...(meta ? { meta } : {}),
                 };
             }, { framework, selector, maxDepth });
+            const result = (await Promise.race([
+                evalPromise,
+                new Promise((_, reject) => setTimeout(() => reject(new Error('page.evaluate timed out after 30000ms')), 30000)),
+            ]));
             return {
                 content: [
                     {

package/dist/src/server/domains/browser/handlers/human-behavior.js

@@ -20,26 +20,30 @@ function generateControlPoints(from, to) {
     const offset2 = (Math.random() - 0.5) * 0.4;
     return [
         {
-            x: from.x + dx * 0.3 + perpX / len * Math.abs(dx + dy) * offset1,
-            y: from.y + dy * 0.3 + perpY / len * Math.abs(dx + dy) * offset1,
+            x: from.x + dx * 0.3 + (perpX / len) * Math.abs(dx + dy) * offset1,
+            y: from.y + dy * 0.3 + (perpY / len) * Math.abs(dx + dy) * offset1,
         },
         {
-            x: from.x + dx * 0.7 + perpX / len * Math.abs(dx + dy) * offset2,
-            y: from.y + dy * 0.7 + perpY / len * Math.abs(dx + dy) * offset2,
+            x: from.x + dx * 0.7 + (perpX / len) * Math.abs(dx + dy) * offset2,
+            y: from.y + dy * 0.7 + (perpY / len) * Math.abs(dx + dy) * offset2,
         },
     ];
 }
 function easeT(t, curve) {
     switch (curve) {
-        case 'linear': return t;
-        case 'ease-in': return t * t;
-        case 'ease-out': return 1 - (1 - t) * (1 - t);
+        case 'linear':
+            return t;
+        case 'ease-in':
+            return t * t;
+        case 'ease-out':
+            return 1 - (1 - t) * (1 - t);
         case 'ease':
-        default: return t < 0.5 ? 2 * t * t : 1 - (-2 * t + 2) ** 2 / 2;
+        default:
+            return t < 0.5 ? 2 * t * t : 1 - (-2 * t + 2) ** 2 / 2;
     }
 }
 function sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
+    return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function toTextResponse(payload) {
     return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }] };
@@ -114,12 +118,12 @@ export async function handleHumanScroll(args, collector) {
     const jitter = Math.max(0, Math.min(argNumber(args, 'jitter', 0.3), 1));
     const selector = argString(args, 'selector');
     const isVertical = direction === 'up' || direction === 'down';
-    const sign = (direction === 'down' || direction === 'right') ? 1 : -1;
+    const sign = direction === 'down' || direction === 'right' ? 1 : -1;
     let scrolled = 0;
     for (let i = 0; i < segments; i++) {
         const progress = i / segments;
         const decel = 1 - progress * 0.4;
-        const baseSegment = distance / segments * decel;
+        const baseSegment = (distance / segments) * decel;
         const segmentDist = baseSegment * (1 + (Math.random() - 0.5) * jitter * 2);
         const actualDist = Math.min(segmentDist, distance - scrolled);
         if (actualDist <= 0)

package/dist/src/server/domains/browser/handlers/js-heap.js

@@ -46,10 +46,12 @@ export class JSHeapSearchHandlers {
         const caseSensitive = argBool(args, 'caseSensitive', false);
         if (!pattern) {
             return {
-                content: [{
+                content: [
+                    {
                         type: 'text',
                         text: JSON.stringify({ success: false, error: 'pattern is required' }, null, 2),
-                    }],
+                    },
+                ],
             };
         }
         return cdpLimit(async () => {
@@ -95,22 +97,26 @@ export class JSHeapSearchHandlers {
                         : 'No matches found. The value may be encrypted, compressed, or stored in a non-string form.',
                 };
                 return {
-                    content: [{
+                    content: [
+                        {
                             type: 'text',
                             text: JSON.stringify(this.detailedDataManager.smartHandle(result, 51200), null, 2),
-                        }],
+                        },
+                    ],
                 };
             }
             catch (error) {
                 logger.error('[js_heap_search] Error:', error);
                 return {
-                    content: [{
+                    content: [
+                        {
                             type: 'text',
                             text: JSON.stringify({
                                 success: false,
                                 error: error instanceof Error ? error.message : String(error),
                             }, null, 2),
-                        }],
+                        },
+                    ],
                 };
             }
             finally {

package/dist/src/server/domains/browser/handlers/page-evaluation.js

@@ -1,5 +1,5 @@
 import { resolveScreenshotOutputPath } from '../../../../utils/outputPaths.js';
-import { argString, argNumber, argBool, argObject, argStringArray } from '../../../domains/shared/parse-args.js';
+import { argString, argNumber, argBool, argObject, argStringArray, } from '../../../domains/shared/parse-args.js';
 function filterFields(value, fields) {
     if (Array.isArray(value)) {
         return value.map((item) => filterFields(item, fields));
@@ -90,7 +90,7 @@ export class PageEvaluationHandlers {
     }
     async handlePageScreenshot(args) {
         const requestedPath = argString(args, 'path');
-        const type = (argString(args, 'type', 'png'));
+        const type = argString(args, 'type', 'png');
         const quality = argNumber(args, 'quality');
         const fullPage = argBool(args, 'fullPage', false);
         const clipArg = argObject(args, 'clip');
@@ -125,16 +125,23 @@ export class PageEvaluationHandlers {
                 const element = await page.$(selector);
                 if (!element) {
                     return {
-                        content: [{
+                        content: [
+                            {
                                 type: 'text',
                                 text: JSON.stringify({ success: false, error: `Element not found: ${selector}` }, null, 2),
-                            }],
+                            },
+                        ],
                     };
                 }
                 buffer = await element.screenshot({ path: absolutePath, type, quality });
             }
             else {
-                buffer = await page.screenshot({ path: absolutePath, type, quality, fullPage: clipArg ? false : fullPage });
+                buffer = await page.screenshot({
+                    path: absolutePath,
+                    type,
+                    quality,
+                    fullPage: clipArg ? false : fullPage,
+                });
             }
             return {
                 content: [
@@ -160,10 +167,12 @@ export class PageEvaluationHandlers {
             const element = await page.$(selector);
             if (!element) {
                 return {
-                    content: [{
+                    content: [
+                        {
                             type: 'text',
                             text: JSON.stringify({ success: false, error: `Element not found: ${selector}` }, null, 2),
-                        }],
+                        },
+                    ],
                 };
             }
             buffer = (await element.screenshot({ path: absolutePath, type, quality }));

package/dist/src/server/domains/browser/handlers/script-management.js

@@ -1,4 +1,5 @@
 import { argString, argNumber, argBool } from '../../../domains/shared/parse-args.js';
+import { SCRIPTS_MAX_CAP } from '../../../../constants.js';
 export class ScriptManagementHandlers {
     deps;
     constructor(deps) {
@@ -6,7 +7,7 @@ export class ScriptManagementHandlers {
     }
     async handleGetAllScripts(args) {
         const includeSource = argBool(args, 'includeSource', false);
-        const MAX_SCRIPTS_CAP = 500;
+        const MAX_SCRIPTS_CAP = SCRIPTS_MAX_CAP;
         const maxScripts = Math.min(argNumber(args, 'maxScripts', includeSource ? 200 : 1000), MAX_SCRIPTS_CAP);
         const scripts = await this.deps.scriptManager.getAllScripts(includeSource, maxScripts);
         const data = { count: scripts.length, scripts };

package/dist/src/server/domains/browser/handlers/stealth-injection.d.ts

@@ -1,4 +1,6 @@
 import type { PageController } from '../../../domains/shared/modules.js';
+import { CDPTimingProxy } from '../../../../modules/stealth/CDPTimingProxy.js';
+import type { CDPTimingOptions } from '../../../../modules/stealth/CDPTimingProxy.types.js';
 interface StealthInjectionHandlersDeps {
     pageController: PageController;
     getActiveDriver: () => 'chrome' | 'camoufox';
@@ -18,5 +20,29 @@ export declare class StealthInjectionHandlers {
             text: string;
         }[];
     }>;
+    handleStealthConfigureJitter(args: Record<string, unknown>): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
+    handleStealthGenerateFingerprint(args: Record<string, unknown>): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
+    handleStealthVerify(_args: Record<string, unknown>): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
 }
+export declare function getJitterOptions(): CDPTimingOptions;
+export declare function createJitteredSession(session: {
+    send: (method: string, params?: Record<string, unknown>) => Promise<unknown>;
+    on: (event: string, handler: (params: unknown) => void) => void;
+    off: (event: string, handler: (params: unknown) => void) => void;
+}): CDPTimingProxy;
 export {};