gdharness 1.2.42 → 1.3.1

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

@@ -0,0 +1,111 @@
+extends RefCounted
+
+## How each engine type built from fields is written: the fields it needs, the ones it reads when
+## they are there, and what a refusal says about a value that is not one.
+##
+## This file is the one beside the operations, and `bun run sync:gd` copies it into each addon.
+
+# 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
+# comes back as it arrived, and whoever asked can read it against the type they were expecting.
+const REQUIRED: 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": [["position", "size"], ["x", "y", "width", "height"]],
+	"Rect2i": [["position", "size"], ["x", "y", "width", "height"]],
+	"Plane": [["normal", "d"]],
+	"Quaternion": [["x", "y", "z", "w"]],
+	"AABB": [["position", "size"]],
+	"Basis": [["x", "y", "z"]],
+	"Transform2D": [["x", "y", "origin"]],
+	"Transform3D": [["basis", "origin"]],
+	"Projection": [["x", "y", "z", "w"]],
+	"Color": [["r", "g", "b"]],
+	"NodePath": [["path"]],
+	"PackedByteArray": [["base64"]],
+	"float": [["value"]],
+	"int": [["value"]],
+	"RID": [["id"]],
+	"Dictionary": [["entries"]],
+}
+## The fields a builder reads when they are there and does without when not.
+const OPTIONAL: Dictionary = {
+	"Color": ["a"],
+	"PackedByteArray": ["size"],
+}
+
+
+## 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 leaves 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 in ["float", "int", "Dictionary"]:
+		return ""
+	var keys: Array = alternatives[0]
+	var optional: Array = OPTIONAL.get(tag, [])
+	var parts: Array[String] = []
+	for key: Variant in keys + optional:
+		parts.append('"%s": ...' % key)
+	var shape: String = "{%s}" % ", ".join(parts)
+	if type == TYPE_COLOR:
+		return shape + ' or as its html code, "#ff8000"'
+	return shape
+
+
+## The keys of [param fields] that a [param tag] built from them would not read, one list for each
+## spelling of its fields carried whole. A rectangle has two: its corners, and four numbers.
+##
+## A builder drops a key it does not know without a word, so {"x": 1, "y": 2, "z": 3} for a Vector2
+## would be written as (1, 2) and answered as written: a value is built only when a list is empty.
+static func spare(fields: Dictionary, tag: String) -> Array:
+	var optional: Array = OPTIONAL.get(tag, [])
+	var lists: Array = []
+	var alternatives: Array = REQUIRED.get(tag, [])
+	for alternative: Variant in alternatives:
+		var keys: Array = alternative
+		if keys.all(func(key: Variant) -> bool: return fields.has(key)):
+			var over: Callable = func(key: Variant) -> bool:
+				return str(key) != "_type" and not keys.has(key) and not optional.has(key)
+			lists.append(fields.keys().filter(over))
+	return lists
+
+
+## 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.
+##
+## The refusal names only the two types, and the key is what the caller has to take out.
+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]
+
+
+static func _unread(value: Variant, type: int) -> String:
+	if not value is Dictionary:
+		return ""
+	var fields: Dictionary = value
+	var tag: String = type_string(type)
+	var lists: Array = spare(fields, tag)
+	var built: bool = lists.any(func(over: Array) -> bool: return over.is_empty())
+	if lists.is_empty() or built or str(fields.get("_type", tag)) != tag:
+		return ""
+	lists.sort_custom(func(a: Array, b: Array) -> bool: return a.size() < b.size())
+	var left: Array = lists[0]
+	var named: PackedStringArray = []
+	for key: Variant in left:
+		var _named: bool = named.append('"%s"' % key)
+	var fields_called: String = "field called" if named.size() == 1 else "fields called"
+	var note: String = (
+		" A %s has no %s %s, so the value is not read as one" % [tag, fields_called, " or ".join(named)]
+	)
+	if left.has("type") and not fields.has("_type"):
+		return note + ': a value names its type under "_type".'
+	return note + "."

package/build/godot/addons/gdharness_editor/value_shapes.gd.uid

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

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

@@ -139,3 +139,31 @@ static func missing_below(
 			"its children are " + shown if not children.is_empty() else "it has no children",
 		]
 	)
