@jshookmcp/jshook 0.1.9 → 0.2.1

package/dist/tests/server/domains/transform/exports.test.d.ts

@@ -0,0 +1 @@
+import '../shared/manifest-test-mocks.js';

package/dist/tests/server/domains/transform/exports.test.js

@@ -0,0 +1,21 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import '../shared/manifest-test-mocks.js';
+import { assertDomainExportContract } from '../shared/export-contract-helpers.js';
+describe('server/domains/transform exports', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.resetModules();
+    });
+    it('exposes transform tool definitions and a matching manifest', async () => {
+        expect.hasAssertions();
+        await assertDomainExportContract({
+            expectedDomain: 'transform',
+            definitionExportNames: ['transformTools'],
+            loadDefinitions: () => import('../../../../src/server/domains/transform/definitions.js'),
+            getToolArrays: (module) => [
+                module.transformTools,
+            ],
+            loadManifest: () => import('../../../../src/server/domains/transform/manifest.js'),
+        });
+    });
+});

package/dist/tests/server/domains/transform/handlers-impl-core.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/server/domains/transform/handlers-impl-core.test.js

@@ -0,0 +1,242 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+vi.mock('@utils/WorkerPool', () => ({
+    WorkerPool: class MockWorkerPool {
+        submit = vi.fn();
+        close = vi.fn().mockResolvedValue(undefined);
+    },
+}));
+vi.mock('@src/constants', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        TRANSFORM_WORKER_TIMEOUT_MS: 5000,
+        TRANSFORM_CRYPTO_POOL_MAX_WORKERS: 2,
+        TRANSFORM_CRYPTO_POOL_IDLE_TIMEOUT_MS: 30000,
+        TRANSFORM_CRYPTO_POOL_MAX_OLD_GEN_MB: 64,
+        TRANSFORM_CRYPTO_POOL_MAX_YOUNG_GEN_MB: 32,
+    };
+});
+import { TransformToolHandlers } from '../../../../src/server/domains/transform/handlers.impl.core.js';
+function parseJson(response) {
+    return JSON.parse(response.content[0].text);
+}
+describe('TransformToolHandlers (handlers.impl.core)', () => {
+    const collector = {
+        getActivePage: vi.fn(),
+    };
+    let handlers;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        handlers = new TransformToolHandlers(collector);
+    });
+    describe('handleAstTransformPreview', () => {
+        it('returns error when code is missing', async () => {
+            const body = parseJson(await handlers.handleAstTransformPreview({ transforms: ['constant_fold'] }));
+            expect(body.tool).toBe('ast_transform_preview');
+            expect(body.error).toContain('code must be a non-empty string');
+        });
+        it('returns error when code is empty string', async () => {
+            const body = parseJson(await handlers.handleAstTransformPreview({ code: '', transforms: ['constant_fold'] }));
+            expect(body.tool).toBe('ast_transform_preview');
+            expect(body.error).toContain('code must be a non-empty string');
+        });
+        it('returns error when transforms is missing', async () => {
+            const body = parseJson(await handlers.handleAstTransformPreview({ code: 'var x = 1;' }));
+            expect(body.tool).toBe('ast_transform_preview');
+            expect(body.error).toContain('transforms');
+        });
+        it('returns error for invalid transform kind', async () => {
+            const body = parseJson(await handlers.handleAstTransformPreview({ code: 'var x = 1;', transforms: ['nope'] }));
+            expect(body.tool).toBe('ast_transform_preview');
+            expect(body.error).toContain('Unsupported transform');
+        });
+        it('applies constant_fold and returns diff when preview=true', async () => {
+            const body = parseJson(await handlers.handleAstTransformPreview({
+                code: 'const x = 1 + 2;',
+                transforms: ['constant_fold'],
+                preview: true,
+            }));
+            expect(body.appliedTransforms).toContain('constant_fold');
+            expect(typeof body.diff).toBe('string');
+            expect(body.diff.length).toBeGreaterThan(0);
+            expect(body.transformed).toContain('3');
+            expect(body.original).toBe('const x = 1 + 2;');
+        });
+        it('returns empty diff when preview=false', async () => {
+            const body = parseJson(await handlers.handleAstTransformPreview({
+                code: 'const x = 1 + 2;',
+                transforms: ['constant_fold'],
+                preview: false,
+            }));
+            expect(body.diff).toBe('');
+            expect(body.transformed).toContain('3');
+        });
+        it('defaults preview to true', async () => {
+            const body = parseJson(await handlers.handleAstTransformPreview({
+                code: 'const x = 1 + 2;',
+                transforms: ['constant_fold'],
+            }));
+            expect(typeof body.diff).toBe('string');
+        });
+        it('returns empty diff when no transforms change the code', async () => {
+            const body = parseJson(await handlers.handleAstTransformPreview({
+                code: 'const x = 1;',
+                transforms: ['dead_code_remove'],
+                preview: true,
+            }));
+            expect(body.appliedTransforms).toEqual([]);
+            expect(body.diff).toBe('');
+            expect(body.transformed).toBe('const x = 1;');
+        });
+        it('applies multiple transforms in order', async () => {
+            const body = parseJson(await handlers.handleAstTransformPreview({
+                code: "if(false){dead}else{var a = '\\x48\\x69';}",
+                transforms: ['dead_code_remove', 'string_decrypt'],
+                preview: true,
+            }));
+            expect(body.appliedTransforms).toContain('dead_code_remove');
+            expect(body.appliedTransforms).toContain('string_decrypt');
+            expect(body.transformed).toContain('Hi');
+        });
+    });
+    describe('handleAstTransformChain', () => {
+        it('creates a named chain successfully', async () => {
+            const body = parseJson(await handlers.handleAstTransformChain({
+                name: 'my-chain',
+                description: 'A test chain',
+                transforms: ['constant_fold', 'dead_code_remove'],
+            }));
+            expect(body.created).toBe(true);
+            expect(body.name).toBe('my-chain');
+            expect(body.transforms).toEqual(['constant_fold', 'dead_code_remove']);
+        });
+        it('returns error when name is missing', async () => {
+            const body = parseJson(await handlers.handleAstTransformChain({
+                transforms: ['constant_fold'],
+            }));
+            expect(body.tool).toBe('ast_transform_chain');
+            expect(body.error).toContain('name must be a non-empty string');
+        });
+        it('returns error when name is empty string', async () => {
+            const body = parseJson(await handlers.handleAstTransformChain({
+                name: '',
+                transforms: ['constant_fold'],
+            }));
+            expect(body.tool).toBe('ast_transform_chain');
+            expect(body.error).toContain('name');
+        });
+        it('returns error when name is whitespace only', async () => {
+            const body = parseJson(await handlers.handleAstTransformChain({
+                name: '   ',
+                transforms: ['constant_fold'],
+            }));
+            expect(body.tool).toBe('ast_transform_chain');
+            expect(body.error).toContain('name cannot be empty');
+        });
+        it('trims the chain name', async () => {
+            const body = parseJson(await handlers.handleAstTransformChain({
+                name: '  my-chain  ',
+                transforms: ['constant_fold'],
+            }));
+            expect(body.name).toBe('my-chain');
+        });
+        it('stores description when provided', async () => {
+            const body = parseJson(await handlers.handleAstTransformChain({
+                name: 'desc-chain',
+                description: 'my desc',
+                transforms: ['constant_fold'],
+            }));
+            expect(body.created).toBe(true);
+        });
+        it('omits description when empty or missing', async () => {
+            const body = parseJson(await handlers.handleAstTransformChain({
+                name: 'no-desc',
+                description: '',
+                transforms: ['constant_fold'],
+            }));
+            expect(body.created).toBe(true);
+        });
+        it('overwrites existing chain with same name', async () => {
+            await handlers.handleAstTransformChain({
+                name: 'reuse',
+                transforms: ['constant_fold'],
+            });
+            const body = parseJson(await handlers.handleAstTransformChain({
+                name: 'reuse',
+                transforms: ['dead_code_remove', 'rename_vars'],
+            }));
+            expect(body.created).toBe(true);
+            expect(body.transforms).toEqual(['dead_code_remove', 'rename_vars']);
+        });
+        it('returns error for invalid transform in chain', async () => {
+            const body = parseJson(await handlers.handleAstTransformChain({
+                name: 'bad',
+                transforms: ['constant_fold', 'invalid_thing'],
+            }));
+            expect(body.tool).toBe('ast_transform_chain');
+            expect(body.error).toContain('Unsupported transform');
+        });
+    });
+    describe('handleAstTransformApply', () => {
+        it('returns error when neither code nor scriptId is provided', async () => {
+            const body = parseJson(await handlers.handleAstTransformApply({}));
+            expect(body.tool).toBe('ast_transform_apply');
+            expect(body.error).toContain('Either code or scriptId must be provided');
+        });
+        it('applies transforms with inline code', async () => {
+            const body = parseJson(await handlers.handleAstTransformApply({
+                code: 'const y = 2 + 3;',
+                transforms: ['constant_fold'],
+            }));
+            expect(body.transformed).toContain('5');
+            expect(body.stats.originalSize).toBe('const y = 2 + 3;'.length);
+            expect(body.stats.transformedSize).toBeGreaterThan(0);
+            expect(body.stats.transformsApplied).toContain('constant_fold');
+        });
+        it('applies a named chain by chainName', async () => {
+            await handlers.handleAstTransformChain({
+                name: 'quick',
+                transforms: ['constant_fold'],
+            });
+            const body = parseJson(await handlers.handleAstTransformApply({
+                chainName: 'quick',
+                code: 'const z = 10 + 20;',
+            }));
+            expect(body.transformed).toContain('30');
+            expect(body.stats.transformsApplied).toContain('constant_fold');
+        });
+        it('returns error for unknown chainName', async () => {
+            const body = parseJson(await handlers.handleAstTransformApply({
+                chainName: 'nonexistent',
+                code: 'const a = 1;',
+            }));
+            expect(body.tool).toBe('ast_transform_apply');
+            expect(body.error).toContain('not found');
+        });
+        it('reports stats with original and transformed sizes', async () => {
+            const code = 'if(false){dead}else{var x = 1 + 2;}';
+            const body = parseJson(await handlers.handleAstTransformApply({
+                code,
+                transforms: ['dead_code_remove', 'constant_fold'],
+            }));
+            expect(body.stats.originalSize).toBe(code.length);
+            expect(body.stats.transformedSize).toBeLessThan(code.length);
+        });
+        it('prefers inline code over scriptId when both are provided', async () => {
+            const body = parseJson(await handlers.handleAstTransformApply({
+                code: 'const x = 1 + 1;',
+                scriptId: 'some-id',
+                transforms: ['constant_fold'],
+            }));
+            expect(body.transformed).toContain('2');
+        });
+        it('handles empty chainName as no chain (uses inline transforms)', async () => {
+            const body = parseJson(await handlers.handleAstTransformApply({
+                chainName: '',
+                code: 'const x = 3 + 4;',
+                transforms: ['constant_fold'],
+            }));
+            expect(body.transformed).toContain('7');
+        });
+    });
+});

