gdharness 1.3.45 → 1.3.46

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

@@ -11,6 +11,11 @@ const LOOP_MODE_NAMES: Dictionary[int, String] = {
 	Animation.LOOP_LINEAR: "linear",
 	Animation.LOOP_PINGPONG: "pingpong",
 }
+const UPDATE_MODE_NAMES: Dictionary[int, String] = {
+	Animation.UPDATE_CONTINUOUS: "continuous",
+	Animation.UPDATE_DISCRETE: "discrete",
+	Animation.UPDATE_CAPTURE: "capture",
+}
 const TRACK_TYPE_NAMES: Dictionary[int, String] = {
 	Animation.TYPE_VALUE: "property",
 	Animation.TYPE_POSITION_3D: "position_3d",
@@ -166,6 +171,9 @@ static func _track(anim: Animation, track: int, values: GdhSerialisation) -> Dic
 	var property: String = str(path.get_concatenated_subnames())
 	if not property.is_empty():
 		shaped["property"] = property
+	if kind == Animation.TYPE_VALUE:
+		var mode: int = anim.value_track_get_update_mode(track)
+		shaped["update"] = UPDATE_MODE_NAMES.get(mode, str(mode))
 	var keyframes: Array[Dictionary] = []
 	var methods: Dictionary = {}
 	for key: int in anim.track_get_key_count(track):

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

@@ -38,6 +38,9 @@ static var scan_due: bool = false
 ## What the saves of a call wrote on nodes it did not ask to change, differently from their file,
 ## gathered for that call's answer as [method _also_saved] finds them.
 static var also_saved: Array[Dictionary] = []
+## What a write said of the connections it kept in the file though the engine cannot make them,
+## gathered for that call's answer as [member also_saved] is.
+static var unmade_note: String = ""
 
 var root: Node = null
 var path: String = ""
@@ -75,6 +78,11 @@ var _text: String = ""
 ## from where the node is, as it keeps layout_mode at Container under a container, and stores the
 ## same from an editor.
 var _engine_kept: Dictionary = {}
+## Each connection the file holds that the engine refused to make as it loaded the scene, as
+## {source, target, from, signal, to, method, flags, binds, unbinds}: one passing binds or unbinds
+## to a method its target lacks. A pack saves only the connections made, so [method write] puts
+## these back.
+var _unmade: Array[Dictionary] = []
 
 
 ## Opens [param scene_path], answering a refusal, or {} with [member root] set.
@@ -100,6 +108,8 @@ func open(scene_path: String, for_writing: bool) -> Dictionary:
 		return { "ok": false, "error": "Failed to instantiate " + path }
 	_state = packed.get_state()
 	_base_paths = makers(_state)
+	if for_writing:
+		_unmade = _unmade_connections(_state)
 	# On a read as well, which would otherwise answer what the scripts set as what the file holds.
 	if for_writing or not Engine.is_editor_hint():
 		for index: int in _state.get_node_count():
@@ -115,6 +125,163 @@ func open(scene_path: String, for_writing: bool) -> Dictionary:
 	return {}
 
 
+## The connections in [param state] the engine did not make on [member root]: Object.connect
+## refuses a callable that binds or unbinds arguments unless its target has the method, so the scene
+## loads without them, in the editor as well, and every save drops them.
+func _unmade_connections(state: SceneState) -> Array[Dictionary]:
+	var unmade: Array[Dictionary] = []
+	for index: int in state.get_connection_count():
+		var from: NodePath = state.get_connection_source(index)
+		var to: NodePath = state.get_connection_target(index)
+		var signal_name: StringName = state.get_connection_signal(index)
+		var method: StringName = state.get_connection_method(index)
+		var source: Node = root.get_node_or_null(from)
+		var target: Node = root.get_node_or_null(to)
+		if source == null or target == null or not source.has_signal(signal_name):
+			continue
+		var made: bool = false
+		for conn: Dictionary in source.get_signal_connection_list(signal_name):
+			var callable: Callable = conn.get("callable", Callable())
+			if callable.get_object() == target and callable.get_method() == method:
+				made = true
+				break
+		if not made:
+			unmade.append(
+				{
+					"source": source,
+					"target": target,
+					"from": str(from),
+					"signal": str(signal_name),
+					"to": str(to),
+					"method": str(method),
+					"flags": state.get_connection_flags(index),
+					"binds": state.get_connection_binds(index),
+					"unbinds": state.get_connection_unbinds(index),
+				}
+			)
+	return unmade
+
+
+## The connection the file holds that the engine could not make, from [param from].[param signal]
+## to [param to].[param method], taken out of those a write refuses to drop, since the tool removes
+## it; {} when there is none.
+func drop_unmade(from: String, signal_name: String, to: String, method: String) -> Dictionary:
+	for index: int in _unmade.size():
+		var held: Dictionary = _unmade[index]
+		var ends: Array = [held["from"], held["signal"], held["to"], held["method"]]
+		if ends == [from, signal_name, to, method]:
+			_unmade.remove_at(index)
+			return held
+	return {}
+
+
+## The [code][connection][/code] lines that put back each connection the engine could not make, at
+## its nodes' paths now. One whose source or target the call took out of the scene goes with it.
+## Read before the write frees [member root].
+func _unmade_lines() -> PackedStringArray:
+	var lines: PackedStringArray = []
+	var still: Array[Dictionary] = []
+	for held: Dictionary in _unmade:
+		var ends: Array[Node] = []
+		for end: String in ["source", "target"]:
+			var held_end: Variant = held[end]
+			if not is_instance_valid(held_end) or not held_end is Node:
+				continue
+			var node: Node = held_end
+			if node == root or root.is_ancestor_of(node):
+				ends.append(node)
+		if ends.size() < 2:
+			continue
+		var from: String = path_of(ends[0])
+		var to: String = path_of(ends[1])
+		var line: String = (
+			'[connection signal="%s" from="%s" to="%s" method="%s"'
+			% [held["signal"], from, to, held["method"]]
+		)
+		var flags: int = held["flags"]
+		if flags != Object.CONNECT_PERSIST:
+			line += " flags=%d" % flags
+		var bound: PackedStringArray = []
+		var unbinds: int = held["unbinds"]
+		if unbinds > 0:
+			line += " unbinds=%d" % unbinds
+			var _unbinding: bool = bound.append("unbinds %d" % unbinds)
+		var binds: Array = held["binds"]
+		if not binds.is_empty():
+			line += " binds= " + var_to_str(binds)
+			var _binding: bool = bound.append("binds " + var_to_str(binds))
+		var _added: bool = lines.append(line + "]")
+		var named_to: String = str(ends[1].name) if ends[1] == root else to
+		held["said"] = (
+			"%s.%s to %s.%s with %s"
+			% [
+				str(ends[0].name) if ends[0] == root else from,
+				held["signal"],
+				named_to,
+				held["method"],
+				" and ".join(bound),
+			]
+		)
+		held["lacks"] = "%s has no method %s" % [named_to, held["method"]]
+		still.append(held)
+	_unmade = still
+	return lines
+
+
+## The connections [method _unmade_lines] kept, named for a sentence.
+func _unmade_named() -> String:
+	var said: PackedStringArray = []
+	var lacking: PackedStringArray = []
+	for held: Dictionary in _unmade:
+		var _said: bool = said.append(str(held["said"]))
+		var _lacks: bool = lacking.append(str(held["lacks"]))
+	return (
+		"%s the engine cannot make as it loads the scene, %s, since %s"
+		% [
+			"a connection" if _unmade.size() == 1 else "connections",
+			"; ".join(said),
+			", ".join(lacking),
+		]
+	)
+
+
+func _unmade_remedy() -> String:
+	return (
+		"The engine connects a signal that binds or unbinds arguments only to a method its target "
+		+ "has: add the method to the target's script, or scene_signal disconnect takes the "
+		+ "connection out."
+	)
+
+
+## Adds [param lines] to the file just saved, answering "" or why they could not be added.
+func _keep_unmade(lines: PackedStringArray) -> String:
+	var saved: String = FileAccess.get_file_as_string(path)
+	var file: FileAccess = FileAccess.open(path, FileAccess.WRITE)
+	if file == null:
+		return (
+			"%s was saved without %s, and could not be opened again to put it back: %s"
+			% [path, _unmade_named(), error_string(FileAccess.get_open_error())]
+		)
+	var joined: String = "\n".join(lines) + "\n"
+	var _stored: bool = file.store_string(
+		saved + joined if saved.contains("\n[connection ") else saved + "\n" + joined
+	)
+	file.close()
+	refresh(path)
+	unmade_note = (
+		"%s holds %s. This write kept %s as the file held %s, and %s nothing until the method "
+		+ "exists. %s"
+	) % [
+		path,
+		_unmade_named(),
+		"it" if _unmade.size() == 1 else "them",
+		"it" if _unmade.size() == 1 else "them",
+		"it does" if _unmade.size() == 1 else "they do",
+		_unmade_remedy(),
+	]
+	return ""
+
+
 ## Puts back what the scene's scripts changed on every node a tool has not asked to change, as
 ## [method write] does, answering "" or why that did not hold. Called once a node has come into the
 ## scene, so what its scripts did on the way in is not taken for the tool's own change.
@@ -629,7 +796,30 @@ func stores(at: String, property: String, given: Variant) -> bool:
 ## The check reads a scene instantiated from the pack, which is what loading the file gives, so
 ## anything the pack leaves out (a property with no storage, a node the scene does not own) is seen
 ## as missing before the file is touched.
+##
+## A connection the file holds that the engine could not make is written back after the save as the
+## file held it, at its nodes' paths now, and goes only with a node of it the call deleted, since a
+## pack saves only the connections made. A binary scene cannot be added to, so there the write is
+## refused.
 func write(check: Callable = Callable()) -> Dictionary:
+	var unmade_lines: PackedStringArray = _unmade_lines()
+	if not unmade_lines.is_empty() and not path.ends_with(".tscn"):
+		return refuse(
+			(
+				"Nothing was written: %s holds %s, and a binary scene saves only the connections "
+				+ "the engine made. %s"
+			)
+			% [path, _unmade_named(), _unmade_remedy()]
+		)
+	var written: Dictionary = _write(check)
+	if written.is_empty() and not unmade_lines.is_empty():
+		var unkept: String = _keep_unmade(unmade_lines)
+		if not unkept.is_empty():
+			return refuse(unkept)
+	return written
+
+
+func _write(check: Callable) -> Dictionary:
 	var packed: PackedScene = PackedScene.new()
 	var packing: Error = packed.pack(root)
 	if packing != OK:

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

@@ -176,12 +176,16 @@ func execute_tool(tool_name: String, args: Dictionary) -> Dictionary:
 		return { "ok": false, "error": "Tool method not found: %s.%s" % [node.name, method] }
 
 	GdhSceneFile.also_saved.clear()
+	GdhSceneFile.unmade_note = ""
 	var result: Variant = node.call(method, args)
 	if result is Dictionary:
 		var answered: Dictionary = result
 		if not GdhSceneFile.also_saved.is_empty():
 			answered["alsoSaved"] = GdhSceneFile.also_saved.duplicate(true)
 			GdhSceneFile.also_saved.clear()
+		if not GdhSceneFile.unmade_note.is_empty():
+			answered["unmadeConnections"] = GdhSceneFile.unmade_note
+			GdhSceneFile.unmade_note = ""
 		return answered
 
 	return { "ok": false, "error": "Invalid tool result from: " + tool_name }

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

@@ -3,6 +3,29 @@ extends "animation_tools.gd"
 ## The tracks and keys of an animation, beside the players and libraries the script it extends
 ## edits, whose helpers it shares.
 
+## The types whose values the editor blends between keys, so it makes a track on one continuous.
+const BLENDED_TYPES: Array[int] = [
+	TYPE_FLOAT,
+	TYPE_VECTOR2,
+	TYPE_RECT2,
+	TYPE_VECTOR3,
+	TYPE_TRANSFORM2D,
+	TYPE_VECTOR4,
+	TYPE_PLANE,
+	TYPE_QUATERNION,
+	TYPE_AABB,
+	TYPE_BASIS,
+	TYPE_TRANSFORM3D,
+	TYPE_PROJECTION,
+	TYPE_COLOR,
+	TYPE_PACKED_FLOAT32_ARRAY,
+	TYPE_PACKED_FLOAT64_ARRAY,
+	TYPE_PACKED_VECTOR2_ARRAY,
+	TYPE_PACKED_VECTOR3_ARRAY,
+	TYPE_PACKED_COLOR_ARRAY,
+	TYPE_PACKED_VECTOR4_ARRAY,
+]
+
 
 # =============================================================================
 # add_animation_track, remove_animation_track
@@ -61,7 +84,7 @@ func add_animation_track(args: Dictionary) -> Dictionary:
 		)
 	var keyframes: Array = keyed[1]
 	var replacing: bool = GdhRead.as_bool(args.get("replaceKeys", false))
-	var built: Array = _add_track(anim, track, target, target_path, keyframes, replacing)
+	var built: Array = _add_track(player, anim, track, target_path, keyframes, replacing)
 	if not str(built[1]).is_empty():
 		return scene.refuse(str(built[1]))
 	var track_idx: int = built[0]
@@ -83,6 +106,9 @@ func add_animation_track(args: Dictionary) -> Dictionary:
 		"keys": keys,
 		"keysAdded": keyframes.size(),
 	}
+	if anim.track_get_type(track_idx) == Animation.TYPE_VALUE:
+		var mode: int = anim.value_track_get_update_mode(track_idx)
+		answer["update"] = GdhAnimationReads.UPDATE_MODE_NAMES.get(mode, str(mode))
 	if built[3]:
 		answer["existingTrack"] = true
 	var replaced: Array = built[5]
@@ -112,7 +138,9 @@ func add_animation_track(args: Dictionary) -> Dictionary:
 	return _finish(scene, check, files, answer)
 
 
-## Adds [param track] to [param anim] with [param keyframes], as [index, why not, methodFound,
+## Adds [param track] to [param anim] of [param player], on the node at [param target_path] from the
+## player's root, which the caller has found, with [param keyframes], as [index, why not,
+## methodFound,
 ## existing, misfit, replaced]: methodFound is null for a property track, existing is whether the
 ## keys went into a track the animation already had for that path, misfit why a method key's
 ## arguments cannot reach the method, or "", and replaced each key [param replacing] let a keyframe
