gdharness 1.3.7 → 1.3.9

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

@@ -172,6 +172,11 @@ func _cut_asked(params: Dictionary, in_window: bool) -> Dictionary:
 			return _refused(shape % JSON.stringify(region_given))
 		asked["region"] = region
 	if not node_path.is_empty():
+		# Before any refusal of the window: a headless game refused a path that named nothing for
+		# having no window, and the wrong path was found only after a restart with one.
+		var standing: Dictionary = GdhValues.node_at(_host.get_tree().root, node_path)
+		if standing.has("message"):
+			return standing
 		asked["node_path"] = node_path
 	return asked
 

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

@@ -493,6 +493,9 @@ func call_method(params: Dictionary) -> Dictionary:
 		answer["awaited"] = true
 	_keep_reported(answer, "errors", caught.raised)
 	_keep_reported(answer, "warnings", caught.warned)
+	# Main.explode, ended at a null it called into, answered result 0 as if it had counted something.
+	if caught.ended_at.has(named):
+		answer["ended_by_error_at"] = caught.ended_at[named]
 	var asked: Variant = params.get("properties")
 	if _reads_the_result(asked):
 		answer.merge(_read_off_result(result, asked))
@@ -524,7 +527,9 @@ static func _not_a_method_to_call(holder: Object, named: String, called: String)
 				% [called, named]
 			)
 		method = GdhPaths.method_of(named)
-	return "" if holder.has_method(method) else "%s has no method %s" % [called, method]
+	if holder.has_method(method):
+		return ""
+	return GdhPaths.with_methods_offered("%s has no method %s" % [called, method], holder, method)
 
 
 ## Whether a call's `properties` asks for its result to be read: true, or a list of names.

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

@@ -21,15 +21,6 @@ const GdhMouse = preload("runtime_mouse.gd")
 ## everything that process starts. Kept in step with `DESKTOP_VARIABLE` in src/desktop.ts.
 const DESKTOP_VARIABLE: String = "GDHARNESS_DESKTOP"
 
-## Node.ProcessMode as its names, for a refusal to say which one is in force.
-const PROCESS_MODES: Dictionary[int, String] = {
-	Node.PROCESS_MODE_INHERIT: "INHERIT",
-	Node.PROCESS_MODE_PAUSABLE: "PAUSABLE",
-	Node.PROCESS_MODE_WHEN_PAUSED: "WHEN_PAUSED",
-	Node.PROCESS_MODE_ALWAYS: "ALWAYS",
-	Node.PROCESS_MODE_DISABLED: "DISABLED",
-}
-
 ## Whether this run has had the pointer note in full; the game process is the run.
 static var _pointer_explained: bool = false
 
@@ -151,13 +142,17 @@ func inject_action(params: Dictionary) -> Dictionary:
 		return {"type": "error", "message": "Action name required"}
 
 	if not InputMap.has_action(action):
-		return {"type": "error", "message": "Action not found: " + action}
+		return {"type": "error", "message": GdhValues.no_action(action)}
 	var holding: Variant = GdhValues.held_for(params)
 	if holding is String:
 		return {"type": "error", "message": holding}
 	var frames: int = holding
 
+	var focused: String = _focus_owner()
 	_say_action(action, whole or held, strength)
+	var shortcuts: Dictionary = {"shortcuts": [], "shortcut_pressed": null}
+	if whole or held:
+		shortcuts = await GdhValues.press_shortcuts(_host.get_tree().root, action)
 	var lasted: Variant = null
 	if whole:
 		# A frame between the halves at least, as a click has: a listener that acts on the press and
@@ -166,15 +161,36 @@ func inject_action(params: Dictionary) -> Dictionary:
 		_say_action(action, false, strength)
 		await _host.get_tree().process_frame
 
