@jshookmcp/jshook 0.2.2 → 0.2.5

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

@@ -23,6 +23,7 @@ export class FrameworkStateHandlers {
                     '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]';
@@ -170,20 +171,236 @@ 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);
+                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 (keys.some((k) => k.startsWith('__reactFiber') || k.startsWith('__reactInternalInstance'))) {
+                    if (hasReactMarker) {
                         detectedFramework = 'react';
                     }
-                    else if (keys.some((k) => k === '__vueParentComponent' || k === '__vue_app__')) {
+                    else if (hasVue3Marker) {
                         detectedFramework = 'vue3';
                     }
-                    else if (keys.some((k) => k === '__vue__')) {
+                    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') {
@@ -195,10 +412,21 @@ export class FrameworkStateHandlers {
                 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([

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

@@ -13,33 +13,24 @@ export class IndexedDBDumpHandlers {
             const result = await page.evaluate(async (opts) => {
                 const dbList = await indexedDB.databases();
                 const output = {};
-                const openDb = (name, version) => new Promise((resolve, reject) => {
-                    const req = version ? indexedDB.open(name, version) : indexedDB.open(name);
-                    req.onsuccess = () => resolve(req.result);
-                    req.onerror = () => reject(req.error);
-                });
-                const getAllFromStore = (db, storeName, max) => new Promise((resolve, reject) => {
-                    try {
-                        const tx = db.transaction(storeName, 'readonly');
-                        const req = tx.objectStore(storeName).getAll();
-                        req.onsuccess = () => resolve(req.result.slice(0, max));
-                        req.onerror = () => reject(req.error);
-                    }
-                    catch (e) {
-                        reject(e);
-                    }
-                });
                 for (const dbInfo of dbList) {
                     if (!dbInfo.name)
                         continue;
                     if (opts.database && dbInfo.name !== opts.database)
                         continue;
+                    const dbName = dbInfo.name;
                     let db;
                     try {
-                        db = await openDb(dbInfo.name, dbInfo.version);
+                        db = await new Promise((resolve, reject) => {
+                            const req = dbInfo.version
+                                ? indexedDB.open(dbName, dbInfo.version)
+                                : indexedDB.open(dbName);
+                            req.addEventListener('success', () => resolve(req.result), { once: true });
+                            req.addEventListener('error', () => reject(req.error), { once: true });
+                        });
                     }
                     catch {
-                        output[dbInfo.name] = { __error__: ['failed to open'] };
+                        output[dbName] = { __error__: ['failed to open'] };
                         continue;
                     }
                     const storeNames = Array.from(db.objectStoreNames);
@@ -48,14 +39,24 @@ export class IndexedDBDumpHandlers {
                         if (opts.store && storeName !== opts.store)
                             continue;
                         try {
-                            dbData[storeName] = await getAllFromStore(db, storeName, opts.maxRecords);
+                            dbData[storeName] = await new Promise((resolve, reject) => {
+                                try {
+                                    const tx = db.transaction(storeName, 'readonly');
+                                    const req = tx.objectStore(storeName).getAll();
+                                    req.addEventListener('success', () => resolve(req.result.slice(0, opts.maxRecords)), { once: true });
+                                    req.addEventListener('error', () => reject(req.error), { once: true });
+                                }
+                                catch (e) {
+                                    reject(e);
+                                }
+                            });
                         }
                         catch {
                             dbData[storeName] = ['__error reading store__'];
                         }
                     }
                     db.close();
-                    output[dbInfo.name] = dbData;
+                    output[dbName] = dbData;
                 }
                 return output;
             }, { database, store, maxRecords });

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

@@ -24,7 +24,7 @@ export class ScriptManagementHandlers {
     async handleGetScriptSource(args) {
         const scriptId = argString(args, 'scriptId');
         const url = argString(args, 'url');
-        const preview = argBool(args, 'preview', false);
+        const preview = argBool(args, 'preview', true);
         const maxLines = argNumber(args, 'maxLines', 100);
         const startLine = argNumber(args, 'startLine');
         const endLine = argNumber(args, 'endLine');

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

@@ -3,7 +3,7 @@ import { argString } from '../../../domains/shared/parse-args.js';
 import { CDPTimingProxy } from '../../../../modules/stealth/CDPTimingProxy.js';
 import { DEFAULT_TIMING_OPTIONS } from '../../../../modules/stealth/CDPTimingProxy.types.js';
 import { logger } from '../../../../utils/logger.js';
-let jitterOptions = { ...DEFAULT_TIMING_OPTIONS };
+const jitterOptions = { ...DEFAULT_TIMING_OPTIONS };
 let fingerprintManagerInstance = null;
 async function getFingerprintManager() {
     if (fingerprintManagerInstance)
@@ -64,6 +64,9 @@ export class StealthInjectionHandlers {
                         success: true,
                         message: 'Stealth scripts injected successfully',
                         fingerprintApplied,
+                        _nextStepHint: 'Stealth patches are now active. ' +
+                            'Next: navigate to your target URL with page_navigate. ' +
+                            'Do NOT call stealth_inject again — it only needs to run once per page.',
                     }, null, 2),
                 },
             ],
@@ -81,6 +84,9 @@ export class StealthInjectionHandlers {
                         success: true,
                         platform,
                         message: `User-Agent set for ${platform}`,
+                        _nextStepHint: 'User-Agent is now configured. ' +
+                            'Next: call stealth_inject to apply all anti-detection patches, ' +
+                            'then page_navigate to your target URL.',
                     }, null, 2),
                 },
             ],
@@ -110,7 +116,7 @@ export class StealthInjectionHandlers {
     }
     async handleStealthGenerateFingerprint(args) {
         const fm = await getFingerprintManager();
-        if (!fm || !fm.isAvailable()) {
+        if (!fm?.isAvailable()) {
             return {
                 content: [
                     {

package/dist/src/server/domains/browser/handlers.impl.d.ts

@@ -3,7 +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 { LLMService } from '../../../services/LLMService.js';
+import { AICaptchaDetector } from '../../domains/shared/modules.js';
+import { 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';
@@ -21,17 +23,18 @@ import { FrameworkStateHandlers } from '../../domains/browser/handlers/framework
 import { IndexedDBDumpHandlers } from '../../domains/browser/handlers/indexeddb-dump.js';
 import { DetailedDataHandlers } from '../../domains/browser/handlers/detailed-data.js';
 import type { TabRegistry } from '../../../modules/browser/TabRegistry.js';
+import { type CamoufoxPage } from '../../domains/browser/handlers/camoufox-flow.js';
 export declare class BrowserToolHandlers {
-    private collector;
-    private pageController;
-    private domInspector;
-    private scriptManager;
-    private consoleMonitor;
-    private captchaDetector;
-    private detailedDataManager;
-    private camoufoxManager;
-    private activeDriver;
-    private camoufoxPage;
+    protected collector: CodeCollector;
+    protected pageController: PageController;
+    protected domInspector: DOMInspector;
+    protected scriptManager: ScriptManager;
+    protected consoleMonitor: ConsoleMonitor;
+    protected captchaDetector: AICaptchaDetector;
+    protected detailedDataManager: DetailedDataManager;
+    protected camoufoxManager: CamoufoxBrowserManager | null;
+    protected activeDriver: 'chrome' | 'camoufox';
+    protected camoufoxPage: CamoufoxPage | null;
     private autoDetectCaptcha;
     private autoSwitchHeadless;
     private captchaTimeout;
@@ -54,7 +57,7 @@ export declare class BrowserToolHandlers {
     private tabWorkflow;
     private detailedData;
     private _tabRegistry;
-    constructor(collector: CodeCollector, pageController: PageController, domInspector: DOMInspector, scriptManager: ScriptManager, consoleMonitor: ConsoleMonitor, llmService: LLMService);
+    constructor(collector: CodeCollector, pageController: PageController, domInspector: DOMInspector, scriptManager: ScriptManager, consoleMonitor: ConsoleMonitor);
     getTabRegistry(): TabRegistry;
     private getCamoufoxPage;
     private closeCamoufox;

package/dist/src/server/domains/browser/handlers.impl.js

@@ -1,10 +1,9 @@
 import { AICaptchaDetector } from '../../domains/shared/modules.js';
-import { LLMService } from '../../../services/LLMService.js';
 import { argString, argNumber, argBool } from '../../domains/shared/parse-args.js';
 import { DetailedDataManager } from '../../../utils/DetailedDataManager.js';
 import { resolveOutputDirectory } from '../../../utils/outputPaths.js';
 import { logger } from '../../../utils/logger.js';
-import { CamoufoxBrowserManager } from '../../domains/shared/modules.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';
@@ -21,8 +20,8 @@ import { StealthInjectionHandlers } from '../../domains/browser/handlers/stealth
 import { FrameworkStateHandlers } from '../../domains/browser/handlers/framework-state.js';
 import { IndexedDBDumpHandlers } from '../../domains/browser/handlers/indexeddb-dump.js';
 import { DetailedDataHandlers } from '../../domains/browser/handlers/detailed-data.js';
-import { JSHeapSearchHandlers } from '../../domains/browser/handlers/js-heap.js';
-import { TabWorkflowHandlers } from '../../domains/browser/handlers/tab-workflow.js';
+import {} from '../../domains/browser/handlers/js-heap.js';
+import {} from '../../domains/browser/handlers/tab-workflow.js';
 import { initializeBrowserHandlerModules } from '../../domains/browser/handlers/facade-initializer.js';
 import { handleHumanMouse, handleHumanScroll, handleHumanTyping, } from '../../domains/browser/handlers/human-behavior.js';
 import { handleCaptchaVisionSolve, handleWidgetChallengeSolve, } from '../../domains/browser/handlers/captcha-solver.js';
@@ -60,14 +59,14 @@ export class BrowserToolHandlers {
     tabWorkflow;
     detailedData;
     _tabRegistry;
-    constructor(collector, pageController, domInspector, scriptManager, consoleMonitor, llmService) {
+    constructor(collector, pageController, domInspector, scriptManager, consoleMonitor) {
         this.collector = collector;
         this.pageController = pageController;
         this.domInspector = domInspector;
         this.scriptManager = scriptManager;
         this.consoleMonitor = consoleMonitor;
         const screenshotDir = resolveOutputDirectory(process.env.CAPTCHA_SCREENSHOT_DIR, 'screenshots/captcha');
-        this.captchaDetector = new AICaptchaDetector(llmService, screenshotDir);
+        this.captchaDetector = new AICaptchaDetector(screenshotDir);
         this.detailedDataManager = DetailedDataManager.getInstance();
         const modules = initializeBrowserHandlerModules({
             collector: this.collector,

package/dist/src/server/domains/browser/manifest.js

@@ -8,7 +8,7 @@ const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
 function ensure(ctx) {
     ensureBrowserCore(ctx);
     if (!ctx.browserHandlers) {
-        ctx.browserHandlers = new BrowserToolHandlers(ctx.collector, ctx.pageController, ctx.domInspector, ctx.scriptManager, ctx.consoleMonitor, ctx.llm);
+        ctx.browserHandlers = new BrowserToolHandlers(ctx.collector, ctx.pageController, ctx.domInspector, ctx.scriptManager, ctx.consoleMonitor);
     }
     return ctx.browserHandlers;
 }
@@ -29,18 +29,42 @@ const manifest = {
         hint: 'Browser automation workflow: bootstrap browser/page state -> navigate -> interact -> extract data',
     },
     prerequisites: {
-        page_navigate: [{ condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' }],
-        page_click: [{ condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' }],
-        page_type: [{ condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' }],
-        page_screenshot: [{ condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' }],
-        page_evaluate: [{ condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' }],
-        page_hover: [{ condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' }],
-        page_scroll: [{ condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' }],
-        page_back: [{ condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' }],
-        page_forward: [{ condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' }],
-        page_reload: [{ condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' }],
-        dom_get_structure: [{ condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' }],
-        dom_query_selector: [{ condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' }],
+        page_navigate: [
+            { condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' },
+        ],
+        page_click: [
+            { condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' },
+        ],
+        page_type: [
+            { condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' },
+        ],
+        page_screenshot: [
+            { condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' },
+        ],
+        page_evaluate: [
+            { condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' },
+        ],
+        page_hover: [
+            { condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' },
+        ],
+        page_scroll: [
+            { condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' },
+        ],
+        page_back: [
+            { condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' },
+        ],
+        page_forward: [
+            { condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' },
+        ],
+        page_reload: [
+            { condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' },
+        ],
+        dom_get_structure: [
+            { condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' },
+        ],
+        dom_query_selector: [
+            { condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' },
+        ],
     },
     registrations: [
         { tool: t('get_detailed_data'), domain: DOMAIN, bind: b((h, a) => h.handleGetDetailedData(a)) },