gdharness 1.2.24 → 1.2.26

package/build/godot/addons/gdharness_editor/serialisation.gd

@@ -321,11 +321,25 @@ static func acceptable(value: Variant, type: int) -> bool:
 ## The conversion is also what restores a packed array's exact type. Those cross as the plain JSON
 ## lists they fit into, so what comes back from the wire is an Array, and the parameter is what says
 ## it was a PackedStringArray.
+##
+## A dictionary with no tag is read as the type wanted when it carries that type's fields, as
+## scene_node and resource_edit read one: runtime_invoke refused {"x": 140, "y": 300} for a Vector2
+## argument the editor tools took, so one value was right for one tool and wrong for the next. The
+## value as sent is what is tagged, since the builders read a nested vector from its own fields.
 func fitted(value: Variant, type: int) -> Variant:
 	var rebuilt: Variant = deserialize_value(value)
 	if type == TYPE_NIL or typeof(rebuilt) == type:
 		return rebuilt
 
+	if value is Dictionary and type != TYPE_DICTIONARY:
+		var fields: Dictionary = value
+		if not fields.has("_type"):
+			var tagged: Dictionary = fields.duplicate()
+			tagged["_type"] = type_string(type)
+			var built: Variant = deserialize_value(tagged)
+			if typeof(built) == type:
+				return built
+
 	if rebuilt is Array and LIST_TYPES.has(type):
 		return type_convert(rebuilt, type)
 
@@ -348,6 +362,21 @@ func fitted(value: Variant, type: int) -> Variant:
 	return type_convert(rebuilt, type)
 
 
+## How a value of [param type] is written to be read as one, for a refusal to name, or empty for a
+## type that is not built from fields. A refusal naming only the two types left a caller to find
+## the shape in the description of another op.
+static func written_as(type: int) -> String:
+	var tag: String = type_string(type)
+	var alternatives: Array = REQUIRED.get(tag, [])
+	if alternatives.is_empty() or tag == "float" or tag == "Dictionary":
+		return ""
+	var keys: Array = alternatives[0]
+	var parts: Array[String] = []
+	for key: Variant in keys:
+		parts.append('"%s": ...' % key)
+	return "{%s}" % ", ".join(parts)
+
+
 ## Whether [param fields] carries every key of any one of [param alternatives].
 ##
 ## More than one spelling because a rectangle has two: the two corners it is answered with, and the

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

