@jshookmcp/jshook 0.2.6 → 0.2.8

package/dist/src/native/HeapAnalyzer.js

@@ -1,239 +0,0 @@
-import { logger } from '../utils/logger.js';
-import koffi from 'koffi';
-import { openProcessForMemory, CloseHandle, ReadProcessMemory } from './Win32API.js';
-import { HEAP_ENUMERATE_MAX_BLOCKS, HEAP_SPRAY_THRESHOLD, HEAP_SPRAY_SIZE_TOLERANCE, HEAP_SUSPICIOUS_BLOCK_SIZE, } from '../constants.js';
-import { LF32, HF32 } from './HeapAnalyzer.types.js';
-import { TH32CS } from './Win32Debug.js';
-let _heapApis = null;
-function loadHeapApis() {
-    const k32 = koffi.load('kernel32.dll');
-    return {
-        CreateToolhelp32Snapshot: k32.func('CreateToolhelp32Snapshot', 'intptr', ['uint32', 'uint32']),
-        Heap32ListFirst: k32.func('Heap32ListFirst', 'bool', ['intptr', '_Inout_ uint8_t *']),
-        Heap32ListNext: k32.func('Heap32ListNext', 'bool', ['intptr', '_Inout_ uint8_t *']),
-        Heap32First: k32.func('Heap32First', 'bool', ['_Inout_ uint8_t *', 'uint32', 'uintptr_t']),
-        Heap32Next: k32.func('Heap32Next', 'bool', ['_Inout_ uint8_t *']),
-        CloseHandle: k32.func('int CloseHandle(intptr)'),
-        HEAPLIST32_SIZE: 36,
-        HEAPENTRY32_SIZE: 56,
-    };
-}
-function getHeapApis() {
-    if (!_heapApis)
-        _heapApis = loadHeapApis();
-    return _heapApis;
-}
-const SIZE_RANGES = [
-    ['0-64B', 0, 64],
-    ['64-256B', 64, 256],
-    ['256B-1KB', 256, 1024],
-    ['1-4KB', 1024, 4096],
-    ['4-16KB', 4096, 16384],
-    ['16-64KB', 16384, 65536],
-    ['64KB-1MB', 65536, 1048576],
-    ['>1MB', 1048576, Number.MAX_SAFE_INTEGER],
-];
-function classifyBlock(size) {
-    for (let i = 0; i < SIZE_RANGES.length; i++) {
-        const range = SIZE_RANGES[i];
-        if (size >= range[1] && size < range[2])
-            return i;
-    }
-    return SIZE_RANGES.length - 1;
-}
-export class HeapAnalyzer {
-    async enumerateHeaps(pid) {
-        const apis = getHeapApis();
-        const hSnap = apis.CreateToolhelp32Snapshot(TH32CS.SNAPHEAPLIST, pid);
-        if (hSnap === -1n && typeof hSnap === 'bigint') {
-            throw new Error(`Failed to create heap snapshot for PID ${pid}`);
-        }
-        const heaps = [];
-        try {
-            const hlBuf = Buffer.alloc(apis.HEAPLIST32_SIZE);
-            hlBuf.writeBigUInt64LE(BigInt(apis.HEAPLIST32_SIZE), 0);
-            let hasHeap = apis.Heap32ListFirst(hSnap, hlBuf);
-            while (hasHeap) {
-                const processId = hlBuf.readUInt32LE(8);
-                const heapId = hlBuf.readBigUInt64LE(12);
-                const flags = hlBuf.readUInt32LE(20);
-                const blocks = await this._enumerateBlocksInternal(pid, heapId, HEAP_ENUMERATE_MAX_BLOCKS);
-                heaps.push({
-                    heapId: `0x${heapId.toString(16)}`,
-                    processId,
-                    flags,
-                    isDefault: (flags & HF32.DEFAULT) !== 0,
-                    blockCount: blocks.length,
-                    totalSize: blocks.reduce((sum, b) => sum + b.size, 0),
-                });
-                hlBuf.writeBigUInt64LE(BigInt(apis.HEAPLIST32_SIZE), 0);
-                hasHeap = apis.Heap32ListNext(hSnap, hlBuf);
-            }
-        }
-        finally {
-            apis.CloseHandle(hSnap);
-        }
-        const stats = this._computeStats(heaps, []);
-        return { heaps, stats };
-    }
-    async enumerateBlocks(pid, heapId, options) {
-        const id = BigInt(heapId);
-        const max = options?.maxBlocks ?? HEAP_ENUMERATE_MAX_BLOCKS;
-        return this._enumerateBlocksInternal(pid, id, max);
-    }
-    async getStats(pid) {
-        const { heaps } = await this.enumerateHeaps(pid);
-        const allBlocks = [];
-        for (const heap of heaps) {
-            const blocks = await this._enumerateBlocksInternal(pid, BigInt(heap.heapId), HEAP_ENUMERATE_MAX_BLOCKS);
-            allBlocks.push(...blocks);
-        }
-        return this._computeStats(heaps, allBlocks);
-    }
-    async detectAnomalies(pid) {
-        const anomalies = [];
-        const { heaps } = await this.enumerateHeaps(pid);
-        for (const heap of heaps) {
-            const blocks = await this._enumerateBlocksInternal(pid, BigInt(heap.heapId), HEAP_ENUMERATE_MAX_BLOCKS);
-            this._detectSpray(blocks, heap.heapId, anomalies);
-            this._detectSuspiciousSizes(blocks, heap.heapId, anomalies);
-            await this._detectPossibleUAF(pid, blocks, heap.heapId, anomalies);
-        }
-        return anomalies;
-    }
-    async _enumerateBlocksInternal(pid, heapId, maxBlocks) {
-        const apis = getHeapApis();
-        const blocks = [];
-        const heBuf = Buffer.alloc(apis.HEAPENTRY32_SIZE);
-        heBuf.writeBigUInt64LE(BigInt(apis.HEAPENTRY32_SIZE), 0);
-        let hasBlock = apis.Heap32First(heBuf, pid, heapId);
-        while (hasBlock && blocks.length < maxBlocks) {
-            const address = heBuf.readBigUInt64LE(16);
-            const blockSize = Number(heBuf.readBigUInt64LE(24));
-            const flags = heBuf.readUInt32LE(32);
-            blocks.push({
-                address: `0x${address.toString(16)}`,
-                size: blockSize,
-                flags,
-                heapId: `0x${heapId.toString(16)}`,
-                isFree: (flags & LF32.FREE) !== 0,
-            });
-            heBuf.writeBigUInt64LE(BigInt(apis.HEAPENTRY32_SIZE), 0);
-            hasBlock = apis.Heap32Next(heBuf);
-        }
-        return blocks;
-    }
-    _computeStats(heaps, blocks) {
-        const buckets = SIZE_RANGES.map(([range]) => ({
-            range,
-            count: 0,
-            totalBytes: 0,
-        }));
-        let totalSize = 0;
-        let freeSize = 0;
-        let largestBlock = 0;
-        let smallestBlock = Number.MAX_SAFE_INTEGER;
-        for (const block of blocks) {
-            totalSize += block.size;
-            if (block.isFree)
-                freeSize += block.size;
-            if (block.size > largestBlock)
-                largestBlock = block.size;
-            if (!block.isFree && block.size < smallestBlock)
-                smallestBlock = block.size;
-            const idx = classifyBlock(block.size);
-            buckets[idx].count++;
-            buckets[idx].totalBytes += block.size;
-        }
-        if (smallestBlock === Number.MAX_SAFE_INTEGER)
-            smallestBlock = 0;
-        if (totalSize === 0 && heaps.length > 0) {
-            totalSize = heaps.reduce((s, h) => s + h.totalSize, 0);
-        }
-        return {
-            totalHeaps: heaps.length,
-            totalBlocks: blocks.length || heaps.reduce((s, h) => s + h.blockCount, 0),
-            totalSize,
-            freeSize,
-            usedSize: totalSize - freeSize,
-            largestBlock,
-            smallestBlock,
-            averageBlockSize: blocks.length > 0 ? Math.round(totalSize / blocks.length) : 0,
-            sizeDistribution: buckets,
-            fragmentationRatio: totalSize > 0 ? freeSize / totalSize : 0,
-        };
-    }
-    _detectSpray(blocks, heapId, anomalies) {
-        const sizeGroups = new Map();
-        for (const block of blocks) {
-            if (block.isFree)
-                continue;
-            const rounded = Math.round(block.size / HEAP_SPRAY_SIZE_TOLERANCE) * HEAP_SPRAY_SIZE_TOLERANCE;
-            const group = sizeGroups.get(rounded) ?? [];
-            group.push(block);
-            sizeGroups.set(rounded, group);
-        }
-        for (const [size, group] of sizeGroups) {
-            if (group.length >= HEAP_SPRAY_THRESHOLD) {
-                anomalies.push({
-                    type: 'heap_spray_pattern',
-                    severity: 'high',
-                    address: group[0].address,
-                    details: `${group.length} blocks of ~${size} bytes detected — possible heap spray`,
-                    heapId,
-                });
-            }
-        }
-    }
-    _detectSuspiciousSizes(blocks, heapId, anomalies) {
-        for (const block of blocks) {
-            if (block.size === 0) {
-                anomalies.push({
-                    type: 'suspicious_size',
-                    severity: 'medium',
-                    address: block.address,
-                    details: 'Block with zero size',
-                    heapId,
-                });
-            }
-            else if (block.size > HEAP_SUSPICIOUS_BLOCK_SIZE) {
-                anomalies.push({
-                    type: 'suspicious_size',
-                    severity: 'medium',
-                    address: block.address,
-                    details: `Unusually large block: ${(block.size / (1024 * 1024)).toFixed(1)} MB`,
-                    heapId,
-                });
-            }
-        }
-    }
-    async _detectPossibleUAF(pid, blocks, heapId, anomalies) {
-        const freeBlocks = blocks.filter((b) => b.isFree && b.size >= 8);
-        const sampled = freeBlocks.slice(0, 100);
-        let hProcess = null;
-        try {
-            hProcess = openProcessForMemory(pid);
-            for (const block of sampled) {
-                const addr = BigInt(block.address);
-                const data = ReadProcessMemory(hProcess, addr, 8);
-                if (data && data.readBigUInt64LE(0) !== 0n) {
-                    anomalies.push({
-                        type: 'possible_uaf',
-                        severity: 'low',
-                        address: block.address,
-                        details: `Free block has non-zero data: 0x${data.readBigUInt64LE(0).toString(16)}`,
-                        heapId,
-                    });
-                }
-            }
-        }
-        catch (e) {
-            logger.debug(`UAF check failed for PID ${pid}: ${e}`);
-        }
-        finally {
-            if (hProcess)
-                CloseHandle(hProcess);
-        }
-    }
-}
-export const heapAnalyzer = new HeapAnalyzer();

