gdharness 1.3.41 → 1.3.43

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

@@ -1,5 +1,4 @@
 extends RefCounted
-
 ## Godot values as JSON can carry them, and JSON back into the values the engine wants.
 ##
 ## This file is the one beside the operations, and `bun run sync:gd` copies it into each addon,
@@ -10,17 +9,14 @@ extends RefCounted
 
 const GdhRead = preload("reading.gd")
 const GdhShapes = preload("value_shapes.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]
-
 # 2^53. A JSON number is a double, and every whole number below this one in size has a double of
 # its own; from here on two or more share each double, so one arriving tells nobody which was sent.
-const EXACT: int = 9007199254740992
-
+const EXACT: int = 9_007_199_254_740_992
 # 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.
@@ -35,7 +31,6 @@ const LIST_TYPES: Array[int] = [
 	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
@@ -92,7 +87,6 @@ const SERIALISERS: Dictionary = {
 	TYPE_PACKED_VECTOR4_ARRAY: "_serialize_vector4s",
 	TYPE_PACKED_COLOR_ARRAY: "_serialize_colors",
 }
-
 # What each tag builds back into. The other half of the table above, and separate from it because
 # they are keyed differently: one by the type of a value in hand, the other by the name in a
 # dictionary that arrived from somewhere else.
@@ -144,7 +138,11 @@ func serialize_value(value: Variant) -> Variant:
 	# The fixed shapes carry their components as bare floats, so an infinite one in a Vector2 is
 	# tagged here, and a 32-bit one shortened; containers reach their members through this already.
 	var type: int = typeof(value)
-	return carried if type in [TYPE_ARRAY, TYPE_DICTIONARY] else _finite(carried, GdhRead.holds_singles(type))
+	return (
+		carried
+		if type in [TYPE_ARRAY, TYPE_DICTIONARY]
+		else _finite(carried, GdhRead.holds_singles(type))
+	)
 
 
 # [param carried] with every non-finite float in it tagged. JSON has no spelling for infinity or
@@ -172,7 +170,10 @@ func _finite(carried: Variant, single: bool = false) -> Variant:
 func _serialize_float(value: float) -> Variant:
 	if is_finite(value):
 		return value
-	return {"_type": "float", "value": "nan" if is_nan(value) else ("inf" if value > 0 else "-inf")}
+	return {
+		"_type": "float",
+		"value": "nan" if is_nan(value) else ("inf" if value > 0 else "-inf"),
+	}
 
 
 # A packed float array stays the JSON list it is unless something in it has no JSON spelling.
@@ -400,8 +401,9 @@ func fitted(value: Variant, type: int) -> Variant:
 	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
-	# A number or a truth value stays as sent where text is wanted, for the refusal to name. Converted,
-	# 1 arrived as the double it is in JSON and was saved as "1.0", which is not the text anyone sends.
+	# A number or a truth value stays as sent where text is wanted, for the refusal to name.
+	# Converted, 1 arrived as the double it is in JSON and was saved as "1.0", which is not the text
+	# anyone sends.
 	if type == TYPE_STRING and not rebuilt is String:
 		return rebuilt
 
@@ -426,9 +428,10 @@ func fitted(value: Variant, type: int) -> Variant:
 
 
 ## Why [param given], meant for an int, may not be the number that was sent, or "" when it is. A
-## JSON number is a double wherever it is read, so a whole number from 2^53 on arrives as the nearest
-## double to the one written: 9007199254740993 sent as a number arrives as 9007199254740992, and a
-## seed written that way would be stored as its neighbour with the answer saying it was written.
+## JSON number is a double wherever it is read, so a whole number from 2^53 on arrives as the
+## nearest double to the one written: 9007199254740993 sent as a number arrives as 9007199254740992,
+## and a seed written that way would be stored as its neighbour with the answer saying it was
+## written.
 static func inexact(given: Variant, type: int) -> String:
 	if type != TYPE_INT or (typeof(given) != TYPE_FLOAT and typeof(given) != TYPE_INT):
 		return ""
@@ -437,9 +440,9 @@ static func inexact(given: Variant, type: int) -> String:
 		return ""
 	return (
 		(
-			"%s is 2^53 or more, where a JSON number holds a whole number only to the nearest double,"
-			+ ' so it may not be the number sent: send the digits as {"_type": "int", "value": "..."}'
-			+ ", the form a read answers with"
+			"%s is 2^53 or more, where a JSON number holds a whole number only to the nearest "
+			+ 'double, so it may not be the number sent: send the digits as {"_type": "int", '
+			+ '"value": "..."}, the form a read answers with'
 		)
 		% String.num(number, 0)
 	)
@@ -450,51 +453,59 @@ func _serialize_nil(_value: Variant) -> Variant:
 
 
 func _serialize_vector2(value: Vector2) -> Dictionary:
-	return {"x": value.x, "y": value.y, "_type": "Vector2"}
+	return { "x": value.x, "y": value.y, "_type": "Vector2" }
 
 
 func _serialize_vector2i(value: Vector2i) -> Dictionary:
-	return {"x": value.x, "y": value.y, "_type": "Vector2i"}
+	return { "x": value.x, "y": value.y, "_type": "Vector2i" }
 
 
 func _serialize_vector3(value: Vector3) -> Dictionary:
-	return {"x": value.x, "y": value.y, "z": value.z, "_type": "Vector3"}
+	return { "x": value.x, "y": value.y, "z": value.z, "_type": "Vector3" }
 
 
 func _serialize_vector3i(value: Vector3i) -> Dictionary:
-	return {"x": value.x, "y": value.y, "z": value.z, "_type": "Vector3i"}
+	return { "x": value.x, "y": value.y, "z": value.z, "_type": "Vector3i" }
 
 
 func _serialize_vector4(value: Vector4) -> Dictionary:
-	return {"x": value.x, "y": value.y, "z": value.z, "w": value.w, "_type": "Vector4"}
+	return { "x": value.x, "y": value.y, "z": value.z, "w": value.w, "_type": "Vector4" }
 
 
 func _serialize_vector4i(value: Vector4i) -> Dictionary:
-	return {"x": value.x, "y": value.y, "z": value.z, "w": value.w, "_type": "Vector4i"}
+	return { "x": value.x, "y": value.y, "z": value.z, "w": value.w, "_type": "Vector4i" }
 
 
 func _serialize_rect2(value: Rect2) -> Dictionary:
 	return {
-		"position": serialize_value(value.position), "size": serialize_value(value.size), "_type": "Rect2"
+		"position": serialize_value(value.position),
+		"size": serialize_value(value.size),
+		"_type": "Rect2",
 	}
 
 
 func _serialize_rect2i(value: Rect2i) -> Dictionary:
 	return {
-		"position": serialize_value(value.position), "size": serialize_value(value.size), "_type": "Rect2i"
+		"position": serialize_value(value.position),
+		"size": serialize_value(value.size),
+		"_type": "Rect2i",
 	}
 
 
 func _serialize_plane(value: Plane) -> Dictionary:
-	return {"normal": serialize_value(value.normal), "d": value.d, "_type": "Plane"}
+	return { "normal": serialize_value(value.normal), "d": value.d, "_type": "Plane" }
 
 
 func _serialize_quaternion(value: Quaternion) -> Dictionary:
-	return {"x": value.x, "y": value.y, "z": value.z, "w": value.w, "_type": "Quaternion"}
+	return { "x": value.x, "y": value.y, "z": value.z, "w": value.w, "_type": "Quaternion" }
 
 
 func _serialize_aabb(value: AABB) -> Dictionary:
-	return {"position": serialize_value(value.position), "size": serialize_value(value.size), "_type": "AABB"}
+	return {
+		"position": serialize_value(value.position),
+		"size": serialize_value(value.size),
+		"_type": "AABB",
+	}
 
 
 func _serialize_basis(value: Basis) -> Dictionary:
@@ -502,7 +513,7 @@ func _serialize_basis(value: Basis) -> Dictionary:
 		"x": serialize_value(value.x),
 		"y": serialize_value(value.y),
 		"z": serialize_value(value.z),
-		"_type": "Basis"
+		"_type": "Basis",
 	}
 
 
@@ -511,13 +522,15 @@ func _serialize_transform2d(value: Transform2D) -> Dictionary:
 		"origin": serialize_value(value.origin),
 		"x": serialize_value(value.x),
 		"y": serialize_value(value.y),
-		"_type": "Transform2D"
+		"_type": "Transform2D",
 	}
 
 
 func _serialize_transform3d(value: Transform3D) -> Dictionary:
 	return {
-		"origin": serialize_value(value.origin), "basis": serialize_value(value.basis), "_type": "Transform3D"
+		"origin": serialize_value(value.origin),
+		"basis": serialize_value(value.basis),
+		"_type": "Transform3D",
 	}
 
 
