gdharness 0.12.16 → 0.12.18

package/build/godot/addons/gdharness_editor/tools/scene_tools.gd

@@ -3,6 +3,8 @@ extends Node
 
 ## Scenes and their nodes, edited in the open editor and read back from what it holds.
 
+const Read = preload("../reading.gd")
+
 var _editor_plugin: EditorPlugin = null
 
 
@@ -89,13 +91,15 @@ func _find_node(root: Node, path: String) -> Node:
 ## declares, or a bare array positional for a vector. Each is its own function; asking all three
 ## in one was twenty-four exits deep and impossible to follow.
 func _parse_value(value: Variant, expected_type: int = TYPE_NIL) -> Variant:
-	if typeof(value) == TYPE_DICTIONARY:
-		var tagged: Array = _parse_tagged_dictionary(value)
+	if value is Dictionary:
+		var fields: Dictionary = value
+		var tagged: Array = _parse_tagged_dictionary(fields)
 		if tagged[0]:
 			return tagged[1]
-		return _parse_shaped_dictionary(value, expected_type)
-	if typeof(value) == TYPE_ARRAY:
-		return _parse_array(value, expected_type)
+		return _parse_shaped_dictionary(fields, expected_type)
+	if value is Array:
+		var items: Array = value
+		return _parse_array(items, expected_type)
 	return value
 
 
@@ -114,26 +118,53 @@ func _parse_tagged_dictionary(value: Dictionary) -> Array:
 
 	match type_tag:
 		"Vector2":
-			return [true, Vector2(value.get("x", 0), value.get("y", 0))]
+			return [true, Vector2(Read.as_float(value.get("x", 0)), Read.as_float(value.get("y", 0)))]
 		"Vector3":
-			return [true, Vector3(value.get("x", 0), value.get("y", 0), value.get("z", 0))]
+			return [
+				true,
+				Vector3(
+					Read.as_float(value.get("x", 0)),
+					Read.as_float(value.get("y", 0)),
+					Read.as_float(value.get("z", 0))
+				)
+			]
 		"Color":
-			return [true, Color(value.get("r", 1), value.get("g", 1), value.get("b", 1), value.get("a", 1))]
+			return [
+				true,
+				Color(
+					Read.as_float(value.get("r", 1), 1.0),
+					Read.as_float(value.get("g", 1), 1.0),
+					Read.as_float(value.get("b", 1), 1.0),
+					Read.as_float(value.get("a", 1), 1.0)
+				)
+			]
 		"Vector2i":
-			return [true, Vector2i(value.get("x", 0), value.get("y", 0))]
+			return [true, Vector2i(Read.as_int(value.get("x", 0)), Read.as_int(value.get("y", 0)))]
 		"Vector3i":
-			return [true, Vector3i(value.get("x", 0), value.get("y", 0), value.get("z", 0))]
+			return [
+				true,
+				Vector3i(
+					Read.as_int(value.get("x", 0)),
+					Read.as_int(value.get("y", 0)),
+					Read.as_int(value.get("z", 0))
+				)
+			]
 		"Rect2":
 			return [
 				true,
-				Rect2(value.get("x", 0), value.get("y", 0), value.get("width", 0), value.get("height", 0))
+				Rect2(
+					Read.as_float(value.get("x", 0)),
+					Read.as_float(value.get("y", 0)),
+					Read.as_float(value.get("width", 0)),
+					Read.as_float(value.get("height", 0))
+				)
 			]
 		"Transform2D":
 			return _parse_transform2d(value)
 		"Transform3D":
 			return _parse_transform3d(value)
 		"NodePath":
-			return [true, NodePath(value.get("path", ""))]
+			return [true, NodePath(str(value.get("path", "")))]
 		"Resource":
 			var resource_path: String = str(value.get("path", ""))
 			return [true, null if resource_path.is_empty() else load(resource_path)]
