gdharness 1.3.0 → 1.3.1

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

@@ -8,7 +8,8 @@ extends RefCounted
 ## before: the same Vector2 came back three ways depending on which tool was asked, and a caller
 ## reading a property off the editor could not feed it back to the game.
 
-const Read = preload("reading.gd")
+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
@@ -120,35 +121,6 @@ const BUILDERS: Dictionary = {
 	"Dictionary": "_build_dictionary",
 }
 
-# What each tag has to carry before it is built. A tag naming a type whose keys are not there is a
-# tag somebody wrote by mistake or wrote for a different shape, and building one out of defaults
-# answers with a Transform2D of zeros where the caller meant something else entirely. Unbuilt, it
-# comes back as it arrived, and whoever asked can read it against the type they were expecting.
-const REQUIRED: Dictionary = {
-	"Vector2": [["x", "y"]],
-	"Vector2i": [["x", "y"]],
-	"Vector3": [["x", "y", "z"]],
-	"Vector3i": [["x", "y", "z"]],
-	"Vector4": [["x", "y", "z", "w"]],
-	"Vector4i": [["x", "y", "z", "w"]],
-	"Rect2": [["position", "size"], ["x", "y", "width", "height"]],
-	"Rect2i": [["position", "size"], ["x", "y", "width", "height"]],
-	"Plane": [["normal", "d"]],
-	"Quaternion": [["x", "y", "z", "w"]],
-	"AABB": [["position", "size"]],
-	"Basis": [["x", "y", "z"]],
-	"Transform2D": [["x", "y", "origin"]],
-	"Transform3D": [["basis", "origin"]],
-	"Projection": [["x", "y", "z", "w"]],
-	"Color": [["r", "g", "b"]],
-	"NodePath": [["path"]],
-	"PackedByteArray": [["base64"]],
-	"float": [["value"]],
-	"int": [["value"]],
-	"RID": [["id"]],
-	"Dictionary": [["entries"]],
-}
-
 
 # Converts a Godot value into something JSON can carry. A type with no entry in the table
 # passes through as itself, which is what the JSON-native ones want.
@@ -246,8 +218,8 @@ func deserialize_value(value: Variant) -> Variant:
 	# under the target project's warning levels, so one such project lost every headless call.
 	var tag: String = str(fields["_type"])
 	var builder: String = BUILDERS.get(tag, "")
-	var needed: Array = REQUIRED.get(tag, [])
-	if builder.is_empty() or not _carries(fields, needed):
+	var spare: Array = GdhShapes.spare(fields, tag)
+	if builder.is_empty() or not spare.any(func(left: Array) -> bool: return left.is_empty()):
 		return fields
 	if tag == "float" and str(fields["value"]) not in ["inf", "-inf", "nan"]:
 		return fields
@@ -430,6 +402,11 @@ func fitted(value: Variant, type: int) -> Variant:
 	if rebuilt is Array and LIST_TYPES.has(type):
 		return type_convert(rebuilt, type)
 
+	# The inspector and every colour picker give a colour as its html code. Anything else stays the
+	# text it is, for the refusal to name.
+	if type == TYPE_COLOR and rebuilt is String and Color.html_is_valid(str(rebuilt)):
+		return Color.html(str(rebuilt))
+
 	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
@@ -441,7 +418,7 @@ func fitted(value: Variant, type: int) -> Variant:
 
 	if rebuilt is String and type != TYPE_STRING:
 		var text: String = rebuilt