@@ -527,22 +540,22 @@ func _serialize_projection(value: Projection) -> Dictionary:
 		"y": serialize_value(value.y),
 		"z": serialize_value(value.z),
 		"w": serialize_value(value.w),
-		"_type": "Projection"
+		"_type": "Projection",
 	}
 
 
 func _serialize_color(value: Color) -> Dictionary:
-	return {"r": value.r, "g": value.g, "b": value.b, "a": value.a, "_type": "Color"}
+	return { "r": value.r, "g": value.g, "b": value.b, "a": value.a, "_type": "Color" }
 
 
 func _serialize_node_path(value: NodePath) -> Dictionary:
-	return {"path": str(value), "_type": "NodePath"}
+	return { "path": str(value), "_type": "NodePath" }
 
 
 # By its id, which is all an RID is from outside the server holding it, and which builds it back:
 # a viewport's RID read off one call is what RenderingServer's render timing takes in the next.
 func _serialize_rid(value: RID) -> Dictionary:
-	return {"id": _serialize_int(value.get_id()), "_type": "RID"}
+	return { "id": _serialize_int(value.get_id()), "_type": "RID" }
 
 
 # A whole number from 2^53 on as its digits, because JSON numbers are doubles on the server's side
@@ -552,7 +565,7 @@ func _serialize_rid(value: RID) -> Dictionary:
 func _serialize_int(value: int) -> Variant:
 	if value > -EXACT and value < EXACT:
 		return value