@@ -0,0 +1,290 @@
+extends RefCounted
+
+## What the running game tells a screen reader: its accessibility tree, as UI Automation reads it.
+##
+## The engine builds the tree only when something asks for it, and nothing on gdharness's desktop
+## does, so a game's NOTIFICATION_ACCESSIBILITY_UPDATE never came and what its controls expose could
+## not be checked. The engine offers no way to read the tree back, so the question is put the way a
+## screen reader puts it: a UI Automation client started by the game lands on the game's own desktop,
+## its first question makes the engine build the tree, and what it reads is what a screen reader is
+## told, names left empty included.
+
+const Read = preload("reading.gd")
+
+## How long the client keeps walking the tree for it to settle: the engine answers the first question
+## with its windows alone and fills them in over the next frames.
+const SETTLE_MS: int = 8000
+## How long a window with nothing in it is walked before the client stops: a game building its tree
+## fills the window within a few frames of being asked, and one building none never does.
+const EMPTY_MS: int = 4000
+## How long the client may take beyond that, starting PowerShell and loading UI Automation included,
+## before it is stopped and the call answers that it did not finish.
+const START_MS: int = 15000
+## Deep enough for any interface a game builds, and inside the hundred levels ConvertTo-Json stops
+## at, which are two to a level of the tree.
+const MOST_LEVELS: int = 40
+
+## The client, as PowerShell, with $Handles, $Out, $SettleMs, $EmptyMs and $MostLevels set before it. Each
+## element answers what UI Automation names its role, its name, its value where it has one, its
+## bounds in the window's pixels, and the actions a screen reader is offered on it.
+const WALK: String = r"""
+$ErrorActionPreference = 'Stop'
+function Answer($value) {
+  [System.IO.File]::WriteAllText($Out, (ConvertTo-Json -InputObject $value -Depth 100 -Compress))
+}
+try {
+  Add-Type -AssemblyName UIAutomationClient, UIAutomationTypes
+  $walker = [System.Windows.Automation.TreeWalker]::RawViewWalker
+  function Patterned($element, $name) {
+    $pattern = ("System.Windows.Automation.$($name)Pattern" -as [type])::Pattern
+    $found = $null
+    if ($element.TryGetCurrentPattern($pattern, [ref]$found)) { return $found }
+    return $null
+  }
+  function Describe($element, $ox, $oy, $depth) {
+    $c = $element.Current
+    $role = $c.ControlType.ProgrammaticName -replace '^ControlType[.]', ''
+    $role = ($role -creplace '(?<=[a-z])(?=[A-Z])', '_').ToLowerInvariant()
+    $node = [ordered]@{ role = $role; name = $c.Name }
+    if ($c.HelpText) { $node.description = $c.HelpText }
+    $r = $c.BoundingRectangle
+    if (-not $r.IsEmpty) {
+      $node.bounds = [ordered]@{ x = [int]($r.X - $ox); y = [int]($r.Y - $oy) }
+      $node.bounds.width = [int]$r.Width
+      $node.bounds.height = [int]$r.Height
+    }
+    $actions = @()
+    if (Patterned $element 'Invoke') { $actions += 'click' }
+    $p = Patterned $element 'Toggle'
+    if ($p) { $actions += 'toggle'; $node.toggled = "$($p.Current.ToggleState)".ToLowerInvariant() }
+    $p = Patterned $element 'ExpandCollapse'
+    if ($p) {
+      $actions += 'expand_collapse'
+      $node.expanded = "$($p.Current.ExpandCollapseState)".ToLowerInvariant()
+    }
+    $p = Patterned $element 'SelectionItem'
+    if ($p) { $actions += 'select'; $node.selected = $p.Current.IsSelected }
+    $p = Patterned $element 'Value'
+    if ($p) {
+      $node.value = $p.Current.Value
+      if (-not $p.Current.IsReadOnly) { $actions += 'set_value' }
+    }
+    $p = Patterned $element 'RangeValue'
+    if ($p) {
+      $node.value = $p.Current.Value
+      $node.range = @($p.Current.Minimum, $p.Current.Maximum)
+      if (-not $p.Current.IsReadOnly) { $actions += 'set_value' }
+    }
+    if (Patterned $element 'ScrollItem') { $actions += 'scroll_into_view' }
+    if ($c.IsKeyboardFocusable) { $actions += 'focus' }
+    $node.actions = $actions
+    if ($c.HasKeyboardFocus) { $node.focused = $true }
+    if (-not $c.IsEnabled) { $node.disabled = $true }
+    if ($c.IsOffscreen) { $node.offscreen = $true }
+    $children = @()
+    if ($depth -lt $MostLevels) {
+      $child = $walker.GetFirstChild($element)
+      while ($null -ne $child) {
+        $children += , (Describe $child $ox $oy ($depth + 1))
+        $child = $walker.GetNextSibling($child)
+      }
+    }
+    $node.children = $children
+    return $node
+  }
+  function Count($node) {
+    $n = 1
+    foreach ($child in $node.children) { $n += Count $child }
+    return $n
+  }
+  $windows = @()
+  foreach ($handle in $Handles) {
+    $root = [System.Windows.Automation.AutomationElement]::FromHandle([IntPtr][long]$handle)
+    $r = $root.Current.BoundingRectangle
+    $deadline = [DateTime]::UtcNow.AddMilliseconds($SettleMs)
+    $empty = [DateTime]::UtcNow.AddMilliseconds($EmptyMs)
+    $tree = Describe $root $r.X $r.Y 0
+    $last = Count $tree
+    # Walked again until two walks in a row agree, since the first question is what makes the
+    # engine build the tree, which arrives over the frames after it.
+    while ([DateTime]::UtcNow -lt $deadline) {
+      Start-Sleep -Milliseconds 150
+      $tree = Describe $root $r.X $r.Y 0
+      $count = Count $tree
+      if ($count -gt 1 -and $count -eq $last) { break }
+      if ($count -eq 1 -and [DateTime]::UtcNow -gt $empty) { break }
+      $last = $count
+    }
+    $windows += , $tree
+  }
+  Answer @{ windows = $windows }
+} catch {
+  Answer @{ error = "$_" }
+}
+"""
+
+var _host: Node
+
+
+func _init(host: Node) -> void:
+	_host = host
+
+
+## The game's windows as a screen reader is told them, each a tree of elements.
+func get_accessibility(_params: Dictionary) -> Dictionary:
+	if DisplayServer.get_name() == "headless":
+		return _refused(
+			(
+				"A headless run has no window, so a screen reader is told nothing: start the run with"
+				+ " headless: false."
+			)
+		)
+	if OS.get_name() != "Windows":
+		return _refused(
+			(
+				(
+					"The tree is read through UI Automation, the interface a Windows screen reader uses, and this"
+					+ " game runs on %s, whose screen readers ask it through another"
+				)
+				% OS.get_name()
+			)
+		)
+	var handles: Array[String] = []
+	var ids: Array[int] = []
+	for id: int in DisplayServer.get_window_list():
+		var handle: int = DisplayServer.window_get_native_handle(DisplayServer.WINDOW_HANDLE, id)
+		if handle != 0:
+			handles.append(str(handle))
+			ids.append(id)
+
+	var out: String = OS.get_temp_dir().path_join(
+		"gdharness-accessibility-%d-%d.json" % [OS.get_process_id(), Time.get_ticks_usec()]
+	)
+	var script: String = (
+		(
+			"$Handles = @(%s)\n$Out = '%s'\n$SettleMs = %d\n$EmptyMs = %d\n$MostLevels = %d\n"
+			% [", ".join(handles), out.replace("'", "''"), SETTLE_MS, EMPTY_MS, MOST_LEVELS]
+		)
+		+ WALK
+	)
+	# The system's own PowerShell by its path, so a powershell.exe earlier on PATH is not what runs.
+	var shell: String = OS.get_environment("SystemRoot").path_join(
+		"System32/WindowsPowerShell/v1.0/powershell.exe"
+	)
+	var pid: int = (
+		OS
+		. create_process(
+			shell,
+			[
+				"-NoProfile",
+				"-NonInteractive",
+				"-EncodedCommand",
+				Marshalls.raw_to_base64(script.to_utf16_buffer()),
+			]
+		)
+	)
+	if pid <= 0:
+		return _refused("PowerShell could not be started from %s to read the tree" % shell)
+	# Waited out a frame at a time rather than blocking: the client's questions are answered on the
+	# game's main thread, which a blocking wait would hold, and neither side would move.
+	var deadline: int = Time.get_ticks_msec() + SETTLE_MS + START_MS
+	while OS.is_process_running(pid):
+		if Time.get_ticks_msec() > deadline:
+			var _killed: Error = OS.kill(pid)
+			return _refused(
+				"UI Automation had not read the tree after %d ms, so it was stopped" % (SETTLE_MS + START_MS)
+			)
+		await _host.get_tree().process_frame
+
+	var text: String = FileAccess.get_file_as_string(out)
+	# Not checked: a file that is not there was never written, which the answer below says.
+	var _removed: Error = DirAccess.remove_absolute(out)
+	var read: Variant = Read.json_or_null(text)
+	if not read is Dictionary:
+		return _refused("UI Automation answered nothing readable: %s" % text.left(500))
+	var answer: Dictionary = read
+	if answer.has("error"):
+		return _refused("UI Automation could not read the game's windows: %s" % str(answer["error"]))
+
+	var windows: Array = answer.get("windows", [])
+	var elements: int = 0
+	var unnamed: int = 0
+	for at: int in windows.size():
+		var window: Dictionary = windows[at]
+		window["window_id"] = ids[at] if at < ids.size() else -1
+		elements += _count(window)
+		unnamed += _unnamed_text(window)
+	var result: Dictionary = {"windows": windows, "elements": elements}
+	if elements <= windows.size():
+		var setting: String = _setting()
+		# The command line's --accessibility is consumed by the engine and not handed on, so only
+		# the setting and a screen reader can say the tree is built; otherwise an empty window is
+		# most likely a game that builds none.
+		# 1 is a screen reader running, 0 none and -1 a platform that cannot say.
+		var read_aloud: bool = setting == "auto" and DisplayServer.accessibility_screen_reader_active() == 1
+		if setting != "always" and not read_aloud:
+			return _refused(
+				(
+					(
+						"UI Automation found nothing in the game's windows: the engine builds the tree a screen"
+						+ " reader reads only with accessibility/general/accessibility_support at Always Active,"
+						+ " or at Auto with a screen reader running when it starts, and this project's is %s."
+						+ ' Start the run with engineArgs ["--accessibility", "always"].'
+					)
+					% setting
+				)
+			)
+		result["_note"] = (
+			"The windows hold nothing a screen reader is told: Controls are in the tree, and Node2D and"
+			+ " Node3D are not unless the game creates elements for them."
+		)
+	elif unnamed > 0:
+		# Seen on a game naming its lines with accessibility_update_set_name: the text was there in
+		# the game and empty to the screen reader.
+		result["_note"] = (
+			(
+				"%d text element(s) on screen have no name, so a screen reader reads them as nothing. Static"
+				+ " text is read from its value, DisplayServer.accessibility_update_set_value, and a name"
+				+ " set on it is not read."
+			)
+			% unnamed
+		)
+	return result
+
+
+## The project's accessibility mode, as the command line's --accessibility names them.
+static func _setting() -> String:
+	match Read.as_int(ProjectSettings.get_setting("accessibility/general/accessibility_support", 0), 0):
+		1:
+			return "always"
+		2:
+			return "disabled"
+	return "auto"
+
+
+static func _count(element: Dictionary) -> int:
+	var total: int = 1
+	var children: Array = element.get("children", [])
+	for child: Variant in children:
+		if child is Dictionary:
+			var inner: Dictionary = child
+			total += _count(inner)
+	return total
+
+
+## Text elements with bounds and no name. A window also holds a nameless text element with no bounds
+## that no node of the game made, in every scene tried, which is left out.
+static func _unnamed_text(element: Dictionary) -> int:
+	var total: int = 0
+	if element.get("role") == "text" and str(element.get("name", "")).is_empty() and element.has("bounds"):
+		total += 1
+	var children: Array = element.get("children", [])
+	for child: Variant in children:
+		if child is Dictionary:
+			var inner: Dictionary = child
+			total += _unnamed_text(inner)
+	return total
+
+
+static func _refused(message: String) -> Dictionary:
+	return {"type": "error", "message": message}

