gdharness 1.3.40 → 1.3.42

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

@@ -64,7 +64,13 @@ static func scene_states(scene_path: String, tree_path: String, state_machine_pa
 			player_path = "."
 		var found: Array = _bare(scene_path, player_path, "AnimationPlayer")
 		player = found[0]
-	var answer: Dictionary = states(tree, state_machine_path, player, player_path)
+	var reached: Node = null
+	if player == null and not player_path.is_empty():
+		reached = _bare(scene_path, player_path, "Node")[0]
+	var unplayed: String = no_player(str(tree.anim_player), reached)
+	if reached != null:
+		reached.free()
+	var answer: Dictionary = states(tree, state_machine_path, player, player_path, unplayed)
 	tree.free()
 	if player != null:
 		player.free()
@@ -236,6 +242,20 @@ static func no_machine(tree: AnimationTree, state_machine_path: String) -> Strin
 	return "No state machine at " + state_machine_path
 
 
+## Why no state finds its animation when [param anim_player], an AnimationTree's path to its
+## player, reaches no AnimationPlayer: [param reached] is the node it reaches instead, null for none.
+static func no_player(anim_player: String, reached: Node) -> String:
+	var until: String = "so no state plays anything until scene_node set points anim_player at one."
+	if anim_player.is_empty():
+		return "The AnimationTree has no anim_player, " + until
+	if reached == null:
+		return "The AnimationTree's anim_player %s reaches no node, %s" % [anim_player, until]
+	return (
+		"The AnimationTree's anim_player %s reaches %s, a %s rather than an AnimationPlayer, %s"
+		% [anim_player, reached.name, reached.get_class(), until]
+	)
+
+
 ## Why a state playing [param animation_name] from [param player], at [param player_path] from the
 ## scene root as playerNodePath takes it, plays nothing yet. anim_player is relative to the tree
 ## ("../Anim"), which no argument takes.
@@ -254,9 +274,14 @@ static func missing_animation(player: AnimationPlayer, player_path: String, anim
 
 ## The states and transitions of the state machine at [param state_machine_path] in [param tree].
 ## A state playing an animation says whether [param player], at [param player_path], has it, as
-## add_state answers: a state naming one it lacks plays nothing, and says so only in a log.
+## add_state answers: a state naming one it lacks plays nothing, and says so only in a log. With no
+## player, each says [param unplayed], what [method no_player] made of the tree's path.
 static func states(
-	tree: AnimationTree, state_machine_path: String, player: AnimationPlayer, player_path: String
+	tree: AnimationTree,
+	state_machine_path: String,
+	player: AnimationPlayer,
+	player_path: String,
+	unplayed: String
 ) -> Dictionary:
 	var sm: AnimationNodeStateMachine = state_machine(tree, state_machine_path)
 	if sm == null:
@@ -270,7 +295,9 @@ static func states(
 			entry["animationName"] = str(plays.animation)
 			var found: bool = player != null and player.has_animation(plays.animation)
 			entry["animationFound"] = found
-			if player != null and not found:
+			if player == null:
+				entry["animationMissing"] = unplayed
+			elif not found:
 				entry["animationMissing"] = missing_animation(player, player_path, str(plays.animation))
 		listed.append(entry)
 	var transitions: Array[Dictionary] = []

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

@@ -11,6 +11,7 @@ extends RefCounted
 ## initialisers run, and a resource with a script is made with it.
 
 const GdhRead = preload("reading.gd")
+const GdhFileWalk = preload("file_walk.gd")
 const GdhSame = preload("same_values.gd")
 const GdhSerialisation = preload("serialisation.gd")
 const GdhShapes = preload("value_shapes.gd")
@@ -487,7 +488,7 @@ static func _stored(type: String, given: Dictionary, include_defaults: bool) ->
 static func resource(res_path: String, include_defaults: bool) -> Dictionary:
 	var file: String = res_path.get_slice("::", 0)
 	if not FileAccess.file_exists(file):
-		return {"ok": false, "error": "No resource at " + file}
+		return {"ok": false, "error": GdhFileWalk.new().with_nearest_files("No resource at " + file, file)}
 	var whole: Resource = ResourceLoader.load(file, "", ResourceLoader.CACHE_MODE_IGNORE)
 	if whole == null:
 		return {"ok": false, "error": "%s did not load as a resource." % file}
@@ -516,6 +517,18 @@ static func resource(res_path: String, include_defaults: bool) -> Dictionary:
 			scripted[str(declared.get("name", ""))] = true
 	var serialiser: GdhSerialisation = GdhSerialisation.new()
 	var properties: Dictionary = {}
+	# A headless engine runs a script that is not a tool as the file loads, so what its _init and
+	# setters gave other properties read as values the file sets; the file's own lines say which it
+	# does. The editor runs no such script.
+	var untooled: bool = script != null and not script.is_tool() and not Engine.is_editor_hint()
+	var from_file: bool = (
+		untooled and file.ends_with(".tres") and not GdhShapes.STORED_APART.has(loaded.get_class())
+	)
+	var set_in_file: Dictionary = (
+		_names_set_in(FileAccess.get_file_as_string(file), res_path.trim_prefix(file).trim_prefix("::"))
+		if from_file
+		else {}
+	)
 	# A Curve's points are read off one with none, since the engine has no default for point_0.
 	var fresh: Object = (
 		ClassDB.instantiate(loaded.get_class()) if GdhShapes.STORED_APART.has(loaded.get_class()) else null
@@ -537,6 +550,8 @@ static func resource(res_path: String, include_defaults: bool) -> Dictionary:
 			)
 			if GdhSame.same(value, default):
 				continue
+			if from_file and not set_in_file.has(property):
+				continue
 		properties[property] = serialiser.serialize_value(value)
 	var answer: Dictionary = {
 		"ok": true, "resourcePath": res_path, "resourceType": loaded.get_class(), "properties": properties
@@ -551,6 +566,26 @@ static func resource(res_path: String, include_defaults: bool) -> Dictionary:
 	return answer
 
 
+## The names the [code][resource][/code] section of [param text], a .tres file, sets, or those of the
+## embedded resource with the id [param id] when one is given, as a set.
+static func _names_set_in(text: String, id: String) -> Dictionary:
+	var names: Dictionary = {}
+	var inside: bool = false
+	var key: RegEx = RegEx.create_from_string("^([^\\s=\\[][^=]*?) = ")
+	for line: String in text.split("\n"):
+		if line.begins_with("["):
+			inside = (
+				line.begins_with("[resource]")
+				if id.is_empty()
+				else line.begins_with("[sub_resource") and line.contains('id="%s"' % id)
+			)
+			continue
+		var found: RegExMatch = key.search(line) if inside else null
+		if found != null:
+			names[found.get_string(1)] = true
+	return names
+
+
 ## The resource [param file] keeps under [param id], found in [param value] or anything it holds.
 ## The engine loads such a path only while the file is cached, and a read loads the file uncached,
 ## so it is looked for among what the file holds. A resource of another file is neither taken nor

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

@@ -35,8 +35,24 @@ static func missing_reason(path: String) -> String:
 
 ## [param said], the refusal for [param path], a res:// path nothing is at, with the files of its
 ## extension whose names are nearest its own, or every one when there are few and none is near, so
-## the caller has a path to send instead.
+## the caller has a path to send instead. Files of the same name beside it come first, since a
+## misspelt extension has no file of its own extension to be near.
 func with_nearest_files(said: String, path: String) -> String:
+	# One the refusal names is the file it refuses, as a script given for a scene is. Word by word,
+	# since res://brain.gd is inside res://brain.gdd.
+	var named: Array[String] = []
+	for word: String in said.replace("\n", " ").replace(",", " ").replace(";", " ").split(" ", false):
+		named.append(word.rstrip(".:"))
+	var namesakes: Array[String] = []
+	for file: String in _namesakes(path):
+		if not file in named:
+			namesakes.append(file)
+	if not namesakes.is_empty():
+		var alone: bool = namesakes.size() == 1
+		return (
+			"%s. The %s of that name beside it %s %s."
+			% [said, "file" if alone else "files", "is" if alone else "are", ", ".join(namesakes)]
+		)
 	var extension: String = path.get_extension()
 	if extension.is_empty():
 		return said
@@ -65,6 +81,22 @@ func with_nearest_files(said: String, path: String) -> String:
 	return "%s. None of the project's %d .%s files is named like it." % [said, files.size(), extension]
 
 
+# The files in [param path]'s folder named as it is with another extension, leaving out the import
+# and uid files the engine keeps beside a file, which are named after the whole file name.
+static func _namesakes(path: String) -> Array[String]:
+	var found: Array[String] = []
+	var folder: String = path.get_base_dir()
+	if not DirAccess.dir_exists_absolute(folder):
+		return found
+	var stem: String = path.get_file().get_basename()
+	var files: PackedStringArray = DirAccess.get_files_at(folder)
+	files.sort()
+	for file: String in files:
+		if file.get_basename() == stem and file != path.get_file():
+			found.append(folder.path_join(file))
+	return found
+
+
 # A directory the engine steps over, marker file and all.
 func is_stepped_over(path: String) -> bool:
 	return FileAccess.file_exists(path + ".gdignore")

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

@@ -505,6 +505,35 @@ static func setter_ran(object: Object, property: String, refused: String) -> Str
 	)
 
 
+## Moves out of alsoChanged in [param answer] each of [param names], what a headless write put back
+## as the doing of the script of [param owner], which is not a tool, to setByScript, with a note
+## saying why the file does not hold it.
+static func move_script_set(answer: Dictionary, names: Array, owner: String) -> void:
+	if not answer.has("alsoChanged"):
+		return
+	var changed: Dictionary = answer["alsoChanged"]
+	var by_script: Dictionary = {}
+	for key: Variant in names:
+		if changed.has(key):
+			by_script[key] = changed[key]
+			var _erased: bool = changed.erase(key)
+	if by_script.is_empty():
+		return
+	if changed.is_empty():
+		var _dropped: bool = answer.erase("alsoChanged")
+	answer["setByScript"] = by_script
+	var listed: Array = by_script.keys()
+	var pronoun: String = "it" if listed.size() == 1 else "them"
+	answer["setByScriptNote"] = (
+		(
+			"%s's script is not a tool, so it ran in the headless engine that wrote the file, and set %s "
+			+ "as it did. The file does not hold %s, as a save from the editor, where the script does not "
+			+ "run, would not; the script sets %s again when it runs in the game."
+		)
+		% [owner, ", ".join(listed), pronoun, pronoun]
+	)
+
+
 ## Why [param name] on [param what] cannot be saved as the file held it.
 static func unasked(what: String, name: String, why: String = "") -> String:
 	return (

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

@@ -383,19 +383,16 @@ func _readable(value: Variant, relative_to: Node) -> Variant:
 	return _values.serialize_value(value)
 
 
-## What [param target] stores, by name, but its script and the properties in [param leave]. A list
-## or a map is copied, since a setter can change the one it holds in place.
+## What [param target] stores, by name, but its script and the properties in [param leave], in the
+## names a read answers with: a Curve's points as point_0/position and the rest rather than the _data
+## list every point write changes. A list or a map is copied, since a setter can change the one it
+## holds in place.
 func _stored(target: Object, leave: Dictionary) -> Dictionary:
 	var held: Dictionary = {}
-	for entry: Dictionary in target.get_property_list():
+	for entry: Dictionary in GdhShapes.read_properties(target):
 		var name: String = str(entry["name"])
 		var usage: int = GdhRead.as_int(entry["usage"])
-		if (
-			usage & PROPERTY_USAGE_STORAGE == 0
-			or usage & HEADINGS != 0
-			or name == "script"
-			or leave.has(name)
-		):
+		if usage & HEADINGS != 0 or name == "script" or leave.has(name):
 			continue
 		var value: Variant = target.get(name)
 		if value is Array:

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

@@ -45,6 +45,17 @@ var root: Node = null
 var path: String = ""
 ## What the last write saved, for its answer to read what the file now stores.
 var written_pack: PackedScene = null
+## The properties a headless write put back on each node the tool changed, by instance id, as a
+## set: what the node's script, which is not a tool, changed as the tool wrote, and the file was
+## not given.
+var restored_by_write: Dictionary = {}
+## What the scene loads with where it stores what the tool gave, by node path and then property:
+## the node's script changed the value as the copy the write checks loaded.
+var loads_as: Dictionary = {}
+## The node paths in [member loads_as] whose script is not a tool, so an editor does not run it.
+var loads_untooled: Dictionary = {}
+## The pack a write's check reads, for [method stores] to answer from.
+var _checked_pack: PackedScene = null
 ## The path of each node a scene this one inherits gives, with the file that makes it.
 var _base_paths: Dictionary = {}
 var _state: SceneState = null
@@ -564,6 +575,19 @@ func kept(saved: Node, loaded: Variant, given: Variant) -> bool:
 	return GdhSame.same(loaded, given)
 
 
+## Whether the pack a write is checking stores [param given] for [param property] on the node at
+## [param at], a path from the root.
+func stores(at: String, property: String, given: Variant) -> bool:
+	if _checked_pack == null:
+		return false
+	var state: SceneState = _checked_pack.get_state()
+	for index: int in state.get_node_count():
+		if _relative(str(state.get_node_path(index))) == at:
+			var stored: Dictionary = _stored_at(state, index)
+			return stored.has(property) and GdhSame.same(stored[property], given)
+	return false
+
+
 ## Packs [member root], has [param check] read the result as the file will hold it, and writes the
 ## file only if the check answers "". Frees [member root] either way.
 ##
@@ -592,6 +616,7 @@ func write(check: Callable = Callable()) -> Dictionary:
 		var saved: Node = packed.instantiate(PackedScene.GEN_EDIT_STATE_MAIN)
 		if saved == null:
 			return refuse("The packed copy of %s did not instantiate, so nothing was written." % path)
+		_checked_pack = packed
 		var missing: String = str(check.call(saved))
 		saved.free()
 		if not missing.is_empty():
@@ -777,8 +802,10 @@ func _settled(packed: PackedScene) -> Array:
 		for found: Array in moved:
 			var node: Node = found[0]
 			var before: Dictionary = _before[node.get_instance_id()]
+			var restored: Dictionary = restored_by_write.get_or_add(node.get_instance_id(), {})
 			for name: String in found[1]:
 				node.set(name, before.get(name, GdhHeadlessCheck.default_of(node, name)))
+				restored[name] = true
 		current = PackedScene.new()
 		var packing: Error = current.pack(root)
 		if packing != OK:

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

@@ -29,7 +29,8 @@ func add_animation_state(args: Dictionary) -> Dictionary:
 	# are in use in every state machine.
 	if sm.has_node(StringName(state_name)):
 		return scene.refuse("The state machine already has a state named %s." % state_name)
-	var player: AnimationPlayer = anim_tree.get_node_or_null(anim_tree.anim_player) as AnimationPlayer
+	var reached: Node = anim_tree.get_node_or_null(anim_tree.anim_player)
+	var player: AnimationPlayer = reached as AnimationPlayer
 	var found: bool = player != null and player.has_animation(StringName(animation_name))
 
 	var anim_node: AnimationNodeAnimation = AnimationNodeAnimation.new()
@@ -57,7 +58,9 @@ func add_animation_state(args: Dictionary) -> Dictionary:
 	}
 	# Written all the same, as the editor writes one: a state machine is often laid out before its
 	# animations are made, and refusing it stopped a tree being built in that order.
-	if player != null and not found:
+	if player == null:
+		answer["animationMissing"] = GdhAnimationReads.no_player(str(anim_tree.anim_player), reached)
+	elif not found:
 		answer["animationMissing"] = GdhAnimationReads.missing_animation(
 			player, scene.path_of(player), animation_name
 		)

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

@@ -259,9 +259,13 @@ func read_animation_states(args: Dictionary) -> Dictionary:
 	if opened[1] == null:
 		return opened[2]
 	var anim_tree: AnimationTree = opened[1]
-	var player: AnimationPlayer = anim_tree.get_node_or_null(anim_tree.anim_player) as AnimationPlayer
+	var reached: Node = anim_tree.get_node_or_null(anim_tree.anim_player)
+	var player: AnimationPlayer = reached as AnimationPlayer
 	var player_path: String = "" if player == null else scene.path_of(player)
-	return _read_in(scene, GdhAnimationReads.states(anim_tree, state_machine_path, player, player_path))
+	var unplayed: String = GdhAnimationReads.no_player(str(anim_tree.anim_player), reached)
+	return _read_in(
+		scene, GdhAnimationReads.states(anim_tree, state_machine_path, player, player_path, unplayed)
+	)
 
 
 # =============================================================================

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

@@ -246,6 +246,7 @@ func create_resource(args: Dictionary) -> Dictionary:
 	var failed: String = _save_checked(resource, res_path, properties.keys(), null)
 	if not failed.is_empty():
 		return {"ok": false, "error": failed}
+	_note_put_back(answer, resource, res_path)
 	if not properties.is_empty():
 		answer["properties"] = _held(resource, properties.keys())
 	return answer
@@ -302,10 +303,24 @@ func modify_resource(args: Dictionary) -> Dictionary:
 	var failed: String = _save_checked(resource, res_path, properties.keys(), previous)
 	if not failed.is_empty():
 		return {"ok": false, "error": failed}
+	_note_put_back(answer, resource, res_path)
 	answer["properties"] = _held(resource, properties.keys())
 	return answer
 
 
+## Moves to setByScript each property alsoChanged in [param answer] gave a value [param resource] no
+## longer holds once saved at [param path]: the save put it back as its script's doing.
+func _note_put_back(answer: Dictionary, resource: Resource, path: String) -> void:
+	var noted: Dictionary = answer.get("alsoChanged", {})
+	var restored: Array = []
+	for key: Variant in noted:
+		var now: Variant = _values.serialize_value(_properties.read_at(resource, str(key)))
+		var entry: Dictionary = noted[key]
+		if JSON.stringify(now) != JSON.stringify(entry.get("now")):
+			restored.append(key)
+	GdhHeadlessCheck.move_script_set(answer, restored, path)
+
+
 ## Why [param resource], saved at [param path], cannot hold what [param names] were given, or "": a
 ## resource cannot hold the file it is saved as. Godot saves the reference as null with only a
 ## warning in its log, and the read back after the save reported the property as one the file does

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

@@ -126,8 +126,13 @@ static func inherit(scene_path: String, base_path: String, root_name: String, sc
 		"rootNodeType": root_type,
 		"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
 
 

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

@@ -0,0 +1,59 @@
+@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

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

@@ -15,6 +15,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,7 +44,16 @@ 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 "
@@ -142,7 +152,6 @@ func _create_of_a_class(args: Dictionary) -> Dictionary:
 
 	if scene_path.is_empty():
 		return {"ok": false, "error": "Missing scenePath"}
-	var asked_type: String = root_node_type
 	var made: Dictionary = GdhSceneFile.made_as(
 		root_node_type,
 		"" if script_path.is_empty() else GdhSceneFile.res_path(project_path, script_path),
@@ -200,13 +209,20 @@ func _create_of_a_class(args: Dictionary) -> Dictionary:
 	if not folder.is_empty():
 		root.free()
 		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()
 	if not written.is_empty():
 		return written
 
 	var answer: Dictionary = {
-		"ok": true, "scenePath": scene_path, "rootNodeType": asked_type, "rootNodeName": root_node_name
+		"ok": true,
+		"scenePath": scene_path,
+		"rootNodeType": root_class["nodeType"],
+		"rootNodeName": root_node_name
 	}
+	if root_class.has("scriptClass"):
+		answer["scriptClass"] = root_class["scriptClass"]
 	if not script_path.is_empty():
 		answer["script"] = script_path
 	if not had_folder:
@@ -241,7 +257,6 @@ func add_node(args: Dictionary) -> Dictionary:
 
 	if node_name.is_empty():
 		return {"ok": false, "error": "Missing nodeName"}
-	var asked_type: String = node_type
 	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")
@@ -301,13 +316,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,
-		"nodeType": asked_type if class_script != null else new_node.get_class(),
-		"nodePath": new_path,
-		"index": new_node.get_index(),
-	}
+	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()})
 	if not properties.is_empty():
 		var held: Dictionary = {}
 		for key: Variant in properties:
@@ -316,6 +327,7 @@ 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(
@@ -328,6 +340,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
@@ -518,6 +532,7 @@ func reparent_node(args: Dictionary) -> 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
+	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
@@ -527,6 +542,11 @@ 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)
@@ -643,6 +663,13 @@ func set_node_properties(args: Dictionary) -> Dictionary:
 	var new_path: String = scene.path_of(node)
 	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,6 +680,7 @@ func set_node_properties(args: Dictionary) -> Dictionary:
 	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 id: int = node.get_instance_id()
 	var written: Dictionary = scene.write(
 		func(saved: Node) -> String:
 			var unkept: String = _kept(scene, saved, node, properties.keys())
@@ -674,12 +702,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.