-	return {"_type": "int", "value": str(value)}
+	return { "_type": "int", "value": str(value) }
 
 
 # A packed list of 64-bit numbers stays the JSON list it is unless something in it is too large for
@@ -570,7 +583,7 @@ func _serialize_ints(value: PackedInt64Array) -> Variant:
 # A bound method, said in the terms a caller could act on: what it is on, and what it is called.
 # It cannot be rebuilt from here, and saying so is the answer rather than a silent null.
 func _serialize_callable(value: Callable) -> Dictionary:
-	var described: Dictionary = {"method": str(value.get_method()), "_type": "Callable"}
+	var described: Dictionary = { "method": str(value.get_method()), "_type": "Callable" }
 	var holder: Object = value.get_object()
 	if holder != null:
 		described["object"] = _describe_object(holder)
@@ -578,7 +591,7 @@ func _serialize_callable(value: Callable) -> Dictionary:
 
 
 func _serialize_signal(value: Signal) -> Dictionary:
-	var described: Dictionary = {"name": str(value.get_name()), "_type": "Signal"}
+	var described: Dictionary = { "name": str(value.get_name()), "_type": "Signal" }
 	var holder: Object = value.get_object()
 	if holder != null:
 		described["object"] = _describe_object(holder)
@@ -589,12 +602,14 @@ func _serialize_signal(value: Signal) -> Dictionary:
 ## int or Vector2 key was answered as its text, and a dictionary read and written back had its keys
 ## replaced by words: `{1: "a"}` came back as `{"1": "a"}`.
 func _serialize_dictionary(value: Dictionary) -> Dictionary:
-	var texts: bool = value.keys().all(func(key: Variant) -> bool: return key is String or key is StringName)
+	var texts: bool = value.keys().all(
+		func(key: Variant) -> bool: return key is String or key is StringName
+	)
 	if not texts:
 		var entries: Array = []
 		for key: Variant in value:
 			entries.append([serialize_value(key), serialize_value(value[key])])
