gdharness 1.2.30 → 1.2.32

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

@@ -517,6 +517,20 @@ func _handle_message(json_string: String) -> void:
 			pass
 
 
+## Says [param tool_name] was not run because the editor is scanning or importing, for the server to
+## ask again once that is over. An older server reads it as an ordinary refusal.
+func send_busy(request_id: String, tool_name: String) -> void:
+	_send_message(
+		{
+			"type": "tool_result",
+			"id": request_id,
+			"success": false,
+			"busy": true,
+			"error": "The editor is scanning or importing its files, so %s was not run." % tool_name,
+		}
+	)
+
+
 func send_tool_result(request_id: String, success: bool, result: Variant = null, error: String = "") -> void:
 	var response: Dictionary = {"type": "tool_result", "id": request_id, "success": success}
 

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

@@ -0,0 +1,237 @@
+extends RefCounted
+
+## Scenes and resources read from their files, by the editor's tools and by a headless engine with
+## none connected, so a read answers the same either way.
+##
+## A scene is read off its SceneState rather than instantiated. Instantiating outside the editor
+## runs every script's member initialisers and _init (measured on 4.7.2, with or without -e), so a
+## read with no editor would have run the game's code on every node; the editor gets placeholders
+## and runs none. The state holds everything the file says, and the scenes it instances theirs,
+## without making a node. Loading the file still does what loading does in the game: static
+## initialisers run, and a resource with a script is made with it.
+
+const PropertyValues = preload("property_values.gd")
+const Read = preload("reading.gd")
+const Serialisation = preload("serialisation.gd")
+
+
+## The nodes of [param scene_path] as {name, type, path, children}, with instanceOf on a node that
+## instances another scene and every stored property when [param include_properties] is set, the
+## file's value or the default where it sets none. [param depth] -1 reads every level.
+static func scene_tree(scene_path: String, depth: int, include_properties: bool) -> Dictionary:
+	if not FileAccess.file_exists(scene_path):
+		return {"ok": false, "error": "Scene not found: " + scene_path}
+	# Loaded without naming the type, so a resource handed in by mistake loads as what it is and the
+	# refusal can say so, where asking for a PackedScene printed the loader's error and a backtrace.
+	var loaded: Resource = ResourceLoader.load(scene_path, "", ResourceLoader.CACHE_MODE_IGNORE)
+	if loaded == null:
+		return {"ok": false, "error": "Failed to load %s as a scene" % scene_path}
+	if not loaded is PackedScene:
+		return {
+			"ok": false,
+			"error":
+			(
+				"%s is a %s, not a scene: resource_edit read reads its properties."
+				% [scene_path, loaded.get_class()]
+			)
+		}
+	var packed: PackedScene = loaded
+	var nodes: Dictionary = {}
+	var refused: String = _lay(packed.get_state(), ".", nodes, [scene_path])
+	if not refused.is_empty():
+		return {"ok": false, "error": refused}
+	if not nodes.has("."):
+		return {"ok": false, "error": "%s holds no nodes" % scene_path}
+	return {"ok": true, "tree": _entry(nodes, ".", include_properties, depth, 0)}
+
+
+## Lays the nodes of [param state] into [param nodes] under [param prefix], keyed by their path
+## from the outermost root, each instanced scene laid where it is instanced and the instancing
+## file's own entries for it applied over it. Answers a refusal, or "".
+##
+## [param within] is the files being laid, outermost first, so a scene that instances one of them
+## is refused rather than laid forever; the engine refuses to load such a scene, so this is only
+## reached through a state built some other way.
+static func _lay(state: SceneState, prefix: String, nodes: Dictionary, within: Array) -> String:
+	var base: SceneState = state.get_base_scene_state()
+	if base != null and not nodes.has(prefix):
+		var refused: String = _lay(base, prefix, nodes, within)
+		if not refused.is_empty():
+			return refused
+	for index: int in state.get_node_count():
+		var path: String = _joined(prefix, str(state.get_node_path(index)))
+		var fresh: bool = not nodes.has(path)
+		if fresh:
+			var instance: PackedScene = state.get_node_instance(index)
+			if instance != null:
+				if within.has(instance.resource_path):
+					return "%s instances %s, which holds it" % [within.back(), instance.resource_path]
+				var refused: String = _lay(
+					instance.get_state(), path, nodes, within + [instance.resource_path]
+				)
+				if not refused.is_empty():
+					return refused
+				if not nodes.has(path):
+					return "%s holds no nodes" % instance.resource_path
+				nodes[path]["instanceOf"] = instance.resource_path
+			elif state.is_node_instance_placeholder(index):
+				nodes[path] = _made("InstancePlaceholder")
+				nodes[path]["instanceOf"] = state.get_node_instance_placeholder(index)
+			elif str(state.get_node_type(index)).is_empty():
+				# An entry for a node of an instance that no longer has it, which the engine skips too.
+				continue
+			else:
+				nodes[path] = _made(str(state.get_node_type(index)))
+		# The name is the state's even for an entry laid already, since an inherited scene names its
+		# root itself; a root instanced inside another scene is renamed by that scene once laid.
+		nodes[path]["name"] = str(state.get_node_name(index))
+		if fresh:
+			# The root of what is laid here is placed by whoever instanced it.
+			if path != prefix:
+				_place(
+					nodes,
+					_joined(prefix, str(state.get_node_path(index, true))),
+					path,
+					state.get_node_index(index)
+				)
+		var held: Dictionary = nodes[path]["properties"]
+		for property: int in state.get_node_property_count(index):
+			held[str(state.get_node_property_name(index, property))] = state.get_node_property_value(
+				index, property
+			)
+	return ""
+
+
+static func _made(type: String) -> Dictionary:
+	var children: Array[String] = []
+	return {"name": "", "type": type, "properties": {}, "children": children}
+
+
+## Puts [param path] among [param parent]'s children, at [param at] when the file says where (a node
+## added inside an instance) and last when it does not.
+static func _place(nodes: Dictionary, parent: String, path: String, at: int) -> void:
+	if not nodes.has(parent):
+		return
+	var children: Array[String] = nodes[parent]["children"]
+	if at >= 0 and at < children.size():
+		var _placed: int = children.insert(at, path)
+	else:
+		children.append(path)
+
+
+## [param given], a path as a SceneState gives it ("." or "./Body/Tail"), under [param prefix].
+static func _joined(prefix: String, given: String) -> String:
+	var relative: String = given.trim_prefix("./")
+	if relative == "." or relative.is_empty():
+		return prefix
+	if prefix == ".":
+		return relative
+	return prefix + "/" + relative
+
+
+static func _entry(
+	nodes: Dictionary, path: String, include_properties: bool, depth: int, current_depth: int
+) -> Dictionary:
+	var node: Dictionary = nodes[path]
+	var children: Array[Dictionary] = []
+	var data: Dictionary = {"name": node["name"], "type": node["type"], "path": path, "children": children}
+	# The root's file is the scene being read, so only another node's names a second scene.
+	if path != "." and node.has("instanceOf"):
+		data["instanceOf"] = node["instanceOf"]
+	if include_properties:
+		var given: Dictionary = node["properties"]
+		data["properties"] = _stored(str(node["type"]), given)
+	if depth >= 0 and current_depth >= depth:
+		return data
+	for child: String in node["children"]:
+		children.append(_entry(nodes, child, include_properties, depth, current_depth + 1))
+	return data
+
+
+## Every property a node of [param type] stores, with the value [param given] sets or the default,
+## read as a node holding those values would answer them.
+##
+## The engine's half is read off a bare node of the class with the file's values set on it, which
+## runs no script: what a node lists depends on its values (a thread group's settings appear only
+## once it has one) and some setters set others (a Control's anchors preset sets how it grows), so
+## the class's defaults and the file's entries alone answered neither. The script's half is its
+## declared defaults under the file's values.
+static func _stored(type: String, given: Dictionary) -> Dictionary:
+	var attached: Variant = given.get("script")
+	var script: Script = attached if attached is Script else null
+	var scripted: Dictionary = {}
+	if script != null:
+		for declared: Dictionary in script.get_script_property_list():
+			var property: String = str(declared.get("name", ""))
+			if not property.is_empty() and Read.as_int(declared.get("usage", 0)) & PROPERTY_USAGE_STORAGE:
+				scripted[property] = script.get_property_default_value(property)
+	var values: Dictionary = {}
+	if ClassDB.class_exists(type) and ClassDB.can_instantiate(type):
+		var bare: Object = ClassDB.instantiate(type)
+		for property: Variant in given:
+			if property != "script" and not scripted.has(property):
+				bare.set(str(property), given[property])
+		for declared: Dictionary in bare.get_property_list():
+			var property: String = str(declared.get("name", ""))
+			if not property.is_empty() and Read.as_int(declared.get("usage", 0)) & PROPERTY_USAGE_STORAGE:
+				values[property] = bare.get(property)
+		if bare is Node:
+			bare.free()
+	for property: String in scripted:
+		values[property] = scripted[property]
+	# Given last, which keeps what a bare node cannot hold: the script itself, and a path to a node
+	# for a property that holds the node once it is in a tree.
+	values.merge(given, true)
+	var serialiser: Serialisation = Serialisation.new()
+	var answered: Dictionary = {}
+	for property: Variant in values:
+		answered[property] = serialiser.serialize_value(values[property])
+	return answered
+
+
+## What a resource file holds, in the form modify takes, so a value read here can be written back.
+## Read from the file rather than a cached copy, since the file is what the writes change and what
+## the project loads.
+static func resource(res_path: String, include_defaults: bool) -> Dictionary:
+	if not FileAccess.file_exists(res_path):
+		return {"ok": false, "error": "No resource at " + res_path}
+	var loaded: Resource = ResourceLoader.load(res_path, "", ResourceLoader.CACHE_MODE_IGNORE)
+	if loaded == null:
+		return {"ok": false, "error": "%s did not load as a resource." % res_path}
+	# A scene's own properties are its packed bundle, which says nothing a caller can use.
+	if loaded is PackedScene:
+		return {
+			"ok": false,
+			"error":
+			"%s is a scene: scene_tree reads its nodes, and scene_node get one node's properties." % res_path
+		}
+
+	var script: Script = loaded.get_script()
+	var scripted: Dictionary = {}
+	if script != null:
+		for declared: Dictionary in script.get_script_property_list():
+			scripted[str(declared.get("name", ""))] = true
+	var serialiser: Serialisation = Serialisation.new()
+	var properties: Dictionary = {}
+	for p: Dictionary in loaded.get_property_list():
+		var property: String = str(p.get("name", ""))
+		if property.is_empty() or property == "script":
+			continue
+		if not (Read.as_int(p.get("usage", 0)) & PROPERTY_USAGE_STORAGE):
+			continue
+		var value: Variant = loaded.get(property)
+		if not include_defaults:
+			var default: Variant = (
+				script.get_property_default_value(property)
+				if scripted.has(property)
+				else ClassDB.class_get_property_default_value(loaded.get_class(), property)
+			)
+			if PropertyValues.same(value, default):
+				continue
+		properties[property] = serialiser.serialize_value(value)
+	var answer: Dictionary = {
+		"ok": true, "resourcePath": res_path, "resourceType": loaded.get_class(), "properties": properties
+	}
+	if script != null:
+		answer["script"] = script.resource_path
+	return answer