@@ -172,9 +203,9 @@ func _parse_transform2d(value: Dictionary) -> Array:
 	return [
 		true,
 		Transform2D(
-			Vector2(basis_x.get("x", 1), basis_x.get("y", 0)),
-			Vector2(basis_y.get("x", 0), basis_y.get("y", 1)),
-			Vector2(origin.get("x", 0), origin.get("y", 0))
+			Vector2(Read.as_float(basis_x.get("x", 1), 1.0), Read.as_float(basis_x.get("y", 0))),
+			Vector2(Read.as_float(basis_y.get("x", 0)), Read.as_float(basis_y.get("y", 1), 1.0)),
+			Vector2(Read.as_float(origin.get("x", 0)), Read.as_float(origin.get("y", 0)))
 		)
 	]
 
@@ -189,11 +220,18 @@ func _parse_transform3d(value: Dictionary) -> Array:
 	var y: Dictionary = b.get("y", {})
 	var z: Dictionary = b.get("z", {})
 	var basis: Basis = Basis(
-		Vector3(x.get("x", 1), x.get("y", 0), x.get("z", 0)),
-		Vector3(y.get("x", 0), y.get("y", 1), y.get("z", 0)),
-		Vector3(z.get("x", 0), z.get("y", 0), z.get("z", 1))
+		Vector3(
+			Read.as_float(x.get("x", 1), 1.0), Read.as_float(x.get("y", 0)), Read.as_float(x.get("z", 0))
+		),
+		Vector3(
+			Read.as_float(y.get("x", 0)), Read.as_float(y.get("y", 1), 1.0), Read.as_float(y.get("z", 0))
+		),
+		Vector3(Read.as_float(z.get("x", 0)), Read.as_float(z.get("y", 0)), Read.as_float(z.get("z", 1), 1.0))
+	)
+	var origin: Vector3 = Vector3(
+		Read.as_float(o.get("x", 0)), Read.as_float(o.get("y", 0)), Read.as_float(o.get("z", 0))
 	)
-	return [true, Transform3D(basis, Vector3(o.get("x", 0), o.get("y", 0), o.get("z", 0)))]
+	return [true, Transform3D(basis, origin)]
 
 
 ## A dictionary with no tag, read against the type the property declares. Falls back to the
@@ -202,27 +240,37 @@ func _parse_shaped_dictionary(value: Dictionary, expected_type: int) -> Variant:
 	match expected_type:
 		TYPE_VECTOR2:
 			if value.has("x") and value.has("y"):
-				return Vector2(value.get("x", 0), value.get("y", 0))
+				return Vector2(Read.as_float(value["x"]), Read.as_float(value["y"]))
 		TYPE_VECTOR2I:
 			if value.has("x") and value.has("y"):
-				return Vector2i(value.get("x", 0), value.get("y", 0))
+				return Vector2i(Read.as_int(value["x"]), Read.as_int(value["y"]))
 		TYPE_VECTOR3:
 			if value.has("x") and value.has("y") and value.has("z"):
-				return Vector3(value.get("x", 0), value.get("y", 0), value.get("z", 0))
+				return Vector3(
+					Read.as_float(value["x"]), Read.as_float(value["y"]), Read.as_float(value["z"])
+				)
 		TYPE_VECTOR3I:
 			if value.has("x") and value.has("y") and value.has("z"):
-				return Vector3i(value.get("x", 0), value.get("y", 0), value.get("z", 0))
+				return Vector3i(Read.as_int(value["x"]), Read.as_int(value["y"]), Read.as_int(value["z"]))
 		TYPE_COLOR:
 			if value.has("r") and value.has("g") and value.has("b"):
