gdharness 1.3.41 → 1.3.43

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

@@ -1,6 +1,5 @@
 @tool
 extends Node
-
 ## Scenes and their nodes, edited in the open editor and read back from what it holds.
 
 const GdhDeclared = preload("../declared_values.gd")
@@ -15,6 +14,7 @@ const GdhPlacing = preload("scene_placing.gd")
 const GdhPropertyValues = preload("../property_values.gd")
 const GdhSame = preload("../same_values.gd")
 const GdhSceneFile = preload("../scene_file.gd")
+const GdhSceneSharing = preload("scene_sharing.gd")
 const GdhSerialisation = preload("../serialisation.gd")
 const GdhTilesetTools = preload("tileset_tools.gd")
 
@@ -43,11 +43,20 @@ func _kept(scene: GdhSceneFile, saved: Node, node: Node, names: Array) -> String
 	for key: Variant in names:
 		var property: String = str(key)
 		var loaded: Variant = _properties.read_at(copy, property)
-		if not scene.kept(saved, loaded, _properties.read_at(node, property)):
+		var given: Variant = _properties.read_at(node, property)
+		if not scene.kept(saved, loaded, given):
+			# The file holds it, and the copy's own script set it again as the copy loaded, as it
+			# will wherever the scene loads; an editor saves the same.
+			if scene.stores(at, property, given):
+				var on: Dictionary = scene.loads_as.get_or_add(at, {})
+				if GdhHeadlessCheck.untooled(copy.get_script()):
+					scene.loads_untooled[at] = true
+				on[property] = _values.serialize_value(loaded)
+				continue
 			return (
 				(
-					"%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."
+					"%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), "", false)]
 			)
@@ -141,7 +150,7 @@ func _create_of_a_class(args: Dictionary) -> Dictionary:
 	var script_path: String = str(args.get("script", ""))
 
 	if scene_path.is_empty():
-		return {"ok": false, "error": "Missing scenePath"}
+		return { "ok": false, "error": "Missing scenePath" }
 	var made: Dictionary = GdhSceneFile.made_as(
 		root_node_type,
 		"" if script_path.is_empty() else GdhSceneFile.res_path(project_path, script_path),
@@ -149,18 +158,21 @@ func _create_of_a_class(args: Dictionary) -> Dictionary:
 		"rootNodeType"
 	)
 	if made.has("error"):
-		return {"ok": false, "error": made["error"]}
+		return { "ok": false, "error": made["error"] }
 	root_node_type = str(made["type"])
 	script_path = str(made["script"])
 	# A class that is not a node went into a Node variable, which is a runtime error the caller
 	# heard about only as "Invalid tool result".
-	if not ClassDB.class_exists(root_node_type) or not ClassDB.is_parent_class(root_node_type, "Node"):
-		return {"ok": false, "error": GdhPlacing.not_a_node_class("rootNodeType", root_node_type)}
+	if (
+		not ClassDB.class_exists(root_node_type)
+		or not ClassDB.is_parent_class(root_node_type, "Node")
+	):
+		return { "ok": false, "error": GdhPlacing.not_a_node_class("rootNodeType", root_node_type) }
 	if not ClassDB.can_instantiate(root_node_type):
-		return {"ok": false, "error": "%s cannot be instantiated." % root_node_type}
+		return { "ok": false, "error": "%s cannot be instantiated." % root_node_type }
 	var unfit: String = GdhSceneFile.unfit_name(root_node_name)
 	if not unfit.is_empty():
-		return {"ok": false, "error": unfit}
+		return { "ok": false, "error": unfit }
 	if FileAccess.file_exists(scene_path):
 		return GdhKin.taken(scene_path)
 
@@ -176,29 +188,32 @@ func _create_of_a_class(args: Dictionary) -> Dictionary:
 		var script: Script = load(full_script_path) as Script
 		if script == null:
 			root.free()
-			return {"ok": false, "error": "No script loads from " + full_script_path}
+			return { "ok": false, "error": "No script loads from " + full_script_path }
 		var uncompiled: String = GdhSceneFile.uncompiled(script, full_script_path)
 		if not uncompiled.is_empty():
 			root.free()
-			return {"ok": false, "error": uncompiled}
+			return { "ok": false, "error": uncompiled }
 		var base: String = str(script.get_instance_base_type())
 		if not ClassDB.is_parent_class(root_node_type, base):
 			root.free()
 			return {
 				"ok": false,
 				"error":
-				"%s extends %s, so it cannot be on a %s root." % [full_script_path, base, root_node_type]
+				(
+					"%s extends %s, so it cannot be on a %s root."
+					% [full_script_path, base, root_node_type]
+				),
 			}
 		root.set_script(script)
-		# Named again, since a headless engine runs the script's _init as it is attached, and a node's
-		# name is no property the write compares.
+		# Named again, since a headless engine runs the script's _init as it is attached, and a
+		# node's name is no property the write compares.
 		root.name = root_node_name
 
 	var had_folder: bool = DirAccess.dir_exists_absolute(scene_path.get_base_dir())
 	var folder: String = GdhSceneFile.make_folder_for(scene_path)
 	if not folder.is_empty():
 		root.free()
-		return {"ok": false, "error": folder}
+		return { "ok": false, "error": folder }
 	# Read before the write, which frees the root.
 	var root_class: Dictionary = GdhSceneFile.class_of(root)
 	var written: Dictionary = scene.write()
@@ -209,7 +224,7 @@ func _create_of_a_class(args: Dictionary) -> Dictionary:
 		"ok": true,
 		"scenePath": scene_path,
 		"rootNodeType": root_class["nodeType"],
-		"rootNodeName": root_node_name
+		"rootNodeName": root_node_name,
 	}
 	if root_class.has("scriptClass"):
 		answer["scriptClass"] = root_class["scriptClass"]
