gdharness 1.3.7 → 1.3.8

package/build/godot/addons/gdharness_runtime/runtime_changes.gd

@@ -524,7 +524,9 @@ static func _not_a_method_to_call(holder: Object, named: String, called: String)
 				% [called, named]
 			)
 		method = GdhPaths.method_of(named)
-	return "" if holder.has_method(method) else "%s has no method %s" % [called, method]
+	if holder.has_method(method):
+		return ""
+	return GdhPaths.with_methods_offered("%s has no method %s" % [called, method], holder, method)
 
 
 ## Whether a call's `properties` asks for its result to be read: true, or a list of names.

package/build/godot/addons/gdharness_runtime/runtime_input.gd

@@ -157,6 +157,7 @@ func inject_action(params: Dictionary) -> Dictionary:
 		return {"type": "error", "message": holding}
 	var frames: int = holding
 
+	var focused: String = _focus_owner()
 	_say_action(action, whole or held, strength)
 	var lasted: Variant = null
 	if whole:
@@ -166,15 +167,34 @@ func inject_action(params: Dictionary) -> Dictionary:
 		_say_action(action, false, strength)
 		await _host.get_tree().process_frame
 
-	return {
-		"type": "input_injected",
-		"input_type": "action",
-		"action": action,
-		"pressed": held and not whole,
-		"whole": whole,
-		"held_frames": GdhValues.held_answer(whole, frames),
-		"held_for": lasted,
-	}
+	return _focus_noted(
+		{
+			"type": "input_injected",
+			"input_type": "action",
+			"action": action,
+			"pressed": held and not whole,
+			"whole": whole,
+			"held_frames": GdhValues.held_answer(whole, frames),
+			"held_for": lasted,
+		},
+		focused
+	)
+
+
+## The path of the Control holding the keyboard focus, or "" when none does. Read before a key or an
+## action goes in, since pressing a focused button can move the focus.
+func _focus_owner() -> String:
+	var holding: Control = _host.get_viewport().gui_get_focus_owner()
+	return "" if holding == null else str(holding.get_path())
+
+
+## [param said] with [param focused], the Control that had the focus, under focused. A key or an action
+## reaches that Control before the game's _unhandled_input, so Space on a focused Button pressed it
+## and the game's own handler counted the key as well, with nothing in the answer saying why.
+static func _focus_noted(said: Dictionary, focused: String) -> Dictionary:
+	if not focused.is_empty():
+		said["focused"] = focused
+	return said
 
 
 func _say_action(action: String, down: bool, strength: float) -> void:
@@ -230,6 +250,7 @@ func inject_key(params: Dictionary) -> Dictionary:
 	# keys are the code points themselves, which is what makes this a mapping and not a table.
 	event.unicode = GdhValues.glyph_of(event.keycode, event.shift_pressed)
 
+	var focused: String = _focus_owner()
 	Input.parse_input_event(event)
 	var lasted: Variant = null
 	if whole:
@@ -239,20 +260,23 @@ func inject_key(params: Dictionary) -> Dictionary:
 		Input.parse_input_event(up)
 		await _host.get_tree().process_frame
 
-	return {
-		"type": "input_injected",
-		"input_type": "key",
-		"held_frames": GdhValues.held_answer(whole, frames),
-		"held_for": lasted,
-		"keycode": event.keycode,
-		"physical_keycode": event.physical_keycode,
-		"shift": event.shift_pressed,
-		"ctrl": event.ctrl_pressed,
-		"alt": event.alt_pressed,
-		"unicode": event.unicode,
-		"pressed": held and not whole,
-		"whole": whole,
-	}
+	return _focus_noted(
+		{
+			"type": "input_injected",
+			"input_type": "key",
+			"held_frames": GdhValues.held_answer(whole, frames),
+			"held_for": lasted,
+			"keycode": event.keycode,
+			"physical_keycode": event.physical_keycode,
+			"shift": event.shift_pressed,
+			"ctrl": event.ctrl_pressed,
+			"alt": event.alt_pressed,
+			"unicode": event.unicode,
+			"pressed": held and not whole,
+			"whole": whole,
+		},
+		focused
+	)
 
 
 ## Clicks a mouse button at a position, and lets go of it again unless asked to hold it.

package/build/godot/addons/gdharness_runtime/runtime_paths.gd

