gdharness 0.12.17 → 0.13.0

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)

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

@@ -3,6 +3,7 @@ extends RefCounted
 ## What the server asks about the running tree: its shape, one node, the nodes matching a
 ## question, where one is on screen, a property set, a method called, the metrics.
 
+const Read = preload("reading.gd")
 const Values = preload("runtime_values.gd")
 
 ## The most nodes one find answers with, unless asked for fewer: enough for any real query and
@@ -31,8 +32,8 @@ func _init(host: Node, values: Values) -> void:
 
 func get_tree(params: Dictionary) -> Dictionary:
 	var root_path: String = str(params.get("root", "/root"))
-	var max_depth: int = int(params.get("depth", 3))
-	var include_properties: bool = bool(params.get("include_properties", false))
+	var max_depth: int = Read.as_int(params.get("depth", 3), 3)
+	var include_properties: bool = Read.as_bool(params.get("include_properties", false))
 
 	var reached: Dictionary = Values.node_at(_host.get_tree().root, root_path)
 	if reached.has("message"):
@@ -65,8 +66,8 @@ func find_nodes(params: Dictionary) -> Dictionary:
 	for filter: String in FILTERS:
 		wanted[filter] = str(params.get(filter, ""))
 	var wanted_property: String = str(params.get("property", ""))
-	var include_hidden: bool = bool(params.get("include_hidden", true))
-	var limit: int = clampi(int(params.get("limit", FIND_LIMIT)), 1, FIND_LIMIT_CEILING)
+	var include_hidden: bool = Read.as_bool(params.get("include_hidden", true), true)
+	var limit: int = clampi(Read.as_int(params.get("limit", FIND_LIMIT), FIND_LIMIT), 1, FIND_LIMIT_CEILING)
 
 	if not _anything_asked(wanted):
 		return {"type": "error", "message": "find_nodes needs at least one of " + ", ".join(FILTERS)}
@@ -110,7 +111,7 @@ func find_nodes(params: Dictionary) -> Dictionary:
 			pending.push_front(children[index])
 
 	var answer: Dictionary = {"type": "nodes", "count": found.size(), "truncated": truncated, "nodes": found}
-	var notes: PackedStringArray = []
+	var notes: Array[String] = []
 	# Nothing found is the one answer that cannot be told apart from having asked the wrong
 	# question, and a name written without a wildcard is the way an agent writes "contains".
 	# Said only when it changes the answer, so a genuine nothing stays a plain nothing.
@@ -262,8 +263,8 @@ func _matches_apart_from_name(node: Node, wanted: Dictionary[String, String]) ->
 ## whose interesting half is below the cut says so in a number rather than in a flag.
 func read_text(params: Dictionary) -> Dictionary:
 	var root_path: String = str(params.get("root", "/root"))
-	var include_hidden: bool = bool(params.get("include_hidden", false))
-	var limit: int = clampi(int(params.get("limit", READ_LIMIT)), 1, READ_LIMIT)
+	var include_hidden: bool = Read.as_bool(params.get("include_hidden", false))
+	var limit: int = clampi(Read.as_int(params.get("limit", READ_LIMIT), READ_LIMIT), 1, READ_LIMIT)
 
 	var reached: Dictionary = Values.node_at(_host.get_tree().root, root_path)
 	if reached.has("message"):
@@ -275,7 +276,7 @@ func read_text(params: Dictionary) -> Dictionary:
 	# player is being asked to answer below them reads exactly like a dialog that is not there,
 	# and a bare `truncated: true` was looked straight past twice before the limit was suspected.
 	# A number is what sends somebody back.
-	var lines: PackedStringArray = PackedStringArray()
+	var lines: Array[String] = []
 	var left_out: int = _read_into(root, include_hidden, limit, lines)
 	return {
 		"type": "text",
@@ -297,7 +298,7 @@ func read_text(params: Dictionary) -> Dictionary:
 ## until it is opened, and reading a closed menu would put every item on the screen.
 ## Fills [param into] up to [param most] lines and answers with how many further lines the rest of
 ## the subtree says, which is what the caller is told rather than left to infer.
-func _read_into(node: Node, include_hidden: bool, most: int, into: PackedStringArray) -> int:
+func _read_into(node: Node, include_hidden: bool, most: int, into: Array[String]) -> int:
 	if not include_hidden and not _drawn(node):
 		return 0
 	var left_out: int = 0
@@ -336,7 +337,7 @@ static func _drawn(node: Node) -> bool:
 ## the three of them come to disagree about a SpinBox.
 static func said_by(node: Node) -> String:
 	for property: Dictionary in node.get_property_list():
-		if str(property.get("name", "")) == "text" and int(property.get("type", 0)) == TYPE_STRING:
+		if str(property.get("name", "")) == "text" and Read.as_int(property.get("type", 0)) == TYPE_STRING:
 			return str(node.get("text")).strip_edges()
 	return ""
 
@@ -374,7 +375,8 @@ func get_rect(params: Dictionary) -> Dictionary:
 			"window": _values.serialize(window_position),
 		}
 	if node is Node3D:
-		return _in_the_frame(node_path, node)
+		var spatial: Node3D = node
+		return _in_the_frame(node_path, spatial)
 	return {
 		"type": "error", "message": "%s is a %s, which has no place on screen" % [node_path, node.get_class()]
 	}
@@ -573,7 +575,8 @@ static func _can_read(holder: Variant, named: String) -> bool:
 		var map: Dictionary = holder
 		return map.has(named) or map.has(StringName(named))
 	if holder is Object:
-		return _has_property(holder, named)
+		var object: Object = holder
+		return _has_property(object, named)
 	return false
 
 
@@ -638,7 +641,7 @@ static func _nothing_there(holder: Variant, named: String, called: String) -> St
 		var keys: Array = map.keys()
 		# Eight of them, because a map keyed by something unexpected is told by the first few and a
 		# map of two hundred would bury the sentence saying which key was missing.
-		var some: PackedStringArray = []
+		var some: Array[String] = []
 		for key: Variant in keys.slice(0, 8):
 			some.append(str(key))
 		var rest: String = ""

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

@@ -3,6 +3,8 @@ extends RefCounted
 ## What crosses the wire between the game and the server, in both directions: Godot values
 ## as JSON-safe dictionaries, and JSON back into the values a property or parameter wants.
 
+const Read = preload("reading.gd")
+
 # What each Godot type becomes on the wire, keyed on typeof() rather than written as a chain of
 # `is` tests whose order has to be trusted: Resource had to be tested before Object, or every
 # resource came back as a bare class name with its path dropped.
@@ -190,17 +192,30 @@ func deserialize(value: Variant) -> Variant:
 
 	match fields["_type"]:
 		"Vector2":
-			return Vector2(fields.get("x", 0), fields.get("y", 0))
+			return Vector2(Read.as_float(fields.get("x", 0)), Read.as_float(fields.get("y", 0)))
 		"Vector3":
-			return Vector3(fields.get("x", 0), fields.get("y", 0), fields.get("z", 0))
+			return Vector3(
+				Read.as_float(fields.get("x", 0)),
+				Read.as_float(fields.get("y", 0)),
+				Read.as_float(fields.get("z", 0))
+			)
 		"Vector2i":
-			return Vector2i(fields.get("x", 0), fields.get("y", 0))
+			return Vector2i(Read.as_int(fields.get("x", 0)), Read.as_int(fields.get("y", 0)))
 		"Vector3i":
-			return Vector3i(fields.get("x", 0), fields.get("y", 0), fields.get("z", 0))
+			return Vector3i(
+				Read.as_int(fields.get("x", 0)),
+				Read.as_int(fields.get("y", 0)),
+				Read.as_int(fields.get("z", 0))
+			)
 		"Color":
-			return Color(fields.get("r", 0), fields.get("g", 0), fields.get("b", 0), fields.get("a", 1))
+			return Color(
+				Read.as_float(fields.get("r", 0)),
+				Read.as_float(fields.get("g", 0)),
+				Read.as_float(fields.get("b", 0)),
+				Read.as_float(fields.get("a", 1), 1.0)
+			)
 		"NodePath":
-			return NodePath(fields.get("path", ""))
+			return NodePath(str(fields.get("path", "")))
 	return value
 
 
@@ -214,7 +229,7 @@ func parameter_type(object: Object, method: String, index: int) -> int:
 		if index < 0 or index >= params.size():
 			return TYPE_NIL
 		var parameter: Dictionary = params[index]
-		return int(parameter.get("type", TYPE_NIL))
+		return Read.as_int(parameter.get("type", TYPE_NIL), TYPE_NIL)
 	return TYPE_NIL
 
 
@@ -231,7 +246,8 @@ func fitted(value: Variant, type: int) -> Variant:
 		return rebuilt
 
 	if rebuilt is String and type != TYPE_STRING:
-		var parsed: Variant = JSON.parse_string(rebuilt)
+		var text: String = rebuilt
+		var parsed: Variant = JSON.parse_string(text)
 		if typeof(parsed) != TYPE_NIL and typeof(parsed) != TYPE_STRING:
 			rebuilt = parsed
 

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

@@ -4,6 +4,7 @@ extends RefCounted
 ## happened, or when the time ran out, so the caller never sleeps for a guessed length.
 
 const Queries = preload("runtime_queries.gd")
+const Read = preload("reading.gd")
 const Values = preload("runtime_values.gd")
 
 ## The longest one wait may last, whatever the request says: past this the server has long
@@ -34,7 +35,7 @@ static func _out_of_range(named: String, asked: int, least: int, most: int) -> D
 
 
 func wait_frames(params: Dictionary) -> Dictionary:
-	var frames: int = int(params.get("frames", 1))
+	var frames: int = Read.as_int(params.get("frames", 1), 1)
 	if frames < 1 or frames > MOST_FRAMES:
 		return _out_of_range("frames", frames, 1, MOST_FRAMES)
 	var started: int = Time.get_ticks_msec()
@@ -47,7 +48,7 @@ func wait_frames(params: Dictionary) -> Dictionary:
 func wait_signal(params: Dictionary) -> Dictionary:
 	var node_path: String = str(params.get("path", ""))
 	var signal_name: String = str(params.get("signal", ""))
-	var timeout_ms: int = int(params.get("timeout_ms", 5000))
+	var timeout_ms: int = Read.as_int(params.get("timeout_ms", 5000), 5000)
 	if timeout_ms < 1 or timeout_ms > CEILING_MSEC:
 		return _out_of_range("timeout_ms", timeout_ms, 1, CEILING_MSEC)
 	if node_path.is_empty() or signal_name.is_empty():
@@ -63,7 +64,9 @@ func wait_signal(params: Dictionary) -> Dictionary:
 	var catcher: SignalCatcher = SignalCatcher.new()
 	catcher.arity = _signal_arity(node, signal_name)
 	var callable: Callable = catcher._on_fired
-	node.connect(signal_name, callable, CONNECT_ONE_SHOT)
+	var listening: Error = node.connect(signal_name, callable, CONNECT_ONE_SHOT)
+	if listening != OK:
+		return {"type": "error", "message": "Could not listen to signal: " + signal_name}
 	var started: int = Time.get_ticks_msec()
 	while not catcher.fired and Time.get_ticks_msec() - started < timeout_ms:
 		await _host.get_tree().process_frame
@@ -86,7 +89,7 @@ func wait_until(params: Dictionary) -> Dictionary:
 	var node_path: String = str(params.get("path", ""))
 	var property: String = str(params.get("property", ""))
 	var says: String = str(params.get("says", ""))
