gdharness 1.3.9 → 1.3.10

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

@@ -22,6 +22,22 @@ static func read(scene: GdhSceneFile, node: Node) -> Dictionary:
 	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.
+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 here: Array = []
+	for group: String in _sorted(adding):
+		if not here.has(group):
+			here.append(group)
+	if here.size() != all.size():
+		answer["groupsHere"] = here
+	return answer
+
+
 ## The group names under [param key] of [param args], which the server has checked are strings, or
 ## none when not given.
 static func asked(args: Dictionary, key: String) -> Array:

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

@@ -7,6 +7,7 @@ extends RefCounted
 const GdhFileReads = preload("../file_reads.gd")
 const GdhPaths = preload("scene_paths.gd")
 const GdhSceneFile = preload("../scene_file.gd")
+const GdhSceneUids = preload("../scene_uids.gd")
 
 
 ## Why a create at [param scene_path] is refused when a file is there already, which saving over
@@ -87,14 +88,14 @@ static func inherit(scene_path: String, base_path: String, root_name: String, sc
 		"",
 		(
 			'[ext_resource type="PackedScene"%s path="%s" id="1_base"]'
-			% [GdhSceneFile.reference_uid(base_path), base_path]
+			% [GdhSceneUids.reference_uid(base_path), base_path]
 		),
 	]
 	if script != null:
 		var _resourced: bool = lines.append(
 			(
 				'[ext_resource type="Script"%s path="%s" id="2_script"]'
-				% [GdhSceneFile.reference_uid(script.resource_path), script.resource_path]
+				% [GdhSceneUids.reference_uid(script.resource_path), script.resource_path]
 			)
 		)
 	lines.append_array(["", '[node name="%s" instance=ExtResource("1_base")]' % name])