-				return Color(value.get("r", 1), value.get("g", 1), value.get("b", 1), value.get("a", 1))
+				return Color(
+					Read.as_float(value["r"]),
+					Read.as_float(value["g"]),
+					Read.as_float(value["b"]),
+					Read.as_float(value.get("a", 1), 1.0)
+				)
 		TYPE_RECT2:
 			if value.has("x") and value.has("y") and value.has("width") and value.has("height"):
 				return Rect2(
-					value.get("x", 0), value.get("y", 0), value.get("width", 0), value.get("height", 0)
+					Read.as_float(value["x"]),
+					Read.as_float(value["y"]),
+					Read.as_float(value["width"]),
+					Read.as_float(value["height"])
 				)
 		TYPE_NODE_PATH:
 			if value.has("path"):
-				return NodePath(value.get("path", ""))
+				return NodePath(str(value["path"]))
 	return value
 
 
@@ -231,23 +279,23 @@ func _parse_array(value: Array, expected_type: int) -> Variant:
 	match expected_type:
 		TYPE_VECTOR2:
 			if value.size() >= 2:
-				return Vector2(value[0], value[1])
+				return Vector2(Read.as_float(value[0]), Read.as_float(value[1]))
 		TYPE_VECTOR2I:
 			if value.size() >= 2:
-				return Vector2i(value[0], value[1])
+				return Vector2i(Read.as_int(value[0]), Read.as_int(value[1]))
 		TYPE_VECTOR3:
 			if value.size() >= 3:
-				return Vector3(value[0], value[1], value[2])
+				return Vector3(Read.as_float(value[0]), Read.as_float(value[1]), Read.as_float(value[2]))
 		TYPE_VECTOR3I:
 			if value.size() >= 3:
-				return Vector3i(value[0], value[1], value[2])
+				return Vector3i(Read.as_int(value[0]), Read.as_int(value[1]), Read.as_int(value[2]))
 	return value.map(func(item: Variant) -> Variant: return _parse_value(item))
 
 
 func _get_property_type(node: Node, prop_name: String) -> int:
 	for prop: Dictionary in node.get_property_list():
 		if str(prop.get("name", "")) == prop_name:
-			return int(prop.get("type", TYPE_NIL))
+			return Read.as_int(prop.get("type", TYPE_NIL), TYPE_NIL)
 	return TYPE_NIL
 
 
@@ -316,7 +364,7 @@ func _set_node_properties(node: Node, properties: Dictionary) -> String:
 		# A resource-valued property takes the path of one, which is how a caller names a
 		# TileSet, a material or a theme: there is no other way to hand a tool a Resource.
 		if expected_type == TYPE_OBJECT and typeof(raw) == TYPE_STRING:
-			var path: String = String(raw)
+			var path: String = str(raw)
 			# The project boundary is enforced here as well as on the server, because only the
 			# engine knows that this property is one holding a path: an absolute path and a
 			# user:// one both load, and neither names a file this project owns.
@@ -344,7 +392,7 @@ func _parse_properties_arg(raw_properties: Variant) -> Dictionary:
 	if typeof(raw_properties) == TYPE_DICTIONARY:
 		return raw_properties
 	if typeof(raw_properties) == TYPE_STRING:
-		var text: String = String(raw_properties)
+		var text: String = str(raw_properties)
 		if text.strip_edges().is_empty():
 			return {}
 		var parsed: Variant = JSON.parse_string(text)
@@ -356,7 +404,9 @@ func _parse_properties_arg(raw_properties: Variant) -> Dictionary:
 func _ensure_parent_dir_for_scene(scene_path: String) -> void:
 	var base_dir: String = scene_path.get_base_dir()
 	if not DirAccess.dir_exists_absolute(base_dir):
-		DirAccess.make_dir_recursive_absolute(base_dir)
+		var made: Error = DirAccess.make_dir_recursive_absolute(base_dir)
+		if made != OK:
+			push_error("gdharness: could not create " + base_dir + ": " + error_string(made))
 
 
 func _set_owner_recursive(node: Node, scene_owner: Node) -> void:
@@ -376,7 +426,7 @@ func _build_node_tree(
 	if include_properties:
 		var props: Dictionary = {}
 		for p: Dictionary in node.get_property_list():
-			if not (int(p.get("usage", 0)) & PROPERTY_USAGE_STORAGE):
+			if not (Read.as_int(p.get("usage", 0)) & PROPERTY_USAGE_STORAGE):
 				continue
 			var pn: String = str(p.get("name", ""))
 			if pn.is_empty():
@@ -439,8 +489,8 @@ func create_scene(args: Dictionary) -> Dictionary:
 func list_scene_nodes(args: Dictionary) -> Dictionary:
 	var project_path: String = str(args.get("projectPath", ""))
 	var scene_path: String = _to_scene_res_path(project_path, str(args.get("scenePath", "")))
-	var depth: int = int(args.get("depth", -1))
-	var include_properties: bool = bool(args.get("includeProperties", false))
+	var depth: int = Read.as_int(args.get("depth", -1), -1)
+	var include_properties: bool = Read.as_bool(args.get("includeProperties", false))
 
 	var loaded: Array = _load_scene(scene_path)
 	var refused: Dictionary = loaded[1]
@@ -652,7 +702,7 @@ func get_node_properties(args: Dictionary) -> Dictionary:
 	var project_path: String = str(args.get("projectPath", ""))
 	var scene_path: String = _to_scene_res_path(project_path, str(args.get("scenePath", "")))
 	var node_path: String = str(args.get("nodePath", "."))
-	var include_defaults: bool = bool(args.get("includeDefaults", false))
+	var include_defaults: bool = Read.as_bool(args.get("includeDefaults", false))
 
 	var loaded: Array = _load_scene(scene_path)
 	var refused: Dictionary = loaded[1]
@@ -671,7 +721,7 @@ func get_node_properties(args: Dictionary) -> Dictionary:
 
 	var props: Dictionary = {}
 	for p: Dictionary in node.get_property_list():
-		var usage: int = int(p.get("usage", 0))
+		var usage: int = Read.as_int(p.get("usage", 0))
 		if not (usage & PROPERTY_USAGE_STORAGE):
 			continue
 		var prop_name: String = str(p.get("name", ""))
@@ -721,7 +771,7 @@ func connect_signal(args: Dictionary) -> Dictionary:
 	var method_name: String = str(args.get("methodName", ""))
 	# A connection without CONNECT_PERSIST is a runtime one, and PackedScene.pack drops those on
 	# the way out: without this the scene saves unchanged and this answers success over nothing.
-	var flags: int = int(args.get("flags", 0)) | Object.CONNECT_PERSIST
+	var flags: int = Read.as_int(args.get("flags", 0)) | Object.CONNECT_PERSIST
 
 	if (
 		source_node_path.is_empty()
@@ -854,7 +904,7 @@ func list_connections(args: Dictionary) -> Dictionary:
 						"signalName": signal_name,
 						"targetNodePath": target_path,
 						"methodName": str(callable.get_method()),
-						"flags": int(conn.get("flags", 0))
+						"flags": Read.as_int(conn.get("flags", 0))
 					}
 				)
 
@@ -877,7 +927,7 @@ func rescan_filesystem(args: Dictionary) -> Dictionary:
 		return {"ok": false, "error": "Editor plugin unavailable"}
 
 	var filesystem: EditorFileSystem = EditorInterface.get_resource_filesystem()
-	if not bool(args.get("statusOnly", false)):
+	if not Read.as_bool(args.get("statusOnly", false)):
 		filesystem.scan()
 
 	# Importing is reported separately from scanning, and a class is not registered until

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

