gdharness 1.3.8 → 1.3.10

package/build/godot/addons/gdharness_runtime/runtime_waits.gd

@@ -27,12 +27,40 @@ const LOOKS_APART: int = 9
 ## two looks and a wait for 32 never sees it.
 const COMPARES: Array[String] = ["==", "!=", ">=", "<=", ">", "<"]
 
-## The most signal watches kept at once; arming one past this lets the oldest go.
+## The most signal watches kept at once; arming one past this lets the oldest go. Property watches
+## are counted apart, to the same number.
 const MOST_WATCHES: int = 16
 
+## The most changes a property watch keeps. Past it, each new one takes the last place, so what is
+## kept still ends on the latest value.
+const MOST_CHANGES: int = 1000
+
+## The commands that can change the game, by the tool call that sends each, which a property watch
+## notes as they arrive.
+const CALLS_NAMED: Dictionary[String, String] = {
+	"set_property": "runtime_invoke set",
+	"call_method": "runtime_invoke call",
+	"click": "runtime_input click",
+	"choose": "runtime_input choose",
+	"inject_action": "runtime_input action",
+	"inject_key": "runtime_input key",
+	"inject_text": "runtime_input text",
+	"inject_mouse_click": "runtime_input mouse_click",
+	"inject_mouse_motion": "runtime_input mouse_motion",
+	"inject_mouse_drag": "runtime_input mouse_drag",
+	"inject_joypad_button": "runtime_input joypad_button",
+	"inject_joypad_motion": "runtime_input joypad_motion",
+}
+
+## What a call noted by a property watch carries of its parameters, when it was given them.
+const CALL_FIELDS: Array[String] = [
+	"path", "method", "property", "action", "keycode", "button", "pressed", "says"
+]
+
 var _host: Node
 var _values: GdhValues
 var _watches: Dictionary[int, GdhWatch] = {}
+var _traces: Dictionary[int, GdhTrace] = {}
 var _next_watch: int = 1
 
 
@@ -110,9 +138,10 @@ func wait_signal(params: Dictionary) -> Dictionary:
 	}
 	if not catcher.fired:
 		answer["note"] = (
-			"If a call meant to set the signal off was sent beside this wait, it may have run only after"
-			+ " the wait answered, as a client can run its calls in turn: arm runtime_wait watch first,"
-			+ " make the call, then wait with signal and that watch"
+			"A wait hears the signal only from when it begins, so one that fired before it is not"
+			+ " counted. If a call meant to set the signal off was sent beside this wait, it may have run"
+			+ " only after the wait answered, as a client can run its calls in turn: arm runtime_wait"
+			+ " watch first, make the call, then wait with signal and that watch"
 		)
 	return answer
 
@@ -125,6 +154,18 @@ func wait_signal(params: Dictionary) -> Dictionary:
 func watch_signal(params: Dictionary) -> Dictionary:
 	var node_path: String = str(params.get("path", ""))
 	var signal_name: String = str(params.get("signal", ""))
+	var property: String = str(params.get("property", ""))
+	if not signal_name.is_empty() and not property.is_empty():
+		return {
+			"type": "error",
+			"message":
+			(
+				"A watch records a signal or a property, not both: this one has signal %s and property %s"
+				% [signal_name, property]
+			)
+		}
+	if not property.is_empty():
+		return _watch_property(node_path, property)
 	if node_path.is_empty() or signal_name.is_empty():
 		return {"type": "error", "message": "Node path and signal name required"}
 	var standing: Dictionary = GdhValues.node_at(_host.get_tree().root, node_path)
@@ -149,6 +190,15 @@ func watch_signal(params: Dictionary) -> Dictionary:
 ## Answers at once with the first emission recorded since watch [param id] was armed, otherwise
 ## waits for the next until the time runs out. The watch goes either way.
 func _collect(id: int, timeout_ms: int) -> Dictionary:
+	if _traces.has(id):
+		return {
+			"type": "error",
+			"message":
+			(
+				"Watch %d records %s:%s, a property, and is collected with runtime_wait recorded"
+				% [id, _traces[id].node_path, _traces[id].property]
+			)
+		}
 	if not _watches.has(id):
 		return {
 			"type": "error",
@@ -194,6 +244,153 @@ func _let_go(id: int) -> void:
 		node.disconnect(watch.signal_name, callable)
 
 
+## Starts recording [param property] every frame and answers at once with the watch and what it
+## reads now.
+##
+## A tween or an animation is over before a client's next call reaches the game: a slide of 0.3
+## seconds had finished by the time a wait sent after the click began, so its middle could be read
+## only by slowing the game's clock. Armed before the click, the watch has every frame of it.
+func _watch_property(node_path: String, property: String) -> Dictionary:
+	if node_path.is_empty():
+		return {"type": "error", "message": "Node path required"}
+	var standing: Dictionary = GdhValues.node_at(_host.get_tree().root, node_path)
+	if standing.has("message"):
+		return standing
+	var node: Node = standing["node"]
+	var watched: Dictionary = _watched(node, node_path, property)
+	if watched.has("message"):
+		return watched
+	var trace: GdhTrace = GdhTrace.new(node, node_path, property)
+	trace.see(0, 0, 0.0, watched["value"], _values)
+	while _traces.size() >= MOST_WATCHES:
+		var _gone: bool = _traces.erase(_traces.keys().min())
+	var id: int = _next_watch
+	_next_watch += 1
+	_traces[id] = trace
+	# Left to run across frames while the answer goes now. Deferred calls run once the frame's
+	# _process is done and before its tweens step, so the recording starts in the frame it was armed in.
+	_record.call_deferred(trace)
+	return {
+		"type": "watching",
+		"watch": id,
+		"path": node_path,
+		"property": property,
+		"value": _values.serialize(watched["value"]),
+	}
+
+
+## Reads the watched property at the start of every frame until the watch is collected, the node
+## goes or the ceiling a wait has is reached.
+##
+## Read where a frame begins, which is after the last one's tweens and _process ran: the game time
+## beside each reading is the time those had been given, which counts the frame the watch was armed
+## in, since commands run before that frame's tweens step.
+func _record(trace: GdhTrace) -> void:
+	var started: int = Time.get_ticks_msec()
+	var given: float = _host.get_process_delta_time()
+	var game_time: float = 0.0
+	var frame: int = 0
+	while not trace.collected:
+		await _host.get_tree().process_frame
+		if trace.collected:
+			return
+		frame += 1
+		game_time += given
+		given = _host.get_process_delta_time()
+		var elapsed: int = Time.get_ticks_msec() - started
+		var held: Object = trace.node.get_ref()
+		var node: Node = held as Node
+		if node == null:
+			trace.ended = "%s was freed %d frames after the watch was armed" % [trace.node_path, frame]
+			return
+		var watched: Dictionary = _watched(node, trace.node_path, trace.property)
+		if watched.has("message"):
+			trace.ended = "%d frames after the watch was armed: %s" % [frame, watched["message"]]
+			return
+		trace.see(frame, elapsed, game_time, watched["value"], _values)
+		trace.frames = frame
+		trace.elapsed_ms = elapsed
+		if elapsed >= CEILING_MSEC:
+			trace.ended = (
+				"recording stopped %d ms after the watch was armed, the longest a wait lasts" % elapsed
+			)
+			return
+
+
+## Notes [param command] in every property watch still recording, beside the last reading taken
+## before it ran, so a recording shows where the call that started a change landed. A call two
+## round trips apart from another lands dozens of frames later, which only this tells apart from
+## the game's own delay.
+func saw_call(command: String, params: Dictionary) -> void:
+	var named: String = CALLS_NAMED.get(command, "")
+	if named.is_empty():
+		return
+	for trace: GdhTrace in _traces.values():
+		if trace.collected or not trace.ended.is_empty():
+			continue
+		if trace.calls.size() >= MOST_CHANGES:
+			trace.calls_dropped += 1
+			continue
+		var noted: Dictionary = {"frame": trace.frames, "call": named}
+		for field: String in CALL_FIELDS:
+			if params.has(field):
+				noted[field] = params[field]
+		trace.calls.append(noted)
+
+
+## What a property watch recorded, each change with the frame, the time and the game time it was
+## read at. The watch goes with the answer.
+func recorded(params: Dictionary) -> Dictionary:
+	var id: int = GdhRead.as_int(params.get("watch", 0), 0)
+	if _watches.has(id):
+		return {
+			"type": "error",
+			"message":
+			(
+				"Watch %d records the signal %s of %s, and is collected with runtime_wait signal"
+				% [id, _watches[id].signal_name, _watches[id].node_path]
+			)
+		}
+	if not _traces.has(id):
+		return {
+			"type": "error",
+			"message":
+			(
+				(
+					"No property watch %d is armed in this game: it was collected already, %d armed after"
+					+ " it let it go, or the game started again since"
+				)
+				% [id, MOST_WATCHES]
+			),
+		}
+	var trace: GdhTrace = _traces[id]
+	trace.collected = true
+	var _gone: bool = _traces.erase(id)
+	var answer: Dictionary = {
+		"type": "recorded",
+		"watch": id,
+		"path": trace.node_path,
+		"property": trace.property,
+		"changes": trace.changes,
+		"calls": trace.calls,
+		"frames": trace.frames,
+		"elapsed_ms": trace.elapsed_ms,
+	}
+	if trace.calls_dropped > 0:
+		answer["calls_dropped"] = trace.calls_dropped
+	if trace.dropped > 0:
+		answer["dropped"] = (
+			(
+				"%d changes are left out: past %d, each new one took the last place, so the list ends on"
+				+ " the latest"
+			)
+			% [trace.dropped, MOST_CHANGES]
+		)
+	if not trace.ended.is_empty():
+		answer["ended"] = trace.ended
+	return answer
+
+
 ## Waits until a property reads as the value given, or until something under the path says what
 ## was given, or the time runs out, and answers with what it read last either way.
 func wait_until(params: Dictionary) -> Dictionary:
@@ -305,7 +502,7 @@ func wait_until(params: Dictionary) -> Dictionary:
 			return watched
 		current = watched["value"]
 
-	return {
+	var answer: Dictionary = {
 		"type": "condition",
 		"path": node_path,
 		"property": property,
@@ -315,6 +512,16 @@ func wait_until(params: Dictionary) -> Dictionary:
 		"elapsed_ms": Time.get_ticks_msec() - started,
 		"frames": frames,
 	}
+	# Said rather than refused, since a game may store a number no value has, as set says it stores
+	# one: a wait for 7 on an enum of three ran its whole timeout and answered only that it was not met.
+	if watched["holder"] is Object:
+		var owner: Object = watched["holder"]
+		var shown: String = JSON.stringify(_values.serialize(wanted), "", false)
+		var declaration: Dictionary = watched["declaration"]
+		var outside: String = GdhDeclared.outside(owner, declaration, wanted, shown)
+		if not outside.is_empty():
+			answer["outside_declared"] = outside
+	return answer
 
 
 ## What a property wait is missing or was given wrongly, or "" when it can go ahead.
@@ -589,7 +796,7 @@ func _wait_until_said(node_path: String, said: String, timeout_ms: int, include_
 		looks += 1
 		looked_usec += Time.get_ticks_usec() - last
 
-	return {
+	var answer: Dictionary = {
 		"type": "condition",
 		"path": node_path,
 		"says": said,
@@ -600,12 +807,24 @@ func _wait_until_said(node_path: String, said: String, timeout_ms: int, include_
 		"looks": looks,
 		"looking_ms": looked_usec / 1000.0,
 	}
+	# Words that are there and cannot be read look, from a wait that ran out, like words that never
+	# came.
+	if not found and not include_hidden and _anything_says(node_path, said, true):
+		answer["unseen_note"] = (
+			(
+				"Something under %s says it, but is hidden or drawn outside the viewport or a"
+				+ " ScrollContainer, where the player cannot read it; includeHidden true counts it there too"
+			)
+			% node_path
+		)
+	return answer
 
 
-## Whether anything under [param node_path] says [param said], the node itself included, and shown
-## unless hidden ones are wanted too. Matched as a find and a click match `says`, a glob over the
-## whole text when it has `*` or `?`: read as literal words, a glob a click had just pressed by was
-## waited on for the whole timeout with its label on screen, and answered as words never arriving.
+## Whether anything under [param node_path] says [param said], the node itself included, and where
+## the player can read it unless hidden ones are wanted too. Matched as a find and a click match
+## `says`, a glob over the whole text when it has `*` or `?`: read as literal words, a glob a click
+## had just pressed by was waited on for the whole timeout with its label on screen, and answered as
+## words never arriving.
 func _anything_says(node_path: String, said: String, include_hidden: bool) -> bool:
 	var root: Node = _host.get_tree().root.get_node_or_null(node_path)
 	if root == null:
@@ -613,7 +832,7 @@ func _anything_says(node_path: String, said: String, include_hidden: bool) -> bo
 	var pending: Array[Node] = [root]
 	while not pending.is_empty():
 		var node: Node = pending.pop_back()
-		if GdhSays.says(node, said) and (include_hidden or GdhQueries.shown(node)):
+		if GdhSays.says(node, said) and (include_hidden or GdhQueries.readable(node)):
 			return true
 		pending.append_array(node.get_children(true))
 	return false
@@ -637,6 +856,55 @@ class GdhSignalCatcher:
 		times += 1
 
 
+## A property recorded from when it was armed until it is collected: the reading at arming, then
+## each frame's that differs from the one before.
+class GdhTrace:
+	extends RefCounted
+	var node: WeakRef
+	var node_path: String
+	var property: String
+	var changes: Array[Dictionary] = []
+	var dropped: int = 0
+	var calls: Array[Dictionary] = []
+	var calls_dropped: int = 0
+	var frames: int = 0
+	var elapsed_ms: int = 0
+	var ended: String = ""
+	var collected: bool = false
+	var _last: Variant = null
+	var _seen: bool = false
+
+	func _init(watched: Node, path: String, named: String) -> void:
+		node = weakref(watched)
+		node_path = path
+		property = named
+
+	func see(frame: int, elapsed: int, game_time: float, value: Variant, values: GdhValues) -> void:
+		if _seen and typeof(value) == typeof(_last) and value == _last:
+			return
+		_seen = true
+		# A copy of a list or a map, which the game may change in place: held as it is, the reading
+		# kept is the game's own, and it reads the same as every later one.
+		_last = value
+		if value is Array:
+			var list: Array = value
+			_last = list.duplicate(true)
+		elif value is Dictionary:
+			var map: Dictionary = value
+			_last = map.duplicate(true)
+		var change: Dictionary = {
+			"frame": frame,
+			"elapsed_ms": elapsed,
+			"game_time": snappedf(game_time, 0.0001),
+			"value": values.serialize(value),
+		}
+		if changes.size() < MOST_CHANGES:
+			changes.append(change)
+		else:
+			changes[changes.size() - 1] = change
+			dropped += 1
+
+
 ## A signal recorded from when it was armed until it is collected.
 class GdhWatch:
 	extends RefCounted

package/build/godot/addons/gdharness_runtime/runtime_words.gd

@@ -55,6 +55,33 @@ static func lines_said_by(node: Node) -> Array[String]:
 	return lines
 
 
+## The node [param node] is drawn as a copy of, or null: the nearest node above it that says
+## anything, when it says the same words, followed up while that one is a copy in turn. A word drawn
+## with an outline or a glow is often a label holding copies of itself, offset or tinted, and a
+## player reads one sign where a find counted four.
+static func copied_from(node: Node) -> Node:
+	var chain: Array[Node] = copied_through(node)
+	return null if chain.is_empty() else chain.back()
+
+
+## Every node above [param node] that it is drawn as a copy of, nearest first: see
+## [method copied_from], which is the last of them.
+static func copied_through(node: Node) -> Array[Node]:
+	var chain: Array[Node] = []
+	var words: String = said_by(node)
+	if words.is_empty():
+		return chain
+	var above: Node = node.get_parent()
+	while above != null:
+		var said: String = said_by(above)
+		if not said.is_empty():
+			if said != words:
+				break
+			chain.append(above)
+		above = above.get_parent()
+	return chain
+
+
 ## Each item [param node] draws as one of a list, as {"says", "item"}: a tab, a menu title, a list
 ## entry or a menu item by its index, and a tree row by its TreeItem. Empty for a node drawing none.
 ## Held apart rather than joined, so a click on a tab's title presses that tab: the bar's middle is

package/build/godot/addons/gdharness_runtime/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/addons/gdharness_runtime/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: