gdharness 1.3.41 → 1.3.43

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

@@ -1,17 +1,15 @@
 extends RefCounted
-
-## What the server changes in the running game: a property written, a method called. Both take values
-## from the wire, so both fit them to what the game declares and refuse what cannot fit, and both read
-## back what the engine did rather than trusting that it did it.
+## What the server changes in the running game: a property written, a method called. Both take
+## values from the wire, so both fit them to what the game declares and refuse what cannot fit, and
+## both read back what the engine did rather than trusting that it did it.
 
 const GdhCallErrors = preload("call_errors.gd")
 const GdhDeclared = preload("declared_values.gd")
 const GdhPaths = preload("runtime_paths.gd")
 const GdhRead = preload("reading.gd")
 const GdhValues = preload("runtime_values.gd")
-
-## The most errors a call's answer carries, which is enough to see what the method ran into and short
-## of a method reporting one per element of a list of thousands.
+## The most errors a call's answer carries, which is enough to see what the method ran into and
+## short of a method reporting one per element of a list of thousands.
 const ERRORS_KEPT: int = 20
 
 var _host: Node
@@ -31,7 +29,7 @@ func set_property(params: Dictionary) -> Dictionary:
 	var value: Variant = params.get("value")
 
 	if node_path.is_empty() or property.is_empty():
-		return {"type": "error", "message": "Node path and property required"}
+		return { "type": "error", "message": "Node path and property required" }
 
 	var standing: Dictionary = GdhValues.target_at(_host.get_tree().root, node_path)
 	if standing.has("message"):
@@ -39,9 +37,9 @@ func set_property(params: Dictionary) -> Dictionary:
 	var node: Node = standing["node"]
 	var target: Object = standing["object"]
 
-	# Through a path as well, for the reason [method GdhPaths.walk_to] gives, and read back off the same
-	# holder afterwards: a set that does not take says so by answering with the old value, which is
-	# how a typed container refusing a write is told from one accepting it.
+	# Through a path as well, for the reason [method GdhPaths.walk_to] gives, and read back off the
+	# same holder afterwards: a set that does not take says so by answering with the old value,
+	# which is how a typed container refusing a write is told from one accepting it.
 	var reached: Dictionary = GdhPaths.walk_to(target, node_path, property)
 	if reached.has("message"):
 		return reached
@@ -57,10 +55,13 @@ func set_property(params: Dictionary) -> Dictionary:
 			(
 				"%s:%s is a call, and a call is not a place to write: name a property"
 				% [reached["called"], named]
-			)
+			),
 		}
 	if not GdhPaths.can_read(holder, named):
-		return {"type": "error", "message": GdhPaths.nothing_there(holder, named, str(reached["called"]))}
+		return {
+			"type": "error",
+			"message": GdhPaths.nothing_there(holder, named, str(reached["called"])),
+		}
 	var old_value: Variant = GdhPaths.read_under(holder, named)
 	var slot: Dictionary = GdhValues.slot_declared(holder, named)
 	var declared: int = slot["type"]
@@ -77,7 +78,7 @@ func set_property(params: Dictionary) -> Dictionary:
 	if copied:
 		var unwritable: String = GdhPaths.unwritable_copy(chain)
 		if not unwritable.is_empty():
-			return {"type": "error", "message": unwritable}
+			return { "type": "error", "message": unwritable }
 	# The write alone, setter included, which is where a property's cost is. Listened to as a call
 	# is, since a setter refusing a value says why only in what it reports.
 	var caught: GdhCallErrors = GdhCallErrors.new()
@@ -102,10 +103,11 @@ func set_property(params: Dictionary) -> Dictionary:
 	# And only one that asked for a change: the value the property already held, written again, left
 	# it as it was because nothing was asked of it.
 	#
-	# Said as what was seen, because two causes look the same from here: the engine refusing the write,
-	# and a setter that ran and left the value where it was, clamping it, say. The one this can name
-	# is an object slot checked only by the engine class a script extends (see
-	# [method GdhValues.slot_declared]), where an object of that class with another script is refused.
+	# Said as what was seen, because two causes look the same from here: the engine refusing the
+	# write, and a setter that ran and left the value where it was, clamping it, say. The one this
+	# can name is an object slot checked only by the engine class a script extends (see
+	# [method GdhValues.slot_declared]), where an object of that class with another script is
+	# refused.
 	#
 	# Judged by what reads back alone, so a value of another kind than the one held, which cannot be
 	# compared with it, is still caught when the engine drops it.