@@ -122,23 +150,31 @@ func add_animation_track(args: Dictionary) -> Dictionary:
 ## animates: two tracks for one path both play, the later overriding the earlier, and a key meant
 ## to extend the motion was split off where reading the animation showed two halves.
 func _add_track(
+	player: AnimationPlayer,
 	anim: Animation,
 	track: Dictionary,
-	target: Node,
 	target_path: String,
 	keyframes: Array,
 	replacing: bool
 ) -> Array:
+	var target: Node = _animated(player, target_path)
 	var track_type: String = str(track.get("type", ""))
 	var keys: Array = []
 	var method_found: Variant = null
 	var misfit: String = ""
 	var kind: Animation.TrackType = Animation.TYPE_VALUE
 	var path: NodePath = NodePath(target_path)
+	var update: int = -1
 	if track_type == "property":
 		var prop_name: String = str(track.get("property", ""))
 		if prop_name.is_empty():
 			return _not_added("track.property is required for property track")
+		# The server has refused any name but these.
+		var named: Variant = GdhAnimationReads.UPDATE_MODE_NAMES.find_key(
+			str(track.get("update", ""))
+		)
+		if named != null:
+			update = GdhRead.as_int(named)
 		var values: Array = _key_values(target, prop_name, keyframes)
 		if not values[0]:
 			return _not_added(str(values[1]))
