@jshookmcp/jshook 0.2.2 → 0.2.5

package/dist/src/modules/process/memory/scanner.js

@@ -3,15 +3,25 @@ import { scanMemoryWindows } from './scanner.windows.js';
 import { scanMemoryLinux } from './scanner.linux.js';
 import { scanMemoryMac } from './scanner.darwin.js';
 export { buildPatternBytesAndMask, patternToBytesMac } from './scanner.patterns.js';
-export async function scanMemory(platform, pid, pattern, patternType = 'hex') {
+export async function scanMemory(platform, pid, pattern, patternType = 'hex', suspendTarget = false) {
+    let suspended = false;
     try {
+        if (suspendTarget) {
+            suspended = await suspendProcess(platform, pid);
+            if (suspended) {
+                logger.info(`Suspended process ${pid} for consistent memory scan`);
+            }
+            else {
+                logger.warn(`Could not suspend process ${pid} — scanning unsuspended`);
+            }
+        }
         switch (platform) {
             case 'win32':
-                return scanMemoryWindows(pid, pattern, patternType);
+                return await scanMemoryWindows(pid, pattern, patternType);
             case 'linux':
-                return scanMemoryLinux(pid, pattern, patternType);
+                return await scanMemoryLinux(pid, pattern, patternType);
             case 'darwin':
-                return scanMemoryMac(pid, pattern, patternType);
+                return await scanMemoryMac(pid, pattern, patternType);
             default:
                 return { success: false, addresses: [], error: `Memory scan not supported on ${platform}` };
         }
@@ -24,6 +34,12 @@ export async function scanMemory(platform, pid, pattern, patternType = 'hex') {
             error: error instanceof Error ? error.message : String(error),
         };
     }
+    finally {
+        if (suspended) {
+            await resumeProcess(platform, pid);
+            logger.info(`Resumed process ${pid} after memory scan`);
+        }
+    }
 }
 export async function scanMemoryFiltered(pid, pattern, addresses, patternType = 'hex', _readMemoryFn, scanMemoryFn) {
     const validAddresses = [];
@@ -59,3 +75,71 @@ export async function scanMemoryFiltered(pid, pattern, addresses, patternType =
         stats: { resultsFound: results.length, patternLength: pattern.length },
     };
 }
+async function suspendProcess(platform, pid) {
+    try {
+        switch (platform) {
+            case 'darwin': {
+                const { createPlatformProvider } = await import('../../../native/platform/factory.js');
+                const provider = createPlatformProvider();
+                const avail = await provider.checkAvailability();
+                if (!avail.available)
+                    return false;
+                const handle = provider.openProcess(pid, false);
+                try {
+                    const { taskSuspend } = await import('../../../native/platform/darwin/DarwinAPI.js');
+                    const { machTaskSelf, taskForPid, KERN } = await import('../../../native/platform/darwin/DarwinAPI.js');
+                    const { kr, task } = taskForPid(machTaskSelf(), pid);
+                    if (kr !== KERN.SUCCESS)
+                        return false;
+                    const suspendKr = taskSuspend(task);
+                    return suspendKr === KERN.SUCCESS;
+                }
+                finally {
+                    provider.closeProcess(handle);
+                }
+            }
+            case 'linux': {
+                const { execAsync } = await import('../../process/memory/types.js');
+                await execAsync(`kill -STOP ${pid}`, { timeout: 2000 });
+                return true;
+            }
+            case 'win32': {
+                const { execAsync } = await import('../../process/memory/types.js');
+                await execAsync(`powershell -NoProfile -Command "(Add-Type -MemberDefinition '[DllImport("ntdll.dll")] public static extern int NtSuspendProcess(IntPtr h);' -Name W -Namespace N -PassThru)::NtSuspendProcess((Get-Process -Id ${pid}).Handle)"`, { timeout: 5000 });
+                return true;
+            }
+            default:
+                return false;
+        }
+    }
+    catch (err) {
+        logger.warn(`Failed to suspend process ${pid}:`, err);
+        return false;
+    }
+}
+async function resumeProcess(platform, pid) {
+    try {
+        switch (platform) {
+            case 'darwin': {
+                const { machTaskSelf, taskForPid, taskResume, KERN } = await import('../../../native/platform/darwin/DarwinAPI.js');
+                const { kr, task } = taskForPid(machTaskSelf(), pid);
+                if (kr === KERN.SUCCESS)
+                    taskResume(task);
+                break;
+            }
+            case 'linux': {
+                const { execAsync } = await import('../../process/memory/types.js');
+                await execAsync(`kill -CONT ${pid}`, { timeout: 2000 });
+                break;
+            }
+            case 'win32': {
+                const { execAsync } = await import('../../process/memory/types.js');
+                await execAsync(`powershell -NoProfile -Command "(Add-Type -MemberDefinition '[DllImport("ntdll.dll")] public static extern int NtResumeProcess(IntPtr h);' -Name W -Namespace N -PassThru)::NtResumeProcess((Get-Process -Id ${pid}).Handle)"`, { timeout: 5000 });
+                break;
+            }
+        }
+    }
+    catch (err) {
+        logger.error(`CRITICAL: Failed to resume process ${pid} — may need manual SIGCONT:`, err);
+    }
+}

package/dist/src/modules/process/memory/writer.js

@@ -1,6 +1,7 @@
 import { logger } from '../../../utils/logger.js';
 import { nativeMemoryManager } from '../../../native/NativeMemoryManager.js';
 import { isKoffiAvailable } from '../../../native/Win32API.js';
+import { MEMORY_MAX_WRITE_BYTES } from '../../../constants.js';
 import { execAsync, executePowerShellScript, } from '../../process/memory/types.js';
 async function writeMemoryWindows(pid, address, data) {
     try {
@@ -108,11 +109,32 @@ async function writeMemoryMac(pid, address, data, checkProtectionFn) {
     if (address === 0) {
         return { success: false, error: 'Invalid address: null pointer (0x0)' };
     }
-    const MAX_WRITE_SIZE = 16 * 1024;
-    if (data.length === 0 || data.length > MAX_WRITE_SIZE) {
-        return { success: false, error: `Invalid write size: must be 1–${MAX_WRITE_SIZE} bytes` };
+    if (data.length === 0 || data.length > MEMORY_MAX_WRITE_BYTES) {
+        return {
+            success: false,
+            error: `Invalid write size: must be 1–${MEMORY_MAX_WRITE_BYTES} bytes`,
+        };
     }
     const addrHex = `0x${address.toString(16)}`;
+    try {
+        const { createPlatformProvider } = await import('../../../native/platform/factory.js');
+        const provider = createPlatformProvider();
+        const avail = await provider.checkAvailability();
+        if (avail.available) {
+            const handle = provider.openProcess(pid, true);
+            try {
+                const result = provider.writeMemory(handle, BigInt(address), data);
+                logger.debug('Native Mach memory write succeeded (zero-pause)');
+                return { success: true, bytesWritten: result.bytesWritten };
+            }
+            finally {
+                provider.closeProcess(handle);
+            }
+        }
+    }
+    catch (nativeErr) {
+        logger.debug('Native Mach write failed, falling back to lldb:', nativeErr);
+    }
     const prot = await checkProtectionFn(pid, addrHex);
     if (!prot.success) {
         return { success: false, error: `Cannot verify memory region: ${prot.error}` };
@@ -138,8 +160,12 @@ async function writeMemoryMac(pid, address, data, checkProtectionFn) {
         return { success: false, error: error instanceof Error ? error.message : String(error) };
     }
 }
+const HEX_ADDR = /^(?:0x)?[0-9a-fA-F]{1,16}$/;
 export async function writeMemory(platform, pid, address, data, encoding = 'hex', checkProtectionFn) {
     try {
+        if (!HEX_ADDR.test(address)) {
+            return { success: false, error: 'Invalid address format. Use hex like "0x12345678"' };
+        }
         const addrNum = parseInt(address, 16);
         if (isNaN(addrNum)) {
             return { success: false, error: 'Invalid address format' };
@@ -154,9 +180,15 @@ export async function writeMemory(platform, pid, address, data, encoding = 'hex'
                 buffer = Buffer.from(cleanHex, 'hex');
             }
         }
-        catch (_e) {
+        catch {
             return { success: false, error: `Invalid ${encoding} data` };
         }
+        if (buffer.length === 0 || buffer.length > MEMORY_MAX_WRITE_BYTES) {
+            return {
+                success: false,
+                error: `Write size must be 1–${MEMORY_MAX_WRITE_BYTES} bytes (${(MEMORY_MAX_WRITE_BYTES / 1024).toFixed(0)} KB)`,
+            };
+        }
         if (platform === 'win32' && isKoffiAvailable()) {
             try {
                 const result = await nativeMemoryManager.writeMemory(pid, address, data, encoding);
@@ -189,7 +221,15 @@ export async function writeMemory(platform, pid, address, data, encoding = 'hex'
         return { success: false, error: error instanceof Error ? error.message : String(error) };
     }
 }
+const MAX_BATCH_PATCHES = 1000;
 export async function batchMemoryWrite(pid, patches, writeFn) {
+    if (patches.length > MAX_BATCH_PATCHES) {
+        return {
+            success: false,
+            results: [],
+            error: `Too many patches (${patches.length}), max ${MAX_BATCH_PATCHES}`,
+        };
+    }
     const results = [];
     for (const patch of patches) {
         const result = await writeFn(pid, patch.address, patch.data, patch.encoding || 'hex');

package/dist/src/modules/security/ExecutionSandbox.js

@@ -57,7 +57,13 @@ export class ExecutionSandbox {
         const startTime = Date.now();
         return new Promise((resolve) => {
             let settled = false;
-            let terminationTimeout;
+            const terminationTimeout = setTimeout(() => {
+                if (!settled) {
+                    void worker.terminate();
+                    logger.warn(`[ExecutionSandbox] Worker terminated after ${timeoutMs + SANDBOX_TERMINATE_GRACE_MS}ms`);
+                    finish({ ok: false, error: 'Execution timed out (worker terminated)', timedOut: true });
+                }
+            }, timeoutMs + SANDBOX_TERMINATE_GRACE_MS);
             const workerOptions = {
                 eval: true,
                 workerData: {
@@ -80,13 +86,6 @@ export class ExecutionSandbox {
                     clearTimeout(terminationTimeout);
                 resolve({ ...result, durationMs: Date.now() - startTime });
             };
-            terminationTimeout = setTimeout(() => {
-                if (!settled) {
-                    void worker.terminate();
-                    logger.warn(`[ExecutionSandbox] Worker terminated after ${timeoutMs + SANDBOX_TERMINATE_GRACE_MS}ms`);
-                    finish({ ok: false, error: 'Execution timed out (worker terminated)', timedOut: true });
-                }
-            }, timeoutMs + SANDBOX_TERMINATE_GRACE_MS);
             worker.on('message', (msg) => {
                 finish({
                     ok: msg.ok,

package/dist/src/modules/stealth/FingerprintManager.js

@@ -70,7 +70,7 @@ export class FingerprintManager {
             throw new Error('fingerprint-injector not installed');
         }
         try {
-            const { newInjectedPage } = await import('fingerprint-injector');
+            const { newInjectedPage } = (await import('fingerprint-injector'));
             const fp = 'fingerprint' in profile ? profile.fingerprint : profile;
             await newInjectedPage(page, { fingerprint: fp });
             logger.info('Fingerprint injected into page');

package/dist/src/modules/stealth/StealthScripts.d.ts

@@ -1,7 +1,9 @@
-import { Page } from 'rebrowser-puppeteer-core';
+import { type Page } from 'rebrowser-puppeteer-core';
 export declare class StealthScripts {
-    private static injectedPages;
+    protected constructor();
+    protected static injectedPages: WeakSet<object>;
     static injectAll(page: Page): Promise<void>;
+    static injectTimingDefense(page: Page): Promise<void>;
     static hideWebDriver(page: Page): Promise<void>;
     static mockChrome(page: Page): Promise<void>;
     static mockPlugins(page: Page): Promise<void>;

package/dist/src/modules/stealth/StealthScripts.js

@@ -1,6 +1,7 @@
-import { Page } from 'rebrowser-puppeteer-core';
+import {} from 'rebrowser-puppeteer-core';
 import { logger } from '../../utils/logger.js';
 export class StealthScripts {
+    constructor() { }
     static injectedPages = new WeakSet();
     static async injectAll(page) {
         if (this.injectedPages.has(page)) {
@@ -20,9 +21,43 @@ export class StealthScripts {
             this.fixMediaDevices(page),
             this.mockNotifications(page),
         ]);
+        await this.injectTimingDefense(page);
         this.injectedPages.add(page);
         logger.info(' ');
     }
+    static async injectTimingDefense(page) {
+        await page.evaluateOnNewDocument(() => {
+            const _originalPerfNow = performance.now.bind(performance);
+            const _originalDateNow = Date.now;
+            let _cdpOffset = 0;
+            performance.now = function () {
+                const win = window;
+                if (typeof win.__cdpTimingOffset === 'number') {
+                    _cdpOffset = win.__cdpTimingOffset;
+                }
+                return _originalPerfNow() - _cdpOffset;
+            };
+            Date.now = function () {
+                const win = window;
+                if (typeof win.__cdpTimingOffset === 'number') {
+                    _cdpOffset = win.__cdpTimingOffset;
+                }
+                return _originalDateNow.call(Date) - Math.floor(_cdpOffset);
+            };
+            const _OriginalDate = Date;
+            const _ProxiedDate = function (...args) {
+                if (args.length === 0) {
+                    return new _OriginalDate(_OriginalDate.now());
+                }
+                return new _OriginalDate(...args);
+            };
+            _ProxiedDate.now = _OriginalDate.now;
+            _ProxiedDate.parse = _OriginalDate.parse.bind(_OriginalDate);
+            _ProxiedDate.UTC = _OriginalDate.UTC.bind(_OriginalDate);
+            Object.defineProperty(_ProxiedDate, 'prototype', { value: _OriginalDate.prototype });
+            globalThis.Date = _ProxiedDate;
+        });
+    }
     static async hideWebDriver(page) {
         await page.evaluateOnNewDocument(() => {
             const originalNavigator = navigator;
@@ -156,29 +191,33 @@ export class StealthScripts {
         await page.evaluateOnNewDocument(() => {
             const originalToDataURL = HTMLCanvasElement.prototype.toDataURL;
             const originalGetImageData = CanvasRenderingContext2D.prototype.getImageData;
-            const addNoise = (imageData) => {
-                const data = imageData.data;
-                if (data) {
-                    for (let i = 0; i < data.length; i += 4) {
-                        data[i] = data[i] ^ 1;
-                        data[i + 1] = data[i + 1] ^ 1;
-                        data[i + 2] = data[i + 2] ^ 1;
-                    }
-                }
-                return imageData;
-            };
             HTMLCanvasElement.prototype.toDataURL = function (...args) {
                 const context = this.getContext('2d');
                 if (context) {
                     const imageData = context.getImageData(0, 0, this.width, this.height);
-                    addNoise(imageData);
+                    const data = imageData.data;
+                    if (data) {
+                        for (let i = 0; i < data.length; i += 4) {
+                            data[i] = data[i] ^ 1;
+                            data[i + 1] = data[i + 1] ^ 1;
+                            data[i + 2] = data[i + 2] ^ 1;
+                        }
+                    }
                     context.putImageData(imageData, 0, 0);
                 }
                 return originalToDataURL.apply(this, args);
             };
             CanvasRenderingContext2D.prototype.getImageData = function (...args) {
                 const imageData = originalGetImageData.apply(this, args);
-                return addNoise(imageData);
+                const data = imageData.data;
+                if (data) {
+                    for (let i = 0; i < data.length; i += 4) {
+                        data[i] = data[i] ^ 1;
+                        data[i + 1] = data[i + 1] ^ 1;
+                        data[i + 2] = data[i + 2] ^ 1;
+                    }
+                }
+                return imageData;
             };
         });
     }

package/dist/src/modules/stealth/StealthVerifier.d.ts

@@ -1,4 +1,4 @@
-import { Page } from 'rebrowser-puppeteer-core';
+import { type Page } from 'rebrowser-puppeteer-core';
 export interface StealthCheck {
     name: string;
     passed: boolean;

package/dist/src/modules/stealth/StealthVerifier.js

@@ -1,4 +1,4 @@
-import { Page } from 'rebrowser-puppeteer-core';
+import {} from 'rebrowser-puppeteer-core';
 export class StealthVerifier {
     async verify(page) {
         const checks = await page.evaluate(() => {
@@ -18,9 +18,7 @@ export class StealthVerifier {
                 expected: 'object',
                 actual: typeof win.chrome,
             });
-            const chromeApp = hasChrome
-                ? win.chrome.app
-                : null;
+            const chromeApp = hasChrome ? win.chrome.app : null;
             const hasAppIsInstalled = chromeApp && typeof chromeApp === 'object' && 'isInstalled' in chromeApp;
             results.push({
                 name: 'chrome.app.isInstalled',

package/dist/src/modules/symbolic/JSVMPSymbolicExecutor.d.ts

@@ -59,6 +59,20 @@ export declare class JSVMPSymbolicExecutor extends SymbolicExecutor {
     private executeAdd;
     private executeSub;
     private executeMul;
+    private executeDiv;
+    private executeMod;
+    private executeAnd;
+    private executeOr;
+    private executeNot;
+    private executeXor;
+    private executeEq;
+    private executeNe;
+    private executeLt;
+    private executeLe;
+    private executeGt;
+    private executeGe;
+    private executeJnz;
+    private executeDup;
     private executeLoad;
     private executeStore;
     private executeJZ;

package/dist/src/modules/symbolic/JSVMPSymbolicExecutor.js

@@ -61,7 +61,7 @@ export class JSVMPSymbolicExecutor extends SymbolicExecutor {
                     break;
                 }
                 executionTrace.push(this.cloneStateInternal(state));
-                state = this.executeInstruction(state, instruction);
+                state = this.executeInstruction(state, instruction, instructions);
                 if (instruction.opcode === JSVMPOpcode.HALT) {
                     break;
                 }
@@ -88,7 +88,7 @@ export class JSVMPSymbolicExecutor extends SymbolicExecutor {
             throw error;
         }
     }
-    executeInstruction(state, instruction) {
+    executeInstruction(state, instruction, instructions) {
         const newState = this.cloneStateInternal(state);
         switch (instruction.opcode) {
             case JSVMPOpcode.PUSH:
@@ -106,6 +106,55 @@ export class JSVMPSymbolicExecutor extends SymbolicExecutor {
             case JSVMPOpcode.MUL:
                 this.executeMul(newState);
                 break;
+            case JSVMPOpcode.DIV:
+                this.executeDiv(newState);
+                break;
+            case JSVMPOpcode.MOD:
+                this.executeMod(newState);
+                break;
+            case JSVMPOpcode.AND:
+                this.executeAnd(newState);
+                break;
+            case JSVMPOpcode.OR:
+                this.executeOr(newState);
+                break;
+            case JSVMPOpcode.NOT:
+                this.executeNot(newState);
+                break;
+            case JSVMPOpcode.XOR:
+                this.executeXor(newState);
+                break;
+            case JSVMPOpcode.EQ:
+                this.executeEq(newState);
+                break;
+            case JSVMPOpcode.NE:
+                this.executeNe(newState);
+                break;
+            case JSVMPOpcode.LT:
+                this.executeLt(newState);
+                break;
+            case JSVMPOpcode.LE:
+                this.executeLe(newState);
+                break;
+            case JSVMPOpcode.GT:
+                this.executeGt(newState);
+                break;
+            case JSVMPOpcode.GE:
+                this.executeGe(newState);
+                break;
+            case JSVMPOpcode.JNZ:
+                this.executeJnz(newState, this.asNumberOperand(instruction.operands[0]));
+                return newState;
+            case JSVMPOpcode.RET:
+                newState.pc = instructions.length;
+                return newState;
+            case JSVMPOpcode.DUP:
+                this.executeDup(newState);
+                break;
+            case JSVMPOpcode.LOAD_CONST:
+                this.executePush(newState, instruction.operands[0]);
+                newState.pc++;
+                return newState;
             case JSVMPOpcode.LOAD:
                 this.executeLoad(newState, this.asStringOperand(instruction.operands[0]));
                 break;
@@ -168,6 +217,136 @@ export class JSVMPSymbolicExecutor extends SymbolicExecutor {
             state.stack.push(result);
         }
     }
+    executeDiv(state) {
+        const b = state.stack.pop();
+        const a = state.stack.pop();
+        if (a && b) {
+            const result = this.createSymbolicValue('number', `${a.name} / ${b.name}`);
+            this.addConstraint(result, 'custom', `${result.name} = ${a.name} / ${b.name}`, '');
+            state.stack.push(result);
+        }
+    }
+    executeMod(state) {
+        const b = state.stack.pop();
+        const a = state.stack.pop();
+        if (a && b) {
+            const result = this.createSymbolicValue('number', `${a.name} % ${b.name}`);
+            this.addConstraint(result, 'custom', `${result.name} = ${a.name} % ${b.name}`, '');
+            state.stack.push(result);
+        }
+    }
+    executeAnd(state) {
+        const b = state.stack.pop();
+        const a = state.stack.pop();
+        if (a && b) {
+            const result = this.createSymbolicValue('boolean', `${a.name} && ${b.name}`);
+            this.addConstraint(result, 'custom', `${result.name} = ${a.name} && ${b.name}`, '');
+            state.stack.push(result);
+        }
+    }
+    executeOr(state) {
+        const b = state.stack.pop();
+        const a = state.stack.pop();
+        if (a && b) {
+            const result = this.createSymbolicValue('boolean', `${a.name} || ${b.name}`);
+            this.addConstraint(result, 'custom', `${result.name} = ${a.name} || ${b.name}`, '');
+            state.stack.push(result);
+        }
+    }
+    executeNot(state) {
+        const a = state.stack.pop();
+        if (a) {
+            const result = this.createSymbolicValue('boolean', `!${a.name}`);
+            this.addConstraint(result, 'custom', `${result.name} = !${a.name}`, '');
+            state.stack.push(result);
+        }
+    }
+    executeXor(state) {
+        const b = state.stack.pop();
+        const a = state.stack.pop();
+        if (a && b) {
+            const result = this.createSymbolicValue('boolean', `${a.name} ^ ${b.name}`);
+            this.addConstraint(result, 'custom', `${result.name} = ${a.name} ^ ${b.name}`, '');
+            state.stack.push(result);
+        }
+    }
+    executeEq(state) {
+        const b = state.stack.pop();
+        const a = state.stack.pop();
+        if (a && b) {
+            const result = this.createSymbolicValue('boolean', `${a.name} === ${b.name}`);
+            this.addConstraint(result, 'custom', `${result.name} = ${a.name} === ${b.name}`, '');
+            state.stack.push(result);
+        }
+    }
+    executeNe(state) {
+        const b = state.stack.pop();
+        const a = state.stack.pop();
+        if (a && b) {
+            const result = this.createSymbolicValue('boolean', `${a.name} !== ${b.name}`);
+            this.addConstraint(result, 'custom', `${result.name} = ${a.name} !== ${b.name}`, '');
+            state.stack.push(result);
+        }
+    }
+    executeLt(state) {
+        const b = state.stack.pop();
+        const a = state.stack.pop();
+        if (a && b) {
+            const result = this.createSymbolicValue('boolean', `${a.name} < ${b.name}`);
+            this.addConstraint(result, 'custom', `${result.name} = ${a.name} < ${b.name}`, '');
+            state.stack.push(result);
+        }
+    }
+    executeLe(state) {
+        const b = state.stack.pop();
+        const a = state.stack.pop();
+        if (a && b) {
+            const result = this.createSymbolicValue('boolean', `${a.name} <= ${b.name}`);
+            this.addConstraint(result, 'custom', `${result.name} = ${a.name} <= ${b.name}`, '');
+            state.stack.push(result);
+        }
+    }
+    executeGt(state) {
+        const b = state.stack.pop();
+        const a = state.stack.pop();
+        if (a && b) {
+            const result = this.createSymbolicValue('boolean', `${a.name} > ${b.name}`);
+            this.addConstraint(result, 'custom', `${result.name} = ${a.name} > ${b.name}`, '');
+            state.stack.push(result);
+        }
+    }
+    executeGe(state) {
+        const b = state.stack.pop();
+        const a = state.stack.pop();
+        if (a && b) {
+            const result = this.createSymbolicValue('boolean', `${a.name} >= ${b.name}`);
+            this.addConstraint(result, 'custom', `${result.name} = ${a.name} >= ${b.name}`, '');
+            state.stack.push(result);
+        }
+    }
+    executeJnz(state, target) {
+        const condition = state.stack.pop();
+        if (condition) {
+            const constraint = {
+                type: 'inequality',
+                expression: `${condition.name} != 0`,
+                description: '',
+            };
+            state.pathConstraints.push(constraint);
+            state.pc = target;
+        }
+    }
+    executeDup(state) {
+        const value = state.stack[state.stack.length - 1];
+        if (value) {
+            const dup = this.createSymbolicValue(value.type, value.name, value.source);
+            dup.constraints = [...value.constraints];
+            if (value.possibleValues) {
+                dup.possibleValues = [...value.possibleValues];
+            }
+            state.stack.push(dup);
+        }
+    }
     executeLoad(state, varName) {
         const value = state.memory.get(varName);
         if (value) {

package/dist/src/modules/trace/TraceDB.js

@@ -1,3 +1,4 @@
+import { formatBetterSqlite3Error } from '../../utils/betterSqlite3.js';
 let Database;
 try {
     Database = require('better-sqlite3');
@@ -19,9 +20,14 @@ export class TraceDB {
     constructor(options) {
         this.options = options;
         if (!Database) {
-            throw new Error('better-sqlite3 is not installed. Install it with: pnpm add better-sqlite3');
+            throw new Error(formatBetterSqlite3Error(new Error("Cannot find package 'better-sqlite3'")));
+        }
+        try {
+            this.db = new Database(options.dbPath);
+        }
+        catch (error) {
+            throw new Error(formatBetterSqlite3Error(error), { cause: error });
         }
-        this.db = new Database(options.dbPath);
         this.batchSize = options.batchSize ?? 200;
         this.db.pragma('journal_mode = WAL');
         this.db.pragma('synchronous = NORMAL');
@@ -138,7 +144,7 @@ export class TraceDB {
             return { columns, rows: [], rowCount: 0 };
         }
         const columns = Object.keys(rows[0]);
-        const rowArrays = rows.map(row => columns.map(col => row[col]));
+        const rowArrays = rows.map((row) => columns.map((col) => row[col]));
         return { columns, rows: rowArrays, rowCount: rows.length };
     }
     getEventsByTimeRange(start, end) {
@@ -150,7 +156,7 @@ export class TraceDB {
       WHERE timestamp >= ? AND timestamp <= ?
       ORDER BY timestamp ASC
     `);
-        return stmt.all(start, end).map(row => ({
+        return stmt.all(start, end).map((row) => ({
             id: row['id'],
             timestamp: row['timestamp'],
             category: row['category'],
@@ -169,7 +175,7 @@ export class TraceDB {
       WHERE address = ?
       ORDER BY timestamp ASC
     `);
-        return stmt.all(address).map(row => ({
+        return stmt.all(address).map((row) => ({
             id: row['id'],
             timestamp: row['timestamp'],
             address: row['address'],
@@ -186,7 +192,7 @@ export class TraceDB {
       FROM heap_snapshots
       ORDER BY timestamp ASC
     `);
-        return stmt.all().map(row => ({
+        return stmt.all().map((row) => ({
             id: row['id'],
             timestamp: row['timestamp'],
             snapshotData: row['snapshot_data'],