-	return {
-		"type": "input_injected",
-		"input_type": "action",
-		"action": action,
-		"pressed": held and not whole,
-		"whole": whole,
-		"held_frames": GdhValues.held_answer(whole, frames),
-		"held_for": lasted,
-	}
+	return _focus_noted(
+		{
+			"type": "input_injected",
+			"input_type": "action",
+			"action": action,
+			"shortcuts": shortcuts["shortcuts"],
+			"shortcut_pressed": shortcuts["shortcut_pressed"],
+			"pressed": held and not whole,
+			"whole": whole,
+			"held_frames": GdhValues.held_answer(whole, frames),
+			"held_for": lasted,
+		},
+		focused
+	)
+
+
+## The path of the Control holding the keyboard focus, or "" when none does. Read before a key or an
+## action goes in, since pressing a focused button can move the focus.
+func _focus_owner() -> String:
+	var holding: Control = _host.get_viewport().gui_get_focus_owner()
+	return "" if holding == null else str(holding.get_path())
+
+
+## [param said] with [param focused], the Control that had the focus, under focused. A key or an action
+## reaches that Control before the game's _unhandled_input, so Space on a focused Button pressed it
+## and the game's own handler counted the key as well, with nothing in the answer saying why.
+static func _focus_noted(said: Dictionary, focused: String) -> Dictionary:
+	if not focused.is_empty():
+		said["focused"] = focused
+	return said
 
 
 func _say_action(action: String, down: bool, strength: float) -> void:
@@ -230,6 +246,7 @@ func inject_key(params: Dictionary) -> Dictionary:
 	# keys are the code points themselves, which is what makes this a mapping and not a table.
 	event.unicode = GdhValues.glyph_of(event.keycode, event.shift_pressed)
 
+	var focused: String = _focus_owner()
 	Input.parse_input_event(event)
 	var lasted: Variant = null
 	if whole:
@@ -239,20 +256,24 @@ func inject_key(params: Dictionary) -> Dictionary:
 		Input.parse_input_event(up)
 		await _host.get_tree().process_frame
 
-	return {
-		"type": "input_injected",
-		"input_type": "key",
-		"held_frames": GdhValues.held_answer(whole, frames),
-		"held_for": lasted,
-		"keycode": event.keycode,
-		"physical_keycode": event.physical_keycode,
-		"shift": event.shift_pressed,
-		"ctrl": event.ctrl_pressed,
-		"alt": event.alt_pressed,
-		"unicode": event.unicode,
-		"pressed": held and not whole,
-		"whole": whole,
-	}
+	return _focus_noted(
+		{
+			"type": "input_injected",
+			"input_type": "key",
+			"held_frames": GdhValues.held_answer(whole, frames),
+			"held_for": lasted,
+			"keycode": event.keycode,
+			"physical_keycode": event.physical_keycode,
+			"shift": event.shift_pressed,
+			"ctrl": event.ctrl_pressed,
+			"alt": event.alt_pressed,
+			"unicode": event.unicode,
+			"actions": GdhValues.actions_of(event),
+			"pressed": held and not whole,
+			"whole": whole,
+		},
+		focused
+	)
 
 
 ## Clicks a mouse button at a position, and lets go of it again unless asked to hold it.
@@ -293,7 +314,8 @@ func inject_mouse_click(params: Dictionary) -> Dictionary:
 	# its drag from the press, which is where a real pointer would be.
 	var _moved: Vector2 = _arrive(position)
 	var supplied: bool = _follow_in_the_window(position)
-	Input.parse_input_event(_button(position, button, whole or held, double))
+	var press: InputEventMouseButton = _button(position, button, whole or held, double)
+	Input.parse_input_event(press)
 	var lasted: Variant = null
 	if notch:
 		Input.parse_input_event(_button(position, button, false, false))
@@ -302,7 +324,12 @@ func inject_mouse_click(params: Dictionary) -> Dictionary:
 		# press and one that acts on the release each get a frame to do it in.
 		lasted = await GdhValues.hold(_host.get_tree(), frames)
 		Input.parse_input_event(_button(position, button, false, false))