@@ -210,6 +246,10 @@ func _add_track(
 	else:
 		track_idx = anim.add_track(kind)
 		anim.track_set_path(track_idx, path)
+		if kind == Animation.TYPE_VALUE:
+			_as_the_editor_makes(anim, track_idx, player, target)
+	if update >= 0:
+		anim.value_track_set_update_mode(track_idx, update as Animation.UpdateMode)
 	for index: int in keyframes.size():
 		var keyframe: Dictionary = keyframes[index]
 		if anim.track_insert_key(track_idx, GdhRead.as_float(keyframe["time"]), keys[index]) < 0:
@@ -217,6 +257,52 @@ func _add_track(
 	return [track_idx, "", method_found, existing, misfit, replaced]
 
 
+## Sets the new property track [param index] up as the editor sets up a track it makes: as the
+## RESET animation's track for the same path when there is one, and otherwise discrete unless the
+## property's declared type is one the editor blends, so a bool or an int changes at its key rather
+## than halfway to it.
+static func _as_the_editor_makes(
+	anim: Animation, index: int, player: AnimationPlayer, target: Node
+) -> void:
+	var path: NodePath = anim.track_get_path(index)
+	var mode: Animation.UpdateMode = Animation.UPDATE_DISCRETE
+	if player.has_animation(&"RESET") and player.get_animation(&"RESET") != anim:
+		var reset: Animation = player.get_animation(&"RESET")
+		for kind: Animation.TrackType in [Animation.TYPE_VALUE, Animation.TYPE_BEZIER]:
+			var at: int = reset.find_track(path, kind)
+			if at < 0:
+				continue
+			if kind == Animation.TYPE_VALUE:
+				mode = reset.value_track_get_update_mode(at)
+			anim.value_track_set_update_mode(index, mode)
+			anim.track_set_interpolation_type(index, reset.track_get_interpolation_type(at))
+			anim.track_set_interpolation_loop_wrap(
+				index, reset.track_get_interpolation_loop_wrap(at)
+			)
+			return
+	if BLENDED_TYPES.has(_declared_type(target, path)):
+		mode = Animation.UPDATE_CONTINUOUS
+	anim.value_track_set_update_mode(index, mode)
+
+
+## The type the node or resource holding the last name of [param path] declares for it, read from
+## [param target] as the editor reads it: a property of a property, as position:x, is no name the
+## node declares, so it has none.
+static func _declared_type(target: Node, path: NodePath) -> int:
+	var reached: Array = target.get_node_and_resource(
+		NodePath(".:" + str(path.get_concatenated_subnames()))
+	)
+	var leftover: NodePath = reached[2]
+	var holder: Object = reached[1] if reached[1] != null else reached[0]
+	if holder == null or leftover.get_subname_count() == 0:
+		return TYPE_NIL
+	var leaf: String = str(leftover.get_subname(leftover.get_subname_count() - 1))
+	for declared: Dictionary in holder.get_property_list():
+		if str(declared.get("name", "")) == leaf:
+			return GdhRead.as_int(declared.get("type", TYPE_NIL))
+	return TYPE_NIL
+
+
 ## What [method _add_track] answers when it added nothing, because of [param why].
 static func _not_added(why: String) -> Array:
 	return [-1, why, null, false, "", []]

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

@@ -86,11 +86,18 @@ func carry(scene: GdhSceneFile, moves: Dictionary) -> int:
 		# A value another file gives is in that file's terms, which its own pass carried already.
 		var from: String = scene.values_from(node, was)
 		var set_here: Dictionary = scene.set_at(was) if not from.is_empty() else {}
+		var read_here: bool = not from.is_empty()
 		for property: Dictionary in node.get_property_list():
 			var name: String = str(property["name"])
 			if not _may_hold_paths(property):
 				continue
 			var entry: Dictionary = { "scenePath": scene.path, "nodePath": now, "property": name }
+			if _names_nodes(property):
+				if not read_here:
+					set_here = scene.set_at(was)
+					read_here = true
+				_carry_nodes(node, name, set_here.get(name), was, now, entry)
+				continue
 			var elsewhere: String = "" if set_here.has(name) else from
 			var carried: Array = _carried(node.get(name), was, now, entry, elsewhere)
 			if carried[0]:
@@ -240,6 +247,60 @@ static func _may_hold_paths(property: Dictionary) -> bool:
 	)
 
 
+## Whether [param property] is typed as a node, or as an array or dictionary of nodes. It holds the
+## nodes themselves, and the pack writes the path to each as it saves.
+static func _names_nodes(property: Dictionary) -> bool:
+	var hint: int = GdhRead.as_int(property.get("hint"))
+	match GdhRead.as_int(property.get("type")):
+		TYPE_OBJECT:
+			return hint == PROPERTY_HINT_NODE_TYPE
+		TYPE_ARRAY, TYPE_DICTIONARY:
+			return (
+				hint == PROPERTY_HINT_TYPE_STRING
+				and str(property.get("hint_string", "")).contains(
+					"%d/%d:" % [TYPE_OBJECT, PROPERTY_HINT_NODE_TYPE]
+				)
+			)
+	return false
+
+
+## Carries the property [param name] of [param node], typed as nodes, from [param held], the paths
+## the file gives it. The nodes it holds moved with the move, so only what the file held is named;
+## marking it asked lets the write save the new paths the pack gives. A node the move deleted is
+## cleared, as the editor's save clears it, since no path reaches it.
+func _carry_nodes(
+	node: Node, name: String, held: Variant, was: String, now: String, entry: Dictionary
+) -> void:
+	var naming: int = still_naming.size()
+	var carried: Array = _carried(held, was, now, entry, "")
+	if still_naming.size() > naming:
+		for index: int in range(naming, still_naming.size()):
+			still_naming[index]["cleared"] = true
+		_scene.asked(node, [name])
+		node.set(name, _unfreed(node.get(name)))
+	elif carried[0]:
+		_scene.asked(node, [name])
+
+
+## [param value] with each freed node in it as null.
+static func _unfreed(value: Variant) -> Variant:
+	if typeof(value) == TYPE_OBJECT:
+		return value if is_instance_valid(value) else null
+	if typeof(value) == TYPE_ARRAY:
+		var items: Array = value
+		items = items.duplicate()
+		for index: int in items.size():
+			items[index] = _unfreed(items[index])
+		return items
+	if typeof(value) == TYPE_DICTIONARY:
+		var pairs: Dictionary = value
+		pairs = pairs.duplicate()
+		for key: Variant in pairs.keys():
+			pairs[key] = _unfreed(pairs[key])
+		return pairs
+	return value
+
+
 ## [param value], held by the node that was at [param was] and is at [param now], with each path in
 ## 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

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

@@ -112,8 +112,9 @@ static func copied(source: Node, root: Node, copies: Dictionary) -> Node:
 	return copy
 
 
-## Gives each copy in [param copies] the persistent connections its source has, to the copy of the
-## target when the target was copied too. A connection an instance makes inside itself is skipped:
+## Gives each copy in [param copies] the persistent connections its source has, with their flags,
+## bound arguments and unbinds, to the copy of the target when the target was copied too. A
+## connection an instance makes inside itself is skipped:
 ## the instance made again from its file already has it.
 static func reconnect(copies: Dictionary, top: Node) -> void:
 	for key: Variant in copies:
@@ -134,7 +135,15 @@ static func reconnect(copies: Dictionary, top: Node) -> void:
 					and (target == top or top.is_ancestor_of(target as Node))
 				):
 					continue
