gdharness 1.3.0 → 1.3.2

package/build/godot/operations/godot_operations.gd

@@ -14,25 +14,25 @@ extends SceneTree
 # the operations directory ships inside the server package and is handed to the engine as an
 # absolute path outside the project. A res:// path would only resolve in the test fixture.
 
-const AnimationReads = preload("animation_reads.gd")
-const AudioBuses = preload("audio_buses.gd")
-const ClassCache = preload("class_cache.gd")
-const ClassDbQueries = preload("classdb_queries.gd")
-const Dependencies = preload("dependencies.gd")
-const ExportPresets = preload("export_presets.gd")
-const FileReads = preload("file_reads.gd")
-const GdscriptAnalysis = preload("gdscript_analysis.gd")
-const GdscriptAuthoring = preload("gdscript_authoring.gd")
-const ImportPipeline = preload("import_pipeline.gd")
-const InputActions = preload("input_actions.gd")
-const Log = preload("logger.gd")
-const Plugins = preload("plugins.gd")
-const ProjectConfig = preload("project_config.gd")
-const ProjectDiagnostics = preload("project_diagnostics.gd")
-const Read = preload("reading.gd")
-const RenameChecks = preload("rename_checks.gd")
-const ResourceFiles = preload("resource_files.gd")
-const ScriptCheck = preload("script_check.gd")
+const GdhAnimationReads = preload("animation_reads.gd")
+const GdhAudioBuses = preload("audio_buses.gd")
+const GdhClassCache = preload("class_cache.gd")
+const GdhClassDbQueries = preload("classdb_queries.gd")
+const GdhDependencies = preload("dependencies.gd")
+const GdhExportPresets = preload("export_presets.gd")
+const GdhFileReads = preload("file_reads.gd")
+const GdhGdscriptAnalysis = preload("gdscript_analysis.gd")
+const GdhGdscriptAuthoring = preload("gdscript_authoring.gd")
+const GdhImportPipeline = preload("import_pipeline.gd")
+const GdhInputActions = preload("input_actions.gd")
+const GdhLog = preload("logger.gd")
+const GdhPlugins = preload("plugins.gd")
+const GdhProjectConfig = preload("project_config.gd")
+const GdhProjectDiagnostics = preload("project_diagnostics.gd")
+const GdhRead = preload("reading.gd")
+const GdhRenameChecks = preload("rename_checks.gd")
+const GdhResourceFiles = preload("resource_files.gd")
+const GdhScriptCheck = preload("script_check.gd")
 
 ## Printed once the answer is written, after which the engine runs the project's autoloads. Kept in
 ## step with `ANSWERED` in src/headless.ts.
@@ -59,12 +59,12 @@ const AFTER_THE_AUTOLOADS: Array[String] = [
 	"run_editor_tool",
 ]
 
-var _log: Log
+var _log: GdhLog
 
 
 func _init() -> void:
 	var args: PackedStringArray = OS.get_cmdline_args()
-	_log = Log.new("--debug-godot" in args)
+	_log = GdhLog.new("--debug-godot" in args)
 
 	# The script path is the argument after --script, so the operation and its parameters are
 	# the two that follow it.
@@ -180,26 +180,27 @@ func _run(operation: String, params: Dictionary) -> Dictionary:
 	match operation:
 		# Resource files
 		"get_uid":
-			payload = ResourceFiles.new(_log).get_uid(params)
+			payload = GdhResourceFiles.new(_log).get_uid(params)
 		"refresh_class_cache":