-		var parsed: Variant = Read.json_or_null(text)
+		var parsed: Variant = GdhRead.json_or_null(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
@@ -461,7 +438,7 @@ func fitted(value: Variant, type: int) -> Variant:
 static func inexact(given: Variant, type: int) -> String:
 	if type != TYPE_INT or (typeof(given) != TYPE_FLOAT and typeof(given) != TYPE_INT):
 		return ""
-	var number: float = Read.as_float(given)
+	var number: float = GdhRead.as_float(given)
 	if not is_finite(number) or absf(number) < EXACT:
 		return ""
 	return (
@@ -474,34 +451,6 @@ static func inexact(given: Variant, type: int) -> String:
 	)
 
 
-## How a value of [param type] is written to be read as one, for a refusal to name, or empty for a
-## type that is not built from fields. A refusal naming only the two types left a caller to find
-## the shape in the description of another op.
-static func written_as(type: int) -> String:
-	var tag: String = type_string(type)
-	var alternatives: Array = REQUIRED.get(tag, [])
-	if alternatives.is_empty() or tag in ["float", "int", "Dictionary"]:
-		return ""
-	var keys: Array = alternatives[0]
-	var parts: Array[String] = []
-	for key: Variant in keys:
-		parts.append('"%s": ...' % key)
-	return "{%s}" % ", ".join(parts)
-
-
-## 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
-## four numbers the editor's own tools answered with before the serialisers were made one, which a
-## caller may have kept.
-func _carries(fields: Dictionary, alternatives: Array) -> bool:
-	for alternative: Variant in alternatives:
-		var keys: Array = alternative
-		if keys.all(func(key: Variant) -> bool: return fields.has(key)):
-			return true
-	return false
-
-
 func _serialize_nil(_value: Variant) -> Variant:
 	return null
 
@@ -769,42 +718,44 @@ func _describe_object(value: Object) -> Dictionary:
 
 
 func _build_vector2(fields: Dictionary) -> Vector2:
-	return Vector2(Read.as_float(fields.get("x", 0)), Read.as_float(fields.get("y", 0)))
+	return Vector2(GdhRead.as_float(fields.get("x", 0)), GdhRead.as_float(fields.get("y", 0)))
 
 
 func _build_vector2i(fields: Dictionary) -> Vector2i:
-	return Vector2i(Read.as_int(fields.get("x", 0)), Read.as_int(fields.get("y", 0)))
+	return Vector2i(GdhRead.as_int(fields.get("x", 0)), GdhRead.as_int(fields.get("y", 0)))
 
 
 func _build_vector3(fields: Dictionary) -> Vector3:
 	return Vector3(
-		Read.as_float(fields.get("x", 0)),
-		Read.as_float(fields.get("y", 0)),
-		Read.as_float(fields.get("z", 0))
+		GdhRead.as_float(fields.get("x", 0)),
+		GdhRead.as_float(fields.get("y", 0)),
+		GdhRead.as_float(fields.get("z", 0))
 	)
 
 
 func _build_vector3i(fields: Dictionary) -> Vector3i:
 	return Vector3i(
-		Read.as_int(fields.get("x", 0)), Read.as_int(fields.get("y", 0)), Read.as_int(fields.get("z", 0))
+		GdhRead.as_int(fields.get("x", 0)),
+		GdhRead.as_int(fields.get("y", 0)),
+		GdhRead.as_int(fields.get("z", 0))
 	)
 
 
 func _build_vector4(fields: Dictionary) -> Vector4:
 	return Vector4(
-		Read.as_float(fields.get("x", 0)),
-		Read.as_float(fields.get("y", 0)),
-		Read.as_float(fields.get("z", 0)),
-		Read.as_float(fields.get("w", 0))
+		GdhRead.as_float(fields.get("x", 0)),
+		GdhRead.as_float(fields.get("y", 0)),
+		GdhRead.as_float(fields.get("z", 0)),
+		GdhRead.as_float(fields.get("w", 0))
 	)
 
 
 func _build_vector4i(fields: Dictionary) -> Vector4i:
 	return Vector4i(
-		Read.as_int(fields.get("x", 0)),
-		Read.as_int(fields.get("y", 0)),
-		Read.as_int(fields.get("z", 0)),
-		Read.as_int(fields.get("w", 0))
+		GdhRead.as_int(fields.get("x", 0)),
+		GdhRead.as_int(fields.get("y", 0)),
+		GdhRead.as_int(fields.get("z", 0)),
+		GdhRead.as_int(fields.get("w", 0))
 	)
 
 
@@ -813,10 +764,10 @@ func _build_vector4i(fields: Dictionary) -> Vector4i:
 func _build_rect2(fields: Dictionary) -> Rect2:
 	if not fields.has("position"):
 		return Rect2(
-			Read.as_float(fields.get("x", 0)),
-			Read.as_float(fields.get("y", 0)),
-			Read.as_float(fields.get("width", 0)),
-			Read.as_float(fields.get("height", 0))
+			GdhRead.as_float(fields.get("x", 0)),
+			GdhRead.as_float(fields.get("y", 0)),
+			GdhRead.as_float(fields.get("width", 0)),
+			GdhRead.as_float(fields.get("height", 0))
 		)
 	return Rect2(_vector2_at(fields, "position"), _vector2_at(fields, "size"))
 
@@ -824,24 +775,24 @@ func _build_rect2(fields: Dictionary) -> Rect2:
 func _build_rect2i(fields: Dictionary) -> Rect2i:
 	if not fields.has("position"):
 		return Rect2i(
-			Read.as_int(fields.get("x", 0)),
-			Read.as_int(fields.get("y", 0)),
-			Read.as_int(fields.get("width", 0)),
-			Read.as_int(fields.get("height", 0))
+			GdhRead.as_int(fields.get("x", 0)),
+			GdhRead.as_int(fields.get("y", 0)),
+			GdhRead.as_int(fields.get("width", 0)),
+			GdhRead.as_int(fields.get("height", 0))
 		)
 	return Rect2i(_vector2i_at(fields, "position"), _vector2i_at(fields, "size"))
 
 
 func _build_plane(fields: Dictionary) -> Plane:
-	return Plane(_vector3_at(fields, "normal"), Read.as_float(fields.get("d", 0)))
+	return Plane(_vector3_at(fields, "normal"), GdhRead.as_float(fields.get("d", 0)))
 
 
 func _build_quaternion(fields: Dictionary) -> Quaternion:
 	return Quaternion(
-		Read.as_float(fields.get("x", 0)),
-		Read.as_float(fields.get("y", 0)),
-		Read.as_float(fields.get("z", 0)),
-		Read.as_float(fields.get("w", 0))
+		GdhRead.as_float(fields.get("x", 0)),
+		GdhRead.as_float(fields.get("y", 0)),
+		GdhRead.as_float(fields.get("z", 0)),
+		GdhRead.as_float(fields.get("w", 0))
 	)
 
 
@@ -881,10 +832,10 @@ func _build_projection(fields: Dictionary) -> Projection:
 
 func _build_color(fields: Dictionary) -> Color:
 	return Color(
-		Read.as_float(fields.get("r", 0)),
-		Read.as_float(fields.get("g", 0)),
-		Read.as_float(fields.get("b", 0)),
-		Read.as_float(fields.get("a", 1), 1.0)
+		GdhRead.as_float(fields.get("r", 0)),
+		GdhRead.as_float(fields.get("g", 0)),
+		GdhRead.as_float(fields.get("b", 0)),
+		GdhRead.as_float(fields.get("a", 1), 1.0)
 	)
 
 
@@ -897,7 +848,7 @@ func _build_bytes(fields: Dictionary) -> PackedByteArray:
 
 
 func _build_float(fields: Dictionary) -> float:
-	return Read.as_float(fields)
+	return GdhRead.as_float(fields)
 
 
 func _build_int(fields: Dictionary) -> int:

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

@@ -5,25 +5,25 @@ extends Node
 ## preloaded rather than looked up on disk at runtime, so a missing one fails to parse here
 ## instead of leaving a command silently unanswered.
 
-const SceneTools = preload("tools/scene_tools.gd")
-const ResourceTools = preload("tools/resource_tools.gd")
-const AnimationTools = preload("tools/animation_tools.gd")
-const PlayTools = preload("tools/play_tools.gd")
-const ClassTools = preload("tools/class_tools.gd")
-const SettingsTools = preload("tools/settings_tools.gd")
-const FilesystemTools = preload("tools/filesystem_tools.gd")
-const ProfileTools = preload("tools/profile_tools.gd")
+const GdhSceneTools = preload("tools/scene_tools.gd")
+const GdhResourceTools = preload("tools/resource_tools.gd")
+const GdhAnimationTools = preload("tools/animation_tools.gd")
+const GdhPlayTools = preload("tools/play_tools.gd")
+const GdhClassTools = preload("tools/class_tools.gd")
+const GdhSettingsTools = preload("tools/settings_tools.gd")
+const GdhFilesystemTools = preload("tools/filesystem_tools.gd")
+const GdhProfileTools = preload("tools/profile_tools.gd")
 
 var _editor_plugin: EditorPlugin = null
 
-var _scene_tools: SceneTools = null
-var _resource_tools: ResourceTools = null
-var _animation_tools: AnimationTools = null
-var _play_tools: PlayTools = null
-var _class_tools: ClassTools = null
-var _settings_tools: SettingsTools = null
-var _filesystem_tools: FilesystemTools = null
-var _profile_tools: ProfileTools = null
+var _scene_tools: GdhSceneTools = null
+var _resource_tools: GdhResourceTools = null
+var _animation_tools: GdhAnimationTools = null
+var _play_tools: GdhPlayTools = null
+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
@@ -46,35 +46,35 @@ func _init_tools() -> void:
 		return
 	_initialized = true
 
-	_scene_tools = SceneTools.new()
+	_scene_tools = GdhSceneTools.new()
 	_scene_tools.name = "SceneTools"
 	add_child(_scene_tools)
 
-	_resource_tools = ResourceTools.new()
+	_resource_tools = GdhResourceTools.new()
 	_resource_tools.name = "ResourceTools"
 	add_child(_resource_tools)
 
-	_animation_tools = AnimationTools.new()
+	_animation_tools = GdhAnimationTools.new()
 	_animation_tools.name = "AnimationTools"
 	add_child(_animation_tools)
 
-	_play_tools = PlayTools.new()
+	_play_tools = GdhPlayTools.new()
 	_play_tools.name = "PlayTools"
 	add_child(_play_tools)
 
-	_class_tools = ClassTools.new()
+	_class_tools = GdhClassTools.new()
 	_class_tools.name = "ClassTools"
 	add_child(_class_tools)
 
-	_settings_tools = SettingsTools.new()
+	_settings_tools = GdhSettingsTools.new()
 	_settings_tools.name = "SettingsTools"
 	add_child(_settings_tools)
 
-	_filesystem_tools = FilesystemTools.new()
+	_filesystem_tools = GdhFilesystemTools.new()
 	_filesystem_tools.name = "FilesystemTools"
 	add_child(_filesystem_tools)
 
-	_profile_tools = ProfileTools.new()
+	_profile_tools = GdhProfileTools.new()
 	_profile_tools.name = "ProfileTools"
 	add_child(_profile_tools)
 

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

@@ -4,19 +4,19 @@ extends Node
 ## Animations and animation trees, edited in the open editor or, for a project no editor serves, by a
 ## headless engine.
 
-const AnimationReads = preload("../animation_reads.gd")
-const HeadlessCheck = preload("../headless_check.gd")
-const PropertyValues = preload("../property_values.gd")
-const Read = preload("../reading.gd")
-const SceneFile = preload("../scene_file.gd")
-const Serialisation = preload("../serialisation.gd")
+const GdhAnimationReads = preload("../animation_reads.gd")
+const GdhHeadlessCheck = preload("../headless_check.gd")
+const GdhPropertyValues = preload("../property_values.gd")
+const GdhRead = preload("../reading.gd")
+const GdhSceneFile = preload("../scene_file.gd")
+const GdhSerialisation = preload("../serialisation.gd")
 
 ## How far right of the rightmost state a new one goes in the editor's graph, wider than a state's
 ## box there.
 const STATE_SPACING: float = 200.0
 
 var _editor_plugin: EditorPlugin = null
-var _properties: PropertyValues = PropertyValues.new()
+var _properties: GdhPropertyValues = GdhPropertyValues.new()
 
 
 func set_editor_plugin(plugin: EditorPlugin) -> void:
@@ -42,15 +42,13 @@ func _find_node(root: Node, path: String) -> Node:
 ## [param kind] the scene owns. Answers [scene, node, refusal]; the refusal is {} when both were
 ## found.
 func _open_at(scene_path: String, node_path: String, kind: String) -> Array:
-	var scene: SceneFile = SceneFile.new()
+	var scene: GdhSceneFile = GdhSceneFile.new()
 	var refused: Dictionary = scene.open(scene_path, true)
 	if not refused.is_empty():
 		return [scene, null, refused]
 	var node: Node = _find_node(scene.root, node_path)
 	if node == null or not node.is_class(kind):
-		return [
-			scene, null, scene.refuse(scene.not_found("%s not found at: %s" % [kind, node_path], node_path))
-		]
+		return [scene, null, _not_of_kind(scene, node, node_path, kind)]
 	var foreign: String = scene.foreign(node)
 	if not foreign.is_empty():
 		return [scene, null, scene.refuse(foreign)]
@@ -60,21 +58,34 @@ func _open_at(scene_path: String, node_path: String, kind: String) -> Array:
 ## [param scene_path] opened for reading, as [method _open_at] answers. A node an instanced scene
 ## owns is read like any other, since nothing is written.
 func _read_at(scene_path: String, node_path: String, kind: String) -> Array:
-	var scene: SceneFile = SceneFile.new()
+	var scene: GdhSceneFile = GdhSceneFile.new()
 	var refused: Dictionary = scene.open(scene_path, false)
 	if not refused.is_empty():
 		return [scene, null, refused]
 	var node: Node = _find_node(scene.root, node_path)
 	if node == null or not node.is_class(kind):
-		return [
-			scene, null, scene.refuse(scene.not_found("%s not found at: %s" % [kind, node_path], node_path))
-		]
+		return [scene, null, _not_of_kind(scene, node, node_path, kind)]
 	return [scene, node, {}]
 
 
+## The refusal for [param node_path] in [param scene], where [param node] is what the scene has
+## there, null or not a [param kind], with where the scene's nodes of that kind are.
+func _not_of_kind(scene: GdhSceneFile, node: Node, node_path: String, kind: String) -> Dictionary:
+	var said: String = "%s not found at: %s" % [kind, node_path]
+	if node == null:
+		said = scene.not_found(said, node_path)
+	var held: PackedStringArray = []
+	if scene.root.is_class(kind):
+		var _root_held: bool = held.append(".")
+	for found: Node in scene.root.find_children("*", kind, true, false):
+		var _held: bool = held.append(str(scene.root.get_path_to(found)))
+	var there: String = "" if node == null else node.get_class()
+	return scene.refuse(GdhRead.not_of_kind(said, node_path, there, kind, held))
+
+
 ## Writes [param scene] once [param check] passes, then the files of [param homes], answering
 ## [param answer] or a refusal.
-func _finish(scene: SceneFile, check: Callable, homes: Dictionary, answer: Dictionary) -> Dictionary:
+func _finish(scene: GdhSceneFile, check: Callable, homes: Dictionary, answer: Dictionary) -> Dictionary:
 	if not Engine.is_editor_hint():
 		for file: Variant in homes:
 			var home: Resource = homes[file]
@@ -91,7 +102,7 @@ func _finish(scene: SceneFile, check: Callable, homes: Dictionary, answer: Dicti
 								)
 								% file
 							)
