@jshookmcp/jshook 0.2.9 → 0.3.0

package/dist/{process-QcbIy5Zq.mjs → process-BTbgcVc6.mjs}

@@ -1,9 +1,9 @@
 import { t as logger } from "./logger-Dh_xb7_2.mjs";
-import { V as ENABLE_INJECTION_TOOLS, wt as MEMORY_AUDIT_TRAIL_CAPACITY } from "./constants-B0OANIBL.mjs";
-import { i as MemoryManager, r as UnifiedProcessManager } from "./modules-C184v-S9.mjs";
-import { o as argStringArray, r as argNumber } from "./parse-args-BlRjqlkL.mjs";
-import { i as connectPlaywrightCdpFallback } from "./ScriptManager-aHHq0X7U.mjs";
-import "./definitions-B4rAvHNZ.mjs";
+import { H as ENABLE_INJECTION_TOOLS, Tt as MEMORY_AUDIT_TRAIL_CAPACITY } from "./constants-CDZLOoVv.mjs";
+import { i as MemoryManager, r as UnifiedProcessManager } from "./modules-tZozf0LQ.mjs";
+import { o as argStringArray, r as argNumber } from "./parse-args-B4cY5Vx5.mjs";
+import { i as connectPlaywrightCdpFallback } from "./ScriptManager-ZuWD-0Jg.mjs";
+import "./definitions-DJA27nsL.mjs";
 //#region src/modules/process/memory/AuditTrail.ts
 var MemoryAuditTrail = class {
 	buffer;
@@ -174,6 +174,15 @@ var ProcessManagementHandlers = class {
 	get platformValue() {
 		return this.platform;
 	}
+	exportMemoryAuditEntries() {
+		return JSON.parse(this.auditTrail.exportJson());
+	}
+	clearMemoryAuditEntries() {
+		this.auditTrail.clear();
+	}
+	getMemoryAuditCount() {
+		return this.auditTrail.size();
+	}
 	async handleProcessList(_args) {
 		try {
 			const processes = await this.processManager.findProcesses("");
@@ -444,11 +453,11 @@ var ProcessManagementHandlers = class {
 var MemoryOperationHandlers = class {
 	memoryManager;
 	platform;
-	processMgmt;
-	constructor(deps, processMgmt) {
+	host;
+	constructor(deps, host) {
 		this.memoryManager = deps.memoryManager;
 		this.platform = deps.platform;
-		this.processMgmt = processMgmt;
+		this.host = host;
 	}
 	async handleMemoryRead(args) {
 		const startedAt = Date.now();
@@ -457,68 +466,46 @@ var MemoryOperationHandlers = class {
 			const address = requireString(args.address, "address");
 			const size = requirePositiveNumber(args.size, "size");
 			const availability = await this.memoryManager.checkAvailability();
-			if (!availability.available) return await this.unavailableResponse("memory_read", pid, address, size, startedAt, availability.reason);
-			const result = await this.memoryManager.readMemory(pid, address, size);
-			const diagnostics = !result.success ? await this.processMgmt.safeBuildMemoryDiagnostics({
-				pid,
-				address,
-				size,
-				operation: "memory_read",
-				error: result.error
-			}) : void 0;
-			this.processMgmt.recordMemoryAudit({
+			if (!availability.available) return this.auditedUnavailableResponse({
 				operation: "memory_read",
 				pid,
 				address,
 				size,
-				result: result.success ? "success" : "failure",
-				error: result.error,
-				durationMs: Date.now() - startedAt
+				startedAt,
+				reason: availability.reason,
+				extra: {
+					requestedAddress: address,
+					requestedSize: size
+				}
 			});
-			const payload = {
-				success: result.success,
-				data: result.data,
-				error: result.error,
+			const result = await this.memoryManager.readMemory(pid, address, size);
+			return this.auditedResultResponse({
+				operation: "memory_read",
 				pid,
 				address,
 				size,
-				platform: this.platform
-			};
-			if (!result.success) payload.diagnostics = diagnostics;
-			return { content: [{
-				type: "text",
-				text: JSON.stringify(payload, null, 2)
-			}] };
+				startedAt,
+				result,
+				payload: {
+					success: result.success,
+					data: result.data,
+					error: result.error,
+					pid,
+					address,
+					size,
+					platform: this.platform
+				}
+			});
 		} catch (error) {
 			logger.error("Memory read failed:", error);
-			const errorMessage = error instanceof Error ? error.message : String(error);
-			const pid = getOptionalPid$1(args.pid);
-			const address = getOptionalString$1(args.address);
-			const size = getOptionalPositiveNumber(args.size);
-			const diagnostics = await this.processMgmt.safeBuildMemoryDiagnostics({
-				pid,
-				address,
-				size,
-				operation: "memory_read",
-				error: errorMessage
-			});
-			this.processMgmt.recordMemoryAudit({
+			return this.auditedExceptionResponse({
 				operation: "memory_read",
-				pid: pid ?? null,
-				address: address ?? null,
-				size: size ?? null,
-				result: "failure",
-				error: errorMessage,
-				durationMs: Date.now() - startedAt
+				pid: getOptionalPid$1(args.pid) ?? null,
+				address: getOptionalString$1(args.address) ?? null,
+				size: getOptionalPositiveNumber(args.size) ?? null,
+				startedAt,
+				error
 			});
-			return { content: [{
-				type: "text",
-				text: JSON.stringify({
-					success: false,
-					error: errorMessage,
-					diagnostics
-				}, null, 2)
-			}] };
 		}
 	}
 	async handleMemoryWrite(args) {
@@ -527,106 +514,53 @@ var MemoryOperationHandlers = class {
 			const pid = validatePid(args.pid);
 			const address = requireString(args.address, "address");
 			const data = requireString(args.data, "data");
-			const encoding = args.encoding || "hex";
+			const encoding = this.normalizeEncoding(args.encoding, "encoding") ?? "hex";
 			const size = getWriteSize(data, encoding);
 			const availability = await this.memoryManager.checkAvailability();
-			if (!availability.available) {
-				const errorMessage = availability.reason ?? "Memory operations not available";
-				const diagnostics = await this.processMgmt.safeBuildMemoryDiagnostics({
-					pid,
-					address,
-					size,
-					operation: "memory_write",
-					error: errorMessage
-				});
-				this.processMgmt.recordMemoryAudit({
-					operation: "memory_write",
-					pid,
-					address,
-					size,
-					result: "failure",
-					error: errorMessage,
-					durationMs: Date.now() - startedAt
-				});
-				return { content: [{
-					type: "text",
-					text: JSON.stringify({
-						success: false,
-						message: "Memory operations not available",
-						reason: availability.reason,
-						platform: this.platform,
-						requestedAddress: address,
-						dataLength: data !== void 0 && data !== null ? data.length : 0,
-						encoding,
-						pid,
-						diagnostics
-					}, null, 2)
-				}] };
-			}
-			const result = await this.memoryManager.writeMemory(pid, address, data, encoding);
-			const diagnostics = !result.success ? await this.processMgmt.safeBuildMemoryDiagnostics({
+			if (!availability.available) return this.auditedUnavailableResponse({
+				operation: "memory_write",
 				pid,
 				address,
 				size,
-				operation: "memory_write",
-				error: result.error
-			}) : void 0;
-			this.processMgmt.recordMemoryAudit({
+				startedAt,
+				reason: availability.reason,
+				extra: {
+					requestedAddress: address,
+					dataLength: data.length,
+					encoding
+				}
+			});
+			const result = await this.memoryManager.writeMemory(pid, address, data, encoding);
+			return this.auditedResultResponse({
 				operation: "memory_write",
 				pid,
 				address,
 				size,
-				result: result.success ? "success" : "failure",
-				error: result.error,
-				durationMs: Date.now() - startedAt
+				startedAt,
+				result,
+				payload: {
+					success: result.success,
+					bytesWritten: result.bytesWritten,
+					error: result.error,
+					pid,
+					address,
+					dataLength: data.length,
+					encoding,
+					platform: this.platform
+				}
 			});
-			const payload = {
-				success: result.success,
-				bytesWritten: result.bytesWritten,
-				error: result.error,
-				pid,
-				address,
-				dataLength: data.length,
-				encoding,
-				platform: this.platform
-			};
-			if (!result.success) payload.diagnostics = diagnostics;
-			return { content: [{
-				type: "text",
-				text: JSON.stringify(payload, null, 2)
-			}] };
 		} catch (error) {
 			logger.error("Memory write failed:", error);
-			const errorMessage = error instanceof Error ? error.message : String(error);
-			const pid = getOptionalPid$1(args.pid);
-			const address = getOptionalString$1(args.address);
 			const data = getOptionalString$1(args.data);
-			const encoding = args.encoding || "hex";
-			const size = data ? getWriteSize(data, encoding) : void 0;
-			const diagnostics = await this.processMgmt.safeBuildMemoryDiagnostics({
-				pid,
-				address,
-				size,
+			const encoding = this.normalizeEncoding(args.encoding, "encoding") ?? "hex";
+			return this.auditedExceptionResponse({
 				operation: "memory_write",
-				error: errorMessage
+				pid: getOptionalPid$1(args.pid) ?? null,
+				address: getOptionalString$1(args.address) ?? null,
+				size: data ? getWriteSize(data, encoding) : null,
+				startedAt,
+				error
 			});
-			this.processMgmt.recordMemoryAudit({
-				operation: "memory_write",
-				pid: pid ?? null,
-				address: address ?? null,
-				size: size ?? null,
-				result: "failure",
-				error: errorMessage,
-				durationMs: Date.now() - startedAt
-			});
-			return { content: [{
-				type: "text",
-				text: JSON.stringify({
-					success: false,
-					error: errorMessage,
-					diagnostics
-				}, null, 2)
-			}] };
 		}
 	}
 	async handleMemoryScan(args) {
@@ -637,118 +571,63 @@ var MemoryOperationHandlers = class {
 			const patternType = normalizePatternType(args.patternType);
 			const suspendTarget = args.suspendTarget === true;
 			const availability = await this.memoryManager.checkAvailability();
-			if (!availability.available) {
-				const errorMessage = availability.reason ?? "Memory operations not available";
-				const diagnostics = await this.processMgmt.safeBuildMemoryDiagnostics({
-					pid,
-					operation: "memory_scan",
-					error: errorMessage
-				});
-				this.processMgmt.recordMemoryAudit({
-					operation: "memory_scan",
-					pid,
-					address: null,
-					size: null,
-					result: "failure",
-					error: errorMessage,
-					durationMs: Date.now() - startedAt
-				});
-				return { content: [{
-					type: "text",
-					text: JSON.stringify({
-						success: false,
-						message: "Memory operations not available",
-						reason: availability.reason,
-						platform: this.platform,
-						requestedPattern: pattern,
-						patternType,
-						pid,
-						diagnostics
-					}, null, 2)
-				}] };
-			}
-			const result = await this.memoryManager.scanMemory(pid, pattern, patternType, suspendTarget);
-			const diagnostics = !result.success ? await this.processMgmt.safeBuildMemoryDiagnostics({
-				pid,
-				operation: "memory_scan",
-				error: result.error
-			}) : void 0;
-			this.processMgmt.recordMemoryAudit({
+			if (!availability.available) return this.auditedUnavailableResponse({
 				operation: "memory_scan",
 				pid,
 				address: null,
 				size: null,
-				result: result.success ? "success" : "failure",
-				error: result.error,
-				durationMs: Date.now() - startedAt
+				startedAt,
+				reason: availability.reason,
+				extra: {
+					requestedPattern: pattern,
+					patternType
+				}
 			});
-			const payload = {
-				success: result.success,
-				addresses: result.addresses,
-				error: result.error,
+			const result = await this.memoryManager.scanMemory(pid, pattern, patternType, suspendTarget);
+			return this.auditedResultResponse({
+				operation: "memory_scan",
 				pid,
-				pattern,
-				patternType,
-				platform: this.platform
-			};
-			if (!result.success) payload.diagnostics = diagnostics;
-			return { content: [{
-				type: "text",
-				text: JSON.stringify(payload, null, 2)
-			}] };
+				address: null,
+				size: null,
+				startedAt,
+				result,
+				payload: {
+					success: result.success,
+					addresses: result.addresses,
+					error: result.error,
+					pid,
+					pattern,
+					patternType,
+					platform: this.platform
+				}
+			});
 		} catch (error) {
 			logger.error("Memory scan failed:", error);
-			const errorMessage = error instanceof Error ? error.message : String(error);
-			const pid = getOptionalPid$1(args.pid);
-			const diagnostics = await this.processMgmt.safeBuildMemoryDiagnostics({
-				pid,
+			return this.auditedExceptionResponse({
 				operation: "memory_scan",
-				error: errorMessage
-			});
-			this.processMgmt.recordMemoryAudit({
-				operation: "memory_scan",
-				pid: pid ?? null,
+				pid: getOptionalPid$1(args.pid) ?? null,
 				address: null,
 				size: null,
-				result: "failure",
-				error: errorMessage,
-				durationMs: Date.now() - startedAt
+				startedAt,
+				error
 			});
-			return { content: [{
-				type: "text",
-				text: JSON.stringify({
-					success: false,
-					error: errorMessage,
-					diagnostics
-				}, null, 2)
-			}] };
 		}
 	}
 	async handleMemoryAuditExport(args) {
 		try {
-			const exportedJson = this.processMgmt["auditTrail"].exportJson();
-			const entries = JSON.parse(exportedJson);
+			const entries = this.host.exportMemoryAuditEntries();
 			const clear = args.clear === true;
-			const count = this.processMgmt["auditTrail"].size();
-			if (clear) this.processMgmt["auditTrail"].clear();
-			return { content: [{
-				type: "text",
-				text: JSON.stringify({
-					success: true,
-					count,
-					cleared: clear,
-					entries
-				}, null, 2)
-			}] };
+			const count = this.host.getMemoryAuditCount();
+			if (clear) this.host.clearMemoryAuditEntries();
+			return this.jsonResponse({
+				success: true,
+				count,
+				cleared: clear,
+				entries
+			});
 		} catch (error) {
 			logger.error("Memory audit export failed:", error);
-			return { content: [{
-				type: "text",
-				text: JSON.stringify({
-					success: false,
-					error: error instanceof Error ? error.message : String(error)
-				}, null, 2)
-			}] };
+			return this.errorResponse(error);
 		}
 	}
 	async handleMemoryCheckProtection(args) {
@@ -756,83 +635,38 @@ var MemoryOperationHandlers = class {
 			const pid = validatePid(args.pid);
 			const address = requireString(args.address, "address");
 			const result = await this.memoryManager.checkMemoryProtection(pid, address);
-			return { content: [{
-				type: "text",
-				text: JSON.stringify(result, null, 2)
-			}] };
+			return this.jsonResponse(result);
 		} catch (error) {
 			logger.error("Memory check protection failed:", error);
-			return { content: [{
-				type: "text",
-				text: JSON.stringify({
-					success: false,
-					error: error instanceof Error ? error.message : String(error)
-				}, null, 2)
-			}] };
+			return this.errorResponse(error);
 		}
 	}
 	async handleMemoryScanFiltered(args) {
 		try {
 			const pid = validatePid(args.pid);
 			const pattern = requireString(args.pattern, "pattern");
-			const addresses = args.addresses;
+			const addresses = this.requireStringArray(args.addresses, "addresses");
 			const patternType = normalizePatternType(args.patternType);
 			const availability = await this.memoryManager.checkAvailability();
-			if (!availability.available) return { content: [{
-				type: "text",
-				text: JSON.stringify({
-					success: false,
-					message: "Memory operations not available",
-					reason: availability.reason,
-					platform: this.platform,
-					pid
-				}, null, 2)
-			}] };
+			if (!availability.available) return this.unavailableResponse(pid, availability.reason);
 			const result = await this.memoryManager.scanMemoryFiltered(pid, pattern, addresses, patternType);
-			return { content: [{
-				type: "text",
-				text: JSON.stringify(result, null, 2)
-			}] };
+			return this.jsonResponse(result);
 		} catch (error) {
 			logger.error("Memory scan filtered failed:", error);
-			return { content: [{
-				type: "text",
-				text: JSON.stringify({
-					success: false,
-					error: error instanceof Error ? error.message : String(error)
-				}, null, 2)
-			}] };
+			return this.errorResponse(error);
 		}
 	}
 	async handleMemoryBatchWrite(args) {
 		try {
 			const pid = validatePid(args.pid);
-			const patches = args.patches;
+			const patches = this.requirePatches(args.patches);
 			const availability = await this.memoryManager.checkAvailability();
-			if (!availability.available) return { content: [{
-				type: "text",
-				text: JSON.stringify({
-					success: false,
-					message: "Memory operations not available",
-					reason: availability.reason,
-					platform: this.platform,
-					pid
-				}, null, 2)
-			}] };
+			if (!availability.available) return this.unavailableResponse(pid, availability.reason);
 			const result = await this.memoryManager.batchMemoryWrite(pid, patches);
-			return { content: [{
-				type: "text",
-				text: JSON.stringify(result, null, 2)
-			}] };
+			return this.jsonResponse(result);
 		} catch (error) {
 			logger.error("Memory batch write failed:", error);
-			return { content: [{
-				type: "text",
-				text: JSON.stringify({
-					success: false,
-					error: error instanceof Error ? error.message : String(error)
-				}, null, 2)
-			}] };
+			return this.errorResponse(error);
 		}
 	}
 	async handleMemoryDumpRegion(args) {
@@ -841,73 +675,144 @@ var MemoryOperationHandlers = class {
 			const address = requireString(args.address, "address");
 			const size = requirePositiveNumber(args.size, "size");
 			const outputPath = requireString(args.outputPath, "outputPath");
-			if (/^[/\\]/.test(outputPath) || /\.\./.test(outputPath) || /^[A-Za-z]:/.test(outputPath)) throw new Error("outputPath must be a relative path without parent directory traversal or drive letters");
+			this.ensureRelativeOutputPath(outputPath);
 			const result = await this.memoryManager.dumpMemoryRegion(pid, address, size, outputPath);
-			return { content: [{
-				type: "text",
-				text: JSON.stringify(result, null, 2)
-			}] };
+			return this.jsonResponse(result);
 		} catch (error) {
 			logger.error("Memory dump region failed:", error);
-			return { content: [{
-				type: "text",
-				text: JSON.stringify({
-					success: false,
-					error: error instanceof Error ? error.message : String(error)
-				}, null, 2)
-			}] };
+			return this.errorResponse(error);
 		}
 	}
 	async handleMemoryListRegions(args) {
 		try {
 			const pid = validatePid(args.pid);
 			const result = await this.memoryManager.enumerateRegions(pid);
-			return { content: [{
-				type: "text",
-				text: JSON.stringify(result, null, 2)
-			}] };
+			return this.jsonResponse(result);
 		} catch (error) {
 			logger.error("Memory list regions failed:", error);
-			return { content: [{
-				type: "text",
-				text: JSON.stringify({
-					success: false,
-					error: error instanceof Error ? error.message : String(error)
-				}, null, 2)
-			}] };
+			return this.errorResponse(error);
 		}
 	}
-	async unavailableResponse(operation, pid, address, size, startedAt, reason) {
-		const errorMessage = reason ?? "Memory operations not available";
-		const diagnostics = await this.processMgmt.safeBuildMemoryDiagnostics({
-			pid,
-			address,
-			size,
-			operation,
+	jsonResponse(payload) {
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(payload, null, 2)
+		}] };
+	}
+	errorResponse(error) {
+		return this.jsonResponse({
+			success: false,
+			error: this.errorMessage(error)
+		});
+	}
+	errorMessage(error) {
+		return error instanceof Error ? error.message : String(error);
+	}
+	async auditedUnavailableResponse(params) {
+		const errorMessage = params.reason ?? "Memory operations not available";
+		const diagnostics = await this.host.safeBuildMemoryDiagnostics({
+			pid: params.pid,
+			address: params.address ?? void 0,
+			size: params.size ?? void 0,
+			operation: params.operation,
 			error: errorMessage
 		});
-		this.processMgmt.recordMemoryAudit({
-			operation,
-			pid,
-			address,
-			size,
+		this.host.recordMemoryAudit({
+			operation: params.operation,
+			pid: params.pid,
+			address: params.address,
+			size: params.size,
 			result: "failure",
 			error: errorMessage,
-			durationMs: Date.now() - startedAt
+			durationMs: Date.now() - params.startedAt
 		});
-		return { content: [{
-			type: "text",
-			text: JSON.stringify({
-				success: false,
-				message: "Memory operations not available",
-				reason,
-				platform: this.platform,
-				requestedAddress: address,
-				requestedSize: size,
-				pid,
-				diagnostics
-			}, null, 2)
-		}] };
+		return this.jsonResponse({
+			success: false,
+			message: "Memory operations not available",
+			reason: params.reason,
+			platform: this.platform,
+			pid: params.pid,
+			...params.extra,
+			diagnostics
+		});
+	}
+	async auditedResultResponse(params) {
+		const diagnostics = !params.result.success ? await this.host.safeBuildMemoryDiagnostics({
+			pid: params.pid,
+			address: params.address ?? void 0,
+			size: params.size ?? void 0,
+			operation: params.operation,
+			error: params.result.error
+		}) : void 0;
+		this.host.recordMemoryAudit({
+			operation: params.operation,
+			pid: params.pid,
+			address: params.address,
+			size: params.size,
+			result: params.result.success ? "success" : "failure",
+			error: params.result.error,
+			durationMs: Date.now() - params.startedAt
+		});
+		if (!params.result.success) params.payload.diagnostics = diagnostics;
+		return this.jsonResponse(params.payload);
+	}
+	async auditedExceptionResponse(params) {
+		const errorMessage = this.errorMessage(params.error);
+		const diagnostics = await this.host.safeBuildMemoryDiagnostics({
+			pid: params.pid ?? void 0,
+			address: params.address ?? void 0,
+			size: params.size ?? void 0,
+			operation: params.operation,
+			error: errorMessage
+		});
+		this.host.recordMemoryAudit({
+			operation: params.operation,
+			pid: params.pid,
+			address: params.address,
+			size: params.size,
+			result: "failure",
+			error: errorMessage,
+			durationMs: Date.now() - params.startedAt
+		});
+		return this.jsonResponse({
+			success: false,
+			error: errorMessage,
+			diagnostics
+		});
+	}
+	unavailableResponse(pid, reason) {
+		return this.jsonResponse({
+			success: false,
+			message: "Memory operations not available",
+			reason,
+			platform: this.platform,
+			pid
+		});
+	}
+	requireStringArray(value, fieldName) {
+		if (!Array.isArray(value)) throw new Error(`${fieldName} must be an array of strings`);
+		return value.map((entry, index) => requireString(entry, `${fieldName}[${index}]`));
+	}
+	requirePatches(value) {
+		if (!Array.isArray(value)) throw new Error("patches must be an array");
+		return value.map((entry, index) => {
+			if (entry === null || typeof entry !== "object") throw new Error(`patches[${index}] must be an object`);
+			const patch = entry;
+			const encoding = this.normalizeEncoding(patch.encoding, `patches[${index}].encoding`);
+			return {
+				address: requireString(patch.address, `patches[${index}].address`),
+				data: requireString(patch.data, `patches[${index}].data`),
+				...encoding ? { encoding } : {}
+			};
+		});
+	}
+	normalizeEncoding(value, fieldName) {
+		if (value === void 0) return;
+		if (value === "hex" || value === "base64") return value;
+		throw new Error(`${fieldName} must be "hex" or "base64"`);
+	}
+	ensureRelativeOutputPath(outputPath) {
+		if (/^[/\\]/.test(outputPath) || /\.\./.test(outputPath) || /^[A-Za-z]:/.test(outputPath)) throw new Error("outputPath must be a relative path without parent directory traversal or drive letters");
 	}
 };
 //#endregion
@@ -1321,15 +1226,15 @@ function createDeps() {
 var ProcessHandlersBase = class {
 	processMgmt;
 	memoryOps;
-	_deps;
+	deps;
 	buildMemoryDiagnostics;
 	safeBuildMemoryDiagnostics;
 	recordMemoryAudit;
 	constructor() {
-		this._deps = createDeps();
-		logger.info(`ProcessToolHandlers initialized for platform: ${this._deps.platform}`);
-		this.processMgmt = new ProcessManagementHandlers(this._deps);
-		this.memoryOps = new MemoryOperationHandlers(this._deps, this.processMgmt);
+		this.deps = createDeps();
+		logger.info(`ProcessToolHandlers initialized for platform: ${this.deps.platform}`);
+		this.processMgmt = new ProcessManagementHandlers(this.deps);
+		this.memoryOps = new MemoryOperationHandlers(this.deps, this.processMgmt);
 		this.buildMemoryDiagnostics = this.processMgmt.buildMemoryDiagnostics.bind(this.processMgmt);
 		this.safeBuildMemoryDiagnostics = this.processMgmt.safeBuildMemoryDiagnostics.bind(this.processMgmt);
 		this.recordMemoryAudit = this.processMgmt.recordMemoryAudit.bind(this.processMgmt);
@@ -1379,7 +1284,7 @@ var ProcessToolHandlers = class extends ProcessHandlersBase {
 	injection;
 	constructor() {
 		super();
-		this.injection = new InjectionHandlers(this._deps, this.processMgmt);
+		this.injection = new InjectionHandlers(this.deps, this.processMgmt);
 	}
 	async handleInjectDll(args) {
 		return this.injection.handleInjectDll(args);