@@ -113,16 +115,16 @@ func set_property(params: Dictionary) -> Dictionary:
 	var unmoved: bool = GdhValues.comparable(now, old_value) and now == old_value
 	if unmoved and not already:
 		var why: String = (
-			"the write left it as it was, which is what the engine refusing it and a setter keeping the"
-			+ " value both look like"
+			"the write left it as it was, which is what the engine refusing it and a setter "
+			+ "keeping the value both look like"
 		)
 		if declared == TYPE_OBJECT and given is Object and declared_script == null:
 			var refused_object: Object = given
 			why += (
 				(
-					". %s is declared as %s, which is also how the engine names a script class with no"
-					+ " class_name; if it is one, the object given has the right class and another script:"
-					+ " it is %s"
+					". %s is declared as %s, which is also how the engine names a script class "
+					+ "with no class_name; if it is one, the object given has the right class and "
+					+ "another script: it is %s"
 				)
 				% [named, str(slot["class"]), GdhValues.class_of(refused_object)]
 			)
@@ -139,7 +141,7 @@ func set_property(params: Dictionary) -> Dictionary:
 		if not caught.raised.is_empty():
 			var reported: PackedStringArray = PackedStringArray(caught.raised.slice(0, ERRORS_KEPT))
 			refused += " While it was written the game reported: %s" % "; ".join(reported)
-		return {"type": "error", "message": refused}
+		return { "type": "error", "message": refused }
 
 	var answer: Dictionary = {
 		"type": "property_set",
@@ -147,14 +149,15 @@ func set_property(params: Dictionary) -> Dictionary:
 		"property": property,
 		"old_value": _values.serialize(old_value),
 		"new_value": _values.serialize(now),
-		"elapsed_usec": elapsed
+		"elapsed_usec": elapsed,
 	}
 	if already and unmoved:
 		answer["unchanged"] = true
 	_keep_reported(answer, "errors", caught.raised)
 	_keep_reported(answer, "warnings", caught.warned)
 	# The engine stores a number past an export range, or one no enum value has, as given; only the
-	# inspector holds a property to them, so the game now holds a value its own script never expected.
+	# inspector holds a property to them, so the game now holds a value its own script never
+	# expected.
 	if holder is Object:
 		var owner: Object = holder
 		var shown: String = JSON.stringify(_values.serialize(now), "", false)
@@ -166,9 +169,9 @@ func set_property(params: Dictionary) -> Dictionary:
 
 
 ## What [param sent] becomes as argument [param index] of the method [param named] on the holder
-## [param reached] ends at, as [method GdhPaths.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.
+## [param reached] ends at, as [method GdhPaths.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:
@@ -185,14 +188,17 @@ func _argument_for(
 				"message":
 				GdhDeclared.enum_argument_refusal(
 					"%s.%s" % [called, named], index, str(choices["enum"]), str(sent), values
-				)
+				),
 			}
-		return {"value": chosen}
+		return { "value": chosen }
 	# A packed list's elements are fitted one by one, and one that cannot become what the list holds
-	# is named: converted whole, a word or a fraction among them became 0 or was cut, and the call ran.
+	# is named: converted whole, a word or a fraction among them became 0 or was cut, and the call
+	# ran.
 	var packed: Variant = GdhValues.packed_template(wants)
 	if packed != null and sent is Array:
