gdharness 1.3.8 → 1.3.10

package/build/godot/operations/scene_connections.gd

@@ -0,0 +1,222 @@
+extends RefCounted
+
+## The signal connections the project's scenes hold that cannot work: a method the node it calls
+## does not have, which fails on every emission, or a signal the node it leaves does not have, which
+## the engine drops as the scene loads. Read from the text of each scene and script, so nothing is
+## loaded and no script runs: a scene loaded to be checked loads every texture and mesh it uses, and
+## a script loaded that does not compile prints its errors here as well as where the scripts check
+## names it.
+##
+## A node whose type or script the text does not settle (a built-in script, a C# one, a child of an
+## instance the scene does not list) is not judged, since nothing here could say it is wrong.
+
+const GdhDependencies = preload("dependencies.gd")
+const GdhFileWalk = preload("file_walk.gd")
+const GdhLog = preload("logger.gd")
+
+const EXT_RESOURCE: String = '^\\[ext_resource [^\\]]*?path="([^"]+)"[^\\]]*? id="([^"]+)"'
+const NODE: String = "^\\[node ([^\\]]*)\\]"
+const CONNECTION: String = "^\\[connection ([^\\]]*)\\]"
+const ATTRIBUTE: String = '(\\w+)="([^"]*)"'
+const INSTANCE: String = 'instance=ExtResource\\(\\s*"([^"]+)"\\s*\\)'
+const SCRIPT_LINE: String = '^script = (Ext|Sub)Resource\\(\\s*"([^"]+)"\\s*\\)'
+const FUNC_LINE: String = "^(?:static\\s+)?func\\s+(\\w+)"
+const SIGNAL_LINE: String = "^signal\\s+(\\w+)"
+const EXTENDS_LINE: String = "^(?:@\\w+\\s+)*(?:class_name\\s+\\w+\\s+)?extends\\s+([^\\s:#]+)"
+
+var _files: GdhFileWalk = GdhFileWalk.new()
+## What each script declares, by path: {class, methods, signals}, or {} when it cannot be read.
+var _scripts: Dictionary = {}
+## What each scene's root is, by path: {class, script}, as a node instancing it is.
+var _roots: Dictionary = {}
+## The class each class_name names, read from the scripts rather than the class cache, which only a
+## scan rewrites.
+var _globals: Dictionary = {}
+
+
+func _init(p_log: GdhLog) -> void:
+	_globals = GdhDependencies.new(p_log).classes_declared()
+
+
+## Every connection that cannot work, as {scene, from, signal, to, method, missing}, where missing is
+## "method" or "signal".
+func broken() -> Array[Dictionary]:
+	var found: Array[Dictionary] = []
+	for scene: String in _files.find_files_with_extensions("res://", ["tscn"]):
+		var content: String = FileAccess.get_file_as_string(scene)
+		var nodes: Dictionary = _nodes_of(content, scene)
+		for attributes: Dictionary in _matches(CONNECTION, content):
+			var from: String = str(attributes.get("from", ""))
+			var to: String = str(attributes.get("to", ""))
+			var signal_name: String = str(attributes.get("signal", ""))
+			var method: String = str(attributes.get("method", ""))
+			# The root by its name, since its path, ".", runs into the member's dot.
+			var root: Dictionary = nodes.get(".", {})
+			var root_name: String = str(root.get("name", "."))
+			var entry: Dictionary = {
+				"scene": scene,
+				"from": root_name if from == "." else from,
+				"signal": signal_name,
+				"to": root_name if to == "." else to,
+				"method": method,
+			}
+			if _lacks(nodes, from, signal_name, "signals"):
+				entry["missing"] = "signal"
+				found.append(entry)
+			elif _lacks(nodes, to, method, "methods"):
+				entry["missing"] = "method"
+				found.append(entry)
+	return found
+
+
+## One line for [param entry], one of [method broken].
+static func broken_line(entry: Dictionary) -> String:
+	var connected: String = (
+		"%s connects %s.%s to %s.%s"
+		% [entry["scene"], entry["from"], entry["signal"], entry["to"], entry["method"]]
+	)
+	if entry["missing"] == "signal":
+		return connected + ", a signal that node does not have, so the engine drops it as the scene loads."
+	return connected + ", a method that node does not have, so every emission fails to call it."
+
+
+## Each node [param content] declares, by its path from the root, as {class, script}, either of
+## which may be "" when the text does not say.
+func _nodes_of(content: String, scene: String) -> Dictionary:
+	var resources: Dictionary = {}
+	var expression: RegEx = RegEx.create_from_string(EXT_RESOURCE)
+	for line: String in content.split("\n"):
+		var matched: RegExMatch = expression.search(line)
+		if matched != null:
+			resources[matched.get_string(2)] = matched.get_string(1)
+	var nodes: Dictionary = {}
+	var node_line: RegEx = RegEx.create_from_string(NODE)
+	var script_line: RegEx = RegEx.create_from_string(SCRIPT_LINE)
+	var instance: RegEx = RegEx.create_from_string(INSTANCE)
+	var current: String = ""
+	for line: String in content.split("\n"):
+		var heading: RegExMatch = node_line.search(line)
+		if heading != null:
+			var attributes: Dictionary = _attributes(heading.get_string(1))
+			var name: String = str(attributes.get("name", ""))
+			var parent: Variant = attributes.get("parent")
+			current = "." if parent == null else (name if parent == "." else "%s/%s" % [parent, name])
+			var node: Dictionary = {"class": str(attributes.get("type", "")), "script": "", "name": name}
+			var instanced: RegExMatch = instance.search(heading.get_string(1))
+			if instanced != null:
+				var root: Dictionary = _root_of(str(resources.get(instanced.get_string(1), "")), scene)
+				node = root.duplicate()
+				node["name"] = name
+			nodes[current] = node
+			continue
+		if line.begins_with("["):
+			current = ""
+			continue
+		var scripted: RegExMatch = script_line.search(line)
+		if scripted != null and nodes.has(current):
+			var node: Dictionary = nodes[current]
+			# A built-in script lives in the scene, where this does not read it, so its node is one
+			# nothing here can judge, which a path that is no script file says.
+			var external: bool = scripted.get_string(1) == "Ext"
+			node["script"] = str(resources.get(scripted.get_string(2), "?")) if external else "built-in"
+	return nodes
+
+
+## What the root of the scene at [param path] is, as [method _nodes_of] gives a node, or a node that
+## says nothing when it cannot be read or instances [param from], which would never end.
+func _root_of(path: String, from: String) -> Dictionary:
+	if _roots.has(path):
+		return _roots[path]
+	_roots[path] = {"class": "", "script": ""}
+	if path.is_empty() or path == from or not path.ends_with(".tscn") or not FileAccess.file_exists(path):
+		return _roots[path]
+	var nodes: Dictionary = _nodes_of(FileAccess.get_file_as_string(path), path)
+	_roots[path] = nodes.get(".", {"class": "", "script": ""})
+	return _roots[path]
+
+
+## Whether the node at [param path] among [param nodes] surely has no [param member] among its
+## [param kind], "methods" or "signals": false whenever what it is cannot be read.
+func _lacks(nodes: Dictionary, path: String, member: String, kind: String) -> bool:
+	if not nodes.has(path):
+		return false
+	var node: Dictionary = nodes[path]
+	var engine_class: String = str(node["class"])
+	var script: String = str(node["script"])
+	if not script.is_empty():
+		var declared: Dictionary = _script(script, {})
+		if declared.is_empty():
+			return false
+		var declared_members: Dictionary = declared[kind]
+		if declared_members.has(member):
+			return false
+		engine_class = str(declared["class"])
+	if engine_class.is_empty() or not ClassDB.class_exists(engine_class):
+		return false
+	if kind == "signals":
+		return not ClassDB.class_has_signal(engine_class, member)
+	return not ClassDB.class_has_method(engine_class, member)
+
+
+## What the script at [param path] declares with every script it extends, as {class, methods,
+## signals}, where class is the engine class at the bottom; {} for one this cannot read through.
+## [param seen] stops a loop of scripts extending each other.
+func _script(path: String, seen: Dictionary) -> Dictionary:
+	if _scripts.has(path):
+		return _scripts[path]
+	if seen.has(path) or not path.ends_with(".gd") or not FileAccess.file_exists(path):
+		return {}
+	seen[path] = true
+	var methods: Dictionary = {}
+	var signals: Dictionary = {}
+	var base: String = "RefCounted"
+	var func_line: RegEx = RegEx.create_from_string(FUNC_LINE)
+	var signal_line: RegEx = RegEx.create_from_string(SIGNAL_LINE)
+	var extends_line: RegEx = RegEx.create_from_string(EXTENDS_LINE)
+	for line: String in FileAccess.get_file_as_string(path).split("\n"):
+		var named: RegExMatch = func_line.search(line)
+		if named != null:
+			methods[named.get_string(1)] = true
+		var sent: RegExMatch = signal_line.search(line)
+		if sent != null:
+			signals[sent.get_string(1)] = true
+		var extended: RegExMatch = extends_line.search(line)
+		if extended != null:
+			base = extended.get_string(1)
+	var engine_class: String = base
+	var base_path: String = ""
+	if base.begins_with('"') or base.begins_with("'"):
+		base_path = base.substr(1, base.length() - 2)
+		if base_path.is_relative_path():
+			base_path = path.get_base_dir().path_join(base_path)
+	elif _globals.has(base):
+		base_path = _globals[base]
+	if not base_path.is_empty():
+		var inherited: Dictionary = _script(base_path, seen)
+		if inherited.is_empty():
+			return {}
+		var inherited_methods: Dictionary = inherited["methods"]
+		var inherited_signals: Dictionary = inherited["signals"]
+		methods.merge(inherited_methods)
+		signals.merge(inherited_signals)
+		engine_class = str(inherited["class"])
+	_scripts[path] = {"class": engine_class, "methods": methods, "signals": signals}
+	return _scripts[path]
+
+
+## The attributes of every line of [param content] [param pattern] matches, one Dictionary each.
+func _matches(pattern: String, content: String) -> Array[Dictionary]:
+	var expression: RegEx = RegEx.create_from_string(pattern)
+	var all: Array[Dictionary] = []
+	for line: String in content.split("\n"):
+		var matched: RegExMatch = expression.search(line)
+		if matched != null:
+			all.append(_attributes(matched.get_string(1)))
+	return all
+
+
+static func _attributes(text: String) -> Dictionary:
+	var attributes: Dictionary = {}
+	for matched: RegExMatch in RegEx.create_from_string(ATTRIBUTE).search_all(text):
+		attributes[matched.get_string(1)] = matched.get_string(2)
+	return attributes