@@ -229,7 +244,9 @@ func list_scene_nodes(args: Dictionary) -> Dictionary:
 
 	# Read as a headless engine reads it with no editor connected, so the answer does not depend on
 	# whether one is.
-	var read: Dictionary = GdhFileReads.scene_tree(scene_path, depth, include_properties, include_defaults)
+	var read: Dictionary = GdhFileReads.scene_tree(
+		scene_path, depth, include_properties, include_defaults
+	)
 	if read.get("ok", false):
 		read["unsavedInEditor"] = GdhSceneFile.unsaved(scene_path)
 	return read
@@ -246,12 +263,12 @@ func add_node(args: Dictionary) -> Dictionary:
 	var adding: Array = GdhGroups.asked(args, "addGroups")
 
 	if node_name.is_empty():
-		return {"ok": false, "error": "Missing nodeName"}
+		return { "ok": false, "error": "Missing nodeName" }
 	var class_script: Script = null
 	if not node_type.is_empty() and not ClassDB.class_exists(node_type):
 		var declared: Dictionary = GdhSceneFile.script_class(node_type, "Node")
 		if declared.has("error"):
-			return {"ok": false, "error": declared["error"]}
+			return { "ok": false, "error": declared["error"] }
 		var held: Variant = declared.get("script")
 		if held is Script:
 			class_script = held
@@ -259,7 +276,7 @@ func add_node(args: Dictionary) -> Dictionary:
 	var making: Array = GdhPlacing.what_to_add(node_type, instance_path, scene_path)
 	var packed: PackedScene = making[0]
 	if not str(making[1]).is_empty():
-		return {"ok": false, "error": making[1]}
+		return { "ok": false, "error": making[1] }
 
 	var opened: Array = _open(scene_path, true)
 	var scene: GdhSceneFile = opened[0]
@@ -270,7 +287,9 @@ func add_node(args: Dictionary) -> Dictionary:
 	var root: Node = scene.root
 	var parent: Node = GdhSceneFile.node_at(root, parent_node_path)
 	if not parent:
-		return scene.refuse(scene.not_found("Parent node not found: " + parent_node_path, 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)
@@ -306,9 +325,9 @@ func add_node(args: Dictionary) -> Dictionary:
 
 	var new_path: String = scene.path_of(new_node)
 	# Read before the write, which frees the scene it was added to.
-	var answer: Dictionary = {"ok": true, "nodeName": node_name}
+	var answer: Dictionary = { "ok": true, "nodeName": node_name }
 	answer.merge(GdhSceneFile.class_of(new_node))
-	answer.merge({"nodePath": new_path, "index": new_node.get_index()})
+	answer.merge({ "nodePath": new_path, "index": new_node.get_index() })
 	if not properties.is_empty():
 		var held: Dictionary = {}
 		for key: Variant in properties:
@@ -317,10 +336,14 @@ func add_node(args: Dictionary) -> Dictionary:
 	_properties.note_write(answer, new_node)
 	if not adding.is_empty():
 		answer.merge(GdhGroups.read_added(new_node, adding))
+	var id: int = new_node.get_instance_id()
 	var written: Dictionary = scene.write(
 		func(saved: Node) -> String:
 			var unkept: String = _kept(
-				scene, saved, new_node, properties.keys() + (["script"] if class_script != null else [])
+				scene,
+				saved,
+				new_node,
+				properties.keys() + (["script"] if class_script != null else [])
 			)
 			if unkept.is_empty() and saved.get_node_or_null(new_path) != null:
 				unkept = GdhGroups.unkept(saved.get_node(new_path), adding, [])
@@ -329,6 +352,8 @@ func add_node(args: Dictionary) -> Dictionary:
 	if not written.is_empty():
 		return written
 
+	_note_put_back(answer, scene, id, new_path)
+	_note_loads_as(answer, scene, new_path)
 	if packed != null:
 		answer["instanceOf"] = instance_path
 	return answer
@@ -344,9 +369,9 @@ func delete_node(args: Dictionary) -> Dictionary:
 			"ok": false,
 			"error":
 			(
-				"The root cannot be deleted, since a scene has exactly one. Delete the nodes under it, or "
-				+ "make a scene with another root with scene_create."
-			)
+				"The root cannot be deleted, since a scene has exactly one. Delete the nodes under "
+				+ "it, or make a scene with another root with scene_create."
+			),
 		}
 
 	var opened: Array = _open(scene_path, true)
@@ -370,7 +395,7 @@ func delete_node(args: Dictionary) -> Dictionary:
 	node.get_parent().remove_child(node)
 	node.free()
 	var carried: GdhPaths = GdhPaths.new()
-	var _rewritten: int = carried.carry(scene, {at: ""})
+	var _rewritten: int = carried.carry(scene, { at: "" })
 
 	var written: Dictionary = scene.write(
 		func(saved: Node) -> String:
@@ -381,7 +406,7 @@ func delete_node(args: Dictionary) -> Dictionary:
 	if not written.is_empty():
 		return written
 
-	var answer: Dictionary = {"ok": true, "deletedNodePath": at}
+	var answer: Dictionary = { "ok": true, "deletedNodePath": at }
 	if not went.is_empty():
 		answer["deletedWithIt"] = went
 	answer.merge(GdhKin.follow(scene_path, at, "", carried))
@@ -396,7 +421,7 @@ func duplicate_node(args: Dictionary) -> Dictionary:
 	var parent_path: String = str(args.get("parentNodePath", ""))
 
 	if node_path.is_empty() or new_name.is_empty():
-		return {"ok": false, "error": "Missing nodePath or newName"}
+		return { "ok": false, "error": "Missing nodePath or newName" }
 
 	var opened: Array = _open(scene_path, true)
 	var scene: GdhSceneFile = opened[0]
@@ -453,7 +478,9 @@ func duplicate_node(args: Dictionary) -> Dictionary:
 			if copy == null:
 				return "the copy would not be in the scene when it loads."
 			if copy.get_index() != placed[1]:
-				return "%s would load at index %d, not %d." % [new_path, copy.get_index(), placed[1]]
+				return (
+					"%s would load at index %d, not %d." % [new_path, copy.get_index(), placed[1]]
+				)
 			return ""
 	)
 	if not written.is_empty():
@@ -476,9 +503,9 @@ func reparent_node(args: Dictionary) -> Dictionary:
 	var new_parent_path: String = str(args.get("newParentPath", ""))
 
 	if node_path.is_empty() or node_path == ".":
-		return {"ok": false, "error": "Cannot reparent root node"}
+		return { "ok": false, "error": "Cannot reparent root node" }
 	if new_parent_path.is_empty():
