gdharness 1.2.39 → 1.2.41

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

@@ -5,6 +5,7 @@ extends RefCounted
 ## stores, which runs no script of the scene's, so a read answers the same either way.
 
 const FileReads = preload("file_reads.gd")
+const Read = preload("reading.gd")
 const Serialisation = preload("serialisation.gd")
 
 const LOOP_MODE_NAMES: Dictionary[int, String] = {
@@ -60,7 +61,12 @@ static func _bare(scene_path: String, node_path: String, kind: String) -> Array:
 		return [null, read]
 	var type: String = str(read.get("type", ""))
 	if not ClassDB.class_exists(type) or not ClassDB.is_parent_class(type, kind):
-		return [null, {"ok": false, "error": "%s not found at: %s" % [kind, node_path]}]
+		var said: String = "%s not found at: %s" % [kind, node_path]
+		if read.is_empty() and FileReads.scene_node(scene_path, node_path.get_slice("/", 0)).is_empty():
+			said = Read.from_the_root(
+				said, node_path, str(FileReads.scene_node(scene_path, ".").get("name", ""))
+			)
+		return [null, {"ok": false, "error": said}]
 	var bare: Node = ClassDB.instantiate(type)
 	bare.name = str(read["name"])
 	var given: Dictionary = read["properties"]
@@ -164,7 +170,10 @@ static func state_machine(tree: AnimationTree, state_machine_path: String) -> An
 ## the path that failed, and what is there instead.
 static func no_machine(tree: AnimationTree, state_machine_path: String) -> String:
 	if tree == null or tree.tree_root == null:
-		return "The AnimationTree has no tree_root."
+		return (
+			"The AnimationTree has no tree_root. Make one with resource_edit create of an "
+			+ "AnimationNodeStateMachine, then give its res:// path to tree_root with scene_node set."
+		)
 	var current: AnimationNodeStateMachine = tree.tree_root as AnimationNodeStateMachine
 	if current == null:
 		return (

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

@@ -544,7 +544,8 @@ func send_tool_result(request_id: String, success: bool, result: Variant = null,
 
 func _send_message(message: Dictionary) -> void:
 	if socket.get_ready_state() == WebSocketPeer.STATE_OPEN:
-		var sent: Error = socket.send_text(JSON.stringify(message))
+		# Keys in the order they were put in, which for a map read is the order the project keeps.
+		var sent: Error = socket.send_text(JSON.stringify(message, "", false))
 		if sent != OK:
 			push_error("gdharness: could not send to the server: " + error_string(sent))
 

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

@@ -147,12 +147,8 @@ static func reached(object: Object, property: String) -> Dictionary:
 ## Whether [param object] holds, at any depth, an embedded resource with a script that is not a tool.
 static func holds_scripted_embedded(object: Object, seen: Dictionary) -> bool:
 	for value: Variant in stored(object).values():
-		var items: Array = value if value is Array else [value]
-		for item: Variant in items:
-			if not item is Resource or seen.has(item):
-				continue
-			var resource: Resource = item
-			if not resource.is_built_in():
+		for resource: Resource in resources_in(value):
+			if seen.has(resource) or not resource.is_built_in():
 				continue
 			seen[resource] = true
 			var script: Script = resource.get_script()
@@ -163,6 +159,25 @@ static func holds_scripted_embedded(object: Object, seen: Dictionary) -> bool:
 	return false
 
 
+## The resources [param value] is or holds through arrays and dictionaries at any depth, keys
+## included: a file embeds a resource kept as a map's value, the way an AnimationLibrary keeps its
+## animations, as it embeds one held directly.
+static func resources_in(value: Variant) -> Array[Resource]:
+	var found: Array[Resource] = []
+	if value is Resource:
+		found.append(value)
+	elif value is Array:
+		var items: Array = value
+		for item: Variant in items:
+			found.append_array(resources_in(item))
+	elif value is Dictionary:
+		var entries_held: Dictionary = value
+		for key: Variant in entries_held:
+			found.append_array(resources_in(key))
+			found.append_array(resources_in(entries_held[key]))
+	return found
+
+
 ## Puts the file at [param file_path] back as [param previous], or removes it when there was none,
 ## answering "" or a sentence saying that failed too.
 static func put_back(file_path: String, previous: Variant) -> String:
@@ -370,11 +385,7 @@ static func settle_saved(
 ## Every embedded resource [param values] reach, at any depth, by its id in the file.
 static func embedded_in(values: Array, found: Dictionary) -> Dictionary:
 	for value: Variant in values:
-		var items: Array = value if value is Array else [value]
-		for item: Variant in items:
-			if not item is Resource:
-				continue
-			var resource: Resource = item
+		for resource: Resource in resources_in(value):
 			var id: String = resource.get_scene_unique_id()
 			if not resource.is_built_in() or id.is_empty() or found.has(id):
 				continue

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

@@ -590,7 +590,7 @@ static func _listed(type: int) -> bool:
 
 ## [param value] as a caller would write it, for a refusal to quote.
 func shown(value: Variant) -> String:
-	return JSON.stringify(_values.serialize_value(value))
+	return JSON.stringify(_values.serialize_value(value), "", false)
 
 
 ## A dictionary carrying its own type name, as the serialiser writes it.

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

@@ -99,3 +99,18 @@ static func json_or_null(text: String) -> Variant:
 	if json.parse(text) != OK:
 		return null
 	return json.data
+
+
+## [param said], the refusal for [param node_path] found nowhere in a scene whose root is called
+## [param root_name], with how paths are read when the path starts with that name and the root has
+## no child called that. Paths go from the root, so its own name there names a child of it, and a
+## caller who read the root as Main in a tree wrote Main/Body and was told only that nothing is there.
+static func from_the_root(said: String, node_path: String, root_name: String) -> String:
+	var first: String = node_path.get_slice("/", 0)
+	if root_name.is_empty() or first != root_name:
+		return said
+	var rest: String = node_path.substr(first.length() + 1)
+	var how: String = 'Paths go from the root, %s, whose own path is "."' % root_name
+	if not rest.is_empty():
+		how += ', so this one is "%s"' % rest
+	return "%s%s %s." % [said, "" if said.ends_with(".") else ".", how]

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

@@ -30,6 +30,7 @@ const HeadlessCheck = preload("headless_check.gd")
 ## How many times what scripts changed is put back before a write is refused for it.
 const PUTTING_BACK_PASSES: int = 4
 const PropertyValues = preload("property_values.gd")
+const Read = preload("reading.gd")
 
 ## Whether a scan asked for through [method scan_later] is still to start, which a caller waiting
 ## for the editor's files to settle has to wait through as well.
@@ -150,6 +151,14 @@ func refuse(error: String) -> Dictionary:
 	return {"ok": false, "error": error}
 
 
+## [param said], the refusal for [param node_path] found nowhere in this scene, with how a path is
+## read when it starts with the root's own name.
+func not_found(said: String, node_path: String) -> String:
+	if root == null or root.has_node(NodePath(node_path.get_slice("/", 0))):
+		return said
+	return Read.from_the_root(said, node_path, str(root.name))
+
+
 func close() -> void:
 	if root != null:
 		root.free()

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

@@ -1,9 +1,11 @@
 @tool
 extends Node
 
-## Animations and animation trees, edited in the open editor.
+## 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")
@@ -46,7 +48,9 @@ func _open_at(scene_path: String, node_path: String, kind: String) -> Array:
 		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("%s not found at: %s" % [kind, node_path])]
+		return [
+			scene, null, scene.refuse(scene.not_found("%s not found at: %s" % [kind, node_path], node_path))
+		]
 	var foreign: String = scene.foreign(node)
 	if not foreign.is_empty():
 		return [scene, null, scene.refuse(foreign)]
@@ -62,25 +66,55 @@ func _read_at(scene_path: String, node_path: String, kind: String) -> Array:
 		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("%s not found at: %s" % [kind, node_path])]
+		return [
+			scene, null, scene.refuse(scene.not_found("%s not found at: %s" % [kind, node_path], node_path))
+		]
 	return [scene, node, {}]
 
 
 ## 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:
+	if not Engine.is_editor_hint():
+		for file: Variant in homes:
+			var home: Resource = homes[file]
+			if _scripted(home):
+				return (
+					scene
+					. refuse(
+						(
+							(
+								(
+									"Nothing was written: %s holds a resource with a script that is not a tool, and what "
+									+ "that script changed when a headless engine loaded it cannot be told apart from the "
+									+ "edit. "
+								)
+								% file
+							)
+							+ HeadlessCheck.REMEDY
+						)
+					)
+				)
 	var written: Dictionary = scene.write(check)
 	if not written.is_empty():
 		return written
 	for file: Variant in homes:
 		var resource: Resource = homes[file]
-		var saving: Error = ResourceSaver.save(resource, str(file))
+		var saving: Error = SceneFile.save_keeping_uid(resource, str(file))
 		if saving != OK:
 			return {"ok": false, "error": "Failed to save %s: %s" % [file, error_string(saving)]}
-		EditorInterface.get_resource_filesystem().update_file(str(file))
+		if Engine.is_editor_hint():
+			EditorInterface.get_resource_filesystem().update_file(str(file))
 	return answer
 
 
+## Whether [param resource], or one it embeds, has a script that is not a tool, which a headless
+## 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, {})
+
+
 func _parse_json_maybe(value: Variant) -> Variant:
 	if typeof(value) != TYPE_STRING:
 		return value

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

@@ -399,6 +399,19 @@ func _atlas(entry: Variant, index: int) -> Array:
 	if texture_path.split("/").has(".."):
 		return [false, "sources[%d].texture leaves the project: %s" % [index, texture_path]]
 	if not ResourceLoader.exists(texture_path):
+		# An image the engine has not imported loads as nothing, where "no texture" would send a caller
+		# looking for a file that is there.
+		if FileAccess.file_exists(texture_path) and not FileAccess.file_exists(texture_path + ".import"):
+			return [
+				false,
+				(
+					(
+						"sources[%d].texture: %s has not been imported, so the engine has no texture for it "
+						+ "yet. project_import reimport with resourcePath %s imports it."
+					)
+					% [index, texture_path, texture_path]
+				)
+			]
 		return [false, "sources[%d].texture: no texture at %s" % [index, texture_path]]
 	var texture: Texture2D = load(texture_path) as Texture2D
 	if texture == null:
@@ -720,13 +733,15 @@ func set_theme_color(args: Dictionary) -> Dictionary:
 		return {"ok": false, "error": "The theme saved without %s/%s" % [control_type, color_name]}
 
 	var stored: Color = saved.get_color(color_name, control_type)
-	return {
-		"ok": true,
-		"themePath": theme_path,
-		"controlType": control_type,
-		"colorName": color_name,
-		"color": {"r": stored.r, "g": stored.g, "b": stored.b, "a": stored.a}
-	}
+	return _noting_variation(
+		{
+			"ok": true,
+			"themePath": theme_path,
+			"controlType": control_type,
+			"colorName": color_name,
+			"color": {"r": stored.r, "g": stored.g, "b": stored.b, "a": stored.a}
+		}
+	)
 
 
 func set_theme_font_size(args: Dictionary) -> Dictionary:
@@ -743,7 +758,23 @@ func set_theme_font_size(args: Dictionary) -> Dictionary:
 	if theme == null:
 		return {"ok": false, "error": "No Theme at %s. Create one there first." % theme_path}
 
-	theme.set_font_size(font_size_name, control_type, Read.as_int(args.get("size", 0)))
+	# Godot reads a size of 0 or less as unset and answers the theme's default, so -3 would be read
+	# back as 16.
+	var pixels: float = Read.as_float(args.get("size"), 0.0)
+	if not is_finite(pixels) or pixels < 1 or pixels != floorf(pixels):
+		var shown: String = str(int(pixels)) if pixels == floorf(pixels) else str(pixels)
+		return {
+			"ok": false,
+			"error":
+			(
+				(
+					"size must be a whole number of pixels, 1 or more, not %s: Godot reads 0 or less as no size "
+					% shown
+				)
+				+ "and uses the theme's default instead."
+			)
+		}
+	theme.set_font_size(font_size_name, control_type, int(pixels))
 
 	var unsaved: String = _save_theme(theme, theme_path, "%s/font_sizes/%s" % [control_type, font_size_name])
 	if not unsaved.is_empty():
@@ -753,10 +784,32 @@ func set_theme_font_size(args: Dictionary) -> Dictionary:
 	if saved == null or not saved.has_font_size(font_size_name, control_type):
 		return {"ok": false, "error": "The theme saved without %s/%s" % [control_type, font_size_name]}
 
-	return {
-		"ok": true,
-		"themePath": theme_path,
-		"controlType": control_type,
-		"fontSizeName": font_size_name,
-		"size": saved.get_font_size(font_size_name, control_type)
-	}
+	return _noting_variation(
+		{
+			"ok": true,
+			"themePath": theme_path,
+			"controlType": control_type,
+			"fontSizeName": font_size_name,
+			"size": saved.get_font_size(font_size_name, control_type)
+		}
+	)
+
+
+## [param answer] with a note when its controlType names no class a theme styles. Any name is a
+## theme type, so one that is no class is a type variation, which styles only a control whose
+## theme_type_variation names it, and a misspelt "Buton" would otherwise read as Button set.
+func _noting_variation(answer: Dictionary) -> Dictionary:
+	var type: String = str(answer.get("controlType", ""))
+	if (
+		ClassDB.class_exists(type)
+		and (ClassDB.is_parent_class(type, "Control") or ClassDB.is_parent_class(type, "Window"))
+	):
+		return answer
+	answer["note"] = (
+		(
+			"%s is not a Control or Window class, so this is a type variation: it styles only a control "
+			+ "whose theme_type_variation is %s."
+		)
+		% [type, type]
+	)
+	return answer

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

@@ -111,7 +111,7 @@ func _kept(scene: SceneFile, saved: Node, node: Node, names: Array) -> String:
 					"%s.%s would load from the file as %s: the scene does not keep it, because the property "
 					+ "is not one a scene stores or the node belongs to another scene."
 				)
-				% [at, property, JSON.stringify(_values.serialize_value(loaded))]
+				% [at, property, JSON.stringify(_values.serialize_value(loaded), "", false)]
 			)
 	return ""
 