package/build/godot/operations/serialisation.gd

@@ -142,28 +142,29 @@ func serialize_value(value: Variant) -> Variant:
 		return value
 	var carried: Variant = call(serialiser, value)
 	# The fixed shapes carry their components as bare floats, so an infinite one in a Vector2 is
-	# tagged here; containers reach their members through this function already.
-	return carried if typeof(value) in [TYPE_ARRAY, TYPE_DICTIONARY] else _finite(carried)
+	# tagged here, and a 32-bit one shortened; containers reach their members through this already.
+	var type: int = typeof(value)
+	return carried if type in [TYPE_ARRAY, TYPE_DICTIONARY] else _finite(carried, GdhRead.holds_singles(type))
 
 
 # [param carried] with every non-finite float in it tagged. JSON has no spelling for infinity or
 # NaN: the engine writes 1e99999 and null, and the server, reading 1e99999 as Infinity, writes it
 # back out as null, so a property holding INF was answered as holding nothing.
-func _finite(carried: Variant) -> Variant:
+func _finite(carried: Variant, single: bool = false) -> Variant:
 	if carried is float:
 		var number: float = carried
-		return _serialize_float(number)
+		return _serialize_float(GdhRead.single(number) if single else number)
 	if carried is Dictionary:
 		var fields: Dictionary = carried
 		var tagged: Dictionary = {}
 		for key: Variant in fields:
-			tagged[key] = _finite(fields[key])
+			tagged[key] = _finite(fields[key], single)
 		return tagged
 	if carried is Array:
 		var items: Array = carried
 		var tagged_items: Array = []
 		for item: Variant in items:
-			tagged_items.append(_finite(item))
+			tagged_items.append(_finite(item, single))
 		return tagged_items
 	return carried
 
@@ -189,7 +190,7 @@ func _serialize_floats(value: Variant) -> Variant:
 			for each: float in numbers:
 				items.append(_serialize_float(each))
 			return items
-	return value
+	return numbers if value is PackedFloat32Array else value
 
 
 # Rebuilds a Godot value from the shape serialize_value gave it.
@@ -222,8 +223,7 @@ func deserialize_value(value: Variant) -> Variant:
 	# under the target project's warning levels, so one such project lost every headless call.
 	var tag: String = str(fields["_type"])
 	var builder: String = BUILDERS.get(tag, "")
-	var spare: Array = GdhShapes.spare(fields, tag)
-	if builder.is_empty() or not spare.any(func(left: Array) -> bool: return left.is_empty()):
+	if builder.is_empty() or not GdhShapes.buildable(fields, tag):
 		return fields
 	if tag == "float" and str(fields["value"]) not in ["inf", "-inf", "nan"]:
 		return fields
