gdharness 1.2.29 → 1.2.30

package/build/cli.js

@@ -12417,7 +12417,7 @@ var init_tool_definitions = __esm(() => {
         value: {
           ops: ["set"],
           blank: true,
-          description: `set: the value, fitted to the property's type. A vector, colour or the like may be written as its fields, {"x": 140, "y": 300}, or tagged, {"_type": "Vector2", "x": 140, "y": 300}, which is the form a read answers with. "" writes an empty string. A property typed as or holding an object takes a path naming one the game holds, the way call's args do, and holds that instance, or null, which the text null also means, to empty it. One declared as Variant or untyped takes anything, as the engine does: a value of the kind it holds is fitted to it, an int staying an int, and any other is stored as sent. A typed list or map, such as Array[int] or Dictionary[String, int], takes a JSON list or object with each element fitted to its element type, and an element that cannot become one is refused by its index or key, as is an object of another script than the one the list holds, whether or not that script has a class_name.`
+          description: `set: the value, fitted to the property's type. A number the property would have to cut is refused rather than truncated: a fraction into an int, a number other than 0 or 1 into a bool. A vector, colour or the like may be written as its fields, {"x": 140, "y": 300}, or tagged, {"_type": "Vector2", "x": 140, "y": 300}, which is the form a read answers with. "" writes an empty string. A property typed as or holding an object takes a path naming one the game holds, the way call's args do, and holds that instance, or null, which the text null also means, to empty it. One declared as Variant or untyped takes anything, as the engine does: a value of the kind it holds is fitted to it, an int staying an int, and any other is stored as sent, a fraction into one holding an int included. A typed list or map, such as Array[int] or Dictionary[String, int], takes a JSON list or object with each element fitted to its element type, and an element that cannot become one is refused by its index or key, as is an object of another script than the one the list holds, whether or not that script has a class_name.`
         },
         method: {
           type: "string",
@@ -12427,7 +12427,7 @@ var init_tool_definitions = __esm(() => {
         args: {
           type: "array",
           ops: ["call"],
-          description: `call: the arguments, fitted to the method's parameter types. A vector, colour or the like may be written as its fields, {"x": 140, "y": 300}, or tagged, {"_type": "Vector2", "x": 140, "y": 300}. A parameter typed as an object takes a path naming one the game holds and is handed that instance: a colon path read from nodePath, "_game:run:wares:3", or one starting at a node, "/root/Main/Hud" or "/root/Main:_game:run". A path that reaches no object, or an object of another class than the parameter declares, is refused, and so are too few or too many arguments. The engine names a parameter typed as a script class without class_name by the class the script extends, so an object of that class with another script passes that check and the engine refuses the call: the answer says the method did not run, with the engine's reason. A parameter typed as a list or map, such as Array[int] or Array[Gear], is built from a JSON list or object element by element, objects named by their paths. The method itself takes its arguments here only: brackets on it holding arguments are refused.`
+          description: `call: the arguments, fitted to the method's parameter types. A number a parameter would have to cut is refused rather than truncated: a fraction for an int, a number other than 0 or 1 for a bool. A vector, colour or the like may be written as its fields, {"x": 140, "y": 300}, or tagged, {"_type": "Vector2", "x": 140, "y": 300}. A parameter typed as an object takes a path naming one the game holds and is handed that instance: a colon path read from nodePath, "_game:run:wares:3", or one starting at a node, "/root/Main/Hud" or "/root/Main:_game:run". A path that reaches no object, or an object of another class than the parameter declares, is refused, and so are too few or too many arguments. The engine names a parameter typed as a script class without class_name by the class the script extends, so an object of that class with another script passes that check and the engine refuses the call: the answer says the method did not run, with the engine's reason. A parameter typed as a list or map, such as Array[int] or Array[Gear], is built from a JSON list or object element by element, objects named by their paths. The method itself takes its arguments here only: brackets on it holding arguments are refused.`
         },
         properties: {
           type: ["boolean", "array"],

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

@@ -61,65 +61,13 @@ func set_property(params: Dictionary) -> Dictionary:
 	if not Paths.can_read(holder, named):
 		return {"type": "error", "message": Paths.nothing_there(holder, named, str(reached["called"]))}
 	var old_value: Variant = Paths.read_under(holder, named)
-	# 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.
-	#
-	# A slot declaring nothing, an untyped or Variant property or an element of an untyped list, takes
-	# anything, and the engine stores what it is given there. What it holds now still says how a value
-	# of the same kind is meant, 5 into an int staying an int, and whether a path names an object, but
-	# a value of another kind is stored as sent: a word into one holding a number is the word, and a
-	# number into one holding a word is the number, not its text. The text null empties it when it
-	# holds an object or nothing, as a wait reads it on the same slot.
 	var slot: Dictionary = Values.slot_declared(holder, named)
 	var declared: int = slot["type"]
 	var declared_script: Script = slot["script"]
-	var wanted: int = declared if declared != TYPE_NIL else typeof(old_value)
-	var holds_objects: bool = (
-		declared == TYPE_OBJECT or (declared == TYPE_NIL and (old_value == null or old_value is Object))
-	)
-	var given: Variant
-	if holds_objects and names_no_object(value):
-		given = null
-	elif wanted == TYPE_OBJECT and (value is String or value is Dictionary):
-		var named_object: Dictionary = _object_named(
-			node, node_path, value, str(slot["class"]), declared_script
-		)
-		if named_object.has("message"):
-			return {
-				"type": "error",
-				"message": "%s.%s holds an object: %s" % [reached["called"], named, named_object["message"]]
-			}
-		given = named_object["object"]
-	else:
-		var as_sent: Variant = _values.fitted(value, TYPE_NIL)
-		if declared == TYPE_NIL and not Values.acceptable(as_sent, wanted):
-			given = as_sent
-		else:
-			given = _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.%s"
-						% [
-							reached["called"],
-							named,
-							type_string(wanted),
-							type_string(typeof(given)),
-							_written_as(wanted)
-						]
-					)
-				}
-		var typed: Dictionary = _values.typed_like(given, old_value, _element_object.bind(node, node_path))
-		if typed.has("message"):
-			return {
-				"type": "error",
-				"message":
-				"%s.%s is a typed %s: %s." % [reached["called"], named, _sort_of(old_value), typed["message"]]
-			}
-		given = typed["value"]
+	var fitting: Dictionary = _value_for(value, slot, old_value, reached, node, node_path)
+	if fitting.has("message"):
+		return fitting
+	var given: Variant = fitting["value"]
 	# A component of a vector or a transform is written into a copy, which is put back where it was
 	# read from, setter and all; the read back is then taken off the game again, since the copy here
 	# says only what was written into it.
@@ -201,6 +149,131 @@ func set_property(params: Dictionary) -> Dictionary:
 	return answer
 
 
+## What [param sent] becomes as argument [param index] of the method [param named] on the holder
+## [param reached] ends at, as [method Paths.walk_to] answered it, as `{"value": ...}`, or the refusal
+## saying why it cannot become one: a number the parameter would have to cut, a value that cannot be
+## converted, or a list or map that cannot be built as the typed one the parameter takes.
+func _argument_for(
+	sent: Variant, index: int, reached: Dictionary, named: String, node: Node, node_path: String
+) -> Dictionary:
+	var holder: Object = reached["holder"]
+	var called: String = reached["called"]
+	var wants: int = _values.parameter_type(holder, named, index)
+	if Values.cuts(sent, wants):
+		return {
+			"type": "error",
+			"message":
+			(
+				"%s.%s takes %s as argument %d and was given %s, which it would have to be cut to fit"
+				% [called, named, type_string(wants), index + 1, JSON.stringify(sent)]
+			)
+		}
+	var given: Variant = _values.fitted(sent, wants)
+	if not Values.acceptable(given, wants):
+		return {
+			"type": "error",
+			"message":
+			(
+				"%s.%s takes %s as argument %d and was given %s, which cannot be converted.%s"
+				% [
+					called,
+					named,
+					type_string(wants),
+					index + 1,
+					type_string(typeof(given)),
+					_written_as(wants)
+				]
+			)
+		}
+	# A typed list or map is built as one, since a plain one handed to such a parameter raises
+	# inside the game, which is what every check here exists to stop.
+	var container: Variant = _values.parameter_container(holder, named, index)
+	if container == null:
+		return {"value": given}
+	var typed: Dictionary = _values.typed_like(given, container, _element_object.bind(node, node_path))
+	if typed.has("message"):
+		return {
+			"type": "error",
+			"message":
+			(
+				"%s.%s takes a typed %s as argument %d: %s."
+				% [called, named, _sort_of(container), index + 1, typed["message"]]
+			)
+		}
+	return {"value": typed["value"]}
+
+
+## What [param value] becomes written into the slot [param reached] ends on, as
+## [method Paths.walk_to] answered it, as `{"value": ...}`, or the refusal saying why it cannot become
+## one.
+##
+## 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. So is a
+## number a whole number or a truth would have to cut, since converting one truncates.
+##
+## A slot declaring nothing, an untyped or Variant property or an element of an untyped list, takes
+## anything, and the engine stores what it is given there. What it holds now still says how a value
+## of the same kind is meant, 5 into an int staying an int, and whether a path names an object, but
+## a value of another kind is stored as sent: a word into one holding a number is the word, a
+## fraction into one holding a whole number is the fraction, and a number into one holding a word is
+## the number, not its text. The text null empties it when it holds an object or nothing, as a wait
+## reads it on the same slot.
+func _value_for(
+	value: Variant, slot: Dictionary, old_value: Variant, reached: Dictionary, node: Node, node_path: String
+) -> Dictionary:
+	var named: String = reached["name"]
+	var called: String = reached["called"]
+	var declared: int = slot["type"]
+	var declared_script: Script = slot["script"]
+	var wanted: int = declared if declared != TYPE_NIL else typeof(old_value)
+	var holds_objects: bool = (
+		declared == TYPE_OBJECT or (declared == TYPE_NIL and (old_value == null or old_value is Object))
+	)
+	if holds_objects and names_no_object(value):
+		return {"value": null}
+	if wanted == TYPE_OBJECT and (value is String or value is Dictionary):
+		var named_object: Dictionary = _object_named(
+			node, node_path, value, str(slot["class"]), declared_script
+		)
+		if named_object.has("message"):
+			return {
+				"type": "error",
+				"message": "%s.%s holds an object: %s" % [called, named, named_object["message"]]
+			}
+		return {"value": named_object["object"]}
+	var as_sent: Variant = _values.fitted(value, TYPE_NIL)
+	var cut: bool = Values.cuts(value, wanted)
+	var given: Variant = as_sent
+	if declared != TYPE_NIL and cut:
+		return {
+			"type": "error",
+			"message":
+			(
+				"%s.%s holds %s and the value given is %s, which it would have to be cut to fit"
+				% [called, named, type_string(wanted), JSON.stringify(value)]
+			)
+		}
+	if declared != TYPE_NIL or (not cut and Values.acceptable(as_sent, wanted)):
+		given = _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.%s"
+					% [called, named, type_string(wanted), type_string(typeof(given)), _written_as(wanted)]
+				)
+			}
+	var typed: Dictionary = _values.typed_like(given, old_value, _element_object.bind(node, node_path))
+	if typed.has("message"):
+		return {
+			"type": "error",
+			"message": "%s.%s is a typed %s: %s." % [called, named, _sort_of(old_value), typed["message"]]
+		}
+	return {"value": typed["value"]}
+
+
 ## Whether [param given] is the value [param held] already is, at the precision the property keeps.
 ##
 ## A float arrives as 64 bits and most engine properties keep 32: Camera3D.h_offset given -1.1
@@ -254,6 +327,12 @@ func call_method(params: Dictionary) -> Dictionary:
 		var spelled: String = str(reached["name"])
 		if Paths.method_of(spelled).is_empty():
 			spelled += "()"
+		# A vector or a transform has no element to call a method on: it is read by its components.
+		if Paths.composite(reached["holder"]):
+			return {
+				"type": "error",
+				"message": Paths.nothing_there(reached["holder"], spelled, str(reached["called"]))
+			}
 		if args.is_empty() and Paths.can_read(reached["holder"], spelled):
 			var read_from: int = Time.get_ticks_usec()
 			var answered: Variant = Paths.read_under(reached["holder"], spelled)
@@ -320,41 +399,10 @@ func call_method(params: Dictionary) -> Dictionary:
 				by_engine_class[index + 1] = [declared, Values.class_of(resolved)]
 			deserialized_args.append(named_object["object"])
 			continue
-		var given: Variant = _values.fitted(args[index], wants)
-		if not Values.acceptable(given, wants):
-			return {
-				"type": "error",
-				"message":
-				(
-					"%s.%s takes %s as argument %d and was given %s, which cannot be converted.%s"
-					% [
-						reached["called"],
-						named,
-						type_string(wants),
-						index + 1,
-						type_string(typeof(given)),
-						_written_as(wants)
-					]
-				)
-			}
-		# A typed list or map is built as one, since a plain one handed to such a parameter raises
-		# inside the game, which is what every check here exists to stop.
-		var container: Variant = _values.parameter_container(holder, named, index)
-		if container != null:
-			var typed: Dictionary = _values.typed_like(
-				given, container, _element_object.bind(node, node_path)
-			)
-			if typed.has("message"):
-				return {
-					"type": "error",
-					"message":
-					(
-						"%s.%s takes a typed %s as argument %d: %s."
-						% [reached["called"], named, _sort_of(container), index + 1, typed["message"]]
-					)
-				}
-			given = typed["value"]
-		deserialized_args.append(given)
+		var argument: Dictionary = _argument_for(args[index], index, reached, named, node, node_path)
+		if argument.has("message"):
+			return argument
+		deserialized_args.append(argument["value"])
 
 	# Timed around the call alone, since the bridge's round trip is a second or more and swamps what
 	# one click's work costs; the frame metrics read whichever frame is last, which is not this one.

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

@@ -134,6 +134,28 @@ static func acceptable(value: Variant, type: int) -> bool:
 	return Serialisation.acceptable(value, type)
 
 
+## Whether [param given] would have to be cut to become a [param type]: a fraction made a whole
+## number, or a number other than 0 or 1 made a truth.
+##
+## A number arrives from JSON as a float, so one is converted to what the slot holds, and the
+## conversion truncates: 2.5 written into an int was stored as 2 and answered as written, and 0.2 on
+## a bool became true. A number written as text counts as the number.
+static func cuts(given: Variant, type: int) -> bool:
+	if type != TYPE_INT and type != TYPE_BOOL:
+		return false
+	var number: Variant = given
+	if given is String:
+		var text: String = given
+		number = Read.json_or_null(text)
+	if typeof(number) != TYPE_FLOAT and typeof(number) != TYPE_INT:
+		return false
+	var value: float = Read.as_float(number)
+	var whole: bool = value == floorf(value)
+	if type == TYPE_INT:
+		return not whole
+	return not (whole and (value == 0.0 or value == 1.0))
+
+
 ## How a value of [param type] is written to be read as one, or empty when it is not built from fields.
 static func written_as(type: int) -> String:
 	return Serialisation.written_as(type)

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

@@ -312,19 +312,7 @@ static func _in_order(compare: String, limit: float, current: Variant) -> bool:
 ## conversion truncates: 3.5 waited on an int became 3 and 0.2 on a bool became true, and a property
 ## already holding that answered met at once, about a state nobody asked for.
 static func _cut_to_fit(given: Variant, type: int, node_path: String, property: String) -> String:
-	if type != TYPE_INT and type != TYPE_BOOL:
-		return ""
-	var number: Variant = given
-	if given is String:
-		var text: String = given
-		number = Read.json_or_null(text)
-	if typeof(number) != TYPE_FLOAT and typeof(number) != TYPE_INT:
-		return ""
-	var value: float = Read.as_float(number)
-	var whole: bool = value == floorf(value)
-	if type == TYPE_INT and whole:
-		return ""
-	if type == TYPE_BOOL and whole and (value == 0.0 or value == 1.0):
+	if not Values.cuts(given, type):
 		return ""
 	return (
 		(

package/build/index.js

@@ -35562,7 +35562,7 @@ var TOOL_SPECS = [
       value: {
         ops: ["set"],
         blank: true,
-        description: `set: the value, fitted to the property's type. A vector, colour or the like may be written as its fields, {"x": 140, "y": 300}, or tagged, {"_type": "Vector2", "x": 140, "y": 300}, which is the form a read answers with. "" writes an empty string. A property typed as or holding an object takes a path naming one the game holds, the way call's args do, and holds that instance, or null, which the text null also means, to empty it. One declared as Variant or untyped takes anything, as the engine does: a value of the kind it holds is fitted to it, an int staying an int, and any other is stored as sent. A typed list or map, such as Array[int] or Dictionary[String, int], takes a JSON list or object with each element fitted to its element type, and an element that cannot become one is refused by its index or key, as is an object of another script than the one the list holds, whether or not that script has a class_name.`
+        description: `set: the value, fitted to the property's type. A number the property would have to cut is refused rather than truncated: a fraction into an int, a number other than 0 or 1 into a bool. A vector, colour or the like may be written as its fields, {"x": 140, "y": 300}, or tagged, {"_type": "Vector2", "x": 140, "y": 300}, which is the form a read answers with. "" writes an empty string. A property typed as or holding an object takes a path naming one the game holds, the way call's args do, and holds that instance, or null, which the text null also means, to empty it. One declared as Variant or untyped takes anything, as the engine does: a value of the kind it holds is fitted to it, an int staying an int, and any other is stored as sent, a fraction into one holding an int included. A typed list or map, such as Array[int] or Dictionary[String, int], takes a JSON list or object with each element fitted to its element type, and an element that cannot become one is refused by its index or key, as is an object of another script than the one the list holds, whether or not that script has a class_name.`
       },
       method: {
         type: "string",
@@ -35572,7 +35572,7 @@ var TOOL_SPECS = [
       args: {
         type: "array",
         ops: ["call"],
-        description: `call: the arguments, fitted to the method's parameter types. A vector, colour or the like may be written as its fields, {"x": 140, "y": 300}, or tagged, {"_type": "Vector2", "x": 140, "y": 300}. A parameter typed as an object takes a path naming one the game holds and is handed that instance: a colon path read from nodePath, "_game:run:wares:3", or one starting at a node, "/root/Main/Hud" or "/root/Main:_game:run". A path that reaches no object, or an object of another class than the parameter declares, is refused, and so are too few or too many arguments. The engine names a parameter typed as a script class without class_name by the class the script extends, so an object of that class with another script passes that check and the engine refuses the call: the answer says the method did not run, with the engine's reason. A parameter typed as a list or map, such as Array[int] or Array[Gear], is built from a JSON list or object element by element, objects named by their paths. The method itself takes its arguments here only: brackets on it holding arguments are refused.`
+        description: `call: the arguments, fitted to the method's parameter types. A number a parameter would have to cut is refused rather than truncated: a fraction for an int, a number other than 0 or 1 for a bool. A vector, colour or the like may be written as its fields, {"x": 140, "y": 300}, or tagged, {"_type": "Vector2", "x": 140, "y": 300}. A parameter typed as an object takes a path naming one the game holds and is handed that instance: a colon path read from nodePath, "_game:run:wares:3", or one starting at a node, "/root/Main/Hud" or "/root/Main:_game:run". A path that reaches no object, or an object of another class than the parameter declares, is refused, and so are too few or too many arguments. The engine names a parameter typed as a script class without class_name by the class the script extends, so an object of that class with another script passes that check and the engine refuses the call: the answer says the method did not run, with the engine's reason. A parameter typed as a list or map, such as Array[int] or Array[Gear], is built from a JSON list or object element by element, objects named by their paths. The method itself takes its arguments here only: brackets on it holding arguments are refused.`
       },
       properties: {
         type: ["boolean", "array"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdharness",
-  "version": "1.2.29",
+  "version": "1.2.30",
   "mcpName": "io.github.Aureliolo/gdharness",
   "description": "A harness for driving a Godot 4 project from an agent: editor addons, a runtime bridge into the running game, an MCP server in front of them, and a CLI that installs and diagnoses the Godot side.",
   "type": "module",