-		return {"_type": "Dictionary", "entries": entries}
+		return { "_type": "Dictionary", "entries": entries }
 	var serialised: Dictionary = {}
 	for key: Variant in value:
 		serialised[str(key)] = serialize_value(value[key])
@@ -612,7 +627,7 @@ func _serialize_array(value: Array) -> Array:
 # TileMapLayer with nothing painted yet, so a read of one carried an engine error in its answer.
 func _serialize_bytes(value: PackedByteArray) -> Dictionary:
 	var text: String = "" if value.is_empty() else Marshalls.raw_to_base64(value)
-	return {"base64": text, "size": value.size(), "_type": "PackedByteArray"}
+	return { "base64": text, "size": value.size(), "_type": "PackedByteArray" }
 
 
 # The packed vector and colour arrays, each element serialised the way one of them on its own is.
@@ -660,7 +675,7 @@ func _serialize_object(value: Object) -> Variant:
 		if resource.resource_path.is_empty() or resource.resource_path.contains("::"):
 			return _describe_built_in(resource)
 		var filed: Dictionary = {
-			"path": resource.resource_path, "class": resource.get_class(), "_type": "Resource"
+			"path": resource.resource_path, "class": resource.get_class(), "_type": "Resource",
 		}
 		# The engine class of a resource with a script is the one its script extends, so a Stats
 		# file read as a Resource and nothing said it was a Stats.
@@ -673,7 +688,7 @@ func _serialize_object(value: Object) -> Variant:
 	if value is Node:
 		var node: Node = value
 		if node.is_inside_tree():
-			return {"path": str(node.get_path()), "class": node.get_class(), "_type": "Node"}
+			return { "path": str(node.get_path()), "class": node.get_class(), "_type": "Node" }
 	return _describe_object(value)
 
 
@@ -683,16 +698,16 @@ func _serialize_object(value: Object) -> Variant:
 ## written back.
 func _describe_built_in(resource: Resource) -> Dictionary:
 	if _describing.has(resource):
-		return {"class": resource.get_class(), "_type": "Resource"}
+		return { "class": resource.get_class(), "_type": "Resource" }
 	_describing.append(resource)
-	var described: Dictionary = {"_type": resource.get_class()}
+	var described: Dictionary = { "_type": resource.get_class() }
 	var attached: Variant = resource.get_script()
 	var script: Script = null
 	if attached is Script:
 		script = attached
 		# By the class its script declares, which a write takes as the _type and which says what it
-		# is: as Resource with the script beside it, one answer named a Shop's built-in item that way
-		# and the file item beside it as an Item.
+		# is: as Resource with the script beside it, one answer named a Shop's built-in item that
+		# way and the file item beside it as an Item.
 		if script.get_global_name().is_empty():
 			described["script"] = serialize_value(script)
 		else:
@@ -741,11 +756,17 @@ static func _fresh(script: Script) -> Object:
 ## away from its default. As a bare resource it was its class and nothing else, so an input action
 ## read back from project.godot could not say whether it was bound to Space or to a joypad button.
 func _describe_input_event(event: InputEvent) -> Dictionary:
-	var described: Dictionary = {"class": event.get_class(), "_type": "Resource", "text": event.as_text()}
+	var described: Dictionary = {
+		"class": event.get_class(), "_type": "Resource", "text": event.as_text(),
+	}
 	for property: Dictionary in event.get_property_list():
 		var usage: int = property.get("usage", 0)
 		var name: String = str(property.get("name", ""))
-		if not (usage & PROPERTY_USAGE_STORAGE) or name.begins_with("resource_") or name == "script":
+		if (
+			not (usage & PROPERTY_USAGE_STORAGE)
+			or name.begins_with("resource_")
+			or name == "script"
+		):
 			continue
 		var held: Variant = event.get(name)
 		if held == ClassDB.class_get_property_default_value(event.get_class(), name):
@@ -764,7 +785,7 @@ func _describe_input_event(event: InputEvent) -> Dictionary:
 ## different per object. None of it is invented: every field is left out when there is nothing to
 ## put in it, because a key holding "" is a worse answer than a key that is not there.
 func _describe_object(value: Object) -> Dictionary:
-	var described: Dictionary = {"class": value.get_class(), "_type": "Object"}
+	var described: Dictionary = { "class": value.get_class(), "_type": "Object" }
 	# Asked as a Variant and narrowed, because get_script answers one and an object without a
 	# script answers null: casting that to Script is the unsafe cast the engine refuses to compile.
 	var attached: Variant = value.get_script()
@@ -892,7 +913,10 @@ func _build_transform3d(fields: Dictionary) -> Transform3D:
 
 func _build_projection(fields: Dictionary) -> Projection:
 	return Projection(
-		_vector4_at(fields, "x"), _vector4_at(fields, "y"), _vector4_at(fields, "z"), _vector4_at(fields, "w")
+		_vector4_at(fields, "x"),
+		_vector4_at(fields, "y"),
+		_vector4_at(fields, "z"),
+		_vector4_at(fields, "w")
 	)
 
 

package/build/godot/addons/gdharness_editor/setting_reads.gd

@@ -1,5 +1,4 @@
 extends RefCounted
-
 ## Project settings read the same way headless and from the open editor, because the two are one
 ## question asked of two places: a field one of them left out read as the editor and the file
 ## disagreeing about something they agree about.
@@ -12,7 +11,7 @@ const GdhSerialisation = preload("serialisation.gd")
 ## the feature overrides that replace it in some builds.
 static func one(setting_path: String, values: GdhSerialisation) -> Dictionary:
 	var result: Dictionary = {
-		"setting_path": setting_path, "exists": ProjectSettings.has_setting(setting_path)
+		"setting_path": setting_path, "exists": ProjectSettings.has_setting(setting_path),
 	}
 
 	if result["exists"]:
@@ -66,8 +65,8 @@ static func under(prefix: String, values: GdhSerialisation) -> Dictionary:
 			"type": type_string(kind),
 			"value": values.serialize_value(value),
 		}
-		# As a single get says it, so a family read can be told apart into what the project sets
-		# and the engine's defaults: "input/" is ninety actions the engine ships and the project's few.
+		# As a single get says it, so a family read can be told apart into what the project sets and
+		# the engine's defaults: "input/" is ninety actions the engine ships and the project's few.
 		var default_value: Variant = ProjectSettings.property_get_revert(name)
 		if default_value != null:
 			described["at_default"] = value == default_value
@@ -76,8 +75,10 @@ static func under(prefix: String, values: GdhSerialisation) -> Dictionary:
 			described["override_of"] = base
 		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}
+	found.sort_custom(
+		func(a: Dictionary, b: Dictionary) -> bool: return a["setting"] < b["setting"]
+	)
+	return { "prefix": prefix, "count": found.size(), "settings": found }
 
 
 ## The setting [param setting_path] overrides for builds with one feature, as

package/build/godot/addons/gdharness_editor/tool_executor.gd

@@ -1,6 +1,5 @@
 @tool
 extends Node
-
 ## Routes each command the server sends to the tool module that answers it. The modules are
 ## preloaded rather than looked up on disk at runtime, so a missing one fails to parse here
 ## instead of leaving a command silently unanswered.
@@ -20,7 +19,6 @@ const GdhFilesystemTools = preload("tools/filesystem_tools.gd")
 const GdhProfileTools = preload("tools/profile_tools.gd")
 
 var _editor_plugin: EditorPlugin = null
-
 var _scene_tools: GdhSceneTools = null
 var _signal_tools: GdhSignalTools = null
 var _resource_tools: GdhResourceTools = null
@@ -33,7 +31,6 @@ var _class_tools: GdhClassTools = null
 var _settings_tools: GdhSettingsTools = null
 var _filesystem_tools: GdhFilesystemTools = null
 var _profile_tools: GdhProfileTools = null
-
 var _tool_map: Dictionary = {}
 var _initialized: bool = false
 
@@ -169,14 +166,14 @@ func _init_tools() -> void:
 
 func execute_tool(tool_name: String, args: Dictionary) -> Dictionary:
 	if not _tool_map.has(tool_name):
