gdharness 1.3.9 → 1.3.11

package/build/godot/operations/input_actions.gd

@@ -5,6 +5,13 @@ 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
+const MOUSE_NAMES: String = (
+	"1 left, 2 right, 3 middle, 4 and 5 the wheel up and down, 6 and 7 the wheel left and right,"
+	+ " 8 and 9 the side buttons"
+)
+const AXIS_NAMES: String = (
+	"0 and 1 the left stick across and down, 2 and 3 the right stick," + " 4 and 5 the triggers"
+)
 
 # The key names a caller may write, and what the engine calls them.
 const KEY_NAMES: Dictionary = {
@@ -147,49 +154,11 @@ func add_input_action(params: Dictionary) -> Dictionary:
 		if not event is Dictionary:
 			return _log.failure("Every event must be an object, not " + JSON.stringify(event))
 		var fields: Dictionary = event
-		var event_type: String = str(fields.get("type", ""))
-
-		match event_type:
-			"key":
-				var keycode: String = str(fields.get("keycode", ""))
-				if keycode.is_empty():
-					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))
-
-				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):
-					event_config["alt_pressed"] = true
-				if fields.get("shift", false):
-					event_config["shift_pressed"] = true
-				events_config.append(event_config)
-
-			"mouse_button":
-				events_config.append(
-					{"class_name": "InputEventMouseButton", "button_index": fields.get("button", 1)}
-				)
-
-			"joypad_button":
-				events_config.append(
-					{"class_name": "InputEventJoypadButton", "button_index": fields.get("button", 0)}
-				)
-
-			"joypad_axis":
-				var motion: Dictionary = {
-					"class_name": "InputEventJoypadMotion",
-					"axis": fields.get("axis", 0),
-					"axis_value": fields.get("axisValue", 1),
-				}
-				events_config.append(motion)
-
-			_:
-				var known: String = "key, mouse_button, joypad_button, joypad_axis"
-				return _log.failure("Unknown event type: " + event_type + ". One of " + known + ".")
+		var built: Variant = _event_config(fields)
+		if built is String:
+			return _log.failure(str(built))
+		var event_config: Dictionary = built
+		events_config.append(event_config)
 
 	if events_config.is_empty():
 		return _log.failure("events must hold at least one event")
@@ -303,14 +272,28 @@ func remove_input_action(params: Dictionary) -> Dictionary:
 		return _log.failure("This project has no input action named " + action_name)
 	# The engine registers its own ui_ actions with a default, so clearing one from project.godot
 	# puts the engine's binding back rather than removing the action.
-	if ProjectSettings.property_get_revert(setting) != null:
+	var engine_binding: Variant = ProjectSettings.property_get_revert(setting)
+	if engine_binding != null:
+		# At the engine's binding the file holds no line for it, and the refusal for a rebound one
+		# spoke of a binding the project had never changed.
+		if ProjectSettings.get_setting(setting) == engine_binding:
+			return _log.failure(
+				(
+					(
+						"%s is one of the engine's own actions, and project.godot does not rebind it, so "
+						+ "there is nothing to remove: the engine's binding holds. Rebind it with "
+						+ "add_input_action."
+					)
+					% action_name
+				)
+			)
 		return _log.failure(
 			(
 				(
-					"%s is one of the engine's own actions: removing it from project.godot restores the "
-					+ "engine's binding rather than removing it. Rebind it with add_input_action instead."
+					"%s is one of the engine's own actions, so it cannot be removed. project_settings "
+					+ "unset %s puts the engine's binding back, and add_input_action rebinds it."
 				)
-				% action_name
+				% [action_name, setting]
 			)
 		)
 	ProjectSettings.set_setting(setting, null)
