@jshookmcp/jshook 0.2.5 → 0.2.7

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

@@ -1,459 +0,0 @@
-import { argString, argNumber } from '../../../domains/shared/parse-args.js';
-import { PrerequisiteError } from '../../../../errors/PrerequisiteError.js';
-export class FrameworkStateHandlers {
-    deps;
-    constructor(deps) {
-        this.deps = deps;
-    }
-    async handleFrameworkStateExtract(args) {
-        const framework = argString(args, 'framework', 'auto');
-        const selector = argString(args, 'selector', '');
-        const maxDepth = argNumber(args, 'maxDepth', 5);
-        try {
-            const page = (await this.deps.getActivePage());
-            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]';
-                    if (val === null || val === undefined)
-                        return val;
-                    if (typeof val === 'function')
-                        return '[Function]';
-                    if (typeof val !== 'object')
-                        return val;
-                    if (Array.isArray(val)) {
-                        return val.slice(0, 20).map((v) => safeSerialize(v, depth + 1));
-                    }
-                    try {
-                        const out = {};
-                        let count = 0;
-                        for (const k of Object.keys(val)) {
-                            if (count++ > 30) {
-                                out['__truncated__'] = true;
-                                break;
-                            }
-                            out[k] = safeSerialize(val[k], depth + 1);
-                        }
-                        return out;
-                    }
-                    catch {
-                        return '[unserializable]';
-                    }
-                }
-                const getRootEl = () => {
-                    if (opts.selector) {
-                        return document.querySelector(opts.selector) ?? document.body;
-                    }
-                    return (document.getElementById('root') ??
-                        document.getElementById('app') ??
-                        document.querySelector('[data-reactroot]') ??
-                        document.body);
-                };
-                const extractReact = () => {
-                    const rootEl = getRootEl();
-                    const rootObj = rootEl;
-                    const fiberKey = Object.keys(rootObj).find((k) => k.startsWith('__reactFiber') ||
-                        k.startsWith('__reactInternalInstance') ||
-                        k.startsWith('__reactFiberContainer'));
-                    if (!fiberKey)
-                        return null;
-                    const states = [];
-                    const visited = new WeakSet();
-                    const visitFiber = (fiber, depth) => {
-                        if (!fiber || depth > opts.maxDepth || visited.has(fiber))
-                            return;
-                        visited.add(fiber);
-                        if (fiber['memoizedState']) {
-                            const stateList = [];
-                            let s = fiber['memoizedState'];
-                            let guard = 0;
-                            while (s && guard++ < 20) {
-                                const queue = s['queue'];
-                                const val = s['memoizedState'] !== undefined
-                                    ? s['memoizedState']
-                                    : queue?.['lastRenderedState'];
-                                if (val !== undefined)
-                                    stateList.push(safeSerialize(val));
-                                s = s['next'] ?? null;
-                            }
-                            if (stateList.length > 0) {
-                                const fiberType = fiber['type'];
-                                const componentName = typeof fiberType === 'object' && fiberType !== null
-                                    ? String(fiberType['name'] ?? 'anonymous')
-                                    : typeof fiberType === 'string'
-                                        ? fiberType
-                                        : 'anonymous';
-                                states.push({ component: componentName, state: stateList });
-                            }
-                        }
-                        visitFiber(fiber['child'] ?? null, depth + 1);
-                        visitFiber(fiber['sibling'] ?? null, depth + 1);
-                    };
-                    visitFiber(rootObj[fiberKey] ?? null, 0);
-                    return states;
-                };
-                const extractVue3 = () => {
-                    const rootEl = getRootEl();
-                    const rootObj = rootEl;
-                    const vueKey = Object.keys(rootObj).find((k) => k === '__vueParentComponent' || k === '__vue_app__' || k.startsWith('__vue'));
-                    if (!vueKey)
-                        return null;
-                    const comp = rootObj[vueKey];
-                    if (!comp)
-                        return null;
-                    const states = [];
-                    const visited = new WeakSet();
-                    const visitComp = (c, depth) => {
-                        if (!c || depth > opts.maxDepth || visited.has(c))
-                            return;
-                        visited.add(c);
-                        const setupState = safeSerialize(c['setupState'] ?? c['ctx']);
-                        const data = safeSerialize(c['$data'] ?? c['data']);
-                        if (setupState || data) {
-                            const compType = c['type'];
-                            states.push({
-                                component: compType?.['__name'] ?? 'unknown',
-                                setupState,
-                                data,
-                            });
-                        }
-                        const subTree = c['subTree'];
-                        const children = subTree?.['children'];
-                        if (Array.isArray(children)) {
-                            for (const child of children) {
-                                if (child?.['component']) {
-                                    visitComp(child['component'], depth + 1);
-                                }
-                            }
-                        }
-                    };
-                    visitComp(comp, 0);
-                    return states;
-                };
-                const extractVue2 = () => {
-                    const rootEl = getRootEl();
-                    const rootObj = rootEl;
-                    const vueKey = Object.keys(rootObj).find((k) => k === '__vue__');
-                    if (!vueKey)
-                        return null;
-                    const vm = rootObj[vueKey];
-                    if (!vm)
-                        return null;
-                    const states = [];
-                    const visited = new WeakSet();
-                    const visitVm = (v, depth) => {
-                        if (!v || depth > opts.maxDepth || visited.has(v))
-                            return;
-                        visited.add(v);
-                        const options = v['$options'];
-                        states.push({
-                            component: options?.['name'] ?? 'unknown',
-                            data: safeSerialize(v['$data']),
-                        });
-                        const children = v['$children'];
-                        if (Array.isArray(children)) {
-                            for (const child of children)
-                                visitVm(child, depth + 1);
-                        }
-                    };
-                    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);
-                const hasReactMarker = keys.some((k) => k.startsWith('__reactFiber') ||
-                    k.startsWith('__reactInternalInstance') ||
-                    k.startsWith('__reactFiberContainer'));
-                const hasVue3Marker = keys.some((k) => k === '__vueParentComponent' || k === '__vue_app__');
-                const hasVue2Marker = keys.some((k) => k === '__vue__');
-                const hasSvelteMarker = keys.some((k) => k === '$$' || k === '__svelte_meta' || k.startsWith('__s'));
-                const hasSolidMarker = win['_$DX'] !== undefined ||
-                    win['_$HY'] !== undefined ||
-                    Boolean(document.querySelector('[data-hk]'));
-                const hasPreactMarker = keys.some((k) => k === '__k' || k === '__e' || k === '_dom' || k === '_children');
-                let detectedFramework = opts.framework;
-                if (detectedFramework === 'preact' && hasReactMarker) {
-                    detectedFramework = 'react';
-                }
-                if (detectedFramework === 'auto') {
-                    if (hasReactMarker) {
-                        detectedFramework = 'react';
-                    }
-                    else if (hasVue3Marker) {
-                        detectedFramework = 'vue3';
-                    }
-                    else if (hasVue2Marker) {
-                        detectedFramework = 'vue2';
-                    }
-                    else if (hasSvelteMarker) {
-                        detectedFramework = 'svelte';
-                    }
-                    else if (hasSolidMarker) {
-                        detectedFramework = 'solid';
-                    }
-                    else if (hasPreactMarker) {
-                        detectedFramework = 'preact';
-                    }
-                }
-                let states = null;
-                if (detectedFramework === 'react' || detectedFramework === 'auto') {
-                    states = extractReact();
-                }
-                if (!states && (detectedFramework === 'vue3' || detectedFramework === 'auto')) {
-                    states = extractVue3();
-                }
-                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: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify(result, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: error instanceof Error ? error.message : String(error),
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-    }
-}

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