package/dist/tests/server/domains/transform/transform-crypto-additional.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/server/domains/transform/transform-crypto-additional.test.js

@@ -0,0 +1,402 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+vi.mock('@utils/WorkerPool', () => ({
+    WorkerPool: class MockWorkerPool {
+        submit = vi.fn();
+        close = vi.fn().mockResolvedValue(undefined);
+    },
+}));
+vi.mock('@src/constants', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        TRANSFORM_WORKER_TIMEOUT_MS: 5000,
+        TRANSFORM_CRYPTO_POOL_MAX_WORKERS: 2,
+        TRANSFORM_CRYPTO_POOL_IDLE_TIMEOUT_MS: 30000,
+        TRANSFORM_CRYPTO_POOL_MAX_OLD_GEN_MB: 64,
+        TRANSFORM_CRYPTO_POOL_MAX_YOUNG_GEN_MB: 32,
+    };
+});
+vi.mock('@server/domains/shared/modules', () => ({
+    ScriptManager: vi.fn(),
+}));
+import { TransformToolHandlersCrypto } from '../../../../src/server/domains/transform/handlers.impl.transform-crypto.js';
+function parseJson(response) {
+    return JSON.parse(response.content[0].text);
+}
+describe('TransformToolHandlersCrypto — additional coverage', () => {
+    const page = {
+        evaluate: vi.fn(),
+    };
+    const collector = {
+        getActivePage: vi.fn(async () => page),
+        getFileByUrl: vi.fn(() => null),
+    };
+    let handlers;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        handlers = new TransformToolHandlersCrypto(collector);
+    });
+    describe('handleCryptoExtractStandalone — edge cases', () => {
+        it('handles whitespace-only targetFunction', async () => {
+            const body = parseJson(await handlers.handleCryptoExtractStandalone({ targetFunction: '   ' }));
+            expect(body.tool).toBe('crypto_extract_standalone');
+            expect(body.error).toBeDefined();
+        });
+        it('handles extracted result with multiple dependency snippets', async () => {
+            page.evaluate.mockResolvedValueOnce({
+                targetPath: 'window.encrypt',
+                targetSource: 'function encrypt(data) { return md5(sha256(data)); }',
+                candidates: [
+                    { path: 'window.encrypt', source: 'function encrypt(data) { return md5(sha256(data)); }', score: 20 },
+                ],
+                dependencies: ['md5', 'sha256', 'helpers'],
+                dependencySnippets: [
+                    'const md5 = function(v) { return v; };',
+                    'const sha256 = function(v) { return v; };',
+                    'const helpers = { util: 1 };',
+                ],
+            });
+            const body = parseJson(await handlers.handleCryptoExtractStandalone({
+                targetFunction: 'encrypt',
+                includePolyfills: true,
+            }));
+            expect(body.extractedCode).toContain("'use strict';");
+            expect(body.extractedCode).toContain('const md5');
+            expect(body.extractedCode).toContain('const sha256');
+            expect(body.extractedCode).toContain('const helpers');
+            expect(body.extractedCode).toContain('const encrypt');
+            expect(body.extractedCode).toContain('globalThis.encrypt');
+            expect(body.dependencies).toHaveLength(3);
+            expect(body.size).toBeGreaterThan(0);
+        });
+        it('handles extracted with no dependency snippets and polyfills disabled', async () => {
+            page.evaluate.mockResolvedValueOnce({
+                targetPath: 'window.hash',
+                targetSource: 'function hash(x) { return x.split("").reverse().join(""); }',
+                candidates: [
+                    { path: 'window.hash', source: 'function hash(x) { return x.split("").reverse().join(""); }', score: 5 },
+                ],
+                dependencies: [],
+                dependencySnippets: [],
+            });
+            const body = parseJson(await handlers.handleCryptoExtractStandalone({
+                targetFunction: 'hash',
+                includePolyfills: false,
+            }));
+            expect(body.extractedCode).toContain("'use strict';");
+            expect(body.extractedCode).not.toContain('atob');
+            expect(body.extractedCode).not.toContain('btoa');
+            expect(body.extractedCode).toContain('const hash');
+            expect(body.extractedCode).toContain('globalThis.hash');
+        });
+        it('resolves function name from targetPath when targetFunction last segment is not a valid identifier', async () => {
+            page.evaluate.mockResolvedValueOnce({
+                targetPath: 'window.crypto.signData',
+                targetSource: '(data) => data + "signed"',
+                candidates: [
+                    { path: 'window.crypto.signData', source: '(data) => data + "signed"', score: 10 },
+                ],
+                dependencies: [],
+                dependencySnippets: [],
+            });
+            const body = parseJson(await handlers.handleCryptoExtractStandalone({
+                targetFunction: '123',
+            }));
+            expect(body.extractedCode).toContain('signData');
+        });
+        it('returns null extracted result', async () => {
+            page.evaluate.mockResolvedValueOnce(null);
+            const body = parseJson(await handlers.handleCryptoExtractStandalone({ targetFunction: 'fn' }));
+            expect(body.tool).toBe('crypto_extract_standalone');
+            expect(body.error).toBeDefined();
+        });
+        it('handles includePolyfills as string "false"', async () => {
+            page.evaluate.mockResolvedValueOnce({
+                targetPath: 'window.fn',
+                targetSource: 'function fn() { return 1; }',
+                candidates: [{ path: 'window.fn', source: 'function fn() { return 1; }', score: 1 }],
+                dependencies: [],
+                dependencySnippets: [],
+            });
+            const body = parseJson(await handlers.handleCryptoExtractStandalone({
+                targetFunction: 'fn',
+                includePolyfills: 'false',
+            }));
+            expect(body.extractedCode).not.toContain('atob');
+        });
+        it('handles includePolyfills as string "true"', async () => {
+            page.evaluate.mockResolvedValueOnce({
+                targetPath: 'window.fn',
+                targetSource: 'function fn() { return 1; }',
+                candidates: [{ path: 'window.fn', source: 'function fn() { return 1; }', score: 1 }],
+                dependencies: [],
+                dependencySnippets: [],
+            });
+            const body = parseJson(await handlers.handleCryptoExtractStandalone({
+                targetFunction: 'fn',
+                includePolyfills: 'true',
+            }));
+            expect(body.extractedCode).toContain('atob');
+        });
+        it('handles includePolyfills as number 0', async () => {
+            page.evaluate.mockResolvedValueOnce({
+                targetPath: 'window.fn',
+                targetSource: 'function fn() { return 1; }',
+                candidates: [{ path: 'window.fn', source: 'function fn() { return 1; }', score: 1 }],
+                dependencies: [],
+                dependencySnippets: [],
+            });
+            const body = parseJson(await handlers.handleCryptoExtractStandalone({
+                targetFunction: 'fn',
+                includePolyfills: 0,
+            }));
+            expect(body.extractedCode).not.toContain('atob');
+        });
+    });
+    describe('handleCryptoTestHarness — additional edge cases', () => {
+        it('throws when testInputs is not an array', async () => {
+            const body = parseJson(await handlers.handleCryptoTestHarness({
+                code: 'function fn(x) { return x; }',
+                functionName: 'fn',
+                testInputs: 'not-an-array',
+            }));
+            expect(body.tool).toBe('crypto_test_harness');
+            expect(body.error).toContain('testInputs');
+        });
+        it('converts non-string test inputs to strings', async () => {
+            const pool = handlers.cryptoHarnessPool;
+            pool.submit.mockResolvedValueOnce({
+                ok: true,
+                results: [
+                    { input: '42', output: '42', duration: 0.1 },
+                    { input: 'true', output: 'true', duration: 0.1 },
+                ],
+            });
+            const body = parseJson(await handlers.handleCryptoTestHarness({
+                code: 'function fn(x) { return x; }',
+                functionName: 'fn',
+                testInputs: [42, true],
+            }));
+            expect(body.results).toHaveLength(2);
+            expect(body.allPassed).toBe(true);
+        });
+        it('strips error field from results when no error occurred', async () => {
+            const pool = handlers.cryptoHarnessPool;
+            pool.submit.mockResolvedValueOnce({
+                ok: true,
+                results: [
+                    { input: 'a', output: 'b', duration: 0.1 },
+                ],
+            });
+            const body = parseJson(await handlers.handleCryptoTestHarness({
+                code: 'function fn(x) { return "b"; }',
+                functionName: 'fn',
+                testInputs: ['a'],
+            }));
+            expect(body.results[0]).not.toHaveProperty('error');
+        });
+        it('includes error field in results when error occurred', async () => {
+            const pool = handlers.cryptoHarnessPool;
+            pool.submit.mockResolvedValueOnce({
+                ok: true,
+                results: [
+                    { input: 'a', output: '', duration: 0.0, error: 'something broke' },
+                ],
+            });
+            const body = parseJson(await handlers.handleCryptoTestHarness({
+                code: 'function fn() {}',
+                functionName: 'fn',
+                testInputs: ['a'],
+            }));
+            expect(body.results[0].error).toBe('something broke');
+            expect(body.allPassed).toBe(false);
+        });
+        it('handles worker returning empty results array', async () => {
+            const pool = handlers.cryptoHarnessPool;
+            pool.submit.mockResolvedValueOnce({
+                ok: true,
+                results: [],
+            });
+            const body = parseJson(await handlers.handleCryptoTestHarness({
+                code: 'function fn(x) { return x; }',
+                functionName: 'fn',
+                testInputs: ['a'],
+            }));
+            expect(body.results).toHaveLength(0);
+            expect(body.allPassed).toBe(true);
+        });
+        it('handles worker returning results without results field', async () => {
+            const pool = handlers.cryptoHarnessPool;
+            pool.submit.mockResolvedValueOnce({
+                ok: true,
+            });
+            const body = parseJson(await handlers.handleCryptoTestHarness({
+                code: 'function fn(x) { return x; }',
+                functionName: 'fn',
+                testInputs: ['a'],
+            }));
+            expect(body.results).toHaveLength(0);
+            expect(body.allPassed).toBe(true);
+        });
+        it('handles worker ok:false without error message', async () => {
+            const pool = handlers.cryptoHarnessPool;
+            pool.submit.mockResolvedValueOnce({
+                ok: false,
+            });
+            const body = parseJson(await handlers.handleCryptoTestHarness({
+                code: 'function fn() {}',
+                functionName: 'fn',
+                testInputs: ['x'],
+            }));
+            expect(body.allPassed).toBe(false);
+            expect(body.results[0].error).toBe('Worker execution failed');
+        });
+        it('handles non-Error exception from pool.submit', async () => {
+            const pool = handlers.cryptoHarnessPool;
+            pool.submit.mockRejectedValueOnce('string error');
+            const body = parseJson(await handlers.handleCryptoTestHarness({
+                code: 'function fn(x) { return x; }',
+                functionName: 'fn',
+                testInputs: ['a'],
+            }));
+            expect(body.allPassed).toBe(false);
+            expect(body.results[0].error).toBe('string error');
+        });
+    });
+    describe('handleCryptoCompare — additional edge cases', () => {
+        it('throws when testInputs is missing', async () => {
+            const body = parseJson(await handlers.handleCryptoCompare({
+                code1: 'function fn() {}',
+                code2: 'function fn() {}',
+                functionName: 'fn',
+            }));
+            expect(body.tool).toBe('crypto_compare');
+            expect(body.error).toContain('testInputs');
+        });
+        it('throws when testInputs is empty array', async () => {
+            const body = parseJson(await handlers.handleCryptoCompare({
+                code1: 'function fn() {}',
+                code2: 'function fn() {}',
+                functionName: 'fn',
+                testInputs: [],
+            }));
+            expect(body.tool).toBe('crypto_compare');
+            expect(body.error).toContain('testInputs');
+        });
+        it('handles missing result from one implementation (index out of range)', async () => {
+            const pool = handlers.cryptoHarnessPool;
+            pool.submit
+                .mockResolvedValueOnce({
+                ok: true,
+                results: [
+                    { input: 'a', output: 'A', duration: 0.1 },
+                    { input: 'b', output: 'B', duration: 0.1 },
+                ],
+            })
+                .mockResolvedValueOnce({
+                ok: true,
+                results: [
+                    { input: 'a', output: 'A', duration: 0.1 },
+                ],
+            });
+            const body = parseJson(await handlers.handleCryptoCompare({
+                code1: 'function fn(x) { return x.toUpperCase(); }',
+                code2: 'function fn(x) { return x.toUpperCase(); }',
+                functionName: 'fn',
+                testInputs: ['a', 'b'],
+            }));
+            expect(body.results).toHaveLength(2);
+            expect(body.results[0].match).toBe(true);
+            expect(body.results[1].match).toBe(false);
+            expect(body.results[1].error2).toBe('missing result from implementation #2');
+        });
+        it('handles missing result from both implementations', async () => {
+            const pool = handlers.cryptoHarnessPool;
+            pool.submit
+                .mockResolvedValueOnce({
+                ok: true,
+                results: [],
+            })
+                .mockResolvedValueOnce({
+                ok: true,
+                results: [],
+            });
+            const body = parseJson(await handlers.handleCryptoCompare({
+                code1: 'function fn() {}',
+                code2: 'function fn() {}',
+                functionName: 'fn',
+                testInputs: ['x'],
+            }));
+            expect(body.results).toHaveLength(1);
+            expect(body.results[0].match).toBe(false);
+            expect(body.results[0].error1).toBe('missing result from implementation #1');
+            expect(body.results[0].error2).toBe('missing result from implementation #2');
+        });
+        it('marks match as false when one side has error even if outputs match', async () => {
+            const pool = handlers.cryptoHarnessPool;
+            pool.submit
+                .mockResolvedValueOnce({
+                ok: true,
+                results: [
+                    { input: 'x', output: 'same', duration: 0.1, error: 'warning' },
+                ],
+            })
+                .mockResolvedValueOnce({
+                ok: true,
+                results: [
+                    { input: 'x', output: 'same', duration: 0.1 },
+                ],
+            });
+            const body = parseJson(await handlers.handleCryptoCompare({
+                code1: 'function fn(x) { return "same"; }',
+                code2: 'function fn(x) { return "same"; }',
+                functionName: 'fn',
+                testInputs: ['x'],
+            }));
+            expect(body.results[0].match).toBe(false);
+            expect(body.results[0].error1).toBe('warning');
+        });
+        it('handles non-Error exception from crypto_compare', async () => {
+            const pool = handlers.cryptoHarnessPool;
+            pool.submit.mockRejectedValue(42);
+            const body = parseJson(await handlers.handleCryptoCompare({
+                code1: 'function fn() {}',
+                code2: 'function fn() {}',
+                functionName: 'fn',
+                testInputs: ['a'],
+            }));
+            expect(body.results[0].match).toBe(false);
+        });
+        it('handles multiple test inputs with mixed results', async () => {
+            const pool = handlers.cryptoHarnessPool;
+            pool.submit
+                .mockResolvedValueOnce({
+                ok: true,
+                results: [
+                    { input: 'a', output: 'X', duration: 0.1 },
+                    { input: 'b', output: 'Y', duration: 0.2 },
+                    { input: 'c', output: 'Z', duration: 0.3 },
+                ],
+            })
+                .mockResolvedValueOnce({
+                ok: true,
+                results: [
+                    { input: 'a', output: 'X', duration: 0.1 },
+                    { input: 'b', output: 'DIFFERENT', duration: 0.2 },
+                    { input: 'c', output: 'Z', duration: 0.3 },
+                ],
+            });
+            const body = parseJson(await handlers.handleCryptoCompare({
+                code1: 'function fn(x) { return x; }',
+                code2: 'function fn(x) { return x; }',
+                functionName: 'fn',
+                testInputs: ['a', 'b', 'c'],
+            }));
+            expect(body.matches).toBe(2);
+            expect(body.mismatches).toBe(1);
+            expect(body.results[0].match).toBe(true);
+            expect(body.results[1].match).toBe(false);
+            expect(body.results[2].match).toBe(true);
+        });
+    });
+});

package/dist/tests/server/domains/transform/transform-crypto-handlers.test.d.ts

@@ -0,0 +1 @@
+export {};