-							+ HeadlessCheck.REMEDY
+							+ GdhHeadlessCheck.REMEDY
 						)
 					)
 				)
@@ -100,7 +111,7 @@ func _finish(scene: SceneFile, check: Callable, homes: Dictionary, answer: Dicti
 		return written
 	for file: Variant in homes:
 		var resource: Resource = homes[file]
-		var saving: Error = SceneFile.save_keeping_uid(resource, str(file))
+		var saving: Error = GdhSceneFile.save_keeping_uid(resource, str(file))
 		if saving != OK:
 			return {"ok": false, "error": "Failed to save %s: %s" % [file, error_string(saving)]}
 		if Engine.is_editor_hint():
@@ -112,14 +123,14 @@ func _finish(scene: SceneFile, check: Callable, homes: Dictionary, answer: Dicti
 ## engine ran as it loaded the file.
 func _scripted(resource: Resource) -> bool:
 	var script: Script = resource.get_script()
-	return (script != null and not script.is_tool()) or HeadlessCheck.holds_scripted_embedded(resource, {})
+	return (script != null and not script.is_tool()) or GdhHeadlessCheck.holds_scripted_embedded(resource, {})
 
 
 func _parse_json_maybe(value: Variant) -> Variant:
 	if typeof(value) != TYPE_STRING:
 		return value
 	var text: String = value
-	var parsed: Variant = Read.json_or_null(text)
+	var parsed: Variant = GdhRead.json_or_null(text)
 	if parsed == null and text != "null":
 		return value
 	return parsed
@@ -140,7 +151,7 @@ func _parse_method_args(raw_args: Array) -> Array:
 ## edited in memory while only the scene was saved, which refers to the file, so the edit was
 ## answered as made and was gone; it is saved too. One inside some other file (an imported model,
 ## the scene this one inherits from) is refused, since nothing written here would keep the edit.
-func _homes(scene: SceneFile, held: Array) -> Array:
+func _homes(scene: GdhSceneFile, held: Array) -> Array:
 	var homes: Dictionary = {}
 	for entry: Array in held:
 		var resource: Resource = entry[0]
@@ -195,10 +206,10 @@ func _library_of(player: AnimationPlayer, animation_name: String) -> AnimationLi
 
 ## The state machine at [param state_machine_path] in [param anim_tree], with the files it is kept
 ## in, as [machine, homes, why not].
-func _machine(scene: SceneFile, anim_tree: AnimationTree, state_machine_path: String) -> Array:
-	var sm: AnimationNodeStateMachine = AnimationReads.state_machine(anim_tree, state_machine_path)
+func _machine(scene: GdhSceneFile, anim_tree: AnimationTree, state_machine_path: String) -> Array:
+	var sm: AnimationNodeStateMachine = GdhAnimationReads.state_machine(anim_tree, state_machine_path)
 	if not sm:
-		return [null, {}, AnimationReads.no_machine(anim_tree, state_machine_path)]
+		return [null, {}, GdhAnimationReads.no_machine(anim_tree, state_machine_path)]
 	var homes: Array = _homes(scene, [[sm, "state machine"]])
 	if not homes[0]:
 		return [null, {}, homes[1]]
@@ -226,18 +237,18 @@ func read_animations(args: Dictionary) -> Dictionary:
 		return {"ok": false, "error": "Missing scenePath"}
 
 	var opened: Array = _read_at(scene_path, player_node_path, "AnimationPlayer")
-	var scene: SceneFile = opened[0]
+	var scene: GdhSceneFile = opened[0]
 	if opened[1] == null:
 		return opened[2]
 	var player: AnimationPlayer = opened[1]
-	return _read_in(scene, AnimationReads.animations(player, animation_name))
+	return _read_in(scene, GdhAnimationReads.animations(player, animation_name))
 
 
 ## [param answer] read from [param scene], with whether the editor holds the scene unsaved.
-func _read_in(scene: SceneFile, answer: Dictionary) -> Dictionary:
+func _read_in(scene: GdhSceneFile, answer: Dictionary) -> Dictionary:
 	if not answer.get("ok", false):
 		return scene.refuse(str(answer.get("error", "")))
-	answer["unsavedInEditor"] = SceneFile.unsaved(scene.path)
+	answer["unsavedInEditor"] = GdhSceneFile.unsaved(scene.path)
 	scene.close()
 	return answer
 
@@ -253,11 +264,11 @@ func read_animation_states(args: Dictionary) -> Dictionary:
 		return {"ok": false, "error": "Missing animTreePath"}
 
 	var opened: Array = _read_at(scene_path, anim_tree_path, "AnimationTree")
-	var scene: SceneFile = opened[0]
+	var scene: GdhSceneFile = opened[0]
 	if opened[1] == null:
 		return opened[2]
 	var anim_tree: AnimationTree = opened[1]
-	return _read_in(scene, AnimationReads.states(anim_tree, state_machine_path))
+	return _read_in(scene, GdhAnimationReads.states(anim_tree, state_machine_path))
 
 
 # =============================================================================
@@ -280,7 +291,7 @@ func create_animation(args: Dictionary) -> Dictionary:
 		return {"ok": false, "error": "Unsupported loopMode: " + loop_mode_name}
 
 	var opened: Array = _open_at(scene_path, player_node_path, "AnimationPlayer")
-	var scene: SceneFile = opened[0]
+	var scene: GdhSceneFile = opened[0]
 	if opened[1] == null:
 		return opened[2]
 	var player: AnimationPlayer = opened[1]
@@ -295,9 +306,9 @@ func create_animation(args: Dictionary) -> Dictionary:
 		return scene.refuse(str(homes[1]))
 
 	var anim: Animation = Animation.new()
-	anim.length = Read.as_float(args.get("length", 1.0), 1.0)
-	anim.loop_mode = Read.as_int(loop_modes[loop_mode_name]) as Animation.LoopMode
-	anim.step = Read.as_float(args.get("step", 0.1), 0.1)
+	anim.length = GdhRead.as_float(args.get("length", 1.0), 1.0)
+	anim.loop_mode = GdhRead.as_int(loop_modes[loop_mode_name]) as Animation.LoopMode
+	anim.step = GdhRead.as_float(args.get("step", 0.1), 0.1)
 	var called: String = animation_name.get_slice("/", 1) if animation_name.contains("/") else animation_name
 	var add_err: Error = anim_lib.add_animation(StringName(called), anim)
 	if add_err != OK:
@@ -337,7 +348,7 @@ func add_animation_track(args: Dictionary) -> Dictionary:
 		return {"ok": false, "error": keyed[1]}
 
 	var opened: Array = _open_at(scene_path, player_node_path, "AnimationPlayer")
-	var scene: SceneFile = opened[0]
+	var scene: GdhSceneFile = opened[0]
 	if opened[1] == null:
 		return opened[2]
 	var player: AnimationPlayer = opened[1]
@@ -429,7 +440,7 @@ func _add_track(
 
 	for index: int in keyframes.size():
 		var keyframe: Dictionary = keyframes[index]
-		if anim.track_insert_key(track_idx, Read.as_float(keyframe["time"]), keys[index]) < 0:
+		if anim.track_insert_key(track_idx, GdhRead.as_float(keyframe["time"]), keys[index]) < 0:
 			return [-1, "Keyframe %d could not be inserted." % index, null]
 	return [track_idx, "", method_found]
 
@@ -450,7 +461,7 @@ func _keyframes(track: Dictionary) -> Array:
 		var time: Variant = keyframe.get("time")
 		if not (time is float or time is int):
 			return [false, "keyframes[%d] has no time." % index]
-		var seconds: float = Read.as_float(time)
+		var seconds: float = GdhRead.as_float(time)
 		if times.has(seconds):
 			return [
 				false, "keyframes[%d] and [%d] are both at %s seconds." % [times[seconds], index, seconds]
@@ -504,7 +515,7 @@ func add_animation_state(args: Dictionary) -> Dictionary:
 			return {"ok": false, "error": "Missing " + str(required[1])}
 
 	var opened: Array = _open_at(scene_path, anim_tree_path, "AnimationTree")
-	var scene: SceneFile = opened[0]
+	var scene: GdhSceneFile = opened[0]
 	if opened[1] == null:
 		return opened[2]
 	var anim_tree: AnimationTree = opened[1]
@@ -547,7 +558,7 @@ func add_animation_state(args: Dictionary) -> Dictionary:
 		"animationName": animation_name,
 		# False when the tree has no player to look the animation up in.
 		"animationFound": player != null,
-		"position": Serialisation.new().serialize_value(position),
+		"position": GdhSerialisation.new().serialize_value(position),
 	}
 	var files: Dictionary = machine[1]
 	return _finish(scene, Callable(), files, answer)
@@ -580,13 +591,13 @@ func connect_animation_states(args: Dictionary) -> Dictionary:
 		return {"ok": false, "error": "Unsupported transitionType: " + transition_type}
 	var transition: AnimationNodeStateMachineTransition = AnimationNodeStateMachineTransition.new()
 	transition.switch_mode = (
-		Read.as_int(modes[transition_type]) as AnimationNodeStateMachineTransition.SwitchMode
+		GdhRead.as_int(modes[transition_type]) as AnimationNodeStateMachineTransition.SwitchMode
 	)
 	if not advance_condition.is_empty():
 		transition.advance_condition = StringName(advance_condition)
 
 	var opened: Array = _open_at(scene_path, anim_tree_path, "AnimationTree")
-	var scene: SceneFile = opened[0]
+	var scene: GdhSceneFile = opened[0]
 	if opened[1] == null:
 		return opened[2]
 	var anim_tree: AnimationTree = opened[1]

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

@@ -4,8 +4,8 @@ extends Node
 ## The editor's view of the files on disk: scans, the reimports asked for, where each stands, and
 ## files moved under it.
 
-const Read = preload("../reading.gd")
-const SceneFile = preload("../scene_file.gd")
+const GdhRead = preload("../reading.gd")
+const GdhSceneFile = preload("../scene_file.gd")
 
 var _editor_plugin: EditorPlugin = null
 
@@ -63,7 +63,7 @@ func rescan_filesystem(args: Dictionary) -> Dictionary:
 	var started: bool = false
 	var completed_before: int = _scans_completed
 	var uids: Dictionary = {"reread": [], "duplicated": []}
-	if not Read.as_bool(args.get("statusOnly", false)) and not busy:
+	if not GdhRead.as_bool(args.get("statusOnly", false)) and not busy:
 		uids = _reread_changed_uids(filesystem)
 		# Files the caller has just written, moved or deleted, read again one by one. The scan finds a
 		# script that appeared and leaves the global class of one that has gone in the editor's list,
@@ -172,7 +172,7 @@ func scan_status(_args: Dictionary) -> Dictionary:
 		"ok": true,
 		"scanning": filesystem.is_scanning(),
 		"importing": filesystem.is_importing(),
-		"pending": SceneFile.scan_due,
+		"pending": GdhSceneFile.scan_due,
 		"sinceScanFinishedMs":
 		-1 if _scan_finished_at_msec < 0 else Time.get_ticks_msec() - _scan_finished_at_msec,
 		"reimportsCompleted": _reimports_completed,

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

@@ -9,7 +9,7 @@ extends Node
 ## tools answer at all.
 
 ## What the display server calls itself when the engine was started with no display at all.
-const Read = preload("../reading.gd")
+const GdhRead = preload("../reading.gd")
 
 const HEADLESS_DISPLAY: String = "headless"
 ## Where Godot keeps the port its own debugger listens on for a game it is playing. One setting
@@ -245,7 +245,7 @@ func playing_status(_args: Dictionary) -> Dictionary:
 	# play, so the one from when this editor greeted the server is a number it has moved off.
 	var settings: EditorSettings = EditorInterface.get_editor_settings()
 	var debugger: int = (
-		Read.as_int(settings.get_setting(DEBUGGER_SETTING))
+		GdhRead.as_int(settings.get_setting(DEBUGGER_SETTING))
 		if settings != null and settings.has_setting(DEBUGGER_SETTING)
 		else 0
 	)