gdharness 1.3.0 → 1.3.1

package/build/godot/operations/gdscript_authoring.gd

@@ -1,16 +1,16 @@
 extends RefCounted
 
-const Read = preload("reading.gd")
-const Log = preload("logger.gd")
-const Patterns = preload("patterns.gd")
+const GdhRead = preload("reading.gd")
+const GdhLog = preload("logger.gd")
+const GdhPatterns = preload("patterns.gd")
 
 const MODIFICATION_TYPES: Array[String] = ["add_constant", "add_variable", "add_signal", "add_function"]
 const BLANKS_AROUND_FUNCTIONS: int = 2
 
-var _log: Log
+var _log: GdhLog
 
 
-func _init(p_log: Log) -> void:
+func _init(p_log: GdhLog) -> void:
 	_log = p_log
 
 
@@ -231,14 +231,14 @@ static func _modification_problems(modifications: Array, declared: Dictionary) -
 # one: variables, constants, signals, functions, enums and inner classes, which share one namespace.
 static func _declared(lines: Array[String]) -> Dictionary:
 	var found: Dictionary = {}
-	var declaration: RegEx = Patterns.compiled(
+	var declaration: RegEx = GdhPatterns.compiled(
 		"^(?:static\\s+)?(var|const|signal|func|enum|class)\\s+([A-Za-z_][A-Za-z0-9_]*)"
 	)
 	for i: int in range(lines.size()):
 		var raw: String = lines[i]
 		if raw.is_empty() or raw[0] == "\t" or raw[0] == " ":
 			continue
-		var matched: RegExMatch = declaration.search(Patterns.without_annotations(raw))
+		var matched: RegExMatch = declaration.search(GdhPatterns.without_annotations(raw))
 		if matched != null and not found.has(matched.get_string(2)):
 			found[matched.get_string(2)] = {"kind": matched.get_string(1), "line": i + 1}
 	return found
@@ -286,7 +286,7 @@ func _add_constant(lines: Array[String], mod: Dictionary, placed: Array[Dictiona
 	var const_line: String = "const %s: %s = %s" % [str(mod.get("name", "")), declared_type, value]
 	var after: int = 0
 	for i: int in range(lines.size()):
-		var line: String = Patterns.without_annotations(lines[i])
+		var line: String = GdhPatterns.without_annotations(lines[i])
 		if (
 			line.begins_with("extends ")
 			or line.begins_with("class_name ")
@@ -310,9 +310,9 @@ func _add_variable(lines: Array[String], mod: Dictionary, placed: Array[Dictiona
 	var var_name: String = str(mod.get("name", ""))
 	var var_type: String = str(mod.get("varType", ""))
 	var default_value: String = str(mod.get("defaultValue", ""))
-	var is_export: bool = Read.as_bool(mod.get("isExport", false))
+	var is_export: bool = GdhRead.as_bool(mod.get("isExport", false))
 	var export_hint: String = str(mod.get("exportHint", ""))
-	var is_onready: bool = Read.as_bool(mod.get("isOnready", false))
+	var is_onready: bool = GdhRead.as_bool(mod.get("isOnready", false))
 
 	var var_line: String = ""
 
@@ -433,7 +433,7 @@ func _variable_insertion_point(lines: Array[String]) -> int:
 		# takes the new line above the `class_name`, where it does not parse; one that declares
 		# `extends` first takes it between the two, which does not parse either. Stripping also
 		# turns `@export var x` into `var x`, which is why the annotation names are gone below.
-		var line: String = Patterns.without_annotations(lines[i])
+		var line: String = GdhPatterns.without_annotations(lines[i])
 		if line.begins_with("extends ") or line.begins_with("class_name "):
 			after_header = i + 1
 		elif line.begins_with("signal "):
@@ -443,7 +443,7 @@ func _variable_insertion_point(lines: Array[String]) -> int:
 			break
 
 	for i: int in range(after_header, before_func):
-		if Patterns.without_annotations(lines[i]).begins_with("var "):
+		if GdhPatterns.without_annotations(lines[i]).begins_with("var "):
 			after_header = i + 1
 
 	return after_header
@@ -455,7 +455,7 @@ func _signal_insertion_point(lines: Array[String]) -> int:
 	for i: int in range(lines.size()):
 		# As above: the annotations come off before the line is read, so an abstract class has a
 		# header to find and `@export var x` reads as the var it is.
-		var line: String = Patterns.without_annotations(lines[i])
+		var line: String = GdhPatterns.without_annotations(lines[i])
 		if line.begins_with("extends ") or line.begins_with("class_name "):
 			after_header = i + 1
 		elif line.begins_with("signal "):
@@ -485,7 +485,7 @@ func _line_after_function(lines: Array[String], prefix: String) -> int:
 		# ends of this. An annotated `_ready` was never found, so `after_ready` placed the new
 		# function at the end of the file, and an annotated function after `_ready` was not the
 		# boundary it is, so the new one went in after whichever later function was plain.
-		var line: String = Patterns.without_annotations(lines[i])
+		var line: String = GdhPatterns.without_annotations(lines[i])
 		if line.begins_with(prefix):
 			inside = true
 		elif inside and (line.begins_with("func ") or line.begins_with("static func ")):
@@ -502,7 +502,9 @@ static func _start_of_declaration(lines: Array[String], at: int) -> int:
 	var start: int = at
 	while start > 0 and _indentation(lines[start - 1]) == indent:
 		var above: String = lines[start - 1].strip_edges()
-		var annotation_only: bool = above.begins_with("@") and Patterns.without_annotations(above).is_empty()
+		var annotation_only: bool = (
+			above.begins_with("@") and GdhPatterns.without_annotations(above).is_empty()
+		)
 		if not above.begins_with("#") and not annotation_only:
 			break
 		start -= 1

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,83 @@ 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)
 
 		# 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,10 @@
 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 GdhExportPresets = preload("export_presets.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 +53,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(
 		(
@@ -203,7 +203,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 +323,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 +355,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 +382,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(
@@ -611,8 +611,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 +697,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 +850,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,7 +108,7 @@ 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)
 	_log.debug("Events: " + JSON.stringify(events))
@@ -192,12 +192,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))
 
@@ -250,7 +250,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 +273,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)
 
 			_:

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()