@jshookmcp/jshook 0.1.9 → 0.2.1

package/dist/tests/modules/process/memory/availability.extended.test.js

@@ -0,0 +1,162 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const state = vi.hoisted(() => ({
+    executePowerShellScript: vi.fn(),
+    execAsync: vi.fn(),
+    getuid: vi.fn(),
+}));
+vi.mock('@src/modules/process/memory/types', () => ({
+    executePowerShellScript: state.executePowerShellScript,
+    execAsync: state.execAsync,
+}));
+async function loadModule() {
+    return import('../../../../src/modules/process/memory/availability.js');
+}
+describe('memory/availability extended', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.resetModules();
+    });
+    describe('checkAvailability - unsupported platform', () => {
+        it('returns unavailable for unrecognized platform', async () => {
+            const { checkAvailability } = await loadModule();
+            const result = await checkAvailability('unknown');
+            expect(result.available).toBe(false);
+            expect(result.reason).toContain('not supported');
+        });
+    });
+    describe('checkAvailability - win32', () => {
+        it('returns unavailable with unexpected PowerShell output', async () => {
+            state.executePowerShellScript.mockResolvedValue({ stdout: 'unexpected output', stderr: '' });
+            const { checkAvailability } = await loadModule();
+            const result = await checkAvailability('win32');
+            expect(result.available).toBe(false);
+            expect(result.reason).toContain('unexpected output');
+        });
+        it('returns unavailable with empty PowerShell output', async () => {
+            state.executePowerShellScript.mockResolvedValue({ stdout: '', stderr: '' });
+            const { checkAvailability } = await loadModule();
+            const result = await checkAvailability('win32');
+            expect(result.available).toBe(false);
+            expect(result.reason).toContain('(empty)');
+        });
+        it('maps "is not recognized" error to PowerShell unavailable', async () => {
+            const error = new Error('is not recognized as an internal or external command');
+            state.executePowerShellScript.mockRejectedValue(error);
+            const { checkAvailability } = await loadModule();
+            const result = await checkAvailability('win32');
+            expect(result.available).toBe(false);
+            expect(result.reason).toContain('PowerShell is unavailable');
+        });
+        it('maps "command not found" error to PowerShell unavailable', async () => {
+            const error = new Error('command not found');
+            state.executePowerShellScript.mockRejectedValue(error);
+            const { checkAvailability } = await loadModule();
+            const result = await checkAvailability('win32');
+            expect(result.available).toBe(false);
+            expect(result.reason).toContain('PowerShell is unavailable');
+        });
+        it('maps "cannot find powershell" stderr to PowerShell unavailable', async () => {
+            const error = Object.assign(new Error('exec failed'), {
+                stderr: 'cannot find the path for powershell',
+            });
+            state.executePowerShellScript.mockRejectedValue(error);
+            const { checkAvailability } = await loadModule();
+            const result = await checkAvailability('win32');
+            expect(result.available).toBe(false);
+            expect(result.reason).toContain('PowerShell is unavailable');
+        });
+        it('maps generic errors to execution-failed reason', async () => {
+            state.executePowerShellScript.mockRejectedValue(new Error('timeout'));
+            const { checkAvailability } = await loadModule();
+            const result = await checkAvailability('win32');
+            expect(result.available).toBe(false);
+            expect(result.reason).toContain('PowerShell command execution failed');
+        });
+    });
+    describe('checkAvailability - linux', () => {
+        it('returns unavailable for non-root without ptrace capability', async () => {
+            state.execAsync
+                .mockResolvedValueOnce({ stdout: '1000\n', stderr: '' })
+                .mockRejectedValueOnce(new Error('capsh failed'));
+            const { checkAvailability } = await loadModule();
+            const result = await checkAvailability('linux');
+            expect(result.available).toBe(false);
+            expect(result.reason).toContain('root privileges or CAP_SYS_PTRACE');
+        });
+        it('returns unavailable when id -u throws', async () => {
+            state.execAsync.mockRejectedValueOnce(new Error('id failed'));
+            const { checkAvailability } = await loadModule();
+            const result = await checkAvailability('linux');
+            expect(result.available).toBe(false);
+            expect(result.reason).toContain('root privileges');
+        });
+    });
+    describe('checkAvailability - darwin', () => {
+        it('returns available when lldb exists and running as root', async () => {
+            state.execAsync.mockResolvedValue({ stdout: '/usr/bin/lldb', stderr: '' });
+            const origGetuid = process.getuid;
+            process.getuid = (() => 0);
+            try {
+                const { checkAvailability } = await loadModule();
+                const result = await checkAvailability('darwin');
+                expect(result.available).toBe(true);
+                expect(result.reason).toBeUndefined();
+            }
+            finally {
+                process.getuid = origGetuid;
+            }
+        });
+        it('returns available with warning when not root', async () => {
+            state.execAsync.mockResolvedValue({ stdout: '/usr/bin/lldb', stderr: '' });
+            const origGetuid = process.getuid;
+            process.getuid = (() => 1000);
+            try {
+                const { checkAvailability } = await loadModule();
+                const result = await checkAvailability('darwin');
+                expect(result.available).toBe(true);
+                expect(result.reason).toContain('without root');
+            }
+            finally {
+                process.getuid = origGetuid;
+            }
+        });
+    });
+    describe('checkDebugPort', () => {
+        it('returns success false for non-windows', async () => {
+            const { checkDebugPort } = await loadModule();
+            const result = await checkDebugPort('linux', 123);
+            expect(result.success).toBe(false);
+            expect(result.error).toContain('only implemented for Windows');
+        });
+        it('returns parsed JSON from PowerShell on Windows', async () => {
+            state.executePowerShellScript.mockResolvedValue({
+                stdout: '{"success":true,"isDebugged":true}',
+                stderr: '',
+            });
+            const { checkDebugPort } = await loadModule();
+            const result = await checkDebugPort('win32', 999);
+            expect(result).toEqual({ success: true, isDebugged: true });
+        });
+        it('returns error when PowerShell returns empty output', async () => {
+            state.executePowerShellScript.mockResolvedValue({ stdout: '', stderr: '' });
+            const { checkDebugPort } = await loadModule();
+            const result = await checkDebugPort('win32', 999);
+            expect(result.success).toBe(false);
+            expect(result.error).toContain('empty output');
+        });
+        it('returns error when PowerShell throws', async () => {
+            state.executePowerShellScript.mockRejectedValue(new Error('ps failed'));
+            const { checkDebugPort } = await loadModule();
+            const result = await checkDebugPort('win32', 999);
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('ps failed');
+        });
+        it('returns generic error for non-Error thrown value', async () => {
+            state.executePowerShellScript.mockRejectedValue('string error');
+            const { checkDebugPort } = await loadModule();
+            const result = await checkDebugPort('win32', 999);
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('PowerShell execution failed');
+        });
+    });
+});