package/build/godot/addons/gdharness_runtime/runtime_accessibility.gd.uid

@@ -0,0 +1 @@
+uid://c8abcitp7crgk

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

@@ -10,10 +10,12 @@ extends Node
 ## wanted. Both directions of the socket carry one JSON object per line. Every request names an
 ## id and the reply carries it back.
 
+const Accessibility = preload("runtime_accessibility.gd")
 const Capture = preload("runtime_capture.gd")
 const Changes = preload("runtime_changes.gd")
 const ErrorReport = preload("error_report.gd")
 const InputCommands = preload("runtime_input.gd")
+const Pad = preload("runtime_pad.gd")
 const Queries = preload("runtime_queries.gd")
 const Read = preload("reading.gd")
 const Typing = preload("runtime_typing.gd")
@@ -85,8 +87,10 @@ var _queries: Queries = Queries.new(self, values)
 var _changes: Changes = Changes.new(self, values)
 var _input: InputCommands = InputCommands.new(self, values)
 var _typing: Typing = Typing.new(self)
+var _pad: Pad = Pad.new(self)
 var _capture: Capture = Capture.new(self, values)
 var _waits: Waits = Waits.new(self, values)
+var _accessibility: Accessibility = Accessibility.new(self)
 
 var _server: TCPServer
 var _clients: Array[StreamPeerTCP] = []