@@ -276,24 +276,7 @@ static func components_of(value: Variant) -> PackedStringArray:
 		TYPE_VECTOR4, TYPE_VECTOR4I, TYPE_QUATERNION:
 			return PackedStringArray(["x", "y", "z", "w"])
 		TYPE_COLOR:
-			return PackedStringArray(
-				[
-					"r",
-					"g",
-					"b",
-					"a",
-					"r8",
-					"g8",
-					"b8",
-					"a8",
-					"h",
-					"s",
-					"v",
-					"ok_hsl_h",
-					"ok_hsl_s",
-					"ok_hsl_l"
-				]
-			)
+			return "r g b a r8 g8 b8 a8 h s v ok_hsl_h ok_hsl_s ok_hsl_l".split(" ")
 		TYPE_RECT2, TYPE_RECT2I, TYPE_AABB:
 			return PackedStringArray(["position", "size", "end"])
 		TYPE_PLANE:
@@ -404,7 +387,8 @@ func fitted(value: Variant, type: int) -> Variant:
 				return built
 
 	if rebuilt is Array and LIST_TYPES.has(type):
-		return type_convert(rebuilt, type)
+		var items: Array = value if value is Array else rebuilt
+		return GdhShapes.packed_from(items, type, fitted)
 
 	# The inspector and every colour picker give a colour as its html code. Anything else stays the
 	# text it is, for the refusal to name.
@@ -704,7 +688,13 @@ func _describe_built_in(resource: Resource) -> Dictionary:
 	var script: Script = null
 	if attached is Script:
 		script = attached
-		described["script"] = serialize_value(script)
+		# By the class its script declares, which a write takes as the _type and which says what it
+		# is: as Resource with the script beside it, one answer named a Shop's built-in item that way
+		# and the file item beside it as an Item.
+		if script.get_global_name().is_empty():
+			described["script"] = serialize_value(script)
+		else:
+			described["_type"] = str(script.get_global_name())
 	var fresh: Object = _fresh(script)
 	for property: Dictionary in resource.get_property_list():
 		var usage: int = property.get("usage", 0)

package/build/godot/operations/setting_reads.gd