-		return {"ok": false, "error": "Unknown tool: " + tool_name}
+		return { "ok": false, "error": "Unknown tool: " + tool_name }
 
 	var handler: Array = _tool_map[tool_name]
 	var node: Node = handler[0]
 	var method: String = handler[1]
 
 	if not node.has_method(method):
-		return {"ok": false, "error": "Tool method not found: %s.%s" % [node.name, method]}
+		return { "ok": false, "error": "Tool method not found: %s.%s" % [node.name, method] }
 
 	GdhSceneFile.also_saved.clear()
 	var result: Variant = node.call(method, args)
@@ -187,4 +184,4 @@ func execute_tool(tool_name: String, args: Dictionary) -> Dictionary:
 			GdhSceneFile.also_saved.clear()
 		return answered
 
-	return {"ok": false, "error": "Invalid tool result from: " + tool_name}
+	return { "ok": false, "error": "Invalid tool result from: " + tool_name }

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

@@ -1,6 +1,5 @@
 @tool
 extends "animation_tools.gd"
-
 ## The states and transitions of an AnimationTree's state machines, beside the players and tracks
 ## the script it extends edits, whose helpers it shares.
 
@@ -16,9 +15,9 @@ func add_animation_state(args: Dictionary) -> Dictionary:
 	var state_name: String = str(args.get("stateName", ""))
 	var animation_name: String = str(args.get("animationName", ""))
 	if state_name.is_empty():
-		return {"ok": false, "error": "Missing stateName"}
+		return { "ok": false, "error": "Missing stateName" }
 	if animation_name.is_empty():
-		return {"ok": false, "error": "Missing animationName"}
+		return { "ok": false, "error": "Missing animationName" }
 	var machine: Array = _machine_at(args)
 	if machine[1] == null:
 		return machine[3]
@@ -29,7 +28,8 @@ func add_animation_state(args: Dictionary) -> Dictionary:
 	# are in use in every state machine.
 	if sm.has_node(StringName(state_name)):
 		return scene.refuse("The state machine already has a state named %s." % state_name)
-	var player: AnimationPlayer = anim_tree.get_node_or_null(anim_tree.anim_player) as AnimationPlayer
+	var reached: Node = anim_tree.get_node_or_null(anim_tree.anim_player)
+	var player: AnimationPlayer = reached as AnimationPlayer
 	var found: bool = player != null and player.has_animation(StringName(animation_name))
 
 	var anim_node: AnimationNodeAnimation = AnimationNodeAnimation.new()
@@ -57,7 +57,11 @@ func add_animation_state(args: Dictionary) -> Dictionary:
 	}
 	# Written all the same, as the editor writes one: a state machine is often laid out before its
 	# animations are made, and refusing it stopped a tree being built in that order.
-	if player != null and not found:
+	if player == null:
+		answer["animationMissing"] = GdhAnimationReads.no_player(
+			str(anim_tree.anim_player), reached
+		)
+	elif not found:
 		answer["animationMissing"] = GdhAnimationReads.missing_animation(
 			player, scene.path_of(player), animation_name
 		)
@@ -73,14 +77,14 @@ func connect_animation_states(args: Dictionary) -> Dictionary:
 	var to_state: String = str(args.get("toState", ""))
 	var transition_type: String = str(args.get("transitionType", "immediate"))
 	var advance_condition: String = str(args.get("advanceCondition", ""))
-	# Auto where it is the only mode that does what was asked: a condition is checked only on an auto
-	# transition, and a machine leaves Start only through one. Written as the default enabled, both
-	# did nothing, and the machine sat in Start with its conditions true.
+	# Auto where it is the only mode that does what was asked: a condition is checked only on an
+	# auto transition, and a machine leaves Start only through one. Written as the default enabled,
+	# both did nothing, and the machine sat in Start with its conditions true.
 	var auto: bool = not advance_condition.is_empty() or from_state == "Start"
 	var advance_mode: String = str(args.get("advanceMode", "auto" if auto else "enabled"))
 
 	if from_state.is_empty() or to_state.is_empty():