-	var timeout_ms: int = int(params.get("timeout_ms", 5000))
+	var timeout_ms: int = Read.as_int(params.get("timeout_ms", 5000), 5000)
 	if timeout_ms < 1 or timeout_ms > CEILING_MSEC:
 		return _out_of_range("timeout_ms", timeout_ms, 1, CEILING_MSEC)
 	if node_path.is_empty():

package/build/godot/operations/audio_buses.gd

@@ -3,6 +3,7 @@ extends RefCounted
 # The bus layout is a project resource the engine loads at startup and this process holds in
 # memory, so every change is written back to that file or it is gone with the process.
 
+const Read = preload("reading.gd")
 const Log = preload("logger.gd")
 
 var _log: Log
@@ -16,7 +17,7 @@ func create_audio_bus(params: Dictionary) -> Dictionary:
 	var bus_name: String = str(params.get("bus_name", ""))
 	if bus_name.is_empty():
 		return _log.failure("bus_name is required")
-	var parent_idx: int = int(params.get("parent_bus_index", 0))
+	var parent_idx: int = Read.as_int(params.get("parent_bus_index", 0))
 	if parent_idx < 0 or parent_idx >= AudioServer.bus_count:
 		return _log.failure("No bus at index " + str(parent_idx))
 
@@ -40,10 +41,10 @@ func get_audio_buses(_params: Dictionary) -> Dictionary:
 
 
 func set_audio_bus_effect(params: Dictionary) -> Dictionary:
-	var bus_idx: int = int(params.get("bus_index", 0))
-	var effect_idx: int = int(params.get("effect_index", 0))
+	var bus_idx: int = Read.as_int(params.get("bus_index", 0))
+	var effect_idx: int = Read.as_int(params.get("effect_index", 0))
 	var effect_type: String = str(params.get("effect_type", ""))
-	var enabled: bool = bool(params.get("enabled", true))
+	var enabled: bool = Read.as_bool(params.get("enabled", true), true)
 	if bus_idx < 0 or bus_idx >= AudioServer.bus_count:
 		return _log.failure("No bus at index " + str(bus_idx))
 
@@ -65,8 +66,8 @@ func set_audio_bus_effect(params: Dictionary) -> Dictionary:
 
 
 func set_audio_bus_volume(params: Dictionary) -> Dictionary:
-	var bus_idx: int = int(params.get("bus_index", 0))
-	var volume_db: float = float(params.get("volume_db", 0.0))
+	var bus_idx: int = Read.as_int(params.get("bus_index", 0))
+	var volume_db: float = Read.as_float(params.get("volume_db", 0.0))
 	if bus_idx < 0 or bus_idx >= AudioServer.bus_count:
 		return _log.failure("No bus at index " + str(bus_idx))
 

package/build/godot/operations/class_cache.gd

@@ -5,6 +5,8 @@ extends RefCounted
 # A game started from a stale editor then cannot resolve any class_name written since, and the
 # engine reads the same file headless, so the list is rebuilt here from the scripts themselves.
 
+const Patterns = preload("patterns.gd")
+const Read = preload("reading.gd")
 const FileWalk = preload("file_walk.gd")
 const Log = preload("logger.gd")
 
@@ -33,7 +35,11 @@ func refresh_class_cache(_params: Dictionary) -> Dictionary:
 	var after: Dictionary = _entries_by_class(entries)
 	var config: ConfigFile = ConfigFile.new()
 	config.set_value("", "list", entries)
-	DirAccess.make_dir_recursive_absolute(ProjectSettings.globalize_path(CACHE_PATH.get_base_dir()))
+	var made: Error = DirAccess.make_dir_recursive_absolute(
+		ProjectSettings.globalize_path(CACHE_PATH.get_base_dir())
+	)
+	if made != OK and made != ERR_ALREADY_EXISTS:
+		return _log.failure("Could not make " + CACHE_PATH.get_base_dir() + ": " + error_string(made))
 	var err: Error = config.save(CACHE_PATH)
 	if err != OK:
 		return _log.failure("Failed to write " + CACHE_PATH + ": " + error_string(err))