@@ -0,0 +1,121 @@
+extends RefCounted
+
+## Project settings read the same way headless and from the open editor, because the two are one
+## question asked of two places: a field one of them left out read as the editor and the file
+## disagreeing about something they agree about.
+
+const GdhRead = preload("reading.gd")
+const GdhSerialisation = preload("serialisation.gd")
+
+
+## One setting: whether the engine knows it, its value, whether that is the engine's default, and
+## the feature overrides that replace it in some builds.
+static func one(setting_path: String, values: GdhSerialisation) -> Dictionary:
+	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"
+
+	# An override exists only while project.godot sets it, so one the file does not set read as a
+	# setting nobody had heard of, when a build with that feature reads its base setting instead.
+	var base: String = override_base(setting_path)
+	if not base.is_empty():
+		result["override_of"] = base
+		if not result["exists"] and ProjectSettings.has_setting(base):
+			result["holds"] = values.serialize_value(ProjectSettings.get_setting(base))
+			result["message"] = overridden_by_none(setting_path, values)
+
+	# 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 = overrides_of(setting_path, values)
+	if not overrides.is_empty():
+		result["overrides"] = overrides
+
+	return result
+
+
+## Every setting whose name starts with [param prefix], with the type the engine registers for
+## each.
+##
+## 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.
+static func under(prefix: String, values: GdhSerialisation) -> Dictionary:
+	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
+		var base: String = override_base(name)
+		if not base.is_empty():
+			described["override_of"] = base
+		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}
+
+
+## The setting [param setting_path] overrides for builds with one feature, as
+## `application/run/max_fps.mobile` does `application/run/max_fps`, or "" for a plain setting.
+static func override_base(setting_path: String) -> String:
+	var dot: int = setting_path.find(".", setting_path.rfind("/") + 1)
+	return "" if dot == -1 else setting_path.substr(0, dot)
+
+
+## The overrides project.godot sets for [param setting_path], by feature.
+static func overrides_of(setting_path: String, values: GdhSerialisation) -> Dictionary:
+	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)
+			)
+	return overrides
+
+
+## What a build with the feature of [param setting_path], an override project.godot does not set,
+## reads in its place.
+static func overridden_by_none(setting_path: String, values: GdhSerialisation) -> String:
+	var base: String = override_base(setting_path)
+	var feature: String = setting_path.substr(base.length() + 1)
+	var said: String = (
+		(
+			"project.godot sets no %s override of %s, so a build with the %s feature reads %s, "
+			+ "the value under holds"
+		)
+		% [feature, base, feature, base]
+	)
+	var others: Array[String] = []
+	for name: String in overrides_of(base, values).keys():
+		if name != feature:
+			others.append(name)
+	if others.is_empty():
+		return said + "."
+	others.sort()
+	return said + (", unless it also has a feature with an override: %s." % ", ".join(others))

package/build/godot/operations/value_shapes.gd

@@ -5,6 +5,22 @@ extends RefCounted
 ##
 ## This file is the one beside the operations, and `bun run sync:gd` copies it into each addon.
 
+const GdhRead = preload("reading.gd")
+
+## What each packed array holds, one value of which every element is fitted to.
+const PACKED_ELEMENTS: Dictionary = {
+	TYPE_PACKED_BYTE_ARRAY: TYPE_INT,
+	TYPE_PACKED_INT32_ARRAY: TYPE_INT,
+	TYPE_PACKED_INT64_ARRAY: TYPE_INT,
+	TYPE_PACKED_FLOAT32_ARRAY: TYPE_FLOAT,
+	TYPE_PACKED_FLOAT64_ARRAY: TYPE_FLOAT,
+	TYPE_PACKED_STRING_ARRAY: TYPE_STRING,
+	TYPE_PACKED_VECTOR2_ARRAY: TYPE_VECTOR2,
+	TYPE_PACKED_VECTOR3_ARRAY: TYPE_VECTOR3,
+	TYPE_PACKED_VECTOR4_ARRAY: TYPE_VECTOR4,
+	TYPE_PACKED_COLOR_ARRAY: TYPE_COLOR,
+}
+
 # What each tag has to carry before it is built. A tag naming a type whose keys are not there is a
 # tag somebody wrote by mistake or wrote for a different shape, and building one out of defaults
 # answers with a Transform2D of zeros where the caller meant something else entirely. Unbuilt, it
@@ -33,6 +49,21 @@ const REQUIRED: Dictionary = {
 	"RID": [["id"]],
 	"Dictionary": [["entries"]],
 }