-		return {"ok": false, "error": "Missing fromState or toState"}
+		return { "ok": false, "error": "Missing fromState or toState" }
 	var advances: Dictionary = {
 		"auto": AnimationNodeStateMachineTransition.ADVANCE_MODE_AUTO,
 		"enabled": AnimationNodeStateMachineTransition.ADVANCE_MODE_ENABLED,
@@ -89,7 +93,7 @@ func connect_animation_states(args: Dictionary) -> Dictionary:
 	if not advances.has(advance_mode):
 		return {
 			"ok": false,
-			"error": "Unsupported advanceMode: %s; it is auto, enabled or disabled" % advance_mode
+			"error": "Unsupported advanceMode: %s; it is auto, enabled or disabled" % advance_mode,
 		}
 	if not advance_condition.is_empty() and advance_mode != "auto":
 		return {
@@ -97,11 +101,12 @@ func connect_animation_states(args: Dictionary) -> Dictionary:
 			"error":
 			(
 				(
-					"advanceCondition %s would never advance a transition whose advanceMode is %s: the engine"
-					+ " checks a condition only on an auto one. Leave advanceMode out, or give auto"
+					"advanceCondition %s would never advance a transition whose advanceMode is %s: "
+					+ "the engine checks a condition only on an auto one. Leave advanceMode out, "
+					+ "or give auto"
 				)
 				% [advance_condition, advance_mode]
-			)
+			),
 		}
 	var modes: Dictionary = {
 		"sync": AnimationNodeStateMachineTransition.SWITCH_MODE_SYNC,
@@ -109,7 +114,7 @@ func connect_animation_states(args: Dictionary) -> Dictionary:
 		"immediate": AnimationNodeStateMachineTransition.SWITCH_MODE_IMMEDIATE,
 	}
 	if not modes.has(transition_type):
-		return {"ok": false, "error": "Unsupported transitionType: " + transition_type}
+		return { "ok": false, "error": "Unsupported transitionType: " + transition_type }
 	var transition: AnimationNodeStateMachineTransition = AnimationNodeStateMachineTransition.new()
 	transition.switch_mode = (
 		GdhRead.as_int(modes[transition_type]) as AnimationNodeStateMachineTransition.SwitchMode
@@ -137,14 +142,16 @@ func connect_animation_states(args: Dictionary) -> Dictionary:
 		scene,
 		Callable(),
 		files,
-		{"ok": true, "from": from_state, "to": to_state, "advanceMode": advance_mode}
+		{ "ok": true, "from": from_state, "to": to_state, "advanceMode": advance_mode }
 	)
 
 
 ## Why [param sm] cannot take a transition from [param from_state] to [param to_state], or "".
 ## Each is a condition add_transition fails on with only a line in the editor's log, and the
 ## transition was answered as made.
-func _transition_problem(sm: AnimationNodeStateMachine, from_state: String, to_state: String) -> String:
+func _transition_problem(
+	sm: AnimationNodeStateMachine, from_state: String, to_state: String
+) -> String:
 	for state: String in [from_state, to_state]:
 		if not sm.has_node(StringName(state)):
 			return _no_state(sm, state)
@@ -169,7 +176,8 @@ static func _no_state(sm: AnimationNodeStateMachine, state_name: String) -> Stri
 	var close: PackedStringArray = GdhRead.nearest(state_name, states)
 	if not close.is_empty():
 		return (
-			"%s; the nearest it has %s %s." % [said, "is" if close.size() == 1 else "are", ", ".join(close)]
+			"%s; the nearest it has %s %s."
+			% [said, "is" if close.size() == 1 else "are", ", ".join(close)]
 		)
 	return "%s; its states are %s." % [said, ", ".join(states)]
 
@@ -180,9 +188,9 @@ func _machine_at(args: Dictionary) -> Array:
 	var scene_path: String = GdhSceneFile.res_path("", str(args.get("scenePath", "")))
 	var anim_tree_path: String = str(args.get("animTreePath", ""))
 	if scene_path.strip_edges() == "res://":