@@ -312,7 +312,7 @@ func add_node(args: Dictionary) -> Dictionary:
 	var root: Node = scene.root
 	var parent: Node = _find_node(root, parent_node_path)
 	if not parent:
-		return scene.refuse("Parent node not found: " + parent_node_path)
+		return scene.refuse(scene.not_found("Parent node not found: " + parent_node_path, parent_node_path))
 	var foreign: String = scene.foreign(parent)
 	if not foreign.is_empty():
 		return scene.refuse(foreign)
@@ -387,7 +387,7 @@ func delete_node(args: Dictionary) -> Dictionary:
 
 	var node: Node = _find_node(scene.root, node_path)
 	if not node:
-		return scene.refuse("Node not found: " + node_path)
+		return scene.refuse(scene.not_found("Node not found: " + node_path, node_path))
 	var fixed: String = scene.fixed(node)
 	if not fixed.is_empty():
 		return scene.refuse(fixed)
@@ -427,7 +427,7 @@ func duplicate_node(args: Dictionary) -> Dictionary:
 	var root: Node = scene.root
 	var source: Node = _find_node(root, node_path)
 	if not source:
-		return scene.refuse("Node not found: " + node_path)
+		return scene.refuse(scene.not_found("Node not found: " + node_path, node_path))
 	if source == root:
 		return scene.refuse("The root of %s cannot be copied into its own scene." % scene_path)
 	var foreign: String = scene.foreign(source)