@@ -0,0 +1,64 @@
+extends RefCounted
+
+# A value out of a request that arrived as JSON, as the type the caller wants.
+#
+# `int(value)`, `float(value)` and `bool(value)` take a Variant, and a project holding
+# `unsafe_call_argument` at error level will not compile a script that hands one over. The
+# conversion is the same; what changes is that the type is established first, on a typed local, and
+# the conversion happens from that.
+#
+# A copy rather than a preload of the one beside the operations, because an addon is installed as a
+# directory and has to hold everything it uses. This one ships inside exported games, so it must not
+# reach into the editor addon, which does not.
+#
+# `fallback` answers a value that is there and is null, which is a caller sending JSON null where a
+# number was expected. Absent keys never reach here: the callers pass their own default to
+# `Dictionary.get`, so what arrives is that default.
+
+
+static func as_int(value: Variant, fallback: int = 0) -> int:
+	if value is int:
+		var already: int = value
+		return already
+	if value is float:
+		var real: float = value
+		return int(real)
+	if value is bool:
+		var flag: bool = value
+		return 1 if flag else 0
+	if value is String:
+		var text: String = value
+		return text.to_int()
+	return fallback
+
+
+static func as_float(value: Variant, fallback: float = 0.0) -> float:
+	if value is float:
+		var already: float = value
+		return already
+	if value is int:
+		var whole: int = value
+		return float(whole)
+	if value is bool:
+		var flag: bool = value
+		return 1.0 if flag else 0.0
+	if value is String:
+		var text: String = value
+		return text.to_float()
+	return fallback
+
+
+static func as_bool(value: Variant, fallback: bool = false) -> bool:
+	if value is bool:
+		var already: bool = value
+		return already
+	if value is int:
+		var whole: int = value
+		return whole != 0
+	if value is float:
+		var real: float = value
+		return not is_zero_approx(real)
+	if value is String:
+		var text: String = value
+		return not text.is_empty()
+	return fallback

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

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

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

@@ -13,6 +13,7 @@ extends Node
 const Capture = preload("runtime_capture.gd")
 const InputCommands = preload("runtime_input.gd")
 const Queries = preload("runtime_queries.gd")
+const Read = preload("reading.gd")
 const Values = preload("runtime_values.gd")
 const Waits = preload("runtime_waits.gd")
 
@@ -110,8 +111,10 @@ func _process(_delta: float) -> void:
 
 	var gone: Array[StreamPeerTCP] = []
 	for client: StreamPeerTCP in _clients:
-		client.poll()
-		if client.get_status() != StreamPeerTCP.STATUS_CONNECTED:
+		# A poll that fails is a client that has already gone, which the status check below is
+		# about to find; the answer is read so it is not dropped, not because it adds anything.
+		var polled: Error = client.poll()
+		if polled != OK or client.get_status() != StreamPeerTCP.STATUS_CONNECTED:
 			gone.append(client)
 			continue
 		var available: int = client.get_available_bytes()
@@ -124,8 +127,11 @@ func _process(_delta: float) -> void:
 
 	for client: StreamPeerTCP in gone:
 		_clients.erase(client)
-		_pending.erase(client)
-		_outgoing.erase(client)
+		# Dictionary.erase answers with whether the key was there, and underscore-prefixed locals
+		# are how GDScript says an answer is deliberately unwanted: a client that had nothing
+		# pending or owed is as forgotten as one that had both.
+		var _had_pending: bool = _pending.erase(client)
+		var _had_outgoing: bool = _outgoing.erase(client)
 
 
 ## Hands the socket as much of what it is owed as it will take, and says whether it is still worth
@@ -138,7 +144,7 @@ func _drain(client: StreamPeerTCP) -> bool:
 	var sent: Array = client.put_partial_data(owed)
 	if sent[0] != OK:
 		return false
-	_outgoing[client] = owed.slice(int(sent[1]))
+	_outgoing[client] = owed.slice(Read.as_int(sent[1]))
 	return true
 
 
@@ -172,14 +178,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 bool(ProjectSettings.get_setting(SCRIPT_RUNS_SETTING, false)):
+	if _script_run() and not Read.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 = int(ProjectSettings.get_setting(PORT_SETTING, 0))
+	var wanted_port: int = Read.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
@@ -233,8 +239,11 @@ func _announce(bind_address: String) -> void:
 			)
 		)
 		return