-		var elements: Dictionary = _values.typed_like(sent, packed, _element_object.bind(node, node_path))
+		var elements: Dictionary = _values.typed_like(
+			sent, packed, _element_object.bind(node, node_path)
+		)
 		if elements.has("message"):
 			return {
 				"type": "error",
@@ -200,29 +206,32 @@ func _argument_for(
 				(
 					"%s.%s takes %s as argument %d: %s"
 					% [called, named, type_string(wants), index + 1, elements["message"]]
-				)
+				),
 			}
 	if GdhValues.cuts(sent, wants):
 		return {
 			"type": "error",
 			"message":
 			(
-				"%s.%s takes %s as argument %d and was given %s, which %s cannot hold without changing it"
+				(
+					"%s.%s takes %s as argument %d and was given %s, which %s cannot hold without "
+					+ "changing it"
+				)
 				% [
 					called,
 					named,
 					type_string(wants),
 					index + 1,
 					JSON.stringify(sent),
-					GdhValues.cut_by(wants)
+					GdhValues.cut_by(wants),
 				]
-			)
+			),
 		}
 	var rounded: String = GdhValues.inexact(sent, wants)
 	if not rounded.is_empty():
 		return {
 			"type": "error",
-			"message": "%s.%s takes int as argument %d: %s." % [called, named, index + 1, rounded]
+			"message": "%s.%s takes int as argument %d: %s." % [called, named, index + 1, rounded],
 		}
 	var given: Variant = _values.fitted(sent, wants)
 	if not GdhValues.acceptable(given, wants):
@@ -237,16 +246,18 @@ func _argument_for(
 					type_string(wants),
 					index + 1,
 					type_string(typeof(given)),
-					GdhValues.remedy(sent, wants)
+					GdhValues.remedy(sent, 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))
+		return { "value": given }
+	var typed: Dictionary = _values.typed_like(
+		given, container, _element_object.bind(node, node_path)
+	)
 	if typed.has("message"):
 		return {
 			"type": "error",
@@ -254,14 +265,14 @@ func _argument_for(
 			(
 				"%s.%s takes a typed %s as argument %d: %s"
 				% [called, named, _sort_of(container), index + 1, typed["message"]]
-			)
+			),
 		}
-	return {"value": typed["value"]}
+	return { "value": typed["value"] }
 
 
 ## What [param value] becomes written into the slot [param reached] ends on, as
-## [method GdhPaths.walk_to] answered it, as `{"value": ...}`, or the refusal saying why it cannot become
-## one.
+## [method GdhPaths.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
@@ -276,7 +287,12 @@ func _argument_for(
 ## 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
+	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"]
@@ -284,27 +300,33 @@ func _value_for(
 	var declared_script: Script = slot["script"]
 	var wanted: int = declared if declared != TYPE_NIL else typeof(old_value)
 	var declaration: Dictionary = slot["declared"]
-	var enum_hint: bool = GdhRead.as_int(declaration.get("hint", PROPERTY_HINT_NONE)) == PROPERTY_HINT_ENUM
+	var enum_hint: bool = (
+		GdhRead.as_int(declaration.get("hint", PROPERTY_HINT_NONE)) == PROPERTY_HINT_ENUM
+	)
 	if declared == TYPE_INT and enum_hint and value is String and reached["holder"] is Object:
 		var owner: Object = reached["holder"]
 		var by_name: Array = GdhDeclared.enum_by_name(owner, declaration, str(value), called)
 		if by_name[0]:
-			return {"value": by_name[1]}
+			return { "value": by_name[1] }
 		if not str(by_name[1]).is_empty():
-			return {"type": "error", "message": by_name[1]}
+			return { "type": "error", "message": by_name[1] }
 	var packed: Variant = GdhValues.packed_template(wanted)
 	if packed != null and value is Array:
-		var elements: Dictionary = _values.typed_like(value, packed, _element_object.bind(node, node_path))
+		var elements: Dictionary = _values.typed_like(
+			value, packed, _element_object.bind(node, node_path)
+		)
 		if elements.has("message"):
 			return {
 				"type": "error",
-				"message": "%s.%s holds %s: %s" % [called, named, type_string(wanted), elements["message"]]
+				"message":
+				"%s.%s holds %s: %s" % [called, named, type_string(wanted), elements["message"]],
 			}
 	var holds_objects: bool = (
-		declared == TYPE_OBJECT or (declared == TYPE_NIL and (old_value == null or old_value is Object))
+		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}
+		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
@@ -312,12 +334,12 @@ func _value_for(
 		if named_object.has("message"):
 			return {
 				"type": "error",
-				"message": "%s.%s holds an object: %s" % [called, named, named_object["message"]]
+				"message": "%s.%s holds an object: %s" % [called, named, named_object["message"]],
 			}
-		return {"value": named_object["object"]}
+		return { "value": named_object["object"] }
 	var rounded: String = GdhValues.inexact(value, wanted)
 	if not rounded.is_empty():
-		return {"type": "error", "message": "%s.%s holds int: %s." % [called, named, rounded]}
+		return { "type": "error", "message": "%s.%s holds int: %s." % [called, named, rounded] }
 	var as_sent: Variant = _values.fitted(value, TYPE_NIL)
 	var cut: bool = GdhValues.cuts(value, wanted)
 	var given: Variant = as_sent
@@ -327,8 +349,14 @@ func _value_for(
 			"message":
 			(
 				"%s.%s holds %s and the value given is %s, which %s cannot hold without changing it"
-				% [called, named, type_string(wanted), JSON.stringify(value), GdhValues.cut_by(wanted)]
-			)
+				% [
+					called,
+					named,
+					type_string(wanted),
+					JSON.stringify(value),
+					GdhValues.cut_by(wanted),
+				]
+			),
 		}
 	if declared != TYPE_NIL or (not cut and GdhValues.acceptable(as_sent, wanted)):
 		given = _values.fitted(value, wanted)
@@ -343,17 +371,20 @@ func _value_for(
 						named,
 						type_string(wanted),
 						type_string(typeof(given)),
-						GdhValues.remedy(value, wanted)
+						GdhValues.remedy(value, wanted),
 					]
-				)
+				),
 			}