@@ -416,7 +416,7 @@ static func _arity(object: Object, method: String) -> Dictionary:
 static func call_refused(object: Object, method: String, called_as: String, given: int = 0) -> String:
 	var arity: Dictionary = _arity(object, method)
 	if arity.is_empty():
-		return "%s has no method %s" % [called_as, method]
+		return with_methods_offered("%s has no method %s" % [called_as, method], object, method)
 	var least: int = arity["least"]
 	var most: int = arity["most"]
 	var any_more: bool = arity["any_more"]
@@ -454,6 +454,32 @@ static func call_refused(object: Object, method: String, called_as: String, give
 	return ""
 
 
+## [param said], a refusal for [param method], which [param object] lacks, with the methods it has
+## nearest the name, or else those its script declares. The engine's own run to hundreds on a node,
+## so they are offered only when one is near.
+static func with_methods_offered(said: String, object: Object, method: String) -> String:
+	var own: Array[String] = []
+	var attached: Variant = object.get_script()
+	if attached is Script:
+		var script: Script = attached
+		for entry: Dictionary in script.get_script_method_list():
+			var name: String = str(entry.get("name", ""))
+			if not name.is_empty() and not own.has(name):
+				own.append(name)
+	var every: Array[String] = own.duplicate()
+	for entry: Dictionary in object.get_method_list():
+		var name: String = str(entry.get("name", ""))
+		if not every.has(name):
+			every.append(name)
+	var close: PackedStringArray = GdhRead.nearest(method, PackedStringArray(every))
+	if not close.is_empty():
+		return "%s; the nearest it has %s %s" % [said, "is" if close.size() == 1 else "are", ", ".join(close)]
+	if own.is_empty():
+		return said
+	own.sort()
+	return "%s; its script declares %s" % [said, ", ".join(PackedStringArray(own))]
+
+
 ## The entry a script attached to [param object] declares for [param method], or an empty one when
 ## the method is the engine's.
 static func _script_method(object: Object, method: String) -> Dictionary:

package/build/godot/operations/dependencies.gd

@@ -168,6 +168,16 @@ func find_resource_usages(params: Dictionary) -> Dictionary:
 	var by_class: RegEx = null
 	if not class_name_declared.is_empty():
 		by_class = GdhPatterns.compiled("\\b" + _regex_escaped(class_name_declared) + "\\b")
+	# The script of an autoload is used wherever code names the autoload, and asked what uses it,
+	# the answer was its line in project.godot alone, beside the scripts calling it.
+	var autoload_named: String = ""
+	var autoloads: Dictionary = autoloads_declared()
+	for name: String in autoloads:
+		if str(autoloads[name]) == resource_path:
+			autoload_named = name
+	var by_autoload: RegEx = null
+	if not autoload_named.is_empty():
+		by_autoload = GdhPatterns.compiled("\\b" + _regex_escaped(autoload_named) + "\\b")
 	var target: Dictionary = {
 		"path": resource_path,
 		"uid": str(GdhResourceFiles.uid_of(resource_path).get("uid", "")) if exists else ""
@@ -203,7 +213,12 @@ func find_resource_usages(params: Dictionary) -> Dictionary:
 				# Strings are text, so a class named in one is not a use of it.
 				by_its_name = by_class.search(_code_of(line)) != null
 				name_in_comment = not by_its_name and by_class.search(_comment_of(line)) != null
-			if not by_its_path and not by_its_name and not name_in_comment:
+			var by_its_autoload: bool = false
+			if not by_its_path and not by_its_name and code and by_autoload != null:
+				by_its_autoload = by_autoload.search(_code_of(line)) != null
+				if not by_its_autoload and not name_in_comment:
+					name_in_comment = by_autoload.search(_comment_of(line)) != null
+			if not by_its_path and not by_its_name and not by_its_autoload and not name_in_comment:
 				continue
 			var trimmed: String = line.strip_edges()
 			var kind: String = ""
@@ -219,6 +234,8 @@ func find_resource_usages(params: Dictionary) -> Dictionary:
 				kind = "comment"
 			elif by_its_path:
 				kind = _path_reference_kind(line, file_path)
+			elif by_its_autoload:
+				kind = "autoload"
 			else:
 				kind = (
 					"extends"
@@ -244,7 +261,7 @@ func find_resource_usages(params: Dictionary) -> Dictionary:
 	var declared: Variant = null
 	if not class_name_declared.is_empty():
 		declared = class_name_declared
-	return {
+	var answer: Dictionary = {
 		"resource_path": resource_path,
 		"exists": exists,
 		"class_name": declared,
@@ -260,6 +277,9 @@ func find_resource_usages(params: Dictionary) -> Dictionary:
 			"by_kind": by_kind,
 		},
 	}
+	if not autoload_named.is_empty():
+		answer["autoload"] = autoload_named
+	return answer
 
 
 # The class_name a script declares, or empty for a scene, a resource or a script without one.
@@ -477,15 +497,19 @@ func _analyze_resource(path: String, current_depth: int, walk: GdhDependencyWalk
 				if not walk.include_built_in and dep_path.begins_with("res://."):
 					continue
 
-				_depend(deps, path, dep_path, "", current_depth, walk)
+				_depend(deps, path, dep_path, {}, current_depth, walk)
 
 		# A script uses another by its class_name as surely as by a preload, and only the reverse walk
 		# looked for that: asked what a script depends on, the answer left out the script it typed a
-		# variable with, while asking what used that script named this one.
+		# variable with, while asking what used that script named this one. An autoload's global
+		# name is the same kind of use, of the script registered under it.
 		if path.get_extension() == "gd":
 			var classes: Dictionary = classes_declared()
 			for used: String in classes_used_in(content, classes):
-				_depend(deps, path, str(classes[used]), used, current_depth, walk)
+				_depend(deps, path, str(classes[used]), {"by_class": used}, current_depth, walk)
+			var autoloads: Dictionary = autoloads_declared()
+			for used: String in classes_used_in(content, autoloads):
+				_depend(deps, path, str(autoloads[used]), {"by_autoload": used}, current_depth, walk)
 
 	walk.path_stack.pop_back()
 	walk.visited[path] = {"deps": deps, "remaining": remaining}
@@ -493,13 +517,13 @@ func _analyze_resource(path: String, current_depth: int, walk: GdhDependencyWalk
 
 
 # Adds [param dep_path] to [param deps], what [param path] depends on, walked as far as the depth left
-# allows, once however many times it is named. [param by_class] is the class name it was named by,
-# or empty for a path.
+# allows, once however many times it is named. [param named_by] is the class or autoload name it was
+# named by, as by_class or by_autoload, or empty for a path.
 func _depend(
 	deps: Array[Dictionary],
 	path: String,
 	dep_path: String,
-	by_class: String,
+	named_by: Dictionary,
 	current_depth: int,
 	walk: GdhDependencyWalk
 ) -> void:
@@ -509,8 +533,7 @@ func _depend(
 		if existing.get("path", "") == dep_path:
 			return
 	var dep_info: Dictionary = {"path": dep_path, "exists": FileAccess.file_exists(dep_path)}
-	if not by_class.is_empty():
-		dep_info["by_class"] = by_class
+	dep_info.merge(named_by)
 	if dep_info["exists"] and current_depth + 1 < walk.max_depth:
 		var sub_deps: Array[Dictionary] = _analyze_resource(dep_path, current_depth + 1, walk)
 		if sub_deps.size() > 0:
@@ -518,6 +541,22 @@ func _depend(
 	deps.append(dep_info)
 
 
+## Every autoload the project registers as a global name, with its script. One that is not global
+## is no name code can use.
+static func autoloads_declared() -> Dictionary:
+	var autoloads: Dictionary = {}
+	for property: Dictionary in ProjectSettings.get_property_list():
+		var setting: String = str(property.get("name", ""))
+		if not setting.begins_with("autoload/"):
+			continue
+		var value: String = str(ProjectSettings.get_setting(setting))
+		if value.begins_with("*"):
+			autoloads[setting.trim_prefix("autoload/")] = _resolved(
+				value.trim_prefix("*"), "res://project.godot"
+			)
+	return autoloads
+
+
 ## Every class_name the project's scripts declare, with the script declaring it.
 func classes_declared() -> Dictionary:
 	if _classes_read:
@@ -530,6 +569,18 @@ func classes_declared() -> Dictionary:
 	return _classes_declared
 
 
+## Every class the project's scripts declare with class_name, sorted by name, with the script
+## declaring it. Read from the files rather than the class cache, which only a scan rewrites.
+func list_script_classes(_params: Dictionary) -> Dictionary:
+	var declared: Dictionary = classes_declared()
+	var names: Array = declared.keys()
+	names.sort()
+	var classes: Array[Dictionary] = []
+	for name: Variant in names:
+		classes.append({"name": str(name), "path": str(declared[name])})
+	return {"classes": classes, "count": classes.size()}
+
+
 ## The names in [param classes] that the code in [param content] uses, in the order first used: words
 ## outside strings and comments, so a class named in prose or in a message is not a use of it.
 static func classes_used_in(content: String, classes: Dictionary) -> Array[String]:

package/build/godot/operations/gdscript_analysis.gd

@@ -23,6 +23,8 @@ class GdhMembers:
 	var constants: Array[Dictionary] = []
 	var enums: Array[Dictionary] = []
 	var inner_classes: Array[Dictionary] = []
+	## The `##` comment the class is documented with, empty when it has none.
+	var doc: String = ""
 	## The index of the last line the body holds.
 	var last: int = -1
 	## An inner class's name and the line its `class` is on.
@@ -43,6 +45,22 @@ class GdhMembers:
 			"inner_classes": inner_classes,
 		}
 
+	## Whether a member is declared yet, past which a `##` block no longer documents the class.
+	func declares_members() -> bool:
+		return not (
+			signals.is_empty()
+			and variables.is_empty()
+			and functions.is_empty()
+			and constants.is_empty()
+			and enums.is_empty()
+			and inner_classes.is_empty()
+		)
+
+	## [param lines] as the class's documentation, when it has none yet.
+	func take_doc(lines: Array[String]) -> void:
+		if doc.is_empty() and not lines.is_empty():
+			doc = "\n".join(PackedStringArray(lines))
+
 
 func _init(p_log: GdhLog) -> void:
 	_log = p_log
@@ -130,6 +148,8 @@ func get_gdscript_info(params: Dictionary) -> Dictionary:
 		"autoloads_used": autoloads_used,
 		"line_count": lines.size() - 1 if content.is_empty() or content.ends_with("\n") else lines.size()
 	}
+	if not own.doc.is_empty():
+		answer["class_doc"] = own.doc
 	if GdhRead.as_bool(params.get("include_inherited", false)):
 		_add_inherited(answer, [full_script_path])
 	return answer
@@ -143,6 +163,7 @@ func _members(
 ) -> GdhMembers:
 	var own: GdhMembers = GdhMembers.new()
 	var in_multiline_string: bool = false
+	var doc: Array[String] = []
 
 	var i: int = first - 1
 	while i + 1 < lines.size():
@@ -158,9 +179,25 @@ func _members(
 			if _triple_quotes(raw) % 2 == 1:
 				in_multiline_string = false
 			continue
+		# A `##` block documents what it sits directly above: the class when that is its class_name
+		# or extends line, or when a blank line follows it before any member, and otherwise the next
+		# member. One at a shallower indent is the outer body's, for what follows this inner class.
+		var trimmed: String = raw.strip_edges()
+		if trimmed.begins_with("##"):
+			if not raw.begins_with(margin):
+				own.last = i - 1
+				return own
+			if _indentation(raw).length() <= margin.length():
+				var said: String = trimmed.substr(2)
+				doc.append(said.substr(1) if said.begins_with(" ") else said)
+			continue
 		var stripped: String = GdhPatterns.without_comment(raw)
 
 		if stripped.is_empty():
+			if trimmed.is_empty() and not doc.is_empty():
+				if not own.declares_members():
+					own.take_doc(doc)
+				doc.clear()
 			continue
 
 		# A line back at a shallower indent closes an inner class's body, and is the outer body's
@@ -210,6 +247,7 @@ func _members(
 				stripped = (stripped + " " + GdhPatterns.without_comment(lines[i])).strip_edges()
 			header = GdhPatterns.without_annotations(stripped)
 		var declaration: RegExMatch = GdhPatterns.declared_class(header)
+		var entry: Dictionary = {}
 		if declaration != null:
 			own.declared_class_name = declaration.get_string(1)
 			# `class_name X extends Y` is also one line, and taking the rest of it as the name
@@ -217,29 +255,47 @@ func _members(
 			# `RefCounted`: the name unusable and the base flatly wrong.
 			if not declaration.get_string(2).is_empty():
 				own.extends_name = declaration.get_string(2)
+			own.take_doc(doc)
 		elif header.begins_with("extends "):
 			own.extends_name = header.substr(8).strip_edges()
+			own.take_doc(doc)
 		elif header.begins_with("signal "):
 			# `at`, not `i`: a wrapped declaration starts where it starts, and `i` is now sitting on
 			# the line that closed it.
-			own.signals.append(_parse_signal(header, at + 1))
+			entry = _parse_signal(header, at + 1)
+			own.signals.append(entry)
 		elif header.begins_with("const "):
-			own.constants.append(_parse_constant(header, at + 1))
+			entry = _parse_constant(header, at + 1)
+			own.constants.append(entry)
 		elif header.begins_with("enum "):
-			own.enums.append(_parse_enum(header, at + 1))
+			entry = _parse_enum(header, at + 1)
+			own.enums.append(entry)
 		elif header.begins_with("var ") or header.begins_with("static var "):
 			# The whole line here, not the header: which annotations a variable carries is the
 			# answer rather than noise in front of it, and `@export_range(0, 1)` is the hint.
-			own.variables.append(_parse_variable(stripped, at + 1))
+			entry = _parse_variable(stripped, at + 1)
+			own.variables.append(entry)
 		elif header.begins_with("func ") or header.begins_with("static func "):
-			own.functions.append(_parse_function(header, at + 1, stripped))
+			entry = _parse_function(header, at + 1, stripped)
+			own.functions.append(entry)
 		elif header.begins_with("class "):
 			_collect_dependencies(stripped, dependencies)
 			var inner: GdhMembers = _inner_class(lines, i, margin, header, dependencies)
-			own.inner_classes.append(inner.as_inner())
+			entry = inner.as_inner()
+			if not doc.is_empty():
+				entry["doc"] = "\n".join(PackedStringArray(doc))
+			doc.clear()
+			own.inner_classes.append(entry)
 			i = inner.last
 			continue
 
+		if not entry.is_empty() and not doc.is_empty():
+			entry["doc"] = "\n".join(PackedStringArray(doc))
+		# A line of annotations alone, `@tool` or `@export` above its variable, is between a comment
+		# and what it documents rather than after it.
+		if not header.is_empty():
+			doc.clear()
+
 		_collect_dependencies(stripped, dependencies)
 
 	own.last = lines.size() - 1

package/build/godot/operations/gdscript_authoring.gd

@@ -196,7 +196,10 @@ func modify_gdscript(params: Dictionary) -> Dictionary:
 	if not problems.is_empty():
 		var refusal: String = "Nothing was changed: " + "; ".join(problems)
 		if _redeclares(modifications, declared):
-			refusal += ". modify only adds, so a member the script declares already is changed in the file itself"
+			refusal += (
+				". modify only adds members; to change one the script declares already,"
+				+ " edit its lines in the file"
+			)
 		return _log.failure(refusal)
 	# Each placed line as a zero-based index that moves down whenever a later insertion lands above
 	# it, so the numbers answered are where the lines are in the file written, not where each went

package/build/godot/operations/godot_operations.gd

@@ -237,6 +237,8 @@ func _run(operation: String, params: Dictionary) -> Dictionary:
 			payload = GdhDependencies.new(_log).get_dependencies(params)
 		"find_resource_usages":
 			payload = GdhDependencies.new(_log).find_resource_usages(params)
+		"list_script_classes":
+			payload = GdhDependencies.new(_log).list_script_classes(params)
 		"get_project_health":
 			payload = GdhProjectDiagnostics.new(_log).get_project_health(params)
 

package/build/godot/operations/import_pipeline.gd

@@ -227,6 +227,7 @@ func set_import_options(params: Dictionary) -> Dictionary:
 	# One already holding the value given changes nothing, and listing it as updated said it had.
 	var updated_keys: Array[String] = []
 	var unchanged_keys: Array[String] = []
+	var changes: Dictionary = {}
 	for name: String in fitted_values:
 		var held: Variant = config.get_value("params", name, null)
 		var value: Variant = fitted_values[name]
@@ -235,6 +236,10 @@ func set_import_options(params: Dictionary) -> Dictionary:
 			continue
 		config.set_value("params", name, value)
 		updated_keys.append(name)
+		changes[name] = {
+			"was": null if held == null else _values.serialize_value(held),
+			"now": _values.serialize_value(value),
+		}
 		_log.debug("Set " + name + " = " + str(value))
 
 	if not updated_keys.is_empty():
@@ -244,6 +249,8 @@ func set_import_options(params: Dictionary) -> Dictionary:
 
 	# The reimport that applies them is the server's, through the editor or the engine's import.
 	var answer: Dictionary = {"resource_path": resource_path, "updated_options": updated_keys}
+	if not changes.is_empty():
+		answer["changed"] = changes
 	if not unchanged_keys.is_empty():
 		answer["unchanged_options"] = unchanged_keys
 	return answer
@@ -387,6 +394,25 @@ func validate_project(params: Dictionary) -> Dictionary:
 			)
 		)
 
+	# A file never imported is on disk, so the reference checks pass it, and still nothing loads it:
+	# a scene using one fails to load in a run or an export.
+	checks_performed.append("imports")
+	var never: Array[String] = []
+	for path: String in _files.find_files_with_extensions("res://", IMPORTABLE_EXTENSIONS):
+		if not FileAccess.file_exists(path + ".import"):
+			never.append(path)
+	if not never.is_empty():
+		never.sort()
+		warnings.append(
+			_finding(
+				"warning",
+				"imports",
+				never_imported_line(never),
+				"Run project_import reimport, or open the project in the editor, whose scan imports them",
+				include_suggestions
+			)
+		)
+
 	checks_performed.append("export_presets")
 	if not FileAccess.file_exists("res://export_presets.cfg"):
 		warnings.append(
@@ -602,7 +628,25 @@ func _no_sidecar(resource_path: String) -> String:
 		return resource_path + " has no import options: " + never
 	return (
 		resource_path
-		+ " has not been imported yet, so it has no import file: project_import reimport imports it"
+		+ " has not been imported yet, so it has no import file: project_import reimport imports"
+		+ " it with the importer's defaults and writes that file"
+	)
+
+
+## [param paths], files the engine imports and never has, as health and validation say it: at most
+## five named, since a project never opened in an editor has every one of its assets here.
+static func never_imported_line(paths: Array[String]) -> String:
+	var named: String = ", ".join(paths.slice(0, 5))
+	if paths.size() > 5:
+		named += " and %d more" % (paths.size() - 5)
+	if paths.size() == 1:
+		return (
+			named
+			+ " has never been imported, so nothing can load it until project_import reimport imports it"
+		)
+	return (
+		"%d files have never been imported, so nothing can load them until project_import reimport imports them: %s"
+		% [paths.size(), named]
 	)
 
 

package/build/godot/operations/project_diagnostics.gd

@@ -50,14 +50,15 @@ func get_project_health(params: Dictionary) -> Dictionary:
 			"res://", GdhImportPipeline.IMPORTABLE_EXTENSIONS
 		)
 
-		var missing_imports: int = 0
+		var missing_imports: Array[String] = []
 		for res: String in resources:
 			if not FileAccess.file_exists(res + ".import"):
-				missing_imports += 1
+				missing_imports.append(res)
 
-		if missing_imports > 0:
-			details.append(str(missing_imports) + " resources may need reimporting")
-			deductions += missing_imports
+		if not missing_imports.is_empty():
+			missing_imports.sort()
+			details.append(GdhImportPipeline.never_imported_line(missing_imports))
+			deductions += missing_imports.size()
 
 		checks["resources"] = {
 			"name": "Resources",

package/build/keeper.js

@@ -1668,6 +1668,7 @@ function emptyRecord() {
 // src/project-scan.ts
 var SKIPPED = new Set(["node_modules"]);
 var SCENE_EXTENSIONS = new Set(["tscn", "scn"]);
+var SIDECAR_EXTENSIONS = new Set(["import", "uid"]);
 var ASSET_EXTENSIONS = new Set([
   "png",
   "jpg",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdharness",
-  "version": "1.3.7",
+  "version": "1.3.8",
   "mcpName": "io.github.Aureliolo/gdharness",
   "description": "A harness for driving a Godot 4 project from an agent: editor addons, a runtime bridge into the running game, an MCP server in front of them, and a CLI that installs and diagnoses the Godot side.",
   "type": "module",