-		return {"ok": false, "error": "Missing newParentPath"}
+		return { "ok": false, "error": "Missing newParentPath" }
 
 	var opened: Array = _open(scene_path, true)
 	var scene: GdhSceneFile = opened[0]
@@ -492,7 +519,9 @@ func reparent_node(args: Dictionary) -> Dictionary:
 	if not node:
 		return scene.refuse(scene.not_found("Node not found: " + node_path, node_path))
 	if not new_parent:
-		return scene.refuse(scene.not_found("New parent not found: " + new_parent_path, 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)
@@ -518,9 +547,12 @@ func reparent_node(args: Dictionary) -> Dictionary:
 	var drawn_at: Dictionary = {}
 	for property: String in GdhPlacing.placing(node):
 		drawn_at[property] = _properties.read_at(node, property)
-	var held_at: Transform3D = (node as Node3D).transform if node is Node3D else Transform3D.IDENTITY
-	# Unowned while it moves: a node taken out of the tree keeps its owner, and adding it under the new
-	# parent warned that the owner was not above it. Node.reparent warns the same way.
+	var held_at: Transform3D = (
+		(node as Node3D).transform if node is Node3D else Transform3D.IDENTITY
+	)
+	var stored_before: Dictionary = GdhHeadlessCheck.stored(node)
+	# Unowned while it moves: a node taken out of the tree keeps its owner, and adding it under the
+	# new parent warned that the owner was not above it. Node.reparent warns the same way.
 	node.owner = null
 	old_parent.remove_child(node)
 	new_parent.add_child(node)
@@ -528,22 +560,30 @@ func reparent_node(args: Dictionary) -> Dictionary:
 	GdhPlacing.own(node, root)
 	if GdhRead.as_bool(args.get("keepGlobalTransform", true)):
 		GdhPlacing.keep_in_place(node, old_parent)
+		# Unasked, a headless write takes the move on a node whose script is not a tool for the
+		# script's doing and puts the node back as the file held it.
+		var placed: Array[String] = GdhHeadlessCheck.differing(node, stored_before, {})
+		if not placed.is_empty():
+			scene.asked(node, placed)
 	var also_changed: Dictionary = {}
 	for property: String in drawn_at:
 		var now: Variant = _properties.read_at(node, property)
 		if not GdhSame.same(now, drawn_at[property]):
-			also_changed[property] = {"was": _readable(node, drawn_at[property]), "now": _readable(node, now)}
+			also_changed[property] = {
+				"was": _readable(node, drawn_at[property]), "now": _readable(node, now),
+			}
 	var sheared: String = ""
 	if node is Node3D and GdhPlacing.sheared((node as Node3D).basis):
 		var spatial: Node3D = node
 		also_changed["transform"] = {
-			"was": _readable(node, held_at), "now": _readable(node, spatial.transform)
+			"was": _readable(node, held_at), "now": _readable(node, spatial.transform),
 		}
 		sheared = (
 			(
-				"%s keeps where it is drawn under %s, which is scaled unevenly across the way it is turned,"
-				+ " so its basis is sheared: no position, rotation and scale describe it, and transform is"
-				+ " what it holds. keepGlobalTransform false keeps its own transform instead."
+				"%s keeps where it is drawn under %s, which is scaled unevenly across the way it "
+				+ "is turned, so its basis is sheared: no position, rotation and scale describe "
+				+ "it, and transform is what it holds. keepGlobalTransform false keeps its own "
+				+ "transform instead."
 			)
 			% [str(node.name), new_parent_path]
 		)
@@ -551,7 +591,10 @@ func reparent_node(args: Dictionary) -> Dictionary:
 	var new_path: String = scene.path_of(node)
 	var index: int = node.get_index()
 	var carried: GdhPaths = GdhPaths.new()
-	var _rewritten: int = carried.carry(scene, {old_path: new_path} if new_path != old_path else {})
+	var _rewritten: int = carried.carry(
+		scene,
+		{ old_path: new_path } if new_path != old_path else {},
+	)
 	var written: Dictionary = scene.write(
 		func(saved: Node) -> String:
 			var copy: Node = saved.get_node_or_null(new_path)
@@ -592,7 +635,10 @@ func set_node_properties(args: Dictionary) -> Dictionary:
 	var adding: Array = GdhGroups.asked(args, "addGroups")
 	var removing: Array = GdhGroups.asked(args, "removeGroups")
 	if properties.is_empty() and editable == null and adding.is_empty() and removing.is_empty():
-		return {"ok": false, "error": "set takes properties, editableChildren, addGroups or removeGroups."}
+		return {
+			"ok": false,
+			"error": "set takes properties, editableChildren, addGroups or removeGroups.",
+		}
 
 	var opened: Array = _open(scene_path, true)
 	var scene: GdhSceneFile = opened[0]
@@ -642,8 +688,15 @@ func set_node_properties(args: Dictionary) -> Dictionary:
 	for key: Variant in properties:
 		held[str(key)] = _readable(node, _properties.read_at(node, str(key)))
 	var new_path: String = scene.path_of(node)
-	var answer: Dictionary = {"ok": true, "nodePath": new_path, "properties": held}
+	var answer: Dictionary = { "ok": true, "nodePath": new_path, "properties": held }
 	_properties.note_write(answer, node)
+	var shared: Dictionary = {}
+	for key: Variant in properties:
+		var holders: Array[Dictionary] = GdhSceneSharing.holders(scene, node, str(key))
+		if not holders.is_empty():
+			shared[str(key)] = holders
+	if not shared.is_empty():
+		answer["sharedWith"] = shared
 	if not adding.is_empty() or not removing.is_empty():
 		answer["groups"] = GdhGroups.read(scene, node).get("groups", [])
 	var named: Array[String] = []
@@ -653,16 +706,24 @@ func set_node_properties(args: Dictionary) -> Dictionary:
 			named.append(property)
 	var source: String = scene.values_from(node, old_path)
 	var carried: GdhPaths = GdhPaths.new()
-	var _rewritten: int = carried.carry(scene, {old_path: new_path} if new_path != old_path else {})
+	var _rewritten: int = carried.carry(
+		scene,
+		{ old_path: new_path } if new_path != old_path else {},
+	)
+	var id: int = node.get_instance_id()
 	var written: Dictionary = scene.write(
 		func(saved: Node) -> String:
 			var unkept: String = _kept(scene, saved, node, properties.keys())
 			if unkept.is_empty():
 				unkept = GdhGroups.unkept(saved.get_node(new_path), adding, removing)
 			if unkept.is_empty() and editable != null:
-				if saved.is_editable_instance(saved.get_node(new_path)) != GdhRead.as_bool(editable):
+				if (
+					saved.is_editable_instance(saved.get_node(new_path))
+					!= GdhRead.as_bool(editable)
+				):
 					return (
-						"%s would load with editableChildren %s." % [new_path, not GdhRead.as_bool(editable)]
+						"%s would load with editableChildren %s."
+						% [new_path, not GdhRead.as_bool(editable)]
 					)
 			return unkept
 	)
@@ -675,12 +736,48 @@ func set_node_properties(args: Dictionary) -> Dictionary:
 	if not dropped.is_empty():
 		answer["droppedValues"] = dropped["values"]
 		answer["droppedNodes"] = dropped["nodes"]
+	_note_put_back(answer, scene, id, new_path)
+	_note_loads_as(answer, scene, new_path)
 	_note_left_out(answer, scene.written_pack, new_path, named, source)
 	if new_path != old_path:
 		answer.merge(GdhKin.follow(scene_path, old_path, new_path, carried))
 	return answer
 
 
+## Puts under loadsAs in [param answer] each value given that the file holds and the script of the
+## node at [param at] changes as the scene loads, as it loads.
+static func _note_loads_as(answer: Dictionary, scene: GdhSceneFile, at: String) -> void:
+	var on: Dictionary = scene.loads_as.get(at, {})
+	if on.is_empty():
+		return
+	answer["loadsAs"] = on
+	var names: Array = on.keys()
+	var pronoun: String = "it" if names.size() == 1 else "them"
+	if scene.loads_untooled.has(at):
+		answer["loadsAsNote"] = (
+			(
+				"The file holds %s as given, which the editor shows. %s's script is not a tool, so "
+				+ "in the game it runs as the scene loads and changes %s to what loadsAs gives."
+			)
+			% [", ".join(names), at, pronoun]
+		)
+	else:
+		answer["loadsAsNote"] = (
+			(
+				"The file holds %s as given. %s's script runs as the scene loads, in the editor "
+				+ "and in the game, and changes %s to what loadsAs gives."
+			)
+			% [", ".join(names), at, pronoun]
+		)
+
+
+## Moves out of alsoChanged in [param answer] what the last write of [param scene] put back on the
+## node with instance id [param id], at [param at], to setByScript.
+static func _note_put_back(answer: Dictionary, scene: GdhSceneFile, id: int, at: String) -> void:
+	var restored: Dictionary = scene.restored_by_write.get(id, {})
+	GdhHeadlessCheck.move_script_set(answer, restored.keys(), at)
+
+
 ## Notes under notStored each of [param named] the file saved from [param pack] does not set on the
 ## node at [param at]: a set gave it the value the node has without it, so the packer leaves it out,
 ## as the editor does, and it follows [param source], or its default, from then on.
@@ -710,8 +807,8 @@ static func _note_left_out(
 	else:
 		answer["notStoredNote"] = (
 			(
-				"%s now %s what %s gives this node, so the file does not store %s, and a change there reaches "
-				+ "this node."
+				"%s now %s what %s gives this node, so the file does not store %s, and a change "
+				+ "there reaches this node."
 			)
 			% [names, verb, source, pronoun]
 		)
@@ -743,7 +840,7 @@ func get_node_properties(args: Dictionary) -> Dictionary:
 	var at: String = scene.path_of(node)
 	var here: Array = set_here.keys()
 	here.sort()
-	var answer: Dictionary = {"ok": true, "nodePath": at, "properties": props, "setHere": here}
+	var answer: Dictionary = { "ok": true, "nodePath": at, "properties": props, "setHere": here }
 	# A Node3D stores only its transform, a matrix, while a set takes the position, rotation and
 	# scale the inspector shows, so a node turned 45 degrees down read back as nine numbers. A
 	# sheared one has no such three, and is left to its transform.
@@ -764,7 +861,9 @@ func get_node_properties(args: Dictionary) -> Dictionary:
 	# A player's getter answers Master for a bus the layout does not have, while the file keeps the
 	# name, so a player left on a renamed or removed bus read as one put on Master.
 	var bus: String = str(set_here.get("bus", ""))
-	var plays: bool = node is AudioStreamPlayer or node is AudioStreamPlayer2D or node is AudioStreamPlayer3D
+	var plays: bool = (
+		node is AudioStreamPlayer or node is AudioStreamPlayer2D or node is AudioStreamPlayer3D
+	)
 	if plays and not bus.is_empty() and AudioServer.get_bus_index(bus) == -1:
 		props["bus"] = bus
 		var buses: PackedStringArray = []
@@ -772,10 +871,15 @@ func get_node_properties(args: Dictionary) -> Dictionary:
 			var _added: bool = buses.append(AudioServer.get_bus_name(index))
 		answer["busNote"] = (
 			(
-				"%s names the bus %s, which the project's bus layout does not have, so it plays on %s; "
-				+ "the buses are %s."
+				"%s names the bus %s, which the project's bus layout does not have, so it plays on "
+				+ "%s; the buses are %s."
 			)
-			% [str(node.name) if at == "." else at, bus, AudioServer.get_bus_name(0), ", ".join(buses)]
+			% [
+				str(node.name) if at == "." else at,
+				bus,
+				AudioServer.get_bus_name(0),
+				", ".join(buses),
+			]
 		)
 	# A mask reads as a number, and which layers it holds, under the names the project gives them,
 	# is what a caller reads it for.
@@ -839,7 +943,7 @@ func save_scene(args: Dictionary) -> Dictionary:
 	if target_path != scene_path:
 		var unsaved: String = GdhSceneFile.unsaved_in_editor(target_path)
 		if not unsaved.is_empty():
-			return {"ok": false, "error": unsaved}
+			return { "ok": false, "error": unsaved }
 
 	var open_root: Node = null
 	var open_roots: Array[Node] = []
@@ -859,7 +963,9 @@ func save_scene(args: Dictionary) -> Dictionary:
 		var packed: PackedScene = PackedScene.new()
 		var packing: Error = packed.pack(open_root)
 		if packing != OK:
-			return {"ok": false, "error": "Failed to pack %s: %s" % [scene_path, error_string(packing)]}
+			return {
+				"ok": false, "error": "Failed to pack %s: %s" % [scene_path, error_string(packing)],
+			}
 		written = GdhSceneFile.save_packed(packed, target_path)
 	else:
 		var scene: GdhSceneFile = GdhSceneFile.new()
@@ -875,7 +981,7 @@ func save_scene(args: Dictionary) -> Dictionary:
 		"ok": true,
 		"scenePath": scene_path,
 		"savedPath": target_path,
-		"from": "editor" if open_root != null else "file"
+		"from": "editor" if open_root != null else "file",
 	}
 
 
@@ -889,16 +995,19 @@ func _save_open_scene(scene_path: String) -> Dictionary:
 		EditorInterface.open_scene_from_path(scene_path)
 	var now: Node = EditorInterface.get_edited_scene_root()
 	if now == null or now.scene_file_path != scene_path:
-		return {"ok": false, "error": "The editor did not switch to %s to save it." % scene_path}
+		return { "ok": false, "error": "The editor did not switch to %s to save it." % scene_path }
 	var saving: Error = EditorInterface.save_scene()
 	if not previous.is_empty() and previous != scene_path:
 		EditorInterface.open_scene_from_path(previous)
 	if saving != OK:
-		return {"ok": false, "error": "The editor failed to save %s: %s" % [scene_path, error_string(saving)]}
+		return {
+			"ok": false,
+			"error": "The editor failed to save %s: %s" % [scene_path, error_string(saving)],
+		}
 	return {
 		"ok": true,
 		"scenePath": scene_path,
 		"savedPath": scene_path,
 		"from": "editor",
-		"unsavedInEditor": GdhSceneFile.unsaved(scene_path)
+		"unsavedInEditor": GdhSceneFile.unsaved(scene_path),
 	}

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

@@ -1,18 +1,21 @@
 @tool
 extends RefCounted
-
 ## The node paths a GDScript names in its own source, from the node it is on: `$Path`, `%Unique`,
 ## and a string handed to get_node, get_node_or_null or has_node called on itself. Read from the
 ## tokens rather than the lines, so a `$` or a `%` inside a string or a comment names nothing, and
 ## a `%` after an operand is the remainder of a division rather than a unique name.
 
-enum { NAME, STRING, MARK }
+enum {
+	NAME,
+	STRING,
+	MARK,
+}
 
 ## The calls that take a path from the node they are called on.
 const CALLS: Array[String] = ["get_node", "get_node_or_null", "has_node"]
 ## The words after which a `%` starts an operand.
 const OPERAND_AFTER: Array[String] = [
-	"return", "and", "or", "not", "in", "if", "elif", "while", "await", "match", "when", "else"
+	"return", "and", "or", "not", "in", "if", "elif", "while", "await", "match", "when", "else",
 ]
 ## The marks after which a `%` starts an operand: an opening bracket, a separator or an operator.
 const OPERAND_AFTER_MARKS: String = "([{,=:;+-*/<>!&|^~%"
@@ -33,10 +36,14 @@ static func named(source: String) -> Array[Dictionary]:
 		elif _is_mark(token, "%") and _starts_operand(tokens, at):
 			path = _path_from(tokens, at)
 		elif token[0] == NAME and CALLS.has(str(token[1])) and _on_itself(tokens, at):
-			if at + 2 < tokens.size() and _is_mark(tokens[at + 1], "(") and tokens[at + 2][0] == STRING:
+			if (
+				at + 2 < tokens.size()
+				and _is_mark(tokens[at + 1], "(")
+				and tokens[at + 2][0] == STRING
+			):
 				path = str(tokens[at + 2][1])
 		if not path.is_empty():
-			found.append({"line": token[2], "path": path})
+			found.append({ "line": token[2], "path": path })
 	return found
 
 
@@ -58,7 +65,8 @@ static func _path_from(tokens: Array[Array], at: int) -> String:
 	return "/".join(parts)
 
 
-## The name of a path at [param at], as [its text, where the next token is], or [] when there is none.
+## The name of a path at [param at], as [its text, where the next token is], or [] when there is
+## none.
 static func _part_at(tokens: Array[Array], at: int) -> Array:
 	var unique: String = ""
 	if at < tokens.size() and _is_mark(tokens[at], "%"):
@@ -112,7 +120,10 @@ static func _tokens(source: String) -> Array[Array]:
 				at += 1
 		elif c in " \t\r":
 			at += 1
-		elif QUOTES.contains(c) or ("r^&".contains(c) and QUOTES.contains(next) and not next.is_empty()):
+		elif (
+			QUOTES.contains(c)
+			or ("r^&".contains(c) and QUOTES.contains(next) and not next.is_empty())
+		):
 			var quoted: Array = _string(source, at if QUOTES.contains(c) else at + 1)
 			tokens.append([STRING, quoted[0], line])
 			line += str(quoted[0]).count("\n")
@@ -133,7 +144,8 @@ static func _tokens(source: String) -> Array[Array]:
 
 
 ## The string whose opening quote is at [param at], as [what is between its quotes, where it ends].
-## A backslash keeps the character after it inside the string, raw or not, as the tokenizer reads it.
+## A backslash keeps the character after it inside the string, raw or not, as the tokenizer reads
+## it.
 static func _string(source: String, at: int) -> Array:
 	var quote: String = source[at]
 	var closing: String = quote.repeat(3) if source.substr(at, 3) == quote.repeat(3) else quote

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

@@ -1,6 +1,5 @@
 @tool
 extends Node
-
 ## Project settings read from the open editor, for a caller that asked for the editor's answer, and
 ## taken up by it after a write to the file.
 ##
@@ -29,7 +28,9 @@ func get_project_setting(args: Dictionary) -> Dictionary:
 
 	var setting: String = str(args.get("setting", ""))
 	if setting.is_empty():
-		return {"ok": false, "error": "setting is required, or prefix to read every setting under one"}
+		return {
+			"ok": false, "error": "setting is required, or prefix to read every setting under one",
+		}
 
 	var result: Dictionary = GdhSettingReads.one(setting, _values)
 	result["ok"] = true
@@ -46,11 +47,11 @@ func adopt_project_settings(args: Dictionary) -> Dictionary:
 	var file: ConfigFile = ConfigFile.new()
 	var loaded: Error = file.load("res://project.godot")
 	if loaded != OK:
-		return {"ok": false, "error": "Could not read project.godot: " + error_string(loaded)}
+		return { "ok": false, "error": "Could not read project.godot: " + error_string(loaded) }
 	var adopted: Array[String] = []
 	var named: Variant = args.get("settings", [])
 	if not named is Array:
-		return {"ok": false, "error": "settings must be a list of setting names"}
+		return { "ok": false, "error": "settings must be a list of setting names" }
 	var settings: Array = named
 	for entry: Variant in settings:
 		var setting: String = str(entry)
@@ -66,19 +67,21 @@ func adopt_project_settings(args: Dictionary) -> Dictionary:
 		else:
 			ProjectSettings.set_setting(setting, null)
 		adopted.append(setting)
-	return {"ok": true, "adopted": adopted}
+	return { "ok": true, "adopted": adopted }
 
 
 ## Loads the bus layout the project names into the editor's audio server, after something else
 ## wrote it: the editor holds the layout it loaded and saves that one when its audio panel changes.
 func adopt_audio_bus_layout(_args: Dictionary) -> Dictionary:
 	var path: String = str(
-		ProjectSettings.get_setting("audio/buses/default_bus_layout", "res://default_bus_layout.tres")
+		ProjectSettings.get_setting(
+			"audio/buses/default_bus_layout", "res://default_bus_layout.tres"
+		)
 	)
 	var layout: AudioBusLayout = ResourceLoader.load(
 		path, "AudioBusLayout", ResourceLoader.CACHE_MODE_REPLACE
 	)
 	if layout == null:
-		return {"ok": false, "error": "Could not load the bus layout at " + path}
+		return { "ok": false, "error": "Could not load the bus layout at " + path }
 	AudioServer.set_bus_layout(layout)
-	return {"ok": true, "layout": path}
+	return { "ok": true, "layout": path }