@@ -438,7 +438,7 @@ func duplicate_node(args: Dictionary) -> Dictionary:
 	if not parent_path.is_empty():
 		target_parent = _find_node(root, parent_path)
 	if not target_parent:
-		return scene.refuse("Parent not found: " + parent_path)
+		return scene.refuse(scene.not_found("Parent not found: " + parent_path, parent_path))
 	foreign = scene.foreign(target_parent)
 	if not foreign.is_empty():
 		return scene.refuse(foreign)
@@ -491,9 +491,9 @@ func reparent_node(args: Dictionary) -> Dictionary:
 	var node: Node = _find_node(root, node_path)
 	var new_parent: Node = _find_node(root, new_parent_path)
 	if not node:
-		return scene.refuse("Node not found: " + node_path)
+		return scene.refuse(scene.not_found("Node not found: " + node_path, node_path))
 	if not new_parent:
-		return scene.refuse("New parent not found: " + new_parent_path)
+		return scene.refuse(scene.not_found("New parent not found: " + new_parent_path, new_parent_path))
 	var fixed: String = scene.fixed(node)
 	if not fixed.is_empty():
 		return scene.refuse(fixed)
@@ -562,7 +562,7 @@ func set_node_properties(args: Dictionary) -> Dictionary:
 
 	var node: Node = _find_node(scene.root, node_path)
 	if not node:
-		return scene.refuse("Node not found: " + node_path)
+		return scene.refuse(scene.not_found("Node not found: " + node_path, node_path))
 	var foreign: String = scene.foreign(node)
 	if not foreign.is_empty():
 		return scene.refuse(foreign)
@@ -606,7 +606,7 @@ func get_node_properties(args: Dictionary) -> Dictionary:
 
 	var node: Node = _find_node(scene.root, node_path)
 	if not node:
-		return scene.refuse("Node not found: " + node_path)
+		return scene.refuse(scene.not_found("Node not found: " + node_path, node_path))
 
 	# Against the default the node would have in no scene: its script's for what the script
 	# declares, the class's for the rest. Compared with a bare instance of the class, every exported
@@ -792,9 +792,9 @@ func _connection_ends(
 	var source: Node = _find_node(scene.root, source_node_path)
 	var target: Node = _find_node(scene.root, target_node_path)
 	if not source:
-		return [null, "Source node not found: " + source_node_path]
+		return [null, scene.not_found("Source node not found: " + source_node_path, source_node_path)]
 	if not target:
-		return [null, "Target node not found: " + target_node_path]
+		return [null, scene.not_found("Target node not found: " + target_node_path, target_node_path)]
 	# pack drops a connection with either end inside an instanced scene, and the answer said it was
 	# made or removed.
 	for end: Node in [source, target]:
@@ -897,7 +897,7 @@ func list_connections(args: Dictionary) -> Dictionary:
 	if not filter_path.is_empty():
 		filtered = _find_node(root, filter_path)
 		if filtered == null:
-			return scene.refuse("Node not found: " + filter_path)
+			return scene.refuse(scene.not_found("Node not found: " + filter_path, filter_path))
 	var nodes: Array = []
 	_collect_nodes_recursive(root, ".", nodes)
 

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

@@ -99,3 +99,18 @@ static func json_or_null(text: String) -> Variant:
 	if json.parse(text) != OK:
 		return null
 	return json.data
+
+
+## [param said], the refusal for [param node_path] found nowhere in a scene whose root is called
+## [param root_name], with how paths are read when the path starts with that name and the root has
+## no child called that. Paths go from the root, so its own name there names a child of it, and a
+## caller who read the root as Main in a tree wrote Main/Body and was told only that nothing is there.
+static func from_the_root(said: String, node_path: String, root_name: String) -> String:
+	var first: String = node_path.get_slice("/", 0)
+	if root_name.is_empty() or first != root_name:
+		return said
+	var rest: String = node_path.substr(first.length() + 1)
+	var how: String = 'Paths go from the root, %s, whose own path is "."' % root_name
+	if not rest.is_empty():
+		how += ', so this one is "%s"' % rest
+	return "%s%s %s." % [said, "" if said.ends_with(".") else ".", how]

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

@@ -660,7 +660,9 @@ static func _is_empty(owed: Variant) -> bool:
 ## taken the lot: see [member _outgoing].
 func _send_response(client: StreamPeerTCP, data: Dictionary) -> void:
 	var owed: PackedByteArray = _outgoing.get(client, PackedByteArray())
-	owed.append_array((JSON.stringify(data) + "\n").to_utf8_buffer())
+	# Keys left in the order they were put in: sorted, a map read came back in another order than
+	# its keys() and the game iterate it in.
+	owed.append_array((JSON.stringify(data, "", false) + "\n").to_utf8_buffer())
 	_outgoing[client] = owed
 
 

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

@@ -129,8 +129,8 @@ func set_property(params: Dictionary) -> Dictionary:
 				% [
 					reached["called"],
 					named,
-					JSON.stringify(_values.serialize(given)),
-					JSON.stringify(_values.serialize(now)),
+					JSON.stringify(_values.serialize(given), "", false),
+					JSON.stringify(_values.serialize(now), "", false),
 					why,
 				]
 			)

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