package/build/godot/addons/gdharness_editor/file_reads.gd.uid

@@ -0,0 +1 @@
+uid://c1lf7gjr8v1ux

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

@@ -8,6 +8,17 @@ extends EditorPlugin
 const BridgeClient = preload("bridge_client.gd")
 const ToolExecutor = preload("tool_executor.gd")
 
+## The tools answered while the editor scans or imports, because none of them saves a file: the
+## ones a caller waits on a scan with, and the ones that only read or stop a played game.
+const ANSWERED_WHILE_SCANNING: Array[String] = [
+	"scan_status",
+	"rescan_filesystem",
+	"reimport_files",
+	"playing_status",
+	"stop_playing",
+	"profile_read",
+]
+
 var _client: BridgeClient
 var _tool_executor: ToolExecutor
 var _status_label: Label
@@ -85,10 +96,26 @@ func _on_disconnected() -> void:
 		_status_label.add_theme_color_override("font_color", Color.RED)
 
 
+## Whether [param tool_name] waits for the editor to finish scanning or importing. A save during a
+## scan updates the file list the scan's thread is writing out (see SceneFile.scan_later), and an
+## import can run frames of the editor from inside itself, the one handling this call among them.
+func turned_away(tool_name: String) -> bool:
+	var filesystem: EditorFileSystem = EditorInterface.get_resource_filesystem()
+	return (
+		not ANSWERED_WHILE_SCANNING.has(tool_name) and (filesystem.is_scanning() or filesystem.is_importing())
+	)
+
+
 func _on_tool_requested(request_id: String, tool_name: String, args: Dictionary) -> void:
 	if _tool_executor == null or _client == null:
 		return
 