@@ -80,8 +86,8 @@ func _entry_for(path: String, skipped: Array[Dictionary]) -> Dictionary:
 		"base": StringName(base),
 		"class": StringName(declared),
 		"icon": str(header.get("icon", "")),
-		"is_abstract": bool(header.get("abstract", false)),
-		"is_tool": bool(header.get("tool", false)),
+		"is_abstract": Read.as_bool(header.get("abstract", false)),
+		"is_tool": Read.as_bool(header.get("tool", false)),
 		"language": StringName("GDScript"),
 		"path": path,
 	}
@@ -123,12 +129,11 @@ func _header_of(path: String) -> Dictionary:
 	var file: FileAccess = FileAccess.open(path, FileAccess.READ)
 	if not file:
 		return header
-	var annotation: RegEx = RegEx.new()
-	annotation.compile('^@([a-z_]+)(?:\\(\\s*(?:"([^"]*)")?[^)]*\\))?\\s*')
-	var class_line: RegEx = RegEx.new()
-	class_line.compile("^class_name\\s+([A-Za-z_][A-Za-z0-9_]*)(?:\\s+extends\\s+(\\S+))?")
-	var extends_line: RegEx = RegEx.new()
-	extends_line.compile("^extends\\s+(\\S+)")
+	var annotation: RegEx = Patterns.compiled('^@([a-z_]+)(?:\\(\\s*(?:"([^"]*)")?[^)]*\\))?\\s*')
+	var class_line: RegEx = Patterns.compiled(
+		"^class_name\\s+([A-Za-z_][A-Za-z0-9_]*)(?:\\s+extends\\s+(\\S+))?"
+	)
+	var extends_line: RegEx = Patterns.compiled("^extends\\s+(\\S+)")
 	while not file.eof_reached():
 		var rest: String = file.get_line().strip_edges()
 		# Annotations may share a line with what they annotate, as in `@abstract class_name X`.

package/build/godot/operations/classdb_queries.gd

@@ -1,5 +1,6 @@
 extends RefCounted
 
+const Read = preload("reading.gd")
 const Log = preload("logger.gd")
 
 # The base class each category name stands for.
@@ -27,7 +28,7 @@ func _init(p_log: Log) -> void:
 func query_classes(params: Dictionary) -> Dictionary:
 	var filter: String = str(params.get("filter", ""))
 	var category: String = str(params.get("category", ""))
-	var instantiable_only: bool = bool(params.get("instantiable_only", false))
+	var instantiable_only: bool = Read.as_bool(params.get("instantiable_only", false))
 
 	_log.info(
 		(
@@ -82,7 +83,7 @@ func query_classes(params: Dictionary) -> Dictionary:
 # Query detailed info about a specific class from ClassDB
 func query_class_info(params: Dictionary) -> Dictionary:
 	var class_name_str: String = str(params.get("class_name", ""))
-	var include_inherited: bool = bool(params.get("include_inherited", false))
+	var include_inherited: bool = Read.as_bool(params.get("include_inherited", false))
 
 	_log.info(
 		"Querying class info for: " + class_name_str + " (include_inherited: " + str(include_inherited) + ")"
@@ -220,7 +221,7 @@ func _properties_of(class_name_str: String, include_inherited: bool) -> Array[Di
 
 	for p: Dictionary in ClassDB.class_get_property_list(class_name_str, not include_inherited):
 		# A category, group or subgroup is an editor heading rather than a property.
-		var usage: int = int(p.get("usage", 0))
+		var usage: int = Read.as_int(p.get("usage", 0))
 		if usage & PROPERTY_USAGE_CATEGORY or usage & PROPERTY_USAGE_GROUP or usage & PROPERTY_USAGE_SUBGROUP:
 			continue
 		properties.append(