+				# Unbound and then bound again as Node.duplicate does: a callable made
+				# from the method alone would save the copy without the arguments the
+				# original passes.
 				var aimed: Callable = Callable(to, callable.get_method())
+				var unbound: int = callable.get_unbound_arguments_count()
+				if unbound > 0:
+					aimed = aimed.unbind(unbound)
+				if callable.get_bound_arguments_count() > 0:
+					aimed = aimed.bindv(callable.get_bound_arguments())
 				if (
 					not copy.is_connected(signal_name, aimed)
 					and copy.connect(signal_name, aimed, flags) != OK
@@ -207,6 +216,16 @@ static func placing(node: Node) -> Array[String]:
 	return []
 
 
+## The stored properties [param node] keeps what [method placing] names in: a Control's position
+## is its offsets, and a Node3D's position, rotation and scale its transform.
+static func placed_in(node: Node) -> Array[String]:
+	if node is Node3D:
+		return ["transform"]
+	if node is Control:
+		return ["offset_left", "offset_top", "offset_right", "offset_bottom"]
+	return placing(node)
+
+
 ## Gives [param node], just moved from under [param was], the transform that keeps it where it was
 ## drawn, as the editor's reparent and Node.reparent do. Worked out from the local transforms
 ## rather than read off the global ones, which the engine answers only for a node in the tree, and

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

@@ -560,11 +560,12 @@ 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)
+	# 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. A new parent changes more than where the
+	# node is drawn: a container gives a Control its own layout mode.
+	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)
@@ -572,6 +573,18 @@ func reparent_node(args: Dictionary) -> Dictionary:
 			also_changed[property] = {
 				"was": _readable(node, drawn_at[property]), "now": _readable(node, now),
 			}
