gdharness 1.3.41 → 1.3.43

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

@@ -1,6 +1,5 @@
 @tool
 extends RefCounted
-
 ## The groups a node of a scene is in. A scene's own file puts a node in a group and can take it
 ## out of one it put it in; a group the scene that makes the node puts it in, the one it is
 ## instanced from or one this scene inherits, can be changed only there, as the editor's group dock
@@ -15,20 +14,20 @@ static func read(scene: GdhSceneFile, node: Node) -> Dictionary:
 	var all: Array = _sorted(node.get_groups())
 	if all.is_empty():
 		return {}
-	var answer: Dictionary = {"groups": all}
+	var answer: Dictionary = { "groups": all }
 	var here: Array = _sorted(scene.groups_at(scene.path_of(node)))
 	if here.size() != all.size():
 		answer["groupsHere"] = here
 	return answer
 
 
-## The groups of [param node], just added to this scene and put in [param adding] there, in the shape
-## [method read] answers: this scene's file does not hold the node until it is saved.
+## The groups of [param node], just added to this scene and put in [param adding] there, in the
+## shape [method read] answers: this scene's file does not hold the node until it is saved.
 static func read_added(node: Node, adding: Array) -> Dictionary:
 	var all: Array = _sorted(node.get_groups())
 	if all.is_empty():
 		return {}
-	var answer: Dictionary = {"groups": all}
+	var answer: Dictionary = { "groups": all }
 	var here: Array = []
 	for group: String in _sorted(adding):
 		if not here.has(group):
@@ -65,19 +64,27 @@ static func change(scene: GdhSceneFile, node: Node, adding: Array, removing: Arr
 			var held: Array = _sorted(node.get_groups())
 			return (
 				"%s is in no group %s; %s."
-				% [node.name, name, "it is in " + ", ".join(held) if not held.is_empty() else "it is in none"]
+				% [
+					node.name,
+					name,
+					"it is in " + ", ".join(held) if not held.is_empty() else "it is in none",
+				]
 			)
 		if not here.has(name):
 			var from: String = scene.values_from(node, at)
 			if from.is_empty():
 				return (
-					"%s is in %s, which no scene file puts it in: something puts it there as it is made, such as its script."
+					(
+						"%s is in %s, which no scene file puts it in: something puts it there as "
+						+ "it is made, such as its script."
+					)
 					% [node.name, name]
 				)
 			return (
 				(
-					"%s is in %s because %s puts it there, and no scene using that one can take it out: "
-					+ "remove the group in %s, which takes it out in every scene using that one."
+					"%s is in %s because %s puts it there, and no scene using that one can take it "
+					+ "out: remove the group in %s, which takes it out in every scene using that "
+					+ "one."
 				)
 				% [node.name, name, from, from]
 			)

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

@@ -1,8 +1,7 @@
 @tool
 extends RefCounted
-
-## The two ways a scene keeps its own values for nodes another scene makes: by inheriting that scene,
-## or by instancing it with its children editable.
+## The two ways a scene keeps its own values for nodes another scene makes: by inheriting that
+## scene, or by instancing it with its children editable.
 
 const GdhFileReads = preload("../file_reads.gd")
 const GdhPaths = preload("scene_paths.gd")
@@ -18,11 +17,11 @@ static func taken(scene_path: String) -> Dictionary:
 		"error":
 		(
 			(
-				"%s already exists, and scene_create op=create would replace everything in it. Edit it "
-				+ "with scene_node, or create the scene under another path."
+				"%s already exists, and scene_create op=create would replace everything in it. "
+				+ "Edit it with scene_node, or create the scene under another path."
 			)
 			% scene_path
-		)
+		),
 	}
 
 
@@ -32,12 +31,15 @@ static func inherited(
 	args: Dictionary, scene_path: String, base_path: String, script_path: String
 ) -> Dictionary:
 	if scene_path.is_empty():
-		return {"ok": false, "error": "Missing scenePath"}
+		return { "ok": false, "error": "Missing scenePath" }
 	if args.has("rootNodeType"):
 		return {
 			"ok": false,
 			"error":
-			"inherits takes the root's class from %s, so rootNodeType is not given with it." % base_path
+			(
+				"inherits takes the root's class from %s, so rootNodeType is not given with it."
+				% base_path
+			),
 		}
 	if FileAccess.file_exists(scene_path):
 		return taken(scene_path)