@@ -376,6 +359,84 @@ 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.
+## The event [param fields] describe, as [method build_input_action] takes it, or why it is no event.
+func _event_config(fields: Dictionary) -> Variant:
+	var event_type: String = str(fields.get("type", ""))
+	match event_type:
+		"key":
+			var keycode: String = str(fields.get("keycode", ""))
+			if keycode.is_empty():
+				return "A key event needs keycode"
+			var key_value: int = _keycode_value(keycode)
+			if key_value == KEY_NONE:
+				return _unknown_key(keycode)
+			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
+			for modifier: String in ["ctrl", "alt", "shift"]:
+				if GdhRead.as_bool(fields.get(modifier, false)):
+					event_config[modifier + "_pressed"] = true
+			return event_config
+		"mouse_button":
+			var mouse: Variant = _whole_in(
+				fields, "button", MOUSE_BUTTON_LEFT, MOUSE_BUTTON_XBUTTON2, MOUSE_NAMES
+			)
+			if mouse is String:
+				return "A mouse_button event " + str(mouse)
+			return {"class_name": "InputEventMouseButton", "button_index": mouse}
+		"joypad_button":
+			var pad: Variant = _whole_in(fields, "button", 0, JOY_BUTTON_MAX - 1, "0 is A, 1 B, 2 X, 3 Y")
+			if pad is String:
+				return "A joypad_button event " + str(pad)
+			return {"class_name": "InputEventJoypadButton", "button_index": pad}
+		"joypad_axis":
+			var axis: Variant = _whole_in(fields, "axis", 0, JOY_AXIS_MAX - 1, AXIS_NAMES)
+			if axis is String:
+				return "A joypad_axis event " + str(axis)
+			# The direction is half the binding: left on a stick and right on it are two actions, and the
+			# editor binds only a whole push one way, so a guessed direction or part of one is a binding
+			# nobody asked for.
+			var direction: Variant = fields.get("axisValue")
+			var numeric: bool = direction is int or direction is float
+			if not numeric or absf(GdhRead.as_float(direction)) != 1.0:
+				return (
+					"A joypad_axis event needs axisValue, -1 or 1, the way the axis is pushed: %s was given."
+					% _shown(direction)
+				)
+			return {
+				"class_name": "InputEventJoypadMotion",
+				"axis": axis,
+				"axis_value": GdhRead.as_float(direction)
+			}
+	var known: String = "key, mouse_button, joypad_button, joypad_axis"
+	return "Unknown event type: " + event_type + ". One of " + known + "."
+
+
+## The whole number [param fields] holds under [param key], from [param least] to [param most], or
+## the rest of a refusal saying what it takes and what [param named] each number is. A field left out
+## was given a default, a left click for a mouse event and axis 0 for a stick, and written as bound.
+static func _whole_in(fields: Dictionary, key: String, least: int, most: int, named: String) -> Variant:
+	var held: Variant = fields.get(key)
+	if held is int or held is float:
+		var number: float = GdhRead.as_float(held)
+		if number == floorf(number) and number >= least and number <= most:
+			return int(number)
+	return (
+		"needs %s, a whole number from %d to %d (%s): %s was given." % [key, least, most, named, _shown(held)]
+	)
+
+
+## [param held] as the caller wrote it: JSON has one kind of number, so 10 arrives as 10.0.
+static func _shown(held: Variant) -> String:
+	if held == null:
+		return "none"
+	if held is float:
+		var number: float = held
+		if is_finite(number) and number == floorf(number):
+			return str(int(number))
+	return JSON.stringify(held)
+
+
 static func _unknown_key(key_name: String) -> String:
 	var every: PackedStringArray = []
 	var named: PackedStringArray = []

package/build/godot/operations/project_config.gd

@@ -5,6 +5,7 @@ const GdhRead = preload("reading.gd")
 const GdhLog = preload("logger.gd")
 const GdhProjectFile = preload("project_file.gd")
 const GdhSerialisation = preload("serialisation.gd")
+const GdhSettingReads = preload("setting_reads.gd")
 const GdhShapes = preload("value_shapes.gd")
 
 var _log: GdhLog
@@ -19,7 +20,8 @@ func _init(p_log: GdhLog) -> void:
 func get_project_setting(params: Dictionary) -> Dictionary:
 	var prefix: String = str(params.get("prefix", ""))
 	if not prefix.is_empty():