@@ -128,6 +132,7 @@ func _init() -> void:
 		"set_property": _changes.set_property,
 		"call_method": _changes.call_method,
 		"get_metrics": _queries.get_metrics,
+		"get_accessibility": _accessibility.get_accessibility,
 		"capture_screenshot": _capture.capture_screenshot,
 		"capture_viewport": _capture.capture_viewport,
 		"inject_action": _input.inject_action,
@@ -135,6 +140,8 @@ func _init() -> void:
 		"inject_text": _typing.inject_text,
 		"inject_mouse_click": _input.inject_mouse_click,
 		"inject_mouse_motion": _input.inject_mouse_motion,
+		"inject_joypad_button": _pad.inject_joypad_button,
+		"inject_joypad_motion": _pad.inject_joypad_motion,
 		"click": _input.click,
 		"choose": _typing.choose,
 		"wait_frames": _waits.wait_frames,

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

@@ -101,8 +101,14 @@ func set_property(params: Dictionary) -> Dictionary:
 					"type": "error",
 					"message":
 					(
-						"%s.%s holds %s and the value given is %s, which cannot become one."
-						% [reached["called"], named, type_string(wanted), type_string(typeof(given))]
+						"%s.%s holds %s and the value given is %s, which cannot become one.%s"
+						% [
+							reached["called"],
+							named,
+							type_string(wanted),
+							type_string(typeof(given)),
+							_written_as(wanted)
+						]
 					)
 				}
 		var typed: Dictionary = _values.typed_like(given, old_value, _element_object.bind(node, node_path))