@@ -12,6 +12,7 @@ const Values = preload("runtime_values.gd")
 const Queries = preload("runtime_queries.gd")
 const Read = preload("reading.gd")
 const Hover = preload("runtime_hover.gd")
+const Items = preload("runtime_items.gd")
 const Screen = preload("runtime_screen.gd")
 const Targets = preload("runtime_targets.gd")
 const Mouse = preload("runtime_mouse.gd")
@@ -509,6 +510,7 @@ func click(params: Dictionary) -> Dictionary:
 	var node_path: String = str(params.get("path", ""))
 	var wanted: String = str(params.get("says", ""))
 	var found: Variant = null
+	var item: Variant = null
 	if not wanted.is_empty():
 		var picked: Dictionary = Targets.control_saying(
 			_host.get_tree().root, "/root" if node_path.is_empty() else node_path, wanted, params.get("index")
@@ -517,6 +519,7 @@ func click(params: Dictionary) -> Dictionary:
 			return picked
 		node_path = picked["path"]
 		found = picked["found"]
+		item = picked.get("item")
 	if node_path.is_empty():
 		return {"type": "error", "message": "click needs a path, or says to find the control by its words"}
 
@@ -541,6 +544,16 @@ func click(params: Dictionary) -> Dictionary:
 	# other words, a link among them. Said either way, so a press on the middle is never read as one
 	# on the words.
 	var aim: Vector2 = control.size * 0.5
+	var item_scrolled: bool = false
+	if item != null:
+		var found_by_words: Dictionary = found
+		var placed_item: Dictionary = await Items.in_view(
+			_host.get_tree(), control, node_path, item, wanted, found_by_words
+		)
+		if placed_item.has("message"):
+			return placed_item
+		aim = placed_item["point"]
+		item_scrolled = placed_item["scrolled"]
 	var rich: RichTextLabel = control as RichTextLabel
 	if found != null and rich != null:
 		var placed: Dictionary = Targets.point_on_words(rich, wanted)
@@ -568,9 +581,9 @@ func click(params: Dictionary) -> Dictionary:
 	# off the top of its container is inside the viewport, behind whatever is drawn up there, so
 	# the click went to that instead and said so. Measured on a hall whose staff panel had been
 	# scrolled past: the button was at y 69 and its container started at y 166.
-	var scrolled: bool = false
+	var scrolled: bool = item_scrolled
 	if not _in_sight(control, own, local):
-		scrolled = await _scroll_into_view(control)
+		scrolled = await _scroll_into_view(control) or item_scrolled
 		var left: String = Values.afterwards(control)
 		if left != "in_tree":
 			return {