gdharness 0.12.17 → 0.13.0

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

@@ -3,6 +3,8 @@ extends Node
 
 ## Animations and animation trees, edited in the open editor.
 
+const Read = preload("../reading.gd")
+
 var _editor_plugin: EditorPlugin = null
 
 
@@ -75,12 +77,19 @@ func _parse_value(value: Variant) -> Variant:
 			var t: Variant = fields.get("type", fields.get("_type", ""))
 			match t:
 				"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))
+					)
 				"Color":
 					return Color(
-						fields.get("r", 1), fields.get("g", 1), fields.get("b", 1), fields.get("a", 1)
+						Read.as_float(fields.get("r", 1), 1.0),
+						Read.as_float(fields.get("g", 1), 1.0),
+						Read.as_float(fields.get("b", 1), 1.0),
+						Read.as_float(fields.get("a", 1), 1.0)
 					)
 	if typeof(value) == TYPE_ARRAY:
 		var result: Array = []
@@ -93,8 +102,9 @@ func _parse_value(value: Variant) -> Variant:
 func _parse_json_maybe(value: Variant) -> Variant:
 	if typeof(value) != TYPE_STRING:
 		return value
-	var parsed: Variant = JSON.parse_string(value)
-	if parsed == null and value != "null":
+	var text: String = value
+	var parsed: Variant = JSON.parse_string(text)
+	if parsed == null and text != "null":
 		return value
 	return parsed
 
@@ -183,9 +193,9 @@ func create_animation(args: Dictionary) -> Dictionary:
 			loop_mode = Animation.LOOP_NONE
 
 	var anim: Animation = Animation.new()
-	anim.length = float(args.get("length", 1.0))
+	anim.length = Read.as_float(args.get("length", 1.0), 1.0)
 	anim.loop_mode = loop_mode
-	anim.step = float(args.get("step", 0.1))
+	anim.step = Read.as_float(args.get("step", 0.1), 0.1)
 
 	var add_err: Error = anim_lib.add_animation(StringName(animation_name), anim)
 	if add_err != OK:
@@ -262,7 +272,11 @@ func add_animation_track(args: Dictionary) -> Dictionary:
 				var parsed_value: Variant = (
 					_parse_json_maybe(raw_value) if typeof(raw_value) == TYPE_STRING else raw_value
 				)
-				anim.track_insert_key(track_idx, float(keyframe.get("time", 0.0)), _parse_value(parsed_value))
+				var placed: int = anim.track_insert_key(
+					track_idx, Read.as_float(keyframe.get("time", 0.0)), _parse_value(parsed_value)
+				)
+				if placed < 0:
+					push_error("gdharness: could not key " + prop_name + " on " + node_path_str)
 
 		"method":
 			var method_node_path: String = str(track.get("nodePath", ""))
@@ -276,10 +290,14 @@ func add_animation_track(args: Dictionary) -> Dictionary:
 				if typeof(entry) != TYPE_DICTIONARY:
 					continue
 				var keyframe: Dictionary = entry
-				var invocation: Dictionary = {
-					"method": method_name, "args": _parse_method_args(keyframe.get("args", []))
-				}
-				anim.track_insert_key(track_idx, float(keyframe.get("time", 0.0)), invocation)
+				var given: Variant = keyframe.get("args", [])
+				var arguments: Array = given if given is Array else []
+				var invocation: Dictionary = {"method": method_name, "args": _parse_method_args(arguments)}
+				var placed: int = anim.track_insert_key(
+					track_idx, Read.as_float(keyframe.get("time", 0.0)), invocation
+				)
+				if placed < 0:
+					push_error("gdharness: could not key " + method_name + " on " + method_node_path)
 
 		_:
 			scene_root.queue_free()

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

@@ -34,7 +34,7 @@ func global_classes(_args: Dictionary) -> Dictionary:
 		return {"ok": false, "error": "Editor plugin unavailable"}
 
 	var filesystem: EditorFileSystem = EditorInterface.get_resource_filesystem()
-	var names: PackedStringArray = []
+	var names: Array[String] = []
 	_walk(filesystem.get_filesystem(), names)
 	names.sort()
 	return {
@@ -45,7 +45,10 @@ func global_classes(_args: Dictionary) -> Dictionary:
 	}
 
 
-func _walk(directory: EditorFileSystemDirectory, into: PackedStringArray) -> void:
+# Array[String] rather than PackedStringArray: appending to a packed array answers with whether it
+# worked, and a project holding return_value_discarded at error level refuses a script that drops
+# that answer. Both reach the caller as the same list of strings.
+func _walk(directory: EditorFileSystemDirectory, into: Array[String]) -> void:
 	if directory == null:
 		return
 	for index: int in range(directory.get_file_count()):

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

