gdharness 1.3.9 → 1.3.11

package/build/godot/operations/reading.gd

@@ -193,7 +193,13 @@ static func nearest(word: String, names: PackedStringArray) -> PackedStringArray
 		func(a: String, b: String) -> bool:
 			return a.to_lower().similarity(wanted) > b.to_lower().similarity(wanted)
 	)
-	return PackedStringArray(close.slice(0, 3))
+	# Every name that only adds to the word stays, since cutting at three named three corners of
+	# corner_radius and left out the fourth as if it were not there.
+	var named: PackedStringArray = PackedStringArray(close.slice(0, 3))
+	for name: String in close.slice(3):
+		if name.to_lower().begins_with(wanted):
+			var _added: bool = named.append(name)
+	return named
 
 
 ## [param said], the refusal for [param word], which is not among [param names], with those nearest
@@ -216,6 +222,10 @@ static func near_property(said: String, target: Object, property: String) -> Str
 	var scripted: Array[String] = []
 	for declared: Dictionary in target.get_property_list():
 		var usage: int = as_int(declared.get("usage", 0))
+		if usage & PROPERTY_USAGE_ARRAY:
+			var listed: String = _list_called(target, declared, property)
+			if not listed.is_empty():
+				return "%s; %s" % [said, listed]
 		if not usage & headings:
 			names.append(str(declared.get("name", "")))
 		if usage & PROPERTY_USAGE_SCRIPT_VARIABLE and not usage & headings:
@@ -229,6 +239,46 @@ static func near_property(said: String, target: Object, property: String) -> Str
 	return "%s; its script declares %s" % [said, ", ".join(PackedStringArray(scripted))]
 
 
+## How [param target] keeps the list [param property] names, when that is the label of one of the
+## engine's numbered lists, such as an OptionButton's Items; empty when it is not. The engine has no
+## property by that name, only a count and each entry's fields under a numbered prefix, so "items"
+## was refused with nothing near it to offer.
+static func _list_called(target: Object, count: Dictionary, property: String) -> String:
+	var parts: PackedStringArray = str(count.get("class_name", "")).split(",")
+	if parts.size() != 2 or _bare(parts[0]) != _bare(property):
+		return ""
+	var counted: String = str(count.get("name", ""))
+	var first: String = parts[1] + "0/"
+	var fields: PackedStringArray = _fields_at(target, first)
+	if fields.is_empty() and ClassDB.can_instantiate(target.get_class()):
+		var fresh: Object = ClassDB.instantiate(target.get_class())
+		fresh.set(counted, 1)
+		fields = _fields_at(fresh, first)
+		if not fresh is RefCounted:
+			fresh.free()
+	var each: String = "each one's fields" if fields.is_empty() else "each one's %s" % ", ".join(fields)
+	return (
+		(
+			"it keeps its %s as %s, how many there are, and %s under %s for the first, %s for the second and so on: "
+			+ "give %s before the fields of the entries it makes"
+		)
+		% [parts[0].to_lower(), counted, each, first, parts[1] + "1/", counted]
+	)
+
+
+static func _fields_at(target: Object, prefix: String) -> PackedStringArray:
+	var fields: PackedStringArray = PackedStringArray()
+	for declared: Dictionary in target.get_property_list():
+		var name: String = str(declared.get("name", ""))
+		if name.begins_with(prefix):
+			var _added: bool = fields.append(name.trim_prefix(prefix))
+	return fields
+
+
+static func _bare(word: String) -> String:
+	return word.to_lower().replace("_", "").replace(" ", "")
+
+
 ## The signals [param object] has that a caller can connect, its own class's first: the engine
 ## lists them from Object down, which puts a Button's pressed after thirty a Control has, and names
 ## starting with an underscore are the engine's own.

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

@@ -223,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
@@ -277,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:
@@ -405,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.
@@ -705,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: