gdharness 1.3.7 → 1.3.9

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/editor_tools.gd

@@ -7,6 +7,7 @@ extends RefCounted
 ## made here passes the same checks and answers in the same shape. What the engine does that an
 ## editor does not, running every script, is put back in scene_file.gd and headless_check.gd.
 
+const GdhAnimationStates = preload("../addons/gdharness_editor/tools/animation_states.gd")
 const GdhAnimationTools = preload("../addons/gdharness_editor/tools/animation_tools.gd")
 const GdhResourceTools = preload("../addons/gdharness_editor/tools/resource_tools.gd")
 const GdhSceneTools = preload("../addons/gdharness_editor/tools/scene_tools.gd")
@@ -36,11 +37,16 @@ const RESOURCE_COMMANDS: Array[String] = [
 const ANIMATION_COMMANDS: Array[String] = [
 	"create_animation",
 	"add_animation_track",
+	"remove_animation_track",
 	"set_animation",
 	"rename_animation",
 	"remove_animation",
+]
+const ANIMATION_STATE_COMMANDS: Array[String] = [
 	"add_animation_state",
 	"connect_animation_states",
+	"remove_animation_state",
+	"disconnect_animation_states",
 ]
 
 
@@ -60,6 +66,8 @@ static func run(params: Dictionary) -> Dictionary:
 		tools = GdhResourceTools.new()
 	elif command in ANIMATION_COMMANDS:
 		tools = GdhAnimationTools.new()
+	elif command in ANIMATION_STATE_COMMANDS:
+		tools = GdhAnimationStates.new()
 	else:
 		return {"ok": false, "error": "No editor tool runs headless as " + command}
 	var answer: Variant = tools.call(command, arguments)

package/build/godot/operations/file_reads.gd

@@ -119,6 +119,9 @@ static func _laid(scene_path: String) -> Dictionary:
 		return {"ok": false, "error": refused}
 	if not nodes.has("."):
 		return {"ok": false, "error": "%s holds no nodes" % scene_path}
+	var base: SceneState = packed.get_state().get_base_scene_state()
+	if base != null:
+		nodes["."]["inherits"] = base.get_path()
 	return {"ok": true, "nodes": nodes}
 
 
@@ -175,6 +178,10 @@ static func _lay(
 				nodes[path] = _made(str(state.get_node_type(index)))
 			if ids[index] >= 0:
 				nodes[path]["uniqueId"] = ids[index]
+			# Laid at the root with no scene handed in is a scene the one being read inherits, and the
+			# deepest is laid first, so this is the file that makes the node.
+			if prefix == "." and loaded == null:
+				nodes[path]["inheritedFrom"] = state.get_path()
 		# The name is the state's even for an entry laid already, since an inherited scene names its
 		# root itself; a root instanced inside another scene is renamed by that scene once laid.
 		if not recovered:
@@ -324,6 +331,12 @@ static func _entry(
 		data["instanceOf"] = node["instanceOf"]
 		if node.has("editableChildren"):
 			data["editableChildren"] = node["editableChildren"]
+	# An inherited scene's file holds only what it changes, so the read says what it inherits and
+	# which nodes come from there, as the editor greys them.
+	if node.has("inherits"):
+		data["inherits"] = node["inherits"]
+	elif node.has("inheritedFrom"):
+		data["inheritedFrom"] = node["inheritedFrom"]
 	var groups: Array[String] = node["groups"]
 	if not groups.is_empty():
 		var sorted: Array[String] = groups.duplicate()

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
@@ -58,6 +76,9 @@ func get_gdscript_info(params: Dictionary) -> Dictionary:
 	if not full_script_path.begins_with("res://"):
 		full_script_path = "res://" + full_script_path
 
+	# Read as GDScript, a scene came back as a script extending RefCounted with nothing in it.
+	if full_script_path.get_extension().to_lower() != "gd":
+		return _log.failure(_not_a_script(full_script_path))
 	if not FileAccess.file_exists(full_script_path):
 		return _log.failure(
 			GdhFileWalk.new().with_nearest_files(
@@ -130,6 +151,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 +166,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 +182,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 +250,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 +258,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
@@ -278,6 +337,17 @@ func _inner_class(
 	return body
 
 
+## The refusal for [param path], which is not a .gd file, with the tool that reads what it is.
+static func _not_a_script(path: String) -> String:
+	var said: String = "%s is not a GDScript file, and script_info reads .gd files only" % path
+	match path.get_extension().to_lower():
+		"tscn", "scn":
+			return said + ": scene_tree reads a scene's nodes, and with properties the script each carries."
+		"tres", "res":
+			return said + ": resource_edit read reads a resource."
+	return said + "."
+
+
 static func _indentation(line: String) -> String:
 	return line.substr(0, line.length() - line.strip_edges(true, false).length())
 

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
@@ -256,7 +259,7 @@ func modify_gdscript(params: Dictionary) -> Dictionary:
 			)
 		return _log.failure(
 			(
-				"Nothing was changed: %s parses as it is and would not with these additions: %s"
+				"Nothing was changed: %s parses now, and would not with these additions: %s"
 				% [script_path, _reasons(caught.raised, full_script_path)]
 			)
 		)

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)
 
@@ -245,6 +247,8 @@ func _run(operation: String, params: Dictionary) -> Dictionary:
 			payload = GdhProjectConfig.new(_log).get_project_setting(params)
 		"set_project_setting":
 			payload = GdhProjectConfig.new(_log).set_project_setting(params)
+		"unset_project_setting":
+			payload = GdhProjectConfig.new(_log).unset_project_setting(params)
 		"add_autoload":
 			payload = GdhProjectConfig.new(_log).add_autoload(params)
 		"remove_autoload":

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/input_actions.gd

@@ -3,6 +3,8 @@ extends RefCounted
 const GdhRead = preload("reading.gd")
 const GdhLog = preload("logger.gd")
 const GdhProjectFile = preload("project_file.gd")
+## The device an event matches every device with, InputMap's ALL_DEVICES, which GDScript is not given.
+const ALL_DEVICES: int = -1
 
 # The key names a caller may write, and what the engine calls them.
 const KEY_NAMES: Dictionary = {
@@ -108,7 +110,13 @@ func _init(p_log: GdhLog) -> 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 = GdhRead.as_float(params.get("deadzone", 0.5), 0.5)
+	var setting: String = "input/" + action_name
+	var held: Variant = ProjectSettings.get_setting(setting) if ProjectSettings.has_setting(setting) else null
+	var old: Dictionary = held if held is Dictionary else {}
+	var old_deadzone: float = GdhRead.as_float(old.get("deadzone", 0.5), 0.5)
+	# A rebind that names no deadzone keeps the one the action has, which a caller adding a key did
+	# not mean to change.
+	var deadzone: float = GdhRead.as_float(params.get("deadzone", old_deadzone), old_deadzone)
 
 	_log.info("Adding input action: " + action_name)
 	# The editor's Input Map refuses these, since project.godot keys an action by its name and
@@ -150,7 +158,9 @@ func add_input_action(params: Dictionary) -> Dictionary:
 				if key_value == KEY_NONE:
 					return _log.failure(_unknown_key(keycode))
 
-				var event_config: Dictionary = {"class_name": "InputEventKey", "keycode": key_value}
+				var event_config: Dictionary = {"class_name": "InputEventKey"}
+				var physical: bool = GdhRead.as_bool(fields.get("physical", false))
+				event_config["physical_keycode" if physical else "keycode"] = key_value
 				if fields.get("ctrl", false):
 					event_config["ctrl_pressed"] = true
 				if fields.get("alt", false):
@@ -190,7 +200,6 @@ func add_input_action(params: Dictionary) -> Dictionary:
 
 	# An action that exists is rebound, which is how one of the engine's ui_ actions is changed, so
 	# what it held is answered rather than lost without a word.
-	var setting: String = "input/" + action_name
 	var answer: Dictionary = {
 		"action_name": action_name,
 		"events_count": events_config.size(),
@@ -199,8 +208,6 @@ func add_input_action(params: Dictionary) -> Dictionary:
 		"was_new": not ProjectSettings.has_setting(setting),
 	}
 	if not answer["was_new"]:
-		var held: Variant = ProjectSettings.get_setting(setting)
-		var old: Dictionary = held if held is Dictionary else {}
 		var old_events: Array[Dictionary] = []
 		var listed: Variant = old.get("events", [])
 		if listed is Array:
@@ -210,7 +217,7 @@ func add_input_action(params: Dictionary) -> Dictionary:
 					var bound: InputEvent = event
 					old_events.append(_shaped(bound))
 		answer["old_events"] = old_events
-		answer["old_deadzone"] = GdhRead.as_float(old.get("deadzone", 0.5), 0.5)
+		answer["old_deadzone"] = old_deadzone
 
 	# 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.
@@ -226,9 +233,12 @@ func add_input_action(params: Dictionary) -> Dictionary:
 ## under text, which also covers a kind of event that form has no fields for.
 static func _shaped(event: InputEvent) -> Dictionary:
 	var shaped: Dictionary = {"class_name": event.get_class(), "text": event.as_text()}
+	if event.device != ALL_DEVICES:
+		shaped["device"] = event.device
 	if event is InputEventKey:
 		var key: InputEventKey = event
-		shaped["keycode"] = key.keycode
+		if key.keycode != KEY_NONE or key.physical_keycode == KEY_NONE:
+			shaped["keycode"] = key.keycode
 		if key.physical_keycode != KEY_NONE:
 			shaped["physical_keycode"] = key.physical_keycode
 		for modifier: String in ["ctrl_pressed", "alt_pressed", "shift_pressed"]:
@@ -328,6 +338,7 @@ func build_input_action(deadzone: float, events: Array) -> Dictionary:
 			"InputEventKey":
 				var key: InputEventKey = InputEventKey.new()
 				key.keycode = GdhRead.as_int(event.get("keycode", 0)) as Key
+				key.physical_keycode = GdhRead.as_int(event.get("physical_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))
@@ -354,6 +365,10 @@ func build_input_action(deadzone: float, events: Array) -> Dictionary:
 
 			_:
 				return _log.failure("Unknown input event class: " + evt_class)
+		# Every device, as the editor's Input Map binds an event: a new event names one device, and
+		# an action bound to it ignored a second joypad.
+		var bound: InputEvent = built.back()
+		bound.device = ALL_DEVICES
 
 	return {"deadzone": deadzone, "events": built}
 

package/build/godot/operations/project_config.gd

@@ -166,6 +166,37 @@ func set_project_setting(params: Dictionary) -> Dictionary:
 	return answer
 
 
+# Takes a setting's line out of project.godot, so the engine's default holds again, or nothing at all
+# for one the engine does not declare: the way back from a set, which writes a misspelt name as given.
+func unset_project_setting(params: Dictionary) -> Dictionary:
+	var setting_path: String = str(params.get("setting", ""))
+	if setting_path.is_empty():
+		return _log.failure("setting is required")
+	var default_value: Variant = ProjectSettings.property_get_revert(setting_path)
+	var held: bool = ProjectSettings.has_setting(setting_path)
+	var value: Variant = ProjectSettings.get_setting(setting_path) if held else null
+	var answer: Dictionary = {
+		"setting_path": setting_path,
+		"default_value": _values.serialize_value(default_value) if default_value != null else null,
+	}
+	# A setting at the engine's default has no line to take out, as the engine leaves it out of the file.
+	if not held or (default_value != null and value == default_value):
+		answer["removed"] = false
+		answer["saved"] = false
+		answer["note"] = "project.godot does not set %s, so there was nothing to take out." % setting_path
+		return answer
+	answer["old_value"] = _values.serialize_value(value)
+	# The default rather than null for a setting the engine declares: null takes the declaration away
+	# as well, and a value at its default is left out of the file all the same.
+	ProjectSettings.set_setting(setting_path, default_value)
+	var err: Error = GdhProjectFile.save()
+	if err != OK:
+		return _log.failure("Failed to save project.godot: " + error_string(err))
+	answer["removed"] = true
+	answer["saved"] = true
+	return answer
+
+
 # The settings in the same section as [param setting_path] named nearest it, for a new one that is
 # likely a misspelt one: a setting nothing declares is written all the same, and is never read.
 static func _settings_near(setting_path: String) -> PackedStringArray:

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",