@satelliteoflove/godot-mcp 3.5.0 → 3.6.1

package/addon/command_router.gd

@@ -21,6 +21,7 @@ func setup(plugin: EditorPlugin) -> void:
 	_register_handler(MCPScene3DCommands.new(), plugin)
 	_register_handler(MCPInputCommands.new(), plugin)
 	_register_handler(MCPProfilerCommands.new(), plugin)
+	_register_handler(MCPRuntimeStateCommands.new(), plugin)
 
 
 func _register_handler(handler: MCPBaseCommand, plugin: EditorPlugin) -> void:

package/addon/commands/runtime_state_commands.gd

@@ -0,0 +1,82 @@
+@tool
+extends MCPBaseCommand
+class_name MCPRuntimeStateCommands
+
+const GENERIC_TIMEOUT := 5.0
+var _last_error: Dictionary = {}
+
+
+func get_commands() -> Dictionary:
+	return {
+		"get_runtime_state": get_runtime_state,
+		"watch_start": watch_start,
+		"watch_collect": watch_collect,
+		"watch_stop": watch_stop,
+	}
+
+
+func get_runtime_state(params: Dictionary) -> Dictionary:
+	var result = await _send_and_wait("get_runtime_state", [params])
+	if result == null:
+		return _last_error
+	if result is Dictionary:
+		return _success(result)
+	return _success({"data": result})
+
+
+func watch_start(params: Dictionary) -> Dictionary:
+	var specs: Array = params.get("specs", [])
+	var hz: int = params.get("hz", 20)
+	var duration_ms: int = params.get("duration_ms", 1000)
+	var result = await _send_and_wait("watch_start", [specs, hz, duration_ms])
+	if result == null:
+		return _last_error
+	if result is Dictionary:
+		return _success(result)
+	return _success({"started": true})
+
+
+func watch_collect(_params: Dictionary) -> Dictionary:
+	var result = await _send_and_wait("watch_collect", [])
+	if result == null:
+		return _last_error
+	if result is Dictionary:
+		return _success(result)
+	return _success({"data": result})
+
+
+func watch_stop(_params: Dictionary) -> Dictionary:
+	var result = await _send_and_wait("watch_stop", [])
+	if result == null:
+		return _last_error
+	if result is Dictionary:
+		return _success(result)
+	return _success({"stopped": true})
+
+
+func _send_and_wait(msg_type: String, args: Array = []):
+	if not EditorInterface.is_playing_scene():
+		_last_error = _error("NOT_RUNNING", "No game is currently running")
+		return null
+
+	var debugger_plugin = _plugin.get_debugger_plugin() if _plugin else null
+	if debugger_plugin == null or not debugger_plugin.has_active_session():
+		_last_error = _error("NO_SESSION", "No active debug session")
+		return null
+
+	var sent: bool = debugger_plugin.send_game_message(msg_type, args)
+	if not sent:
+		_last_error = _error("SEND_FAILED", "Failed to send message to game")
+		return null
+
+	var start_time := Time.get_ticks_msec()
+	while not debugger_plugin.has_response(msg_type):
+		await Engine.get_main_loop().process_frame
+		if (Time.get_ticks_msec() - start_time) / 1000.0 > GENERIC_TIMEOUT:
+			debugger_plugin.clear_response(msg_type)
+			_last_error = _error("TIMEOUT", "Timed out waiting for %s response" % msg_type)
+			return null
+
+	var response = debugger_plugin.get_response(msg_type)
+	debugger_plugin.clear_response(msg_type)
+	return response

package/addon/commands/screenshot_commands.gd

@@ -2,7 +2,7 @@
 extends MCPBaseCommand
 class_name MCPScreenshotCommands
 
-const DEFAULT_MAX_WIDTH := 1024
+const DEFAULT_MAX_WIDTH := 900
 const DEFAULT_JPEG_QUALITY := 75
 const SCREENSHOT_TIMEOUT := 5.0
 

package/addon/game_bridge/mcp_game_bridge.gd

@@ -6,6 +6,7 @@ const DEFAULT_JPEG_QUALITY := 0.75
 
 var _logger: _MCPGameLogger
 var _profiler: MCPFrameProfiler
+var _sampler: MCPRuntimeStateSampler
 
 
 func _ready() -> void:
@@ -15,6 +16,8 @@ func _ready() -> void:
 	OS.add_logger(_logger)
 	_profiler = MCPFrameProfiler.new()
 	EngineDebugger.register_profiler("mcp_frame_profiler", _profiler)
+	_sampler = MCPRuntimeStateSampler.new()
+	add_child(_sampler)
 	EngineDebugger.register_message_capture("godot_mcp", _on_debugger_message)
 	MCPLog.info("Game bridge initialized")
 
@@ -90,6 +93,18 @@ func _on_debugger_message(message: String, data: Array) -> bool:
 		"get_signal_connections":
 			_handle_get_signal_connections(data)
 			return true
+		"get_runtime_state":
+			_handle_get_runtime_state(data)
+			return true
+		"watch_start":
+			_handle_watch_start(data)
+			return true
+		"watch_collect":
+			_handle_watch_collect()
+			return true
+		"watch_stop":
+			_handle_watch_stop()
+			return true
 	return false
 
 
@@ -376,6 +391,290 @@ func _node_path_string(node: Node, scene_root: Node) -> String:
 	return path
 
 
+func _handle_get_runtime_state(data: Array) -> void:
+	var params: Dictionary = data[0] if data.size() > 0 and data[0] is Dictionary else {}
+
+	var tree := get_tree()
+	var scene_root := tree.current_scene if tree else null
+	if not scene_root:
+		EngineDebugger.send_message("godot_mcp:game_response", ["get_runtime_state", {
+			"scene": "",
+			"selection": "fallback",
+			"entity_count": 0,
+			"entities": [],
+			"hint": "No scene is currently running.",
+		}])
+		return
+
+	var select_mode: String = params.get("select", "auto")
+	var group_name: String = params.get("group", "mcp_watch")
+	var name_filter: String = params.get("name", "")
+	var type_filter: String = params.get("type", "")
+	var max_nodes: int = params.get("max_nodes", 40)
+	var include_fields: Array = params.get("include", [])
+	max_nodes = clampi(max_nodes, 1, 200)
+
+	# Resolve camera for on-screen checks
+	var camera_2d: Camera2D = _find_camera_2d()
+	var camera_viewport_rect := Rect2()
+	if camera_2d:
+		camera_viewport_rect = camera_2d.get_viewport_rect()
+
+	# Determine which selection tier to use
+	var actual_selection: String = select_mode
+	if select_mode == "auto":
+		if _has_group_members(scene_root, group_name):
+			actual_selection = "group"
+		elif _has_mcp_state_nodes(scene_root):
+			actual_selection = "method"
+		else:
+			actual_selection = "fallback"
+
+	# Collect entities
+	var entities: Array = []
+	_collect_runtime_state(scene_root, scene_root, actual_selection, group_name,
+		name_filter, type_filter, include_fields, camera_2d, camera_viewport_rect,
+		max_nodes, entities)
+
+	# Extract camera entity separately if present
+	var camera_entity = null
+	var cam_node := _find_camera_2d() if actual_selection != "fallback" else camera_2d
+	if cam_node:
+		camera_entity = {
+			"type": "Camera2D",
+			"pos": {"x": snapped(cam_node.global_position.x, 0.01), "y": snapped(cam_node.global_position.y, 0.01)},
+			"zoom": {"x": snapped(cam_node.zoom.x, 0.01), "y": snapped(cam_node.zoom.y, 0.01)},
+			"camera": true,
+		}
+
+	var hint := ""
+	if actual_selection == "fallback":
+		hint = ("No nodes found in group '%s' and no _mcp_state() methods detected. " +
+			"For richer data: add key nodes to the '%s' group, then implement " +
+			"`func _mcp_state() -> Dictionary` on them. " +
+			"In _mcp_state(), include both live runtime values (position, health, score) " +
+			"AND static definition context (puzzle clues, level config, item data) — " +
+			"an agent needs both to understand and verify game state.") % [group_name, group_name]
+
+	var result: Dictionary = {
+		"scene": scene_root.scene_file_path,
+		"selection": actual_selection,
+		"entity_count": entities.size(),
+		"entities": entities,
+	}
+	if camera_entity:
+		result["camera"] = camera_entity
+	if not hint.is_empty():
+		result["hint"] = hint
+
+	EngineDebugger.send_message("godot_mcp:game_response", ["get_runtime_state", result])
+
+
+func _has_group_members(scene_root: Node, group_name: String) -> bool:
+	var tree := get_tree()
+	if tree == null:
+		return false
+	return tree.get_nodes_in_group(group_name).size() > 0
+
+
+func _has_mcp_state_nodes(node: Node) -> bool:
+	if node.has_method("_mcp_state"):
+		return true
+	for child in node.get_children():
+		if _has_mcp_state_nodes(child):
+			return true
+	return false
+
+
+func _collect_runtime_state(node: Node, scene_root: Node, selection: String, group_name: String,
+		name_filter: String, type_filter: String, include_fields: Array,
+		camera_2d: Camera2D, viewport_rect: Rect2,
+		max_nodes: int, results: Array) -> void:
+	if results.size() >= max_nodes:
+		return
+
+	var include_node := false
+	match selection:
+		"group":
+			include_node = node.is_in_group(group_name)
+		"method":
+			include_node = node.has_method("_mcp_state")
+		"fallback":
+			include_node = (node is CanvasItem and (node as CanvasItem).is_visible_in_tree())
+
+	if include_node:
+		if not name_filter.is_empty() and not node.name.matchn(name_filter):
+			include_node = false
+		if not type_filter.is_empty() and not node.is_class(type_filter):
+			include_node = false
+
+	if include_node:
+		var entity := _extract_node_state(node, scene_root, include_fields, camera_2d, viewport_rect)
+		if entity != null:
+			results.append(entity)
+
+	for child in node.get_children():
+		if results.size() >= max_nodes:
+			return
+		_collect_runtime_state(child, scene_root, selection, group_name,
+			name_filter, type_filter, include_fields, camera_2d, viewport_rect,
+			max_nodes, results)
+
+
+# _mcp_state() contract: return a Dictionary with two categories —
+#   (1) live runtime values that change during play (cursor pos, health, score, fill counts)
+#   (2) static definition context needed to interpret them (puzzle clues, level layout, config)
+# An agent can observe (1) without (2) but cannot verify correctness without both.
+# Optionally include layout geometry (bounds, sizes) to enable programmatic layout checks.
+# Error handling: _mcp_state() runtime errors are non-fatal in GDScript (Godot prints them
+# and the call returns null); the `is Dictionary` check below handles that silently.
+func _extract_node_state(node: Node, scene_root: Node, include_fields: Array,
+		camera_2d: Camera2D, viewport_rect: Rect2) -> Dictionary:
+	var want := include_fields.is_empty()
+	var want_transform := want or include_fields.has("transform")
+	var want_velocity := want or include_fields.has("velocity")
+	var want_anim := want or include_fields.has("anim")
+	var want_groups := want or include_fields.has("groups")
+	var want_onscreen := want or include_fields.has("onscreen")
+	var want_state := want or include_fields.has("state")
+
+	var entity: Dictionary = {
+		"path": _node_path_string(node, scene_root),
+		"type": node.get_class(),
+	}
+
+	if want_groups:
+		var groups := node.get_groups().filter(func(g): return not g.begins_with("_"))
+		if not groups.is_empty():
+			entity["groups"] = groups
+
+	if want_transform and node is Node2D:
+		var n2d := node as Node2D
+		entity["pos"] = {"x": snapped(n2d.global_position.x, 0.01), "y": snapped(n2d.global_position.y, 0.01)}
+		entity["rot"] = snapped(rad_to_deg(n2d.global_rotation), 0.01)
+		if n2d.scale != Vector2.ONE:
+			entity["scale"] = {"x": snapped(n2d.scale.x, 0.01), "y": snapped(n2d.scale.y, 0.01)}
+
+	if want_transform and node is Node3D:
+		var n3d := node as Node3D
+		entity["pos"] = {
+			"x": snapped(n3d.global_position.x, 0.01),
+			"y": snapped(n3d.global_position.y, 0.01),
+			"z": snapped(n3d.global_position.z, 0.01),
+		}
+		entity["rot"] = {
+			"x": snapped(rad_to_deg(n3d.global_rotation.x), 0.01),
+			"y": snapped(rad_to_deg(n3d.global_rotation.y), 0.01),
+			"z": snapped(rad_to_deg(n3d.global_rotation.z), 0.01),
+		}
+
+	if want_velocity:
+		if node is CharacterBody2D:
+			var v := (node as CharacterBody2D).velocity
+			entity["vel"] = {"x": snapped(v.x, 0.01), "y": snapped(v.y, 0.01)}
+		elif node is RigidBody2D:
+			var v := (node as RigidBody2D).linear_velocity
+			entity["vel"] = {"x": snapped(v.x, 0.01), "y": snapped(v.y, 0.01)}
+			entity["angvel"] = snapped((node as RigidBody2D).angular_velocity, 0.01)
+		elif node is CharacterBody3D:
+			var v := (node as CharacterBody3D).velocity
+			entity["vel"] = {"x": snapped(v.x, 0.01), "y": snapped(v.y, 0.01), "z": snapped(v.z, 0.01)}
+		elif node is RigidBody3D:
+			var v := (node as RigidBody3D).linear_velocity
+			entity["vel"] = {"x": snapped(v.x, 0.01), "y": snapped(v.y, 0.01), "z": snapped(v.z, 0.01)}
+			var av := (node as RigidBody3D).angular_velocity
+			entity["angvel"] = {"x": snapped(av.x, 0.01), "y": snapped(av.y, 0.01), "z": snapped(av.z, 0.01)}
+
+	if want_anim:
+		if node is AnimationPlayer:
+			var ap := node as AnimationPlayer
+			entity["anim"] = ap.current_animation
+			entity["anim_pos"] = snapped(ap.current_animation_position, 0.01)
+			entity["playing"] = ap.is_playing()
+		elif node is AnimatedSprite2D:
+			var asp := node as AnimatedSprite2D
+			entity["anim"] = asp.animation
+			entity["anim_frame"] = asp.frame
+
+	if want_onscreen and camera_2d and node is Node2D:
+		var pos := (node as Node2D).global_position
+		entity["onscreen"] = viewport_rect.has_point(pos)
+
+	if want_state and node.has_method("_mcp_state"):
+		var raw_state = node._mcp_state()
+		if raw_state is Dictionary:
+			var serialized := _serialize_mcp_state(raw_state)
+			if not serialized.is_empty():
+				entity["state"] = serialized
+
+	return entity
+
+
+const _MCP_STATE_MAX_BYTES := 1024
+
+
+func _serialize_mcp_state(state: Dictionary) -> Dictionary:
+	var result: Dictionary = {}
+	for key in state:
+		var val = state[key]
+		var serializable = null
+		match typeof(val):
+			TYPE_BOOL, TYPE_STRING:
+				serializable = val
+			TYPE_INT:
+				serializable = int(val)
+			TYPE_FLOAT:
+				serializable = snapped(float(val), 0.01)
+			TYPE_ARRAY:
+				serializable = val
+			TYPE_DICTIONARY:
+				serializable = val
+			# skip non-serializable types (Objects, NodePaths, RIDs, etc.)
+		if serializable == null:
+			continue
+		result[str(key)] = serializable
+		if JSON.stringify(result).length() > _MCP_STATE_MAX_BYTES:
+			result.erase(str(key))
+			result["_truncated"] = true
+			break
+	return result
+
+
+func _find_camera_2d() -> Camera2D:
+	var viewport := get_viewport()
+	if viewport == null:
+		return null
+	return viewport.get_camera_2d()
+
+
+func _handle_watch_start(data: Array) -> void:
+	if _sampler == null:
+		EngineDebugger.send_message("godot_mcp:game_response", ["watch_start", {"started": false, "error": "Sampler not initialized"}])
+		return
+	var specs: Array = data[0] if data.size() > 0 else []
+	var hz: int = data[1] if data.size() > 1 else 20
+	var duration_ms: int = data[2] if data.size() > 2 else 1000
+	var start_result := _sampler.start(specs, hz, duration_ms)
+	EngineDebugger.send_message("godot_mcp:game_response", ["watch_start", {
+		"started": true,
+		"resolved_fields": start_result.get("resolved_fields", 0),
+	}])
+
+
+func _handle_watch_collect() -> void:
+	if _sampler == null:
+		EngineDebugger.send_message("godot_mcp:game_response", ["watch_collect", {"window_ms": 0, "sample_count": 0, "fields": {}}])
+		return
+	EngineDebugger.send_message("godot_mcp:game_response", ["watch_collect", _sampler.collect()])
+
+
+func _handle_watch_stop() -> void:
+	if _sampler == null:
+		EngineDebugger.send_message("godot_mcp:game_response", ["watch_stop", {"window_ms": 0, "sample_count": 0, "fields": {}}])
+		return
+	EngineDebugger.send_message("godot_mcp:game_response", ["watch_stop", _sampler.stop()])
+
+
 class _MCPGameLogger extends Logger:
 	var _output: PackedStringArray = []
 	var _max_lines := 1000