+
+
+## [param said], the refusal for a [param kind] the scene does not have at [param node_path], with
+## what is there when the scene has a node there, [param found] its class, and [param holders], the
+## paths of the nodes in the scene that are one, so the caller has the path to pass. Names up to
+## [constant NAMED_CHILDREN] of them.
+static func not_of_kind(
+	said: String, node_path: String, found: String, kind: String, holders: PackedStringArray
+) -> String:
+	var told: String = said + ("" if said.ends_with(".") else ".")
+	if not found.is_empty():
+		told += ' The node at "%s" is %s, not %s.' % [node_path, with_article(found), with_article(kind)]
+	if holders.is_empty():
+		return told + " The scene holds no %s." % kind
+	var quoted: PackedStringArray = []
+	for holder: String in holders.slice(0, NAMED_CHILDREN):
+		var _quoted: bool = quoted.append('"%s"' % holder)
+	var shown: String = ", ".join(quoted)
+	if holders.size() > NAMED_CHILDREN:
+		shown += " and %d more" % (holders.size() - NAMED_CHILDREN)
+	if holders.size() == 1:
+		return told + " The scene's %s is at %s." % [kind, shown]
+	return told + " The scene's %ss are at %s." % [kind, shown]
+
+
+## [param word] after the article it takes, "an AnimationTree" or "a Node2D".
+static func with_article(word: String) -> String:
+	return ("an " if word.left(1).to_upper() in ["A", "E", "I", "O", "U"] else "a ") + word

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

@@ -9,8 +9,8 @@ extends RefCounted
 ## 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")
-const Says = preload("runtime_says.gd")
+const GdhRead = preload("reading.gd")
+const GdhSays = preload("runtime_says.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.
@@ -260,7 +260,7 @@ func get_accessibility(params: Dictionary) -> Dictionary:
 	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)
+	var read: Variant = GdhRead.json_or_null(text)
 	if not read is Dictionary:
 		return _refused("UI Automation answered nothing readable: %s" % text.left(500))
 	var answer: Dictionary = read
@@ -270,7 +270,7 @@ func get_accessibility(params: Dictionary) -> Dictionary:
 	var windows: Array = answer.get("windows", [])
 	var made_by: Dictionary = {}
 	_note_elements(_host.get_tree().root, made_by)
-	var placing: Placing = Placing.new()
+	var placing: GdhPlacing = GdhPlacing.new()
 	var elements: int = 0
 	var unnamed: int = 0
 	for at: int in windows.size():
@@ -373,7 +373,7 @@ static func _narrow(result: Dictionary, params: Dictionary) -> void:
 			if window is Dictionary:
 				var holder: Dictionary = window
 				_keep_only(holder, fields)
-	var limit: int = Read.as_int(params.get("limit", 0), 0)
+	var limit: int = GdhRead.as_int(params.get("limit", 0), 0)
 	if limit > 0:
 		var left: Array[int] = [limit]
 		var omitted: Array[int] = [0]
@@ -401,7 +401,7 @@ static func _matches(element: Dictionary, under: String, said: String) -> bool:
 			return false
 	if not said.is_empty():
 		for field: String in ["name", "value", "value_text"]:
-			if element.has(field) and Says.matches(str(element[field]), said):
+			if element.has(field) and GdhSays.matches(str(element[field]), said):
 				return true
 		return false
 	return true
@@ -452,7 +452,7 @@ static func _cut(element: Dictionary, left: Array[int], omitted: Array[int]) ->
 
 ## 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):
+	match GdhRead.as_int(ProjectSettings.get_setting("accessibility/general/accessibility_support", 0), 0):
 		1:
 			return "always"
 		2:
@@ -498,7 +498,7 @@ static func _window_with(node: Node, window_id: int) -> Window:
 ## UI Automation's runtime id for an element ends in the four halves of AccessKit's id for it, and
 ## Godot gives AccessKit the element's RID: measured on 4.7.2, /root/Main's element answered
 ## 114,1,0,0 with RID 114 << 32 | 1. Which pair holds it is not assumed, so both are tried.
-static func _match(element: Dictionary, made_by: Dictionary, placing: Placing) -> void:
+static func _match(element: Dictionary, made_by: Dictionary, placing: GdhPlacing) -> void:
 	var children: Array = element.get("children", [])
 	for child: Variant in children:
 		if not child is Dictionary:
@@ -530,14 +530,14 @@ static func _match(element: Dictionary, made_by: Dictionary, placing: Placing) -
 ## column of plain containers came out straight under the window. So the node is found where it
 ## must be: below the shown element's node, itself left out of the tree (a node that is shown would
 ## have the part under it), drawn around the part, and, for text, holding its words.