-		return _settings_under(prefix)
+		_log.info("Listing project settings under: " + prefix)
+		return GdhSettingReads.under(prefix, _values)
 
 	var setting_path: String = str(params.get("setting", ""))
 	if setting_path.is_empty():
@@ -27,73 +29,7 @@ func get_project_setting(params: Dictionary) -> Dictionary:
 
 	_log.info("Getting project setting: " + setting_path)
 
-	var result: Dictionary = {
-		"setting_path": setting_path, "exists": ProjectSettings.has_setting(setting_path)
-	}
-
-	if result["exists"]:
-		var value: Variant = ProjectSettings.get_setting(setting_path)
-		result["value"] = _values.serialize_value(value)
-		# A setting the engine registers exists whether or not the project sets it, so exists did
-		# not say whether project.godot has a line for it. At its default it has none: the engine
-		# drops such a key when it saves.
-		var default_value: Variant = ProjectSettings.property_get_revert(setting_path)
-		if default_value != null:
-			result["at_default"] = value == default_value
-	else:
-		result["value"] = null
-		result["message"] = "Setting does not exist"
-
-	# The value under this name is not the one every build reads: `name.windows` replaces it on
-	# Windows, `name.editor` in the editor. Read alone, a caller saw the plain value and not the one
-	# their game showed.
-	var overrides: Dictionary = {}
-	for info: Dictionary in ProjectSettings.get_property_list():
-		var name: String = str(info.get("name", ""))
-		if name.begins_with(setting_path + "."):
-			overrides[name.substr(setting_path.length() + 1)] = _values.serialize_value(
-				ProjectSettings.get_setting(name)
-			)
-	if not overrides.is_empty():
-		result["overrides"] = overrides
-
-	return result
-
-
-# Every setting whose name starts with [prefix], with the type the engine registers for each.
-#
-# A caller after a whole family, "everything under debug/gdscript/warnings", had no way to ask: a get
-# takes one name, and the engine is the only thing that knows what the family contains. The way round
-# it was to walk ProjectSettings.get_property_list() from a script written for the purpose, which is
-# an engine start to answer a question the engine was already open for.
-#
-# The type is here because it is the half a name hides. A setting sitting among a family of levels
-# can be a bool, and a caller that assumes otherwise writes a level over it and sees nothing go
-# wrong: 2 is as true as true is. Reading it out of the property list is how that is caught.
-func _settings_under(prefix: String) -> Dictionary:
-	_log.info("Listing project settings under: " + prefix)
-
-	var found: Array[Dictionary] = []
-	for property: Dictionary in ProjectSettings.get_property_list():
-		var name: String = str(property.get("name", ""))
-		if not name.begins_with(prefix):
-			continue
-		var kind: int = GdhRead.as_int(property.get("type", TYPE_NIL), TYPE_NIL)
-		var value: Variant = ProjectSettings.get_setting(name)
-		var described: Dictionary = {
-			"setting": name,
-			"type": type_string(kind),
-			"value": _values.serialize_value(value),
-		}
-		# As a single get says it, so a family read can be told apart into what the project sets
-		# and the engine's defaults: "input/" is ninety actions the engine ships and the project's few.
-		var default_value: Variant = ProjectSettings.property_get_revert(name)
-		if default_value != null:
-			described["at_default"] = value == default_value
-		found.append(described)
-
-	found.sort_custom(func(a: Dictionary, b: Dictionary) -> bool: return a["setting"] < b["setting"])
-	return {"prefix": prefix, "count": found.size(), "settings": found}
+	return GdhSettingReads.one(setting_path, _values)
 
 
 # Set a project setting value
@@ -146,6 +82,14 @@ func set_project_setting(params: Dictionary) -> Dictionary:
 	if had_value and typeof(old_value) == typeof(final_value) and old_value == final_value:
 		answer["saved"] = false
 		answer["unchanged"] = true
