@jshookmcp/jshook 0.2.9 → 0.3.1

package/dist/handlers.impl-DS0d9fUw.mjs

@@ -1,761 +0,0 @@
-import { Lt as MEMORY_SCAN_MAX_RESULTS } from "./constants-B0OANIBL.mjs";
-//#region src/server/domains/memory/handlers/session.ts
-function toTextResponse$6(payload) {
-	return { content: [{
-		type: "text",
-		text: JSON.stringify(payload, null, 2)
-	}] };
-}
-function toErrorResponse$6(tool, error) {
-	return toTextResponse$6({
-		success: false,
-		tool,
-		error: error instanceof Error ? error.message : String(error)
-	});
-}
-var SessionHandlers = class {
-	constructor(sessionManager) {
-		this.sessionManager = sessionManager;
-	}
-	async handleScanList(_args) {
-		try {
-			const sessions = this.sessionManager.listSessions();
-			return toTextResponse$6({
-				success: true,
-				sessions,
-				count: sessions.length
-			});
-		} catch (error) {
-			return toErrorResponse$6("memory_scan_list", error);
-		}
-	}
-	async handleScanDelete(args) {
-		try {
-			return toTextResponse$6({
-				success: true,
-				deleted: this.sessionManager.deleteSession(args.sessionId)
-			});
-		} catch (error) {
-			return toErrorResponse$6("memory_scan_delete", error);
-		}
-	}
-	async handleScanExport(args) {
-		try {
-			return toTextResponse$6({
-				success: true,
-				exportedData: this.sessionManager.exportSession(args.sessionId)
-			});
-		} catch (error) {
-			return toErrorResponse$6("memory_scan_export", error);
-		}
-	}
-};
-//#endregion
-//#region src/server/domains/memory/handlers/scan.ts
-/** SECURITY: Cap user-supplied maxResults to prevent OOM */
-function capMaxResults(value) {
-	if (value === void 0 || !Number.isFinite(value) || value <= 0) return MEMORY_SCAN_MAX_RESULTS;
-	return Math.min(value, MEMORY_SCAN_MAX_RESULTS);
-}
-function toTextResponse$5(payload) {
-	return { content: [{
-		type: "text",
-		text: JSON.stringify(payload, null, 2)
-	}] };
-}
-function toErrorResponse$5(tool, error) {
-	return toTextResponse$5({
-		success: false,
-		tool,
-		error: error instanceof Error ? error.message : String(error)
-	});
-}
-var ScanHandlers = class {
-	constructor(scanner, eventBus) {
-		this.scanner = scanner;
-		this.eventBus = eventBus;
-	}
-	async handleFirstScan(args) {
-		try {
-			const options = {
-				valueType: args.valueType,
-				alignment: args.alignment,
-				maxResults: capMaxResults(args.maxResults),
-				regionFilter: args.regionFilter,
-				onProgress: args.onProgress
-			};
-			const result = await this.scanner.firstScan(args.pid, args.value, options);
-			this.eventBus?.emit("memory:scan_completed", {
-				scanType: "first",
-				resultCount: result.totalMatches ?? 0,
-				timestamp: (/* @__PURE__ */ new Date()).toISOString()
-			});
-			return toTextResponse$5({
-				success: true,
-				...result,
-				hint: result.totalMatches > 0 ? `Found ${result.totalMatches} matches. Use memory_next_scan with sessionId "${result.sessionId}" to narrow down.` : "No matches found. Try a different value or type."
-			});
-		} catch (error) {
-			return toErrorResponse$5("memory_first_scan", error);
-		}
-	}
-	async handleNextScan(args) {
-		try {
-			const result = await this.scanner.nextScan(args.sessionId, args.mode, args.value, args.value2);
-			return toTextResponse$5({
-				success: true,
-				...result,
-				hint: result.totalMatches <= 10 ? "Few matches remaining — inspect these addresses." : `${result.totalMatches} matches remain. Continue narrowing with memory_next_scan.`
-			});
-		} catch (error) {
-			return toErrorResponse$5("memory_next_scan", error);
-		}
-	}
-	async handleUnknownScan(args) {
-		try {
-			const options = {
-				valueType: args.valueType,
-				alignment: args.alignment,
-				maxResults: capMaxResults(args.maxResults),
-				regionFilter: args.regionFilter,
-				onProgress: args.onProgress
-			};
-			const result = await this.scanner.unknownInitialScan(args.pid, options);
-			return toTextResponse$5({
-				success: true,
-				...result,
-				hint: `Captured ${result.totalMatches} addresses. Use memory_next_scan with changed/unchanged/increased/decreased to narrow.`
-			});
-		} catch (error) {
-			return toErrorResponse$5("memory_unknown_scan", error);
-		}
-	}
-	async handlePointerScan(args) {
-		try {
-			return toTextResponse$5({
-				success: true,
-				...await this.scanner.pointerScan(args.pid, args.targetAddress, {
-					maxResults: capMaxResults(args.maxResults),
-					moduleOnly: args.moduleOnly
-				})
-			});
-		} catch (error) {
-			return toErrorResponse$5("memory_pointer_scan", error);
-		}
-	}
-	async handleGroupScan(args) {
-		try {
-			return toTextResponse$5({
-				success: true,
-				...await this.scanner.groupScan(args.pid, args.pattern, {
-					alignment: args.alignment,
-					maxResults: capMaxResults(args.maxResults)
-				})
-			});
-		} catch (error) {
-			return toErrorResponse$5("memory_group_scan", error);
-		}
-	}
-};
-//#endregion
-//#region src/server/domains/memory/handlers/pointer-chain.ts
-function toTextResponse$4(payload) {
-	return { content: [{
-		type: "text",
-		text: JSON.stringify(payload, null, 2)
-	}] };
-}
-function toErrorResponse$4(tool, error) {
-	return toTextResponse$4({
-		success: false,
-		tool,
-		error: error instanceof Error ? error.message : String(error)
-	});
-}
-var PointerChainHandlers = class {
-	constructor(ptrEngine) {
-		this.ptrEngine = ptrEngine;
-	}
-	async handlePointerChainScan(args) {
-		try {
-			const result = await this.ptrEngine.scan(args.pid, args.targetAddress, {
-				maxDepth: args.maxDepth,
-				maxOffset: args.maxOffset,
-				staticOnly: args.staticOnly,
-				modules: args.modules,
-				maxResults: args.maxResults
-			});
-			return toTextResponse$4({
-				success: true,
-				...result,
-				hint: result.totalFound > 0 ? `Found ${result.totalFound} pointer chains. Static chains survive process restarts.` : "No pointer chains found. Try increasing maxDepth or maxOffset."
-			});
-		} catch (error) {
-			return toErrorResponse$4("memory_pointer_chain_scan", error);
-		}
-	}
-	async handlePointerChainValidate(args) {
-		try {
-			const chains = JSON.parse(args.chains);
-			const results = await this.ptrEngine.validateChains(args.pid, chains);
-			return toTextResponse$4({
-				success: true,
-				results,
-				validCount: results.filter((r) => r.isValid).length,
-				totalChecked: chains.length
-			});
-		} catch (error) {
-			return toErrorResponse$4("memory_pointer_chain_validate", error);
-		}
-	}
-	async handlePointerChainResolve(args) {
-		try {
-			const chain = JSON.parse(args.chain);
-			const resolved = await this.ptrEngine.resolveChain(args.pid, chain);
-			return toTextResponse$4({
-				success: true,
-				chainId: chain.id,
-				resolvedAddress: resolved,
-				isResolvable: resolved !== null
-			});
-		} catch (error) {
-			return toErrorResponse$4("memory_pointer_chain_resolve", error);
-		}
-	}
-	async handlePointerChainExport(args) {
-		try {
-			const chains = JSON.parse(args.chains);
-			return toTextResponse$4({
-				success: true,
-				exportedData: this.ptrEngine.exportChains(chains),
-				chainCount: chains.length
-			});
-		} catch (error) {
-			return toErrorResponse$4("memory_pointer_chain_export", error);
-		}
-	}
-};
-//#endregion
-//#region src/server/domains/memory/handlers/structure.ts
-function toTextResponse$3(payload) {
-	return { content: [{
-		type: "text",
-		text: JSON.stringify(payload, null, 2)
-	}] };
-}
-function toErrorResponse$3(tool, error) {
-	return toTextResponse$3({
-		success: false,
-		tool,
-		error: error instanceof Error ? error.message : String(error)
-	});
-}
-var StructureHandlers = class {
-	constructor(structAnalyzer) {
-		this.structAnalyzer = structAnalyzer;
-	}
-	async handleStructureAnalyze(args) {
-		try {
-			const result = await this.structAnalyzer.analyzeStructure(args.pid, args.address, {
-				size: args.size,
-				otherInstances: args.otherInstances,
-				parseRtti: args.parseRtti
-			});
-			return toTextResponse$3({
-				success: true,
-				...result,
-				hint: result.className ? `Detected class: ${result.className}${result.baseClasses?.length ? ` (inherits: ${result.baseClasses.join(" → ")})` : ""}` : `Inferred ${result.fields.length} fields. Use memory_structure_export_c to export as C struct.`
-			});
-		} catch (error) {
-			return toErrorResponse$3("memory_structure_analyze", error);
-		}
-	}
-	async handleVtableParse(args) {
-		try {
-			return toTextResponse$3({
-				success: true,
-				...await this.structAnalyzer.parseVtable(args.pid, args.vtableAddress)
-			});
-		} catch (error) {
-			return toErrorResponse$3("memory_vtable_parse", error);
-		}
-	}
-	async handleStructureExportC(args) {
-		try {
-			const structure = JSON.parse(args.structure);
-			return toTextResponse$3({
-				success: true,
-				...this.structAnalyzer.exportToCStruct(structure, args.name)
-			});
-		} catch (error) {
-			return toErrorResponse$3("memory_structure_export_c", error);
-		}
-	}
-	async handleStructureCompare(args) {
-		try {
-			const result = await this.structAnalyzer.compareInstances(args.pid, args.address1, args.address2, args.size);
-			return toTextResponse$3({
-				success: true,
-				matchingFieldCount: result.matching.length,
-				differingFieldCount: result.differing.length,
-				...result
-			});
-		} catch (error) {
-			return toErrorResponse$3("memory_structure_compare", error);
-		}
-	}
-};
-//#endregion
-//#region src/server/domains/memory/handlers/hooks.ts
-function toTextResponse$2(payload) {
-	return { content: [{
-		type: "text",
-		text: JSON.stringify(payload, null, 2)
-	}] };
-}
-function toErrorResponse$2(tool, error) {
-	return toTextResponse$2({
-		success: false,
-		tool,
-		error: error instanceof Error ? error.message : String(error)
-	});
-}
-var HookHandlers = class {
-	constructor(bpEngine, injector) {
-		this.bpEngine = bpEngine;
-		this.injector = injector;
-	}
-	async handleBreakpointSet(args) {
-		try {
-			return toTextResponse$2({
-				success: true,
-				...await this.bpEngine.setBreakpoint(args.pid, args.address, args.access, args.size ?? 4),
-				hint: `Hardware breakpoint set on DR register. Use memory_breakpoint_trace to collect hits.`
-			});
-		} catch (error) {
-			return toErrorResponse$2("memory_breakpoint_set", error);
-		}
-	}
-	async handleBreakpointRemove(args) {
-		try {
-			return toTextResponse$2({
-				success: true,
-				removed: await this.bpEngine.removeBreakpoint(args.breakpointId)
-			});
-		} catch (error) {
-			return toErrorResponse$2("memory_breakpoint_remove", error);
-		}
-	}
-	async handleBreakpointList(_args) {
-		try {
-			const bps = this.bpEngine.listBreakpoints();
-			return toTextResponse$2({
-				success: true,
-				breakpoints: bps,
-				count: bps.length
-			});
-		} catch (error) {
-			return toErrorResponse$2("memory_breakpoint_list", error);
-		}
-	}
-	async handleBreakpointTrace(args) {
-		try {
-			const hits = await this.bpEngine.traceAccess(args.pid, args.address, args.access, args.maxHits, args.timeoutMs);
-			return toTextResponse$2({
-				success: true,
-				hits,
-				hitCount: hits.length,
-				hint: hits.length > 0 ? `${hits.length} accesses captured. Check instructionAddress to find the code accessing this address.` : "No hits captured within timeout."
-			});
-		} catch (error) {
-			return toErrorResponse$2("memory_breakpoint_trace", error);
-		}
-	}
-	async handlePatchBytes(args) {
-		try {
-			const patch = await this.injector.patchBytes(args.pid, args.address, args.bytes);
-			return toTextResponse$2({
-				success: true,
-				...patch,
-				hint: `Patch applied. Use memory_patch_undo with patchId "${patch.id}" to restore.`
-			});
-		} catch (error) {
-			return toErrorResponse$2("memory_patch_bytes", error);
-		}
-	}
-	async handlePatchNop(args) {
-		try {
-			return toTextResponse$2({
-				success: true,
-				...await this.injector.nopBytes(args.pid, args.address, args.count),
-				hint: `${args.count} bytes NOP'd. Use memory_patch_undo to restore.`
-			});
-		} catch (error) {
-			return toErrorResponse$2("memory_patch_nop", error);
-		}
-	}
-	async handlePatchUndo(args) {
-		try {
-			return toTextResponse$2({
-				success: true,
-				restored: await this.injector.unpatch(args.patchId)
-			});
-		} catch (error) {
-			return toErrorResponse$2("memory_patch_undo", error);
-		}
-	}
-	async handleCodeCaves(args) {
-		try {
-			const caves = await this.injector.findCodeCaves(args.pid, args.minSize);
-			return toTextResponse$2({
-				success: true,
-				caves,
-				count: caves.length
-			});
-		} catch (error) {
-			return toErrorResponse$2("memory_code_caves", error);
-		}
-	}
-};
-//#endregion
-//#region src/server/domains/memory/handlers/readwrite.ts
-function toTextResponse$1(payload) {
-	return { content: [{
-		type: "text",
-		text: JSON.stringify(payload, null, 2)
-	}] };
-}
-function toErrorResponse$1(tool, error) {
-	return toTextResponse$1({
-		success: false,
-		tool,
-		error: error instanceof Error ? error.message : String(error)
-	});
-}
-var ReadWriteHandlers = class {
-	constructor(memCtrl) {
-		this.memCtrl = memCtrl;
-	}
-	async handleWriteValue(args) {
-		try {
-			return toTextResponse$1({
-				success: true,
-				...await this.memCtrl.writeValue(args.pid, args.address, args.value, args.valueType),
-				hint: "Use memory_write_undo to revert."
-			});
-		} catch (error) {
-			return toErrorResponse$1("memory_write_value", error);
-		}
-	}
-	async handleFreeze(args) {
-		try {
-			const entry = await this.memCtrl.freeze(args.pid, args.address, args.value, args.valueType, args.intervalMs);
-			return toTextResponse$1({
-				success: true,
-				...entry,
-				hint: `Frozen. Use memory_unfreeze with freezeId "${entry.id}" to stop.`
-			});
-		} catch (error) {
-			return toErrorResponse$1("memory_freeze", error);
-		}
-	}
-	async handleUnfreeze(args) {
-		try {
-			return toTextResponse$1({
-				success: true,
-				unfrozen: await this.memCtrl.unfreeze(args.freezeId)
-			});
-		} catch (error) {
-			return toErrorResponse$1("memory_unfreeze", error);
-		}
-	}
-	async handleDump(args) {
-		try {
-			return toTextResponse$1({
-				success: true,
-				dump: await this.memCtrl.dumpMemoryHex(args.pid, args.address, args.size ?? 256)
-			});
-		} catch (error) {
-			return toErrorResponse$1("memory_dump", error);
-		}
-	}
-	async handleWriteUndo(_args) {
-		try {
-			const entry = await this.memCtrl.undo();
-			return toTextResponse$1({
-				success: true,
-				undone: entry !== null,
-				entry
-			});
-		} catch (error) {
-			return toErrorResponse$1("memory_write_undo", error);
-		}
-	}
-	async handleWriteRedo(_args) {
-		try {
-			const entry = await this.memCtrl.redo();
-			return toTextResponse$1({
-				success: true,
-				redone: entry !== null,
-				entry
-			});
-		} catch (error) {
-			return toErrorResponse$1("memory_write_redo", error);
-		}
-	}
-};
-//#endregion
-//#region src/server/domains/memory/handlers/integrity.ts
-function toTextResponse(payload) {
-	return { content: [{
-		type: "text",
-		text: JSON.stringify(payload, null, 2)
-	}] };
-}
-function toErrorResponse(tool, error) {
-	return toTextResponse({
-		success: false,
-		tool,
-		error: error instanceof Error ? error.message : String(error)
-	});
-}
-var IntegrityHandlers = class {
-	constructor(speedhackEngine, heapAnalyzer, peAnalyzer, antiCheatDetector) {
-		this.speedhackEngine = speedhackEngine;
-		this.heapAnalyzer = heapAnalyzer;
-		this.peAnalyzer = peAnalyzer;
-		this.antiCheatDetector = antiCheatDetector;
-	}
-	async handleSpeedhackApply(args) {
-		try {
-			return toTextResponse({
-				...await this.speedhackEngine.apply(args.pid, args.speed),
-				success: true,
-				hint: `Speedhack active (${args.speed}x). Use memory_speedhack({ action: 'set' }) to adjust.`
-			});
-		} catch (error) {
-			return toErrorResponse("memory_speedhack", error);
-		}
-	}
-	async handleSpeedhackSet(args) {
-		try {
-			return toTextResponse({
-				success: true,
-				updated: await this.speedhackEngine.setSpeed(args.pid, args.speed),
-				newSpeed: args.speed
-			});
-		} catch (error) {
-			return toErrorResponse("memory_speedhack", error);
-		}
-	}
-	async handleHeapEnumerate(args) {
-		try {
-			const result = await this.heapAnalyzer.enumerateHeaps(args.pid);
-			return toTextResponse({
-				success: true,
-				...result,
-				hint: `Enumerated ${result.heaps.length} heaps. Use memory_heap_stats for statistics or memory_heap_anomalies to check for issues.`
-			});
-		} catch (error) {
-			return toErrorResponse("memory_heap_enumerate", error);
-		}
-	}
-	async handleHeapStats(args) {
-		try {
-			return toTextResponse({
-				success: true,
-				...await this.heapAnalyzer.getStats(args.pid)
-			});
-		} catch (error) {
-			return toErrorResponse("memory_heap_stats", error);
-		}
-	}
-	async handleHeapAnomalies(args) {
-		try {
-			const anomalies = await this.heapAnalyzer.detectAnomalies(args.pid);
-			return toTextResponse({
-				success: true,
-				anomalies,
-				count: anomalies.length,
-				hint: anomalies.length > 0 ? `Found ${anomalies.length} anomalies — inspect types for spray, UAF, or suspicious patterns.` : "No heap anomalies detected."
-			});
-		} catch (error) {
-			return toErrorResponse("memory_heap_anomalies", error);
-		}
-	}
-	async handlePEHeaders(args) {
-		try {
-			return toTextResponse({
-				success: true,
-				...await this.peAnalyzer.parseHeaders(args.pid, args.moduleBase)
-			});
-		} catch (error) {
-			return toErrorResponse("memory_pe_headers", error);
-		}
-	}
-	async handlePEImportsExports(args) {
-		try {
-			const table = args.table || "both";
-			const base = args.moduleBase;
-			const pid = args.pid;
-			const result = { success: true };
-			if (table === "imports" || table === "both") result.imports = await this.peAnalyzer.parseImports(pid, base);
-			if (table === "exports" || table === "both") result.exports = await this.peAnalyzer.parseExports(pid, base);
-			return toTextResponse(result);
-		} catch (error) {
-			return toErrorResponse("memory_pe_imports_exports", error);
-		}
-	}
-	async handleInlineHookDetect(args) {
-		try {
-			const hooks = await this.peAnalyzer.detectInlineHooks(args.pid, args.moduleName);
-			return toTextResponse({
-				success: true,
-				hooks,
-				count: hooks.length,
-				hint: hooks.length > 0 ? `Detected ${hooks.length} inline hooks — check hookType and jumpTarget for each.` : "No inline hooks detected — exports match disk bytes."
-			});
-		} catch (error) {
-			return toErrorResponse("memory_inline_hook_detect", error);
-		}
-	}
-	async handleAntiCheatDetect(args) {
-		try {
-			const detections = await this.antiCheatDetector.detect(args.pid);
-			return toTextResponse({
-				success: true,
-				detections,
-				count: detections.length,
-				hint: detections.length > 0 ? `Found ${detections.length} anti-debug mechanisms. Each includes a bypassSuggestion.` : "No anti-debug mechanisms detected in imports."
-			});
-		} catch (error) {
-			return toErrorResponse("memory_anticheat_detect", error);
-		}
-	}
-	async handleGuardPages(args) {
-		try {
-			const pages = await this.antiCheatDetector.findGuardPages(args.pid);
-			return toTextResponse({
-				success: true,
-				guardPages: pages,
-				count: pages.length,
-				hint: pages.length > 0 ? `Found ${pages.length} guard page regions — these may indicate anti-tampering.` : "No guard pages found."
-			});
-		} catch (error) {
-			return toErrorResponse("memory_guard_pages", error);
-		}
-	}
-	async handleIntegrityCheck(args) {
-		try {
-			const results = await this.antiCheatDetector.checkIntegrity(args.pid, args.moduleName);
-			const modified = results.filter((r) => r.isModified);
-			return toTextResponse({
-				success: true,
-				sections: results,
-				totalChecked: results.length,
-				modifiedCount: modified.length,
-				hint: modified.length > 0 ? `${modified.length} section(s) modified — code may have been patched or hooked.` : "All checked sections match disk — no runtime modifications detected."
-			});
-		} catch (error) {
-			return toErrorResponse("memory_integrity_check", error);
-		}
-	}
-};
-//#endregion
-//#region src/server/domains/memory/handlers.impl.ts
-var MemoryScanHandlers = class {
-	sessions;
-	scans;
-	ptrChains;
-	structures;
-	hooks;
-	readwrite;
-	integrity;
-	constructor(scanner, sessionManager, ptrEngine, structAnalyzer, bpEngine, injector, memCtrl, speedhackEngine, heapAnalyzer, peAnalyzer, antiCheatDetector, eventBus) {
-		this.sessions = new SessionHandlers(sessionManager);
-		this.scans = new ScanHandlers(scanner, eventBus);
-		this.ptrChains = new PointerChainHandlers(ptrEngine);
-		this.structures = new StructureHandlers(structAnalyzer);
-		this.hooks = new HookHandlers(bpEngine, injector);
-		this.readwrite = new ReadWriteHandlers(memCtrl);
-		this.integrity = new IntegrityHandlers(speedhackEngine, heapAnalyzer, peAnalyzer, antiCheatDetector);
-	}
-	handleScanSessionDispatch(args) {
-		switch (String(args["action"] ?? "")) {
-			case "delete": return this.sessions.handleScanDelete(args);
-			case "export": return this.sessions.handleScanExport(args);
-			default: return this.sessions.handleScanList(args);
-		}
-	}
-	handleScanList = (args) => this.sessions.handleScanList(args);
-	handleScanDelete = (args) => this.sessions.handleScanDelete(args);
-	handleScanExport = (args) => this.sessions.handleScanExport(args);
-	handleFirstScan = (args) => this.scans.handleFirstScan(args);
-	handleNextScan = (args) => this.scans.handleNextScan(args);
-	handleUnknownScan = (args) => this.scans.handleUnknownScan(args);
-	handlePointerScan = (args) => this.scans.handlePointerScan(args);
-	handleGroupScan = (args) => this.scans.handleGroupScan(args);
-	handlePointerChainDispatch(args) {
-		switch (String(args["action"] ?? "")) {
-			case "validate": return this.ptrChains.handlePointerChainValidate(args);
-			case "resolve": return this.ptrChains.handlePointerChainResolve(args);
-			case "export": return this.ptrChains.handlePointerChainExport(args);
-			default: return this.ptrChains.handlePointerChainScan(args);
-		}
-	}
-	handlePointerChainScan = (args) => this.ptrChains.handlePointerChainScan(args);
-	handlePointerChainValidate = (args) => this.ptrChains.handlePointerChainValidate(args);
-	handlePointerChainResolve = (args) => this.ptrChains.handlePointerChainResolve(args);
-	handlePointerChainExport = (args) => this.ptrChains.handlePointerChainExport(args);
-	handleStructureAnalyze = (args) => this.structures.handleStructureAnalyze(args);
-	handleVtableParse = (args) => this.structures.handleVtableParse(args);
-	handleStructureExportC = (args) => this.structures.handleStructureExportC(args);
-	handleStructureCompare = (args) => this.structures.handleStructureCompare(args);
-	handleBreakpointDispatch(args) {
-		switch (String(args["action"] ?? "")) {
-			case "remove": return this.hooks.handleBreakpointRemove(args);
-			case "list": return this.hooks.handleBreakpointList(args);
-			case "trace": return this.hooks.handleBreakpointTrace(args);
-			default: return this.hooks.handleBreakpointSet(args);
-		}
-	}
-	handleBreakpointSet = (args) => this.hooks.handleBreakpointSet(args);
-	handleBreakpointRemove = (args) => this.hooks.handleBreakpointRemove(args);
-	handleBreakpointList = (args) => this.hooks.handleBreakpointList(args);
-	handleBreakpointTrace = (args) => this.hooks.handleBreakpointTrace(args);
-	handlePatchBytes = (args) => this.hooks.handlePatchBytes(args);
-	handlePatchNop = (args) => this.hooks.handlePatchNop(args);
-	handlePatchUndo = (args) => this.hooks.handlePatchUndo(args);
-	handleCodeCaves = (args) => this.hooks.handleCodeCaves(args);
-	handleFreezeDispatch(args) {
-		if (String(args["action"] ?? "") === "unfreeze") return this.readwrite.handleUnfreeze(args);
-		return this.readwrite.handleFreeze(args);
-	}
-	handleWriteHistoryDispatch(args) {
-		if (String(args["action"] ?? "") === "redo") return this.readwrite.handleWriteRedo(args);
-		return this.readwrite.handleWriteUndo(args);
-	}
-	handleWriteValue = (args) => this.readwrite.handleWriteValue(args);
-	handleFreeze = (args) => this.readwrite.handleFreeze(args);
-	handleUnfreeze = (args) => this.readwrite.handleUnfreeze(args);
-	handleDump = (args) => this.readwrite.handleDump(args);
-	handleWriteUndo = (args) => this.readwrite.handleWriteUndo(args);
-	handleWriteRedo = (args) => this.readwrite.handleWriteRedo(args);
-	handleSpeedhackDispatch(args) {
-		if (String(args["action"] ?? "") === "set") return this.integrity.handleSpeedhackSet(args);
-		return this.integrity.handleSpeedhackApply(args);
-	}
-	handleSpeedhackApply = (args) => this.integrity.handleSpeedhackApply(args);
-	handleSpeedhackSet = (args) => this.integrity.handleSpeedhackSet(args);
-	handleHeapEnumerate = (args) => this.integrity.handleHeapEnumerate(args);
-	handleHeapStats = (args) => this.integrity.handleHeapStats(args);
-	handleHeapAnomalies = (args) => this.integrity.handleHeapAnomalies(args);
-	handlePEHeaders = (args) => this.integrity.handlePEHeaders(args);
-	handlePEImportsExports = (args) => this.integrity.handlePEImportsExports(args);
-	handleInlineHookDetect = (args) => this.integrity.handleInlineHookDetect(args);
-	handleAntiCheatDetect = (args) => this.integrity.handleAntiCheatDetect(args);
-	handleGuardPages = (args) => this.integrity.handleGuardPages(args);
-	handleIntegrityCheck = (args) => this.integrity.handleIntegrityCheck(args);
-};
-//#endregion
-export { MemoryScanHandlers };