-		await _host.get_tree().process_frame
+	# Input hands the events on at the next frame, so the control under the pointer is read after it.
+	await _host.get_tree().process_frame
+	var hovered: Control = _hover.hovered_in(_host.get_viewport())
+	var hovered_path: Variant = null
+	if hovered != null:
+		hovered_path = str(hovered.get_path())
 
 	var at: Array[Vector2] = [position]
 	var said: Dictionary = _pointer_noted(
@@ -314,6 +341,8 @@ func inject_mouse_click(params: Dictionary) -> Dictionary:
 				"held_for": lasted,
 				"position": [position.x, position.y],
 				"button": button,
+				"hovered": hovered_path,
+				"actions": GdhValues.actions_of(press),
 				"pressed": held and not whole,
 				"whole": whole,
 				"double": double
@@ -629,7 +658,8 @@ func click(params: Dictionary) -> Dictionary:
 	var was_pressed: Variant = null
 	if toggle != null and toggle.toggle_mode:
 		was_pressed = toggle.button_pressed
-	_press_button(viewport, _button(position, button, true, double))
+	var press: InputEventMouseButton = _button(position, button, true, double)
+	_press_button(viewport, press)
 	await _host.get_tree().process_frame
 	_press_button(viewport, _button(position, button, false, false))
 	# The release is what a button acts on, and a queue_free it causes lands at the end of
@@ -651,9 +681,16 @@ func click(params: Dictionary) -> Dictionary:
 		"double": double,
 		"hovered": hovered_path,
 		"landed": landed,
+		"actions": GdhValues.actions_of(press),
 		"control_afterwards": afterwards,
 		"scrolled_into_view": scrolled,
 	}
+	# A Label and a TextureRect ignore the pointer unless told otherwise, so the click goes to what is
+	# under them, and landed false with that control as hovered said nothing of why.
+	if not landed and control.mouse_filter == Control.MOUSE_FILTER_IGNORE:
+		answer["why_not_landed"] = (
+			"%s's mouse_filter is ignore, so the pointer passes through it to what is under it" % node_path
+		)
 	if found != null:
 		answer["found"] = found
 	if was_pressed != null:
@@ -694,7 +731,7 @@ func _takes_no_click(control: Control, node_path: String) -> String:
 			% [node_path, on]
 		)
 	if not control.can_process():
-		var why: String = _why_it_does_not_process(control, node_path)
+		var why: String = GdhTargets.why_it_does_not_process(control, node_path)
 		var over: Node = GdhTargets.drawn_over(control)
 		var cover: String = "" if over == null else "; %s is drawn over it" % over.get_path()
 		if _host.get_tree().paused:
@@ -706,23 +743,6 @@ func _takes_no_click(control: Control, node_path: String) -> String:
 	return ""
 
 
-## Which node's process_mode keeps [param control] from processing, and what it is. A node set to
-## inherit takes its parent's, so the one deciding can be any node above it: the game turning a
-## whole screen off while a menu shows over it reads, on the button, as a button turned off.
-static func _why_it_does_not_process(control: Control, node_path: String) -> String:
-	var deciding: Node = control
-	while deciding.process_mode == Node.PROCESS_MODE_INHERIT and deciding.get_parent() != null:
-		deciding = deciding.get_parent()
-	# The root inherits from nothing, which processes as pausable.
-	var value: int = deciding.process_mode
-	if value == Node.PROCESS_MODE_INHERIT:
-		value = Node.PROCESS_MODE_PAUSABLE
-	var mode: String = PROCESS_MODES.get(value, str(value))
-	if deciding == control:
-		return "its process_mode is %s" % mode
-	return "%s inherits process_mode %s from %s" % [node_path, mode, deciding.get_path()]
-
-
 ## Why a click at [param control]'s centre would reach nothing, or "" when it would reach it: the
 ## centre outside the viewport it is drawn in, at [param local]; outside the viewport showing that
 ## one on the screen, which [param reached] holds with the centre there; or clipped away by a

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

@@ -405,10 +405,13 @@ static func _arity(object: Object, method: String) -> Dictionary:
 ##
 ## A path is read, and a wait reads it every frame, so a call in one has to be a read. The engine
 ## marks its own reading methods const and `queue_free()`, `free()` and `set_name()` not, measured on