-	file.store_string(JSON.stringify(_identity(bind_address)))
+	var announced: bool = file.store_string(JSON.stringify(_identity(bind_address)))
 	file.close()
+	if not announced:
+		push_warning("[gdharness] cannot write %s; the server will not find this game" % path)
+		return
 	_announcement = path
 
 
@@ -286,11 +295,12 @@ func _handle_message(client: StreamPeerTCP, line: String) -> void:
 	if not params is Dictionary:
 		_send_error(client, request_id, "params must be an object")
 		return
+	var arguments: Dictionary = params
 
 	# A command that waits on the game (a frame, a signal, a condition) suspends here and answers
 	# when it is done, while _process keeps serving the other clients in the meantime. A client
 	# that hung up while its command waited is simply not written to.
-	var result: Dictionary = await _execute_command(command, params)
+	var result: Dictionary = await _execute_command(command, arguments)
 	result["id"] = request_id
 	if client.get_status() == StreamPeerTCP.STATUS_CONNECTED:
 		_send_response(client, result)
@@ -346,5 +356,9 @@ func _cleanup() -> void:
 	# The announcement is what tells the server this game exists, so it goes before the
 	# process does. A crash leaves it behind, and the server drops one whose process is gone.
 	if not _announcement.is_empty():
-		DirAccess.remove_absolute(_announcement)
+		var removed: Error = DirAccess.remove_absolute(_announcement)
+		if removed != OK:
+			push_warning(
+				"[gdharness] cannot remove %s; the server will find a game that is gone" % _announcement
+			)
 		_announcement = ""

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

@@ -2,6 +2,7 @@ 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")
 
 var _host: Node
@@ -16,7 +17,7 @@ func capture_screenshot(params: Dictionary) -> Dictionary:
 
 
 func capture_viewport(params: Dictionary) -> Dictionary:
-	var viewport_path: String = String(params.get("viewportPath", ""))
+	var viewport_path: String = str(params.get("viewportPath", ""))
 	if viewport_path.is_empty():
 		return capture_screenshot(params)
 
@@ -26,13 +27,14 @@ func capture_viewport(params: Dictionary) -> Dictionary:
 	var node: Node = standing["node"]
 	if not node is Viewport:
 		return {"type": "error", "message": "Node is not a Viewport: " + viewport_path}
-	return _capture(node, params)
+	var viewport: Viewport = node
+	return _capture(viewport, params)
 
 
 ## The server names the file, so a game cannot point it at a path of its own choosing; a call
 ## with no path is a call the server did not make.
 func _capture(viewport: Viewport, params: Dictionary) -> Dictionary:
-	var requested_path: String = String(params.get("output_path", ""))
+	var requested_path: String = str(params.get("output_path", ""))
 	if requested_path.is_empty():
 		return {"type": "error", "message": "output_path required"}
 
@@ -59,8 +61,8 @@ func _capture(viewport: Viewport, params: Dictionary) -> Dictionary:
 	if image == null:
 		return {"type": "error", "message": "Failed to capture viewport image"}
 
-	var width: int = int(params.get("width", 0))
-	var height: int = int(params.get("height", 0))
+	var width: int = Read.as_int(params.get("width", 0))
+	var height: int = Read.as_int(params.get("height", 0))
 	if width > 0 and height > 0:
 		image.resize(width, height)
 

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

@@ -9,6 +9,7 @@ const Values = preload("runtime_values.gd")
 ## query module rather than worked out again here, so the place this aims at and the place a rect
 ## reports are the same place by construction rather than by agreement.
 const Queries = preload("runtime_queries.gd")
+const Read = preload("reading.gd")
 
 ## The distance from a capital letter to its small one in Unicode. A keycode holds the capital.
 const TO_SMALL: int = 32