@@ -179,7 +180,7 @@ static func follow(changed: String, old_path: String, new_path: String, carried:
 		var moves: Dictionary = {}
 		if _inherits(scene_path, changed, texts):
 			moves[old_path] = new_path
-		var read: Dictionary = GdhFileReads.scene_tree(scene_path, -1, false)
+		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", ""))})
 			continue

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

@@ -14,6 +14,7 @@ enum { UNCHANGED, REWRITTEN, DELETED }
 const GdhHeadlessCheck = preload("../headless_check.gd")
 const GdhRead = preload("../reading.gd")
 const GdhSceneFile = preload("../scene_file.gd")
+const GdhSceneUids = preload("../scene_uids.gd")
 ## PROPERTY_HINT_NO_NODEPATH, which marks a property the editor's rename skips. It is not bound for
 ## scripts, and follows PROPERTY_HINT_ONESHOT in the engine's list.
 const HINT_NO_NODEPATH: int = PROPERTY_HINT_ONESHOT + 1
@@ -127,7 +128,7 @@ func put_back(scene_path: String, why: String = "") -> void:
 func answer() -> Dictionary:
 	for file: String in _homes:
 		var resource: Resource = _homes[file]
-		var saving: Error = GdhSceneFile.save_keeping_uid(resource, file)
+		var saving: Error = GdhSceneUids.save_keeping_uid(resource, file)
 		if saving == OK:
 			if Engine.is_editor_hint():
 				EditorInterface.get_resource_filesystem().update_file(file)

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

@@ -3,17 +3,20 @@ extends Node
 
 ## Scenes and their nodes, edited in the open editor and read back from what it holds.
 
+const GdhDeclared = preload("../declared_values.gd")
 const GdhFileReads = preload("../file_reads.gd")
 const GdhRead = preload("../reading.gd")
 const GdhGroups = preload("scene_groups.gd")
+const GdhHeadlessCheck = preload("../headless_check.gd")
 const GdhKin = preload("scene_kin.gd")
+const GdhNavigationBake = preload("navigation_bake.gd")
 const GdhPaths = preload("scene_paths.gd")
 const GdhPlacing = preload("scene_placing.gd")
 const GdhPropertyValues = preload("../property_values.gd")
-const GdhResourceTools = preload("resource_tools.gd")
 const GdhSame = preload("../same_values.gd")
 const GdhSceneFile = preload("../scene_file.gd")
 const GdhSerialisation = preload("../serialisation.gd")
+const GdhTilesetTools = preload("tileset_tools.gd")
 
 var _editor_plugin: EditorPlugin = null
 var _values: GdhSerialisation = GdhSerialisation.new()
@@ -216,10 +219,11 @@ func list_scene_nodes(args: Dictionary) -> Dictionary:
 	var scene_path: String = GdhSceneFile.res_path(project_path, str(args.get("scenePath", "")))
 	var depth: int = GdhRead.as_int(args.get("depth", -1), -1)
 	var include_properties: bool = GdhRead.as_bool(args.get("includeProperties", false))
+	var include_defaults: bool = GdhRead.as_bool(args.get("includeDefaults", false))
 
 	# 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)
+	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
@@ -287,6 +291,9 @@ func add_node(args: Dictionary) -> Dictionary:
 		return scene.refuse("Nothing was written: " + unsettled)
 	scene.asked(new_node, properties.keys())
 	var unwritten: String = _properties.write_all(new_node, properties)
+	scene.asked(new_node, _properties.moved_by_engine.keys())
+	if not unwritten.is_empty():
+		unwritten = GdhHeadlessCheck.setter_ran(new_node, _properties.unheld, unwritten)
 	if unwritten.is_empty():
 		unwritten = GdhGroups.change(scene, new_node, adding, [])
 	if not unwritten.is_empty():
@@ -308,7 +315,7 @@ func add_node(args: Dictionary) -> Dictionary:
 		answer["properties"] = held
 	_properties.note_write(answer, new_node)
 	if not adding.is_empty():
-		answer.merge(GdhGroups.read(scene, new_node))
+		answer.merge(GdhGroups.read_added(new_node, adding))
 	var written: Dictionary = scene.write(
 		func(saved: Node) -> String:
 			var unkept: String = _kept(
@@ -619,8 +626,13 @@ func set_node_properties(args: Dictionary) -> Dictionary:
 	var old_path: String = scene.path_of(node)
 	scene.asked(node, properties.keys())
 	var refused_property: String = _properties.write_all(node, properties)
+	scene.asked(node, _properties.moved_by_engine.keys())
 	if not refused_property.is_empty():
-		return scene.refuse(GdhSceneFile.missing_on(node, refused_property))
+		return scene.refuse(
+			GdhHeadlessCheck.setter_ran(
+				node, _properties.unheld, GdhSceneFile.missing_on(node, refused_property)
+			)
+		)
 	var ungrouped: String = GdhGroups.change(scene, node, adding, removing)
 	if not ungrouped.is_empty():
 		return scene.refuse(ungrouped)
@@ -726,11 +738,55 @@ func get_node_properties(args: Dictionary) -> Dictionary:
 	# names this scene's file sets are always answered.
 	var set_here: Dictionary = scene.set_here(node)
 	var props: Dictionary = _properties_of(node, include_defaults, set_here)
-	var cells: Dictionary = GdhResourceTools.cells_of(node)
+	var cells: Dictionary = GdhTilesetTools.cells_of(node)
 	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}
+	# 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.
+	var placed: Node3D = node as Node3D
+	var rebuilt: Transform3D = Transform3D()
+	if placed != null:
+		var turned: Basis = Basis.from_euler(placed.rotation, placed.rotation_order)
+		rebuilt = Transform3D(turned * Basis.from_scale(placed.scale), placed.position)
+	if placed != null and props.has("transform") and rebuilt.is_equal_approx(placed.transform):
+		# Rounded, since a node never scaled came back with a scale of 0.99999994 out of the matrix;
+		# the transform beside it is exact.
+		var step: Vector3 = Vector3.ONE * 0.00001
+		answer["placement"] = {
+			"position": _readable(node, placed.position.snapped(step)),
+			"rotation_degrees": _readable(node, placed.rotation_degrees.snapped(step)),
+			"scale": _readable(node, placed.scale.snapped(step)),
+		}
+	# 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
+	if plays and not bus.is_empty() and AudioServer.get_bus_index(bus) == -1:
+		props["bus"] = bus
+		var buses: PackedStringArray = []
+		for index: int in AudioServer.bus_count:
+			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."
+			)
+			% [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.
+	var layers: Dictionary = {}
+	for declared: Dictionary in node.get_property_list():
+		var hint: int = GdhRead.as_int(declared.get("hint", PROPERTY_HINT_NONE))
+		var named: String = str(declared.get("name", ""))
+		var mask: Variant = node.get(named) if props.has(named) else null
+		if hint in GdhDeclared.LAYER_NAMES and mask is int:
+			layers[named] = GdhDeclared.layers_in(hint, GdhRead.as_int(mask))
+	if not layers.is_empty():
+		answer["layers"] = layers
 	answer.merge(GdhSceneFile.class_of(node))
 	answer.merge(GdhGroups.read(scene, node))
 	var from: String = scene.values_from(node, at)
@@ -753,6 +809,24 @@ func get_node_properties(args: Dictionary) -> Dictionary:
 	return answer
 
 
+func bake_navigation(args: Dictionary) -> Dictionary:
+	var project_path: String = str(args.get("projectPath", ""))
+	var scene_path: String = GdhSceneFile.res_path(project_path, str(args.get("scenePath", "")))
+	var node_path: String = str(args.get("nodePath", "."))
+	var opened: Array = _open(scene_path, true)
+	var scene: GdhSceneFile = opened[0]
+	var refused: Dictionary = opened[1]
+	if not refused.is_empty():
+		return refused
+	var node: Node = GdhSceneFile.node_at(scene.root, node_path)
+	if not node:
+		return scene.refuse(scene.not_found("Node not found: " + node_path, node_path))
+	var foreign: String = scene.foreign(node)
+	if not foreign.is_empty():
+		return scene.refuse(foreign)
+	return GdhNavigationBake.bake(scene, node)
+
+
 func save_scene(args: Dictionary) -> Dictionary:
 	var project_path: String = str(args.get("projectPath", ""))
 	var scene_path: String = GdhSceneFile.res_path(project_path, str(args.get("scenePath", "")))

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

@@ -10,12 +10,12 @@ extends Node
 ## of the two a caller wants is theirs to say, so the server only comes here when asked, and the
 ## difference is the reason the argument exists rather than an inconvenience to paper over.
 ##
-## Every value goes through the same serialiser the headless answer uses, because the two are one
+## Every answer is built by the same reads the headless answer uses, because the two are one
 ## question asked of two places: a value spelled differently here would read as the editor and the
 ## file disagreeing about something they agree about.
 
-const GdhRead = preload("../reading.gd")
 const GdhSerialisation = preload("../serialisation.gd")
+const GdhSettingReads = preload("../setting_reads.gd")
 
 var _values: GdhSerialisation = GdhSerialisation.new()
 
@@ -23,42 +23,19 @@ var _values: GdhSerialisation = GdhSerialisation.new()
 func get_project_setting(args: Dictionary) -> Dictionary:
 	var prefix: String = str(args.get("prefix", ""))
 	if not prefix.is_empty():
-		return _settings_under(prefix)
+		var family: Dictionary = GdhSettingReads.under(prefix, _values)
+		family["ok"] = true
+		return family
 
 	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"}
 
-	var exists: bool = ProjectSettings.has_setting(setting)
-	var result: Dictionary = {"ok": true, "setting_path": setting, "exists": exists, "value": null}
-	if exists:
-		result["value"] = _values.serialize_value(ProjectSettings.get_setting(setting))
-	else:
-		result["message"] = "Setting does not exist"
+	var result: Dictionary = GdhSettingReads.one(setting, _values)
+	result["ok"] = true
 	return result
 
 
-## Every setting under [prefix] with the type the engine registers for each, which is the half a
-## name hides: a family of levels can hold a setting that is a bool, and writing a level over it
-## looks like it worked.
-func _settings_under(prefix: String) -> Dictionary:
-	var found: Array[Dictionary] = []
-	for property: Dictionary in ProjectSettings.get_property_list():
-		var setting: String = str(property.get("name", ""))
-		if not setting.begins_with(prefix):
-			continue
-		var kind: int = GdhRead.as_int(property.get("type", TYPE_NIL), TYPE_NIL)
-		var described: Dictionary = {
-			"setting": setting,
-			"type": type_string(kind),
-			"value": _values.serialize_value(ProjectSettings.get_setting(setting)),
-		}
-		found.append(described)
-
-	found.sort_custom(func(a: Dictionary, b: Dictionary) -> bool: return a["setting"] < b["setting"])
-	return {"ok": true, "prefix": prefix, "count": found.size(), "settings": found}
-
-
 ## Takes the named settings from project.godot as it is on disk, after something else wrote it.
 ##
 ## The editor loads the file once, at startup. Written from outside, it goes on holding the old

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

@@ -6,9 +6,33 @@ extends Node
 
 const GdhRead = preload("../reading.gd")
 const GdhSceneFile = preload("../scene_file.gd")
+const GdhSerialisation = preload("../serialisation.gd")
 
 ## What every emission meets when a connection cannot call its method.
 const FAILS: String = ", so every emission fails to call it."
+## The names Object.ConnectFlags gives each bit. The number alone left a reader guessing that 2 is
+## the persistence every connection in a saved scene carries.
+const CONNECT_FLAG_NAMES: Dictionary[int, String] = {
+	Object.CONNECT_DEFERRED: "deferred",
+	Object.CONNECT_PERSIST: "persist",
+	Object.CONNECT_ONE_SHOT: "one_shot",
+	Object.CONNECT_REFERENCE_COUNTED: "reference_counted",
+	Object.CONNECT_APPEND_SOURCE_OBJECT: "append_source_object",
+	# The engine's CONNECT_INHERITED, which GDScript is not given: on a connection an instanced scene
+	# makes inside itself, as a scene holding one loads it.
+	32: "inherited",
+}
+## The flags a caller may give: the engine's own CONNECT_INHERITED marks a connection an instanced
+## scene makes, and is never one a scene makes for itself.
+const GIVEN_FLAGS: int = (
+	Object.CONNECT_DEFERRED
+	| Object.CONNECT_PERSIST
+	| Object.CONNECT_ONE_SHOT
+	| Object.CONNECT_REFERENCE_COUNTED
+	| Object.CONNECT_APPEND_SOURCE_OBJECT
+)
+
+var _values: GdhSerialisation = GdhSerialisation.new()
 
 
 func connect_signal(args: Dictionary) -> Dictionary:
@@ -20,7 +44,8 @@ func connect_signal(args: Dictionary) -> Dictionary:
 	var method_name: String = str(args.get("methodName", ""))
 	# A connection without CONNECT_PERSIST is a runtime one, and PackedScene.pack drops those on
 	# the way out: without this the scene saves unchanged and this answers success over nothing.
-	var flags: int = GdhRead.as_int(args.get("flags", 0)) | Object.CONNECT_PERSIST
+	var given_flags: int = GdhRead.as_int(args.get("flags", 0))
+	var flags: int = given_flags | Object.CONNECT_PERSIST
 
 	if (
 		source_node_path.is_empty()
@@ -29,6 +54,9 @@ func connect_signal(args: Dictionary) -> Dictionary:
 		or method_name.is_empty()
 	):
 		return {"ok": false, "error": "Missing required signal connection arguments"}
+	var unasked: String = _unasked(given_flags)
+	if not unasked.is_empty():
+		return {"ok": false, "error": unasked}
 
 	var scene: GdhSceneFile = GdhSceneFile.new()
 	var refused: Dictionary = scene.open(scene_path, true)
@@ -43,40 +71,57 @@ func connect_signal(args: Dictionary) -> Dictionary:
 
 	# Reconnected rather than left alone when the flags differ, so the connection saved is the one
 	# asked for. Left alone, the answer gave the flags asked for and the file kept the old ones.
+	# Found by its object and method, as the engine finds it: a connection carrying binds is another
+	# callable, so comparing callables missed it, and the engine's is_connected then found it, took it
+	# out and put a bare one in its place, losing the binds without a word.
+	var before: Dictionary = _held(source, signal_name, target, method_name)
+	var binds: Array = []
+	var unbinds: int = 0
+	if not before.is_empty():
+		binds = before["binds"]
+		unbinds = before["unbinds"]
+	if args.has("unbinds"):
+		unbinds = GdhRead.as_int(args["unbinds"])
+	if args.has("binds"):
+		var given: Array = args["binds"]
+		binds = _bound_values(given, source, signal_name, Callable(target, method_name), unbinds, flags)
 	var callable: Callable = Callable(target, method_name)
+	if not binds.is_empty():
+		callable = callable.bindv(binds)
+	if unbinds > 0:
+		callable = callable.unbind(unbinds)
 	var method_found: bool = target.has_method(method_name)
 	var misfit: String = _misfit(source, signal_name, callable, flags)
-	var flags_before: int = -1
-	for connection: Dictionary in source.get_signal_connection_list(signal_name):
-		if connection.get("callable") == callable:
-			flags_before = GdhRead.as_int(connection.get("flags", 0))
-	if source.is_connected(signal_name, callable):
-		source.disconnect(signal_name, callable)
+	if not before.is_empty():
+		var held: Callable = before["callable"]
+		source.disconnect(signal_name, held)
 	var connect_result: Error = source.connect(signal_name, callable, flags)
 	if connect_result != OK:
 		return scene.refuse("Failed to connect signal: " + error_string(connect_result))
 
 	var from: String = scene.path_of(source)
 	var to: String = scene.path_of(target)
-	var saved_flags: Array = [-1]
+	var saved: Dictionary = {}
 	var written: Dictionary = scene.write(
-		func(saved: Node) -> String:
-			saved_flags[0] = _connection_flags(saved, from, signal_name, to, method_name)
-			if saved_flags[0] < 0:
+		func(loaded: Node) -> String:
+			var found: Dictionary = _saved(loaded, from, signal_name, to, method_name)
+			saved.merge(found)
+			if found.is_empty():
 				return "the connection would not be in the scene when it loads."
 			return ""
 	)
 	if not written.is_empty():
 		return written
 
+	var saved_flags: int = saved["flags"]
 	var answer: Dictionary = {
 		"ok": true,
 		"sourceNodePath": from,
 		"signalName": signal_name,
 		"targetNodePath": to,
 		"methodName": method_name,
-		"flags": saved_flags[0],
-		"flagNames": GdhSceneFile.flag_names(GdhRead.as_int(saved_flags[0])),
+		"flags": saved_flags,
+		"flagNames": flag_names(saved_flags),
 		# Connected either way, as the editor's own dialog allows, since the method may be written
 		# next; a caller told nothing learnt of a misspelt one only when the signal fired.
 		"methodFound": method_found
@@ -89,13 +134,108 @@ func connect_signal(args: Dictionary) -> Dictionary:
 	# A second connect of the same pair read exactly like the first, so a caller could not tell a
 	# connection made from one that was already there, and a list showing one where two were made
 	# looked like a lost write.
-	if flags_before >= 0:
+	_bound_into(answer, saved)
+	if not before.is_empty():
 		answer["alreadyConnected"] = true
-		if flags_before != GdhRead.as_int(saved_flags[0]):
-			answer["flagsBefore"] = GdhSceneFile.flag_names(flags_before)
+		var flags_before: int = before["flags"]
+		if flags_before != saved_flags:
+			answer["flagsBefore"] = flag_names(flags_before)
+		var binds_before: Variant = _values.serialize_value(before["binds"])
+		if JSON.stringify(binds_before) != JSON.stringify(answer.get("binds", [])):
+			answer["bindsBefore"] = binds_before
+		if before["unbinds"] != saved["unbinds"]:
+			answer["unbindsBefore"] = before["unbinds"]
 	return answer
 
 
+## Why [param given_flags] cannot be connected with, or "" when it can: a bit no flag a scene
+## connects with has. The server checks the type of every argument, and nothing knows the bits.
+static func _unasked(given_flags: int) -> String:
+	if given_flags >= 0 and not given_flags & ~GIVEN_FLAGS:
+		return ""
+	var named: Array[String] = []
+	for bit: int in CONNECT_FLAG_NAMES:
+		if bit & GIVEN_FLAGS:
+			named.append("%s %d" % [CONNECT_FLAG_NAMES[bit], bit])
+	return (
+		"flags %d holds bits no flag a scene connects with has: they are %s, added together."
+		% [given_flags, ", ".join(named)]
+	)
+
+
+## [param given] as the values [param called] is bound with, each number fitted to the parameter it
+## lands on. JSON has one kind of number, so 3 arrived as 3.0, the file said [3.0], and a whole
+## number for an untyped parameter is an int, as GDScript reads the literal 3.
+func _bound_values(
+	given: Array, source: Node, signal_name: String, called: Callable, unbinds: int, flags: int
+) -> Array:
+	var passed: int = 0
+	for info: Dictionary in source.get_signal_list():
+		if str(info.get("name", "")) == signal_name:
+			var arguments: Array = info.get("args", [])
+			passed = arguments.size()
+	if flags & Object.CONNECT_APPEND_SOURCE_OBJECT:
+		passed += 1
+	passed = maxi(passed - unbinds, 0)
+	var parameters: Array = []
+	for info: Dictionary in called.get_object().get_method_list():
+		if str(info.get("name", "")) == str(called.get_method()):
+			parameters = info.get("args", [])
+			break
+	var values: Array = []
+	for at: int in given.size():
+		var value: Variant = _values.deserialize_value(given[at])
+		var declared: int = TYPE_NIL
+		if passed + at < parameters.size():
+			var parameter: Dictionary = parameters[passed + at]
+			declared = GdhRead.as_int(parameter.get("type", TYPE_NIL))
+		if value is float and declared != TYPE_FLOAT:
+			var number: float = value
+			if is_finite(number) and number == floorf(number) and absf(number) < 9007199254740992.0:
+				value = int(number)
+		values.append(value)
+	return values
+
+
+## The connection from [param signal_name] of [param source] to [param method] on [param target],
+## as {callable, flags, binds, unbinds}, or {} when there is none.
+static func _held(source: Node, signal_name: String, target: Object, method: String) -> Dictionary:
+	for conn: Dictionary in source.get_signal_connection_list(signal_name):
+		var callable: Callable = conn.get("callable", Callable())
+		if callable.get_object() == target and str(callable.get_method()) == method:
+			return {
+				"callable": callable,
+				"flags": GdhRead.as_int(conn.get("flags", 0)),
+				"binds": callable.get_bound_arguments(),
+				"unbinds": callable.get_unbound_arguments_count(),
+			}
+	return {}
+
+
+## [param held]'s binds and unbinds into [param answer], each only when it has any, as the scene
+## file writes them.
+func _bound_into(answer: Dictionary, held: Dictionary) -> void:
+	var binds: Array = held["binds"]
+	if not binds.is_empty():
+		answer["binds"] = _values.serialize_value(binds)
+	var unbinds: int = held["unbinds"]
+	if unbinds > 0:
+		answer["unbinds"] = unbinds
+
+
+## Each bit set in [param flags], a connection's, by name, and any bits left unnamed as one number.
+static func flag_names(flags: int) -> Array[String]:
+	var names: Array[String] = []
+	var rest: int = flags
+	for bit: int in CONNECT_FLAG_NAMES:
+		if flags & bit:
+			names.append(CONNECT_FLAG_NAMES[bit])
+			rest &= ~bit
+	if rest != 0:
+		names.append(str(rest))
+	return names
+
+
 ## The two ends of a connection in [param scene], as [source, target], or [null, why not].
 func _connection_ends(
 	scene: GdhSceneFile, source_node_path: String, signal_name: String, target_node_path: String
@@ -119,23 +259,17 @@ func _connection_ends(
 	return [source, target]
 
 
-## The flags of the persistent connection from [param from]'s [param signal_name] to
-## [param method] on [param to] in the tree under [param root], or -1 when there is none.
-func _connection_flags(root: Node, from: String, signal_name: String, to: String, method: String) -> int:
+## The persistent connection from [param from]'s [param signal_name] to [param method] on [param to]
+## in the tree under [param root], as [method _held] answers it, or {} when there is none.
+static func _saved(root: Node, from: String, signal_name: String, to: String, method: String) -> Dictionary:
 	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):
-		return -1
-	for conn: Dictionary in source.get_signal_connection_list(signal_name):
-		var flags: int = GdhRead.as_int(conn.get("flags", 0))
-		var callable: Callable = conn.get("callable", Callable())
-		if (
-			flags & Object.CONNECT_PERSIST
-			and callable.get_object() == target
-			and str(callable.get_method()) == method
-		):
-			return flags
-	return -1
+		return {}
+	var held: Dictionary = _held(source, signal_name, target, method)
+	if held.is_empty() or not GdhRead.as_int(held["flags"]) & Object.CONNECT_PERSIST:
+		return {}
+	return held
 
 
 ## Why what [param signal_name] of [param source] passes cannot reach [param callable], or "" when it
@@ -264,7 +398,8 @@ func disconnect_signal(args: Dictionary) -> Dictionary:
 	var to: String = scene.path_of(target)
 	# A connection that was never there saved the scene unchanged and answered as removed, so a
 	# typo in either name read as success.
-	if _connection_flags(scene.root, from, signal_name, to, method_name) < 0:
+	var held: Dictionary = _saved(scene.root, from, signal_name, to, method_name)
+	if 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
@@ -274,25 +409,31 @@ func disconnect_signal(args: Dictionary) -> Dictionary:
 				% [scene_path, said_from, signal_name, said_to, method_name]
 			)
 		)
-	source.disconnect(signal_name, Callable(target, method_name))
+	var callable: Callable = held["callable"]
+	source.disconnect(signal_name, callable)
 
 	var written: Dictionary = scene.write(
-		func(saved: Node) -> String:
-			if _connection_flags(saved, from, signal_name, to, method_name) >= 0:
+		func(loaded: Node) -> String:
+			if not _saved(loaded, from, signal_name, to, method_name).is_empty():
 				return "the connection would still be in the scene when it loads."
 			return ""
 	)
 	if not written.is_empty():
 		return written
 
-	return {
+	var removed_flags: int = held["flags"]
+	var answer: Dictionary = {
 		"ok": true,
 		"removed": true,
 		"sourceNodePath": from,
 		"signalName": signal_name,
 		"targetNodePath": to,
-		"methodName": method_name
+		"methodName": method_name,
+		"flags": removed_flags,
+		"flagNames": flag_names(removed_flags),
 	}
+	_bound_into(answer, held)
+	return answer
 
 
 func list_connections(args: Dictionary) -> Dictionary:
@@ -344,12 +485,17 @@ func list_connections(args: Dictionary) -> Dictionary:
 					"targetNodePath": target_path,
 					"methodName": str(callable.get_method()),
 					"flags": flags,
-					"flagNames": GdhSceneFile.flag_names(flags),
+					"flagNames": flag_names(flags),
 					# False for a connection an instanced scene makes inside itself, which only that
 					# scene can change.
 					"editable": editable,
 					"methodFound": target_obj != null and target_obj.has_method(callable.get_method()),
 				}
+				var bound: Dictionary = {
+					"binds": callable.get_bound_arguments(),
+					"unbinds": callable.get_unbound_arguments_count(),
+				}
+				_bound_into(listed, bound)
 				var misfit: String = _misfit(node, signal_name, callable, flags)
 				if not misfit.is_empty():
 					listed["misfit"] = misfit