-## 4.7.2. A game's methods carry no such mark, so one declared `-> void` is taken at its word, as
-## doing something and answering nothing, and one left untyped is trusted. Without this a find
-## with property "queue_free()" freed every node it matched, and a wait on "advance_day()" called
-## it once a frame and then reported the state it had driven the game to.
+## 4.7.2, though it leaves some reads unmarked as well, `Engine.get_frames_drawn()` and
+## `get_time_scale()` among them; so the refusal says the mark is missing, not that the method
+## changes anything, and points at runtime_invoke call, which calls it. A game's methods carry no
+## such mark, so one declared `-> void` is taken at its word, as doing something and answering
+## nothing, and one left untyped is trusted. Without this a find with property "queue_free()" freed
+## every node it matched, and a wait on "advance_day()" called it once a frame and then reported the
+## state it had driven the game to.
 ##
 ## Given [param given] arguments, a call is the engine's and marked as reading, or it is refused. A
 ## game's method taking arguments is trusted on nothing at all: one answering a value can as well
@@ -416,7 +419,7 @@ static func _arity(object: Object, method: String) -> Dictionary:
 static func call_refused(object: Object, method: String, called_as: String, given: int = 0) -> String:
 	var arity: Dictionary = _arity(object, method)
 	if arity.is_empty():
-		return "%s has no method %s" % [called_as, method]
+		return with_methods_offered("%s has no method %s" % [called_as, method], object, method)
 	var least: int = arity["least"]
 	var most: int = arity["most"]
 	var any_more: bool = arity["any_more"]
@@ -450,10 +453,39 @@ static func call_refused(object: Object, method: String, called_as: String, give
 			)
 		return ""
 	if _native_flags(object, method) & METHOD_FLAG_CONST == 0:
-		return "%s.%s changes what it is called on rather than reading it%s" % [called_as, method, READS_ONLY]
+		return (
+			"%s.%s is not one the engine marks as only reading%s; runtime_invoke call calls it"
+			% [called_as, method, READS_ONLY]
+		)
 	return ""
 
 
+## [param said], a refusal for [param method], which [param object] lacks, with the methods it has
+## nearest the name, or else those its script declares. The engine's own run to hundreds on a node,
+## so they are offered only when one is near.
+static func with_methods_offered(said: String, object: Object, method: String) -> String:
+	var own: Array[String] = []
+	var attached: Variant = object.get_script()
+	if attached is Script:
+		var script: Script = attached
+		for entry: Dictionary in script.get_script_method_list():
+			var name: String = str(entry.get("name", ""))
+			if not name.is_empty() and not own.has(name):
+				own.append(name)
+	var every: Array[String] = own.duplicate()
+	for entry: Dictionary in object.get_method_list():
+		var name: String = str(entry.get("name", ""))
+		if not every.has(name):
+			every.append(name)
+	var close: PackedStringArray = GdhRead.nearest(method, PackedStringArray(every))
+	if not close.is_empty():
+		return "%s; the nearest it has %s %s" % [said, "is" if close.size() == 1 else "are", ", ".join(close)]
+	if own.is_empty():
+		return said
+	own.sort()
+	return "%s; its script declares %s" % [said, ", ".join(PackedStringArray(own))]
+
+
 ## The entry a script attached to [param object] declares for [param method], or an empty one when
 ## the method is the engine's.
 static func _script_method(object: Object, method: String) -> Dictionary:

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

@@ -723,6 +723,8 @@ func get_metrics(params: Dictionary) -> Dictionary:
 		"frame_time": frame_time,
 		"frame_time_max": frame_time_max,
 		"frames_timed": timed,
+		"process_frames": Engine.get_process_frames(),
+		"physics_frames": Engine.get_physics_frames(),
 		"physics_steps_per_second": physics_steps_per_second,
 		"physics_ticks_per_second": Engine.physics_ticks_per_second,
 		"max_physics_steps_per_frame": Engine.max_physics_steps_per_frame,

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

@@ -13,6 +13,15 @@ const GdhWords = preload("runtime_words.gd")
 ## How many of the controls saying the same words a refusal names, with the index for each.
 const LISTED_CANDIDATES: int = 10
 