package/dist/src/native/HeapAnalyzer.types.d.ts

@@ -1,49 +0,0 @@
-export interface HeapInfo {
-    heapId: string;
-    processId: number;
-    flags: number;
-    isDefault: boolean;
-    blockCount: number;
-    totalSize: number;
-}
-export interface HeapBlock {
-    address: string;
-    size: number;
-    flags: number;
-    heapId: string;
-    isFree: boolean;
-}
-export interface HeapStats {
-    totalHeaps: number;
-    totalBlocks: number;
-    totalSize: number;
-    freeSize: number;
-    usedSize: number;
-    largestBlock: number;
-    smallestBlock: number;
-    averageBlockSize: number;
-    sizeDistribution: HeapSizeBucket[];
-    fragmentationRatio: number;
-}
-export interface HeapSizeBucket {
-    range: string;
-    count: number;
-    totalBytes: number;
-}
-export type HeapAnomalyType = 'heap_spray_pattern' | 'possible_uaf' | 'suspicious_size' | 'possible_double_free' | 'guard_page_missing';
-export interface HeapAnomaly {
-    type: HeapAnomalyType;
-    severity: 'low' | 'medium' | 'high';
-    address: string;
-    details: string;
-    heapId: string;
-}
-export declare const LF32: {
-    readonly FIXED: 1;
-    readonly FREE: 2;
-    readonly MOVEABLE: 4;
-};
-export declare const HF32: {
-    readonly DEFAULT: 1;
-    readonly SHARED: 2;
-};

package/dist/src/native/HeapAnalyzer.types.js

@@ -1,9 +0,0 @@
-export const LF32 = {
-    FIXED: 0x00000001,
-    FREE: 0x00000002,
-    MOVEABLE: 0x00000004,
-};
-export const HF32 = {
-    DEFAULT: 0x00000001,
-    SHARED: 0x00000002,
-};

package/dist/src/native/MemoryController.d.ts

@@ -1,17 +0,0 @@
-import type { FreezeEntry, WriteHistoryEntry } from './MemoryController.types.js';
-export declare class MemoryController {
-    private freezes;
-    private writeHistory;
-    private undoneStack;
-    writeValue(pid: number, address: string, value: string, valueType: string): Promise<WriteHistoryEntry>;
-    undo(): Promise<WriteHistoryEntry | null>;
-    redo(): Promise<WriteHistoryEntry | null>;
-    freeze(pid: number, address: string, value: string, valueType: string, intervalMs?: number): Promise<FreezeEntry>;
-    unfreeze(freezeId: string): Promise<boolean>;
-    unfreezeAll(): Promise<number>;
-    listFreezes(): FreezeEntry[];
-    dumpMemory(pid: number, address: string, size: number): Promise<Buffer>;
-    dumpMemoryHex(pid: number, address: string, size: number): Promise<string>;
-    getWriteHistory(): WriteHistoryEntry[];
-}
-export declare const memoryController: MemoryController;

package/dist/src/native/MemoryController.js

@@ -1,165 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { FREEZE_DEFAULT_INTERVAL_MS, WRITE_HISTORY_MAX } from '../constants.js';
-import { openProcessForMemory, CloseHandle, ReadProcessMemory, WriteProcessMemory, VirtualProtectEx, PAGE, } from './Win32API.js';
-import { parsePattern } from './NativeMemoryManager.utils.js';
-export class MemoryController {
-    freezes = new Map();
-    writeHistory = [];
-    undoneStack = [];
-    async writeValue(pid, address, value, valueType) {
-        const addr = BigInt(address.startsWith('0x') ? address : `0x${address}`);
-        const { patternBytes } = parsePattern(value, valueType);
-        const newBuf = Buffer.from(patternBytes);
-        const handle = openProcessForMemory(pid, true);
-        try {
-            const oldBuf = ReadProcessMemory(handle, addr, newBuf.length);
-            const { oldProtect } = VirtualProtectEx(handle, addr, newBuf.length, PAGE.READWRITE);
-            WriteProcessMemory(handle, addr, newBuf);
-            VirtualProtectEx(handle, addr, newBuf.length, oldProtect);
-            const entry = {
-                id: randomUUID(),
-                pid,
-                address: `0x${addr.toString(16).toUpperCase()}`,
-                oldValue: Array.from(oldBuf),
-                newValue: Array.from(newBuf),
-                timestamp: Date.now(),
-                undone: false,
-            };
-            this.writeHistory.push(entry);
-            this.undoneStack = [];
-            if (this.writeHistory.length > WRITE_HISTORY_MAX) {
-                this.writeHistory = this.writeHistory.slice(-WRITE_HISTORY_MAX);
-            }
-            return entry;
-        }
-        finally {
-            CloseHandle(handle);
-        }
-    }
-    async undo() {
-        for (let i = this.writeHistory.length - 1; i >= 0; i--) {
-            const entry = this.writeHistory[i];
-            if (!entry.undone) {
-                const addr = BigInt(entry.address);
-                const oldBuf = Buffer.from(entry.oldValue);
-                const handle = openProcessForMemory(entry.pid, true);
-                try {
-                    const { oldProtect } = VirtualProtectEx(handle, addr, oldBuf.length, PAGE.READWRITE);
-                    WriteProcessMemory(handle, addr, oldBuf);
-                    VirtualProtectEx(handle, addr, oldBuf.length, oldProtect);
-                }
-                finally {
-                    CloseHandle(handle);
-                }
-                entry.undone = true;
-                this.undoneStack.push(entry);
-                return entry;
-            }
-        }
-        return null;
-    }
-    async redo() {
-        const entry = this.undoneStack.pop();
-        if (!entry)
-            return null;
-        const addr = BigInt(entry.address);
-        const newBuf = Buffer.from(entry.newValue);
-        const handle = openProcessForMemory(entry.pid, true);
-        try {
-            const { oldProtect } = VirtualProtectEx(handle, addr, newBuf.length, PAGE.READWRITE);
-            WriteProcessMemory(handle, addr, newBuf);
-            VirtualProtectEx(handle, addr, newBuf.length, oldProtect);
-        }
-        finally {
-            CloseHandle(handle);
-        }
-        entry.undone = false;
-        return entry;
-    }
-    async freeze(pid, address, value, valueType, intervalMs) {
-        const addr = BigInt(address.startsWith('0x') ? address : `0x${address}`);
-        const { patternBytes } = parsePattern(value, valueType);
-        const valueBuf = Buffer.from(patternBytes);
-        const interval = intervalMs ?? FREEZE_DEFAULT_INTERVAL_MS;
-        const entry = {
-            id: randomUUID(),
-            pid,
-            address: `0x${addr.toString(16).toUpperCase()}`,
-            value: Array.from(valueBuf),
-            valueType,
-            intervalMs: interval,
-            isActive: true,
-        };
-        entry.timer = setInterval(() => {
-            try {
-                const handle = openProcessForMemory(pid, true);
-                try {
-                    const { oldProtect } = VirtualProtectEx(handle, addr, valueBuf.length, PAGE.READWRITE);
-                    WriteProcessMemory(handle, addr, valueBuf);
-                    VirtualProtectEx(handle, addr, valueBuf.length, oldProtect);
-                }
-                finally {
-                    CloseHandle(handle);
-                }
-            }
-            catch {
-                entry.isActive = false;
-                if (entry.timer)
-                    clearInterval(entry.timer);
-            }
-        }, interval);
-        this.freezes.set(entry.id, entry);
-        return entry;
-    }
-    async unfreeze(freezeId) {
-        const entry = this.freezes.get(freezeId);
-        if (!entry)
-            return false;
-        if (entry.timer)
-            clearInterval(entry.timer);
-        entry.isActive = false;
-        this.freezes.delete(freezeId);
-        return true;
-    }
-    async unfreezeAll() {
-        let count = 0;
-        for (const [id] of this.freezes) {
-            await this.unfreeze(id);
-            count++;
-        }
-        return count;
-    }
-    listFreezes() {
-        return Array.from(this.freezes.values()).map(({ timer: _timer, ...rest }) => rest);
-    }
-    async dumpMemory(pid, address, size) {
-        const addr = BigInt(address.startsWith('0x') ? address : `0x${address}`);
-        const handle = openProcessForMemory(pid, false);
-        try {
-            return ReadProcessMemory(handle, addr, size);
-        }
-        finally {
-            CloseHandle(handle);
-        }
-    }
-    async dumpMemoryHex(pid, address, size) {
-        const buf = await this.dumpMemory(pid, address, size);
-        const lines = [];
-        const addr = BigInt(address.startsWith('0x') ? address : `0x${address}`);
-        for (let i = 0; i < buf.length; i += 16) {
-            const lineAddr = addr + BigInt(i);
-            const hex = Array.from(buf.subarray(i, Math.min(i + 16, buf.length)))
-                .map((b) => b.toString(16).padStart(2, '0'))
-                .join(' ');
-            const ascii = Array.from(buf.subarray(i, Math.min(i + 16, buf.length)))
-                .map((b) => (b >= 0x20 && b <= 0x7e ? String.fromCharCode(b) : '.'))
-                .join('');
-            lines.push(`${lineAddr.toString(16).padStart(12, '0')}  ${hex.padEnd(47)}  |${ascii}|`);
-        }
-        return lines.join('\n');
-    }
-    getWriteHistory() {
-        return [...this.writeHistory];
-    }
-}
-export const memoryController = new MemoryController();