-	var typed: Dictionary = _values.typed_like(given, old_value, _element_object.bind(node, node_path))
+	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"]]
+			"message":
+			"%s.%s is a typed %s: %s" % [called, named, _sort_of(old_value), typed["message"]],
 		}
-	return {"value": typed["value"]}
+	return { "value": typed["value"] }
 
 
 ## Whether [param given] is the value [param held] already is, at the precision the property keeps.
@@ -376,9 +407,9 @@ static func held_already(given: Variant, held: Variant) -> bool:
 	return PackedFloat32Array([given])[0] == PackedFloat32Array([held])[0]
 
 
-## What to do instead of the call [param method] makes on [param sort], the list or map [param
-## reached] ends on, which a path does not make. A method of the list itself is the likelier aim
-## than one of what it holds when the list has it: told to call append() on an element, a caller
+## What to do instead of the call [param method] makes on [param sort], the list or map
+## [param reached] ends on, which a path does not make. A method of the list itself is the likelier
+## aim than one of what it holds when the list has it: told to call append() on an element, a caller
 ## adding to a list has nowhere to go.
 static func _instead_of_a_call(reached: Dictionary, method: String, sort: String) -> String:
 	var own: String = GdhPaths.method_of(str(reached["name"]))
@@ -396,23 +427,25 @@ static func _instead_of_a_call(reached: Dictionary, method: String, sort: String
 			if through_a_call:
 				return (
 					(
-						"%s() changes %s: to change it, call a method of the game that changes it, since %s"
-						+ " is returned by a call, and runtime_invoke set does not write into what a call returns"
+						"%s() changes %s: to change it, call a method of the game that changes it, "
+						+ "since %s is returned by a call, and runtime_invoke set does not write "
+						+ "into what a call returns"
 					)
 					% [own, the, reached["called"]]
 				)
 			return (
 				(
-					"%s() changes %s: to change it, give %s its new value whole with runtime_invoke set,"
-					+ " property %s, or call a method of the game that changes it"
+					"%s() changes %s: to change it, give %s its new value whole with "
+					+ "runtime_invoke set, property %s, or call a method of the game that changes "
+					+ "it"
 				)
 				% [own, the, reached["called"], holding]
 			)
 		"reads":
 			return (
 				(
-					"To look in %s with %s(), read %s whole with runtime_inspect property, property %s, and"
-					+ " look in what comes back"
+					"To look in %s with %s(), read %s whole with runtime_inspect property, "
+					+ "property %s, and look in what comes back"
 				)
 				% [the, own, reached["called"], holding]
 			)
@@ -428,7 +461,7 @@ func call_method(params: Dictionary) -> Dictionary:
 	var args: Array = params.get("args", [])
 
 	if node_path.is_empty() or method.is_empty():
-		return {"type": "error", "message": "Node path and method required"}
+		return { "type": "error", "message": "Node path and method required" }
 
 	var root: Node = _host.get_tree().root
 	var standing: Dictionary = GdhValues.class_at(root, node_path)
@@ -441,8 +474,8 @@ func call_method(params: Dictionary) -> Dictionary:
 			var close: PackedStringArray = GdhRead.nearest(node_path, PackedStringArray(classes))
 			standing["message"] = (
 				(
-					"%s. No global class is called %s either%s; a static function is called with its"
-					+ " class's name or its script's res:// path as the path."
+					"%s. No global class is called %s either%s; a static function is called with "
+					+ "its class's name or its script's res:// path as the path."
 				)
 				% [
 					str(standing["message"]).trim_suffix("."),
@@ -462,8 +495,8 @@ func call_method(params: Dictionary) -> Dictionary:
 	var node: Node = standing["node"]
 	var target: Object = standing["object"]
 
-	# Through a path as well, for the reason [method GdhPaths.walk_to] gives. What a game does hangs off its
-	# nodes as much as its state does, so reading `_game:run:day` while being unable to call
+	# Through a path as well, for the reason [method GdhPaths.walk_to] gives. What a game does hangs
+	# off its nodes as much as its state does, so reading `_game:run:day` while being unable to call
 	# `_game:run:advance` answers half of what a node holds and refuses the other half.
 	var reached: Dictionary = GdhPaths.walk_to(target, node_path, method)
 	if reached.has("message"):
@@ -471,7 +504,8 @@ func call_method(params: Dictionary) -> Dictionary:
 
 	# A list or a map answers the calls a path makes on one, and nothing else: said in those terms
 	# rather than as "has no method", which reads as a misspelling of a method that was never going
-	# to be there, and with the element spelled out, since a method on what it holds is the usual aim.
+	# to be there, and with the element spelled out, since a method on what it holds is the usual
+	# aim.
 	if not reached["holder"] is Object:
 		var sort: String = "a list"
 		if reached["holder"] is Dictionary:
@@ -481,8 +515,8 @@ func call_method(params: Dictionary) -> Dictionary:
 		var spelled: String = str(reached["name"])
 		if GdhPaths.method_of(spelled).is_empty():
 			spelled += "()"
-		# A vector or a transform has no element to call a method on, so a call it does not answer is
-		# refused without the advice about elements below.
+		# A vector or a transform has no element to call a method on, so a call it does not answer
+		# is refused without the advice about elements below.
 		var answers: bool = GdhPaths.can_read(reached["holder"], spelled)
 		var called_on: Variant = reached["holder"]
 		if (
@@ -496,7 +530,7 @@ func call_method(params: Dictionary) -> Dictionary:
 					"%s:%s takes no arguments" % [reached["called"], spelled]
 					if answers
 					else GdhPaths.nothing_there(reached["holder"], spelled, str(reached["called"]))
-				)
+				),
 			}
 		if args.is_empty() and answers:
 			var read_from: int = Time.get_ticks_usec()
@@ -518,7 +552,9 @@ func call_method(params: Dictionary) -> Dictionary:
 			if GdhPaths.can_read(reached["holder"], spelled)
 			else GdhPaths.nothing_there(reached["holder"], spelled, str(reached["called"]))
 		)