-		return [null, null, {}, {"ok": false, "error": "Missing scenePath"}]
+		return [null, null, {}, { "ok": false, "error": "Missing scenePath" }]
 	if anim_tree_path.is_empty():
-		return [null, null, {}, {"ok": false, "error": "Missing animTreePath"}]
+		return [null, null, {}, { "ok": false, "error": "Missing animTreePath" }]
 	var opened: Array = _open_at(scene_path, anim_tree_path, "AnimationTree")
 	var scene: GdhSceneFile = opened[0]
 	if opened[1] == null:
@@ -203,14 +211,16 @@ func _machine_at(args: Dictionary) -> Array:
 func remove_animation_state(args: Dictionary) -> Dictionary:
 	var state_name: String = str(args.get("stateName", ""))
 	if state_name.is_empty():
-		return {"ok": false, "error": "Missing stateName"}
+		return { "ok": false, "error": "Missing stateName" }
 	var found: Array = _machine_at(args)
 	if found[1] == null:
 		return found[3]
 	var scene: GdhSceneFile = found[0]
 	var sm: AnimationNodeStateMachine = found[1]
 	if state_name in ["Start", "End"]:
-		return scene.refuse("%s is part of every state machine, so it cannot be removed." % state_name)
+		return scene.refuse(
+			"%s is part of every state machine, so it cannot be removed." % state_name
+		)
 	if not sm.has_node(StringName(state_name)):
 		return scene.refuse(_no_state(sm, state_name))
 	var dropped: Array = []
@@ -218,7 +228,7 @@ func remove_animation_state(args: Dictionary) -> Dictionary:
 		var from: String = str(sm.get_transition_from(index))
 		var to: String = str(sm.get_transition_to(index))
 		if state_name in [from, to]:
-			dropped.append({"from": from, "to": to})
+			dropped.append({ "from": from, "to": to })
 	sm.remove_node(StringName(state_name))
 	if sm.has_node(StringName(state_name)):
 		return scene.refuse("The state machine did not let go of %s." % state_name)
@@ -228,9 +238,8 @@ func remove_animation_state(args: Dictionary) -> Dictionary:
 				"The state machine kept a transition of %s after the state went." % state_name
 			)
 	var files: Dictionary = found[2]
-	return _finish(
-		scene, Callable(), files, {"ok": true, "removed": state_name, "transitionsRemoved": dropped}
-	)
+	var answer: Dictionary = { "ok": true, "removed": state_name, "transitionsRemoved": dropped }
+	return _finish(scene, Callable(), files, answer)
 
 
 ## Takes out the transition from one state to another.
@@ -238,7 +247,7 @@ func disconnect_animation_states(args: Dictionary) -> Dictionary:
 	var from_state: String = str(args.get("fromState", ""))
 	var to_state: String = str(args.get("toState", ""))
 	if from_state.is_empty() or to_state.is_empty():
-		return {"ok": false, "error": "Missing fromState or toState"}
+		return { "ok": false, "error": "Missing fromState or toState" }
 	var found: Array = _machine_at(args)
 	if found[1] == null:
 		return found[3]
@@ -255,9 +264,13 @@ func disconnect_animation_states(args: Dictionary) -> Dictionary:
 		var said: String = "There is no transition from %s to %s" % [from_state, to_state]
 		if leaving.is_empty():
 			return scene.refuse("%s; none leaves %s." % [said, from_state])
-		return scene.refuse("%s; the ones leaving %s go to %s." % [said, from_state, ", ".join(leaving)])
+		return scene.refuse(
+			"%s; the ones leaving %s go to %s." % [said, from_state, ", ".join(leaving)]
+		)
 	sm.remove_transition(StringName(from_state), StringName(to_state))
 	if sm.has_transition(StringName(from_state), StringName(to_state)):
 		return scene.refuse("The state machine did not let go of the transition.")
 	var files: Dictionary = found[2]
-	return _finish(scene, Callable(), files, {"ok": true, "removed": {"from": from_state, "to": to_state}})
+	return _finish(
+		scene, Callable(), files, { "ok": true, "removed": { "from": from_state, "to": to_state } }
+	)