+	# Turned away rather than held, so the server asks again: a call held here could run after the
+	# server had given up on it.
+	if turned_away(tool_name):
+		_client.send_busy(request_id, tool_name)
+		return
+
 	var result: Dictionary = _tool_executor.execute_tool(tool_name, args)
 	var success: bool = result.get("ok", false)
 

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

@@ -162,6 +162,9 @@ func cannot_hold(
 ## max_value) is set once more after the rest, so the order a caller wrote them in does not decide
 ## what is saved.
 ##
+## A name may be a colon path into a property's components, "position:x" or "region_rect:size:y",
+## spelled as the runtime tools spell it, so one axis can be written without restating the others.
+##
 ## Nothing here saves, so a refusal partway leaves the change in memory and the file as it was. The
 ## caller returns the refusal instead of saving.
 func write_all(target: Object, properties: Dictionary) -> String:
@@ -169,19 +172,23 @@ func write_all(target: Object, properties: Dictionary) -> String:
 	for key: Variant in properties:
 		var property: String = str(key)
 		var declared: Dictionary = declaration(target, property)
+		if declared.is_empty() and ":" in property:
+			declared = _component_slot(target, property)
+			if declared.has("refused"):
+				return str(declared["refused"])
 		if declared.is_empty():
 			return "%s has no property %s" % [target.get_class(), property]
 		var value: Array = value_for(target, declared, properties[key])
 		if not value[0]:
 			return str(value[1])
-		target.set(property, value[1])
+		_write(target, property, value[1])
 		given[property] = value[1]
 
 	for property: String in given:
-		if not same(target.get(property), given[property]):
-			target.set(property, given[property])
+		if not same(read_at(target, property), given[property]):
+			_write(target, property, given[property])
 	for property: String in given:
-		var held: Variant = target.get(property)
+		var held: Variant = read_at(target, property)
 		if not same(held, given[property]):
 			return (
 				(
@@ -193,6 +200,58 @@ func write_all(target: Object, properties: Dictionary) -> String:
 	return ""
 
 
+## What [param target] holds under [param key], a property or a colon path into one's components.
+func read_at(target: Object, key: String) -> Variant:
+	if ":" in key and declaration(target, key).is_empty():
+		return target.get_indexed(NodePath(key))
+	return target.get(key)
+
+
+## Writes [param value] under [param key], putting a changed component back into the property it
+## was read out of, and that one into the one above it.
+func _write(target: Object, key: String, value: Variant) -> void:
+	if ":" in key and declaration(target, key).is_empty():
+		target.set_indexed(NodePath(key), value)
+	else:
+		target.set(key, value)
+
+
+## The declaration the last step of [param path] would have, typed as the component it reaches, so
+## a fraction for an integer vector's axis is refused as one for an int property is; or
+## {"refused": why} for the first step that is not there.
+func _component_slot(target: Object, path: String) -> Dictionary:
+	var steps: PackedStringArray = path.split(":")
+	var owner: String = target.get_class()
+	if declaration(target, steps[0]).is_empty():
+		return {"refused": "%s has no property %s" % [owner, steps[0]]}
+	var value: Variant = target.get(steps[0])
+	var walked: String = steps[0]
+	for index: int in range(1, steps.size()):
+		var step: String = steps[index]
+		var has: PackedStringArray = Serialisation.components_of(value)
+		var kind: String = type_string(typeof(value))
+		var sort: String = ("an " if kind.left(1).to_upper() in ["A", "E", "I", "O", "U"] else "a ") + kind
+		if has.is_empty():
+			return {
+				"refused":
+				(
+					(
+						"%s.%s is %s, which a path does not step into: a path reaches the components of a "
+						+ "vector, a colour, a rectangle or a transform."
+					)
+					% [owner, walked, sort]
+				)
+			}
+		if not step in has:
+			return {
+				"refused":
+				"%s.%s is %s, so it has no %s; it has %s" % [owner, walked, sort, step, ", ".join(has)]
+			}
+		value = value[step]
+		walked += ":" + step
+	return {"name": path, "type": typeof(value), "usage": PROPERTY_USAGE_DEFAULT}
+
+
 ## [param raw] as the value [param declared] takes, as [ok, value] or [false, why not].
 func value_for(target: Object, declared: Dictionary, raw: Variant) -> Array:
 	var property: String = str(declared.get("name", ""))
@@ -607,57 +666,24 @@ func _parse_new_resource(type_tag: String, value: Dictionary) -> Array:
 	return [true, built]
 
 
-## A dictionary with no tag, read against the type the property declares. Anything else is a
-## dictionary the property genuinely wants, and its values are read as values in their own right:
-## kept as the tags they arrived as, a Vector2 read off one node and written to another was saved as
-## a dictionary holding the word "Vector2".
+## A dictionary with no tag, read against the type the property declares, by the fields the tagged
+## form of that type carries: the shape a read answers with, untagged, is a value too. A rectangle
+## written as the position and size a read gave was refused while the four numbers were taken, and
+## a Rect2i, an AABB or a transform had no untagged form at all. Anything else is a dictionary the
+## property genuinely wants, and its values are read as values in their own right: kept as the tags
+## they arrived as, a Vector2 read off one node and written to another was saved as a dictionary
+## holding the word "Vector2".
 func _parse_shaped_dictionary(value: Dictionary, expected_type: int, elements: Array) -> Variant:
-	match expected_type:
-		TYPE_VECTOR2:
-			if value.has("x") and value.has("y"):
-				return Vector2(Read.as_float(value["x"]), Read.as_float(value["y"]))
-		TYPE_VECTOR2I:
-			if value.has("x") and value.has("y"):
-				return Vector2i(Read.as_int(value["x"]), Read.as_int(value["y"]))
-		TYPE_VECTOR3:
-			if value.has("x") and value.has("y") and value.has("z"):
-				return Vector3(
-					Read.as_float(value["x"]), Read.as_float(value["y"]), Read.as_float(value["z"])
-				)
-		TYPE_VECTOR3I:
-			if value.has("x") and value.has("y") and value.has("z"):
-				return Vector3i(Read.as_int(value["x"]), Read.as_int(value["y"]), Read.as_int(value["z"]))
-		TYPE_VECTOR4:
-			if value.has("x") and value.has("y") and value.has("z") and value.has("w"):
-				return Vector4(
-					Read.as_float(value["x"]),
-					Read.as_float(value["y"]),
-					Read.as_float(value["z"]),
-					Read.as_float(value["w"])
-				)
-		TYPE_COLOR:
-			if value.has("r") and value.has("g") and value.has("b"):
-				return Color(
-					Read.as_float(value["r"]),
-					Read.as_float(value["g"]),
-					Read.as_float(value["b"]),
-					Read.as_float(value.get("a", 1), 1.0)
-				)
-		TYPE_RECT2:
-			if value.has("x") and value.has("y") and value.has("width") and value.has("height"):
-				return Rect2(
-					Read.as_float(value["x"]),
-					Read.as_float(value["y"]),
-					Read.as_float(value["width"]),
-					Read.as_float(value["height"])
-				)
-		TYPE_NODE_PATH:
-			if value.has("path"):
-				return NodePath(str(value["path"]))
-	if expected_type != TYPE_NIL and expected_type != TYPE_DICTIONARY:
-		return value
-
-	return _parse_entries(value, elements)
+	if expected_type == TYPE_NIL or expected_type == TYPE_DICTIONARY:
+		return _parse_entries(value, elements)
+	var tag: String = type_string(expected_type)
+	if Serialisation.REQUIRED.has(tag):
+		var tagged: Dictionary = value.duplicate()
+		tagged["_type"] = tag
+		var built: Variant = _values.deserialize_value(tagged)
+		if typeof(built) == expected_type:
+			return built
+	return value
 
 
 ## The entries of a dictionary a property holds, each value read as a value in its own right, and

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

@@ -19,6 +19,10 @@ extends RefCounted
 
 const PropertyValues = preload("property_values.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.
+static var scan_due: bool = false
+
 var root: Node = null
 var path: String = ""
 var _base_paths: Dictionary = {}
@@ -249,11 +253,44 @@ static func save_packed(packed: PackedScene, scene_path: String) -> Dictionary:
 static func refresh(scene_path: String) -> void:
 	if ResourceLoader.has_cached(scene_path):
 		var _replaced: Resource = ResourceLoader.load(scene_path, "", ResourceLoader.CACHE_MODE_REPLACE)
-	EditorInterface.get_resource_filesystem().scan()
+	scan_later()
 	if EditorInterface.get_open_scenes().has(scene_path):
 		EditorInterface.reload_scene_from_path(scene_path)
 
 
+## Has the editor scan its files once the call in hand has answered, rather than now.
+##
+## A scan's thread ends by writing the editor's file list to its cache, walking the list as it goes,
+## while each save made in the editor updates an entry of that list on the main thread and frees
+## what the entry held (4.7.2's [code]_save_filesystem_cache[/code] and
+## [code]EditorNode::_resource_saved[/code]). A scene saved 250 ms after a resource's scan began was
+## followed by garbage decoded as text and a dropped connection. Started at the end of the frame,
+## the scan begins after every save the call makes, and the plugin turns away calls that could save
+## until it is over.
+static func scan_later() -> void:
+	if scan_due:
+		return
+	scan_due = true
+	_start_scan.call_deferred()
+
+
+## [method EditorFileSystem.scan] does nothing, and says nothing, while the thread of the scan
+## before it is still to be joined, which is a frame or two after that scan stops reporting itself,
+## so a scan that leaves the editor not scanning is asked for once more once that is over. Asked of
+## a scan that ended within the call, the second costs one more scan.
+static func _start_scan() -> void:
+	var filesystem: EditorFileSystem = EditorInterface.get_resource_filesystem()
+	var tree: SceneTree = Engine.get_main_loop()
+	while filesystem.is_scanning() or filesystem.is_importing():
+		await tree.process_frame
+	filesystem.scan()
+	if not filesystem.is_scanning():
+		await tree.process_frame
+		await tree.process_frame
+		filesystem.scan()
+	scan_due = false
+
+
 ## Whether the editor holds unsaved changes to [param scene_path], for a read to say that the file
 ## it answers from is not what the editor shows.
 static func unsaved(scene_path: String) -> bool:

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

@@ -246,6 +246,52 @@ func deserialize_value(value: Variant) -> Variant:
 	return call(builder, fields)
 
 
+## The components a path reads off [param value], by the names GDScript gives them, or none for a
+## value that has none: a vector's axes, a colour's channels, a rectangle's corners and size, a
+## transform's basis and origin. A value of one of these is a copy wherever it is read, so a write
+## into a component is a write into the copy until it is put back where it was read from.
+static func components_of(value: Variant) -> PackedStringArray:
+	match typeof(value):
+		TYPE_VECTOR2, TYPE_VECTOR2I:
+			return PackedStringArray(["x", "y"])
+		TYPE_VECTOR3, TYPE_VECTOR3I:
+			return PackedStringArray(["x", "y", "z"])
+		TYPE_VECTOR4, TYPE_VECTOR4I, TYPE_QUATERNION:
+			return PackedStringArray(["x", "y", "z", "w"])
+		TYPE_COLOR:
+			return PackedStringArray(
+				[
+					"r",
+					"g",
+					"b",
+					"a",
+					"r8",
+					"g8",
+					"b8",
+					"a8",
+					"h",
+					"s",
+					"v",
+					"ok_hsl_h",
+					"ok_hsl_s",
+					"ok_hsl_l"
+				]
+			)
+		TYPE_RECT2, TYPE_RECT2I, TYPE_AABB:
+			return PackedStringArray(["position", "size", "end"])
+		TYPE_PLANE:
+			return PackedStringArray(["normal", "x", "y", "z", "d"])
+		TYPE_BASIS:
+			return PackedStringArray(["x", "y", "z"])
+		TYPE_TRANSFORM2D:
+			return PackedStringArray(["x", "y", "origin"])
+		TYPE_TRANSFORM3D:
+			return PackedStringArray(["basis", "origin"])
+		TYPE_PROJECTION:
+			return PackedStringArray(["x", "y", "z", "w"])
+	return PackedStringArray()
+
+
 ## Whether [param entries] is a list of [key, value] pairs, as a Dictionary tag carries them.
 static func pairs(entries: Variant) -> bool:
 	if not entries is Array:

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

@@ -95,6 +95,7 @@ func _init_tools() -> void:
 		"rescan_filesystem": [_filesystem_tools, "rescan_filesystem"],
 		"scan_status": [_filesystem_tools, "scan_status"],
 		"reimport_files": [_filesystem_tools, "reimport_files"],
+		"files_moved": [_filesystem_tools, "files_moved"],
 		"global_classes": [_class_tools, "global_classes"],
 		"reload_script": [_class_tools, "reload_script"],
 		# Settings, for a caller that asked the editor rather than the file on disk

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

@@ -117,9 +117,31 @@ func reload_script(args: Dictionary) -> Dictionary:
 			answer["restoredAs"] = error_string(restored)
 	answer["methods"] = _method_names(script)
 	answer["constants"] = _constant_names(script)
+	_reread_open_tabs(path, answer)
 	return answer
 
 
+## Has the script editor's tabs reread what changed on disk, as the editor does when its window takes
+## the focus, which a hidden editor's never does. A tab with unsaved edits is left alone and named:
+## saving it writes its text over the file, and rereading would ask a question nobody can answer in a
+## hidden editor's dialog.
+func _reread_open_tabs(path: String, answer: Dictionary) -> void:
+	# The engine fixtures reload from a script run outside any editor, where there are no tabs and
+	# EditorInterface has none of its methods.
+	if not Engine.is_editor_hint():
+		return
+	var scripts: ScriptEditor = EditorInterface.get_script_editor()
+	var unsaved: PackedStringArray = scripts.get_unsaved_files()
+	if path in unsaved:
+		answer["unsavedInEditor"] = true
+		return
+	var rereads: Variant = EditorInterface.get_editor_settings().get_setting(
+		"text_editor/behavior/files/auto_reload_scripts_on_external_change"
+	)
+	if unsaved.is_empty() and rereads is bool and rereads:
+		scripts.reload_open_files()
+
+
 ## [param path] as the files on disk spell it, a step at a time, or as given where a step is not
 ## there. On a filesystem that ignores case, `res://Core/Rules.gd` opens the file at
 ## `res://core/rules.gd`, but the editor holds its copy under the spelling on disk, and a load by