@jshookmcp/jshook 0.2.8 → 0.2.9

package/dist/handlers.impl-DS0d9fUw.mjs

@@ -0,0 +1,761 @@
+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 };