+	var drawn_in: Array[String] = GdhPlacing.placed_in(node)
+	for property: String in placed:
+		if property in drawn_in or also_changed.has(property):
+			continue
+		var was: Variant = (
+			stored_before[property]
+			if stored_before.has(property)
+			else GdhHeadlessCheck.default_of(node, property)
+		)
+		also_changed[property] = {
+			"was": _readable(node, was), "now": _readable(node, node.get(property)),
+		}
 	var sheared: String = ""
 	if node is Node3D and GdhPlacing.sheared((node as Node3D).basis):
 		var spatial: Node3D = node

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

@@ -92,6 +92,19 @@ func connect_signal(args: Dictionary) -> Dictionary:
 	if unbinds > 0:
 		callable = callable.unbind(unbinds)
 	var method_found: bool = target.has_method(method_name)
+	if not method_found and (not binds.is_empty() or unbinds > 0):
+		var named_to: String = str(target.name) if target == scene.root else target_node_path
+		return scene.refuse(
+			(
+				(
+					"%s has no method %s, and the engine connects a signal that binds or unbinds "
+					+ "arguments only to a method its target has, so the scene would load without "
+					+ "the connection. Add the method to the target's script first, or connect "
+					+ "without binds and unbinds."
+				)
+				% [named_to, method_name]
+			)
+		)
 	var misfit: String = _misfit(source, signal_name, callable, flags)
 	if not before.is_empty():
 		var held: Callable = before["callable"]