@@ -301,8 +307,15 @@ func call_method(params: Dictionary) -> Dictionary:
 				"type": "error",
 				"message":
 				(
-					"%s.%s takes %s as argument %d and was given %s, which cannot be converted."
-					% [reached["called"], named, type_string(wants), index + 1, type_string(typeof(given))]
+					"%s.%s takes %s as argument %d and was given %s, which cannot be converted.%s"
+					% [
+						reached["called"],
+						named,
+						type_string(wants),
+						index + 1,
+						type_string(typeof(given)),
+						_written_as(wants)
+					]
 				)
 			}
 		# A typed list or map is built as one, since a plain one handed to such a parameter raises
@@ -492,6 +505,13 @@ func _element_object(
 
 
 ## "list" or "map", for a refusal about a typed container.
+## The sentence a refusal ends with for a type built from fields, naming the shape that is read as
+## one, or nothing for a type that is not.
+static func _written_as(type: int) -> String:
+	var shape: String = Values.written_as(type)
+	return "" if shape.is_empty() else " A %s is sent as %s." % [type_string(type), shape]
+
+
 static func _sort_of(container: Variant) -> String:
 	return "list" if container is Array else "map"
 

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

@@ -0,0 +1,150 @@
+extends RefCounted
+
+## What reaches the running game the way a controller reaches it: a button pressed and a stick or
+## trigger moved, as the events a pad sends.
+##
+## The events themselves rather than the actions bound to them: a game reading the pad in _input or
+## _unhandled_input looks for InputEventJoypadButton and InputEventJoypadMotion, and an action
+## reached it as an InputEventAction it never reads, so a controller layout could only be driven by
+## calling the game's own methods. The engine still fires the actions bound to a button from these.
+
+const Read = preload("reading.gd")
+
+## Controller buttons by the names Godot gives them, for a caller naming one rather than numbering it.
+const JOY_BUTTONS: Dictionary[String, int] = {
+	"a": JOY_BUTTON_A,
+	"b": JOY_BUTTON_B,
+	"x": JOY_BUTTON_X,
+	"y": JOY_BUTTON_Y,
+	"back": JOY_BUTTON_BACK,
+	"guide": JOY_BUTTON_GUIDE,
+	"start": JOY_BUTTON_START,
+	"left_stick": JOY_BUTTON_LEFT_STICK,
+	"right_stick": JOY_BUTTON_RIGHT_STICK,
+	"left_shoulder": JOY_BUTTON_LEFT_SHOULDER,
+	"right_shoulder": JOY_BUTTON_RIGHT_SHOULDER,
+	"dpad_up": JOY_BUTTON_DPAD_UP,
+	"dpad_down": JOY_BUTTON_DPAD_DOWN,
+	"dpad_left": JOY_BUTTON_DPAD_LEFT,
+	"dpad_right": JOY_BUTTON_DPAD_RIGHT,
+	"misc1": JOY_BUTTON_MISC1,
+	"paddle1": JOY_BUTTON_PADDLE1,
+	"paddle2": JOY_BUTTON_PADDLE2,
+	"paddle3": JOY_BUTTON_PADDLE3,
+	"paddle4": JOY_BUTTON_PADDLE4,
+	"touchpad": JOY_BUTTON_TOUCHPAD,
+}
+
+## Stick and trigger axes by the names Godot gives them.
+const JOY_AXES: Dictionary[String, int] = {
+	"left_x": JOY_AXIS_LEFT_X,
+	"left_y": JOY_AXIS_LEFT_Y,
+	"right_x": JOY_AXIS_RIGHT_X,
+	"right_y": JOY_AXIS_RIGHT_Y,
+	"trigger_left": JOY_AXIS_TRIGGER_LEFT,
+	"trigger_right": JOY_AXIS_TRIGGER_RIGHT,
+}
+
+var _host: Node
+
+
+func _init(host: Node) -> void:
+	_host = host
+
+
+## Presses a controller button, and lets go of it again unless asked to hold it, as a key press does:
+## a button left down is a press that never ends, and everything reading it goes on seeing it.
+func inject_joypad_button(params: Dictionary) -> Dictionary:
+	var given: Variant = params.get("button", null)
+	var button: int = _named_or_numbered(given, JOY_BUTTONS, JOY_BUTTON_MAX)
+	if button < 0:
+		return {"type": "error", "message": _not_one_of("button", given, JOY_BUTTONS, JOY_BUTTON_MAX)}
+	var device: int = Read.as_int(params.get("device", 0), 0)
+	var held: bool = Read.as_bool(params.get("pressed", true), true)
+	var whole: bool = not params.has("pressed")
+
+	Input.parse_input_event(_button(button, device, whole or held))
+	if whole:
+		# A frame between the halves, as a key has, so a game that acts on the press and one that
+		# acts on the release each get a frame to do it in.
+		await _host.get_tree().process_frame
+		Input.parse_input_event(_button(button, device, false))
+		await _host.get_tree().process_frame
+
+	return {
+		"type": "input_injected",
+		"input_type": "joypad_button",
+		"button": button,
+		"button_name": _name_of(button, JOY_BUTTONS),
+		"device": device,
+		"pressed": held and not whole,
+		"whole": whole,
+	}
+
+
+## Moves a stick or trigger axis to a value, where it stays until another motion moves it, as a
+## stick held over does.
+func inject_joypad_motion(params: Dictionary) -> Dictionary:
+	var given: Variant = params.get("axis", null)
+	var axis: int = _named_or_numbered(given, JOY_AXES, JOY_AXIS_MAX)
+	if axis < 0:
+		return {"type": "error", "message": _not_one_of("axis", given, JOY_AXES, JOY_AXIS_MAX)}
+	if not params.has("value"):
+		return {"type": "error", "message": "joypad_motion needs value, where the axis is, -1 to 1"}
+	var value: float = Read.as_float(params.get("value"), 0.0)
+	if value < -1.0 or value > 1.0:
+		return {
+			"type": "error", "message": "value %s is outside -1 to 1, the whole travel of an axis" % value
+		}
+	var device: int = Read.as_int(params.get("device", 0), 0)
+
+	var event: InputEventJoypadMotion = InputEventJoypadMotion.new()
+	event.axis = axis as JoyAxis
+	event.axis_value = value
+	event.device = device
+	Input.parse_input_event(event)
+
+	return {
+		"type": "input_injected",
+		"input_type": "joypad_motion",
+		"axis": axis,
+		"axis_name": _name_of(axis, JOY_AXES),
+		"value": value,
+		"device": device,
+	}
+
+
+static func _button(button: int, device: int, down: bool) -> InputEventJoypadButton:
+	var event: InputEventJoypadButton = InputEventJoypadButton.new()
+	event.button_index = button as JoyButton
+	event.pressed = down
+	event.device = device
+	return event
+
+
+## [param given] as one of [param names], or as a number below [param count], or -1 for neither.
+static func _named_or_numbered(given: Variant, names: Dictionary[String, int], count: int) -> int:
+	if given is String:
+		var named: String = given
+		return Read.as_int(names.get(named.strip_edges().to_lower(), -1), -1)
+	if given is int or given is float:
+		var number: int = Read.as_int(given, -1)
+		return number if number >= 0 and number < count else -1
+	return -1
+
+
+static func _not_one_of(
+	argument: String, given: Variant, names: Dictionary[String, int], count: int
+) -> String:
+	return (
+		"%s %s is not one: give its name, one of %s, or its number, 0 to %d"
+		% [argument, JSON.stringify(given), ", ".join(PackedStringArray(names.keys())), count - 1]
+	)
+
+
+## The name [param number] goes by in [param names], or empty for a number with none.
+static func _name_of(number: int, names: Dictionary[String, int]) -> String:
+	for named: String in names:
+		if names[named] == number:
+			return named
+	return ""

package/build/godot/addons/gdharness_runtime/runtime_pad.gd.uid

@@ -0,0 +1 @@
+uid://cj164fjnsnn1y

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

@@ -718,6 +718,11 @@ func get_metrics(params: Dictionary) -> Dictionary:
 		"render_total_objects": Performance.get_monitor(Performance.RENDER_TOTAL_OBJECTS_IN_FRAME),
 		"render_total_primitives": Performance.get_monitor(Performance.RENDER_TOTAL_PRIMITIVES_IN_FRAME),
 		"render_total_draw_calls": Performance.get_monitor(Performance.RENDER_TOTAL_DRAW_CALLS_IN_FRAME),
+		# The GPU's half of the game's memory, in bytes, which memory_static does not count: a game
+		# committing 2.3 GB answered 298 MB there, and the rest could not be asked about.
+		"render_video_mem_used": Performance.get_monitor(Performance.RENDER_VIDEO_MEM_USED),
+		"render_texture_mem_used": Performance.get_monitor(Performance.RENDER_TEXTURE_MEM_USED),
+		"render_buffer_mem_used": Performance.get_monitor(Performance.RENDER_BUFFER_MEM_USED),
 	}
 
 	if metrics.is_empty():

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

