@jshookmcp/jshook 0.1.6 → 0.1.8

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

@@ -1,5 +1,5 @@
 import { logger } from '../../../../utils/logger.js';
-import { CAPTCHA_2CAPTCHA_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';
+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));
 }
@@ -14,15 +14,64 @@ function toErrorResponse(tool, error, extra = {}) {
         ...extra,
     });
 }
+function normalizeSolverMode(rawMode) {
+    const value = typeof rawMode === 'string' ? rawMode.toLowerCase() : '';
+    if (value === 'hook')
+        return 'hook';
+    if (value === 'external_service')
+        return 'external_service';
+    if (value === '2captcha' || value === 'anticaptcha' || value === 'capsolver') {
+        return 'external_service';
+    }
+    return 'manual';
+}
+function normalizeChallengeTypeHint(rawType) {
+    const value = typeof rawType === 'string' ? rawType.toLowerCase() : '';
+    if (value === 'image')
+        return 'image';
+    if (value === 'widget' ||
+        value === 'recaptcha_v2' ||
+        value === 'recaptcha_v3' ||
+        value === 'hcaptcha' ||
+        value === 'funcaptcha' ||
+        value === 'turnstile') {
+        return 'widget';
+    }
+    if (value === 'browser_check' || value === 'managed_widget') {
+        return 'browser_check';
+    }
+    return 'auto';
+}
+function resolveLegacyServiceOverride(rawProvider) {
+    if (typeof rawProvider !== 'string' || !rawProvider.trim()) {
+        return undefined;
+    }
+    return rawProvider.trim().toLowerCase();
+}
+function resolveExternalServiceName(args) {
+    const legacyOverride = resolveLegacyServiceOverride(args.provider);
+    const configured = (process.env.CAPTCHA_PROVIDER || '').trim().toLowerCase();
+    return legacyOverride || configured || '2captcha';
+}
 async function solveWith2Captcha(apiKey, params, timeoutMs) {
     const start = Date.now();
-    const baseUrl = CAPTCHA_2CAPTCHA_BASE_URL;
+    const baseUrl = CAPTCHA_SOLVER_BASE_URL;
+    if (!baseUrl) {
+        throw new Error('CAPTCHA_SOLVER_BASE_URL must be configured before using external_service mode.');
+    }
     const submitBody = {
         key: apiKey,
         json: 1,
     };
-    if (params.type === 'turnstile' || params.type === 'recaptcha_v2' || params.type === 'hcaptcha') {
-        submitBody.method = params.type === 'turnstile' ? 'turnstile' : params.type === 'hcaptcha' ? 'hcaptcha' : 'userrecaptcha';
+    if (params.taskKind === 'turnstile' ||
+        params.taskKind === 'recaptcha_v2' ||
+        params.taskKind === 'hcaptcha') {
+        submitBody.method =
+            params.taskKind === 'turnstile'
+                ? 'turnstile'
+                : params.taskKind === 'hcaptcha'
+                    ? 'hcaptcha'
+                    : 'userrecaptcha';
         submitBody.sitekey = params.siteKey;
         submitBody.pageurl = params.pageUrl;
     }
@@ -61,8 +110,8 @@ async function solveWith2Captcha(apiKey, params, timeoutMs) {
         if (resultData.status === 1) {
             return {
                 token: resultData.request,
-                type: params.type,
-                provider: '2captcha',
+                challengeType: params.taskKind === 'image' ? 'image' : 'widget',
+                mode: 'external_service',
                 durationMs: Date.now() - start,
             };
         }
@@ -76,73 +125,87 @@ export async function handleCaptchaVisionSolve(args, collector) {
     const page = await collector.getActivePage();
     if (!page)
         throw new Error('No active page.');
-    const provider = args.provider || process.env.CAPTCHA_PROVIDER || 'manual';
+    const mode = normalizeSolverMode(args.mode ?? args.provider ?? process.env.CAPTCHA_PROVIDER);
+    const externalService = resolveExternalServiceName(args);
     const apiKey = args.apiKey || process.env.CAPTCHA_API_KEY || '';
-    const typeHint = args.typeHint || 'auto';
+    const challengeTypeHint = normalizeChallengeTypeHint(args.challengeType ?? args.typeHint);
     const timeoutMs = Math.min(Math.max(args.timeoutMs ?? CAPTCHA_DEFAULT_TIMEOUT_MS, CAPTCHA_MIN_TIMEOUT_MS), CAPTCHA_MAX_TIMEOUT_MS);
     const maxRetries = Math.min(Math.max(args.maxRetries ?? CAPTCHA_DEFAULT_RETRIES, 0), CAPTCHA_MAX_RETRIES);
-    let captchaType = typeHint;
+    let challengeType = challengeTypeHint;
+    let taskKind = challengeTypeHint === 'image' ? 'image' : 'recaptcha_v2';
     let siteKey = args.siteKey;
     const pageUrl = args.pageUrl || page.url();
-    if (captchaType === 'auto') {
+    if (challengeType === 'auto') {
         const detected = await page.evaluate(() => {
             if (document.querySelector('[data-sitekey]')) {
                 const el = document.querySelector('[data-sitekey]');
                 const sk = el?.getAttribute('data-sitekey') || '';
-                if (document.querySelector('.cf-turnstile'))
-                    return { type: 'turnstile', siteKey: sk };
-                if (document.querySelector('.h-captcha'))
-                    return { type: 'hcaptcha', siteKey: sk };
-                return { type: 'recaptcha_v2', siteKey: sk };
+                if (document.querySelector('.cf-turnstile')) {
+                    return { challengeType: 'widget', taskKind: 'turnstile', siteKey: sk };
+                }
+                if (document.querySelector('.h-captcha')) {
+                    return { challengeType: 'widget', taskKind: 'hcaptcha', siteKey: sk };
+                }
+                return { challengeType: 'widget', taskKind: 'recaptcha_v2', siteKey: sk };
+            }
+            if (document.querySelector('iframe[src*="recaptcha"]')) {
+                return { challengeType: 'widget', taskKind: 'recaptcha_v2', siteKey: '' };
+            }
+            if (document.querySelector('iframe[src*="hcaptcha"]')) {
+                return { challengeType: 'widget', taskKind: 'hcaptcha', siteKey: '' };
             }
-            if (document.querySelector('iframe[src*="recaptcha"]'))
-                return { type: 'recaptcha_v2', siteKey: '' };
-            if (document.querySelector('iframe[src*="hcaptcha"]'))
-                return { type: 'hcaptcha', siteKey: '' };
-            if (document.querySelector('.cf-turnstile'))
-                return { type: 'turnstile', siteKey: '' };
-            return { type: 'image', siteKey: '' };
+            if (document.querySelector('.cf-turnstile')) {
+                return { challengeType: 'widget', taskKind: 'turnstile', siteKey: '' };
+            }
+            return { challengeType: 'image', taskKind: 'image', siteKey: '' };
         });
-        captchaType = detected.type;
+        challengeType = detected.challengeType;
+        taskKind = detected.taskKind;
         if (!siteKey && detected.siteKey)
             siteKey = detected.siteKey;
     }
-    if (provider === 'manual') {
+    else if (challengeType === 'image') {
+        taskKind = 'image';
+    }
+    else {
+        taskKind = 'recaptcha_v2';
+    }
+    if (mode === 'manual') {
         return toTextResponse({
             success: true,
             mode: 'manual',
-            captchaType,
+            challengeType,
             siteKey: siteKey ?? null,
             instruction: 'Please solve the CAPTCHA manually in the browser, then continue.',
-            hint: 'Set CAPTCHA_PROVIDER and CAPTCHA_API_KEY env vars for automatic solving.',
+            hint: 'Configure an external solver service and CAPTCHA_API_KEY to automate this flow.',
         });
     }
     if (!apiKey) {
-        return toErrorResponse('captcha_vision_solve', new Error(`API key required for provider "${provider}". Set CAPTCHA_API_KEY env var.`));
+        return toErrorResponse('captcha_vision_solve', new Error('External solver credentials are required. Set CAPTCHA_API_KEY.'));
     }
     let lastError = null;
     for (let attempt = 0; attempt <= maxRetries; attempt++) {
         try {
             let result;
-            if (provider === '2captcha') {
+            if (externalService === '2captcha') {
                 result = await solveWith2Captcha(apiKey, {
-                    type: captchaType,
+                    taskKind,
                     siteKey,
                     pageUrl,
                 }, timeoutMs);
             }
-            else if (provider === 'anticaptcha' || provider === 'capsolver') {
-                throw new Error(`Provider "${provider}" is not yet implemented. ` +
-                    `Currently only "2captcha" and "manual" are supported.`);
+            else if (externalService === 'anticaptcha' || externalService === 'capsolver') {
+                throw new Error('The selected external solver service is not yet implemented. ' +
+                    'Currently only the configured primary service and manual mode are supported.');
             }
             else {
-                throw new Error(`Unsupported provider: ${provider}`);
+                throw new Error('Unsupported external solver service.');
             }
             return toTextResponse({
                 success: true,
                 token: result.token,
-                captchaType: result.type,
-                provider: result.provider,
+                challengeType: result.challengeType,
+                mode: result.mode,
                 durationMs: result.durationMs,
                 attempt: attempt + 1,
             });
@@ -153,17 +216,18 @@ export async function handleCaptchaVisionSolve(args, collector) {
         }
     }
     return toErrorResponse('captcha_vision_solve', lastError ?? new Error('All attempts failed'), {
-        captchaType,
-        provider,
+        challengeType,
+        mode,
         maxRetries,
-        suggestion: 'Try a different provider or solve manually.',
+        suggestion: 'Try manual mode or adjust the external solver configuration.',
     });
 }
-export async function handleTurnstileSolve(args, collector) {
+export async function handleWidgetChallengeSolve(args, collector) {
     const page = await collector.getActivePage();
     if (!page)
         throw new Error('No active page.');
-    const provider = args.provider || process.env.CAPTCHA_PROVIDER || 'manual';
+    const mode = normalizeSolverMode(args.mode ?? args.provider ?? process.env.CAPTCHA_PROVIDER);
+    const externalService = resolveExternalServiceName(args);
     const apiKey = args.apiKey || process.env.CAPTCHA_API_KEY || '';
     const timeoutMs = Math.min(Math.max(args.timeoutMs ?? 120_000, 5_000), 600_000);
     const injectToken = args.injectToken ?? true;
@@ -176,9 +240,9 @@ export async function handleTurnstileSolve(args, collector) {
         }) || undefined;
     }
     if (!siteKey) {
-        return toErrorResponse('turnstile_solve', new Error('Could not detect Turnstile siteKey. Provide it manually or ensure the page has a Turnstile widget.'));
+        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 (provider === 'hook') {
+    if (mode === 'hook') {
         const hookTimeoutMs = Math.min(timeoutMs, 30_000);
         const token = await page.evaluate((hookTimeout) => {
             return new Promise((resolve, reject) => {
@@ -195,7 +259,7 @@ export async function handleTurnstileSolve(args, collector) {
                 }
                 else {
                     clearTimeout(timeout);
-                    reject(new Error('No turnstile callbacks found. Try provider: "2captcha" instead.'));
+                    reject(new Error('No widget callbacks found. Try external_service mode instead.'));
                 }
             });
         }, hookTimeoutMs).catch(() => null);
@@ -204,29 +268,31 @@ export async function handleTurnstileSolve(args, collector) {
                 success: true,
                 token,
                 method: 'hook',
+                challengeType: 'widget',
                 siteKey,
             });
         }
     }
-    if (provider === 'manual') {
+    if (mode === 'manual') {
         return toTextResponse({
             success: true,
             mode: 'manual',
+            challengeType: 'widget',
             siteKey,
             pageUrl,
-            instruction: 'Please complete the Turnstile challenge manually.',
+            instruction: 'Please complete the widget challenge manually.',
         });
     }
-    if (provider !== '2captcha') {
-        return toErrorResponse('turnstile_solve', new Error(`Provider "${provider}" is not yet implemented for Turnstile. ` +
-            `Currently only "2captcha", "manual", and "hook" are supported.`));
+    if (externalService !== '2captcha') {
+        return toErrorResponse('widget_challenge_solve', new Error('The selected external solver service is not implemented for this widget flow. ' +
+            'Currently only the configured primary service, manual mode, and hook mode are supported.'));
     }
     if (!apiKey) {
-        return toErrorResponse('turnstile_solve', new Error('API key required'));
+        return toErrorResponse('widget_challenge_solve', new Error('External solver credentials are required.'));
     }
     try {
         const result = await solveWith2Captcha(apiKey, {
-            type: 'turnstile',
+            taskKind: 'turnstile',
             siteKey,
             pageUrl,
         }, timeoutMs);
@@ -244,17 +310,18 @@ export async function handleTurnstileSolve(args, collector) {
         return toTextResponse({
             success: true,
             token: result.token,
+            challengeType: result.challengeType,
             siteKey,
-            provider: result.provider,
+            mode: result.mode,
             durationMs: result.durationMs,
             injected: injectToken,
         });
     }
     catch (error) {
-        return toErrorResponse('turnstile_solve', error, {
+        return toErrorResponse('widget_challenge_solve', error, {
             siteKey,
-            provider,
-            suggestion: 'Try provider: "manual" or provider: "hook".',
+            mode,
+            suggestion: 'Try manual mode or hook mode.',
         });
     }
 }

package/dist/server/domains/browser/handlers/page-navigation.js

@@ -23,7 +23,6 @@ export class PageNavigationHandlers {
                         text: JSON.stringify({
                             success: true,
                             driver: 'camoufox',
-                            captcha_detected: false,
                             url: page.url(),
                             title: await page.title(),
                             network_monitoring: {
@@ -51,7 +50,6 @@ export class PageNavigationHandlers {
                     type: 'text',
                     text: JSON.stringify({
                         success: true,
-                        captcha_detected: false,
                         url: currentUrl,
                         title,
                         network_monitoring: {

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

@@ -394,6 +394,6 @@ export declare class BrowserToolHandlers {
     handleHumanScroll(args: Record<string, unknown>): Promise<unknown>;
     handleHumanTyping(args: Record<string, unknown>): Promise<unknown>;
     handleCaptchaVisionSolve(args: Record<string, unknown>): Promise<unknown>;
-    handleTurnstileSolve(args: Record<string, unknown>): Promise<unknown>;
+    handleWidgetChallengeSolve(args: Record<string, unknown>): Promise<unknown>;
 }
 export { BrowserControlHandlers, CamoufoxBrowserHandlers, PageNavigationHandlers, PageInteractionHandlers, PageEvaluationHandlers, PageDataHandlers, DOMQueryHandlers, DOMStyleHandlers, DOMSearchHandlers, ConsoleHandlers, ScriptManagementHandlers, CaptchaHandlers, StealthInjectionHandlers, FrameworkStateHandlers, IndexedDBDumpHandlers, DetailedDataHandlers };

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

@@ -20,7 +20,7 @@ import { IndexedDBDumpHandlers } from '../../domains/browser/handlers/indexeddb-
 import { DetailedDataHandlers } from '../../domains/browser/handlers/detailed-data.js';
 import { initializeBrowserHandlerModules } from '../../domains/browser/handlers/facade-initializer.js';
 import { handleHumanMouse, handleHumanScroll, handleHumanTyping, } from '../../domains/browser/handlers/human-behavior.js';
-import { handleCaptchaVisionSolve, handleTurnstileSolve, } from '../../domains/browser/handlers/captcha-solver.js';
+import { handleCaptchaVisionSolve, handleWidgetChallengeSolve, } from '../../domains/browser/handlers/captcha-solver.js';
 import { handleCamoufoxLaunchFlow, handleCamoufoxNavigateFlow, } from '../../domains/browser/handlers/camoufox-flow.js';
 export class BrowserToolHandlers {
     collector;
@@ -381,8 +381,8 @@ export class BrowserToolHandlers {
     async handleCaptchaVisionSolve(args) {
         return handleCaptchaVisionSolve(args, this.collector);
     }
-    async handleTurnstileSolve(args) {
-        return handleTurnstileSolve(args, this.collector);
+    async handleWidgetChallengeSolve(args) {
+        return handleWidgetChallengeSolve(args, this.collector);
     }
 }
 export { BrowserControlHandlers, CamoufoxBrowserHandlers, PageNavigationHandlers, PageInteractionHandlers, PageEvaluationHandlers, PageDataHandlers, DOMQueryHandlers, DOMStyleHandlers, DOMSearchHandlers, ConsoleHandlers, ScriptManagementHandlers, CaptchaHandlers, StealthInjectionHandlers, FrameworkStateHandlers, IndexedDBDumpHandlers, DetailedDataHandlers };

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

@@ -79,7 +79,7 @@ const manifest = {
         { tool: t('human_scroll'), domain: DOMAIN, bind: b((h, a) => h.handleHumanScroll(a)) },
         { tool: t('human_typing'), domain: DOMAIN, bind: b((h, a) => h.handleHumanTyping(a)) },
         { tool: t('captcha_vision_solve'), domain: DOMAIN, bind: b((h, a) => h.handleCaptchaVisionSolve(a)) },
-        { tool: t('turnstile_solve'), domain: DOMAIN, bind: b((h, a) => h.handleTurnstileSolve(a)) },
+        { tool: t('widget_challenge_solve'), domain: DOMAIN, bind: b((h, a) => h.handleWidgetChallengeSolve(a)) },
     ],
 };
 export default manifest;

package/dist/server/domains/shared/modules.d.ts

@@ -1,6 +1,7 @@
 export { CodeAnalyzer } from '../../../modules/analyzer/CodeAnalyzer.js';
 export { CamoufoxBrowserManager } from '../../../modules/browser/CamoufoxBrowserManager.js';
 export { AICaptchaDetector } from '../../../modules/captcha/AICaptchaDetector.js';
+export type { CaptchaType, CaptchaProviderHint, CaptchaDetectionResult, AICaptchaDetectionResult, CaptchaDetectionConfig, } from '../../../modules/captcha/types.js';
 export { CodeCollector } from '../../../modules/collector/CodeCollector.js';
 export { DOMInspector } from '../../../modules/collector/DOMInspector.js';
 export { PageController } from '../../../modules/collector/PageController.js';

package/dist/server/domains/transform/handlers.impl.transform-base.js

@@ -28,98 +28,98 @@ export const CRYPTO_KEYWORDS = [
     'aes',
     'rsa',
 ];
-const CRYPTO_TEST_WORKER_SCRIPT = `
-const __bootstrap = async () => {
-  const [workerThreads, vm, perfHooks] = await Promise.all([
-    import('node:worker_threads'),
-    import('node:vm'),
-    import('node:perf_hooks'),
-  ]);
-
-  const parentPort = workerThreads.parentPort;
-  const performance = perfHooks.performance;
-
-  if (!parentPort) {
-    throw new Error('worker parentPort is unavailable');
-  }
-
-  function normalizeOutput(value) {
-    if (value === undefined) return '__undefined__';
-    if (value === null) return 'null';
-    if (typeof value === 'string') return value;
-    if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') return String(value);
-    try { return JSON.stringify(value); } catch { return String(value); }
-  }
-
-  parentPort.on('message', async (msg) => {
-    const { jobId, payload } = msg;
-    try {
-      const { code, functionName, testInputs } = payload;
-      const sandbox = {
-        console: { log() {}, warn() {}, error() {} },
-        Buffer,
-        TextEncoder,
-        TextDecoder,
-        atob: (v) => Buffer.from(String(v), 'base64').toString('binary'),
-        btoa: (v) => Buffer.from(String(v), 'binary').toString('base64'),
-      };
-      sandbox.globalThis = sandbox;
-      const context = vm.createContext(sandbox);
-
-      const isValidIdentifier = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(functionName);
-      const bindCode = isValidIdentifier
-        ? "\\n;globalThis.__targetFn = (typeof " + functionName + " !== 'undefined' ? " + functionName + " : globalThis[" + JSON.stringify(functionName) + "]);"
-        : "\\n;globalThis.__targetFn = globalThis[" + JSON.stringify(functionName) + "];";
-
-      const script = new vm.Script(code + bindCode, { timeout: 5000 });
-      script.runInContext(context, { timeout: 5000 });
-
-      const targetFn = context.__targetFn;
-      if (typeof targetFn !== 'function') {
-        throw new Error("Function not found or not callable: " + functionName);
-      }
-
-      const rows = [];
-      for (const input of testInputs) {
-        const started = performance.now();
-        try {
-          const raw = targetFn(input);
-          const resolved = raw && typeof raw.then === 'function' ? await raw : raw;
-          rows.push({
-            input,
-            output: normalizeOutput(resolved),
-            duration: Number((performance.now() - started).toFixed(3)),
-          });
-        } catch (err) {
-          rows.push({
-            input,
-            output: '',
-            error: err && err.message ? err.message : String(err),
-            duration: Number((performance.now() - started).toFixed(3)),
-          });
-        }
-      }
-
-      parentPort.postMessage({ jobId, ok: true, result: { ok: true, results: rows } });
-    } catch (error) {
-      parentPort.postMessage({
-        jobId,
-        ok: true,
-        result: {
-          ok: false,
-          error: error && error.message ? error.message : String(error),
-          results: [],
-        },
-      });
-    }
-  });
-};
-
-__bootstrap().catch((error) => {
-  if (typeof console !== 'undefined' && typeof console.error === 'function') {
-    console.error('crypto harness worker bootstrap failed:', error && error.message ? error.message : String(error));
-  }
-});
+const CRYPTO_TEST_WORKER_SCRIPT = `
+const __bootstrap = async () => {
+  const [workerThreads, vm, perfHooks] = await Promise.all([
+    import('node:worker_threads'),
+    import('node:vm'),
+    import('node:perf_hooks'),
+  ]);
+
+  const parentPort = workerThreads.parentPort;
+  const performance = perfHooks.performance;
+
+  if (!parentPort) {
+    throw new Error('worker parentPort is unavailable');
+  }
+
+  function normalizeOutput(value) {
+    if (value === undefined) return '__undefined__';
+    if (value === null) return 'null';
+    if (typeof value === 'string') return value;
+    if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') return String(value);
+    try { return JSON.stringify(value); } catch { return String(value); }
+  }
+
+  parentPort.on('message', async (msg) => {
+    const { jobId, payload } = msg;
+    try {
+      const { code, functionName, testInputs } = payload;
+      const sandbox = {
+        console: { log() {}, warn() {}, error() {} },
+        Buffer,
+        TextEncoder,
+        TextDecoder,
+        atob: (v) => Buffer.from(String(v), 'base64').toString('binary'),
+        btoa: (v) => Buffer.from(String(v), 'binary').toString('base64'),
+      };
+      sandbox.globalThis = sandbox;
+      const context = vm.createContext(sandbox);
+
+      const isValidIdentifier = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(functionName);
+      const bindCode = isValidIdentifier
+        ? "\\n;globalThis.__targetFn = (typeof " + functionName + " !== 'undefined' ? " + functionName + " : globalThis[" + JSON.stringify(functionName) + "]);"
+        : "\\n;globalThis.__targetFn = globalThis[" + JSON.stringify(functionName) + "];";
+
+      const script = new vm.Script(code + bindCode, { timeout: 5000 });
+      script.runInContext(context, { timeout: 5000 });
+
+      const targetFn = context.__targetFn;
+      if (typeof targetFn !== 'function') {
+        throw new Error("Function not found or not callable: " + functionName);
+      }
+
+      const rows = [];
+      for (const input of testInputs) {
+        const started = performance.now();
+        try {
+          const raw = targetFn(input);
+          const resolved = raw && typeof raw.then === 'function' ? await raw : raw;
+          rows.push({
+            input,
+            output: normalizeOutput(resolved),
+            duration: Number((performance.now() - started).toFixed(3)),
+          });
+        } catch (err) {
+          rows.push({
+            input,
+            output: '',
+            error: err && err.message ? err.message : String(err),
+            duration: Number((performance.now() - started).toFixed(3)),
+          });
+        }
+      }
+
+      parentPort.postMessage({ jobId, ok: true, result: { ok: true, results: rows } });
+    } catch (error) {
+      parentPort.postMessage({
+        jobId,
+        ok: true,
+        result: {
+          ok: false,
+          error: error && error.message ? error.message : String(error),
+          results: [],
+        },
+      });
+    }
+  });
+};
+
+__bootstrap().catch((error) => {
+  if (typeof console !== 'undefined' && typeof console.error === 'function') {
+    console.error('crypto harness worker bootstrap failed:', error && error.message ? error.message : String(error));
+  }
+});
 `;
 export class TransformToolHandlersBase {
     collector;
@@ -333,16 +333,16 @@ export class TransformToolHandlersBase {
         return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(value);
     }
     buildCryptoPolyfills() {
-        return `
-const __textEncoder = typeof TextEncoder !== 'undefined' ? new TextEncoder() : null;
-const __textDecoder = typeof TextDecoder !== 'undefined' ? new TextDecoder() : null;
-
-if (typeof globalThis.atob === 'undefined') {
-  globalThis.atob = (value) => Buffer.from(String(value), 'base64').toString('binary');
-}
-if (typeof globalThis.btoa === 'undefined') {
-  globalThis.btoa = (value) => Buffer.from(String(value), 'binary').toString('base64');
-}
+        return `
+const __textEncoder = typeof TextEncoder !== 'undefined' ? new TextEncoder() : null;
+const __textDecoder = typeof TextDecoder !== 'undefined' ? new TextDecoder() : null;
+
+if (typeof globalThis.atob === 'undefined') {
+  globalThis.atob = (value) => Buffer.from(String(value), 'base64').toString('binary');
+}
+if (typeof globalThis.btoa === 'undefined') {
+  globalThis.btoa = (value) => Buffer.from(String(value), 'binary').toString('base64');
+}
 `.trim();
     }
     async runCryptoHarness(code, functionName, testInputs) {