@@ -45,10 +47,10 @@ static func inherited(
 	if not script_path.is_empty():
 		script = load(script_path) as Script
 		if script == null:
-			return {"ok": false, "error": "No script loads from " + script_path}
+			return { "ok": false, "error": "No script loads from " + script_path }
 		var uncompiled: String = GdhSceneFile.uncompiled(script, script_path)
 		if not uncompiled.is_empty():
-			return {"ok": false, "error": uncompiled}
+			return { "ok": false, "error": uncompiled }
 	return inherit(scene_path, base_path, str(args.get("rootNodeName", "")), script)
 
 
@@ -57,17 +59,22 @@ static func inherited(
 ## given. Answers what scene_create answers, or a refusal.
 ##
 ## Written as the text the editor's New Inherited Scene saves rather than packed from an instance of
-## the base: a headless engine making that instance runs every script in the base, and the pack would
-## keep what they set as this scene's own values.
-static func inherit(scene_path: String, base_path: String, root_name: String, script: Script) -> Dictionary:
+## the base: a headless engine making that instance runs every script in the base, and the pack
+## would keep what they set as this scene's own values.
+static func inherit(
+	scene_path: String, base_path: String, root_name: String, script: Script
+) -> Dictionary:
 	var base: Dictionary = GdhFileReads.scene_node(base_path, ".")
 	if not base.get("ok", false):
-		return {"ok": false, "error": "inherits: " + str(base.get("error", "%s holds no nodes" % base_path))}
+		return {
+			"ok": false,
+			"error": "inherits: " + str(base.get("error", "%s holds no nodes" % base_path)),
+		}
 	var root_type: String = str(base["type"])
 	var name: String = str(base["name"]) if root_name.is_empty() else root_name
 	var unfit: String = GdhSceneFile.unfit_name(name)
 	if not unfit.is_empty():
-		return {"ok": false, "error": unfit}
+		return { "ok": false, "error": unfit }
 	if script != null:
 		var extended: String = str(script.get_instance_base_type())
 		if not ClassDB.is_parent_class(root_type, extended):
@@ -77,11 +84,11 @@ static func inherit(scene_path: String, base_path: String, root_name: String, sc
 				(
 					"%s extends %s, so it cannot be on the %s root %s inherits."
 					% [script.resource_path, extended, root_type, base_path]
-				)
+				),
 			}
 	var folder: String = GdhSceneFile.make_folder_for(scene_path)
 	if not folder.is_empty():
-		return {"ok": false, "error": folder}
+		return { "ok": false, "error": folder }
 
 	var lines: PackedStringArray = [
 		'[gd_scene format=3 uid="%s"]' % ResourceUID.id_to_text(ResourceUID.create_id()),
@@ -105,18 +112,24 @@ static func inherit(scene_path: String, base_path: String, root_name: String, sc
 	if file == null or not file.store_string("\n".join(lines) + "\n"):
 		return {
 			"ok": false,
-			"error": "Could not write %s: %s" % [scene_path, error_string(FileAccess.get_open_error())]
+			"error":
+			"Could not write %s: %s" % [scene_path, error_string(FileAccess.get_open_error())],
 		}
 	file.close()
 
-	var loaded: PackedScene = ResourceLoader.load(scene_path, "PackedScene", ResourceLoader.CACHE_MODE_IGNORE)
+	var loaded: PackedScene = ResourceLoader.load(
+		scene_path, "PackedScene", ResourceLoader.CACHE_MODE_IGNORE
+	)
 	var instanced: PackedScene = loaded.get_state().get_node_instance(0) if loaded != null else null
 	if instanced == null or instanced.resource_path != base_path:
 		var _removed: Error = DirAccess.remove_absolute(scene_path)
 		return {
 			"ok": false,
 			"error":
-			"%s did not load back as a scene inheriting %s, so it was removed." % [scene_path, base_path]
+			(
+				"%s did not load back as a scene inheriting %s, so it was removed."
+				% [scene_path, base_path]
+			),
 		}
 	GdhSceneFile.refresh(scene_path)
 	var answer: Dictionary = {
@@ -124,17 +137,23 @@ static func inherit(scene_path: String, base_path: String, root_name: String, sc
 		"scenePath": scene_path,
 		"inherits": base_path,
 		"rootNodeType": root_type,
-		"rootNodeName": name
+		"rootNodeName": name,
 	}
-	if script != null:
-		answer["script"] = script.resource_path
+	var properties: Dictionary = base["properties"]
+	var carried: Variant = script if script != null else properties.get("script")
+	if carried is Script:
+		var carried_script: Script = carried
+		answer["script"] = carried_script.resource_path
+		if not str(carried_script.get_global_name()).is_empty():
+			answer["scriptClass"] = str(carried_script.get_global_name())
 	return answer
 
 
 ## Makes the children of [param node], an instance in [param scene], editable or not, answering why
 ## it cannot or "". With them editable the scene keeps its own values for them, as the editor's
 ## Editable Children does; made not editable again, the values it kept for them are dropped. The
-## caller has had [method GdhSceneFile.foreign] refuse a node inside an instance that is not editable.
+## caller has had [method GdhSceneFile.foreign] refuse a node inside an instance that is not
+## editable.
 static func set_editable(scene: GdhSceneFile, node: Node, editable: bool) -> String:
 	if node.owner == null or node.scene_file_path.is_empty():
 		return (
@@ -156,7 +175,9 @@ static func set_editable(scene: GdhSceneFile, node: Node, editable: bool) -> Str
 ## for a node deleted, they are only named. Answers followed, the scenes rewritten, and
 ## notFollowed, each one left as it was with why, each only when it names any, with what
 ## [param carried] gives.
-static func follow(changed: String, old_path: String, new_path: String, carried: GdhPaths) -> Dictionary:
+static func follow(
+	changed: String, old_path: String, new_path: String, carried: GdhPaths
+) -> Dictionary:
 	var texts: Dictionary = {}
 	_read_scenes("res://", texts)
 	var kin: Array[String] = [changed]
@@ -182,7 +203,7 @@ static func follow(changed: String, old_path: String, new_path: String, carried:
 			moves[old_path] = new_path
 		var read: Dictionary = GdhFileReads.scene_tree(scene_path, -1, false, false)
 		if not read.get("ok", false):
-			not_followed.append({"scenePath": scene_path, "reason": str(read.get("error", ""))})
+			not_followed.append({ "scenePath": scene_path, "reason": str(read.get("error", "")) })
 			continue
 		var tree: Dictionary = read["tree"]
 		_instances_of(tree, changed, old_path, new_path, moves)
@@ -193,28 +214,29 @@ static func follow(changed: String, old_path: String, new_path: String, carried:
 			rewritten = _rewritten(text, moves, old_path.get_base_dir() != new_path.get_base_dir())
 		if rewritten != text:
 			if not unsaved.is_empty():
-				not_followed.append({"scenePath": scene_path, "reason": unsaved})
+				not_followed.append({ "scenePath": scene_path, "reason": unsaved })
 				continue
 			var file: FileAccess = FileAccess.open(scene_path, FileAccess.WRITE)
 			if file == null or not file.store_string(rewritten):
 				not_followed.append(
-					{"scenePath": scene_path, "reason": error_string(FileAccess.get_open_error())}
+					{ "scenePath": scene_path, "reason": error_string(FileAccess.get_open_error()) }
 				)
 				continue
 			file.close()
 			GdhSceneFile.refresh(scene_path)
 			followed.append(scene_path)
 		var holds_paths: bool = text.contains("NodePath(")
-		# A script is only read, for the lines naming the node, so it does not need the file written.
+		# A script is only read, for the lines naming the node, so it does not need the file
+		# written.
 		if moves.is_empty() or not (holds_paths or text.contains('Script"')):
 			continue
 		if holds_paths and not unsaved.is_empty() and not new_path.is_empty():
-			not_followed.append({"scenePath": scene_path, "reason": unsaved})
+			not_followed.append({ "scenePath": scene_path, "reason": unsaved })
 			continue
 		var before: int = carried.retargeted.size()
 		var unwritten: String = carried.carry_into(scene_path, moves)
 		if not unwritten.is_empty() and not followed.has(scene_path):
-			not_followed.append({"scenePath": scene_path, "reason": unwritten})
+			not_followed.append({ "scenePath": scene_path, "reason": unwritten })
 		elif carried.retargeted.size() > before and not followed.has(scene_path):
 			followed.append(scene_path)
 	var answer: Dictionary = carried.answer()
@@ -233,7 +255,9 @@ static func _read_scenes(directory: String, texts: Dictionary) -> void:
 			_read_scenes(directory.path_join(name), texts)
 	for name: String in DirAccess.get_files_at(directory):
 		if name.ends_with(".tscn"):
-			texts[directory.path_join(name)] = FileAccess.get_file_as_string(directory.path_join(name))
+			texts[directory.path_join(name)] = FileAccess.get_file_as_string(
+				directory.path_join(name)
+			)
 
 
 ## Whether the scene at [param scene_path] inherits [param changed], through any number of scenes.
@@ -248,19 +272,22 @@ static func _inherits(scene_path: String, changed: String, texts: Dictionary) ->
 	return false
 
 
-## The scene the root of [param text] inherits, or "": a root entry naming an instance and no parent.
+## The scene the root of [param text] inherits, or "": a root entry naming an instance and no
+## parent.
 static func _base_of(text: String) -> String:
 	for line: String in text.split("\n"):
 		if not line.begins_with("[node "):
 			continue
-		var instanced: RegExMatch = RegEx.create_from_string('instance=ExtResource\\("([^"]+)"\\)').search(
-			line
+		var instanced: RegExMatch = (
+			RegEx.create_from_string('instance=ExtResource\\("([^"]+)"\\)').search(line)
 		)
 		if instanced == null or line.contains(" parent="):
 			return ""
 		var named: RegExMatch = (
 			RegEx
-			. create_from_string('\\[ext_resource [^\\n]*path="([^"]+)" id="%s"\\]' % instanced.get_string(1))
+			. create_from_string(
+				'\\[ext_resource [^\\n]*path="([^"]+)" id="%s"\\]' % instanced.get_string(1)
+			)
 			. search(text)
 		)
 		return named.get_string(1) if named != null else ""
@@ -284,10 +311,11 @@ static func _instances_of(
 
 ## [param text] with every path [param moves] names, and every path below one, moved.
 ##
-## Beside a path the saver writes the unique_ids of the nodes along it, which the loader follows when
-## the path has vanished. A rename leaves those ids as they were; with [param reparented] they run
-## through the old parent, which still exists, so a recovery would find the wrong node. They are left
-## out of each path moved, as a hand-written scene leaves them, and the next save writes them anew.
+## Beside a path the saver writes the unique_ids of the nodes along it, which the loader follows
+## when the path has vanished. A rename leaves those ids as they were; with [param reparented] they
+## run through the old parent, which still exists, so a recovery would find the wrong node. They are
+## left out of each path moved, as a hand-written scene leaves them, and the next save writes them
+## anew.
 static func _rewritten(text: String, moves: Dictionary, reparented: bool) -> String:
 	if moves.is_empty():
 		return text
@@ -309,7 +337,11 @@ static func _rewritten(text: String, moves: Dictionary, reparented: bool) -> Str
 				var placed: String = _attribute_set(
 					line, "parent", "." if moved_parent.is_empty() else moved_parent
 				)
-				line = _without_ids(placed, "parent_id_path") if placed != line and reparented else placed
+				line = (
+					_without_ids(placed, "parent_id_path")
+					if placed != line and reparented
+					else placed
+				)
 			else:
 				line = _attribute_moved(line, "parent", "parent_id_path", moves, reparented)
 		lines[at] = line
@@ -333,8 +365,8 @@ static func _attribute_set(line: String, attribute: String, value: String) -> St
 	return line.substr(0, found.get_start(1)) + value + line.substr(found.get_end(1))
 
 
-## [param line] with the path under [param attribute] moved by [param moves], and, when that moved it
-## and the move was a reparent, without the ids under [param ids] that went along the old path.
+## [param line] with the path under [param attribute] moved by [param moves], and, when that moved
+## it and the move was a reparent, without the ids under [param ids] that went along the old path.
 static func _attribute_moved(
 	line: String, attribute: String, ids: String, moves: Dictionary, reparented: bool
 ) -> String:

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

@@ -1,6 +1,5 @@
 @tool
 extends RefCounted
-
 ## The node paths scenes hold, carried after a node moves as the editor's own rename carries them:
 ## the NodePath values on their nodes, inside arrays, dictionaries and the resources built into the
 ## scene too, and the tracks of the animations their players play. After a delete they are named
@@ -9,7 +8,11 @@ extends RefCounted
 ## A path is worked out from where its holder was and where it pointed before the move, so it is
 ## followed in a scene loaded after the move as well, where the old path no longer resolves.
 
-enum { UNCHANGED, REWRITTEN, DELETED }
+enum {
+	UNCHANGED,
+	REWRITTEN,
+	DELETED,
+}
 
 const GdhHeadlessCheck = preload("../headless_check.gd")
 const GdhRead = preload("../reading.gd")
@@ -87,7 +90,7 @@ func carry(scene: GdhSceneFile, moves: Dictionary) -> int:
 			var name: String = str(property["name"])
 			if not _may_hold_paths(property):
 				continue
-			var entry: Dictionary = {"scenePath": scene.path, "nodePath": now, "property": name}
+			var entry: Dictionary = { "scenePath": scene.path, "nodePath": now, "property": name }
 			var elsewhere: String = "" if set_here.has(name) else from
 			var carried: Array = _carried(node.get(name), was, now, entry, elsewhere)
 			if carried[0]:
@@ -241,10 +244,12 @@ static func _may_hold_paths(property: Dictionary) -> bool:
 ## it carried, as [whether any was, the value]. A resource built into the scene is changed in place.
 ## [param entry] says where the value is held, for the record of each path. A path in a resource may
 ## be relative to something other than its holder, as the editor allows; it is followed only when it
-## names a node from where its holder was, as one relative to the holder does. A value [param
-## elsewhere], a file other than the scene's, gives is named only when it names nothing since the
-## move, which its own file's pass could not see.
-func _carried(value: Variant, was: String, now: String, entry: Dictionary, elsewhere: String) -> Array:
+## names a node from where its holder was, as one relative to the holder does. A value
+## [param elsewhere], a file other than the scene's, gives is named only when it names nothing since
+## the move, which its own file's pass could not see.
+func _carried(
+	value: Variant, was: String, now: String, entry: Dictionary, elsewhere: String
+) -> Array:
 	match typeof(value):
 		TYPE_NODE_PATH:
 			var path: NodePath = value
@@ -256,7 +261,10 @@ func _carried(value: Variant, was: String, now: String, entry: Dictionary, elsew
 					not_retargeted.append(
 						_left(
 							record,
-							"The value is set in %s, and an edit here would not be saved there." % elsewhere
+							(
+								"The value is set in %s, and an edit here would not be saved there."
+								% elsewhere
+							)
 						)
 					)
 			elif after[0] == DELETED:
@@ -350,7 +358,9 @@ func _after(path: NodePath, was: String, now: String) -> Array:
 ## Whether [param path], held by the node at [param now], names no node.
 func _names_nothing(path: NodePath, now: String) -> bool:
 	var holder: Node = _scene.root.get_node_or_null(now)
-	return holder != null and holder.get_node_or_null(NodePath(path.get_concatenated_names())) == null
+	return (
+		holder != null and holder.get_node_or_null(NodePath(path.get_concatenated_names())) == null
+	)
 
 
 ## The path to [param target] through the unique node that was at [param start], written through its
@@ -424,8 +434,9 @@ func _tracks(mixer: AnimationMixer, now: String) -> void:
 			var animation: Animation = library.get_animation(animation_name)
 			var home: Dictionary = _home_of(animation, library)
 			var why: String = home["why"]
-			# Carried once, from the first scene playing it. One kept in a file of its own that this call
-			# rewrote is held in _homes, so a later scene loading that file is given this same copy.
+			# Carried once, from the first scene playing it. One kept in a file of its own that this
+			# call rewrote is held in _homes, so a later scene loading that file is given this same
+			# copy.
 			if _seen.has(animation):
 				continue
 			_seen[animation] = true
@@ -466,13 +477,14 @@ func _tracks(mixer: AnimationMixer, now: String) -> void:
 
 
 ## Where an edit to [param animation], played from [param library], is saved, as {file, home, why,
-## theirs}: file "" with the scene, or the file of its own it or its library is kept in, with home the
-## resource saved there; why, when nothing written here would keep the edit; theirs, when that is
-## because it is kept in another scene or an imported file, whose tracks are written in its terms.
+## theirs}: file "" with the scene, or the file of its own it or its library is kept in, with home
+## the resource saved there; why, when nothing written here would keep the edit; theirs, when that
+## is because it is kept in another scene or an imported file, whose tracks are written in its
+## terms.
 func _home_of(animation: Animation, library: AnimationLibrary) -> Dictionary:
 	var file: String = animation.resource_path.get_slice("::", 0)
 	if file.is_empty() or file == _scene.path:
-		return {"file": "", "why": ""}
+		return { "file": "", "why": "" }
 	var home: Resource = animation
 	if animation.resource_path.contains("::"):
 		home = library if library.resource_path == file else null
@@ -483,18 +495,21 @@ func _home_of(animation: Animation, library: AnimationLibrary) -> Dictionary:
 		}
 	if not Engine.is_editor_hint():
 		var script: Script = home.get_script()
-		if (script != null and not script.is_tool()) or GdhHeadlessCheck.holds_scripted_embedded(home, {}):
+		if (
+			(script != null and not script.is_tool())
+			or GdhHeadlessCheck.holds_scripted_embedded(home, {})
+		):
 			return {
 				"why":
 				(
 					(
 						(
-							"%s holds a resource with a script that is not a tool, which a headless engine runs as "
-							+ "it loads the file. "
+							"%s holds a resource with a script that is not a tool, which a "
+							+ "headless engine runs as it loads the file. "
 						)
 						% file
 					)
 					+ GdhHeadlessCheck.REMEDY
-				)
+				),
 			}
-	return {"file": file, "home": home, "why": ""}
+	return { "file": file, "home": home, "why": "" }

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

@@ -1,6 +1,5 @@
 @tool
 extends RefCounted
-
 ## What a new node in a scene is made or copied from, what the scene owns of it, and where among its
 ## siblings a node may go.
 
@@ -15,7 +14,8 @@ static func what_to_add(node_type: String, instance_path: String, scene_path: St
 	if node_type.is_empty() == instance_path.is_empty():
 		return [
 			null,
-			"add takes nodeType for a node of a class, or instancePath for a scene, and one of them only."
+			"add takes nodeType for a node of a class, or instancePath for a scene, and one of "
+			+ "them only.",
 		]
 	if not instance_path.is_empty():
 		# Asked before the cycle walk, which reads the file's dependencies and so loaded a file that
@@ -35,9 +35,12 @@ static func what_to_add(node_type: String, instance_path: String, scene_path: St
 		return [
 			null,
 			(
-				"nodeType must be a node class, and %s is a scene: pass it as instancePath to instance it."
+				(
+					"nodeType must be a node class, and %s is a scene: pass it as instancePath to "
+					+ "instance it."
+				)
 				% node_type
-			)
+			),
 		]
 	if not ClassDB.class_exists(node_type) or not ClassDB.is_parent_class(node_type, "Node"):
 		return [null, not_a_node_class("nodeType", node_type)]
@@ -73,10 +76,12 @@ static func made(packed: PackedScene, node_type: String) -> Node:
 static func copied(source: Node, root: Node, copies: Dictionary) -> Node:
 	var copy: Node = null
 	if not source.scene_file_path.is_empty():
-		# An instanced scene made again from its file, so the copy is an instance too. Node.duplicate
-		# makes a plain node of the instance's class, and the pack saved it with every property of the
-		# instance's root frozen into this scene.
-		var packed: PackedScene = ResourceLoader.load(source.scene_file_path, "PackedScene") as PackedScene
+		# An instanced scene made again from its file, so the copy is an instance too.
+		# Node.duplicate makes a plain node of the instance's class, and the pack saved it with
+		# every property of the instance's root frozen into this scene.
+		var packed: PackedScene = (
+			ResourceLoader.load(source.scene_file_path, "PackedScene") as PackedScene
+		)
 		if packed == null:
 			return null
 		copy = packed.instantiate(PackedScene.GEN_EDIT_STATE_INSTANCE)
@@ -123,7 +128,11 @@ static func reconnect(copies: Dictionary, top: Node) -> void:
 				if not flags & Object.CONNECT_PERSIST or target == null:
 					continue
 				var to: Object = copies.get(target, target)
-				if to == target and target is Node and (target == top or top.is_ancestor_of(target as Node)):
+				if (
+					to == target
+					and target is Node
+					and (target == top or top.is_ancestor_of(target as Node))
+				):
 					continue
 				var aimed: Callable = Callable(to, callable.get_method())
 				if (
@@ -131,7 +140,10 @@ static func reconnect(copies: Dictionary, top: Node) -> void:
 					and copy.connect(signal_name, aimed, flags) != OK
 				):
 					push_error(
-						"gdharness: could not copy the connection %s of %s" % [signal_name, source.name]
+						(
+							"gdharness: could not copy the connection %s of %s"
+							% [signal_name, source.name]
+						)
 					)
 
 
@@ -150,7 +162,9 @@ static func own(node: Node, root: Node) -> void:
 static func unplaceable(parent: Node, node: Node, asked: Variant) -> String:
 	if asked == null:
 		return ""
-	var others: int = parent.get_child_count() - (1 if node != null and node.get_parent() == parent else 0)
+	var others: int = (
+		parent.get_child_count() - (1 if node != null and node.get_parent() == parent else 0)
+	)
 	var at: int = GdhRead.as_int(asked, -1)
 	if at < 0 or at > others:
 		return (
@@ -159,7 +173,7 @@ static func unplaceable(parent: Node, node: Node, asked: Variant) -> String:
 				str(at) if asked is int or asked is float else JSON.stringify(asked),
 				others,
 				parent.name,
-				others
+				others,
 			]
 		)
 	return ""
@@ -234,7 +248,8 @@ static func _spatial_space(parent: Node) -> Transform3D:
 	return space
 
 
-## Where the children of [param parent] are drawn in 2D, as [method _spatial_space] works it out in 3D.
+## Where the children of [param parent] are drawn in 2D, as [method _spatial_space] works it out in
+## 3D.
 static func _canvas_space(parent: Node) -> Transform2D:
 	var space: Transform2D = Transform2D.IDENTITY
 	var at: Node = parent

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

@@ -0,0 +1,66 @@
+@tool
+extends RefCounted
+## Where else in a scene a resource built into it is held, since such a resource is one object
+## wherever the scene uses it.
+
+const GdhPropertyPaths = preload("../property_paths.gd")
+const GdhRead = preload("../reading.gd")
+const GdhSceneFile = preload("../scene_file.gd")
+
+
+## Every other place in [param scene] holding a resource that [param key] was written through on
+## [param node], as {node, property}. A copy made by duplicate shares its original's resources, so
+## the write changed each of them too.
+static func holders(scene: GdhSceneFile, node: Node, key: String) -> Array[Dictionary]:
+	var found_at: Array[Dictionary] = []
+	var through: Array = GdhPropertyPaths.holder_of(node, key, GdhPropertyPaths.home_of(node))[2]
+	if through.is_empty():
+		return found_at
+	var wanted: Dictionary = {}
+	for reached: Resource in through:
+		wanted[reached.get_instance_id()] = true
+	var nodes: Array[Node] = [scene.root]
+	nodes.append_array(scene.root.find_children("*", "", true, false))
+	for at: Node in nodes:
+		for declared: Dictionary in at.get_property_list():
+			var property: String = str(declared.get("name", ""))
+			if (
+				property.is_empty()
+				or not (GdhRead.as_int(declared.get("usage", 0)) & PROPERTY_USAGE_STORAGE)
+			):
+				continue
+			for found: String in _paths_to(at.get(property), property, wanted, {}):
+				if at != node or not key.begins_with(found + "/"):
+					found_at.append({ "node": scene.path_of(at), "property": found })
+	return found_at
+
+
+## The paths below [param path] at which [param value] holds a resource of [param wanted], by
+## instance id, stepping into lists and into resources built into a scene.
+static func _paths_to(
+	value: Variant, path: String, wanted: Dictionary, seen: Dictionary
+) -> Array[String]:
+	var paths: Array[String] = []
+	if value is Array:
+		var items: Array = value
+		for index: int in items.size():
+			paths.append_array(_paths_to(items[index], "%s/%d" % [path, index], wanted, seen))
+		return paths
+	if not value is Resource:
+		return paths
+	var held: Resource = value
+	var id: int = held.get_instance_id()
+	if wanted.has(id):
+		paths.append(path)
+	var built_in: bool = held.resource_path.is_empty() or held.resource_path.contains("::")
+	if seen.has(id) or not built_in:
+		return paths
+	seen[id] = true
+	for declared: Dictionary in held.get_property_list():
+		var property: String = str(declared.get("name", ""))
+		if (
+			not property.is_empty()
+			and GdhRead.as_int(declared.get("usage", 0)) & PROPERTY_USAGE_STORAGE
+		):
+			paths.append_array(_paths_to(held.get(property), path + "/" + property, wanted, seen))
+	return paths

package/build/godot/addons/gdharness_editor/tools/scene_sharing.gd.uid

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