@@ -65,6 +65,11 @@ static func acceptable(value: Variant, type: int) -> bool:
 	return Serialisation.acceptable(value, type)
 
 
+## How a value of [param type] is written to be read as one, or empty when it is not built from fields.
+static func written_as(type: int) -> String:
+	return Serialisation.written_as(type)
+
+
 ## The declared type of one parameter of a method, or TYPE_NIL when the method or the parameter
 ## is not there, which reads as "no opinion".
 func parameter_type(object: Object, method: String, index: int) -> int:

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

@@ -321,11 +321,25 @@ static func acceptable(value: Variant, type: int) -> bool:
 ## The conversion is also what restores a packed array's exact type. Those cross as the plain JSON
 ## lists they fit into, so what comes back from the wire is an Array, and the parameter is what says
 ## it was a PackedStringArray.
+##
+## A dictionary with no tag is read as the type wanted when it carries that type's fields, as
+## scene_node and resource_edit read one: runtime_invoke refused {"x": 140, "y": 300} for a Vector2
+## argument the editor tools took, so one value was right for one tool and wrong for the next. The
+## value as sent is what is tagged, since the builders read a nested vector from its own fields.
 func fitted(value: Variant, type: int) -> Variant:
 	var rebuilt: Variant = deserialize_value(value)
 	if type == TYPE_NIL or typeof(rebuilt) == type:
 		return rebuilt
 