package/dist/tests/modules/process/memory/monitor.extended.test.d.ts

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

package/dist/tests/modules/process/memory/monitor.extended.test.js

@@ -0,0 +1,90 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { MemoryMonitorManager } from '../../../../src/modules/process/memory/monitor.js';
+describe('MemoryMonitorManager', () => {
+    let manager;
+    beforeEach(() => {
+        vi.useFakeTimers();
+        manager = new MemoryMonitorManager();
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    it('start returns a unique monitor ID', () => {
+        const readFn = vi.fn().mockResolvedValue({ success: true, data: 'AABB' });
+        const id = manager.start(100, '0x1000', 4, 1000, readFn);
+        expect(id).toMatch(/^monitor_\d+_/);
+        manager.stop(id);
+    });
+    it('calls readMemoryFn on each interval tick', async () => {
+        const readFn = vi.fn().mockResolvedValue({ success: true, data: 'AABB' });
+        const id = manager.start(100, '0x1000', 4, 500, readFn);
+        await vi.advanceTimersByTimeAsync(500);
+        expect(readFn).toHaveBeenCalledTimes(1);
+        expect(readFn).toHaveBeenCalledWith(100, '0x1000', 4);
+        await vi.advanceTimersByTimeAsync(500);
+        expect(readFn).toHaveBeenCalledTimes(2);
+        manager.stop(id);
+    });
+    it('invokes onChange when value changes after initial read', async () => {
+        const readFn = vi.fn()
+            .mockResolvedValueOnce({ success: true, data: 'AA' })
+            .mockResolvedValueOnce({ success: true, data: 'BB' })
+            .mockResolvedValueOnce({ success: true, data: 'BB' });
+        const onChange = vi.fn();
+        const id = manager.start(100, '0x1000', 1, 100, readFn, onChange);
+        await vi.advanceTimersByTimeAsync(100);
+        expect(onChange).not.toHaveBeenCalled();
+        await vi.advanceTimersByTimeAsync(100);
+        expect(onChange).toHaveBeenCalledWith('AA', 'BB');
+        await vi.advanceTimersByTimeAsync(100);
+        expect(onChange).toHaveBeenCalledTimes(1);
+        manager.stop(id);
+    });
+    it('does not invoke onChange when read fails', async () => {
+        const readFn = vi.fn()
+            .mockResolvedValueOnce({ success: true, data: 'AA' })
+            .mockResolvedValueOnce({ success: false, error: 'read error' });
+        const onChange = vi.fn();
+        const id = manager.start(100, '0x1000', 1, 100, readFn, onChange);
+        await vi.advanceTimersByTimeAsync(100);
+        await vi.advanceTimersByTimeAsync(100);
+        expect(onChange).not.toHaveBeenCalled();
+        manager.stop(id);
+    });
+    it('stop returns true for active monitor and false for unknown', () => {
+        const readFn = vi.fn().mockResolvedValue({ success: true, data: 'AA' });
+        const id = manager.start(100, '0x1000', 4, 1000, readFn);
+        expect(manager.stop(id)).toBe(true);
+        expect(manager.stop(id)).toBe(false);
+        expect(manager.stop('nonexistent_id')).toBe(false);
+    });
+    it('stops polling after monitor is stopped', async () => {
+        const readFn = vi.fn().mockResolvedValue({ success: true, data: 'AA' });
+        const id = manager.start(100, '0x1000', 4, 200, readFn);
+        await vi.advanceTimersByTimeAsync(200);
+        expect(readFn).toHaveBeenCalledTimes(1);
+        manager.stop(id);
+        await vi.advanceTimersByTimeAsync(400);
+        expect(readFn).toHaveBeenCalledTimes(1);
+    });
+    it('supports multiple concurrent monitors', async () => {
+        const readFn1 = vi.fn().mockResolvedValue({ success: true, data: 'AA' });
+        const readFn2 = vi.fn().mockResolvedValue({ success: true, data: 'BB' });
+        const id1 = manager.start(100, '0x1000', 4, 100, readFn1);
+        const id2 = manager.start(200, '0x2000', 8, 200, readFn2);
+        await vi.advanceTimersByTimeAsync(200);
+        expect(readFn1).toHaveBeenCalledTimes(2);
+        expect(readFn2).toHaveBeenCalledTimes(1);
+        manager.stop(id1);
+        manager.stop(id2);
+    });
+    it('uses default size of 4 and interval of 1000', () => {
+        const readFn = vi.fn().mockResolvedValue({ success: true, data: 'AA' });
+        const id = manager.start(100, '0x1000', undefined, undefined, readFn);
+        vi.advanceTimersByTime(999);
+        expect(readFn).not.toHaveBeenCalled();
+        vi.advanceTimersByTime(1);
+        expect(readFn).toHaveBeenCalledWith(100, '0x1000', 4);
+        manager.stop(id);
+    });
+});

package/dist/tests/modules/process/memory/regions-dump.additional.test.d.ts

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

package/dist/tests/modules/process/memory/regions-dump.additional.test.js

@@ -0,0 +1,205 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+vi.mock('@utils/logger', () => ({
+    logger: {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        success: vi.fn(),
+    },
+}));
+vi.mock('@modules/process/memory/types', () => ({
+    execFileAsync: vi.fn(),
+    executePowerShellScript: vi.fn(),
+}));
+import { dumpMemoryRegion } from '../../../../src/modules/process/memory/regions.dump.js';
+import { execFileAsync, executePowerShellScript } from '../../../../src/modules/process/memory/types.js';
+const mockExecFileAsync = vi.mocked(execFileAsync);
+const mockExecutePowerShellScript = vi.mocked(executePowerShellScript);
+describe('dumpMemoryRegion', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('unsupported platform', () => {
+        it('returns error for linux platform', async () => {
+            const result = await dumpMemoryRegion('linux', 1234, 'FF00', 100, '/tmp/dump.bin');
+            expect(result.success).toBe(false);
+            expect(result.error).toContain('only implemented for Windows and macOS');
+        });
+        it('returns error for unknown platform', async () => {
+            const result = await dumpMemoryRegion('unknown', 1234, 'FF00', 100, '/tmp/dump.bin');
+            expect(result.success).toBe(false);
+            expect(result.error).toContain('only implemented for Windows and macOS');
+        });
+    });
+    describe('darwin platform', () => {
+        it('returns error for invalid hex address', async () => {
+            const result = await dumpMemoryRegion('darwin', 1234, 'ZZZZ', 100, '/tmp/dump.bin');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Invalid address format');
+        });
+        it('returns error for invalid pid (zero)', async () => {
+            const result = await dumpMemoryRegion('darwin', 0, 'FF00', 100, '/tmp/dump.bin');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Invalid pid');
+        });
+        it('returns error for negative pid', async () => {
+            const result = await dumpMemoryRegion('darwin', -1, 'FF00', 100, '/tmp/dump.bin');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Invalid pid');
+        });
+        it('returns error for non-integer pid', async () => {
+            const result = await dumpMemoryRegion('darwin', 1.5, 'FF00', 100, '/tmp/dump.bin');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Invalid pid');
+        });
+        it('returns error for invalid size (zero)', async () => {
+            const result = await dumpMemoryRegion('darwin', 1234, 'FF00', 0, '/tmp/dump.bin');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Invalid size');
+        });
+        it('returns error for negative size', async () => {
+            const result = await dumpMemoryRegion('darwin', 1234, 'FF00', -10, '/tmp/dump.bin');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Invalid size');
+        });
+        it('returns error for non-integer size', async () => {
+            const result = await dumpMemoryRegion('darwin', 1234, 'FF00', 1.5, '/tmp/dump.bin');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Invalid size');
+        });
+        it('succeeds when lldb reports bytes written', async () => {
+            mockExecFileAsync.mockResolvedValue({
+                stdout: '100 bytes written to /tmp/dump.bin',
+                stderr: '',
+            });
+            const result = await dumpMemoryRegion('darwin', 1234, 'FF00', 100, '/tmp/dump.bin');
+            expect(result.success).toBe(true);
+            expect(mockExecFileAsync).toHaveBeenCalledWith('lldb', expect.arrayContaining(['--batch', '-p', '1234']), expect.objectContaining({ timeout: 60000 }));
+        });
+        it('returns error when lldb output does not contain bytes written', async () => {
+            mockExecFileAsync.mockResolvedValue({
+                stdout: 'error: some lldb error\nother output',
+                stderr: '',
+            });
+            const result = await dumpMemoryRegion('darwin', 1234, 'FF00', 100, '/tmp/dump.bin');
+            expect(result.success).toBe(false);
+            expect(result.error).toContain('lldb dump failed');
+            expect(result.error).toContain('error: some lldb error');
+        });
+        it('returns error when lldb output has no error line', async () => {
+            mockExecFileAsync.mockResolvedValue({
+                stdout: 'no match here',
+                stderr: '',
+            });
+            const result = await dumpMemoryRegion('darwin', 1234, 'FF00', 100, '/tmp/dump.bin');
+            expect(result.success).toBe(false);
+            expect(result.error).toContain('lldb dump failed');
+        });
+        it('handles lldb execution throwing an Error', async () => {
+            mockExecFileAsync.mockRejectedValue(new Error('lldb not found'));
+            const result = await dumpMemoryRegion('darwin', 1234, 'FF00', 100, '/tmp/dump.bin');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('lldb not found');
+        });
+        it('handles lldb execution throwing a non-Error', async () => {
+            mockExecFileAsync.mockRejectedValue('string error');
+            const result = await dumpMemoryRegion('darwin', 1234, 'FF00', 100, '/tmp/dump.bin');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('string error');
+        });
+        it('correctly converts hex address to 0x format for lldb', async () => {
+            mockExecFileAsync.mockResolvedValue({
+                stdout: '64 bytes written to /tmp/dump.bin',
+                stderr: '',
+            });
+            await dumpMemoryRegion('darwin', 1234, 'A0FF', 64, '/tmp/dump.bin');
+            const call = mockExecFileAsync.mock.calls[0];
+            const args = call[1];
+            const memoryReadArg = args.find((a) => a.includes('0xa0ff'));
+            expect(memoryReadArg).toBeDefined();
+        });
+    });
+    describe('win32 platform', () => {
+        it('returns error for invalid hex address', async () => {
+            const result = await dumpMemoryRegion('win32', 1234, 'ZZZZ', 100, 'C:\\dump.bin');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Invalid address format');
+        });
+        it('returns error for invalid pid', async () => {
+            const result = await dumpMemoryRegion('win32', 0, 'FF00', 100, 'C:\\dump.bin');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Invalid pid');
+        });
+        it('returns error for negative pid', async () => {
+            const result = await dumpMemoryRegion('win32', -5, 'FF00', 100, 'C:\\dump.bin');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Invalid pid');
+        });
+        it('returns error for invalid size', async () => {
+            const result = await dumpMemoryRegion('win32', 1234, 'FF00', 0, 'C:\\dump.bin');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Invalid size');
+        });
+        it('returns error for negative size', async () => {
+            const result = await dumpMemoryRegion('win32', 1234, 'FF00', -1, 'C:\\dump.bin');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Invalid size');
+        });
+        it('succeeds when PowerShell returns success JSON', async () => {
+            mockExecutePowerShellScript.mockResolvedValue({
+                stdout: JSON.stringify({ success: true, message: 'Dumped 100 bytes' }),
+                stderr: '',
+            });
+            const result = await dumpMemoryRegion('win32', 1234, 'FF00', 100, 'C:\\dump.bin');
+            expect(result.success).toBe(true);
+            expect(mockExecutePowerShellScript).toHaveBeenCalled();
+        });
+        it('returns error when PowerShell returns error JSON', async () => {
+            mockExecutePowerShellScript.mockResolvedValue({
+                stdout: JSON.stringify({ success: false, error: 'Access denied' }),
+                stderr: '',
+            });
+            const result = await dumpMemoryRegion('win32', 1234, 'FF00', 100, 'C:\\dump.bin');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Access denied');
+        });
+        it('returns error when PowerShell returns empty output', async () => {
+            mockExecutePowerShellScript.mockResolvedValue({
+                stdout: '',
+                stderr: '',
+            });
+            const result = await dumpMemoryRegion('win32', 1234, 'FF00', 100, 'C:\\dump.bin');
+            expect(result.success).toBe(false);
+            expect(result.error).toContain('PowerShell returned empty output');
+        });
+        it('returns error when PowerShell returns whitespace-only output', async () => {
+            mockExecutePowerShellScript.mockResolvedValue({
+                stdout: '   \n  ',
+                stderr: '',
+            });
+            const result = await dumpMemoryRegion('win32', 1234, 'FF00', 100, 'C:\\dump.bin');
+            expect(result.success).toBe(false);
+        });
+        it('returns error when PowerShell returns invalid JSON', async () => {
+            mockExecutePowerShellScript.mockResolvedValue({
+                stdout: 'not valid json at all',
+                stderr: '',
+            });
+            const result = await dumpMemoryRegion('win32', 1234, 'FF00', 100, 'C:\\dump.bin');
+            expect(result.success).toBe(false);
+        });
+        it('handles PowerShell execution throwing an Error', async () => {
+            mockExecutePowerShellScript.mockRejectedValue(new Error('PowerShell not found'));
+            const result = await dumpMemoryRegion('win32', 1234, 'FF00', 100, 'C:\\dump.bin');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('PowerShell not found');
+        });
+        it('handles PowerShell execution throwing a non-Error', async () => {
+            mockExecutePowerShellScript.mockRejectedValue('unexpected failure');
+            const result = await dumpMemoryRegion('win32', 1234, 'FF00', 100, 'C:\\dump.bin');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('PowerShell execution failed');
+        });
+    });
+});

package/dist/tests/modules/process/memory/scanner.patterns.test.d.ts

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

package/dist/tests/modules/process/memory/scanner.patterns.test.js

@@ -0,0 +1,119 @@
+import { describe, it, expect } from 'vitest';
+import { buildPatternBytesAndMask, patternToBytesMac, } from '../../../../src/modules/process/memory/scanner.patterns.js';
+describe('scanner.patterns', () => {
+    describe('buildPatternBytesAndMask', () => {
+        it('parses hex pattern with concrete bytes', () => {
+            const result = buildPatternBytesAndMask('AA BB CC', 'hex');
+            expect(result.patternBytes).toEqual([0xaa, 0xbb, 0xcc]);
+            expect(result.mask).toEqual([1, 1, 1]);
+        });
+        it('handles wildcard bytes in hex patterns', () => {
+            const result = buildPatternBytesAndMask('AA ?? BB ** CC ?', 'hex');
+            expect(result.patternBytes).toEqual([0xaa, 0, 0xbb, 0, 0xcc, 0]);
+            expect(result.mask).toEqual([1, 0, 1, 0, 1, 0]);
+        });
+        it('parses int32 into little-endian bytes', () => {
+            const result = buildPatternBytesAndMask('256', 'int32');
+            expect(result.patternBytes).toEqual([0, 1, 0, 0]);
+            expect(result.mask).toEqual([1, 1, 1, 1]);
+        });
+        it('parses negative int32 values', () => {
+            const result = buildPatternBytesAndMask('-1', 'int32');
+            expect(result.patternBytes).toEqual([0xff, 0xff, 0xff, 0xff]);
+            expect(result.mask).toEqual([1, 1, 1, 1]);
+        });
+        it('parses int64 into 8-byte little-endian', () => {
+            const result = buildPatternBytesAndMask('1', 'int64');
+            expect(result.patternBytes).toEqual([1, 0, 0, 0, 0, 0, 0, 0]);
+            expect(result.mask).toEqual([1, 1, 1, 1, 1, 1, 1, 1]);
+        });
+        it('parses float into 4-byte LE representation', () => {
+            const result = buildPatternBytesAndMask('1.0', 'float');
+            expect(result.patternBytes).toEqual([0x00, 0x00, 0x80, 0x3f]);
+            expect(result.mask).toEqual([1, 1, 1, 1]);
+        });
+        it('parses double into 8-byte LE representation', () => {
+            const result = buildPatternBytesAndMask('1.0', 'double');
+            expect(result.patternBytes).toEqual([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x3f]);
+            expect(result.mask).toEqual([1, 1, 1, 1, 1, 1, 1, 1]);
+        });
+        it('parses string into UTF-8 bytes', () => {
+            const result = buildPatternBytesAndMask('AB', 'string');
+            expect(result.patternBytes).toEqual([0x41, 0x42]);
+            expect(result.mask).toEqual([1, 1]);
+        });
+        it('throws on empty hex pattern', () => {
+            expect(() => buildPatternBytesAndMask('', 'hex')).toThrow('Invalid pattern');
+        });
+        it('throws on invalid int32', () => {
+            expect(() => buildPatternBytesAndMask('notanumber', 'int32')).toThrow('Invalid pattern');
+        });
+        it('throws on invalid float', () => {
+            expect(() => buildPatternBytesAndMask('notanumber', 'float')).toThrow('Invalid pattern');
+        });
+        it('throws on invalid double', () => {
+            expect(() => buildPatternBytesAndMask('notanumber', 'double')).toThrow('Invalid pattern');
+        });
+    });
+    describe('patternToBytesMac', () => {
+        it('parses hex pattern with wildcards', () => {
+            const result = patternToBytesMac('AA ?? CC', 'hex');
+            expect(result.bytes).toEqual([0xaa, 0, 0xcc]);
+            expect(result.mask).toEqual([1, 0, 1]);
+        });
+        it('handles all wildcard forms (?, ??, **)', () => {
+            const result = patternToBytesMac('FF ? ?? ** 00', 'hex');
+            expect(result.bytes).toEqual([0xff, 0, 0, 0, 0]);
+            expect(result.mask).toEqual([1, 0, 0, 0, 1]);
+        });
+        it('throws on invalid hex byte', () => {
+            expect(() => patternToBytesMac('AA ZZ CC', 'hex')).toThrow('Invalid hex byte: ZZ');
+        });
+        it('throws on empty hex pattern', () => {
+            expect(() => patternToBytesMac('', 'hex')).toThrow('Invalid hex byte');
+        });
+        it('parses int32 correctly', () => {
+            const result = patternToBytesMac('42', 'int32');
+            const expected = Buffer.allocUnsafe(4);
+            expected.writeInt32LE(42, 0);
+            expect(result.bytes).toEqual(Array.from(expected));
+            expect(result.mask).toEqual([1, 1, 1, 1]);
+        });
+        it('throws on invalid int32', () => {
+            expect(() => patternToBytesMac('abc', 'int32')).toThrow('Invalid int32 value');
+        });
+        it('parses int64 correctly', () => {
+            const result = patternToBytesMac('100', 'int64');
+            const expected = Buffer.allocUnsafe(8);
+            expected.writeBigInt64LE(100n, 0);
+            expect(result.bytes).toEqual(Array.from(expected));
+            expect(result.mask).toEqual([1, 1, 1, 1, 1, 1, 1, 1]);
+        });
+        it('parses float correctly', () => {
+            const result = patternToBytesMac('3.14', 'float');
+            const expected = Buffer.allocUnsafe(4);
+            expected.writeFloatLE(3.14, 0);
+            expect(result.bytes).toEqual(Array.from(expected));
+        });
+        it('throws on invalid float', () => {
+            expect(() => patternToBytesMac('xyz', 'float')).toThrow('Invalid float value');
+        });
+        it('parses double correctly', () => {
+            const result = patternToBytesMac('2.718', 'double');
+            const expected = Buffer.allocUnsafe(8);
+            expected.writeDoubleLE(2.718, 0);
+            expect(result.bytes).toEqual(Array.from(expected));
+        });
+        it('throws on invalid double', () => {
+            expect(() => patternToBytesMac('xyz', 'double')).toThrow('Invalid double value');
+        });
+        it('parses string into UTF-8 bytes', () => {
+            const result = patternToBytesMac('Hello', 'string');
+            expect(result.bytes).toEqual([72, 101, 108, 108, 111]);
+            expect(result.mask).toEqual([1, 1, 1, 1, 1]);
+        });
+        it('throws on unsupported pattern type', () => {
+            expect(() => patternToBytesMac('test', 'binary')).toThrow('Unsupported pattern type');
+        });
+    });
+});

package/dist/tests/modules/process/process-index.test.d.ts

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