@@ -102,6 +115,7 @@ func connect_signal(args: Dictionary) -> Dictionary:
 
 	var from: String = scene.path_of(source)
 	var to: String = scene.path_of(target)
+	var _replaced: Dictionary = scene.drop_unmade(from, signal_name, to, method_name)
 	var saved: Dictionary = {}
 	var written: Dictionary = scene.write(
 		func(loaded: Node) -> String:
@@ -464,7 +478,11 @@ func disconnect_signal(args: Dictionary) -> Dictionary:
 	# A connection that was never there saved the scene unchanged and answered as removed, so a
 	# typo in either name read as success.
 	var held: Dictionary = _saved(scene.root, from, signal_name, to, method_name)
-	if held.is_empty():
+	# One the engine could not make is in the file alone, and the write drops it.
+	var unmade: Dictionary = scene.drop_unmade(from, signal_name, to, method_name)
+	if held.is_empty() and not unmade.is_empty():
+		held = { "flags": unmade["flags"], "binds": unmade["binds"], "unbinds": unmade["unbinds"] }
+	elif held.is_empty():
 		# The root's path is ".", which before ".method" read as "..method".
 		var said_from: String = str(source.name) if source == scene.root else from
 		var said_to: String = str(target.name) if target == scene.root else to
@@ -492,8 +510,9 @@ func disconnect_signal(args: Dictionary) -> Dictionary:
 				)
 			)
 		)
-	var callable: Callable = held["callable"]
-	source.disconnect(signal_name, callable)
+	if held.has("callable"):
+		var callable: Callable = held["callable"]
+		source.disconnect(signal_name, callable)
 
 	var written: Dictionary = scene.write(
 		func(loaded: Node) -> String:

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

@@ -303,6 +303,13 @@ func set_tilemap_cells(args: Dictionary) -> Dictionary:
 		wanted.append([at, source_id, atlas_coords, alternative])
 		if source_id == -1:
 			erased += 1
+	# An erased cell leaves the layer's data at its next update, which a layer outside the tree
+	# never has, so the pack wrote it as a cell naming no tile, where the editor's save leaves it
+	# out.
+	if layered != null:
+		layered.update_internals()
+	else:
+		single.update_internals()
 
 	var at_path: String = scene.path_of(node)
 	var written: Dictionary = scene.write(

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

@@ -62,6 +62,15 @@ func set_property(params: Dictionary) -> Dictionary:
 			"type": "error",
 			"message": GdhPaths.nothing_there(holder, named, str(reached["called"])),
 		}
+	if GdhPaths.is_constant(holder, named):
+		return {
+			"type": "error",
+			"message":
+			(
+				"%s:%s is a constant its script declares, and a constant cannot be set"
+				% [reached["called"], named]
+			),
+		}
 	var old_value: Variant = GdhPaths.read_under(holder, named)
 	var slot: Dictionary = GdhValues.slot_declared(holder, named)
 	var declared: int = slot["type"]