+	if value is Dictionary and type != TYPE_DICTIONARY:
+		var fields: Dictionary = value
+		if not fields.has("_type"):
+			var tagged: Dictionary = fields.duplicate()
+			tagged["_type"] = type_string(type)
+			var built: Variant = deserialize_value(tagged)
+			if typeof(built) == type:
+				return built
+
 	if rebuilt is Array and LIST_TYPES.has(type):
 		return type_convert(rebuilt, type)
 
@@ -348,6 +362,21 @@ func fitted(value: Variant, type: int) -> Variant:
 	return type_convert(rebuilt, type)
 
 
+## How a value of [param type] is written to be read as one, for a refusal to name, or empty for a
+## type that is not built from fields. A refusal naming only the two types left a caller to find
+## the shape in the description of another op.
+static func written_as(type: int) -> String:
+	var tag: String = type_string(type)
+	var alternatives: Array = REQUIRED.get(tag, [])
+	if alternatives.is_empty() or tag == "float" or tag == "Dictionary":
+		return ""
+	var keys: Array = alternatives[0]
+	var parts: Array[String] = []
+	for key: Variant in keys:
+		parts.append('"%s": ...' % key)
+	return "{%s}" % ", ".join(parts)
+
+
 ## Whether [param fields] carries every key of any one of [param alternatives].
 ##
 ## More than one spelling because a rectangle has two: the two corners it is answered with, and the

package/build/godot/operations/godot_operations.gd

@@ -29,6 +29,10 @@ const ProjectDiagnostics = preload("project_diagnostics.gd")
 const RenameChecks = preload("rename_checks.gd")
 const ResourceFiles = preload("resource_files.gd")
 
+## Printed once the answer is written, after which the engine runs the project's autoloads. Kept in
+## step with `ANSWERED` in src/headless.ts.
+const ANSWERED: String = "[gdharness] answered"
+
 var _log: Log
 
 
@@ -86,6 +90,9 @@ func _init() -> void:
 		_log.error("Could not write the answer to " + answer_path)
 		quit(1)
 		return
+	# On stderr, where the engine's errors go, so the server can tell what the project's autoloads
+	# report after this from what the operation reported before it.
+	printerr(ANSWERED)
 	quit()