+		if was_default:
+			answer["note"] = (
+				(
+					"%s is already this setting's default, which project.godot holds no line for:"
+					+ " the engine reads it wherever %s is asked for, so nothing was written."
+				)
+				% [JSON.stringify(_values.serialize_value(final_value)), setting_path]
+			)
 		return answer
 
 	var near: PackedStringArray = []
@@ -159,6 +103,24 @@ func set_project_setting(params: Dictionary) -> Dictionary:
 			)
 			% [setting_path, "setting is" if near.size() == 1 else "settings are", ", ".join(near)]
 		)
+	# Written as given, since a file can be made after the setting names it, as an import makes a
+	# translation; said, since until then the engine complains of it on every boot.
+	var missing: Array[String] = _missing_files(final_value)
+	if not missing.is_empty():
+		answer["missing_files"] = missing
+		var said: String = (
+			"%s %s not exist, and the engine reports %s on every boot until %s"
+			% [
+				", ".join(missing),
+				"does" if missing.size() == 1 else "do",
+				"it" if missing.size() == 1 else "them",
+				"it does" if missing.size() == 1 else "they do",
+			]
+		)
+		var made: Array[String] = _translations_made_by(missing)
+		if not made.is_empty():
+			said += ("; project_import reimport makes the translation files from " + ", ".join(made))
+		answer["note"] = (str(answer["note"]) + " " if answer.has("note") else "") + said + "."
 	ProjectSettings.set_setting(setting_path, final_value)
 	var err: Error = GdhProjectFile.save()
 	if err != OK:
@@ -166,6 +128,45 @@ func set_project_setting(params: Dictionary) -> Dictionary:
 	return answer
 
 
+## The res:// files [param value] names that are not on disk: a path, an autoload's starred path, or
+## a list or dictionary of them.
+static func _missing_files(value: Variant) -> Array[String]:
+	var items: Array = []
+	if value is String or value is StringName:
+		items = [value]
+	elif value is PackedStringArray:
+		var strings: PackedStringArray = value
+		items = Array(strings)
+	elif value is Array:
+		items = value
+	elif value is Dictionary:
+		var held: Dictionary = value
+		items = held.values()
+	var missing: Array[String] = []
+	for item: Variant in items:
+		if not (item is String or item is StringName):
+			continue
+		var path: String = str(item).trim_prefix("*")
+		if not path.begins_with("res://"):
+			continue
+		if not FileAccess.file_exists(path) and not DirAccess.dir_exists_absolute(path):
+			missing.append(path)
+	return missing
+
+
+## The CSV files an import makes the translations among [param missing] from: strings.en.translation
+## from strings.csv beside it.
+static func _translations_made_by(missing: Array[String]) -> Array[String]:
+	var sources: Array[String] = []
+	for path: String in missing:
+		if path.get_extension() != "translation":
+			continue
+		var csv: String = path.get_basename().get_basename() + ".csv"
+		if FileAccess.file_exists(csv) and not csv in sources:
+			sources.append(csv)
+	return sources
+
+
 # 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:
@@ -184,7 +185,7 @@ func unset_project_setting(params: Dictionary) -> Dictionary:
 		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
+		return _with_what_holds(answer, setting_path)
 	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.
@@ -194,6 +195,19 @@ func unset_project_setting(params: Dictionary) -> Dictionary:
 		return _log.failure("Failed to save project.godot: " + error_string(err))
 	answer["removed"] = true
 	answer["saved"] = true
+	return _with_what_holds(answer, setting_path)
+
+
+# An override has no default of its own: with it gone, a build with its feature reads the base
+# setting, and default_value, null, said nothing of that.
+func _with_what_holds(answer: Dictionary, setting_path: String) -> Dictionary:
+	var base: String = GdhSettingReads.override_base(setting_path)
+	if base.is_empty() or not ProjectSettings.has_setting(base):
+		return answer
+	answer["override_of"] = base
+	answer["holds"] = _values.serialize_value(ProjectSettings.get_setting(base))
+	var said: String = GdhSettingReads.overridden_by_none(setting_path, _values)
+	answer["note"] = said if not answer.has("note") else "%s %s" % [answer["note"], said]
 	return answer
 
 