@@ -1,4 +0,0 @@
-import type { CodeCollector } from '../../../domains/shared/modules.js';
-export declare function handleHumanMouse(args: Record<string, unknown>, collector: CodeCollector): Promise<unknown>;
-export declare function handleHumanScroll(args: Record<string, unknown>, collector: CodeCollector): Promise<unknown>;
-export declare function handleHumanTyping(args: Record<string, unknown>, collector: CodeCollector): Promise<unknown>;

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

@@ -1,202 +0,0 @@
-import { argString, argNumber, argBool } from '../../../domains/shared/parse-args.js';
-function cubicBezier(p0, p1, p2, p3, t) {
-    const u = 1 - t;
-    const uu = u * u;
-    const uuu = uu * u;
-    const tt = t * t;
-    const ttt = tt * t;
-    return {
-        x: uuu * p0.x + 3 * uu * t * p1.x + 3 * u * tt * p2.x + ttt * p3.x,
-        y: uuu * p0.y + 3 * uu * t * p1.y + 3 * u * tt * p2.y + ttt * p3.y,
-    };
-}
-function generateControlPoints(from, to) {
-    const dx = to.x - from.x;
-    const dy = to.y - from.y;
-    const perpX = -dy;
-    const perpY = dx;
-    const len = Math.sqrt(perpX * perpX + perpY * perpY) || 1;
-    const offset1 = (Math.random() - 0.5) * 0.4;
-    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.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 'ease':
-        default:
-            return t < 0.5 ? 2 * t * t : 1 - (-2 * t + 2) ** 2 / 2;
-    }
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function toTextResponse(payload) {
-    return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }] };
-}
-export async function handleHumanMouse(args, collector) {
-    const page = await collector.getActivePage();
-    if (!page)
-        throw new Error('No active page. Use browser_launch or browser_attach first.');
-    let toX = argNumber(args, 'toX');
-    let toY = argNumber(args, 'toY');
-    const selector = argString(args, 'selector');
-    if (selector) {
-        const box = await page.evaluate((sel) => {
-            const el = document.querySelector(sel);
-            if (!el)
-                return null;
-            const rect = el.getBoundingClientRect();
-            return { x: rect.x + rect.width / 2, y: rect.y + rect.height / 2 };
-        }, selector);
-        if (!box)
-            throw new Error(`Selector not found: ${selector}`);
-        toX = box.x;
-        toY = box.y;
-    }
-    if (toX === undefined || toY === undefined) {
-        throw new Error('Either selector or toX/toY coordinates are required');
-    }
-    const fromX = argNumber(args, 'fromX', 0);
-    const fromY = argNumber(args, 'fromY', 0);
-    const steps = Math.max(1, Math.min(argNumber(args, 'steps', 24), 500));
-    const durationMs = Math.max(10, Math.min(argNumber(args, 'durationMs', 600), 30000));
-    const jitterPx = Math.max(0, Math.min(argNumber(args, 'jitterPx', 1.5), 20));
-    const curve = argString(args, 'curve', 'ease');
-    const shouldClick = argBool(args, 'click', false);
-    const from = { x: fromX, y: fromY };
-    const to = { x: toX, y: toY };
-    const [cp1, cp2] = generateControlPoints(from, to);
-    const stepDelay = durationMs / steps;
-    for (let i = 0; i <= steps; i++) {
-        const rawT = i / steps;
-        const t = easeT(rawT, curve);
-        const pt = cubicBezier(from, cp1, cp2, to, t);
-        if (i > 0 && i < steps) {
-            pt.x += (Math.random() - 0.5) * 2 * jitterPx;
-            pt.y += (Math.random() - 0.5) * 2 * jitterPx;
-        }
-        pt.x = Math.max(0, pt.x);
-        pt.y = Math.max(0, pt.y);
-        await page.mouse.move(pt.x, pt.y);
-        await sleep(stepDelay * (0.8 + Math.random() * 0.4));
-    }
-    if (shouldClick) {
-        await page.mouse.click(toX, toY);
-    }
-    return toTextResponse({
-        success: true,
-        from: { x: fromX, y: fromY },
-        to: { x: toX, y: toY },
-        steps,
-        durationMs,
-        clicked: shouldClick,
-    });
-}
-export async function handleHumanScroll(args, collector) {
-    const page = await collector.getActivePage();
-    if (!page)
-        throw new Error('No active page.');
-    const distance = Math.max(1, Math.min(argNumber(args, 'distance', 500), 10000));
-    const direction = argString(args, 'direction', 'down');
-    const segments = Math.max(1, Math.min(argNumber(args, 'segments', 8), 200));
-    const pauseMs = Math.max(0, Math.min(argNumber(args, 'pauseMs', 80), 5000));
-    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;
-    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 segmentDist = baseSegment * (1 + (Math.random() - 0.5) * jitter * 2);
-        const actualDist = Math.min(segmentDist, distance - scrolled);
-        if (actualDist <= 0)
-            break;
-        const deltaX = isVertical ? 0 : actualDist * sign;
-        const deltaY = isVertical ? actualDist * sign : 0;
-        if (selector) {
-            await page.evaluate((sel, dx, dy) => {
-                const el = document.querySelector(sel);
-                if (el)
-                    el.scrollBy({ left: dx, top: dy, behavior: 'auto' });
-            }, selector, deltaX, deltaY);
-        }
-        else {
-            await page.evaluate((dx, dy) => window.scrollBy({ left: dx, top: dy, behavior: 'auto' }), deltaX, deltaY);
-        }
-        scrolled += actualDist;
-        const actualPause = pauseMs * (0.5 + Math.random());
-        await sleep(actualPause);
-    }
-    return toTextResponse({
-        success: true,
-        direction,
-        requestedDistance: distance,
-        actualScrolled: Math.round(scrolled),
-        segments,
-    });
-}
-export async function handleHumanTyping(args, collector) {
-    const page = await collector.getActivePage();
-    if (!page)
-        throw new Error('No active page.');
-    const selector = argString(args, 'selector', '');
-    const text = argString(args, 'text', '');
-    const wpm = Math.max(10, Math.min(argNumber(args, 'wpm', 90), 300));
-    const errorRate = Math.max(0, Math.min(argNumber(args, 'errorRate', 0.02), 0.3));
-    const correctDelayMs = Math.max(50, Math.min(argNumber(args, 'correctDelayMs', 200), 2000));
-    const clearFirst = argBool(args, 'clearFirst', false);
-    if (!selector || !text) {
-        throw new Error('selector and text are required');
-    }
-    const avgDelayMs = 60_000 / (wpm * 5);
-    await page.click(selector);
-    if (clearFirst) {
-        await page.evaluate((sel) => {
-            const el = document.querySelector(sel);
-            if (el)
-                el.value = '';
-        }, selector);
-    }
-    let typoCount = 0;
-    for (const char of text) {
-        if (Math.random() < errorRate && char !== ' ') {
-            const wrongChar = String.fromCharCode(char.charCodeAt(0) + (Math.random() > 0.5 ? 1 : -1));
-            await page.keyboard.type(wrongChar, { delay: 0 });
-            await sleep(correctDelayMs * (0.5 + Math.random()));
-            await page.keyboard.press('Backspace');
-            await sleep(50 + Math.random() * 50);
-            typoCount++;
-        }
-        await page.keyboard.type(char, { delay: 0 });
-        let delay = avgDelayMs * (0.5 + Math.random());
-        if (char === ' ' || '.,:;!?'.includes(char)) {
-            delay *= 1.5 + Math.random() * 0.5;
-        }
-        await sleep(delay);
-    }
-    return toTextResponse({
-        success: true,
-        selector,
-        length: text.length,
-        wpm,
-        typosSimulated: typoCount,
-        errorRate,
-    });
-}

package/dist/src/server/domains/browser/handlers/indexeddb-dump.d.ts

@@ -1,14 +0,0 @@
-interface IndexedDBDumpHandlersDeps {
-    getActivePage: () => Promise<unknown>;
-}
-export declare class IndexedDBDumpHandlers {
-    private deps;
-    constructor(deps: IndexedDBDumpHandlersDeps);
-    handleIndexedDBDump(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-}
-export {};