-		return {"type": "error", "message": "%s. %s" % [why, _instead_of_a_call(reached, method, sort)]}
+		return {
+			"type": "error", "message": "%s. %s" % [why, _instead_of_a_call(reached, method, sort)],
+		}
 	var holder: Object = reached["holder"]
 	var named: String = reached["name"]
 	# The method a call ends on is the one being called whether or not it carries the brackets a
@@ -532,7 +568,7 @@ func call_method(params: Dictionary) -> Dictionary:
 	if not_called.is_empty():
 		not_called = _not_a_method_to_call(holder, named, str(reached["called"]))
 	if not not_called.is_empty():
-		return {"type": "error", "message": not_called}
+		return { "type": "error", "message": not_called }
 	if not GdhPaths.method_of(named).is_empty():
 		named = GdhPaths.method_of(named)
 
@@ -542,10 +578,10 @@ func call_method(params: Dictionary) -> Dictionary:
 	# nowhere near the argument. A wrong argument costs a refusal, never the session's game.
 	var count: String = _argument_count_refused(holder, named, args.size())
 	if not count.is_empty():
-		return {"type": "error", "message": "%s.%s %s" % [reached["called"], named, count]}
+		return { "type": "error", "message": "%s.%s %s" % [reached["called"], named, count] }
 	var deserialized_args: Array = []
