gdharness 1.3.0 → 1.3.1

package/build/godot/operations/project_config.gd

@@ -1,15 +1,16 @@
 extends RefCounted
 
-const Read = preload("reading.gd")
-const Log = preload("logger.gd")
-const ProjectFile = preload("project_file.gd")
-const Serialisation = preload("serialisation.gd")
+const GdhRead = preload("reading.gd")
+const GdhLog = preload("logger.gd")
+const GdhProjectFile = preload("project_file.gd")
+const GdhSerialisation = preload("serialisation.gd")
+const GdhShapes = preload("value_shapes.gd")
 
-var _log: Log
-var _values: Serialisation = Serialisation.new()
+var _log: GdhLog
+var _values: GdhSerialisation = GdhSerialisation.new()
 
 
-func _init(p_log: Log) -> void:
+func _init(p_log: GdhLog) -> void:
 	_log = p_log
 
 
@@ -76,7 +77,7 @@ func _settings_under(prefix: String) -> Dictionary:
 		var name: String = str(property.get("name", ""))
 		if not name.begins_with(prefix):
 			continue
-		var kind: int = Read.as_int(property.get("type", TYPE_NIL), TYPE_NIL)
+		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,
@@ -113,8 +114,13 @@ func set_project_setting(params: Dictionary) -> Dictionary:
 	var default_value: Variant = ProjectSettings.property_get_revert(setting_path)
 	var was_default: bool = had_value and default_value != null and old_value == default_value
 
-	var final_value: Variant = _values.deserialize_value(value)
 	var wanted: int = _wanted_type(setting_path, old_value if had_value else null)
+	# A value of fields or a colour's html code is fitted as a property write fits it, so a value one
+	# of them takes the other takes too. A number is left to the check below, which refuses one the
+	# setting would cut where fitting it would cut it.
+	var final_value: Variant = _values.deserialize_value(value)
+	if final_value is Dictionary or (wanted == TYPE_COLOR and final_value is String):
+		final_value = _values.fitted(value, wanted)
 	if wanted > TYPE_NIL and final_value != null and typeof(final_value) != wanted:
 		if not _converts_faithfully(final_value, wanted):
 			return _log.failure(_cannot_hold(setting_path, wanted, final_value))
@@ -136,7 +142,7 @@ func set_project_setting(params: Dictionary) -> Dictionary:
 		return answer
 
 	ProjectSettings.set_setting(setting_path, final_value)
-	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 answer
@@ -157,7 +163,7 @@ func set_project_setting(params: Dictionary) -> Dictionary:
 func _wanted_type(setting_path: String, current: Variant) -> int:
 	for info: Dictionary in ProjectSettings.get_property_list():
 		if str(info.get("name", "")) == setting_path:
-			return Read.as_int(info.get("type", TYPE_NIL), TYPE_NIL)
+			return GdhRead.as_int(info.get("type", TYPE_NIL), TYPE_NIL)
 	return typeof(current)
 
 
@@ -181,19 +187,20 @@ static func _cannot_hold(setting_path: String, wanted: int, value: Variant) -> S
 	if wanted in numbers and typeof(value) in numbers:
 		return "%s, and %s is not the same number as one.%s" % [declared, str(value), cost]
 	var given: String = type_string(typeof(value))
-	return "%s, and %s (%s) cannot become one." % [declared, JSON.stringify(value), given]
+	var remedy: String = GdhShapes.remedy(value, wanted)
+	return "%s, and %s (%s) cannot become one.%s" % [declared, JSON.stringify(value), given, remedy]
 
 
 # Add an autoload singleton
 func add_autoload(params: Dictionary) -> Dictionary:
 	var name: String = str(params.get("name", ""))
 	var path: String = str(params.get("path", ""))
-	var global: bool = Read.as_bool(params.get("global", true), true)
+	var global: bool = GdhRead.as_bool(params.get("global", true), true)
 
 	# There is no disabled autoload in Godot 4: every entry in the list is loaded under the root at
 	# every start. `enabled: false` used to write the entry without its asterisk and answer that it
 	# was disabled, and the autoload ran all the same.
-	if not Read.as_bool(params.get("enabled", true), true):
+	if not GdhRead.as_bool(params.get("enabled", true), true):
 		return _log.failure(
 			(
 				"An autoload cannot be added disabled: Godot loads every autoload in the list at every"
@@ -219,7 +226,7 @@ func add_autoload(params: Dictionary) -> Dictionary:
 	# "Global Variable" column. Without it the node still comes up under the root; only the name
 	# stops resolving.
 	ProjectSettings.set_setting(setting, ("*" if global else "") + path)
-	var err: Error = ProjectFile.save()
+	var err: Error = GdhProjectFile.save()
 	if err != OK:
 		return _log.failure("Failed to save project.godot: " + error_string(err))
 
@@ -244,7 +251,7 @@ func remove_autoload(params: Dictionary) -> Dictionary:
 
 	var old_value: String = str(ProjectSettings.get_setting(setting))
 	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))
 
@@ -293,7 +300,7 @@ func set_main_scene(params: Dictionary) -> Dictionary:
 	var old_main_scene: String = str(ProjectSettings.get_setting("application/run/main_scene", ""))
 
 	ProjectSettings.set_setting("application/run/main_scene", scene_path)
-	var err: Error = ProjectFile.save()
+	var err: Error = GdhProjectFile.save()
 
 	if err != OK:
 		return _log.failure("Failed to save project settings: " + str(err))

package/build/godot/operations/project_diagnostics.gd

@@ -1,14 +1,14 @@
 extends RefCounted
 
-const FileWalk = preload("file_walk.gd")
-const ImportPipeline = preload("import_pipeline.gd")
-const Log = preload("logger.gd")
+const GdhFileWalk = preload("file_walk.gd")
+const GdhImportPipeline = preload("import_pipeline.gd")
+const GdhLog = preload("logger.gd")
 
-var _log: Log
-var _files: FileWalk = FileWalk.new()
+var _log: GdhLog
+var _files: GdhFileWalk = GdhFileWalk.new()
 
 
-func _init(p_log: Log) -> void:
+func _init(p_log: GdhLog) -> void:
 	_log = p_log
 
 
@@ -44,7 +44,7 @@ func get_project_health(params: Dictionary) -> Dictionary:
 		# Every format the engine imports, the list the import status reads: five of them were checked
 		# here, so a project of glTF models, fonts and WebP textures had nothing to reimport.
 		var resources: Array[String] = _files.find_files_with_extensions(
-			"res://", ImportPipeline.IMPORTABLE_EXTENSIONS
+			"res://", GdhImportPipeline.IMPORTABLE_EXTENSIONS
 		)
 
 		var missing_imports: int = 0
@@ -119,8 +119,8 @@ func get_project_health(params: Dictionary) -> Dictionary:
 		if main_scene.is_empty():
 			details.append("No main scene configured")
 			deductions += 10
-		elif not FileWalk.missing_reason(main_scene).is_empty():
-			details.append("Main scene " + FileWalk.missing_reason(main_scene))
+		elif not GdhFileWalk.missing_reason(main_scene).is_empty():
+			details.append("Main scene " + GdhFileWalk.missing_reason(main_scene))
 			deductions += 15
 
 		var project_name: String = str(ProjectSettings.get_setting("application/config/name", ""))

package/build/godot/operations/property_values.gd

@@ -14,8 +14,9 @@ extends RefCounted
 ## write accepts. What is here on top of it is the part only a property knows: the type wanted, so a
 ## dictionary shaped like a vector or a bare pair of numbers can be read as one.
 
-const Read = preload("reading.gd")
-const Serialisation = preload("serialisation.gd")
+const GdhRead = preload("reading.gd")
+const GdhSerialisation = preload("serialisation.gd")
+const GdhShapes = preload("value_shapes.gd")
 
 # The data types a Theme names its items by, as in "Button/colors/font_color", and what each holds.
 const THEME_ITEMS: Dictionary[String, Array] = {
@@ -65,12 +66,18 @@ const FLOAT_SHAPES: Array[int] = [
 # names, so a write to "Visibility" or "Transform" changed nothing and was answered as made.
 const HEADINGS: int = PROPERTY_USAGE_CATEGORY | PROPERTY_USAGE_GROUP | PROPERTY_USAGE_SUBGROUP
 
-var _values: Serialisation = Serialisation.new()
+var _values: GdhSerialisation = GdhSerialisation.new()
 
 # Why the value being parsed cannot be written, when the parse is what found out. A resource is
 # built inside the parse and there is nowhere in a parsed value to put the reason it is wrong.
 var _refused: String = ""
 
+# The stored properties the last write_all changed without being given them, by name, as [what it
+# held before, what it holds now]. A setter keeps other properties in step with the one it is given:
+# a Gradient given a third colour gives that point an offset of 0, a Control given a size moves its
+# offsets. An answer naming only what was given leaves the caller to guess the rest.
+var _also_changed: Dictionary = {}
+
 
 ## Turns what arrived over the wire into the Godot value a property wants.
 ##
@@ -85,7 +92,7 @@ func parse(value: Variant, expected_type: int = TYPE_NIL, elements: Array = [])
 		var fields: Dictionary = value
 		# A dictionary with keys that are not text arrives as its entries, and is read against the
 		# declared element types like any other.
-		if str(fields.get("_type", "")) == "Dictionary" and Serialisation.pairs(fields.get("entries")):
+		if str(fields.get("_type", "")) == "Dictionary" and GdhSerialisation.pairs(fields.get("entries")):
 			var built: Dictionary = _values.deserialize_value(fields)
 			return _parse_entries(built, elements)
 		var tagged: Array = _parse_tagged_dictionary(fields)
@@ -113,38 +120,39 @@ func cannot_hold(
 ) -> String:
 	var held: String = type_string(expected_type)
 	var cost: String = " Setting it would save a different value than the one asked for."
-	if not Serialisation.acceptable(value, expected_type):
+	if not GdhSerialisation.acceptable(value, expected_type):
 		var shape: String = "%s.%s is %s and the value given is %s, which cannot become one."
-		return shape % [holder, property, held, type_string(typeof(value))] + cost
+		var remedy: String = GdhShapes.remedy(value, expected_type)
+		return shape % [holder, property, held, type_string(typeof(value))] + remedy + cost
 
 	# And the same question of each element, because a list is accepted for a packed or typed array
 	# whatever is in it: a polygon written as [{"x": 1}] passes the check above and lands as one zero
 	# vector, and [1.5, "x"] for a PackedInt32Array as [1, 0].
-	var element: int = Read.as_int(PACKED_ELEMENTS.get(expected_type, TYPE_NIL), TYPE_NIL)
+	var element: int = GdhRead.as_int(PACKED_ELEMENTS.get(expected_type, TYPE_NIL), TYPE_NIL)
 	if expected_type == TYPE_ARRAY and not elements.is_empty():
-		element = Read.as_int(elements[0], TYPE_NIL)
+		element = GdhRead.as_int(elements[0], TYPE_NIL)
 	if element != TYPE_NIL and value is Array:
 		var items: Array = value
 		for index: int in items.size():
-			if not Serialisation.acceptable(items[index], element):
+			if not GdhSerialisation.acceptable(items[index], element):
 				var shape: String = "%s.%s is %s and item %d of the list given is %s, not %s."
 				var named: Array = [
 					holder, property, held, index, type_string(typeof(items[index])), type_string(element)
 				]
-				return shape % named + cost
+				return shape % named + GdhShapes.remedy(items[index], element) + cost
 	if expected_type == TYPE_DICTIONARY and elements.size() == 2 and value is Dictionary:
 		var entries: Dictionary = value
-		var key_type: int = Read.as_int(elements[0], TYPE_NIL)
-		var value_type: int = Read.as_int(elements[1], TYPE_NIL)
+		var key_type: int = GdhRead.as_int(elements[0], TYPE_NIL)
+		var value_type: int = GdhRead.as_int(elements[1], TYPE_NIL)
 		for key: Variant in entries:
-			if not Serialisation.acceptable(key, key_type):
+			if not GdhSerialisation.acceptable(key, key_type):
 				var shape: String = "%s.%s has %s keys, and %s is not one."
 				return shape % [holder, property, type_string(key_type), shown(key)] + cost
 			var entry: Variant = entries[key]
-			if not Serialisation.acceptable(entry, value_type):
+			if not GdhSerialisation.acceptable(entry, value_type):
 				var shape: String = "%s.%s holds %s values, and the one given for %s is %s."
 				var named: Array = [holder, property, type_string(value_type), shown(key), shown(entry)]
-				return shape % named + cost
+				return shape % named + GdhShapes.remedy(entry, value_type) + cost
 	return ""
 
 
@@ -168,6 +176,11 @@ func cannot_hold(
 ## Nothing here saves, so a refusal partway leaves the change in memory and the file as it was. The
 ## caller returns the refusal instead of saving.
 func write_all(target: Object, properties: Dictionary) -> String:
+	_also_changed = {}
+	var named: Dictionary = {}
+	for key: Variant in properties:
+		named[str(key).get_slice(":", 0)] = true
+	var before: Dictionary = _stored(target, named)
 	var given: Dictionary = {}
 	for key: Variant in properties:
 		var property: String = str(key)
@@ -197,9 +210,62 @@ func write_all(target: Object, properties: Dictionary) -> String:
 				)
 				% [target.get_class(), property, shown(given[property]), shown(held)]
 			)
+	for property: String in before:
+		var now: Variant = target.get(property)
+		if not same(now, before[property]):
+			_also_changed[property] = [before[property], now]
 	return ""
 
 
+## Puts under alsoChanged in [param answer] each property the last [method write_all] changed
+## without being given it, as {was, now}, when there are any. A node is named by its path from
+## [param relative_to], as a scene answer names one. Called before the scene is written, since the
+## write frees the nodes these values can hold.
+func note_also_changed(answer: Dictionary, relative_to: Node = null) -> void:
+	if _also_changed.is_empty():
+		return
+	var noted: Dictionary = {}
+	for property: Variant in _also_changed:
+		var pair: Array = _also_changed[property]
+		noted[property] = {"was": _readable(pair[0], relative_to), "now": _readable(pair[1], relative_to)}
+	answer["alsoChanged"] = noted
+
+
+func _readable(value: Variant, relative_to: Node) -> Variant:
+	if value is Node and relative_to != null:
+		var target: Node = value
+		return _values.serialize_value(relative_to.get_path_to(target))
+	if value is Array:
+		var items: Array = value
+		return items.map(func(item: Variant) -> Variant: return _readable(item, relative_to))
+	return _values.serialize_value(value)
+
+
+## What [param target] stores, by name, but its script and the properties in [param leave]. A list
+## or a map is copied, since a setter can change the one it holds in place.
+func _stored(target: Object, leave: Dictionary) -> Dictionary:
+	var held: Dictionary = {}
+	for entry: Dictionary in target.get_property_list():
+		var name: String = str(entry["name"])
+		var usage: int = GdhRead.as_int(entry["usage"])
+		if (
+			usage & PROPERTY_USAGE_STORAGE == 0
+			or usage & HEADINGS != 0
+			or name == "script"
+			or leave.has(name)
+		):
+			continue
+		var value: Variant = target.get(name)
+		if value is Array:
+			var listed: Array = value
+			value = listed.duplicate(true)
+		elif value is Dictionary:
+			var mapped: Dictionary = value
+			value = mapped.duplicate(true)
+		held[name] = value
+	return held
+
+
 ## What [param target] holds under [param key], a property or a colon path into one's components.
 func read_at(target: Object, key: String) -> Variant:
 	if ":" in key and declaration(target, key).is_empty():
@@ -228,9 +294,8 @@ func _component_slot(target: Object, path: String) -> Dictionary:
 	var walked: String = steps[0]
 	for index: int in range(1, steps.size()):
 		var step: String = steps[index]
-		var has: PackedStringArray = Serialisation.components_of(value)
-		var kind: String = type_string(typeof(value))
-		var sort: String = ("an " if kind.left(1).to_upper() in ["A", "E", "I", "O", "U"] else "a ") + kind
+		var has: PackedStringArray = GdhSerialisation.components_of(value)
+		var sort: String = GdhRead.with_article(type_string(typeof(value)))
 		if has.is_empty():
 			return {
 				"refused":
@@ -255,8 +320,8 @@ func _component_slot(target: Object, path: String) -> Dictionary:
 ## [param raw] as the value [param declared] takes, as [ok, value] or [false, why not].
 func value_for(target: Object, declared: Dictionary, raw: Variant) -> Array:
 	var property: String = str(declared.get("name", ""))
-	var expected_type: int = Read.as_int(declared.get("type", TYPE_NIL), TYPE_NIL)
-	var hint: int = Read.as_int(declared.get("hint", PROPERTY_HINT_NONE))
+	var expected_type: int = GdhRead.as_int(declared.get("type", TYPE_NIL), TYPE_NIL)
+	var hint: int = GdhRead.as_int(declared.get("hint", PROPERTY_HINT_NONE))
 	if expected_type == TYPE_OBJECT and hint == PROPERTY_HINT_NODE_TYPE:
 		return _node_reference(target, property, raw)
 
@@ -272,7 +337,7 @@ func value_for(target: Object, declared: Dictionary, raw: Variant) -> Array:
 		var elements: Array = elements_of(declared)
 		if _fraction(raw, expected_type, elements):
 			return [false, _fraction_refusal(target, property, raw)]
-		var rounded: String = Serialisation.inexact(raw, expected_type)
+		var rounded: String = GdhSerialisation.inexact(raw, expected_type)
 		if not rounded.is_empty():
 			return [false, "%s.%s holds int: %s." % [target.get_class(), property, rounded]]
 		_refused = ""
@@ -328,7 +393,7 @@ func _node_reference(target: Object, property: String, raw: Variant) -> Array:
 ## an object of the wrong class: measured on 4.7.2, a Sprite2D given a Material for its texture
 ## held nothing afterwards, and the scene was saved without the texture it had.
 func _wrong_class(value: Object, declared: Dictionary) -> String:
-	var hint: int = Read.as_int(declared.get("hint", PROPERTY_HINT_NONE))
+	var hint: int = GdhRead.as_int(declared.get("hint", PROPERTY_HINT_NONE))
 	var wanted: String = str(declared.get("hint_string", ""))
 	if hint != PROPERTY_HINT_RESOURCE_TYPE or wanted.is_empty():
 		return ""
@@ -354,8 +419,8 @@ func _wrong_class(value: Object, declared: Dictionary) -> String:
 ## behind a placeholder in the editor, and measured on 4.7.2 that placeholder stores [1.5, 2.0]
 ## as given, which the game then fails to load into the typed array.
 static func elements_of(declared: Dictionary) -> Array:
-	var type: int = Read.as_int(declared.get("type", TYPE_NIL), TYPE_NIL)
-	var hint: int = Read.as_int(declared.get("hint", PROPERTY_HINT_NONE))
+	var type: int = GdhRead.as_int(declared.get("type", TYPE_NIL), TYPE_NIL)
+	var hint: int = GdhRead.as_int(declared.get("hint", PROPERTY_HINT_NONE))
 	var wanted: String = str(declared.get("hint_string", ""))
 	if wanted.is_empty():
 		return []
@@ -397,21 +462,21 @@ func _fraction(value: Variant, type: int, elements: Array = []) -> bool:
 	if type == TYPE_INT:
 		var number: Variant = value
 		if typeof(value) == TYPE_STRING:
-			number = Read.json_or_null(str(value))
+			number = GdhRead.json_or_null(str(value))
 		if typeof(number) != TYPE_FLOAT:
 			return false
 		var whole: float = number
 		return is_finite(whole) and whole != floorf(whole)
-	var element: int = Read.as_int(PACKED_ELEMENTS.get(type, TYPE_NIL), TYPE_NIL)
+	var element: int = GdhRead.as_int(PACKED_ELEMENTS.get(type, TYPE_NIL), TYPE_NIL)
 	if type == TYPE_ARRAY and not elements.is_empty():
-		element = Read.as_int(elements[0], TYPE_NIL)
+		element = GdhRead.as_int(elements[0], TYPE_NIL)
 	if value is Array and element != TYPE_NIL:
 		var items: Array = value
 		return items.any(func(item: Variant) -> bool: return _fraction(item, element))
 	if type == TYPE_DICTIONARY and elements.size() == 2 and value is Dictionary:
 		var entries: Dictionary = value
-		var key_type: int = Read.as_int(elements[0], TYPE_NIL)
-		var value_type: int = Read.as_int(elements[1], TYPE_NIL)
+		var key_type: int = GdhRead.as_int(elements[0], TYPE_NIL)
+		var value_type: int = GdhRead.as_int(elements[1], TYPE_NIL)
 		for key: Variant in entries:
 			if _fraction(key, key_type) or _fraction(entries[key], value_type):
 				return true
@@ -463,7 +528,7 @@ func declaration(target: Object, property: String) -> Dictionary:
 	for declared: Dictionary in target.get_property_list():
 		if str(declared.get("name", "")) != property:
 			continue
-		if Read.as_int(declared.get("usage", 0)) & HEADINGS:
+		if GdhRead.as_int(declared.get("usage", 0)) & HEADINGS:
 			continue
 		return declared
 	if target is Theme:
@@ -503,13 +568,13 @@ static func same(held: Variant, given: Variant) -> bool:
 		return held_none == given_none
 	if held_type == TYPE_OBJECT or given_type == TYPE_OBJECT:
 		return _same_object(held, given)
-	if Serialisation.NUMBERS.has(held_type) and Serialisation.NUMBERS.has(given_type):
+	if GdhSerialisation.NUMBERS.has(held_type) and GdhSerialisation.NUMBERS.has(given_type):
 		if held_type == TYPE_BOOL or given_type == TYPE_BOOL:
 			return held_type == given_type and held == given
-		var held_number: float = Read.as_float(held)
-		var given_number: float = Read.as_float(given)
+		var held_number: float = GdhRead.as_float(held)
+		var given_number: float = GdhRead.as_float(given)
 		return (is_nan(held_number) and is_nan(given_number)) or is_equal_approx(held_number, given_number)
-	if Serialisation.TEXTS.has(held_type) and Serialisation.TEXTS.has(given_type):
+	if GdhSerialisation.TEXTS.has(held_type) and GdhSerialisation.TEXTS.has(given_type):
 		return str(held) == str(given)
 	if _listed(held_type) and _listed(given_type):
 		var held_items: Array = type_convert(held, TYPE_ARRAY)
@@ -675,7 +740,7 @@ func _parse_shaped_dictionary(value: Dictionary, expected_type: int, elements: A
 	if expected_type == TYPE_NIL or expected_type == TYPE_DICTIONARY:
 		return _parse_entries(value, elements)
 	var tag: String = type_string(expected_type)
-	if Serialisation.REQUIRED.has(tag):
+	if GdhShapes.REQUIRED.has(tag):
 		var tagged: Dictionary = value.duplicate()
 		tagged["_type"] = tag
 		var built: Variant = _values.deserialize_value(tagged)
@@ -690,8 +755,8 @@ func _parse_entries(value: Dictionary, elements: Array) -> Dictionary:
 	var key_type: int = TYPE_NIL
 	var value_type: int = TYPE_NIL
 	if elements.size() == 2:
-		key_type = Read.as_int(elements[0], TYPE_NIL)
-		value_type = Read.as_int(elements[1], TYPE_NIL)
+		key_type = GdhRead.as_int(elements[0], TYPE_NIL)
+		value_type = GdhRead.as_int(elements[1], TYPE_NIL)
 	var entries: Dictionary = {}
 	for key: Variant in value:
 		entries[_values.fitted(key, key_type)] = parse(value[key], value_type)
@@ -709,7 +774,7 @@ func _typed_dictionary(entries: Dictionary, key_type: int, value_type: int) -> D
 	for key: Variant in entries:
 		if key_type != TYPE_NIL and typeof(key) != key_type:
 			return entries
-		if not Serialisation.acceptable(entries[key], value_type):
+		if not GdhSerialisation.acceptable(entries[key], value_type):
 			return entries
 	var fitted: Dictionary = {}
 	for key: Variant in entries:
@@ -720,46 +785,48 @@ func _typed_dictionary(entries: Dictionary, key_type: int, value_type: int) -> D
 ## An array, either positional for a vector the property declares, or a list to parse per item.
 func _parse_array(value: Array, expected_type: int, elements: Array) -> Variant:
 	if PACKED_ELEMENTS.has(expected_type):
-		var element: int = Read.as_int(PACKED_ELEMENTS[expected_type], TYPE_NIL)
+		var element: int = GdhRead.as_int(PACKED_ELEMENTS[expected_type], TYPE_NIL)
 		return value.map(func(item: Variant) -> Variant: return parse(item, element))
 
 	match expected_type:
 		TYPE_VECTOR2:
 			if value.size() == 2:
-				return Vector2(Read.as_float(value[0]), Read.as_float(value[1]))
+				return Vector2(GdhRead.as_float(value[0]), GdhRead.as_float(value[1]))
 		TYPE_VECTOR2I:
 			if value.size() == 2:
-				return Vector2i(Read.as_int(value[0]), Read.as_int(value[1]))
+				return Vector2i(GdhRead.as_int(value[0]), GdhRead.as_int(value[1]))
 		TYPE_VECTOR3:
 			if value.size() == 3:
-				return Vector3(Read.as_float(value[0]), Read.as_float(value[1]), Read.as_float(value[2]))
+				return Vector3(
+					GdhRead.as_float(value[0]), GdhRead.as_float(value[1]), GdhRead.as_float(value[2])
+				)
 		TYPE_VECTOR3I:
 			if value.size() == 3:
-				return Vector3i(Read.as_int(value[0]), Read.as_int(value[1]), Read.as_int(value[2]))
+				return Vector3i(GdhRead.as_int(value[0]), GdhRead.as_int(value[1]), GdhRead.as_int(value[2]))
 		TYPE_VECTOR4:
 			if value.size() == 4:
 				return Vector4(
-					Read.as_float(value[0]),
-					Read.as_float(value[1]),
-					Read.as_float(value[2]),
-					Read.as_float(value[3])
+					GdhRead.as_float(value[0]),
+					GdhRead.as_float(value[1]),
+					GdhRead.as_float(value[2]),
+					GdhRead.as_float(value[3])
 				)
 		TYPE_COLOR:
 			if value.size() == 3 or value.size() == 4:
 				return Color(
-					Read.as_float(value[0]),
-					Read.as_float(value[1]),
-					Read.as_float(value[2]),
-					Read.as_float(value[3]) if value.size() == 4 else 1.0
+					GdhRead.as_float(value[0]),
+					GdhRead.as_float(value[1]),
+					GdhRead.as_float(value[2]),
+					GdhRead.as_float(value[3]) if value.size() == 4 else 1.0
 				)
 
 	var element_type: int = TYPE_NIL
 	if expected_type == TYPE_ARRAY and not elements.is_empty():
-		element_type = Read.as_int(elements[0], TYPE_NIL)
+		element_type = GdhRead.as_int(elements[0], TYPE_NIL)
 	var items: Array = value.map(func(item: Variant) -> Variant: return parse(item, element_type))
 	if element_type == TYPE_NIL or element_type == TYPE_OBJECT:
 		return items
-	if not items.all(func(item: Variant) -> bool: return Serialisation.acceptable(item, element_type)):
+	if not items.all(func(item: Variant) -> bool: return GdhSerialisation.acceptable(item, element_type)):
 		return items
 	var fitted: Array = items.map(func(item: Variant) -> Variant: return type_convert(item, element_type))
 	return Array(fitted, element_type, &"", null)

package/build/godot/operations/reading.gd

@@ -139,3 +139,31 @@ static func missing_below(
 			"its children are " + shown if not children.is_empty() else "it has no children",
 		]
 	)
+
+
+## [param said], the refusal for a [param kind] the scene does not have at [param node_path], with
+## what is there when the scene has a node there, [param found] its class, and [param holders], the
+## paths of the nodes in the scene that are one, so the caller has the path to pass. Names up to
+## [constant NAMED_CHILDREN] of them.
+static func not_of_kind(
+	said: String, node_path: String, found: String, kind: String, holders: PackedStringArray
+) -> String:
+	var told: String = said + ("" if said.ends_with(".") else ".")
+	if not found.is_empty():
+		told += ' The node at "%s" is %s, not %s.' % [node_path, with_article(found), with_article(kind)]
+	if holders.is_empty():
+		return told + " The scene holds no %s." % kind
+	var quoted: PackedStringArray = []
+	for holder: String in holders.slice(0, NAMED_CHILDREN):
+		var _quoted: bool = quoted.append('"%s"' % holder)
+	var shown: String = ", ".join(quoted)
+	if holders.size() > NAMED_CHILDREN:
+		shown += " and %d more" % (holders.size() - NAMED_CHILDREN)
+	if holders.size() == 1:
+		return told + " The scene's %s is at %s." % [kind, shown]
+	return told + " The scene's %ss are at %s." % [kind, shown]
+
+
+## [param word] after the article it takes, "an AnimationTree" or "a Node2D".
+static func with_article(word: String) -> String:
+	return ("an " if word.left(1).to_upper() in ["A", "E", "I", "O", "U"] else "a ") + word

package/build/godot/operations/rename_checks.gd

@@ -1,11 +1,11 @@
 extends RefCounted
 
-const Log = preload("logger.gd")
+const GdhLog = preload("logger.gd")
 
-var _log: Log
+var _log: GdhLog
 
 
-func _init(p_log: Log) -> void:
+func _init(p_log: GdhLog) -> void:
 	_log = p_log
 
 

package/build/godot/operations/resource_files.gd

@@ -1,7 +1,7 @@
 extends RefCounted
 
-const Log = preload("logger.gd")
-const Patterns = preload("patterns.gd")
+const GdhLog = preload("logger.gd")
+const GdhPatterns = preload("patterns.gd")
 
 ## Where the engine keeps a file's UID, by what kind of file it is. Measured on 4.7.2: a script or
 ## shader has a `.uid` file beside it, an imported file has it in its `.import`, and a text scene or
@@ -10,10 +10,10 @@ const Patterns = preload("patterns.gd")
 const SIDECAR_KINDS: Array[String] = ["gd", "gdshader", "gdshaderinc", "cs"]
 const TEXT_RESOURCE_KINDS: Array[String] = ["tscn", "tres", "escn"]
 
-var _log: Log
+var _log: GdhLog
 
 
-func _init(p_log: Log) -> void:
+func _init(p_log: GdhLog) -> void:
 	_log = p_log
 
 
@@ -59,7 +59,7 @@ static func uid_of(file_path: String) -> Dictionary:
 		if file != null:
 			var header: String = file.get_line()
 			file.close()
-			var matched: RegExMatch = Patterns.compiled('\\buid="(uid://[^"]+)"').search(header)
+			var matched: RegExMatch = GdhPatterns.compiled('\\buid="(uid://[^"]+)"').search(header)
 			if matched != null:
 				return {"uid": matched.get_string(1), "from": "the file's header"}
 	var id: int = ResourceLoader.get_resource_uid(file_path)

package/build/godot/operations/script_check.gd

@@ -13,17 +13,17 @@ extends RefCounted
 ## reaches, and every script loaded after it that depends on it compiles in silence, reload() and all.
 ## So a run ends at the first script that raised anything, and the rest go to a fresh engine.
 
-const Read = preload("reading.gd")
-const Log = preload("logger.gd")
+const GdhRead = preload("reading.gd")
+const GdhLog = preload("logger.gd")
 
 ## Where the engine raises a script's compile errors from.
 const RELOAD: String = "GDScript::reload"
 
-var _log: Log
+var _log: GdhLog
 
 
 ## Every compile error the engine raises while it is attached, in order.
-class Caught:
+class GdhCaught:
 	extends Logger
 
 	var raised: Array[Dictionary] = []
@@ -50,7 +50,7 @@ class Caught:
 		)
 
 
-func _init(p_log: Log) -> void:
+func _init(p_log: GdhLog) -> void:
 	_log = p_log
 
 
@@ -62,7 +62,7 @@ func _init(p_log: Log) -> void:
 ## resource cache, so a script loaded for an earlier one is compiled again for its own entry.
 func check_scripts(params: Dictionary) -> Dictionary:
 	var asked: Array = params.get("paths", [])
-	var caught: Caught = Caught.new()
+	var caught: GdhCaught = GdhCaught.new()
 	OS.add_logger(caught)
 	var checked: Array[String] = []
 	var failed: Array[String] = []
@@ -80,7 +80,7 @@ func check_scripts(params: Dictionary) -> Dictionary:
 				if not at in others:
 					others.append(at)
 				continue
-			var found: Dictionary = {"line": Read.as_int(error["line"]), "message": str(error["message"])}
+			var found: Dictionary = {"line": GdhRead.as_int(error["line"]), "message": str(error["message"])}
 			if not found in errors:
 				errors.append(found)
 		if loaded == null and errors.is_empty():