+## Node.ProcessMode as its names, for a refusal to say which one is in force.
+const PROCESS_MODES: Dictionary[int, String] = {
+	Node.PROCESS_MODE_INHERIT: "INHERIT",
+	Node.PROCESS_MODE_PAUSABLE: "PAUSABLE",
+	Node.PROCESS_MODE_WHEN_PAUSED: "WHEN_PAUSED",
+	Node.PROCESS_MODE_ALWAYS: "ALWAYS",
+	Node.PROCESS_MODE_DISABLED: "DISABLED",
+}
+
 ## What a game started without a window gets whatever the project settings say, and the usual
 ## reason a control is out of reach. Only worth telling somebody when it is what they have.
 const HEADLESS_VIEWPORT: Vector2 = Vector2(64, 64)
@@ -954,3 +963,20 @@ static func _out_of_reach_exactly(nodes: Array[Node], why: Array[String]) -> Str
 	if nodes.size() == 1:
 		return "1 control says exactly that and cannot be clicked: %s" % first
 	return "%d controls say exactly that and cannot be clicked, such as %s" % [nodes.size(), first]
+
+
+## Which node's process_mode keeps [param control] from processing, and what it is. A node set to
+## inherit takes its parent's, so the one deciding can be any node above it: the game turning a
+## whole screen off while a menu shows over it reads, on the button, as a button turned off.
+static func why_it_does_not_process(control: Control, node_path: String) -> String:
+	var deciding: Node = control
+	while deciding.process_mode == Node.PROCESS_MODE_INHERIT and deciding.get_parent() != null:
+		deciding = deciding.get_parent()
+	# The root inherits from nothing, which processes as pausable.
+	var value: int = deciding.process_mode
+	if value == Node.PROCESS_MODE_INHERIT:
+		value = Node.PROCESS_MODE_PAUSABLE
+	var mode: String = PROCESS_MODES.get(value, str(value))
+	if deciding == control:
+		return "its process_mode is %s" % mode
+	return "%s inherits process_mode %s from %s" % [node_path, mode, deciding.get_path()]

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

@@ -31,6 +31,9 @@ const SINGLETONS: Array[String] = [
 ## The most frames a press is held in one call, as many as a frames wait takes.
 const MOST_HELD: int = 600
 
+## Read by [method _key_names], once a game.
+static var _named_keys: PackedStringArray = []
+
 var _shared: GdhSerialisation = GdhSerialisation.new()
 
 
@@ -160,12 +163,7 @@ static func glyph_of(keycode: Key, shifted: bool) -> int:
 ## engine's own names, printable keys and the special ones above [constant KEY_SPECIAL], since the
 ## game takes any name OS.find_keycode_from_string does.
 static func unknown_key(name: String) -> String:
-	var names: PackedStringArray = []
-	for code: int in range(32, 127) + range(KEY_SPECIAL + 1, KEY_SPECIAL + 0x100):
-		var spelled: String = OS.get_keycode_string(code as Key)
-		if not spelled.is_empty() and OS.find_keycode_from_string(spelled) == code:
-			var _named: bool = names.append(spelled)
-	var close: PackedStringArray = GdhRead.nearest(name, names)
+	var close: PackedStringArray = GdhRead.nearest(name, _key_names())
 	var said: String = "No key is called %s." % name
 	if close.size() == 1:
 		said += " The nearest key name is %s." % close[0]
@@ -178,6 +176,107 @@ static func unknown_key(name: String) -> String:
 	)
 
 