-	# The object arguments checked only against the engine class, by position from 1, for the refusal
-	# the engine may still make: see [method GdhValues.slot_declared].
+	# The object arguments checked only against the engine class, by position from 1, for the
+	# refusal the engine may still make: see [method GdhValues.slot_declared].
 	var by_engine_class: Dictionary = {}
 	# The enum arguments given a number none of their values has, said beside the answer: the engine
 	# passes any number on, and a write of the same number to a property already said so.
@@ -559,14 +595,19 @@ func call_method(params: Dictionary) -> Dictionary:
 				return {
 					"type": "error",
 					"message":
-					"%s.%s argument %d: %s" % [reached["called"], named, index + 1, named_object["message"]]
+					(
+						"%s.%s argument %d: %s"
+						% [reached["called"], named, index + 1, named_object["message"]]
+					),
 				}
 			var resolved: Object = named_object["object"]
 			if resolved != null and ClassDB.class_exists(declared):
 				by_engine_class[index + 1] = [declared, GdhValues.class_of(resolved)]
 			deserialized_args.append(named_object["object"])
 			continue
-		var argument: Dictionary = _argument_for(args[index], index, reached, named, node, node_path)
+		var argument: Dictionary = _argument_for(
+			args[index], index, reached, named, node, node_path
+		)
 		if argument.has("message"):
 			return argument
 		deserialized_args.append(argument["value"])
@@ -601,27 +642,27 @@ func call_method(params: Dictionary) -> Dictionary:
 			"%s.%s did not run: the engine refused the call: %s"
 			% [reached["called"], named, caught.refused.trim_suffix(".")]
 		)
