gdharness 0.13.4 → 0.13.6

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

@@ -4,10 +4,12 @@ extends Node
 ## Scenes and their nodes, edited in the open editor and read back from what it holds.
 
 const Read = preload("../reading.gd")
+const PropertyValues = preload("../property_values.gd")
 const Serialisation = preload("../serialisation.gd")
 
 var _editor_plugin: EditorPlugin = null
 var _values: Serialisation = Serialisation.new()
+var _properties: PropertyValues = PropertyValues.new()
 
 ## How many scans the editor has finished, counted off its own signal, and what the count was when
 ## a scan was last asked for. A queued scan has not started, so the flags the engine offers read
@@ -103,176 +105,9 @@ func _find_node(root: Node, path: String) -> Node:
 	return root.get_node_or_null(path)
 
 
-## Turns what arrived over the wire into the Godot value a property wants.
-##
-## Three separate questions, asked in order, because a caller may say what it means in three
-## ways: a dictionary that names its own type, a dictionary shaped like the type the property
-## 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 value is Dictionary:
-		var fields: Dictionary = value
-		var tagged: Array = _parse_tagged_dictionary(fields)
-		if tagged[0]:
-			return tagged[1]
-		return _parse_shaped_dictionary(fields, expected_type)
-	if value is Array:
-		var items: Array = value
-		return _parse_array(items, expected_type)
-	return value
-
-
-## A dictionary carrying its own type name, as the serialiser writes it.
-##
-## Answers [handled, value] rather than just the value, because a handled tag may legitimately
-## produce null: a Resource with no path is "this is nothing", not "this is not mine". A tag
-## that names a type but lacks the keys to build it is left unhandled on purpose, so the caller
-## can still read it against the type the property declares.
-func _parse_tagged_dictionary(value: Dictionary) -> Array:
-	var type_tag: String = str(value.get("_type", value.get("type", "")))
-	if type_tag == "Resource":
-		var resource_path: String = str(value.get("path", ""))
-		return [true, null if resource_path.is_empty() else load(resource_path)]
-
-	# The shared builder is the same one the answer was written by, so every shape it writes comes
-	# back as itself. `type` as the tag is read as `_type`: it is what this tool answered with
-	# before the serialisers were made one, and a caller who kept an answer can still send it.
-	var tagged: Dictionary = value
-	if not value.has("_type") and not type_tag.is_empty():
-		tagged = value.duplicate()
-		tagged["_type"] = type_tag
-	var rebuilt: Variant = _values.deserialize_value(tagged)
-	if not rebuilt is Dictionary:
-		return [true, rebuilt]
-
-	return _parse_new_resource(type_tag, value)
-
-
-## A tag naming a Resource class builds a fresh one, its other keys set as properties, so a
-## NavigationRegion2D can arrive with its NavigationPolygon and an AnimationTree with its root
-## state machine in the same add as any other property.
-func _parse_new_resource(type_tag: String, value: Dictionary) -> Array:
-	if (
-		type_tag.is_empty()
-		or not ClassDB.class_exists(type_tag)
-		or not ClassDB.is_parent_class(type_tag, "Resource")
-		or not ClassDB.can_instantiate(type_tag)
-	):
-		return [false, null]
-
-	var built: Resource = ClassDB.instantiate(type_tag)
-	for key: Variant in value:
-		var property: String = str(key)
-		if property == "_type" or property == "type":
-			continue
-		built.set(property, _parse_value(value[key], typeof(built.get(property))))
-	return [true, built]
-
-
-## A dictionary with no tag, read against the type the property declares. Falls back to the
-## dictionary itself, since a property may genuinely want one.
-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(Read.as_float(value["x"]), Read.as_float(value["y"]))
-		TYPE_VECTOR2I:
-			if value.has("x") and value.has("y"):
-				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(
-					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(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(
-					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(
-					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(str(value["path"]))
-	return value
-
-
-## An array, either positional for a vector the property declares, or a list to parse per item.
-func _parse_array(value: Array, expected_type: int) -> Variant:
-	match expected_type:
-		TYPE_VECTOR2:
-			if value.size() >= 2:
-				return Vector2(Read.as_float(value[0]), Read.as_float(value[1]))
-		TYPE_VECTOR2I:
-			if value.size() >= 2:
-				return Vector2i(Read.as_int(value[0]), Read.as_int(value[1]))
-		TYPE_VECTOR3:
-			if value.size() >= 3:
-				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(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 Read.as_int(prop.get("type", TYPE_NIL), TYPE_NIL)
-	return TYPE_NIL
-
-
 ## Set each property, answering with what went wrong or "" when nothing did.
-##
-## A property the node does not have, and a resource path nothing is at, are both refused: Object
-## .set ignores an unknown name and stores null for a resource that would not load, so either one
-## saves a scene that quietly did not change and reports it as a change that did.
 func _set_node_properties(node: Node, properties: Dictionary) -> String:
-	for prop_name: Variant in properties:
-		var property: String = str(prop_name)
-		if not _has_property(node, property):
-			return "%s has no property %s" % [node.get_class(), property]
-
-		var expected_type: int = _get_property_type(node, property)
-		var raw: Variant = properties[prop_name]
-
-		# 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 = 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.
-			if not (path.begins_with("res://") or path.begins_with("uid://")):
-				return "%s takes a res:// or uid:// path, not %s" % [property, path]
-			if path.split("/").has(".."):
-				return "%s leaves the project: %s" % [property, path]
-			if not ResourceLoader.exists(path):
-				return "No resource at %s for %s" % [path, property]
-			node.set(property, load(path))
-			continue
-
-		node.set(property, _parse_value(raw, expected_type))
-	return ""
-
-
-func _has_property(node: Node, prop_name: String) -> bool:
-	for prop: Dictionary in node.get_property_list():
-		if str(prop.get("name", "")) == prop_name:
-			return true
-	return false
+	return _properties.write_all(node, properties)
 
 
 func _parse_properties_arg(raw_properties: Variant) -> Dictionary:

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

@@ -567,6 +567,16 @@ static func _can_hold(value: Variant) -> bool:
 ## is a list and an in-tray is a map, and a path that could not step into either stopped at the
 ## first one. An index reads the way a property does, and a negative one counts from the end the
 ## way GDScript's own does, so reading the last of something does not mean asking how many first.
+## What is wrong with reading [param named] off [param holder], or "" when nothing is.
+##
+## Public because a wait asks the same question before it starts waiting, and used to answer it by
+## waiting: a property nobody has spends the whole timeout and comes back "not met", which reads
+## exactly like a game that never reached the state. The read refuses a mistyped name in one call
+## and says so, and the two tools disagreeing about one typo is worth more than the duplication.
+static func nothing_under(holder: Variant, named: String, called: String) -> String:
+	return "" if _can_read(holder, named) else _nothing_there(holder, named, called)
+
+
 static func _can_read(holder: Variant, named: String) -> bool:
 	if holder is Array:
 		var items: Array = holder
@@ -685,7 +695,21 @@ func set_property(params: Dictionary) -> Dictionary:
 	if not _can_read(holder, named):
 		return {"type": "error", "message": _nothing_there(holder, named, str(reached["called"]))}
 	var old_value: Variant = _read(holder, named)
-	_write(holder, named, _values.fitted(value, typeof(old_value)))
+	# The same rule the call path holds: a value that cannot become what the property holds is
+	# refused rather than written. Writing it means the engine picks something, and what it picks
+	# for a word where a number goes is zero, which the answer then reports as the new value.
+	var wanted: int = typeof(old_value)
+	var given: Variant = _values.fitted(value, wanted)
+	if not Values.acceptable(given, wanted):
+		return {
+			"type": "error",
+			"message":
+			(
+				"%s.%s holds %s and the value given is %s, which cannot become one."
+				% [reached["called"], named, type_string(wanted), type_string(typeof(given))]
+			)
+		}
+	_write(holder, named, given)
 
 	return {
 		"type": "property_set",

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

@@ -11,27 +11,6 @@ extends RefCounted
 const Read = preload("reading.gd")
 const Serialisation = preload("serialisation.gd")
 
-# What the engine carries from one to another without complaint, which is what an argument may
-# arrive as. Numbers include bool because the engine counts it as one, and the three text types
-# are one string wearing three hats.
-const NUMBERS: Array[int] = [TYPE_BOOL, TYPE_INT, TYPE_FLOAT]
-const TEXTS: Array[int] = [TYPE_STRING, TYPE_STRING_NAME, TYPE_NODE_PATH]
-
-# The types that cross as a plain JSON list and have to be built back into themselves. A list is
-# what a caller can write by hand and what the serialiser answers with, and the parameter or
-# property being written is the only thing that knows which of these it wanted.
-const LIST_TYPES: Array[int] = [
-	TYPE_PACKED_INT32_ARRAY,
-	TYPE_PACKED_INT64_ARRAY,
-	TYPE_PACKED_FLOAT32_ARRAY,
-	TYPE_PACKED_FLOAT64_ARRAY,
-	TYPE_PACKED_STRING_ARRAY,
-	TYPE_PACKED_VECTOR2_ARRAY,
-	TYPE_PACKED_VECTOR3_ARRAY,
-	TYPE_PACKED_VECTOR4_ARRAY,
-	TYPE_PACKED_COLOR_ARRAY,
-]
-
 var _shared: Serialisation = Serialisation.new()
 
 
@@ -77,49 +56,13 @@ static func node_at(root: Node, path: String) -> Dictionary:
 
 
 ## Whether two values can be compared without the comparison itself failing.
-##
-## GDScript's `==` is not total. An Object against a String is a hard error rather than false, and
-## an error raised inside the game is not a wrong answer: it stops the game. A caller who asked
-## `runtime_wait until` for the wrong kind of value got their game held at a debugger break, every
-## later call answering "did not respond within 10000ms, it may be stuck in a long frame", and
-## nothing anywhere naming the argument that did it. A wrong argument costs a refusal, never the
-## session's game.
-##
-## Only an object is special. Every other pair the engine answers, false where they differ, and
-## refusing those would refuse calls that work: an int against a float is the same number to a
-## caller waiting for 1 on a property holding 1.0.
 static func comparable(one: Variant, other: Variant) -> bool:
-	var left: int = typeof(one)
-	var right: int = typeof(other)
-	if left != TYPE_OBJECT and right != TYPE_OBJECT:
-		return true
-	# An object compares with another object and with null. Anything else is the error above.
-	return (left == TYPE_OBJECT or left == TYPE_NIL) and (right == TYPE_OBJECT or right == TYPE_NIL)
+	return Serialisation.comparable(one, other)
 
 
 ## Whether a value can be handed to a parameter declared as [param type] without the call failing.
-##
-## The same reason as [method comparable]: `callv` raises inside the game when an argument cannot
-## be converted, and an error raised in a game somebody is playing holds it at a debugger break.
-##
-## A list of what is accepted rather than of what is refused, which is the way round that errs
-## safely. The engine's own conversion table is not readable from GDScript, so either list is a
-## guess at it; guessing narrow costs a caller a refusal naming both types, and guessing wide costs
-## them the session. A refusal is the cheaper mistake, and it is the one they can act on.
 static func acceptable(value: Variant, type: int) -> bool:
-	if type == TYPE_NIL:
-		return true
-	var given: int = typeof(value)
-	if given == type:
-		return true
-	# null is a value for anything that holds an object, and for nothing else.
-	if given == TYPE_NIL:
-		return type == TYPE_OBJECT
-	if NUMBERS.has(given) and NUMBERS.has(type):
-		return true
-	if TEXTS.has(given) and TEXTS.has(type):
-		return true
-	return given == TYPE_ARRAY and LIST_TYPES.has(type)
+	return Serialisation.acceptable(value, type)
 
 
 ## The declared type of one parameter of a method, or TYPE_NIL when the method or the parameter
@@ -136,29 +79,6 @@ func parameter_type(object: Object, method: String, index: int) -> int:
 	return TYPE_NIL
 
 
-## A value from the wire fitted to the type a property or parameter declares. Arguments arrive
-## as strings often enough, and callv refuses a "2.0" where a float is wanted, so a string that
-## reads as the wanted scalar is read as one.
-##
-## The conversion is also what restores a packed array's exact type. Those cross as the plain JSON
-## lists they fit into, so what comes back from the wire is an Array, and the parameter is what says
-## it was a PackedStringArray.
+## A value from the wire fitted to the type a property or parameter declares.
 func fitted(value: Variant, type: int) -> Variant:
-	var rebuilt: Variant = deserialize(value)
-	if type == TYPE_NIL or typeof(rebuilt) == type:
-		return rebuilt
-
-	if rebuilt is Array and LIST_TYPES.has(type):
-		return type_convert(rebuilt, type)
-
-	var simple: Array[int] = [TYPE_BOOL, TYPE_INT, TYPE_FLOAT, TYPE_STRING]
-	if not simple.has(type) or not simple.has(typeof(rebuilt)):
-		return rebuilt
-
-	if rebuilt is String and type != TYPE_STRING:
-		var text: String = rebuilt
-		var parsed: Variant = JSON.parse_string(text)
-		if typeof(parsed) != TYPE_NIL and typeof(parsed) != TYPE_STRING:
-			rebuilt = parsed
-
-	return type_convert(rebuilt, type)
+	return _shared.fitted(value, type)

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

@@ -97,6 +97,23 @@ func wait_until(params: Dictionary) -> Dictionary:
 	var standing: Dictionary = Values.node_at(_host.get_tree().root, node_path)
 	if standing.has("message"):
 		return standing
+	# Two different questions, not two ways of asking one: says looks for words anywhere under the
+	# path, a property compares one value on one node. Taking says and dropping the other left a
+	# caller watching a screen while believing they were watching a property, and the answer says
+	# which of them it is about only if you already know that says wins.
+	if not says.is_empty() and (not property.is_empty() or params.has("value")):
+		var other: String = property if not property.is_empty() else "value"
+		return {
+			"type": "error",
+			"message":
+			(
+				(
+					'A wait takes says or a property, not both: this one has says "%s" and %s as well.'
+					+ " Ask for one of them."
+				)
+				% [says, other]
+			)
+		}
 	if not says.is_empty():
 		return await _wait_until_said(node_path, says, timeout_ms)
 	if property.is_empty():
@@ -106,6 +123,14 @@ func wait_until(params: Dictionary) -> Dictionary:
 
 	var node: Node = standing["node"]
 
+	# A property the node has not got, refused here rather than waited on. Waiting answered "not
+	# met" after the whole timeout, which is what a game that never reached the state answers too,
+	# so a mistyped name and a condition that did not happen read the same. The property read
+	# refuses that typo in one call, and two tools disagreeing about it is the fault.
+	var missing: String = Queries.nothing_under(node, property, node_path)
+	if not missing.is_empty():
+		return {"type": "error", "message": missing}
+
 	var current: Variant = node.get(property)
 	var wanted: Variant = _values.fitted(params["value"], typeof(current))
 	# Refused before anything is evaluated, because the evaluation is what does the damage: an
@@ -124,6 +149,22 @@ func wait_until(params: Dictionary) -> Dictionary:
 				% [node_path, property, type_string(typeof(current)), type_string(typeof(wanted))]
 			)
 		}
+	# And a value that cannot become what the property holds, which lands worse than the halt: a
+	# word where a number goes became 0.0, 0.0 already equalled the property, and the wait answered
+	# met the instant it started, about a state nobody asked about, with the real value beside it.
+	# A refusal is read and a met is acted on.
+	if not Values.acceptable(wanted, typeof(current)):
+		return {
+			"type": "error",
+			"message":
+			(
+				(
+					"%s.%s holds %s and the value to wait for is %s, which cannot become one:"
+					+ " waiting on it would answer about a state nobody asked for."
+				)
+				% [node_path, property, type_string(typeof(current)), type_string(typeof(wanted))]
+			)
+		}
 
 	var started: int = Time.get_ticks_msec()
 	# The type is checked every time round, not only at the top: a property that holds an object a

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

@@ -10,6 +10,27 @@ extends RefCounted
 
 const Read = preload("reading.gd")
 
+# What the engine carries from one to another without complaint, which is what a value written to a
+# property or handed to a parameter may arrive as. Numbers include bool because the engine counts it
+# as one, and the three text types are one string wearing three hats.
+const NUMBERS: Array[int] = [TYPE_BOOL, TYPE_INT, TYPE_FLOAT]
+const TEXTS: Array[int] = [TYPE_STRING, TYPE_STRING_NAME, TYPE_NODE_PATH]
+
+# The types that cross as a plain JSON list and have to be built back into themselves. A list is
+# what a caller can write by hand and what the serialiser answers with, and the parameter or
+# property being written is the only thing that knows which of these it wanted.
+const LIST_TYPES: Array[int] = [
+	TYPE_PACKED_INT32_ARRAY,
+	TYPE_PACKED_INT64_ARRAY,
+	TYPE_PACKED_FLOAT32_ARRAY,
+	TYPE_PACKED_FLOAT64_ARRAY,
+	TYPE_PACKED_STRING_ARRAY,
+	TYPE_PACKED_VECTOR2_ARRAY,
+	TYPE_PACKED_VECTOR3_ARRAY,
+	TYPE_PACKED_VECTOR4_ARRAY,
+	TYPE_PACKED_COLOR_ARRAY,
+]
+
 # 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
@@ -163,6 +184,91 @@ func deserialize_value(value: Variant) -> Variant:
 	return call(builder, fields)
 
 
+## Whether two values can be compared without the comparison itself failing.
+##
+## GDScript's `==` is not total. An Object against a String is a hard error rather than false, and
+## an error raised inside a game is not a wrong answer: it stops the game. A caller who asked
+## `runtime_wait until` for the wrong kind of value got their game held at a debugger break, every
+## later call answering "did not respond within 10000ms, it may be stuck in a long frame", and
+## nothing anywhere naming the argument that did it. A wrong argument costs a refusal, never the
+## session's game.
+##
+## Only an object is special. Every other pair the engine answers, false where they differ, and
+## refusing those would refuse calls that work: an int against a float is the same number to a
+## caller waiting for 1 on a property holding 1.0.
+static func comparable(one: Variant, other: Variant) -> bool:
+	var left: int = typeof(one)
+	var right: int = typeof(other)
+	if left != TYPE_OBJECT and right != TYPE_OBJECT:
+		return true
+	# An object compares with another object and with null. Anything else is the error above.
+	return (left == TYPE_OBJECT or left == TYPE_NIL) and (right == TYPE_OBJECT or right == TYPE_NIL)
+
+
+## Whether [param value] can be given to something declared as [param type] without damage.
+##
+## Here rather than beside either caller because the running game and the editor ask it of the same
+## values and must not answer differently. What it protects against differs by side and both are
+## silent: `callv` and `==` raise inside a running game, which holds it at a debugger break, while
+## `Object.set` in the editor converts instead and writes the result to the scene file. A word where
+## an int goes is stored as 0, where a bool goes as true, where a Vector2 goes as (0, 0), and the
+## tool reports the change as made. The property keeps a value nobody asked for and the scene is
+## saved with it.
+##
+## A list of what is accepted rather than of what is refused, which is the way round that errs
+## safely. The engine's own conversion table is not readable from GDScript, so either list is a
+## guess at it; guessing narrow costs a caller a refusal naming both types, and guessing wide costs
+## them the damage above. A refusal is the cheaper mistake, and it is the one they can act on.
+static func acceptable(value: Variant, type: int) -> bool:
+	if type == TYPE_NIL:
+		return true
+	var given: int = typeof(value)
+	if given == type:
+		return true
+	# null is a value for anything that holds an object, and for nothing else.
+	if given == TYPE_NIL:
+		return type == TYPE_OBJECT
+	if NUMBERS.has(given) and NUMBERS.has(type):
+		return true
+	if TEXTS.has(given) and TEXTS.has(type):
+		return true
+	return given == TYPE_ARRAY and LIST_TYPES.has(type)
+
+
+## A value from the wire fitted to the type a property or parameter declares. Arguments arrive
+## as strings often enough, and callv refuses a "2.0" where a float is wanted, so a string that
+## reads as the wanted scalar is read as one.
+##
+## The conversion is also what restores a packed array's exact type. Those cross as the plain JSON
+## lists they fit into, so what comes back from the wire is an Array, and the parameter is what says
+## it was a PackedStringArray.
+func fitted(value: Variant, type: int) -> Variant:
+	var rebuilt: Variant = deserialize_value(value)
+	if type == TYPE_NIL or typeof(rebuilt) == type:
+		return rebuilt
+
+	if rebuilt is Array and LIST_TYPES.has(type):
+		return type_convert(rebuilt, type)
+
+	var simple: Array[int] = [TYPE_BOOL, TYPE_INT, TYPE_FLOAT, TYPE_STRING]
+	if not simple.has(type) or not simple.has(typeof(rebuilt)):
+		return rebuilt
+
+	if rebuilt is String and type != TYPE_STRING:
+		var text: String = rebuilt
+		var parsed: Variant = JSON.parse_string(text)
+		# A string that does not read as the type wanted is handed back as the string it is, so
+		# whoever asked can refuse it. type_convert answers 0 for "not an index" and true for any
+		# text at all, and a caller who sent a word got back a number they never sent: get_child
+		# answered about child 0 with no refusal and no note, which is a halt traded for a plausible
+		# wrong answer, and the wrong answer is the worse of the two.
+		if typeof(parsed) == TYPE_NIL or typeof(parsed) == TYPE_STRING:
+			return rebuilt
+		rebuilt = parsed
+
+	return type_convert(rebuilt, type)
+
+
 ## Whether [param fields] carries every key of any one of [param alternatives].
 ##
 ## More than one spelling because a rectangle has two: the two corners it is answered with, and the

package/build/godot/operations/serialisation.gd

@@ -10,6 +10,27 @@ extends RefCounted
 
 const Read = preload("reading.gd")
 
+# What the engine carries from one to another without complaint, which is what a value written to a
+# property or handed to a parameter may arrive as. Numbers include bool because the engine counts it
+# as one, and the three text types are one string wearing three hats.
+const NUMBERS: Array[int] = [TYPE_BOOL, TYPE_INT, TYPE_FLOAT]
+const TEXTS: Array[int] = [TYPE_STRING, TYPE_STRING_NAME, TYPE_NODE_PATH]
+
+# The types that cross as a plain JSON list and have to be built back into themselves. A list is
+# what a caller can write by hand and what the serialiser answers with, and the parameter or
+# property being written is the only thing that knows which of these it wanted.
+const LIST_TYPES: Array[int] = [
+	TYPE_PACKED_INT32_ARRAY,
+	TYPE_PACKED_INT64_ARRAY,
+	TYPE_PACKED_FLOAT32_ARRAY,
+	TYPE_PACKED_FLOAT64_ARRAY,
+	TYPE_PACKED_STRING_ARRAY,
+	TYPE_PACKED_VECTOR2_ARRAY,
+	TYPE_PACKED_VECTOR3_ARRAY,
+	TYPE_PACKED_VECTOR4_ARRAY,
+	TYPE_PACKED_COLOR_ARRAY,
+]
+
 # 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
@@ -163,6 +184,91 @@ func deserialize_value(value: Variant) -> Variant:
 	return call(builder, fields)
 
 
+## Whether two values can be compared without the comparison itself failing.
+##
+## GDScript's `==` is not total. An Object against a String is a hard error rather than false, and
+## an error raised inside a game is not a wrong answer: it stops the game. A caller who asked
+## `runtime_wait until` for the wrong kind of value got their game held at a debugger break, every
+## later call answering "did not respond within 10000ms, it may be stuck in a long frame", and
+## nothing anywhere naming the argument that did it. A wrong argument costs a refusal, never the
+## session's game.
+##
+## Only an object is special. Every other pair the engine answers, false where they differ, and
+## refusing those would refuse calls that work: an int against a float is the same number to a
+## caller waiting for 1 on a property holding 1.0.
+static func comparable(one: Variant, other: Variant) -> bool:
+	var left: int = typeof(one)
+	var right: int = typeof(other)
+	if left != TYPE_OBJECT and right != TYPE_OBJECT:
+		return true
+	# An object compares with another object and with null. Anything else is the error above.
+	return (left == TYPE_OBJECT or left == TYPE_NIL) and (right == TYPE_OBJECT or right == TYPE_NIL)
+
+
+## Whether [param value] can be given to something declared as [param type] without damage.
+##
+## Here rather than beside either caller because the running game and the editor ask it of the same
+## values and must not answer differently. What it protects against differs by side and both are
+## silent: `callv` and `==` raise inside a running game, which holds it at a debugger break, while
+## `Object.set` in the editor converts instead and writes the result to the scene file. A word where
+## an int goes is stored as 0, where a bool goes as true, where a Vector2 goes as (0, 0), and the
+## tool reports the change as made. The property keeps a value nobody asked for and the scene is
+## saved with it.
+##
+## A list of what is accepted rather than of what is refused, which is the way round that errs
+## safely. The engine's own conversion table is not readable from GDScript, so either list is a
+## guess at it; guessing narrow costs a caller a refusal naming both types, and guessing wide costs
+## them the damage above. A refusal is the cheaper mistake, and it is the one they can act on.
+static func acceptable(value: Variant, type: int) -> bool:
+	if type == TYPE_NIL:
+		return true
+	var given: int = typeof(value)
+	if given == type:
+		return true
+	# null is a value for anything that holds an object, and for nothing else.
+	if given == TYPE_NIL:
+		return type == TYPE_OBJECT
+	if NUMBERS.has(given) and NUMBERS.has(type):
+		return true
+	if TEXTS.has(given) and TEXTS.has(type):
+		return true
+	return given == TYPE_ARRAY and LIST_TYPES.has(type)
+
+
+## A value from the wire fitted to the type a property or parameter declares. Arguments arrive
+## as strings often enough, and callv refuses a "2.0" where a float is wanted, so a string that
+## reads as the wanted scalar is read as one.
+##
+## The conversion is also what restores a packed array's exact type. Those cross as the plain JSON
+## lists they fit into, so what comes back from the wire is an Array, and the parameter is what says
+## it was a PackedStringArray.
+func fitted(value: Variant, type: int) -> Variant:
+	var rebuilt: Variant = deserialize_value(value)
+	if type == TYPE_NIL or typeof(rebuilt) == type:
+		return rebuilt
+
+	if rebuilt is Array and LIST_TYPES.has(type):
+		return type_convert(rebuilt, type)
+
+	var simple: Array[int] = [TYPE_BOOL, TYPE_INT, TYPE_FLOAT, TYPE_STRING]
+	if not simple.has(type) or not simple.has(typeof(rebuilt)):
+		return rebuilt
+
+	if rebuilt is String and type != TYPE_STRING:
+		var text: String = rebuilt
+		var parsed: Variant = JSON.parse_string(text)
+		# A string that does not read as the type wanted is handed back as the string it is, so
+		# whoever asked can refuse it. type_convert answers 0 for "not an index" and true for any
+		# text at all, and a caller who sent a word got back a number they never sent: get_child
+		# answered about child 0 with no refusal and no note, which is a halt traded for a plausible
+		# wrong answer, and the wrong answer is the worse of the two.
+		if typeof(parsed) == TYPE_NIL or typeof(parsed) == TYPE_STRING:
+			return rebuilt
+		rebuilt = parsed
+
+	return type_convert(rebuilt, type)
+
+
 ## Whether [param fields] carries every key of any one of [param alternatives].
 ##
 ## More than one spelling because a rectangle has two: the two corners it is answered with, and the