-static func _attribute(element: Dictionary, holder: Node, placing: Placing, is_window: bool) -> void:
+static func _attribute(element: Dictionary, holder: Node, placing: GdhPlacing, is_window: bool) -> void:
 	var children: Array = element.get("children", [])
 	for child: Variant in children:
 		if not child is Dictionary:
 			continue
 		var inner: Dictionary = child
 		if inner.has(NODE_ID):
-			var node: Node = instance_from_id(Read.as_int(inner[NODE_ID], 0))
+			var node: Node = instance_from_id(GdhRead.as_int(inner[NODE_ID], 0))
 			var _dropped: bool = inner.erase(NODE_ID)
 			_attribute(inner, node if node != null else holder, placing, false)
 			continue
@@ -561,16 +561,16 @@ static func _attribute(element: Dictionary, holder: Node, placing: Placing, is_w
 ## The nodes that may have made [param element], below [param holder]: the deepest ones drawn
 ## around it whose own elements are not shown, narrowed to those holding its words when that leaves
 ## any. [param holder] alone when none is drawn around it, or when it has no bounds to look by.
-static func _owners_of(element: Dictionary, holder: Node, placing: Placing) -> Array[Node]:
+static func _owners_of(element: Dictionary, holder: Node, placing: GdhPlacing) -> Array[Node]:
 	var bounds: Variant = element.get("bounds")
 	if not bounds is Dictionary:
 		return [holder]
 	var box: Dictionary = bounds
 	var drawn: Rect2 = Rect2(
-		Read.as_float(box.get("x", 0)),
-		Read.as_float(box.get("y", 0)),
-		Read.as_float(box.get("width", 0)),
-		Read.as_float(box.get("height", 0))
+		GdhRead.as_float(box.get("x", 0)),
+		GdhRead.as_float(box.get("y", 0)),
+		GdhRead.as_float(box.get("width", 0)),
+		GdhRead.as_float(box.get("height", 0))
 	)
 	var found: Array[Node] = []
 	_drawn_around(holder, drawn, placing, found)
@@ -590,7 +590,7 @@ static func _owners_of(element: Dictionary, holder: Node, placing: Placing) -> A
 
 ## Where a Control is drawn is read off its screen transform, which for a window that is not
 ## embedded is in that window's own pixels, as the bounds are.
-static func _drawn_around(node: Node, drawn: Rect2, placing: Placing, found: Array[Node]) -> void:
+static func _drawn_around(node: Node, drawn: Rect2, placing: GdhPlacing, found: Array[Node]) -> void:
 	for child: Node in node.get_children(true):
 		# A node that is shown has its parts under it, and so do the nodes below it.
 		if placing.shown.has(child.get_instance_id()):
@@ -632,7 +632,7 @@ static func _text_of(node: Node) -> String:
 static func _made(parts: Array, made_by: Dictionary) -> Node:
 	var halves: Array[int] = []
 	for part: Variant in parts:
-		halves.append(Read.as_int(part, 0) & 0xFFFFFFFF)
+		halves.append(GdhRead.as_int(part, 0) & 0xFFFFFFFF)
 	for at: int in [0, 2]:
 		var id: int = (halves[at] << 32) | halves[at + 1]
 		if made_by.has(id):
@@ -642,7 +642,7 @@ static func _made(parts: Array, made_by: Dictionary) -> Node:
 
 ## Counts kept while the elements are placed, and the nodes whose own elements UI Automation shows,
 ## by instance id.
-class Placing:
+class GdhPlacing:
 	extends RefCounted
 	var asked: int = 0
 	var placed: int = 0

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

@@ -10,20 +10,20 @@ 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 Targets = preload("runtime_targets.gd")
-const Typing = preload("runtime_typing.gd")
-const Values = preload("runtime_values.gd")
-const Waits = preload("runtime_waits.gd")
-
-const PROTOCOL: int = 2
+const GdhAccessibility = preload("runtime_accessibility.gd")
+const GdhCapture = preload("runtime_capture.gd")
+const GdhChanges = preload("runtime_changes.gd")
+const GdhErrorReport = preload("error_report.gd")
+const GdhInputCommands = preload("runtime_input.gd")
+const GdhPad = preload("runtime_pad.gd")
+const GdhQueries = preload("runtime_queries.gd")
+const GdhRead = preload("reading.gd")
+const GdhTargets = preload("runtime_targets.gd")
+const GdhTyping = preload("runtime_typing.gd")
+const GdhValues = preload("runtime_values.gd")
+const GdhWaits = preload("runtime_waits.gd")
+
+const PROTOCOL: int = 3
 const DEFAULT_BIND_ADDRESS: String = "127.0.0.1"
 const BIND_ADDRESS_SETTING: String = "gdharness/runtime/bind_address"
 ## 0 asks the operating system for a free port, which is the default and what the server
@@ -83,19 +83,19 @@ const ERROR_REPORT_NAME: String = "runtime-%d.log"
 const VERSION_MARKER: String = "res://addons/gdharness_runtime/.gdharness-version"
 const DIGEST_MARKER: String = "res://addons/gdharness_runtime/.gdharness-digest"
 
-var values: Values = Values.new()
+var values: GdhValues = GdhValues.new()
 
 # The modules are members and not locals of _init, because a Callable holds its object by id
 # rather than by reference, and a module referenced only by the Callables in the command table
 # would be freed on the way out of _init, leaving every command "unknown".
-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 _queries: GdhQueries = GdhQueries.new(self, values)
+var _changes: GdhChanges = GdhChanges.new(self, values)
+var _input: GdhInputCommands = GdhInputCommands.new(self, values)
+var _typing: GdhTyping = GdhTyping.new(self)
+var _pad: GdhPad = GdhPad.new(self)
+var _capture: GdhCapture = GdhCapture.new(self, values)
+var _waits: GdhWaits = GdhWaits.new(self, values)
+var _accessibility: GdhAccessibility = GdhAccessibility.new(self)
 
 var _server: TCPServer
 var _clients: Array[StreamPeerTCP] = []
@@ -114,7 +114,7 @@ var _enabled: bool = true
 var _announcement: String = ""
 ## Held for as long as the game runs: a Logger the engine has is kept by reference, and one
 ## that goes away mid-run takes the report with it.
-var _errors: ErrorReport
+var _errors: GdhErrorReport
 ## Every command, by the name a request uses, as the module method that answers it.
 var _commands: Dictionary = {}
 ## The addon this game loaded, read once at start: an upgrade rewrites the markers under a running
@@ -174,7 +174,7 @@ func _size_a_windowless_game() -> void:
 	if DisplayServer.get_name() != "headless" or _script_run() or not OS.is_debug_build():
 		return
 	var root: Window = get_tree().root
-	if Vector2(root.size) != Targets.HEADLESS_VIEWPORT:
+	if Vector2(root.size) != GdhTargets.HEADLESS_VIEWPORT:
 		return
 	root.size = Vector2i(_window_dimension("width", 1152), _window_dimension("height", 648))
 
@@ -182,12 +182,12 @@ func _size_a_windowless_game() -> void:
 ## The window's [param axis] as the project opens it: the override when one is set, otherwise the
 ## viewport's size, whose engine default is [param fallback].
 static func _window_dimension(axis: String, fallback: int) -> int:
-	var override: int = Read.as_int(
+	var override: int = GdhRead.as_int(
 		ProjectSettings.get_setting("display/window/size/window_%s_override" % axis, 0)
 	)
 	if override > 0:
 		return override
-	return Read.as_int(
+	return GdhRead.as_int(
 		ProjectSettings.get_setting("display/window/size/viewport_%s" % axis, fallback), fallback
 	)
 
@@ -342,7 +342,7 @@ func _report_errors() -> void:
 	var made: Error = DirAccess.make_dir_recursive_absolute(directory)
 	if made != OK and made != ERR_ALREADY_EXISTS:
 		return
-	_errors = ErrorReport.new(directory.path_join(ERROR_REPORT_NAME % OS.get_process_id()))
+	_errors = GdhErrorReport.new(directory.path_join(ERROR_REPORT_NAME % OS.get_process_id()))
 	OS.add_logger(_errors)
 
 
@@ -404,7 +404,7 @@ func _drain(client: StreamPeerTCP) -> bool:
 	var sent: Array = client.put_partial_data(owed)
 	if sent[0] != OK:
 		return false
-	_outgoing[client] = owed.slice(Read.as_int(sent[1]))
+	_outgoing[client] = owed.slice(GdhRead.as_int(sent[1]))
 	return true
 
 
@@ -438,14 +438,14 @@ func _start_server() -> void:
 	# own path: a gate that starts sixteen engines at once announces sixteen games that are not
 	# games, and a client asking the runtime anything while they run can be answered by whichever
 	# of them replies first. Measured on two projects before it was written here.
-	if _script_run() and not Read.as_bool(ProjectSettings.get_setting(SCRIPT_RUNS_SETTING, false)):
+	if _script_run() and not GdhRead.as_bool(ProjectSettings.get_setting(SCRIPT_RUNS_SETTING, false)):
 		_enabled = false
 		return
 
 	_server = TCPServer.new()
 	# listen() defaults bind_address to "*", which exposes the game to the whole network.
 	var bind_address: String = str(ProjectSettings.get_setting(BIND_ADDRESS_SETTING, DEFAULT_BIND_ADDRESS))
-	var wanted_port: int = Read.as_int(ProjectSettings.get_setting(PORT_SETTING, 0))
+	var wanted_port: int = GdhRead.as_int(ProjectSettings.get_setting(PORT_SETTING, 0))
 	var error: Error = _server.listen(wanted_port, bind_address)
 	if error != OK:
 		# A warning, not an error: callers treat any ERROR line on stderr as a failed
@@ -502,7 +502,7 @@ func _announce(bind_address: String) -> void:
 	# Written whole under a name no server reads and moved into place, so no look ever meets
 	# the file empty: a server sweeping the directory between an open and a write took the
 	# announcement for a dead game's leftover, and the directory is shared by every server on
-	# the machine, older ones included.
+	# the machine.
 	var staged: String = path + ".tmp"
 	var file: FileAccess = FileAccess.open(staged, FileAccess.WRITE)
 	if file == null:

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

@@ -2,20 +2,20 @@ extends RefCounted
 
 ## A picture of the running game, as a PNG written where the server asked for it.
 
-const Read = preload("reading.gd")
-const Values = preload("runtime_values.gd")
-const Queries = preload("runtime_queries.gd")
-const Screen = preload("runtime_screen.gd")
+const GdhRead = preload("reading.gd")
+const GdhValues = preload("runtime_values.gd")
+const GdhQueries = preload("runtime_queries.gd")
+const GdhScreen = preload("runtime_screen.gd")
 
 ## How far zoom enlarges at most. Sixteen makes a 3-pixel ring 48 pixels across, past any need to
 ## see it, and a 200-pixel region 3200, past the size anybody reads a picture at.
 const ZOOM_MOST: int = 16
 
 var _host: Node
-var _values: Values
+var _values: GdhValues
 
 
-func _init(host: Node, values: Values) -> void:
+func _init(host: Node, values: GdhValues) -> void:
 	_host = host
 	_values = values
 
@@ -29,13 +29,42 @@ func capture_viewport(params: Dictionary) -> Dictionary:
 	if viewport_path.is_empty():
 		return await capture_screenshot(params)
 
-	var standing: Dictionary = Values.node_at(_host.get_tree().root, viewport_path)
+	var standing: Dictionary = GdhValues.node_at(_host.get_tree().root, viewport_path)
 	if standing.has("message"):
 		return standing
 	var node: Node = standing["node"]
 	if not node is Viewport:
 		return {"type": "error", "message": "Node is not a Viewport: " + viewport_path}
 	var viewport: Viewport = node
+	# The root's own state is refused in _capture. Another window of the game's that is hidden or
+	# minimised holds no frame, and asking it for its image makes the engine log the empty read into
+	# the game's output, so the run would stop unclean for an error the capture raised.
+	if viewport is Window and viewport != _host.get_tree().root:
+		var window: Window = viewport
+		if not window.visible:
+			return {
+				"type": "error",
+				"message":
+				(
+					(
+						"The Window at %s is hidden, so nothing is drawn to it. Show it (its visible "
+						+ "property) and ask again."
+					)
+					% viewport_path
+				),
+			}
+		if not window.can_draw():
+			return {
+				"type": "error",
+				"message":
+				(
+					(
+						"Nothing is being drawn to the Window at %s, which is minimised. Restore it and "
+						+ "ask again."
+					)
+					% viewport_path
+				),
+			}
 	if not viewport is SubViewport:
 		return await _capture(viewport, params)
 	# Drawn now rather than taken as it stands. A SubViewport the game does not redraw every frame
@@ -74,7 +103,8 @@ func _lay_native_windows(image: Image) -> void:
 		if node == root or not node is Window:
 			continue
 		var window: Window = node
-		if not window.visible or window.is_embedded():
+		# A minimised window is not on the screen, and its texture holds the last frame it drew.
+		if not window.visible or window.is_embedded() or not window.can_draw():
 			continue
 		var drawn: Image = window.get_texture().get_image()
 		if drawn == null or drawn.is_empty():
@@ -106,8 +136,10 @@ static func scaled_to(drawn: Vector2i, width: int, height: int) -> Vector2i:
 func _cut_asked(params: Dictionary, in_window: bool) -> Dictionary:
 	var region_given: Variant = params.get("region")
 	var node_path: String = str(params.get("nodePath", ""))
-	var zoom: int = Read.as_int(params.get("zoom", 1), 1)
-	var sized: bool = Read.as_int(params.get("width", 0)) > 0 or Read.as_int(params.get("height", 0)) > 0
+	var zoom: int = GdhRead.as_int(params.get("zoom", 1), 1)
+	var sized: bool = (
+		GdhRead.as_int(params.get("width", 0)) > 0 or GdhRead.as_int(params.get("height", 0)) > 0
+	)
 	if region_given != null and not node_path.is_empty():
 		return _refused("region and nodePath each name the part to capture; give one of them")
 	if (region_given != null or not node_path.is_empty()) and not in_window:
@@ -148,7 +180,7 @@ static func _refused(message: String) -> Dictionary:
 ## The rectangle [param given] names: the four numbers x, y, width and height, or a rectangle as the
 ## runtime answers one, its two corners tagged with their type, passed back as it came. Null when it
 ## is neither or has no area.
-static func region_of(values: Values, given: Variant) -> Variant:
+static func region_of(values: GdhValues, given: Variant) -> Variant:
 	if not given is Dictionary:
 		return null
 	var fields: Dictionary = given
@@ -175,21 +207,21 @@ static func region_of(values: Values, given: Variant) -> Variant:
 static func drawn_rect_of(node: Node) -> Variant:
 	if node is Control:
 		var control: Control = node
-		return Screen.rect_in_window(
+		return GdhScreen.rect_in_window(
 			control.get_viewport(),
 			control.get_global_transform_with_canvas() * Rect2(Vector2.ZERO, control.size)
 		)
 	if node is Node3D:
 		var spatial: Node3D = node
-		var found: Dictionary = Queries.in_frame(spatial)
+		var found: Dictionary = GdhQueries.in_frame(spatial)
 		if not found.has("rect"):
 			return "%s is not drawn by any current camera, so it covers nothing on screen" % node.get_path()
 		var covered: Rect2 = found["rect"]
-		return Screen.rect_in_window(spatial.get_viewport(), covered)
+		return GdhScreen.rect_in_window(spatial.get_viewport(), covered)
 	if node is Node2D and node.has_method("get_rect"):
 		var item: Node2D = node
 		var own: Rect2 = item.call("get_rect")
-		return Screen.rect_in_window(item.get_viewport(), item.get_global_transform_with_canvas() * own)
+		return GdhScreen.rect_in_window(item.get_viewport(), item.get_global_transform_with_canvas() * own)
 	var no_extent: String = (
 		"%s is a %s, which has a position on screen and no extent; give region around the point "
 		+ "runtime_inspect rect answers for it"
@@ -292,7 +324,7 @@ func _capture(viewport: Viewport, params: Dictionary, with_windows: bool = false
 	var region: Variant = asked.get("region")
 	if asked.has("node_path"):
 		var node_path: String = asked["node_path"]
-		var standing: Dictionary = Values.node_at(_host.get_tree().root, node_path)
+		var standing: Dictionary = GdhValues.node_at(_host.get_tree().root, node_path)
 		if standing.has("message"):
 			return standing
 		var node: Node = standing["node"]
@@ -302,7 +334,7 @@ func _capture(viewport: Viewport, params: Dictionary, with_windows: bool = false
 			return _refused(why)
 		region = placed
 		# A hidden node's rectangle is still a place, and what is drawn there is whatever is behind it.
-		if not Queries.shown(node):
+		if not GdhQueries.shown(node):
 			described["note"] = (
 				"%s is hidden, so this is what is drawn where it would be rather than the node" % node_path
 			)
@@ -335,7 +367,7 @@ func _capture(viewport: Viewport, params: Dictionary, with_windows: bool = false
 	else:
 		var drawn: Vector2i = Vector2i(image.get_width(), image.get_height())
 		var target: Vector2i = scaled_to(
-			drawn, Read.as_int(params.get("width", 0)), Read.as_int(params.get("height", 0))
+			drawn, GdhRead.as_int(params.get("width", 0)), GdhRead.as_int(params.get("height", 0))
 		)
 		if target != drawn:
 			image.resize(target.x, target.y)