gdharness 0.12.17 → 0.13.0

package/build/godot/operations/dependencies.gd

@@ -1,5 +1,7 @@
 extends RefCounted
 
+const Patterns = preload("patterns.gd")
+const Read = preload("reading.gd")
 const FileWalk = preload("file_walk.gd")
 const Log = preload("logger.gd")
 
@@ -39,9 +41,9 @@ func _init(p_log: Log) -> void:
 func get_dependencies(params: Dictionary) -> Dictionary:
 	var resource_path: String = str(params.get("resource_path", ""))
 	# No depth, or a depth of zero or less, means the whole chain; the walk stops at cycles.
-	var depth: int = int(params.get("depth", 0))
+	var depth: int = Read.as_int(params.get("depth", 0))
 	var max_depth: int = depth if depth > 0 else 1000
-	var include_built_in: bool = bool(params.get("include_builtin", false))
+	var include_built_in: bool = Read.as_bool(params.get("include_builtin", false))
 
 	_log.info(
 		(
@@ -83,7 +85,10 @@ func get_dependencies(params: Dictionary) -> Dictionary:
 
 	var dep_count: int = 0
 	for key: String in dependencies:
-		dep_count += _count_recursive(dependencies[key])
+		# Through a typed local: what comes out of a Dictionary is Variant, and a project that
+		# errors on handing one to a typed parameter will not compile this script at all.
+		var walked: Array[Dictionary] = dependencies[key]
+		dep_count += _count_recursive(walked)
 
 	return {
 		"dependencies": dependencies,
@@ -111,12 +116,10 @@ func find_resource_usages(params: Dictionary) -> Dictionary:
 	_log.info("Finding usages of: " + resource_path)
 
 	var class_name_declared: String = _declared_class_name(resource_path)
-	var by_path: RegEx = RegEx.new()
-	by_path.compile('"(res://)?' + _regex_escaped(resource_path.substr(6)) + '"')
+	var by_path: RegEx = Patterns.compiled('"(res://)?' + _regex_escaped(resource_path.substr(6)) + '"')
 	var by_class: RegEx = null
 	if not class_name_declared.is_empty():
-		by_class = RegEx.new()
-		by_class.compile("\\b" + _regex_escaped(class_name_declared) + "\\b")
+		by_class = Patterns.compiled("\\b" + _regex_escaped(class_name_declared) + "\\b")
 
 	var all_files: Array[String] = []
 	for ext: Variant in file_types:
@@ -146,7 +149,7 @@ func find_resource_usages(params: Dictionary) -> Dictionary:
 			if kind.is_empty():
 				continue
 			references.append({"line": i + 1, "kind": kind, "text": line.strip_edges()})
-			by_kind[kind] = int(by_kind.get(kind, 0)) + 1
+			by_kind[kind] = Read.as_int(by_kind.get(kind, 0)) + 1
 
 		if not references.is_empty():
 			usages.append({"file": file_path, "references": references})
@@ -176,8 +179,7 @@ func _declared_class_name(path: String) -> String:
 	var file: FileAccess = FileAccess.open(path, FileAccess.READ)
 	if not file:
 		return ""
-	var declaration: RegEx = RegEx.new()
-	declaration.compile("^class_name\\s+([A-Za-z_][A-Za-z0-9_]*)")
+	var declaration: RegEx = Patterns.compiled("^class_name\\s+([A-Za-z_][A-Za-z0-9_]*)")
 	while not file.eof_reached():
 		var found: RegExMatch = declaration.search(file.get_line())
 		if found != null:
@@ -214,7 +216,8 @@ func _count_recursive(deps: Array[Dictionary]) -> int:
 	var count: int = deps.size()
 	for dep: Dictionary in deps:
 		if dep.has("dependencies"):
-			count += _count_recursive(dep["dependencies"])
+			var deeper: Array[Dictionary] = dep["dependencies"]
+			count += _count_recursive(deeper)
 	return count
 
 
@@ -243,8 +246,7 @@ func _analyze_resource(path: String, current_depth: int, walk: DependencyWalk) -
 		file.close()
 
 		for pattern: String in REFERENCE_PATTERNS:
-			var regex: RegEx = RegEx.new()
-			regex.compile(pattern)
+			var regex: RegEx = Patterns.compiled(pattern)
 			for m: RegExMatch in regex.search_all(content):
 				var dep_path: String = _referenced_path(m.get_string())
 
@@ -282,12 +284,13 @@ func _analyze_resource(path: String, current_depth: int, walk: DependencyWalk) -
 
 # The path inside a preload(), load() or ext_resource match; a bare res:// match is the path.
 func _referenced_path(matched: String) -> String:
-	var inner: RegEx = RegEx.new()
+	var expression: String = ""
 	if "preload" in matched or "load" in matched:
-		inner.compile('"([^"]+)"')
+		expression = '"([^"]+)"'
 	elif "ext_resource" in matched:
-		inner.compile('path="([^"]+)"')
+		expression = 'path="([^"]+)"'
 	else:
 		return matched
+	var inner: RegEx = Patterns.compiled(expression)
 	var inner_match: RegExMatch = inner.search(matched)
 	return inner_match.get_string(1) if inner_match else matched

package/build/godot/operations/file_walk.gd

@@ -24,7 +24,8 @@ func find_files(path: String, extension: String) -> Array[String]:
 	var dir: DirAccess = DirAccess.open(path)
 
 	if dir:
-		dir.list_dir_begin()
+		if dir.list_dir_begin() != OK:
+			return files
 		var file_name: String = dir.get_next()
 
 		while file_name != "":
@@ -47,7 +48,8 @@ func find_files_with_extensions(path: String, extensions: Array) -> Array[String
 	var dir: DirAccess = DirAccess.open(path)
 
 	if dir:
-		dir.list_dir_begin()
+		if dir.list_dir_begin() != OK:
+			return files
 		var file_name: String = dir.get_next()
 
 		while file_name != "":

package/build/godot/operations/gdscript_analysis.gd

@@ -1,5 +1,6 @@
 extends RefCounted
 
+const Patterns = preload("patterns.gd")
 const Log = preload("logger.gd")
 
 var _log: Log
@@ -278,9 +279,7 @@ func _parse_param(param_text: String) -> Dictionary:
 
 func _extract_dependencies(line: String) -> Array[String]:
 	var deps: Array[String] = []
-	var regex: RegEx = RegEx.new()
-
-	regex.compile("(?:preload|load)\\s*\\(\\s*[\"']([^\"']+)[\"']\\s*\\)")
+	var regex: RegEx = Patterns.compiled("(?:preload|load)\\s*\\(\\s*[\"']([^\"']+)[\"']\\s*\\)")
 
 	for m: RegExMatch in regex.search_all(line):
 		deps.append(m.get_string(1))

package/build/godot/operations/gdscript_authoring.gd

@@ -1,5 +1,6 @@
 extends RefCounted
 
+const Read = preload("reading.gd")
 const Log = preload("logger.gd")
 
 var _log: Log
@@ -58,8 +59,10 @@ func create_gdscript(params: Dictionary) -> Dictionary:
 	if not file:
 		return _log.failure("Failed to create script file: " + full_script_path)
 
-	file.store_string(script_content)
+	var stored: bool = file.store_string(script_content)
 	file.close()
+	if not stored:
+		return _log.failure("Failed to write to script file: " + full_script_path)
 
 	# Whether the engine accepts what was written, parsed under this project's own warning
 	# settings: a script that does not load is a script the caller wants to hear about now,
@@ -132,8 +135,10 @@ func modify_gdscript(params: Dictionary) -> Dictionary:
 	if not file:
 		return _log.failure("Failed to write to script file: " + full_script_path)
 
-	file.store_string("\n".join(lines))
+	var rewrote: bool = file.store_string("\n".join(lines))
 	file.close()
+	if not rewrote:
+		return _log.failure("Failed to write to script file: " + full_script_path)
 
 	return {
 		"success": true,
@@ -143,14 +148,15 @@ func modify_gdscript(params: Dictionary) -> Dictionary:
 	}
 
 
-# Inserts the declaration and answers with its one-based line number.
+# Inserts the declaration and answers with its one-based line number, or 0 for one that could not
+# be placed, which is a number no line has.
 func _add_variable(lines: Array[String], mod: Dictionary) -> int:
 	var var_name: String = str(mod.get("name", ""))
 	var var_type: String = str(mod.get("varType", ""))
 	var default_value: String = str(mod.get("defaultValue", ""))
-	var is_export: bool = bool(mod.get("isExport", false))
+	var is_export: bool = Read.as_bool(mod.get("isExport", false))
 	var export_hint: String = str(mod.get("exportHint", ""))
-	var is_onready: bool = bool(mod.get("isOnready", false))
+	var is_onready: bool = Read.as_bool(mod.get("isOnready", false))
 
 	var var_line: String = ""
 
@@ -179,7 +185,9 @@ func _add_variable(lines: Array[String], mod: Dictionary) -> int:
 		var_line += ": Variant"
 
 	var insert_line: int = _variable_insertion_point(lines)
-	lines.insert(insert_line, var_line)
+	if lines.insert(insert_line, var_line) != OK:
+		push_error("gdharness: could not place a declaration at line " + str(insert_line))
+		return 0
 	return insert_line + 1
 
 
@@ -208,7 +216,9 @@ func _add_signal(lines: Array[String], mod: Dictionary) -> int:
 		signal_line += "(" + signal_params + ")"
 
 	var insert_line: int = _signal_insertion_point(lines)
-	lines.insert(insert_line, signal_line)
+	if lines.insert(insert_line, signal_line) != OK:
+		push_error("gdharness: could not place a signal at line " + str(insert_line))
+		return 0
 	return insert_line + 1
 
 
@@ -234,7 +244,9 @@ func _add_function(lines: Array[String], mod: Dictionary) -> int:
 	var insert_line: int = _function_insertion_point(lines, position)
 
 	for i: int in range(func_lines.size() - 1, -1, -1):
-		lines.insert(insert_line, func_lines[i])
+		if lines.insert(insert_line, func_lines[i]) != OK:
+			push_error("gdharness: could not place a function at line " + str(insert_line))
+			return 0
 
 	return insert_line + 1
 

package/build/godot/operations/godot_operations.gd

@@ -48,10 +48,15 @@ func _init() -> void:
 	_log.debug("All arguments: " + str(args))
 
 	var operation: String = args[script_index + 2]
-	var params: Variant = _read_params(args[params_index])
-	if not params is Dictionary:
+	var read: Variant = _read_params(args[params_index])
+	if not read is Dictionary:
 		quit(1)
 		return
+	# Through a typed local rather than straight into the call. The check above proves the type to
+	# a reader and not to the analyser, so the call handed a Variant to a Dictionary parameter, and
+	# a project holding unsafe_call_argument at error level then refused to compile this script at
+	# all. It is compiled under the target project's warning levels, not under this package's.
+	var params: Dictionary = read
 
 	_log.info("Executing operation: " + operation)
 

package/build/godot/operations/import_pipeline.gd

@@ -1,5 +1,6 @@
 extends RefCounted
 
+const Read = preload("reading.gd")
 const FileWalk = preload("file_walk.gd")
 const Log = preload("logger.gd")
 
@@ -18,7 +19,7 @@ func _init(p_log: Log) -> void:
 # Get import status for resources
 func get_import_status(params: Dictionary) -> Dictionary:
 	var resource_path: String = str(params.get("resource_path", ""))
-	var include_up_to_date: bool = bool(params.get("include_up_to_date", false))
+	var include_up_to_date: bool = Read.as_bool(params.get("include_up_to_date", false))
 
 	_log.info(
 		(
@@ -90,7 +91,7 @@ func set_import_options(params: Dictionary) -> Dictionary:
 		resource_path = "res://" + resource_path
 
 	var options: Dictionary = params.get("options", {})
-	var do_reimport: bool = bool(params.get("reimport", true))
+	var do_reimport: bool = Read.as_bool(params.get("reimport", true), true)
 
 	_log.info("Setting import options for: " + resource_path)
 
@@ -131,7 +132,7 @@ func set_import_options(params: Dictionary) -> Dictionary:
 # Reimport a resource or all resources
 func reimport_resource(params: Dictionary) -> Dictionary:
 	var resource_path: String = str(params.get("resource_path", ""))
-	var force: bool = bool(params.get("force", false))
+	var force: bool = Read.as_bool(params.get("force", false))
 
 	_log.info(
 		(
@@ -208,7 +209,7 @@ func list_export_presets(_params: Dictionary) -> Dictionary:
 # Validate project for export
 func validate_project(params: Dictionary) -> Dictionary:
 	var preset_name: String = str(params.get("preset", ""))
-	var include_suggestions: bool = bool(params.get("include_suggestions", true))
+	var include_suggestions: bool = Read.as_bool(params.get("include_suggestions", true), true)
 
 	_log.info("Validating project" + (" for preset: " + preset_name if not preset_name.is_empty() else ""))
 

package/build/godot/operations/input_actions.gd

@@ -1,5 +1,6 @@
 extends RefCounted
 
+const Read = preload("reading.gd")
 const Log = preload("logger.gd")
 
 # The key names a caller may write, and what the engine calls them.
@@ -106,7 +107,7 @@ func _init(p_log: Log) -> void:
 func add_input_action(params: Dictionary) -> Dictionary:
 	var action_name: String = str(params.get("action_name", ""))
 	var events: Array = params.get("events", [])
-	var deadzone: float = float(params.get("deadzone", 0.5))
+	var deadzone: float = Read.as_float(params.get("deadzone", 0.5), 0.5)
 
 	_log.info("Adding input action: " + action_name)
 	_log.debug("Events: " + JSON.stringify(events))
@@ -200,26 +201,29 @@ func build_input_action(deadzone: float, events: Array) -> Dictionary:
 		match evt_class:
 			"InputEventKey":
 				var key: InputEventKey = InputEventKey.new()
-				key.keycode = int(event.get("keycode", 0)) as Key
-				key.ctrl_pressed = bool(event.get("ctrl_pressed", false))
-				key.alt_pressed = bool(event.get("alt_pressed", false))
-				key.shift_pressed = bool(event.get("shift_pressed", false))
+				key.keycode = Read.as_int(event.get("keycode", 0)) as Key
+				key.ctrl_pressed = Read.as_bool(event.get("ctrl_pressed", false))
+				key.alt_pressed = Read.as_bool(event.get("alt_pressed", false))
+				key.shift_pressed = Read.as_bool(event.get("shift_pressed", false))
 				built.append(key)
 
 			"InputEventMouseButton":
 				var mouse: InputEventMouseButton = InputEventMouseButton.new()
-				mouse.button_index = (int(event.get("button_index", MOUSE_BUTTON_LEFT)) as MouseButton)
+				mouse.button_index = (
+					Read.as_int(event.get("button_index", MOUSE_BUTTON_LEFT), MOUSE_BUTTON_LEFT)
+					as MouseButton
+				)
 				built.append(mouse)
 
 			"InputEventJoypadButton":
 				var pad: InputEventJoypadButton = InputEventJoypadButton.new()
-				pad.button_index = int(event.get("button_index", 0)) as JoyButton
+				pad.button_index = Read.as_int(event.get("button_index", 0)) as JoyButton
 				built.append(pad)
 
 			"InputEventJoypadMotion":
 				var motion: InputEventJoypadMotion = InputEventJoypadMotion.new()
-				motion.axis = int(event.get("axis", 0)) as JoyAxis
-				motion.axis_value = float(event.get("axis_value", 1.0))
+				motion.axis = Read.as_int(event.get("axis", 0)) as JoyAxis
+				motion.axis_value = Read.as_float(event.get("axis_value", 1.0), 1.0)
 				built.append(motion)
 
 			_:

package/build/godot/operations/patterns.gd

@@ -0,0 +1,22 @@
+extends RefCounted
+
+# A compiled regular expression, with a pattern that will not compile said rather than dropped.
+#
+# `RegEx.compile()` answers with an Error, and every caller here passes a literal its author had
+# already checked by eye, so the answer was thrown away eleven times. A project holding
+# `return_value_discarded` at error level will not compile a script that does that, and these
+# scripts are compiled under the target project's warning levels rather than under this package's:
+# one project turning that warning on loses every headless operation at once.
+#
+# A pattern that fails here is a mistake in this repository rather than anything a caller did, so
+# it goes to the engine's error stream, where the operation's answer carries it back under
+# `engine_messages`. The empty RegEx it then returns matches nothing, which is the honest result of
+# a pattern that does not exist.
+
+
+static func compiled(expression: String) -> RegEx:
+	var regex: RegEx = RegEx.new()
+	var built: Error = regex.compile(expression)
+	if built != OK:
+		push_error("gdharness: could not compile the pattern " + expression)
+	return regex

package/build/godot/operations/plugins.gd

@@ -1,5 +1,6 @@
 extends RefCounted
 
+const Patterns = preload("patterns.gd")
 const Log = preload("logger.gd")
 
 var _log: Log
@@ -30,8 +31,7 @@ func list_plugins(_params: Dictionary) -> Dictionary:
 	var enabled_count: int = 0
 
 	var dir: DirAccess = DirAccess.open(addons_path)
-	if dir:
-		dir.list_dir_begin()
+	if dir and dir.list_dir_begin() == OK:
 		var folder_name: String = dir.get_next()
 
 		while folder_name != "":
@@ -122,8 +122,7 @@ func disable_plugin(params: Dictionary) -> Dictionary:
 # type; the String form is what an older hand-edited file can carry.
 func _enabled_plugin_names() -> Array[String]:
 	var names: Array[String] = []
-	var regex: RegEx = RegEx.new()
-	regex.compile("res://addons/([^/]+)/plugin.cfg")
+	var regex: RegEx = Patterns.compiled("res://addons/([^/]+)/plugin.cfg")
 
 	var enabled_value: Variant = ProjectSettings.get_setting("editor_plugins/enabled", PackedStringArray())
 	if enabled_value is PackedStringArray:
@@ -151,9 +150,14 @@ func _save_enabled_plugins(names: Array[String]) -> Error:
 		ProjectSettings.set_setting("editor_plugins/enabled", null)
 		return ProjectSettings.save()
 
-	var enabled_paths: PackedStringArray = PackedStringArray()
+	# Gathered in an Array[String] and converted at the end, because appending to a packed array
+	# answers with whether it worked and a project holding return_value_discarded at error level
+	# will not compile a script that drops that answer. The conversion is what matters: an
+	# Array[String] handed to set_setting is written as Array[String]([...]), which the editor does
+	# not read as a plugin list at all.
+	var enabled_paths: Array[String] = []
 	for name: String in names:
 		enabled_paths.append("res://addons/" + name + "/plugin.cfg")
 
-	ProjectSettings.set_setting("editor_plugins/enabled", enabled_paths)
+	ProjectSettings.set_setting("editor_plugins/enabled", PackedStringArray(enabled_paths))
 	return ProjectSettings.save()

package/build/godot/operations/project_config.gd

@@ -1,5 +1,6 @@
 extends RefCounted
 
+const Read = preload("reading.gd")
 const Log = preload("logger.gd")
 const Serialisation = preload("serialisation.gd")
 
@@ -11,9 +12,15 @@ func _init(p_log: Log) -> void:
 	_log = p_log
 
 
-# Get a project setting value
+# Get a project setting value, or every setting under a prefix.
 func get_project_setting(params: Dictionary) -> Dictionary:
+	var prefix: String = str(params.get("prefix", ""))
+	if not prefix.is_empty():
+		return _settings_under(prefix)
+
 	var setting_path: String = str(params.get("setting", ""))
+	if setting_path.is_empty():
+		return _log.failure("setting is required, or prefix to read every setting under one")
 
 	_log.info("Getting project setting: " + setting_path)
 
@@ -30,6 +37,37 @@ func get_project_setting(params: Dictionary) -> Dictionary:
 	return result
 
 
+# Every setting whose name starts with [prefix], with the type the engine registers for each.
+#
+# A caller after a whole family, "everything under debug/gdscript/warnings", had no way to ask: a get
+# takes one name, and the engine is the only thing that knows what the family contains. The way round
+# it was to walk ProjectSettings.get_property_list() from a script written for the purpose, which is
+# an engine start to answer a question the engine was already open for.
+#
+# The type is here because it is the half a name hides. A setting sitting among a family of levels
+# can be a bool, and a caller that assumes otherwise writes a level over it and sees nothing go
+# wrong: 2 is as true as true is. Reading it out of the property list is how that is caught.
+func _settings_under(prefix: String) -> Dictionary:
+	_log.info("Listing project settings under: " + prefix)
+
+	var found: Array[Dictionary] = []
+	for property: Dictionary in ProjectSettings.get_property_list():
+		var name: String = str(property.get("name", ""))
+		if not name.begins_with(prefix):
+			continue
+		var kind: int = Read.as_int(property.get("type", TYPE_NIL), TYPE_NIL)
+		var value: Variant = ProjectSettings.get_setting(name)
+		var described: Dictionary = {
+			"setting": name,
+			"type": type_string(kind),
+			"value": _values.serialize_value(value),
+		}
+		found.append(described)
+
+	found.sort_custom(func(a: Dictionary, b: Dictionary) -> bool: return a["setting"] < b["setting"])
+	return {"prefix": prefix, "count": found.size(), "settings": found}
+
+
 # Set a project setting value
 func set_project_setting(params: Dictionary) -> Dictionary:
 	var setting_path: String = str(params.get("setting", ""))
@@ -85,7 +123,7 @@ func set_project_setting(params: Dictionary) -> Dictionary:
 func _wanted_type(setting_path: String, current: Variant) -> int:
 	for info: Dictionary in ProjectSettings.get_property_list():
 		if str(info.get("name", "")) == setting_path:
-			return int(info.get("type", TYPE_NIL))
+			return Read.as_int(info.get("type", TYPE_NIL), TYPE_NIL)
 	return typeof(current)
 
 
@@ -101,7 +139,7 @@ func _converts_faithfully(value: Variant, to: int) -> bool:
 func add_autoload(params: Dictionary) -> Dictionary:
 	var name: String = str(params.get("name", ""))
 	var path: String = str(params.get("path", ""))
-	var enabled: bool = bool(params.get("enabled", true))
+	var enabled: bool = Read.as_bool(params.get("enabled", true), true)
 
 	if not path.begins_with("res://"):
 		path = "res://" + path

package/build/godot/operations/reading.gd

@@ -0,0 +1,66 @@
+extends RefCounted
+
+# A value out of a dictionary that came from JSON, as the type the operation 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. These
+# scripts are compiled under the target project's warning levels rather than under this package's,
+# because `--path` makes that project the loaded one and the file's living in the npm cache
+# changes nothing: one project turning that warning on lost every headless operation at once.
+#
+# The conversion itself is the same. What changes is that the type is established first, on a
+# typed local, and the conversion happens from that. Here rather than at each of the thirty-one
+# places that read a parameter, because thirty-one is how many chances there are to write the old
+# form again, and the error does not appear until somebody sets the warning.
+#
+# `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/operations/serialisation.gd

@@ -1,5 +1,7 @@
 extends RefCounted
 
+const Read = preload("reading.gd")
+
 # What each Godot type becomes on the wire, as one table you can read rather than an order you
 # have to trust. Keyed on typeof() rather than written as a chain of `is` tests, because the
 # order mattered: Resource had to be tested before Object or every resource came back as a bare
@@ -60,26 +62,56 @@ func deserialize_value(value: Variant) -> Variant:
 			rebuilt[key] = deserialize_value(fields[key])
 		return rebuilt
 
+	# Each component read as the type the constructor wants before it is handed over. These come
+	# out of JSON as Variant, and a project holding `unsafe_call_argument` at error level refuses
+	# to compile a script that gives a Variant to a typed parameter: the operations are compiled
+	# under the target project's warning levels, so one such project lost every headless call.
 	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)
+			)
 		"Rect2":
-			var position: Variant = deserialize_value(fields.get("position", {}))
-			var size: Variant = deserialize_value(fields.get("size", {}))
-			return Rect2(position, size)
+			return _rect_from(fields)
 		"NodePath":
-			return NodePath(fields.get("path", ""))
+			return NodePath(str(fields.get("path", "")))
 	return fields
 
 
+## A Rect2 out of its two tagged corners, or the fields back when they do not describe one.
+##
+## Its own function because the components have to be read as Vector2 before the constructor is
+## given them, and a branch that can also answer with the fields would push the match above past
+## the return count this project holds itself to.
+func _rect_from(fields: Dictionary) -> Variant:
+	var position: Variant = deserialize_value(fields.get("position", {}))
+	var size: Variant = deserialize_value(fields.get("size", {}))
+	if not (position is Vector2 and size is Vector2):
+		return fields
+	var at: Vector2 = position
+	var extent: Vector2 = size
+	return Rect2(at, extent)
+
+
 func _serialize_nil(_value: Variant) -> Variant:
 	return null