@@ -9,6 +9,8 @@ extends Node
 ## tools answer at all.
 
 ## What the display server calls itself when the engine was started with no display at all.
+const Read = preload("../reading.gd")
+
 const HEADLESS_DISPLAY: String = "headless"
 ## Where Godot keeps the port its own debugger listens on for a game it is playing. One setting
 ## for every editor on the machine, and bound only while a game runs.
@@ -158,7 +160,7 @@ func playing_status(_args: Dictionary) -> Dictionary:
 	# play, so the one from when this editor greeted the server is a number it has moved off.
 	var settings: EditorSettings = EditorInterface.get_editor_settings()
 	var debugger: int = (
-		int(settings.get_setting(DEBUGGER_SETTING))
+		Read.as_int(settings.get_setting(DEBUGGER_SETTING))
 		if settings != null and settings.has_setting(DEBUGGER_SETTING)
 		else 0
 	)

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

@@ -3,6 +3,8 @@ extends Node
 
 ## Resource files, shaders, tilesets and themes, written through the open editor.
 
+const Read = preload("../reading.gd")
+
 # Shader templates. Written as real multi-line source rather than escaped one-liners so that
 # what ends up in the .gdshader can be read here. The %s is the shader type.
 const SHADER_EMPTY: String = """shader_type %s;
@@ -75,26 +77,37 @@ func _parse_value(value: Variant) -> Variant:
 			var t: Variant = fields.get("type", fields.get("_type", ""))
 			match t:
 				"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))
+					)
 				"Color":
 					return Color(
-						fields.get("r", 1), fields.get("g", 1), fields.get("b", 1), fields.get("a", 1)
+						Read.as_float(fields.get("r", 1), 1.0),
+						Read.as_float(fields.get("g", 1), 1.0),
+						Read.as_float(fields.get("b", 1), 1.0),
+						Read.as_float(fields.get("a", 1), 1.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))
+					)
 				"Rect2":
 					return Rect2(
-						fields.get("x", 0),
-						fields.get("y", 0),
-						fields.get("width", 0),
-						fields.get("height", 0)
+						Read.as_float(fields.get("x", 0)),
+						Read.as_float(fields.get("y", 0)),
+						Read.as_float(fields.get("width", 0)),
+						Read.as_float(fields.get("height", 0))
 					)
 				"NodePath":
-					return NodePath(fields.get("path", ""))
+					return NodePath(str(fields.get("path", "")))
 	if typeof(value) == TYPE_ARRAY:
 		var result: Array = []
 		for item: Variant in value:
@@ -106,16 +119,17 @@ func _parse_value(value: Variant) -> Variant:
 func _set_resource_properties(resource: Resource, properties: Variant) -> void:
 	var props: Dictionary = _parse_properties_dict(properties)
 	for key: Variant in props:
-		var val: Variant = _parse_value(props[key])
-		resource.set(key, val)
+		var named: String = str(key)
+		resource.set(named, _parse_value(props[key]))
 
 
 func _parse_properties_dict(raw: Variant) -> Dictionary:
 	if typeof(raw) == TYPE_DICTIONARY:
 		return raw
 	if typeof(raw) == TYPE_STRING and raw != "":
+		var text: String = raw
 		var json: JSON = JSON.new()
-		if json.parse(raw) == OK and typeof(json.data) == TYPE_DICTIONARY:
+		if json.parse(text) == OK and typeof(json.data) == TYPE_DICTIONARY:
 			return json.data
 	return {}
 
@@ -212,8 +226,10 @@ func create_shader(args: Dictionary) -> Dictionary:
 	var file: FileAccess = FileAccess.open(shader_path, FileAccess.WRITE)
 	if file == null:
 		return {"ok": false, "error": "Failed to open shader file for writing", "shaderPath": shader_path}
-	file.store_string(code)
+	var written: bool = file.store_string(code)
 	file.close()
+	if not written:
+		return {"ok": false, "error": "Failed to write the shader file", "shaderPath": shader_path}
 
 	_refresh_filesystem()
 	return {"ok": true, "shaderPath": shader_path, "shaderType": shader_type}
@@ -241,17 +257,21 @@ func create_tileset(args: Dictionary) -> Dictionary:
 		atlas.texture = tex
 
 		var tile_size: Dictionary = source.get("tileSize", {})
-		atlas.texture_region_size = Vector2i(int(tile_size.get("x", 0)), int(tile_size.get("y", 0)))
+		atlas.texture_region_size = Vector2i(
+			Read.as_int(tile_size.get("x", 0)), Read.as_int(tile_size.get("y", 0))
+		)
 
 		if source.has("separation"):
 			var sep: Dictionary = source.get("separation", {})
-			atlas.separation = Vector2i(int(sep.get("x", 0)), int(sep.get("y", 0)))
+			atlas.separation = Vector2i(Read.as_int(sep.get("x", 0)), Read.as_int(sep.get("y", 0)))
 
 		if source.has("offset"):
 			var off: Dictionary = source.get("offset", {})
-			atlas.margins = Vector2i(int(off.get("x", 0)), int(off.get("y", 0)))
+			atlas.margins = Vector2i(Read.as_int(off.get("x", 0)), Read.as_int(off.get("y", 0)))
 
-		tileset.add_source(atlas)
+		var added: int = tileset.add_source(atlas)
+		if added < 0:
+			return {"ok": false, "error": "Failed to add a tile source", "texture": tex_path}
 
 	var save_result: Error = ResourceSaver.save(tileset, tileset_path)
 	if save_result != OK:
@@ -262,8 +282,8 @@ func create_tileset(args: Dictionary) -> Dictionary:
 
 
 ## The source ids a tile set holds, for saying what a cell could have named instead.
-func _source_ids(tile_set: TileSet) -> PackedInt32Array:
-	var ids: PackedInt32Array = PackedInt32Array()
+func _source_ids(tile_set: TileSet) -> Array[int]:
+	var ids: Array[int] = []
 	for index: int in tile_set.get_source_count():
 		ids.append(tile_set.get_source_id(index))
 	return ids
@@ -293,7 +313,7 @@ func set_tilemap_cells(args: Dictionary) -> Dictionary:
 		root.queue_free()
 		return {"ok": false, "error": "TileMap node not found", "tilemapNodePath": node_path}
 
-	var layer: int = int(args.get("layer", 0))
+	var layer: int = Read.as_int(args.get("layer", 0))
 	var cells: Variant = args.get("cells", [])
 	# Refused rather than skipped: placing nothing and answering success is indistinguishable
 	# from placing everything, and the caller only finds out by opening the scene.
@@ -322,7 +342,7 @@ func set_tilemap_cells(args: Dictionary) -> Dictionary:
 				"ok": false, "error": "every cell must be an object with coords, sourceId and atlasCoords"
 			}
 		var cell: Dictionary = entry
-		var source_id: int = int(cell.get("sourceId", -1))
+		var source_id: int = Read.as_int(cell.get("sourceId", -1), -1)
 		if not tile_set.has_source(source_id):
 			root.queue_free()
 			return {
@@ -332,13 +352,13 @@ func set_tilemap_cells(args: Dictionary) -> Dictionary:
 
 		var coords: Dictionary = cell.get("coords", {})
 		var atlas_coords: Dictionary = cell.get("atlasCoords", {})
-		var at: Vector2i = Vector2i(int(coords.get("x", 0)), int(coords.get("y", 0)))
+		var at: Vector2i = Vector2i(Read.as_int(coords.get("x", 0)), Read.as_int(coords.get("y", 0)))
 		tilemap.set_cell(
 			layer,
 			at,
 			source_id,
-			Vector2i(int(atlas_coords.get("x", 0)), int(atlas_coords.get("y", 0))),
-			int(cell.get("alternativeTile", 0))
+			Vector2i(Read.as_int(atlas_coords.get("x", 0)), Read.as_int(atlas_coords.get("y", 0))),
+			Read.as_int(cell.get("alternativeTile", 0))
 		)
 		if tilemap.get_cell_source_id(layer, at) != -1:
 			written += 1
@@ -368,7 +388,10 @@ func set_theme_color(args: Dictionary) -> Dictionary:
 
 	var c: Dictionary = args.get("color", {})
 	var color: Color = Color(
-		float(c.get("r", 1.0)), float(c.get("g", 1.0)), float(c.get("b", 1.0)), float(c.get("a", 1.0))
+		Read.as_float(c.get("r", 1.0), 1.0),
+		Read.as_float(c.get("g", 1.0), 1.0),
+		Read.as_float(c.get("b", 1.0), 1.0),
+		Read.as_float(c.get("a", 1.0), 1.0)
 	)
 	theme.set_color(color_name, control_type, color)
 
@@ -406,7 +429,7 @@ func set_theme_font_size(args: Dictionary) -> Dictionary:
 	if theme == null:
 		return {"ok": false, "error": "No Theme at %s. Create one there first." % theme_path}
 
-	theme.set_font_size(font_size_name, control_type, int(args.get("size", 0)))
+	theme.set_font_size(font_size_name, control_type, Read.as_int(args.get("size", 0)))
 
 	var save_result: Error = ResourceSaver.save(theme, theme_path)
 	if save_result != OK:

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