package/dist/src/native/MemoryController.types.d.ts

@@ -1,18 +0,0 @@
-export interface FreezeEntry {
-    id: string;
-    pid: number;
-    address: string;
-    value: number[];
-    valueType: string;
-    intervalMs: number;
-    isActive: boolean;
-}
-export interface WriteHistoryEntry {
-    id: string;
-    pid: number;
-    address: string;
-    oldValue: number[];
-    newValue: number[];
-    timestamp: number;
-    undone: boolean;
-}

package/dist/src/native/MemoryController.types.js

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

package/dist/src/native/MemoryScanSession.d.ts

@@ -1,24 +0,0 @@
-import type { ScanOptions, ScanSessionState, ScanValueType } from './NativeMemoryManager.types.js';
-export interface ScanSessionSummary {
-    id: string;
-    pid: number;
-    valueType: ScanValueType;
-    addressCount: number;
-    scanCount: number;
-    age: string;
-}
-export declare class MemoryScanSessionManager {
-    private sessions;
-    private readonly maxSessions;
-    private readonly sessionTtlMs;
-    constructor(maxSessions?: number, sessionTtlMs?: number);
-    createSession(pid: number, options: ScanOptions): string;
-    getSession(sessionId: string): ScanSessionState;
-    updateSession(sessionId: string, addresses: bigint[], values: Map<bigint, Buffer>): void;
-    listSessions(): ScanSessionSummary[];
-    deleteSession(sessionId: string): boolean;
-    cleanup(): number;
-    exportSession(sessionId: string): string;
-    importSession(data: string): string;
-}
-export declare const scanSessionManager: MemoryScanSessionManager;