@@ -40,10 +41,10 @@ func _init(host: Node, values: Values) -> void:
 ##
 ## `pressed` is how a caller says otherwise: true holds it down, false lets go of one being held.
 func inject_action(params: Dictionary) -> Dictionary:
-	var action: String = String(params.get("action", ""))
-	var held: bool = bool(params.get("pressed", true))
+	var action: String = str(params.get("action", ""))
+	var held: bool = Read.as_bool(params.get("pressed", true), true)
 	var whole: bool = not params.has("pressed")
-	var strength: float = float(params.get("strength", 1.0))
+	var strength: float = Read.as_float(params.get("strength", 1.0), 1.0)
 
 	if action.is_empty():
 		return {"type": "error", "message": "Action name required"}
@@ -79,15 +80,15 @@ func _say_action(action: String, down: bool, strength: float) -> void:
 ## Presses one key, and lets go of it again unless asked to hold it. See [method inject_action].
 func inject_key(params: Dictionary) -> Dictionary:
 	var keycode_raw: Variant = params.get("keycode", 0)
-	var held: bool = bool(params.get("pressed", true))
+	var held: bool = Read.as_bool(params.get("pressed", true), true)
 	var whole: bool = not params.has("pressed")
-	var key_label: String = String(params.get("key_label", ""))
+	var key_label: String = str(params.get("key_label", ""))
 
 	if keycode_raw is String:
 		var named: String = keycode_raw
 		if not named.is_empty() and key_label.is_empty():
 			key_label = named
-	var keycode: int = 0 if keycode_raw is String else int(keycode_raw)
+	var keycode: int = 0 if keycode_raw is String else Read.as_int(keycode_raw)
 
 	var event: InputEventKey = InputEventKey.new()
 	event.pressed = whole or held
@@ -109,9 +110,9 @@ func inject_key(params: Dictionary) -> Dictionary:
 	event.physical_keycode = event.keycode
 	event.key_label = event.keycode
 
-	event.shift_pressed = bool(params.get("shift", false))
-	event.ctrl_pressed = bool(params.get("ctrl", false))
-	event.alt_pressed = bool(params.get("alt", false))
+	event.shift_pressed = Read.as_bool(params.get("shift", false))
+	event.ctrl_pressed = Read.as_bool(params.get("ctrl", false))
+	event.alt_pressed = Read.as_bool(params.get("alt", false))
 
 	# The fourth thing a real event carries, and the only one a text field reads: LineEdit and
 	# TextEdit insert `unicode` and never consult the keycode, so an injected key could press any
@@ -161,8 +162,8 @@ func inject_key(params: Dictionary) -> Dictionary:
 ## 2.1, and the answer said four characters had gone in. What the field holds afterwards is read
 ## back now rather than echoed from the request, so a call that typed somewhere unhelpful says so.
 func inject_text(params: Dictionary) -> Dictionary:
-	var text: String = String(params.get("text", ""))
-	var over: bool = bool(params.get("replace", false))
+	var text: String = str(params.get("text", ""))
+	var over: bool = Read.as_bool(params.get("replace", false))
 	if text.is_empty() and not over:
 		return {"type": "error", "message": "text needs something to type, or replace to empty a field"}
 
@@ -305,7 +306,7 @@ func _glyph_of(keycode: Key, shifted: bool) -> int:
 ## Answers a Vector2, or the String that says what was wrong with it.
 func _read_point(params: Dictionary, x_key: String, y_key: String, pair_key: String) -> Variant:
 	if params.has(x_key) and params.has(y_key):
-		return Vector2(float(params[x_key]), float(params[y_key]))
+		return Vector2(Read.as_float(params[x_key]), Read.as_float(params[y_key]))
 	var raw: Variant = params.get(pair_key, Vector2.ZERO)
 	if raw is Vector2:
 		return raw