-		var position: RegExMatch = RegEx.create_from_string(r"Cannot convert argument (\d+)").search(
-			caught.refused
+		var position: RegExMatch = (
+			RegEx.create_from_string(r"Cannot convert argument (\d+)").search(caught.refused)
 		)
 		if position != null and by_engine_class.has(int(position.get_string(1))):
 			var checked: Array = by_engine_class[int(position.get_string(1))]
 			message += (
 				(
-					". The parameter is declared as %s, which is also how the engine names a script class"
-					+ " with no class_name; if it is one, the object given has the right class and another"
-					+ " script: it is %s"
+					". The parameter is declared as %s, which is also how the engine names a "
+					+ "script class with no class_name; if it is one, the object given has the "
+					+ "right class and another script: it is %s"
 				)
 				% checked
 			)
-		return {"type": "error", "message": message + "."}
+		return { "type": "error", "message": message + "." }
 
 	var answer: Dictionary = {
 		"type": "method_result",
 		"path": node_path,
 		"method": method,
 		"result": _values.serialize(result),
-		"elapsed_usec": elapsed
+		"elapsed_usec": elapsed,
 	}
 	if awaited:
 		answer["awaited"] = true
@@ -629,7 +670,8 @@ func call_method(params: Dictionary) -> Dictionary:
 		answer["outside_declared"] = " ".join(outside)
 	_keep_reported(answer, "errors", caught.raised)
 	_keep_reported(answer, "warnings", caught.warned)
-	# Main.explode, ended at a null it called into, answered result 0 as if it had counted something.
+	# Main.explode, ended at a null it called into, answered result 0 as if it had counted
+	# something.
 	if caught.ended_at.has(named):
 		answer["ended_by_error_at"] = caught.ended_at[named]
 	var asked: Variant = params.get("properties")
@@ -648,9 +690,9 @@ static func _keep_reported(answer: Dictionary, field: String, reported: Array[St
 		answer[field + "_not_shown"] = reported.size() - ERRORS_KEPT
 
 
-## Why [param named], the last step of a call's method, names no method of [param holder] to call, or
-## "" when it does. Brackets on it holding arguments are refused rather than read: the arguments are
-## taken from args alone, so a call is never made with half of them in one place and half in the
+## Why [param named], the last step of a call's method, names no method of [param holder] to call,
+## or "" when it does. Brackets on it holding arguments are refused rather than read: the arguments
+## are taken from args alone, so a call is never made with half of them in one place and half in the
 ## other, or with the bracketed ones quietly dropped.
 static func _not_a_method_to_call(holder: Object, named: String, called: String) -> String:
 	var method: String = named
@@ -659,7 +701,10 @@ static func _not_a_method_to_call(holder: Object, named: String, called: String)
 		var in_brackets: Array = bracketed.get("args", [])
 		if bracketed.has("message") or not in_brackets.is_empty():
 			return (
-				"%s:%s: the method a call ends on takes its arguments under args, not in its brackets"
+				(
+					"%s:%s: the method a call ends on takes its arguments under args, not in its "
+					+ "brackets"
+				)
 				% [called, named]
 			)
 		method = GdhPaths.method_of(named)
@@ -675,12 +720,15 @@ static func _instance_method(holder: Object, method: String, called: String) ->
 		return ""
 	var script: Script = holder
 	for entry: Dictionary in script.get_script_method_list():
-		if str(entry.get("name", "")) != method or GdhRead.as_int(entry.get("flags", 0)) & METHOD_FLAG_STATIC:
+		if (
+			str(entry.get("name", "")) != method
+			or GdhRead.as_int(entry.get("flags", 0)) & METHOD_FLAG_STATIC
+		):
 			continue
 		return (
 			(
-				"%s.%s is not static, so it runs on an instance of the class: call it on a node carrying %s,"
-				+ " or on an object a path from one reaches"
+				"%s.%s is not static, so it runs on an instance of the class: call it on a node "
+				+ "carrying %s, or on an object a path from one reaches"
 			)
 			% [called, method, script.resource_path]
 		)
@@ -726,21 +774,25 @@ func _read_off_result(result: Variant, asked: Variant) -> Dictionary:
 				read_by_key[str(key)] = got
 			else:
 				entries.append([shown, got])
-		var shaped: Variant = read_by_key if texts else {"_type": "Dictionary", "entries": entries}
+		var shaped: Variant = read_by_key if texts else {
+			"_type": "Dictionary",
+			"entries": entries,
+		}
 		return _read_off_many(shaped, map.values(), "Dictionary", missing)
 	if result is Object and not is_instance_valid(result):
 		return {
-			"properties_note": "the call answered an object that has since been freed, so nothing was read"
+			"properties_note":
+			"the call answered an object that has since been freed, so nothing was read",
 		}
 	if not result is Object:
 		return {
 			"properties_note":
-			"the call answered %s, which has no properties to read" % type_string(typeof(result))
+			"the call answered %s, which has no properties to read" % type_string(typeof(result)),
 		}
 	var object: Object = result
 	var one: Dictionary = _read_off_object(object, asked)
 	missing = one["missing"]
-	var answered: Dictionary = {"result_properties": one["read"]}
+	var answered: Dictionary = { "result_properties": one["read"] }
 	if not missing.is_empty():
 		answered["result_properties_missing"] = missing
 	return answered
@@ -748,7 +800,9 @@ func _read_off_result(result: Variant, asked: Variant) -> Dictionary:
 
 ## What was read off one element of a list or a dictionary a call answered with, or null for one
 ## that is no object; why a name was not there goes into [param missing], led by [param named].
-func _read_off_element(element: Variant, named: String, asked: Variant, missing: Array[String]) -> Variant:
+func _read_off_element(
+	element: Variant, named: String, asked: Variant, missing: Array[String]
+) -> Variant:
 	if not element is Object:
 		return null
 	if not is_instance_valid(element):
@@ -770,9 +824,9 @@ static func _read_off_many(
 	if not elements.any(func(element: Variant) -> bool: return element is Object):
 		return {
 			"properties_note":
-			"the call answered %s with no object in it, so there are no properties to read" % shape
+			"the call answered %s with no object in it, so there are no properties to read" % shape,
 		}
-	var answered: Dictionary = {"result_properties": read}
+	var answered: Dictionary = { "result_properties": read }
 	if not missing.is_empty():
 		answered["result_properties_missing"] = missing
 	return answered
@@ -795,7 +849,7 @@ func _read_off_object(object: Object, asked: Variant) -> Dictionary:
 			missing.append(str(walked["message"]))
 		else:
 			read[path] = _values.serialize(walked["value"])
-	return {"read": read, "missing": missing}
+	return { "read": read, "missing": missing }
 
 
 ## The variables the script attached to [param object] declares, in the order it declares them.
@@ -817,13 +871,16 @@ static func _walk_from(object: Object, path: String) -> Dictionary:
 		if not GdhPaths.can_hold(holder):
 			return {
 				"message":
-				"%s holds %s, which has nothing to read %s off" % [called, type_string(typeof(holder)), named]
+				(
+					"%s holds %s, which has nothing to read %s off"
+					% [called, type_string(typeof(holder)), named]
+				),
 			}
 		if not GdhPaths.can_read(holder, named):
-			return {"message": GdhPaths.nothing_there(holder, named, called)}
+			return { "message": GdhPaths.nothing_there(holder, named, called) }
 		holder = GdhPaths.read_under(holder, named)
 		called = "%s:%s" % [called, named]
-	return {"value": holder}
+	return { "value": holder }
 
 
 ## Why [param given] arguments are the wrong number for [param method], or "" when they are not.
@@ -832,8 +889,9 @@ static func _walk_from(object: Object, path: String) -> Dictionary:
 ## null, and the method list says how many a method takes: its parameters less those with defaults,
 ## up to all of them, or any number past that for one taking varargs.
 static func _argument_count_refused(holder: Object, method: String, given: int) -> String:
-	# A node's method list runs to hundreds of entries, and walking it costs a couple of milliseconds
-	# of the game's frame; a call giving exactly the arguments the method declares needs no walk.
+	# A node's method list runs to hundreds of entries, and walking it costs a couple of
+	# milliseconds of the game's frame; a call giving exactly the arguments the method declares
+	# needs no walk.
 	if given == holder.get_method_argument_count(method):
 		return ""
 	for entry: Dictionary in GdhValues.methods_of(holder):
@@ -856,8 +914,8 @@ static func _argument_count_refused(holder: Object, method: String, given: int)
 	return ""
 
 
-## [method _object_named] with the path first, which is the order [method GdhValues.typed_like] calls
-## an element resolver in.
+## [method _object_named] with the path first, which is the order [method GdhValues.typed_like]
+## calls an element resolver in.
 func _element_object(
 	given: Variant, declared: String, script: Script, node: Node, node_path: String
 ) -> Dictionary:
@@ -886,7 +944,7 @@ func _object_named(
 	node: Node, node_path: String, given: Variant, declared: String, script: Script = null
 ) -> Dictionary:
 	if names_no_object(given):
-		return {"object": null}
+		return { "object": null }
 	var found: Dictionary = GdhPaths.object_at(_host.get_tree().root, node, node_path, given)
 	if found.has("message"):
 		return found
@@ -895,9 +953,13 @@ func _object_named(
 		var wanted: String = "an instance of %s" % GdhValues.script_named(script)
 		if not script.get_global_name().is_empty():
 			wanted = "a %s" % script.get_global_name()
-		return {"message": "%s is %s, not %s" % [str(given), GdhValues.class_of(instance), wanted]}
+		return {
+			"message": "%s is %s, not %s" % [str(given), GdhValues.class_of(instance), wanted],
+		}
 	if script == null and not declared.is_empty() and not GdhValues.is_a(instance, declared):
-		return {"message": "%s is %s, not a %s" % [str(given), GdhValues.class_of(instance), declared]}
+		return {
+			"message": "%s is %s, not a %s" % [str(given), GdhValues.class_of(instance), declared],
+		}
 	return found