package/build/godot/operations/project_diagnostics.gd

@@ -5,6 +5,7 @@ const GdhFileWalk = preload("file_walk.gd")
 const GdhImportPipeline = preload("import_pipeline.gd")
 const GdhLog = preload("logger.gd")
 const GdhRead = preload("reading.gd")
+const GdhSceneConnections = preload("scene_connections.gd")
 const GdhScriptCheck = preload("script_check.gd")
 
 var _log: GdhLog
@@ -129,6 +130,9 @@ func get_project_health(params: Dictionary) -> Dictionary:
 		if scene_files.size() == 0:
 			details.append("No scene files found in project")
 			deductions += 5
+		for entry: Dictionary in GdhSceneConnections.new(_log).broken():
+			details.append(GdhSceneConnections.broken_line(entry))
+			deductions += 5
 
 		checks["scenes"] = {
 			"name": "Scenes",

package/build/godot/operations/project_validation.gd

@@ -0,0 +1,266 @@
+extends RefCounted
+
+## Whether a project is ready to run and export: its settings, main scene, imports, presets,
+## scripts, references and signal connections, each named under checks_performed.
+
+const GdhDependencies = preload("dependencies.gd")
+const GdhExportPresets = preload("export_presets.gd")
+const GdhFileWalk = preload("file_walk.gd")
+const GdhImportPipeline = preload("import_pipeline.gd")
+const GdhLog = preload("logger.gd")
+const GdhRead = preload("reading.gd")
+const GdhSceneConnections = preload("scene_connections.gd")
+const GdhScriptCheck = preload("script_check.gd")
+const CONNECTION_FIX: String = (
+	"Write the method or signal, or point the connection at the one that replaced it with" + " scene_signal"
+)
+
+var _log: GdhLog
+var _files: GdhFileWalk = GdhFileWalk.new()
+
+
+func _init(p_log: GdhLog) -> void:
+	_log = p_log
+
+
+func validate_project(params: Dictionary) -> Dictionary:
+	var preset_name: String = str(params.get("preset", ""))
+	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 ""))
+
+	var issues: Array[Dictionary] = []
+	var warnings: Array[Dictionary] = []
+	var checks_performed: Array[String] = []
+
+	checks_performed.append("project_file")
+	if not FileAccess.file_exists("res://project.godot"):
+		issues.append(
+			_finding(
+				"error",
+				"project_file",
+				"project.godot not found",
+				"Ensure you are running this from a valid Godot project directory",
+				include_suggestions
+			)
+		)
+
+	checks_performed.append("main_scene")
+	var main_scene: String = str(ProjectSettings.get_setting("application/run/main_scene", ""))
+	if main_scene.is_empty():
+		issues.append(
+			_finding(
+				"error",
+				"main_scene",
+				"No main scene set",
+				"Set a main scene in Project Settings > Application > Run > Main Scene",
+				include_suggestions
+			)
+		)
+	elif not GdhFileWalk.missing_reason(main_scene).is_empty():
+		issues.append(
+			_finding(
+				"error",
+				"main_scene",
+				"Main scene " + GdhFileWalk.missing_reason(main_scene),
+				"Update the main scene setting or create the missing scene file",
+				include_suggestions
+			)
+		)
+
+	# 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://", GdhImportPipeline.IMPORTABLE_EXTENSIONS):
+		if not FileAccess.file_exists(path + ".import"):
+			never.append(path)
+	if not never.is_empty():
+		never.sort()
+		warnings.append(
+			_finding(
+				"warning",
+				"imports",
+				GdhImportPipeline.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(
+			_finding(
+				"warning",
+				"export_presets",
+				"No export presets configured",
+				"Add a preset with project_export add_preset, or in the editor: Project > Export",
+				include_suggestions
+			)
+		)
+
+	# The preset asked about is looked for rather than only logged: validating "for" a preset that
+	# 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] = GdhExportPresets.names()
+		if preset_name not in named:
+			issues.append(
+				_finding(
+					"error",
+					"export_preset",
+					(
+						"No export preset is named "
+						+ preset_name
+						+ (
+							": the project has none"
+							if named.is_empty()
+							else ": the presets are " + ", ".join(named)
+						)
+					),
+					"Pass one of the preset names, or add the preset with project_export add_preset",
+					include_suggestions
+				)
+			)
+		else:
+			var gone: Array[String] = GdhExportPresets.missing_named(preset_name)
+			if not gone.is_empty():
+				warnings.append(
+					_finding(
+						"warning",
+						"export_preset_files",
+						"The preset %s names files that are not there: %s" % [preset_name, "; ".join(gone)],
+						"Add the files, or point the options at others with project_export set_preset",
+						include_suggestions
+					)
+				)
+
+	checks_performed.append("icon")
+	var icon_path: String = str(ProjectSettings.get_setting("application/config/icon", ""))
+	if icon_path.is_empty():
+		warnings.append(
+			_finding(
+				"warning",
+				"icon",
+				"No application icon set",
+				"Set an icon in Project Settings > Application > Config > Icon",
+				include_suggestions
+			)
+		)
+	elif not FileAccess.file_exists(icon_path):
+		warnings.append(
+			_finding(
+				"warning",
+				"icon",
+				"Icon file does not exist: " + icon_path,
+				"Update the icon path or add the missing icon file",
+				include_suggestions
+			)
+		)
+
+	checks_performed.append("project_name")
+	var project_name: String = str(ProjectSettings.get_setting("application/config/name", ""))
+	if project_name.is_empty():
+		warnings.append(
+			_finding(
+				"warning",
+				"project_name",
+				"No project name set",
+				"Set a project name in Project Settings > Application > Config > Name",
+				include_suggestions
+			)
+		)
+
+	checks_performed.append("scripts")
+	var script_files: Array[String] = _files.find_files_with_extensions("res://", ["gd"])
+	var scripts_checked: int = 0
+	var script_issues: Array[Dictionary] = []
+
+	# A hundred scripts is enough to say whether the project is tidy without a large one
+	# turning validation into a full read of its source tree.
+	for script_path: String in script_files.slice(0, 100):
+		scripts_checked += 1
+		var file: FileAccess = FileAccess.open(script_path, FileAccess.READ)
+		if file:
+			var content: String = file.get_as_text()
+			file.close()
+
+			if "# TODO" in content or "# FIXME" in content:
+				script_issues.append({"path": script_path, "issue": "Contains TODO/FIXME comments"})
+			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
+			)
+		)
+
+	# A connection whose method or signal is not there loads without a word and fails only once the
+	# game runs, on every emission or not at all; the references check sees files, not members.
+	checks_performed.append("connections")
+	for entry: Dictionary in GdhSceneConnections.new(_log).broken():
+		warnings.append(
+			_finding(
+				"warning",
+				"connections",
+				GdhSceneConnections.broken_line(entry),
+				CONNECTION_FIX,
+				include_suggestions
+			)
+		)
+
+	if script_issues.size() > 0:
+		var warning: Dictionary = _finding(
+			"warning",
+			"scripts",
+			str(script_issues.size()) + " script issues found",
+			"Review and resolve TODO/FIXME items before release",
+			include_suggestions
+		)
+		warning["details"] = script_issues.slice(0, 5)
+		warnings.append(warning)
+
+	return {
+		"valid": issues.is_empty(),
+		"issues": issues,
+		"warnings": warnings,
+		"checks_performed": checks_performed,
+		"scripts_checked": scripts_checked,
+		# Said beside the count, so a project of four hundred scripts is not read as checked whole.
+		"scripts_total": script_files.size(),
+		"issue_count": issues.size(),
+		"warning_count": warnings.size()
+	}
+
+
+func _finding(
+	type: String, check: String, message: String, suggestion: String, include_suggestion: bool
+) -> Dictionary:
+	var finding: Dictionary = {"type": type, "check": check, "message": message}
+	if include_suggestion:
+		finding["suggestion"] = suggestion
+	return finding