package/dist/src/native/MemoryScanSession.js

@@ -1,140 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { SCAN_SESSION_MAX_COUNT, SCAN_SESSION_TTL_MS } from '../constants.js';
-import { getDefaultAlignment } from './ScanComparators.js';
-import { formatAddress, parseAddress } from './formatAddress.js';
-export class MemoryScanSessionManager {
-    sessions = new Map();
-    maxSessions;
-    sessionTtlMs;
-    constructor(maxSessions = SCAN_SESSION_MAX_COUNT, sessionTtlMs = SCAN_SESSION_TTL_MS) {
-        this.maxSessions = maxSessions;
-        this.sessionTtlMs = sessionTtlMs;
-    }
-    createSession(pid, options) {
-        this.cleanup();
-        if (this.sessions.size >= this.maxSessions) {
-            let oldestId = null;
-            let oldestTime = Infinity;
-            for (const [id, session] of this.sessions) {
-                if (session.createdAt < oldestTime) {
-                    oldestTime = session.createdAt;
-                    oldestId = id;
-                }
-            }
-            if (oldestId) {
-                this.sessions.delete(oldestId);
-            }
-        }
-        const id = randomUUID();
-        const alignment = options.alignment ?? getDefaultAlignment(options.valueType);
-        const now = Date.now();
-        const session = {
-            id,
-            pid,
-            valueType: options.valueType,
-            alignment,
-            createdAt: now,
-            lastScanAt: now,
-            scanCount: 0,
-            addresses: [],
-            previousValues: new Map(),
-        };
-        this.sessions.set(id, session);
-        return id;
-    }
-    getSession(sessionId) {
-        const session = this.sessions.get(sessionId);
-        if (!session) {
-            throw new Error(`Scan session not found: ${sessionId}`);
-        }
-        if (Date.now() - session.lastScanAt > this.sessionTtlMs) {
-            this.sessions.delete(sessionId);
-            throw new Error(`Scan session expired: ${sessionId}`);
-        }
-        return session;
-    }
-    updateSession(sessionId, addresses, values) {
-        const session = this.getSession(sessionId);
-        session.addresses = addresses;
-        session.previousValues = values;
-        session.lastScanAt = Date.now();
-        session.scanCount++;
-    }
-    listSessions() {
-        this.cleanup();
-        const result = [];
-        const now = Date.now();
-        for (const session of this.sessions.values()) {
-            const ageMs = now - session.createdAt;
-            const ageMin = Math.floor(ageMs / 60_000);
-            const ageSec = Math.floor((ageMs % 60_000) / 1_000);
-            result.push({
-                id: session.id,
-                pid: session.pid,
-                valueType: session.valueType,
-                addressCount: session.addresses.length,
-                scanCount: session.scanCount,
-                age: ageMin > 0 ? `${ageMin}m${ageSec}s` : `${ageSec}s`,
-            });
-        }
-        return result;
-    }
-    deleteSession(sessionId) {
-        return this.sessions.delete(sessionId);
-    }
-    cleanup() {
-        const now = Date.now();
-        let count = 0;
-        for (const [id, session] of this.sessions) {
-            if (now - session.lastScanAt > this.sessionTtlMs) {
-                this.sessions.delete(id);
-                count++;
-            }
-        }
-        return count;
-    }
-    exportSession(sessionId) {
-        const session = this.getSession(sessionId);
-        const serializable = {
-            ...session,
-            addresses: session.addresses.map((addr) => formatAddress(addr)),
-            previousValues: Array.from(session.previousValues.entries()).map(([addr, buf]) => [formatAddress(addr), buf.toString('hex')]),
-        };
-        return JSON.stringify(serializable);
-    }
-    importSession(data) {
-        const parsed = JSON.parse(data);
-        const id = randomUUID();
-        const now = Date.now();
-        const previousValues = new Map();
-        if (Array.isArray(parsed.previousValues)) {
-            for (const [addr, hex] of parsed.previousValues) {
-                if (typeof addr === 'string' && typeof hex === 'string') {
-                    previousValues.set(parseAddress(addr), Buffer.from(hex, 'hex'));
-                }
-            }
-        }
-        const addresses = [];
-        if (Array.isArray(parsed.addresses)) {
-            for (const addr of parsed.addresses) {
-                if (typeof addr === 'string') {
-                    addresses.push(parseAddress(addr));
-                }
-            }
-        }
-        const session = {
-            id,
-            pid: parsed.pid,
-            valueType: parsed.valueType,
-            alignment: parsed.alignment ?? 4,
-            createdAt: now,
-            lastScanAt: now,
-            scanCount: parsed.scanCount ?? 0,
-            addresses,
-            previousValues,
-        };
-        this.sessions.set(id, session);
-        return id;
-    }
-}
-export const scanSessionManager = new MemoryScanSessionManager();