@jshookmcp/jshook 0.2.8 → 0.2.9

package/dist/{DarwinAPI-B8hg_yhz.mjs → DarwinAPI-BNPxu0RH.mjs}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./chunk-CjcI7cDX.mjs";
-import { t as logger } from "./logger-BmWzC2lM.mjs";
+import { t as logger } from "./logger-Dh_xb7_2.mjs";
 import koffi from "koffi";
 //#region src/native/platform/darwin/DarwinAPI.ts
 /**

package/dist/DetailedDataManager-BQQcxh64.mjs

@@ -0,0 +1,217 @@
+import { t as logger } from "./logger-Dh_xb7_2.mjs";
+import { I as DETAILED_DATA_DEFAULT_TTL_MS, L as DETAILED_DATA_MAX_TTL_MS, R as DETAILED_DATA_SMART_THRESHOLD_BYTES } from "./constants-B0OANIBL.mjs";
+//#region src/utils/DetailedDataManager.ts
+var DetailedDataManager = class DetailedDataManager {
+	static instance;
+	cache = /* @__PURE__ */ new Map();
+	cleanupInterval = null;
+	DEFAULT_TTL = DETAILED_DATA_DEFAULT_TTL_MS;
+	MAX_TTL = DETAILED_DATA_MAX_TTL_MS;
+	MAX_CACHE_SIZE = 100;
+	AUTO_EXTEND_ON_ACCESS = true;
+	EXTEND_DURATION = 900 * 1e3;
+	/** Memo cache to avoid re-serializing the same object within a single call chain */
+	serializationMemo = /* @__PURE__ */ new WeakMap();
+	constructor() {
+		this.cleanupInterval = setInterval(() => this.cleanup(), 300 * 1e3);
+		if (typeof this.cleanupInterval === "object" && "unref" in this.cleanupInterval) this.cleanupInterval.unref();
+	}
+	/** @deprecated Use constructor injection. Kept for backward compatibility. */
+	static getInstance() {
+		if (!this.instance) this.instance = new DetailedDataManager();
+		return this.instance;
+	}
+	shutdown() {
+		if (this.cleanupInterval) {
+			clearInterval(this.cleanupInterval);
+			this.cleanupInterval = null;
+		}
+		this.cache.clear();
+		DetailedDataManager.instance = void 0;
+		logger.info("DetailedDataManager shut down");
+	}
+	/**
+	* Serialize data with memoization to avoid redundant JSON.stringify calls.
+	* Objects are cached in a WeakMap so the memo is automatically GC'd.
+	*/
+	serializeWithMemo(data) {
+		if (data !== null && typeof data === "object") {
+			const cached = this.serializationMemo.get(data);
+			if (cached) return cached;
+		}
+		const json = JSON.stringify(data);
+		const result = {
+			json,
+			size: json.length
+		};
+		if (data !== null && typeof data === "object") this.serializationMemo.set(data, result);
+		return result;
+	}
+	isRecord(value) {
+		return value !== null && typeof value === "object";
+	}
+	readPathSegment(value, key) {
+		return Object(value)[key];
+	}
+	smartHandle(data, threshold = DETAILED_DATA_SMART_THRESHOLD_BYTES) {
+		if (data === null || data === void 0) return data;
+		if (typeof data !== "object" && typeof data !== "string") return data;
+		if (typeof data === "string") {
+			if (data.length <= threshold) return data;
+		}
+		const { json: jsonStr, size } = this.serializeWithMemo(data);
+		if (size <= threshold) return data;
+		logger.info(`Data too large (${(size / 1024).toFixed(1)}KB), returning summary with detailId`);
+		return this.createDetailedResponseWithSize(data, jsonStr, size);
+	}
+	createDetailedResponseWithSize(data, jsonStr, size) {
+		const detailId = this.storeWithSize(data, size);
+		return {
+			summary: this.generateSummaryFromJson(data, jsonStr, size),
+			detailId,
+			hint: `Data too large. Use get_detailed_data("${detailId}") to retrieve full data, or get_detailed_data("${detailId}", path="key.subkey") for specific part.`,
+			expiresAt: Date.now() + this.DEFAULT_TTL
+		};
+	}
+	store(data, customTTL) {
+		const { size } = this.serializeWithMemo(data);
+		return this.storeWithSize(data, size, customTTL);
+	}
+	storeWithSize(data, size, customTTL) {
+		if (this.cache.size >= this.MAX_CACHE_SIZE) this.evictLRU();
+		const detailId = `detail_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+		const now = Date.now();
+		const ttl = customTTL || this.DEFAULT_TTL;
+		const entry = {
+			data,
+			expiresAt: now + ttl,
+			createdAt: now,
+			lastAccessedAt: now,
+			accessCount: 0,
+			size
+		};
+		this.cache.set(detailId, entry);
+		logger.debug(`Stored detailed data: ${detailId}, size: ${(size / 1024).toFixed(1)}KB, expires in ${ttl / 1e3}s`);
+		return detailId;
+	}
+	retrieve(detailId, path) {
+		const cached = this.cache.get(detailId);
+		if (!cached) throw new Error(`DetailId not found or expired: ${detailId}`);
+		const now = Date.now();
+		if (now > cached.expiresAt) {
+			this.cache.delete(detailId);
+			throw new Error(`DetailId expired: ${detailId}`);
+		}
+		cached.lastAccessedAt = now;
+		cached.accessCount++;
+		if (this.AUTO_EXTEND_ON_ACCESS) {
+			if (cached.expiresAt - now < 300 * 1e3) {
+				cached.expiresAt = Math.min(now + this.EXTEND_DURATION, now + this.MAX_TTL);
+				logger.debug(`Auto-extended detailId ${detailId}, new expiry: ${new Date(cached.expiresAt).toISOString()}`);
+			}
+		}
+		if (path) return this.getByPath(cached.data, path);
+		return cached.data;
+	}
+	getByPath(obj, path) {
+		const keys = path.split(".");
+		let current = obj;
+		for (const key of keys) {
+			if (current === null || current === void 0) throw new Error(`Path not found: ${path} (stopped at ${key})`);
+			current = this.readPathSegment(current, key);
+		}
+		return current;
+	}
+	generateSummaryFromJson(data, jsonStr, size) {
+		const summary = {
+			type: Array.isArray(data) ? "array" : typeof data,
+			size,
+			sizeKB: (size / 1024).toFixed(1) + "KB",
+			preview: jsonStr.substring(0, 200) + (size > 200 ? "..." : "")
+		};
+		if (this.isRecord(data)) {
+			const keys = Object.keys(data);
+			summary.structure = { keys: keys.slice(0, 50) };
+			if (!Array.isArray(data)) {
+				const methods = keys.filter((k) => typeof data[k] === "function");
+				const properties = keys.filter((k) => typeof data[k] !== "function");
+				summary.structure.methods = methods.slice(0, 30);
+				summary.structure.properties = properties.slice(0, 50);
+			} else summary.structure.length = data.length;
+		}
+		return summary;
+	}
+	cleanup() {
+		const now = Date.now();
+		let cleaned = 0;
+		for (const [id, cached] of this.cache.entries()) if (now > cached.expiresAt) {
+			this.cache.delete(id);
+			cleaned++;
+		}
+		if (cleaned > 0) logger.debug(`Cleaned ${cleaned} expired detailed data entries`);
+	}
+	evictLRU() {
+		if (this.cache.size === 0) return;
+		let oldestId = null;
+		let oldestAccessTime = Infinity;
+		for (const [id, entry] of this.cache.entries()) if (entry.lastAccessedAt < oldestAccessTime) {
+			oldestAccessTime = entry.lastAccessedAt;
+			oldestId = id;
+		}
+		if (oldestId) {
+			const entry = this.cache.get(oldestId);
+			this.cache.delete(oldestId);
+			logger.info(`Evicted LRU entry: ${oldestId}, last accessed: ${new Date(entry.lastAccessedAt).toISOString()}, access count: ${entry.accessCount}`);
+		}
+	}
+	extend(detailId, additionalTime) {
+		const cached = this.cache.get(detailId);
+		if (!cached) throw new Error(`DetailId not found: ${detailId}`);
+		const now = Date.now();
+		if (now > cached.expiresAt) throw new Error(`DetailId already expired: ${detailId}`);
+		const extendBy = additionalTime || this.EXTEND_DURATION;
+		const newExpiresAt = Math.min(cached.expiresAt + extendBy, now + this.MAX_TTL);
+		cached.expiresAt = newExpiresAt;
+		logger.info(`Extended detailId ${detailId} by ${extendBy / 1e3}s, new expiry: ${new Date(newExpiresAt).toISOString()}`);
+	}
+	getStats() {
+		let totalSize = 0;
+		let totalAccessCount = 0;
+		const entries = Array.from(this.cache.values());
+		for (const entry of entries) {
+			totalSize += entry.size;
+			totalAccessCount += entry.accessCount;
+		}
+		return {
+			cacheSize: this.cache.size,
+			maxCacheSize: this.MAX_CACHE_SIZE,
+			defaultTTLSeconds: this.DEFAULT_TTL / 1e3,
+			maxTTLSeconds: this.MAX_TTL / 1e3,
+			totalSizeKB: (totalSize / 1024).toFixed(1),
+			avgAccessCount: entries.length > 0 ? (totalAccessCount / entries.length).toFixed(1) : "0",
+			autoExtendEnabled: this.AUTO_EXTEND_ON_ACCESS,
+			extendDurationSeconds: this.EXTEND_DURATION / 1e3
+		};
+	}
+	getDetailedStats() {
+		const now = Date.now();
+		const entries = Array.from(this.cache.entries()).map(([id, entry]) => ({
+			detailId: id,
+			sizeKB: (entry.size / 1024).toFixed(1),
+			createdAt: new Date(entry.createdAt).toISOString(),
+			lastAccessedAt: new Date(entry.lastAccessedAt).toISOString(),
+			expiresAt: new Date(entry.expiresAt).toISOString(),
+			remainingSeconds: Math.max(0, Math.floor((entry.expiresAt - now) / 1e3)),
+			accessCount: entry.accessCount,
+			isExpired: now > entry.expiresAt
+		}));
+		entries.sort((a, b) => new Date(b.lastAccessedAt).getTime() - new Date(a.lastAccessedAt).getTime());
+		return entries;
+	}
+	clear() {
+		this.cache.clear();
+		logger.info("Cleared all detailed data cache");
+	}
+};
+//#endregion
+export { DetailedDataManager as t };

package/dist/EventBus-DgPmwpeu.mjs

@@ -0,0 +1,141 @@
+//#region src/server/EventBus.ts
+var EventBus = class {
+	listeners = /* @__PURE__ */ new Map();
+	wildcardListeners = [];
+	/**
+	* Subscribe to a specific event.
+	* Returns an unsubscribe function.
+	*/
+	on(event, handler) {
+		const subs = this.listeners.get(event) ?? [];
+		const subscription = {
+			handler,
+			once: false
+		};
+		subs.push(subscription);
+		this.listeners.set(event, subs);
+		return () => {
+			const list = this.listeners.get(event);
+			if (list) {
+				const idx = list.indexOf(subscription);
+				if (idx >= 0) list.splice(idx, 1);
+			}
+		};
+	}
+	/**
+	* Subscribe to a specific event, auto-unsubscribing after the first fire.
+	*/
+	once(event, handler) {
+		const subs = this.listeners.get(event) ?? [];
+		const subscription = {
+			handler,
+			once: true
+		};
+		subs.push(subscription);
+		this.listeners.set(event, subs);
+		return () => {
+			const list = this.listeners.get(event);
+			if (list) {
+				const idx = list.indexOf(subscription);
+				if (idx >= 0) list.splice(idx, 1);
+			}
+		};
+	}
+	/**
+	* Subscribe to all events (wildcard listener).
+	*/
+	onAny(handler) {
+		const subscription = {
+			handler,
+			once: false
+		};
+		this.wildcardListeners.push(subscription);
+		return () => {
+			const idx = this.wildcardListeners.indexOf(subscription);
+			if (idx >= 0) this.wildcardListeners.splice(idx, 1);
+		};
+	}
+	/**
+	* Emit an event to all registered listeners.
+	*
+	* Named listeners run sequentially (preserving ordering semantics).
+	* Wildcard listeners run in parallel via Promise.allSettled since they
+	* are observability/telemetry side-effects whose ordering does not matter.
+	* Errors in one listener never prevent others from running.
+	*/
+	async emit(event, payload) {
+		const subs = this.listeners.get(event);
+		if (subs) {
+			const toRemove = [];
+			for (let i = 0; i < subs.length; i++) {
+				const sub = subs[i];
+				if (!sub) continue;
+				try {
+					await sub.handler(payload);
+				} catch {}
+				if (sub.once) toRemove.push(i);
+			}
+			for (let i = toRemove.length - 1; i >= 0; i--) subs.splice(toRemove[i], 1);
+		}
+		if (this.wildcardListeners.length > 0) {
+			const wildPayload = {
+				event,
+				payload
+			};
+			const promises = this.wildcardListeners.map((sub) => {
+				try {
+					return Promise.resolve(sub.handler(wildPayload));
+				} catch {
+					return Promise.resolve();
+				}
+			});
+			await Promise.allSettled(promises);
+		}
+	}
+	/**
+	* Remove all listeners for a specific event, or all listeners if no event specified.
+	*/
+	removeAllListeners(event) {
+		if (event) this.listeners.delete(event);
+		else {
+			this.listeners.clear();
+			this.wildcardListeners.length = 0;
+		}
+	}
+	/**
+	* Get the number of listeners for a specific event.
+	*/
+	listenerCount(event) {
+		return this.listeners.get(event)?.length ?? 0;
+	}
+};
+/**
+* Singleton-style factory for the server event bus.
+* Call `createServerEventBus()` once during server init.
+*/
+function createServerEventBus() {
+	return new EventBus();
+}
+/**
+* Creates a debounced progress emitter for tool handlers.
+* @param eventBus The server event bus
+* @param progressToken The progress token from args._meta.progressToken
+* @param debounceMs Minimum time between emissions (defaults to 500ms)
+*/
+function createProgressDebouncer(eventBus, progressToken, debounceMs = 500) {
+	let lastEmit = 0;
+	return (progress, total) => {
+		const now = Date.now();
+		if (now - lastEmit >= debounceMs || progress === total) {
+			lastEmit = now;
+			eventBus.emit("tool:progress", {
+				progressToken,
+				progress,
+				total,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			});
+		}
+	};
+}
+//#endregion
+export { createServerEventBus as n, createProgressDebouncer as t };

package/dist/EvidenceGraphBridge-SFesNera.mjs

@@ -0,0 +1,153 @@
+//#region src/server/instrumentation/EvidenceGraphBridge.ts
+var EvidenceGraphBridge = class {
+	/** Maps operationId → primary evidence node ID for edge linking. */
+	operationNodeMap = /* @__PURE__ */ new Map();
+	/** Maps operationId → request node ID for manual linking / replay chaining. */
+	requestNodeMap = /* @__PURE__ */ new Map();
+	constructor(graph) {
+		this.graph = graph;
+	}
+	getString(value) {
+		return typeof value === "string" && value.length > 0 ? value : void 0;
+	}
+	getInitiatorLabel(config) {
+		const directInitiator = this.getString(config.initiator);
+		if (directInitiator) return directInitiator;
+		const directStack = this.getString(config.initiatorStack);
+		if (directStack) return directStack;
+		const initiator = config.initiator;
+		if (initiator && typeof initiator === "object") {
+			const record = initiator;
+			return this.getString(record.stack) ?? this.getString(record.url) ?? this.getString(record.type) ?? this.getString(record.name);
+		}
+	}
+	/** Manually link a request node to an initiator-stack node. */
+	linkRequestToInitiator(requestNodeId, initiatorStackNodeId) {
+		this.graph.addEdge(requestNodeId, initiatorStackNodeId, "initiates");
+	}
+	/**
+	* Called when a new operation is registered.
+	* Creates evidence node(s) based on operation type.
+	* Returns the primary evidence node ID (or null if no mapping).
+	*/
+	onOperation(op) {
+		let primaryNodeId = null;
+		switch (op.type) {
+			case "runtime-hook": {
+				const funcNode = this.graph.addNode("function", op.target, {
+					functionName: op.target,
+					sessionId: op.sessionId,
+					operationId: op.id
+				});
+				const scriptId = this.getString(op.config.scriptId);
+				if (scriptId) {
+					const scriptNode = this.graph.addNode("script", `script:${scriptId}`, {
+						scriptId,
+						sessionId: op.sessionId,
+						operationId: op.id
+					});
+					this.graph.addEdge(scriptNode.id, funcNode.id, "contains");
+				}
+				const hookNode = this.graph.addNode("breakpoint-hook", `hook:${op.target}`, {
+					hookType: "runtime-hook",
+					sessionId: op.sessionId,
+					operationId: op.id,
+					config: op.config
+				});
+				this.graph.addEdge(funcNode.id, hookNode.id, "triggers");
+				primaryNodeId = hookNode.id;
+				break;
+			}
+			case "network-intercept": {
+				const reqNode = this.graph.addNode("request", op.target, {
+					url: op.target,
+					sessionId: op.sessionId,
+					operationId: op.id,
+					config: op.config
+				});
+				this.requestNodeMap.set(op.id, reqNode.id);
+				const initiatorLabel = this.getInitiatorLabel(op.config);
+				let initiatorNodeId = null;
+				if (initiatorLabel) {
+					const initiatorNode = this.graph.addNode("initiator-stack", initiatorLabel, {
+						sessionId: op.sessionId,
+						operationId: op.id,
+						initiator: op.config.initiator,
+						initiatorStack: op.config.initiatorStack
+					});
+					this.linkRequestToInitiator(reqNode.id, initiatorNode.id);
+					initiatorNodeId = initiatorNode.id;
+				}
+				const initiatorScriptId = this.getString(op.config.initiatorScriptId);
+				if (initiatorNodeId && initiatorScriptId) {
+					const scriptNode = this.graph.addNode("script", `script:${initiatorScriptId}`, {
+						scriptId: initiatorScriptId,
+						sessionId: op.sessionId,
+						operationId: op.id
+					});
+					this.graph.addEdge(initiatorNodeId, scriptNode.id, "loads");
+				}
+				primaryNodeId = reqNode.id;
+				break;
+			}
+			case "function-trace": {
+				const funcNode = this.graph.addNode("function", op.target, {
+					functionName: op.target,
+					sessionId: op.sessionId,
+					operationId: op.id,
+					traceMode: true
+				});
+				const scriptId = this.getString(op.config.scriptId);
+				if (scriptId) {
+					const scriptNode = this.graph.addNode("script", `script:${scriptId}`, {
+						scriptId,
+						sessionId: op.sessionId,
+						operationId: op.id
+					});
+					this.graph.addEdge(scriptNode.id, funcNode.id, "contains");
+				}
+				primaryNodeId = funcNode.id;
+				break;
+			}
+			case "before-load-inject":
+				primaryNodeId = this.graph.addNode("script", op.target, {
+					injectionPoint: "before-load",
+					sessionId: op.sessionId,
+					operationId: op.id
+				}).id;
+				break;
+		}
+		if (primaryNodeId) this.operationNodeMap.set(op.id, primaryNodeId);
+		return primaryNodeId;
+	}
+	/**
+	* Called when an artifact is captured.
+	* Creates a captured-data node and links it to the operation's evidence node.
+	* If the artifact represents a live replay, also creates a replay-artifact node.
+	*/
+	onArtifact(artifact) {
+		const operationNodeId = this.operationNodeMap.get(artifact.operationId);
+		const dataNode = this.graph.addNode("captured-data", `data:${artifact.operationId}`, {
+			sessionId: artifact.sessionId,
+			operationId: artifact.operationId,
+			artifactType: artifact.type,
+			...artifact.data
+		});
+		if (operationNodeId) this.graph.addEdge(operationNodeId, dataNode.id, "captures");
+		if (artifact.data.replayMode === "live") {
+			const replayNode = this.graph.addNode("replay-artifact", `replay:${artifact.operationId}`, {
+				sessionId: artifact.sessionId,
+				operationId: artifact.operationId,
+				artifactType: artifact.type,
+				replayMode: artifact.data.replayMode,
+				requestId: artifact.data.requestId,
+				url: artifact.data.url,
+				method: artifact.data.method,
+				statusCode: artifact.data.statusCode
+			});
+			this.graph.addEdge(dataNode.id, replayNode.id, "replays");
+		}
+	}
+};
+//#endregion
+export { EvidenceGraphBridge };

package/dist/{ExtensionManager-D5-bO9D8.mjs → ExtensionManager-CWYgw0YW.mjs}

@@ -1,10 +1,12 @@
-import { t as logger } from "./logger-BmWzC2lM.mjs";
-import { f as INSTALLED_EXTENSION_METADATA_FILENAME, t as allTools } from "./ToolCatalog-Bq4V2sbJ.mjs";
-import { readFile } from "node:fs/promises";
-import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
+import { t as __exportAll } from "./chunk-CjcI7cDX.mjs";
+import { t as logger } from "./logger-Dh_xb7_2.mjs";
+import { t as allTools } from "./ToolCatalog-C0JGZoOm.mjs";
+import { t as INSTALLED_EXTENSION_METADATA_FILENAME } from "./types-Bx92KJfT.mjs";
 import { createHash } from "node:crypto";
 import { existsSync, readFileSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { readFile } from "node:fs/promises";
 import { glob } from "tinyglobby";
 //#region src/server/extensions/ExtensionManager.roots.ts
 /**
@@ -344,6 +346,11 @@ function buildListResult(ctx, pluginRoots, workflowRoots) {
 }
 //#endregion
 //#region src/server/extensions/ExtensionManager.ts
+var ExtensionManager_exports = /* @__PURE__ */ __exportAll({
+	ensureWorkflowsLoaded: () => ensureWorkflowsLoaded,
+	listExtensions: () => listExtensions,
+	reloadExtensions: () => reloadExtensions
+});
 function listExtensions(ctx) {
 	return buildListResult(ctx, resolveRoots(parseRoots(process.env.MCP_PLUGIN_ROOTS, DEFAULT_PLUGIN_ROOTS)), resolveRoots(parseRoots(process.env.MCP_WORKFLOW_ROOTS, DEFAULT_WORKFLOW_ROOTS)));
 }
@@ -704,4 +711,4 @@ async function reloadExtensionsInner(ctx) {
 	};
 }
 //#endregion
-export { listExtensions as n, reloadExtensions as r, ensureWorkflowsLoaded as t };
+export { reloadExtensions as i, ensureWorkflowsLoaded as n, listExtensions as r, ExtensionManager_exports as t };

package/dist/{FingerprintManager-BVxFJL2-.mjs → FingerprintManager-gzWtkKuf.mjs}

@@ -1,5 +1,5 @@
 import { n as __require } from "./chunk-CjcI7cDX.mjs";
-import { t as logger } from "./logger-BmWzC2lM.mjs";
+import { t as logger } from "./logger-Dh_xb7_2.mjs";
 //#region src/modules/stealth/FingerprintManager.ts
 var FingerprintManager = class FingerprintManager {
 	static instance = null;

package/dist/{HardwareBreakpoint-DK1yjWkV.mjs → HardwareBreakpoint-B9gZCdFP.mjs}

@@ -1,6 +1,6 @@
-import { _ as BREAKPOINT_TRACE_MAX_HITS, g as BREAKPOINT_HIT_TIMEOUT_MS } from "./constants-CCvsN80K.mjs";
-import { t as CloseHandle } from "./Win32API-Bc0QnQsN.mjs";
-import { _ as openThreadForDebug, a as DebugActiveProcessStop, c as EnumerateProcessThreads, d as ResumeThread, f as SetThreadContext, g as encodeDR7, h as WaitForDebugEvent, i as DebugActiveProcess, n as ContinueDebugEvent, o as DebugSetProcessKillOnExit, p as SuspendThread, r as DBG, s as EXCEPTION_CODE, t as CONTEXT_FLAGS, u as GetThreadContext, v as parseContext, y as writeContext } from "./Win32Debug-DUHt9XUn.mjs";
+import { _ as BREAKPOINT_TRACE_MAX_HITS, g as BREAKPOINT_HIT_TIMEOUT_MS } from "./constants-B0OANIBL.mjs";
+import { t as CloseHandle } from "./Win32API-CePkipZY.mjs";
+import { _ as openThreadForDebug, a as DebugActiveProcessStop, c as EnumerateProcessThreads, d as ResumeThread, f as SetThreadContext, g as encodeDR7, h as WaitForDebugEvent, i as DebugActiveProcess, n as ContinueDebugEvent, o as DebugSetProcessKillOnExit, p as SuspendThread, r as DBG, s as EXCEPTION_CODE, t as CONTEXT_FLAGS, u as GetThreadContext, v as parseContext, y as writeContext } from "./Win32Debug-BvKs-gxc.mjs";
 import { randomUUID } from "node:crypto";
 //#region src/native/HardwareBreakpoint.ts
 /**

package/dist/{HeapAnalyzer-CEbo10xU.mjs → HeapAnalyzer-BLDH0dCv.mjs}

@@ -1,7 +1,7 @@
-import { t as logger } from "./logger-BmWzC2lM.mjs";
-import { at as HEAP_SUSPICIOUS_BLOCK_SIZE, it as HEAP_SPRAY_THRESHOLD, nt as HEAP_ENUMERATE_MAX_BLOCKS, rt as HEAP_SPRAY_SIZE_TOLERANCE } from "./constants-CCvsN80K.mjs";
-import { b as openProcessForMemory, d as ReadProcessMemory, t as CloseHandle } from "./Win32API-Bc0QnQsN.mjs";
-import { m as TH32CS } from "./Win32Debug-DUHt9XUn.mjs";
+import { t as logger } from "./logger-Dh_xb7_2.mjs";
+import { at as HEAP_ENUMERATE_MAX_BLOCKS, ct as HEAP_SUSPICIOUS_BLOCK_SIZE, ot as HEAP_SPRAY_SIZE_TOLERANCE, st as HEAP_SPRAY_THRESHOLD } from "./constants-B0OANIBL.mjs";
+import { b as openProcessForMemory, d as ReadProcessMemory, t as CloseHandle } from "./Win32API-CePkipZY.mjs";
+import { m as TH32CS } from "./Win32Debug-BvKs-gxc.mjs";
 import koffi from "koffi";
 //#region src/native/HeapAnalyzer.types.ts
 /** Heap block flags */