+## Every key name the engine takes, read once a game. The engine spells a code it has no name for as
+## the character it would be, and past the last code point that is an error it prints: 136 of them
+## for the special range, two seconds of console on a fast machine, more than a call's whole wait on
+## a loaded one, and each in the game's log as an error the game never made. So they are asked with
+## the engine's error printing off, which no other line of the main thread runs beside.
+static func _key_names() -> PackedStringArray:
+	if not _named_keys.is_empty():
+		return _named_keys
+	var printing: bool = Engine.print_error_messages
+	Engine.print_error_messages = false
+	for code: int in range(32, 127) + range(KEY_SPECIAL + 1, KEY_SPECIAL + 0x100):
+		var spelled: String = OS.get_keycode_string(code as Key)
+		if not spelled.is_empty() and OS.find_keycode_from_string(spelled) == code:
+			var _named: bool = _named_keys.append(spelled)
+	Engine.print_error_messages = printing
+	return _named_keys
+
+
+## The refusal for [param action], which the input map lacks, with the nearest of the project's own
+## actions, or else all of them. The engine's ui_ ones are in every project, and offered for any name
+## they only buried the project's ("dance" is near ui_cancel), so they are offered for a ui_ name only.
+static func no_action(action: String) -> String:
+	var engine: PackedStringArray = []
+	var own: PackedStringArray = []
+	for named: StringName in InputMap.get_actions():
+		if str(named).begins_with("ui_"):
+			var _listed: bool = engine.append(str(named))
+		else:
+			var _owned: bool = own.append(str(named))
+	own.sort()
+	var said: String = "Action not found: %s" % action
+	var close: PackedStringArray = GdhRead.nearest(action, engine if action.begins_with("ui_") else own)
+	if not close.is_empty():
+		return "%s; the nearest %s %s." % [said, "is" if close.size() == 1 else "are", ", ".join(close)]
+	if own.is_empty():
+		return "%s; the project defines no actions of its own, and the engine's are the ui_ ones." % said
+	return "%s; the project's own actions are %s, beside the engine's ui_ ones." % [said, ", ".join(own)]
+
+
+## The actions of the input map that [param event] stands for, as Input reads it for
+## is_action_pressed: a key or a button bound to an action presses that action too, so a game
+## counting the action counted the key, and the answer had said only that a key went in.
+static func actions_of(event: InputEvent) -> Array[String]:
+	var named: Array[String] = []
+	for action: StringName in InputMap.get_actions():
+		if InputMap.event_is_action(event, action):
+			named.append(str(action))
+	named.sort()
+	return named
+
+
+## Presses the buttons under [param root] whose Shortcut [param action] matches, as the player's key
+## bound to it would, and answers their paths under "shortcuts" and the one that took the press
+## under "shortcut_pressed". A Viewport hands a shortcut only keys, joypad buttons and
+## InputEventShortcut, so an action pressed on its own never reached a Button whose Shortcut holds
+## that action, which is how a game gives a button a binding the player can change.
+##
+## A key goes to the shortcuts last in the tree first and stops at the first button that takes it,
+## while an InputEventShortcut reaches only the buttons holding that one Shortcut. So each Shortcut
+## is sent in that order, a frame apart, until a button is pressed; a button still decides by its
+## disabled, its visibility and its shortcut context, as it does for the key.
+static func press_shortcuts(root: Node, action: String) -> Dictionary:
+	var pressing: InputEventAction = InputEventAction.new()
+	pressing.action = action
+	pressing.pressed = true
+	var buttons: Array[BaseButton] = []
+	for node: Node in root.find_children("*", "BaseButton", true, false):
+		var button: BaseButton = node
+		if button.shortcut != null and button.shortcut.matches_event(pressing):
+			buttons.append(button)
+	var paths: Array[String] = []
+	for button: BaseButton in buttons:
+		paths.append(str(button.get_path()))
+	buttons.reverse()
+	var taken: Array[String] = []
+	var heard: Array[Callable] = []
+	for button: BaseButton in buttons:
+		var path: String = str(button.get_path())
+		var hearing: Callable = func() -> void: taken.append(path)
+		heard.append(hearing)
+		var _listening: int = button.pressed.connect(hearing)
+	var sent: Dictionary = {}
+	for button: BaseButton in buttons:
+		if not taken.is_empty():
+			break
+		if sent.has(button.shortcut):
+			continue
+		sent[button.shortcut] = true
+		var through: InputEventShortcut = InputEventShortcut.new()
+		through.shortcut = button.shortcut
+		Input.parse_input_event(through)
+		await root.get_tree().process_frame
+	for at: int in buttons.size():
+		if is_instance_valid(buttons[at]):
+			buttons[at].pressed.disconnect(heard[at])
+	var pressed: Variant = null
+	if not taken.is_empty():
+		pressed = taken[0]
+	return {"shortcuts": paths, "shortcut_pressed": pressed}
+
+
 ## What [param path] names: a node under [param root], as [method node_at] reads it, or an engine
 ## singleton by its name. Answers the object under "object", and under "node" the node that objects
 ## named in a value are found from, which for a singleton is [param root].

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.