+## The fields each type reads as numbers. A builder reads a word there as 0, so {"x": 0, "y": "far"}
+## was written as (0, 0) and answered as written.
+const NUMBER_FIELDS: Dictionary = {
+	"Vector2": ["x", "y"],
+	"Vector2i": ["x", "y"],
+	"Vector3": ["x", "y", "z"],
+	"Vector3i": ["x", "y", "z"],
+	"Vector4": ["x", "y", "z", "w"],
+	"Vector4i": ["x", "y", "z", "w"],
+	"Rect2": ["x", "y", "width", "height"],
+	"Rect2i": ["x", "y", "width", "height"],
+	"Plane": ["d"],
+	"Quaternion": ["x", "y", "z", "w"],
+	"Color": ["r", "g", "b", "a"],
+}
 ## The fields a builder reads when they are there and does without when not.
 const OPTIONAL: Dictionary = {
 	"Color": ["a"],
@@ -77,6 +108,86 @@ static func spare(fields: Dictionary, tag: String) -> Array:
 	return lists
 
 
+## Whether a [param tag] built from [param fields] reads every one of them, and each it reads as a
+## number holds one.
+static func buildable(fields: Dictionary, tag: String) -> bool:
+	return (
+		spare(fields, tag).any(func(left: Array) -> bool: return left.is_empty())
+		and not_a_number(fields, tag).is_empty()
+	)
+
+
+## The first field of [param fields] that a [param tag] reads as a number and that holds no number,
+## or "" when there is none. Digits in quotes are a number, as a write takes them for a float.
+static func not_a_number(fields: Dictionary, tag: String) -> String:
+	for key: String in NUMBER_FIELDS.get(tag, []):
+		if fields.has(key) and not _is_number(fields[key]):
+			return key
+	return ""
+
+
+## Whether every item of [param items] is a number, for a list read by its places as a vector.
+static func all_numbers(items: Array) -> bool:
+	return items.all(_is_number)
+
+
+# A float JSON has no number for, infinity or NaN, crosses tagged as {"_type": "float", "value":
+# "inf"}, and is a number.
+static func _is_number(held: Variant) -> bool:
+	if held is int or held is float:
+		return true
+	if held is String:
+		return str(held).is_valid_float()
+	if held is Dictionary:
+		var tagged: Dictionary = held
+		return str(tagged.get("_type", "")) in ["float", "int"] and tagged.has("value")
+	return false
+
+
+## Whether [param value] holds a number with a fractional part where an integer is wanted, in a
+## list or a dictionary as much as bare. The conversion would cut 2.7 to 2 without a word, and a
+## dictionary key arrives as the text "2.7", which reads as the same number.
+static func fraction(value: Variant, type: int, elements: Array = []) -> bool:
+	if type == TYPE_INT:
+		var number: Variant = value
+		if typeof(value) == TYPE_STRING:
+			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 = GdhRead.as_int(PACKED_ELEMENTS.get(type, TYPE_NIL), TYPE_NIL)
+	if type == TYPE_ARRAY and not elements.is_empty():
+		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 = 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
+	return false
+
+
+## The packed array [param type] built from [param items], each fitted by [param fit] to what the
+## array holds, or [param items] as they are when one cannot become that, for the caller to refuse.
+## Element by element, so a point given as its fields is read as one: converted whole, a list of
+## {"x": 3, "y": 4} became zero vectors, and the call ran on them.
+static func packed_from(items: Array, type: int, fit: Callable) -> Variant:
+	var element: int = PACKED_ELEMENTS[type]
+	var numbers: Array[int] = [TYPE_INT, TYPE_FLOAT]
+	var built: Array = []
+	for item: Variant in items:
+		var one: Variant = fit.call(item, element)
+		if typeof(one) != element and not (numbers.has(typeof(one)) and numbers.has(element)):
+			return items
+		built.append(one)
+	return type_convert(built, type)
+
+
 ## The sentences a refusal of [param value] where a [param type] goes ends with: which of its keys
 ## kept it from being read as one, and how one is written. Empty for a type not built from fields.
 ##
@@ -92,7 +203,23 @@ static func remedy(value: Variant, type: int) -> String:
 	var shape: String = written_as(type)
 	if shape.is_empty():
 		return ""
-	return _unread(value, type) + " A %s is sent as %s." % [type_string(type), shape]
+	return (
+		_unread(value, type) + _no_number(value, type) + " A %s is sent as %s." % [type_string(type), shape]
+	)
+
+
+static func _no_number(value: Variant, type: int) -> String:
+	var tag: String = type_string(type)
+	if value is Dictionary:
+		var fields: Dictionary = value
+		var key: String = not_a_number(fields, tag)
+		if not key.is_empty():
+			return " Its %s is %s, which is no number." % [key, JSON.stringify(fields[key])]
+	if value is Array and NUMBER_FIELDS.has(tag):
+		var items: Array = value
+		if not all_numbers(items):
+			return " Read by its places, each item is a number."
+	return ""
 
 
 static func _unread(value: Variant, type: int) -> String:

package/build/godot/tests/listed.gd

@@ -10,8 +10,8 @@ extends SceneTree
 ## its own and reaches gdUnit4 through the project's global classes. Besides the file of suites it
 ## finds each case by its id in a dictionary ([GdhIndexedSession]), can compile the suites together
 ## before gdUnit4 loads them ([constant TOGETHER]), can turn off the reports the caller does
-## not read ([constant REPORTS_OFF]), and writes the errors each suite declares it expects
-## ([constant EXPECTED_OUT]).
+## not read ([constant REPORTS_OFF]), and writes the errors and warnings each suite declares it
+## prints ([constant EXPECTED_OUT]).
 
 const LISTED: String = "--suites-in"
 const SKIPPING: String = "--skipping-in"
@@ -27,11 +27,15 @@ const REPORTS_OFF: Dictionary[String, String] = {
 ## does not compile named. project_test does not: its answer is about the scripts its run reached,
 ## and the compile names every broken script of the game, then once more as the one script it made.
 const TOGETHER: String = "--compile-together"
-## The file to write the errors every suite declares it expects into, as JSON keyed by suite path and
-## then case name.
-const EXPECTED_OUT: String = "--expected-errors-out"
-## The constant a suite declares its expected errors in: case name to the exact texts it prints.
-const EXPECTED: String = "GDHARNESS_EXPECTED_ERRORS"
+## The file to write what every suite declares it prints into, as JSON: each key of
+## [constant EXPECTED] holding the declarations keyed by suite path and then case name.
+const EXPECTED_OUT: String = "--expected-out"
+## The constants a suite declares what it prints on purpose in, case name to the exact texts: its
+## engine errors, and its engine warnings.
+const EXPECTED: Dictionary[String, String] = {
+	"errors": "GDHARNESS_EXPECTED_ERRORS",
+	"warnings": "GDHARNESS_EXPECTED_WARNINGS",
+}
 ## The tool name gdUnit4 reads its options after.
 const TOOL: String = "GdUnitCmdTool.gd"
 ## How long a windowless engine sleeps after each frame. The engine's own default is the
@@ -217,18 +221,18 @@ static func argument_after(args: PackedStringArray, flag: String) -> String:
 	return args[at + 1]
 
 
-## The errors each of [param suites] declares it expects, by suite path and then case name, read off
-## the compiled suite's constants so a declaration is whatever the engine made of it. A directory
+## What each of [param suites] declares in [param constant], by suite path and then case name, read
+## off the compiled suite's constants so a declaration is whatever the engine made of it. A directory
 ## listed is walked for its scripts, as gdUnit4 walks it for suites. Only a script whose source names
 ## the constant is loaded: gdUnit4 stops on a suite that does not load only when its own load is the
 ## one that fails, so a broken suite loaded here first let the rest of its directory run.
-static func expected_by_suite(suites: PackedStringArray) -> Dictionary:
+static func expected_by_suite(suites: PackedStringArray, constant: String) -> Dictionary:
 	var expected: Dictionary = {}
 	for path: String in scripts_in(suites):
-		if not FileAccess.file_exists(path) or not FileAccess.get_file_as_string(path).contains(EXPECTED):
+		if not FileAccess.file_exists(path) or not FileAccess.get_file_as_string(path).contains(constant):
 			continue
 		var suite: Script = load(path)
-		var declared: Variant = suite.get_script_constant_map().get(EXPECTED)
+		var declared: Variant = suite.get_script_constant_map().get(constant)
 		if declared is Dictionary:
 			expected[path] = declared
 	return expected
@@ -259,5 +263,8 @@ static func write_expected(path: String, suites: PackedStringArray) -> void:
 	if file == null:
 		push_error("Could not write the expected errors to %s: %s" % [path, FileAccess.get_open_error()])
 		return
-	var _stored: bool = file.store_string(JSON.stringify(expected_by_suite(suites)))
+	var expected: Dictionary = {}
+	for kind: String in EXPECTED:
+		expected[kind] = expected_by_suite(suites, EXPECTED[kind])
+	var _stored: bool = file.store_string(JSON.stringify(expected))
 	file.close()