package/addon/game_bridge/mcp_runtime_state_sampler.gd

@@ -0,0 +1,215 @@
+extends Node
+class_name MCPRuntimeStateSampler
+
+const MAX_FIELDS := 32
+const MAX_SAMPLES_PER_FIELD := 200
+
+var _active: bool = false
+var _specs: Array = []       # [{node, fields: [{key, resolver}]}]
+var _hz: int = 20
+var _duration_ms: int = 1000
+var _start_time: int = 0
+var _stop_time: int = 0      # set on auto-stop or manual stop; 0 = still running
+var _frame_index: int = 0
+var _sample_interval: int = 1  # sample every N frames
+var _samples: Dictionary = {}  # field_key -> Array of {t_ms, value}
+
+
+func start(specs: Array, hz: int, duration_ms: int) -> Dictionary:
+	_specs = []
+	_samples = {}
+	_hz = clampi(hz, 1, 60)
+	_duration_ms = clampi(duration_ms, 100, 5000)
+	_start_time = Time.get_ticks_msec()
+	_frame_index = 0
+	_sample_interval = max(1, int(Engine.get_frames_per_second() / _hz)) if Engine.get_frames_per_second() > 0 else max(1, int(60.0 / _hz))
+
+	var field_count := 0
+	for spec in specs:
+		if field_count >= MAX_FIELDS:
+			break
+		var node_path: String = spec.get("path", "")
+		var fields: Array = spec.get("fields", [])
+		if node_path.is_empty() or fields.is_empty():
+			continue
+
+		var node := _resolve_node(node_path)
+		if node == null:
+			continue
+
+		var resolved_fields: Array = []
+		for field_key in fields:
+			if field_count >= MAX_FIELDS:
+				break
+			var full_key: String = node_path + ":" + str(field_key)
+			_samples[full_key] = []
+			resolved_fields.append({"key": field_key, "full_key": full_key})
+			field_count += 1
+
+		if not resolved_fields.is_empty():
+			_specs.append({"node": node, "node_path": node_path, "fields": resolved_fields})
+
+	_stop_time = 0
+	_active = true
+	set_process(true)
+	return {"resolved_fields": field_count}
+
+
+func _process(_delta: float) -> void:
+	if not _active:
+		return
+
+	var elapsed := Time.get_ticks_msec() - _start_time
+
+	if elapsed >= _duration_ms:
+		_active = false
+		_stop_time = Time.get_ticks_msec()
+		set_process(false)
+		return
+
+	_frame_index += 1
+	if _frame_index % _sample_interval != 0:
+		return
+
+	for spec in _specs:
+		var node: Node = spec.node
+		if not is_instance_valid(node):
+			# node was freed — mark all fields and skip
+			for field_info in spec.fields:
+				var arr: Array = _samples.get(field_info.full_key, [])
+				if arr.size() < MAX_SAMPLES_PER_FIELD:
+					arr.append({"t_ms": elapsed, "value": "freed"})
+			continue
+
+		for field_info in spec.fields:
+			var value = _read_field(node, field_info.key)
+			if value == null:
+				continue
+			var arr: Array = _samples.get(field_info.full_key, [])
+			if arr.size() < MAX_SAMPLES_PER_FIELD:
+				arr.append({"t_ms": elapsed, "value": value})
+
+
+func collect() -> Dictionary:
+	var elapsed: int
+	if _stop_time > 0:
+		elapsed = _stop_time - _start_time
+	elif _start_time > 0:
+		elapsed = Time.get_ticks_msec() - _start_time
+	else:
+		elapsed = 0  # never started
+	var total_samples := 0
+	for key in _samples:
+		total_samples += (_samples[key] as Array).size()
+	return {
+		"window_ms": elapsed,
+		"sample_count": total_samples,
+		"fields": _samples.duplicate(true),
+	}
+
+
+func stop() -> Dictionary:
+	_active = false
+	_stop_time = Time.get_ticks_msec()
+	set_process(false)
+	return collect()
+
+
+func is_active() -> bool:
+	return _active
+
+
+func _resolve_node(path: String) -> Node:
+	var tree := get_tree()
+	if tree == null:
+		return null
+	var scene_root := tree.current_scene
+	if scene_root == null:
+		return null
+
+	if path == "/root/" + scene_root.name or path == "/":
+		return scene_root
+
+	if path.begins_with("/root/"):
+		var parts := path.split("/")
+		# parts[0]="", parts[1]="root", parts[2]=scene_name, parts[3+]=relative
+		if parts.size() >= 3 and parts[2] == scene_root.name:
+			if parts.size() == 3:
+				return scene_root
+			var relative := "/".join(parts.slice(3))
+			return scene_root.get_node_or_null(relative)
+
+	return scene_root.get_node_or_null(path)
+
+
+func _read_field(node: Node, key: String) -> Variant:
+	match key:
+		"pos.x":
+			if node is Node2D:
+				return snapped((node as Node2D).global_position.x, 0.01)
+			if node is Node3D:
+				return snapped((node as Node3D).global_position.x, 0.01)
+		"pos.y":
+			if node is Node2D:
+				return snapped((node as Node2D).global_position.y, 0.01)
+			if node is Node3D:
+				return snapped((node as Node3D).global_position.y, 0.01)
+		"pos.z":
+			if node is Node3D:
+				return snapped((node as Node3D).global_position.z, 0.01)
+		"vel.x":
+			if node is CharacterBody2D:
+				return snapped((node as CharacterBody2D).velocity.x, 0.01)
+			if node is RigidBody2D:
+				return snapped((node as RigidBody2D).linear_velocity.x, 0.01)
+			if node is CharacterBody3D:
+				return snapped((node as CharacterBody3D).velocity.x, 0.01)
+			if node is RigidBody3D:
+				return snapped((node as RigidBody3D).linear_velocity.x, 0.01)
+		"vel.y":
+			if node is CharacterBody2D:
+				return snapped((node as CharacterBody2D).velocity.y, 0.01)
+			if node is RigidBody2D:
+				return snapped((node as RigidBody2D).linear_velocity.y, 0.01)
+			if node is CharacterBody3D:
+				return snapped((node as CharacterBody3D).velocity.y, 0.01)
+			if node is RigidBody3D:
+				return snapped((node as RigidBody3D).linear_velocity.y, 0.01)
+		"vel.z":
+			if node is CharacterBody3D:
+				return snapped((node as CharacterBody3D).velocity.z, 0.01)
+			if node is RigidBody3D:
+				return snapped((node as RigidBody3D).linear_velocity.z, 0.01)
+		"rot":
+			if node is Node2D:
+				return snapped(rad_to_deg((node as Node2D).global_rotation), 0.01)
+			if node is Node3D:
+				return snapped(rad_to_deg((node as Node3D).global_rotation.y), 0.01)
+		"anim":
+			if node is AnimationPlayer:
+				return (node as AnimationPlayer).current_animation
+			if node is AnimatedSprite2D:
+				return (node as AnimatedSprite2D).animation
+		"anim_frame":
+			if node is AnimatedSprite2D:
+				return (node as AnimatedSprite2D).frame
+
+	# Custom state fallback — `is Dictionary` guards against _mcp_state() errors,
+	# which are non-fatal in GDScript (Godot prints the error and returns null).
+	if node.has_method("_mcp_state"):
+		var state = node._mcp_state()
+		if state is Dictionary and state.has(key):
+			var val = state[key]
+			if val is float or val is int:
+				return snapped(float(val), 0.01)
+			return val
+
+	# Generic property fallback
+	if key in node:
+		var val = node.get(key)
+		if val is float or val is int:
+			return snapped(float(val), 0.01)
+		if val is String or val is bool:
+			return val
+
+	return null

package/addon/plugin.cfg

@@ -3,6 +3,6 @@
 name="Godot MCP"
 description="Model Context Protocol server for AI assistant integration"
 author="godot-mcp"
-version="3.5.0"
+version="3.6.1"
 script="plugin.gd"
 godot_version_min="4.5"

package/dist/__tests__/tools/runtime-state.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=runtime-state.test.d.ts.map

package/dist/__tests__/tools/runtime-state.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-state.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/tools/runtime-state.test.ts"],"names":[],"mappings":""}