@@ -313,7 +314,7 @@ func _read_point(params: Dictionary, x_key: String, y_key: String, pair_key: Str
 		var pair: Array = raw
 		if pair.size() < 2:
 			return "%s array must contain [x, y]" % pair_key
-		return Vector2(float(pair[0]), float(pair[1]))
+		return Vector2(Read.as_float(pair[0]), Read.as_float(pair[1]))
 	return "%s must be Vector2 or [x, y]" % pair_key
 
 
@@ -325,8 +326,8 @@ func inject_mouse_click(params: Dictionary) -> Dictionary:
 	var button: int = _resolve_mouse_button(params.get("button", MOUSE_BUTTON_LEFT))
 	if button < 0:
 		return _no_such_button(params.get("button"))
-	var pressed: bool = bool(params.get("pressed", true))
-	var double: bool = bool(params.get("doubleClick", false))
+	var pressed: bool = Read.as_bool(params.get("pressed", true), true)
+	var double: bool = Read.as_bool(params.get("doubleClick", false))
 
 	Input.parse_input_event(_button(position, button, pressed, double))
 
@@ -445,7 +446,8 @@ func click(params: Dictionary) -> Dictionary:
 		return standing
 	var node: Node = standing["node"]
 	if node is Node3D:
-		return await _click_in_the_world(node_path, node, params)
+		var spatial: Node3D = node
+		return await _click_in_the_world(node_path, spatial, params)
 	if not node is Control:
 		return {
 			"type": "error",
@@ -495,7 +497,7 @@ func click(params: Dictionary) -> Dictionary:
 	var button: int = _resolve_mouse_button(params.get("button", MOUSE_BUTTON_LEFT))
 	if button < 0:
 		return _no_such_button(params.get("button"))
-	var double: bool = bool(params.get("double", false))
+	var double: bool = Read.as_bool(params.get("double", false))
 
 	# Pushed into the viewport rather than through Input: Input accumulates events and flushes
 	# them at the next frame, so the hovered control read below would be the one from before
@@ -672,7 +674,7 @@ static func _menu_of(node: Node) -> PopupMenu:
 ## Minus one when neither names one that is there.
 static func _wanted_item(menu: PopupMenu, params: Dictionary) -> int:
 	if params.has("index"):
-		var asked: int = int(params.get("index", -1))
+		var asked: int = Read.as_int(params.get("index", -1), -1)
 		return asked if asked >= 0 and asked < menu.get_item_count() else -1
 	var wanted: String = str(params.get("text", ""))
 	if wanted.is_empty():
@@ -687,8 +689,8 @@ static func _wanted_item(menu: PopupMenu, params: Dictionary) -> int:
 
 
 ## What the menu says, for a refusal that names the choices rather than the miss.
-static func _items_of(menu: PopupMenu) -> PackedStringArray:
-	var said: PackedStringArray = PackedStringArray()
+static func _items_of(menu: PopupMenu) -> Array[String]:
+	var said: Array[String] = []
 	for index: int in menu.get_item_count():
 		said.append("%d: %s" % [index, menu.get_item_text(index)])
 	return said
@@ -758,7 +760,7 @@ func _click_in_the_world(node_path: String, item: Node3D, params: Dictionary) ->
 	var button: int = _resolve_mouse_button(params.get("button", MOUSE_BUTTON_LEFT))
 	if button < 0:
 		return _no_such_button(params.get("button"))
-	var double: bool = bool(params.get("double", false))
+	var double: bool = Read.as_bool(params.get("double", false))
 
 	viewport.push_input(_motion(position, Vector2.ZERO))
 	# Read before the press, for the reason the Control click reads it: what the caller needs to
@@ -839,4 +841,4 @@ func _resolve_mouse_button(raw: Variant) -> int:
 				return MOUSE_BUTTON_WHEEL_DOWN
 			_:
 				return -1
-	return int(raw)
+	return Read.as_int(raw, -1)