-			payload = ClassCache.new(_log).refresh_class_cache(params)
+			payload = GdhClassCache.new(_log).refresh_class_cache(params)
 		"read_scene_tree":
 			payload = _read(
-				FileReads.scene_tree(
+				GdhFileReads.scene_tree(
 					str(params.get("scene_path", "")),
-					Read.as_int(params.get("depth", -1), -1),
-					Read.as_bool(params.get("include_properties", false))
+					GdhRead.as_int(params.get("depth", -1), -1),
+					GdhRead.as_bool(params.get("include_properties", false))
 				)
 			)
 		"read_resource":
 			payload = _read(
-				FileReads.resource(
-					str(params.get("resource_path", "")), Read.as_bool(params.get("include_defaults", false))
+				GdhFileReads.resource(
+					str(params.get("resource_path", "")),
+					GdhRead.as_bool(params.get("include_defaults", false))
 				)
 			)
 		"read_animations":
 			payload = _read(
-				AnimationReads.scene_animations(
+				GdhAnimationReads.scene_animations(
 					str(params.get("scene_path", "")),
 					str(params.get("player_node_path", ".")),
 					str(params.get("animation_name", ""))
@@ -207,7 +208,7 @@ func _run(operation: String, params: Dictionary) -> Dictionary:
 			)
 		"read_animation_states":
 			payload = _read(
-				AnimationReads.scene_states(
+				GdhAnimationReads.scene_states(
 					str(params.get("scene_path", "")),
 					str(params.get("anim_tree_path", "")),
 					str(params.get("state_machine_path", ""))
@@ -219,83 +220,85 @@ func _run(operation: String, params: Dictionary) -> Dictionary:
 
 		# Import and export pipeline
 		"get_import_status":
-			payload = ImportPipeline.new(_log).get_import_status(params)
+			payload = GdhImportPipeline.new(_log).get_import_status(params)
 		"get_import_options":
-			payload = ImportPipeline.new(_log).get_import_options(params)
+			payload = GdhImportPipeline.new(_log).get_import_options(params)
 		"set_import_options":
-			payload = ImportPipeline.new(_log).set_import_options(params)
+			payload = GdhImportPipeline.new(_log).set_import_options(params)
 		"list_export_presets":
-			payload = ExportPresets.new(_log).list_export_presets(params)
+			payload = GdhExportPresets.new(_log).list_export_presets(params)
 		"add_export_preset":
-			payload = ExportPresets.new(_log).add_export_preset(params)
+			payload = GdhExportPresets.new(_log).add_export_preset(params)
 		"validate_project":
-			payload = ImportPipeline.new(_log).validate_project(params)
+			payload = GdhImportPipeline.new(_log).validate_project(params)
 
 		# Dependencies and project inspection
 		"get_dependencies":
-			payload = Dependencies.new(_log).get_dependencies(params)
+			payload = GdhDependencies.new(_log).get_dependencies(params)
 		"find_resource_usages":
-			payload = Dependencies.new(_log).find_resource_usages(params)
+			payload = GdhDependencies.new(_log).find_resource_usages(params)
 		"get_project_health":
-			payload = ProjectDiagnostics.new(_log).get_project_health(params)
+			payload = GdhProjectDiagnostics.new(_log).get_project_health(params)
 
 		# project.godot
 		"get_project_setting":
-			payload = ProjectConfig.new(_log).get_project_setting(params)
+			payload = GdhProjectConfig.new(_log).get_project_setting(params)
 		"set_project_setting":
-			payload = ProjectConfig.new(_log).set_project_setting(params)
+			payload = GdhProjectConfig.new(_log).set_project_setting(params)
 		"add_autoload":
-			payload = ProjectConfig.new(_log).add_autoload(params)
+			payload = GdhProjectConfig.new(_log).add_autoload(params)
 		"remove_autoload":
-			payload = ProjectConfig.new(_log).remove_autoload(params)
+			payload = GdhProjectConfig.new(_log).remove_autoload(params)
 		"list_autoloads":
-			payload = ProjectConfig.new(_log).list_autoloads(params)
+			payload = GdhProjectConfig.new(_log).list_autoloads(params)
 		"set_main_scene":
-			payload = ProjectConfig.new(_log).set_main_scene(params)
+			payload = GdhProjectConfig.new(_log).set_main_scene(params)
 
 		# GDScript files
 		"create_script":
-			payload = GdscriptAuthoring.new(_log).create_gdscript(params)
+			payload = GdhGdscriptAuthoring.new(_log).create_gdscript(params)
 		"modify_script":
-			payload = GdscriptAuthoring.new(_log).modify_gdscript(params)
+			payload = GdhGdscriptAuthoring.new(_log).modify_gdscript(params)
 		"get_script_info":
-			payload = GdscriptAnalysis.new(_log).get_gdscript_info(params)
+			payload = GdhGdscriptAnalysis.new(_log).get_gdscript_info(params)
 		"names_taken":
-			payload = RenameChecks.new(_log).names_taken(params)
+			payload = GdhRenameChecks.new(_log).names_taken(params)
 		"check_scripts":
-			payload = ScriptCheck.new(_log).check_scripts(params)
+			payload = GdhScriptCheck.new(_log).check_scripts(params)
 
 		# Plugins and input
 		"list_plugins":
-			payload = Plugins.new(_log).list_plugins(params)
+			payload = GdhPlugins.new(_log).list_plugins(params)
 		"enable_plugin":
-			payload = Plugins.new(_log).enable_plugin(params)
+			payload = GdhPlugins.new(_log).enable_plugin(params)
 		"disable_plugin":
-			payload = Plugins.new(_log).disable_plugin(params)
+			payload = GdhPlugins.new(_log).disable_plugin(params)
 		"add_input_action":
-			payload = InputActions.new(_log).add_input_action(params)
+			payload = GdhInputActions.new(_log).add_input_action(params)
 		"remove_input_action":
-			payload = InputActions.new(_log).remove_input_action(params)
+			payload = GdhInputActions.new(_log).remove_input_action(params)
+		"list_input_actions":
+			payload = GdhInputActions.new(_log).list_input_actions(params)
 
 		# Audio
 		"create_audio_bus":
-			payload = AudioBuses.new(_log).create_audio_bus(params)
+			payload = GdhAudioBuses.new(_log).create_audio_bus(params)
 		"remove_audio_bus":
-			payload = AudioBuses.new(_log).remove_audio_bus(params)
+			payload = GdhAudioBuses.new(_log).remove_audio_bus(params)
 		"get_audio_buses":
-			payload = AudioBuses.new(_log).get_audio_buses(params)
+			payload = GdhAudioBuses.new(_log).get_audio_buses(params)
 		"set_audio_bus_effect":
-			payload = AudioBuses.new(_log).set_audio_bus_effect(params)
+			payload = GdhAudioBuses.new(_log).set_audio_bus_effect(params)
 		"set_audio_bus_volume":
-			payload = AudioBuses.new(_log).set_audio_bus_volume(params)
+			payload = GdhAudioBuses.new(_log).set_audio_bus_volume(params)
 
 		# ClassDB
 		"query_classes":
-			payload = ClassDbQueries.new(_log).query_classes(params)
+			payload = GdhClassDbQueries.new(_log).query_classes(params)
 		"query_class_info":
-			payload = ClassDbQueries.new(_log).query_class_info(params)
+			payload = GdhClassDbQueries.new(_log).query_class_info(params)
 		"inspect_inheritance":
-			payload = ClassDbQueries.new(_log).inspect_inheritance(params)
+			payload = GdhClassDbQueries.new(_log).inspect_inheritance(params)
 
 		_:
 			_log.error("Unknown operation: " + operation)

package/build/godot/operations/import_pipeline.gd

@@ -1,10 +1,12 @@
 extends RefCounted
 
-const ExportPresets = preload("export_presets.gd")
-const Read = preload("reading.gd")
-const Serialisation = preload("serialisation.gd")
-const FileWalk = preload("file_walk.gd")
-const Log = preload("logger.gd")
+const GdhDependencies = preload("dependencies.gd")
+const GdhExportPresets = preload("export_presets.gd")
+const GdhScriptCheck = preload("script_check.gd")
+const GdhRead = preload("reading.gd")
+const GdhSerialisation = preload("serialisation.gd")
+const GdhFileWalk = preload("file_walk.gd")
+const GdhLog = preload("logger.gd")
 
 ## What the engine imports with no tool outside it, for finding what has not been imported yet;
 ## everything imported already is found by its sidecar whatever its extension.
@@ -53,20 +55,20 @@ const OPENTYPE_OPTIONS: Dictionary[String, Array] = {"font_data_dynamic": ["open
 const EDITOR_DIRECTORY: String = "res://.godot/editor"
 const EDITOR_CACHE_PREFIX: String = "filesystem_cache"
 
-var _log: Log
-var _files: FileWalk = FileWalk.new()
-var _values: Serialisation = Serialisation.new()
+var _log: GdhLog
+var _files: GdhFileWalk = GdhFileWalk.new()
+var _values: GdhSerialisation = GdhSerialisation.new()
 var _sidecar_md5s: Variant = null
 
 
-func _init(p_log: Log) -> void:
+func _init(p_log: GdhLog) -> void:
 	_log = p_log
 
 
 # Get import status for resources
 func get_import_status(params: Dictionary) -> Dictionary:
 	var resource_path: String = str(params.get("resource_path", ""))
-	var include_up_to_date: bool = Read.as_bool(params.get("include_up_to_date", false))
+	var include_up_to_date: bool = GdhRead.as_bool(params.get("include_up_to_date", false))
 
 	_log.info(
 		(
@@ -85,6 +87,14 @@ func get_import_status(params: Dictionary) -> Dictionary:
 		if not full_path.begins_with("res://"):
 			full_path = "res://" + full_path
 
+		# missing_source is a sidecar whose source has gone; with neither, the path names nothing the
+		# engine ever imported, and answering it as a lost source sent a caller to restore a file.
+		if not FileAccess.file_exists(full_path) and not FileAccess.file_exists(full_path + ".import"):
+			return _log.failure(
+				_files.with_nearest_files(
+					"Nothing is at %s, and no import sidecar names it" % full_path, full_path
+				)
+			)
 		var status: Dictionary = _import_status_of(full_path, full_path + ".import")
 		resources.append(status)
 		_tally(summary, status)
@@ -203,7 +213,7 @@ func set_import_options(params: Dictionary) -> Dictionary:
 			and (value is int or value is float)
 			and type_convert(value, typeof(given)) != given
 		)
-		if held != null and (lossy or not Serialisation.acceptable(value, typeof(held))):
+		if held != null and (lossy or not GdhSerialisation.acceptable(value, typeof(held))):
 			var held_type: String = type_string(typeof(held))
 			var article: String = "an" if held_type.to_lower()[0] in "aeiou" else "a"
 			refused.append(
@@ -323,7 +333,7 @@ static func _all_ints(held: Variant, keys: bool) -> bool:
 # Validate project for export
 func validate_project(params: Dictionary) -> Dictionary:
 	var preset_name: String = str(params.get("preset", ""))
-	var include_suggestions: bool = Read.as_bool(params.get("include_suggestions", true), true)
+	var include_suggestions: bool = GdhRead.as_bool(params.get("include_suggestions", true), true)
 
 	_log.info("Validating project" + (" for preset: " + preset_name if not preset_name.is_empty() else ""))
 
@@ -355,12 +365,12 @@ func validate_project(params: Dictionary) -> Dictionary:
 				include_suggestions
 			)
 		)
-	elif not FileWalk.missing_reason(main_scene).is_empty():
+	elif not GdhFileWalk.missing_reason(main_scene).is_empty():
 		issues.append(
 			_finding(
 				"error",
 				"main_scene",
-				"Main scene " + FileWalk.missing_reason(main_scene),
+				"Main scene " + GdhFileWalk.missing_reason(main_scene),
 				"Update the main scene setting or create the missing scene file",
 				include_suggestions
 			)
@@ -382,7 +392,7 @@ func validate_project(params: Dictionary) -> Dictionary:
 	# does not exist answered valid, as though it had been checked.
 	if not preset_name.is_empty():
 		checks_performed.append("export_preset")
-		var named: Array[String] = ExportPresets.names()
+		var named: Array[String] = GdhExportPresets.names()
 		if preset_name not in named:
 			issues.append(
 				_finding(
@@ -457,6 +467,35 @@ func validate_project(params: Dictionary) -> Dictionary:
 			if "pass # TODO" in content:
 				script_issues.append({"path": script_path, "issue": "Contains unimplemented functions"})
 
+	# Compiled by the server and handed in, as for the health check: a script the engine refuses
+	# stops the export's game at the first scene using it, which the comment check above never saw.
+	var compiled: Dictionary = params.get("compiled", {})
+	if compiled.has("checked"):
+		checks_performed.append("compiles")
+	var failures: Array = compiled.get("failures", [])
+	for failure: Dictionary in failures:
+		issues.append(
+			_finding(
+				"error",
+				"compiles",
+				GdhScriptCheck.failure_line(failure),
+				"script_diagnostics gives every error in it with its line",
+				include_suggestions
+			)
+		)
+
+	checks_performed.append("references")
+	for entry: Dictionary in GdhDependencies.new(_log).missing_references():
+		issues.append(
+			_finding(
+				"error",
+				"references",
+				GdhDependencies.missing_line(entry),
+				"Restore the file, or point the reference at the file that replaced it",
+				include_suggestions
+			)
+		)
+
 	if script_issues.size() > 0:
 		var warning: Dictionary = _finding(
 			"warning",
@@ -611,8 +650,8 @@ static func _import_staleness(resource_path: String, sidecar: ConfigFile) -> Dic
 	# imported them again: every scene after an engine upgrade raised the importer's version, and
 	# every VRAM texture once the project asked for another compression format.
 	var importer: String = str(sidecar.get_value("remap", "importer", ""))
-	var version: int = Read.as_int(sidecar.get_value("remap", "importer_version", 0))
-	var current: int = Read.as_int(IMPORTER_VERSIONS.get(importer, 0))
+	var version: int = GdhRead.as_int(sidecar.get_value("remap", "importer_version", 0))
+	var current: int = GdhRead.as_int(IMPORTER_VERSIONS.get(importer, 0))
 	if current > version:
 		return _stale(
 			(
@@ -697,12 +736,12 @@ static func _vram_formats_lacking(metadata: Variant) -> Array[String]:
 	if not metadata is Dictionary:
 		return lacking
 	var meta: Dictionary = metadata
-	if not Read.as_bool(meta.get("vram_texture", false)):
+	if not GdhRead.as_bool(meta.get("vram_texture", false)):
 		return lacking
 	var written: Variant = meta.get("imported_formats", [])
 	var formats: Array = written if written is Array else []
 	for format: String in VRAM_FORMATS:
-		var asked: bool = Read.as_bool(
+		var asked: bool = GdhRead.as_bool(
 			ProjectSettings.get_setting("rendering/textures/vram_compression/import_" + format, false)
 		)
 		if asked and format not in formats:
@@ -850,7 +889,7 @@ static func _images_of(scene_path: String) -> Array[String]:
 				text = bytes.slice(20, mini(20 + length, bytes.size())).get_string_from_utf8()
 	if text.is_empty():
 		return images
-	var parsed: Variant = Read.json_or_null(text)
+	var parsed: Variant = GdhRead.json_or_null(text)
 	if not parsed is Dictionary:
 		return images
 	var document: Dictionary = parsed

package/build/godot/operations/input_actions.gd

@@ -1,8 +1,8 @@
 extends RefCounted
 
-const Read = preload("reading.gd")
-const Log = preload("logger.gd")
-const ProjectFile = preload("project_file.gd")
+const GdhRead = preload("reading.gd")
+const GdhLog = preload("logger.gd")
+const GdhProjectFile = preload("project_file.gd")
 
 # The key names a caller may write, and what the engine calls them.
 const KEY_NAMES: Dictionary = {
@@ -97,10 +97,10 @@ const KEY_NAMES: Dictionary = {
 	"Equal": KEY_EQUAL,
 }
 
-var _log: Log
+var _log: GdhLog
 
 
-func _init(p_log: Log) -> void:
+func _init(p_log: GdhLog) -> void:
 	_log = p_log
 
 
@@ -108,9 +108,27 @@ func _init(p_log: Log) -> void:
 func add_input_action(params: Dictionary) -> Dictionary:
 	var action_name: String = str(params.get("action_name", ""))
 	var events: Array = params.get("events", [])
-	var deadzone: float = Read.as_float(params.get("deadzone", 0.5), 0.5)
+	var deadzone: float = GdhRead.as_float(params.get("deadzone", 0.5), 0.5)
 
 	_log.info("Adding input action: " + action_name)
+	# The editor's Input Map refuses these, since project.godot keys an action by its name and
+	# the characters below are its own syntax there; a name holding one is written escaped and
+	# reads back as a name nobody typed.
+	for index: int in action_name.length():
+		var code: int = action_name.unicode_at(index)
+		if code < 32 or action_name[index] in ["/", ":", "=", "\\", '"']:
+			return (
+				_log
+				. failure(
+					(
+						(
+							"%s is not an action name the engine's Input Map takes: a name cannot hold / : = \\ "
+							+ "or a double quote, or a control character. jump, move_left or ui_menu are names it takes."
+						)
+						% JSON.stringify(action_name)
+					)
+				)
+			)
 	_log.debug("Events: " + JSON.stringify(events))
 	_log.debug("Deadzone: " + str(deadzone))
 
@@ -130,7 +148,7 @@ func add_input_action(params: Dictionary) -> Dictionary:
 					return _log.failure("A key event needs keycode")
 				var key_value: int = _keycode_value(keycode)
 				if key_value == KEY_NONE:
-					return _log.failure("Unknown key: " + keycode)
+					return _log.failure(_unknown_key(keycode))
 
 				var event_config: Dictionary = {"class_name": "InputEventKey", "keycode": key_value}
 				if fields.get("ctrl", false):
@@ -192,12 +210,12 @@ func add_input_action(params: Dictionary) -> Dictionary:
 					var bound: InputEvent = event
 					old_events.append(_shaped(bound))
 		answer["old_events"] = old_events
-		answer["old_deadzone"] = Read.as_float(old.get("deadzone", 0.5), 0.5)
+		answer["old_deadzone"] = GdhRead.as_float(old.get("deadzone", 0.5), 0.5)
 
 	# Through ProjectSettings so the file is saved the way the editor saves it, header and
 	# every other line kept; a ConfigFile of project.godot drops the comments on the way out.
 	ProjectSettings.set_setting(setting, action)
-	var err: Error = ProjectFile.save()
+	var err: Error = GdhProjectFile.save()
 	if err != OK:
 		return _log.failure("Failed to save project.godot: " + error_string(err))
 
@@ -229,6 +247,42 @@ static func _shaped(event: InputEvent) -> Dictionary:
 	return shaped
 
 
+## The input actions project.godot holds, each with its deadzone and events in the form
+## add_input_action answers with. An engine ui_ action is listed only when the project rebinds it,
+## as engineAction, since the engine's own eighty are there in every project.
+func list_input_actions(_params: Dictionary) -> Dictionary:
+	var actions: Array[Dictionary] = []
+	for info: Dictionary in ProjectSettings.get_property_list():
+		var setting: String = str(info.get("name", ""))
+		if not setting.begins_with("input/"):
+			continue
+		var engine_default: Variant = ProjectSettings.property_get_revert(setting)
+		var held: Variant = ProjectSettings.get_setting(setting)
+		if engine_default != null and held == engine_default:
+			continue
+		var action: Dictionary = held if held is Dictionary else {}
+		var events: Array[Dictionary] = []
+		var listed: Variant = action.get("events", [])
+		if listed is Array:
+			var bound: Array = listed
+			for event: Variant in bound:
+				if event is InputEvent:
+					var shaped: InputEvent = event
+					events.append(_shaped(shaped))
+		(
+			actions
+			. append(
+				{
+					"name": setting.trim_prefix("input/"),
+					"deadzone": GdhRead.as_float(action.get("deadzone", 0.5), 0.5),
+					"events": events,
+					"engineAction": engine_default != null,
+				}
+			)
+		)
+	return {"actions": actions, "count": actions.size()}
+
+
 # Remove an input action the project defines, which add_input_action had no way back from.
 func remove_input_action(params: Dictionary) -> Dictionary:
 	var action_name: String = str(params.get("action_name", ""))
@@ -250,7 +304,7 @@ func remove_input_action(params: Dictionary) -> Dictionary:
 			)
 		)
 	ProjectSettings.set_setting(setting, null)
-	var err: Error = ProjectFile.save()
+	var err: Error = GdhProjectFile.save()
 	if err != OK:
 		return _log.failure("Failed to save project.godot: " + error_string(err))
 	return {"action_name": action_name, "removed": true}
@@ -273,29 +327,29 @@ func build_input_action(deadzone: float, events: Array) -> Dictionary:
 		match evt_class:
 			"InputEventKey":
 				var key: InputEventKey = InputEventKey.new()
-				key.keycode = Read.as_int(event.get("keycode", 0)) as Key
-				key.ctrl_pressed = Read.as_bool(event.get("ctrl_pressed", false))
-				key.alt_pressed = Read.as_bool(event.get("alt_pressed", false))
-				key.shift_pressed = Read.as_bool(event.get("shift_pressed", false))
+				key.keycode = GdhRead.as_int(event.get("keycode", 0)) as Key
+				key.ctrl_pressed = GdhRead.as_bool(event.get("ctrl_pressed", false))
+				key.alt_pressed = GdhRead.as_bool(event.get("alt_pressed", false))
+				key.shift_pressed = GdhRead.as_bool(event.get("shift_pressed", false))
 				built.append(key)
 
 			"InputEventMouseButton":
 				var mouse: InputEventMouseButton = InputEventMouseButton.new()
 				mouse.button_index = (
-					Read.as_int(event.get("button_index", MOUSE_BUTTON_LEFT), MOUSE_BUTTON_LEFT)
+					GdhRead.as_int(event.get("button_index", MOUSE_BUTTON_LEFT), MOUSE_BUTTON_LEFT)
 					as MouseButton
 				)
 				built.append(mouse)
 
 			"InputEventJoypadButton":
 				var pad: InputEventJoypadButton = InputEventJoypadButton.new()
-				pad.button_index = Read.as_int(event.get("button_index", 0)) as JoyButton
+				pad.button_index = GdhRead.as_int(event.get("button_index", 0)) as JoyButton
 				built.append(pad)
 
 			"InputEventJoypadMotion":
 				var motion: InputEventJoypadMotion = InputEventJoypadMotion.new()
-				motion.axis = Read.as_int(event.get("axis", 0)) as JoyAxis
-				motion.axis_value = Read.as_float(event.get("axis_value", 1.0), 1.0)
+				motion.axis = GdhRead.as_int(event.get("axis", 0)) as JoyAxis
+				motion.axis_value = GdhRead.as_float(event.get("axis_value", 1.0), 1.0)
 				built.append(motion)
 
 			_:
@@ -305,6 +359,24 @@ func build_input_action(deadzone: float, events: Array) -> Dictionary:
 
 
 # The keycode for a key name as the tool spells it, or KEY_NONE for a name the table lacks.
+## The refusal for [param key_name], which names no key: the names nearest it, then every name taken,
+## since a name the caller has to guess at is the same guess again.
+static func _unknown_key(key_name: String) -> String:
+	var every: PackedStringArray = []
+	var named: PackedStringArray = []
+	for name: String in KEY_NAMES:
+		var _every: bool = every.append(name)
+		if name.length() > 1 and not (name.begins_with("F") and name.substr(1).is_valid_int()):
+			var _named: bool = named.append(name)
+	var nearest: PackedStringArray = GdhRead.nearest(key_name, every)
+	var said: String = "Unknown key: %s." % key_name
+	if nearest.size() == 1:
+		said += " The nearest key name is %s." % nearest[0]
+	elif not nearest.is_empty():
+		said += " The nearest key names are %s." % ", ".join(nearest)
+	return said + " A key is named by its letter, its digit, F1 to F12, or one of: %s." % ", ".join(named)
+
+
 func _keycode_value(key_name: String) -> int:
 	var wanted: String = key_name.to_lower()
 	for name: String in KEY_NAMES:

package/build/godot/operations/logger.gd

@@ -3,7 +3,7 @@ extends RefCounted
 # Everything printed is diagnostics; the answer goes to a file. The server reads `[ERROR]` lines as
 # the operation's own errors, and the prefixes let a human read the rest without parsing it.
 #
-# Every module preloads this as `Log`. `Logger` is a native class from Godot 4.5 on, and a
+# Every module preloads this as `GdhLog`. `Logger` is a native class from Godot 4.5 on, and a
 # constant of that name is a parse error rather than a shadowing warning.
 
 var debug_mode: bool = false

package/build/godot/operations/plugins.gd

@@ -1,13 +1,13 @@
 extends RefCounted
 
-const Patterns = preload("patterns.gd")
-const Log = preload("logger.gd")
-const ProjectFile = preload("project_file.gd")
+const GdhPatterns = preload("patterns.gd")
+const GdhLog = preload("logger.gd")
+const GdhProjectFile = preload("project_file.gd")
 
-var _log: Log
+var _log: GdhLog
 
 
-func _init(p_log: Log) -> void:
+func _init(p_log: GdhLog) -> void:
 	_log = p_log
 
 
@@ -148,7 +148,7 @@ func _enabled_paths() -> Array[String]:
 		paths.assign(packed)
 	elif enabled_value is String:
 		var listed: String = enabled_value
-		for m: RegExMatch in Patterns.compiled("res://[^\"',)]+?plugin\\.cfg").search_all(listed):
+		for m: RegExMatch in GdhPatterns.compiled("res://[^\"',)]+?plugin\\.cfg").search_all(listed):
 			paths.append(m.get_string())
 	return paths
 
@@ -172,11 +172,11 @@ static func _names_of(paths: Array[String]) -> Array[String]:
 func _save_enabled_paths(paths: Array[String]) -> Error:
 	if paths.is_empty():
 		ProjectSettings.set_setting("editor_plugins/enabled", null)
-		return ProjectFile.save()
+		return GdhProjectFile.save()
 
 	# Kept in an Array[String] and converted here, because appending to a packed array answers with
 	# whether it worked and a project holding return_value_discarded at error level will not compile
 	# a script that drops that answer. The conversion is what matters: an Array[String] handed to
 	# set_setting is written as Array[String]([...]), which the editor does not read as a plugin list.
 	ProjectSettings.set_setting("editor_plugins/enabled", PackedStringArray(paths))
-	return ProjectFile.save()
+	return GdhProjectFile.save()