gdharness 1.3.3 → 1.3.5

package/build/godot/operations/animation_reads.gd

@@ -164,8 +164,9 @@ static func state_machine(tree: AnimationTree, state_machine_path: String) -> An
 static func no_machine(tree: AnimationTree, state_machine_path: String) -> String:
 	if tree == null or tree.tree_root == null:
 		return (
-			"The AnimationTree has no tree_root. Make one with resource_edit create of an "
-			+ "AnimationNodeStateMachine, then give its res:// path to tree_root with scene_node set."
+			"The AnimationTree has no tree_root. Give it one with scene_node set: tree_root "
+			+ '{"_type": "AnimationNodeStateMachine"} builds one into the scene, and the res:// path '
+			+ "of one made with resource_edit create keeps it in a file of its own."
 		)
 	var current: AnimationNodeStateMachine = tree.tree_root as AnimationNodeStateMachine
 	if current == null:

package/build/godot/operations/classdb_queries.gd

@@ -4,6 +4,9 @@ const GdhRead = preload("reading.gd")
 const GdhLog = preload("logger.gd")
 const GdhSerialisation = preload("serialisation.gd")
 
+# How far below the closest name another may score and still be offered beside it.
+const CLOSE_TO_THE_BEST: float = 0.2
+
 # The base classes each category name stands for. Kept to the list the tool's schema offers, which
 # a case holds: the schema offered physics3d and ui, which this refused, and physics answered the 3D
 # bodies alone beside physics2d and physics3d.
@@ -114,20 +117,20 @@ func query_class_info(params: Dictionary) -> Dictionary:
 	)
 
 	if not ClassDB.class_exists(class_name_str):
-		return _not_found(class_name_str)
+		return _not_found(class_name_str, _declared_classes(params))
 
 	var member: String = str(params.get("member", ""))
 	if not member.is_empty():
 		return _member_of(class_name_str, member)
 
-	var methods: Array[Dictionary] = _methods_of(class_name_str, include_inherited)
-	var properties: Array[Dictionary] = _properties_of(class_name_str, include_inherited)
-	var signals: Array[Dictionary] = _signals_of(class_name_str, include_inherited)
+	var methods: Array[Dictionary] = _methods_of(class_name_str)
+	var properties: Array[Dictionary] = _properties_of(class_name_str)
+	var signals: Array[Dictionary] = _signals_of(class_name_str)
 
 	var enums: Dictionary = {}
-	for e: String in ClassDB.class_get_enum_list(class_name_str, not include_inherited):
+	for e: String in ClassDB.class_get_enum_list(class_name_str, true):
 		var enum_values: Dictionary = {}
-		for c: String in ClassDB.class_get_enum_constants(class_name_str, e, not include_inherited):
+		for c: String in ClassDB.class_get_enum_constants(class_name_str, e, true):
 			enum_values[c] = ClassDB.class_get_integer_constant(class_name_str, c)
 		enums[e] = enum_values
 
@@ -143,7 +146,7 @@ func query_class_info(params: Dictionary) -> Dictionary:
 		)
 	)
 
-	return {
+	var answer: Dictionary = {
 		"class_name": class_name_str,
 		"parent_class": ClassDB.get_parent_class(class_name_str),
 		"can_instantiate": ClassDB.can_instantiate(class_name_str),
@@ -156,43 +159,99 @@ func query_class_info(params: Dictionary) -> Dictionary:
 		"signals": signals,
 		"enums": enums
 	}
+	if include_inherited:
+		answer["inherited"] = _inherited_names(class_name_str)
+	return answer
+
+
+# What [param class_name_str] inherits, by name under the ancestor declaring it, nearest first. In
+# full, CharacterBody2D's inherited members ran to two hundred thousand characters, more than a
+# client takes in one answer, and any one of them is read in full by asking for it as member.
+func _inherited_names(class_name_str: String) -> Array[Dictionary]:
+	var inherited: Array[Dictionary] = []
+	var current: String = ClassDB.get_parent_class(class_name_str)
+	while not current.is_empty():
+		(
+			inherited
+			. append(
+				{
+					"class": current,
+					"methods": _names(_methods_of(current)),
+					"properties": _names(_properties_of(current)),
+					"signals": _names(_signals_of(current)),
+					"enums": Array(ClassDB.class_get_enum_list(current, true)),
+				}
+			)
+		)
+		current = ClassDB.get_parent_class(current)
+	return inherited
+
+
+static func _names(members: Array[Dictionary]) -> Array[String]:
+	var names: Array[String] = []
+	for each: Dictionary in members:
+		names.append(str(each["name"]))
+	return names
+
+
+static func _declared_classes(params: Dictionary) -> Dictionary:
+	var given: Variant = params.get("project_classes", {})
+	if given is Dictionary:
+		var declared: Dictionary = given
+		return declared
+	return {}
 
 
-# One member of a class by name, wherever in its ancestry it is declared.
-#
-# The question a member is asked by name for is "does this engine have it, and what does it take":
-# the whole class in answer to that ran to seventy thousand characters for Control, and the member
-# is as often an ancestor's as the class's own, so the ancestry is walked without being asked. Each
-# match says which class declares it. Nothing found names the members whose names contain the one
-# asked for, since the usual miss is a spelling.
 ## Why [param wanted] has no answer here. A class_name a project script declares is not in ClassDB,
-## and "Class not found" for one read as though the project had no such class.
-func _not_found(wanted: String) -> Dictionary:
-	for entry: Dictionary in ProjectSettings.get_global_class_list():
-		if str(entry.get("class", "")) == wanted:
-			return (
-				_log
-				. failure(
-					(
-						(
-							"%s is not an engine class: it is the class_name %s declares, and editor_classes reads "
-							+ "the engine's ClassDB only. script_info structure on that script, with "
-							+ "includeInherited, answers what it declares and what it inherits."
-						)
-						% [wanted, str(entry.get("path", ""))]
-					)
+## and "Class not found" for one read as though the project had no such class. [param declared] is
+## what the project's scripts declare on disk, class to path, rather than the engine's list, which is
+## the class cache: that lags the scripts, and a class written a moment ago was refused as declared
+## nowhere.
+func _not_found(wanted: String, declared: Dictionary) -> Dictionary:
+	if declared.has(wanted):
+		return _log.failure(
+			(
+				(
+					"%s is not an engine class: it is the class_name %s declares, and editor_classes reads "
+					+ "the engine's ClassDB only. script_info structure on that script, with "
+					+ "includeInherited, answers what it declares and what it inherits."
 				)
+				% [wanted, str(declared[wanted])]
 			)
-	# The usual miss is a spelling, one letter off a class the engine has.
-	var close: PackedStringArray = GdhRead.nearest(wanted, ClassDB.get_class_list())
+		)
+	# The usual miss is a spelling, one letter off a class the engine has or one the project declares.
+	# Ranked as one pool and kept near the best, since a project class a letter off came behind three
+	# engine classes that shared only "Texture" with it.
+	var pool: PackedStringArray = ClassDB.get_class_list()
+	pool.append_array(PackedStringArray(declared.keys()))
+	var close: PackedStringArray = GdhRead.nearest(wanted, pool)
+	var best: float = 0.0 if close.is_empty() else close[0].to_lower().similarity(wanted.to_lower())
+	var engine: Array[String] = []
+	var own: Array[String] = []
+	for name: String in close:
+		if name.to_lower().similarity(wanted.to_lower()) < best - CLOSE_TO_THE_BEST:
+			continue
+		if declared.has(name):
+			own.append(name)
+		else:
+			engine.append(name)
 	var offered: String = (
 		""
-		if close.is_empty()
+		if engine.is_empty()
 		else (
 			" The nearest engine %s %s."
-			% ["class is" if close.size() == 1 else "classes are", ", ".join(close)]
+			% ["class is" if engine.size() == 1 else "classes are", ", ".join(engine)]
 		)
 	)
+	if not own.is_empty():
+		offered += (
+			" The nearest %s a project script declares %s %s, which script_info structure reads."
+			% [
+				"class" if own.size() == 1 else "classes",
+				"is" if own.size() == 1 else "are",
+				", ".join(own),
+			]
+		)
 	return _log.failure(
 		(
 			(
@@ -204,17 +263,24 @@ func _not_found(wanted: String) -> Dictionary:
 	)
 
 
+# One member of a class by name, wherever in its ancestry it is declared.
+#
+# The question a member is asked by name for is "does this engine have it, and what does it take":
+# the whole class in answer to that ran to seventy thousand characters for Control, and the member
+# is as often an ancestor's as the class's own, so the ancestry is walked without being asked. Each
+# match says which class declares it. Nothing found names the members whose names contain the one
+# asked for, since the usual miss is a spelling.
 func _member_of(class_name_str: String, member: String) -> Dictionary:
 	var found: Array[Dictionary] = []
 	var current: String = class_name_str
 	while not current.is_empty():
-		for m: Dictionary in _methods_of(current, false):
+		for m: Dictionary in _methods_of(current):
 			if m["name"] == member:
 				found.append({"kind": "method", "declared_in": current, "member": m})
-		for p: Dictionary in _properties_of(current, false):
+		for p: Dictionary in _properties_of(current):
 			if p["name"] == member:
 				found.append({"kind": "property", "declared_in": current, "member": p})
-		for s: Dictionary in _signals_of(current, false):
+		for s: Dictionary in _signals_of(current):
 			if s["name"] == member:
 				found.append({"kind": "signal", "declared_in": current, "member": s})
 		for e: String in ClassDB.class_get_enum_list(current, true):
@@ -251,15 +317,15 @@ func _members_alike(class_name_str: String, member: String) -> Array[String]:
 	var wanted: String = member.to_lower()
 	var current: String = class_name_str
 	while not current.is_empty():
-		for m: Dictionary in _methods_of(current, false):
+		for m: Dictionary in _methods_of(current):
 			var name: String = m["name"]
 			if name.to_lower().contains(wanted) and not alike.has(name):
 				alike.append(name)
-		for p: Dictionary in _properties_of(current, false):
+		for p: Dictionary in _properties_of(current):
 			var name: String = p["name"]
 			if name.to_lower().contains(wanted) and not alike.has(name):
 				alike.append(name)
-		for s: Dictionary in _signals_of(current, false):
+		for s: Dictionary in _signals_of(current):
 			var name: String = s["name"]
 			if name.to_lower().contains(wanted) and not alike.has(name):
 				alike.append(name)
@@ -275,7 +341,7 @@ func inspect_inheritance(params: Dictionary) -> Dictionary:
 	_log.info("Inspecting inheritance for: " + class_name_str)
 
 	if not ClassDB.class_exists(class_name_str):
-		return _not_found(class_name_str)
+		return _not_found(class_name_str, _declared_classes(params))
 
 	var ancestors: Array[String] = []
 	var current: String = class_name_str
@@ -324,10 +390,10 @@ func inspect_inheritance(params: Dictionary) -> Dictionary:
 	}
 
 
-func _methods_of(class_name_str: String, include_inherited: bool) -> Array[Dictionary]:
+func _methods_of(class_name_str: String) -> Array[Dictionary]:
 	var methods: Array[Dictionary] = []
 
-	for m: Dictionary in ClassDB.class_get_method_list(class_name_str, not include_inherited):
+	for m: Dictionary in ClassDB.class_get_method_list(class_name_str, true):
 		var args: Array[Dictionary] = []
 		var declared_args: Array = m.get("args", [])
 		for a: Dictionary in declared_args:
@@ -389,10 +455,10 @@ static func _type_name(info: Dictionary, nil_name: String) -> String:
 	return type_string(type)
 
 
-func _properties_of(class_name_str: String, include_inherited: bool) -> Array[Dictionary]:
+func _properties_of(class_name_str: String) -> Array[Dictionary]:
 	var properties: Array[Dictionary] = []
 
-	for p: Dictionary in ClassDB.class_get_property_list(class_name_str, not include_inherited):
+	for p: Dictionary in ClassDB.class_get_property_list(class_name_str, true):
 		# A category, group or subgroup is an editor heading rather than a property.
 		var usage: int = GdhRead.as_int(p.get("usage", 0))
 		if usage & PROPERTY_USAGE_CATEGORY or usage & PROPERTY_USAGE_GROUP or usage & PROPERTY_USAGE_SUBGROUP:
@@ -412,10 +478,10 @@ func _properties_of(class_name_str: String, include_inherited: bool) -> Array[Di
 	return properties
 
 
-func _signals_of(class_name_str: String, include_inherited: bool) -> Array[Dictionary]:
+func _signals_of(class_name_str: String) -> Array[Dictionary]:
 	var signals: Array[Dictionary] = []
 
-	for s: Dictionary in ClassDB.class_get_signal_list(class_name_str, not include_inherited):
+	for s: Dictionary in ClassDB.class_get_signal_list(class_name_str, true):
 		var sig_args: Array[Dictionary] = []
 		var declared_args: Array = s.get("args", [])
 		for a: Dictionary in declared_args:

package/build/godot/operations/declared_values.gd

@@ -58,12 +58,70 @@ static func enum_named(choices: Dictionary, word: String) -> Variant:
 	return null
 
 
-static func enum_refusal(holder: String, property: String, word: String, choices: Dictionary) -> String:
+## The values of the engine enum [param property] of [param target] holds, by the constants its
+## class declares them as: blend_mode's Add is BLEND_MODE_ADD in a script, and the hint gives only
+## the inspector's word. Empty for an enum a script declares.
+##
+## The enum is named by the setter's argument, as Node.ProcessMode, since the property list gives
+## an engine enum property no class of its own.
+static func engine_constants(target: Object, property: String) -> Dictionary:
+	var values: Dictionary = {}
+	var engine_class: String = target.get_class()
+	var setter: String = str(ClassDB.class_get_property_setter(engine_class, property))
+	if setter.is_empty():
+		return values
+	var named: String = ""
+	for method: Dictionary in ClassDB.class_get_method_list(engine_class):
+		var arguments: Array = method.get("args", [])
+		if str(method.get("name", "")) == setter and not arguments.is_empty():
+			var value_argument: Dictionary = arguments[-1]
+			named = str(value_argument.get("class_name", ""))
+			break
+	var holder: String = named.get_slice(".", 0)
+	if named.count(".") != 1 or not ClassDB.class_exists(holder):
+		return values
+	for constant: String in ClassDB.class_get_enum_constants(holder, named.get_slice(".", 1)):
+		values[constant] = ClassDB.class_get_integer_constant(holder, constant)
+	return values
+
+
+## [param word] as the number of the value the enum property [param declared] of [param target]
+## names by it, as [true, number], or [false, why] naming the values, with [param holder] naming the
+## target in the refusal. [false, ""] for a word that is a number, which converts as one.
+##
+## An enum is written by the name of a value as well as its number, since the name is what the script
+## and the inspector show and the number is only where the value happens to sit. Tried as the script
+## spells it, then as the hint does, then as the engine's constant.
+static func enum_by_name(target: Object, declared: Dictionary, word: String, holder: String) -> Array:
+	var property: String = str(declared.get("name", ""))
+	var choices: Dictionary = enum_of(target, declared)
+	var chosen: Variant = enum_named(choices, word)
+	if chosen == null:
+		chosen = enum_named(enum_values(str(declared.get("hint_string", ""))), word)
+	var constants: Dictionary = {}
+	if chosen == null:
+		constants = engine_constants(target, property)
+		chosen = enum_named(constants, word)
+	if chosen != null:
+		return [true, chosen]
+	if word.strip_edges().is_valid_int():
+		return [false, ""]
+	return [false, enum_refusal(holder, property, word, choices, constants)]
+
+
+static func enum_refusal(
+	holder: String, property: String, word: String, choices: Dictionary, constants: Dictionary = {}
+) -> String:
+	var ways: String = "by name or by number"
+	if not constants.is_empty():
+		ways = "by name, by number or by the engine's constant, such as %s" % str(constants.keys()[0])
 	var said: String = (
-		"%s.%s is an enum, and %s is none of its values: send %s by name or by number"
-		% [holder, property, word, _listed(choices)]
+		"%s.%s is an enum, and %s is none of its values: send %s %s"
+		% [holder, property, word, _listed(choices), ways]
 	)
-	var close: PackedStringArray = GdhRead.nearest(word, PackedStringArray(choices.keys()))
+	var named: PackedStringArray = PackedStringArray(choices.keys())
+	named.append_array(PackedStringArray(constants.keys()))
+	var close: PackedStringArray = GdhRead.nearest(word, named)
 	if close.is_empty():
 		return said + "."
 	return said + ". The nearest %s %s." % ["is" if close.size() == 1 else "are", ", ".join(close)]
@@ -76,6 +134,17 @@ static func outside(target: Object, declared: Dictionary, value: Variant, shown:
 	var hint: int = GdhRead.as_int(declared.get("hint", PROPERTY_HINT_NONE))
 	var hint_string: String = str(declared.get("hint_string", ""))
 	var property: String = str(declared.get("name", ""))
+	if hint == PROPERTY_HINT_ENUM and (typeof(value) == TYPE_STRING or typeof(value) == TYPE_STRING_NAME):
+		var names: PackedStringArray = PackedStringArray(enum_values(hint_string).keys())
+		if names.is_empty() or names.has(str(value)):
+			return ""
+		return (
+			(
+				"%s is none of the names %s lists: %s, which the inspector holds it to; the engine "
+				+ "stores it as given."
+			)
+			% [shown, property, ", ".join(names)]
+		)
 	if typeof(value) != TYPE_INT and typeof(value) != TYPE_FLOAT:
 		return ""
 	var number: float = GdhRead.as_float(value)
@@ -114,3 +183,111 @@ static func _listed(choices: Dictionary) -> String:
 ## A range's end as the script wrote it: the engine's hint gives @export_range(0, 10) as 0.0 and 10.0.
 static func _bound(end: float) -> String:
 	return str(int(end)) if end == floorf(end) and absf(end) < 1e15 else str(end)
+
+
+## Puts back on [param built] what its script set as it was attached and was not among
+## [param wanted], to the defaults it declares, outside the editor. Attaching runs the script's _init
+## there, which the editor never runs for a script that is not a tool, so a resource_name _init chose
+## was saved as if asked for. A property whose default the engine cannot report is left as made.
+static func unmade(built: Resource, wanted: Dictionary) -> void:
+	var attached: Variant = built.get_script()
+	if Engine.is_editor_hint() or not attached is Script:
+		return
+	var script: Script = attached
+	var asked: Dictionary = {}
+	for key: Variant in wanted:
+		asked[str(key).get_slice(":", 0)] = true
+	for entry: Dictionary in built.get_property_list():
+		var name: String = str(entry["name"])
+		var usage: int = GdhRead.as_int(entry["usage"])
+		if usage & PROPERTY_USAGE_STORAGE == 0 or name == "script" or asked.has(name):
+			continue
+		var declared: Variant = ClassDB.class_get_property_default_value(built.get_class(), name)
+		if usage & PROPERTY_USAGE_SCRIPT_VARIABLE:
+			declared = script.get_property_default_value(name)
+		var held: Variant = built.get(name)
+		if declared != null and not (typeof(held) == typeof(declared) and held == declared):
+			built.set(name, declared)
+
+
+## The element types a typed Array or Dictionary property declares: [element] for an array,
+## [key, value] for a dictionary, [] when nothing is declared.
+##
+## Read from the declaration because the value cannot say: a script's exported `Array[int]` sits
+## behind a placeholder in the editor, and measured on 4.7.2 that placeholder stores [1.5, 2.0]
+## as given, which the game then fails to load into the typed array.
+static func elements_of(declared: Dictionary) -> Array:
+	var type: int = GdhRead.as_int(declared.get("type", TYPE_NIL), TYPE_NIL)
+	var hint: int = GdhRead.as_int(declared.get("hint", PROPERTY_HINT_NONE))
+	var wanted: String = str(declared.get("hint_string", ""))
+	if wanted.is_empty():
+		return []
+	if hint == PROPERTY_HINT_TYPE_STRING:
+		var parts: PackedStringArray = wanted.split(";")
+		if type == TYPE_ARRAY and parts.size() == 1:
+			return [_type_in_hint(parts[0])]
+		if type == TYPE_DICTIONARY and parts.size() == 2:
+			return [_type_in_hint(parts[0]), _type_in_hint(parts[1])]
+		return []
+	if hint == PROPERTY_HINT_ARRAY_TYPE and type == TYPE_ARRAY:
+		return [_type_named(wanted)]
+	if hint == PROPERTY_HINT_DICTIONARY_TYPE and type == TYPE_DICTIONARY:
+		var parts: PackedStringArray = wanted.split(";")
+		if parts.size() == 2:
+			return [_type_named(parts[0]), _type_named(parts[1])]
+	return []
+
+
+## The type at the front of one entry of a type-string hint, "2:" or "24/17:Texture2D".
+static func _type_in_hint(entry: String) -> int:
+	var number: String = entry.get_slice(":", 0).get_slice("/", 0)
+	return number.to_int() if number.is_valid_int() else TYPE_NIL
+
+
+## The Variant type [param name] names, or TYPE_OBJECT for a class.
+static func _type_named(name: String) -> int:
+	var named: String = name.get_slice(":", 0).strip_edges()
+	for type: int in TYPE_MAX:
+		if type_string(type) == named:
+			return type
+	return TYPE_OBJECT if not named.is_empty() else TYPE_NIL
+
+
+## The class the objects of a typed list or map hold, and whether they are nodes, as
+## [class, nodes], read from entry [param at] of [param declared]'s hint: "24/17:Item" in a type
+## string, "Item" in an array or dictionary type.
+static func object_kind(declared: Dictionary, at: int) -> Array:
+	var entry: String = str(declared.get("hint_string", "")).get_slice(";", at)
+	if GdhRead.as_int(declared.get("hint", PROPERTY_HINT_NONE)) != PROPERTY_HINT_TYPE_STRING:
+		return [entry.strip_edges(), false]
+	var nodes: bool = entry.get_slice(":", 0).get_slice("/", 1) == str(PROPERTY_HINT_NODE_TYPE)
+	return [entry.get_slice(":", 1), nodes]
+
+
+## The base class and script that type a list or map holding [param wanted], as [class, script],
+## or [] when nothing in the project or the engine is called that.
+static func object_typing(wanted: String) -> Array:
+	if ClassDB.class_exists(wanted):
+		return [StringName(wanted), null]
+	var script: Script = script_class(wanted)
+	return [] if script == null else [script.get_instance_base_type(), script]
+
+
+## The script declaring the class_name [param name], or null.
+static func script_class(name: String) -> Script:
+	for entry: Dictionary in ProjectSettings.get_global_class_list():
+		if str(entry.get("class", "")) == name:
+			return load(str(entry.get("path", ""))) as Script
+	return null
+
+
+## Whether [param value] is the class [param name] names, an engine class or a script's class_name.
+static func is_a(value: Object, name: String) -> bool:
+	if value.is_class(name):
+		return true
+	var script: Script = value.get_script()
+	while script != null:
+		if str(script.get_global_name()) == name:
+			return true
+		script = script.get_base_script()
+	return false

package/build/godot/operations/dependencies.gd

@@ -58,47 +58,21 @@ func get_dependencies(params: Dictionary) -> Dictionary:
 	var max_depth: int = depth if depth > 0 else 1000
 	var include_built_in: bool = GdhRead.as_bool(params.get("include_builtin", false))
 
-	_log.info(
-		(
-			"Getting dependencies"
-			+ (" for: " + resource_path if not resource_path.is_empty() else " for all resources")
-		)
-	)
+	if resource_path.is_empty():
+		return _log.failure("resource_path is required")
+	_log.info("Getting dependencies for: " + resource_path)
 
 	var dependencies: Dictionary = {}
 	var circular_references: Array = []
-	var total_resources: int = 0
-
-	if not resource_path.is_empty():
-		var full_path: String = resource_path
-		if not full_path.begins_with("res://"):
-			full_path = "res://" + full_path
-
-		if not FileAccess.file_exists(full_path):
-			return _log.failure(
-				_files.with_nearest_files("Resource file does not exist: " + full_path, full_path)
-			)
-
-		var walk: GdhDependencyWalk = GdhDependencyWalk.new(max_depth, include_built_in, circular_references)
-		dependencies[full_path] = _analyze_resource(full_path, 0, walk)
-		total_resources = 1
-	else:
-		var resource_extensions: Array[String] = ["tscn", "tres", "gd", "gdshader", "shader"]
-		var all_resources: Array[String] = []
-		for ext: String in resource_extensions:
-			all_resources.append_array(_files.find_files("res://", "." + ext))
-
-		# Each root gets a fresh walk so a cycle is reported from every resource it passes
-		# through, rather than only from whichever one happened to be walked first.
-		for res_path: String in all_resources:
-			var walk: GdhDependencyWalk = GdhDependencyWalk.new(
-				max_depth, include_built_in, circular_references
-			)
-			var deps: Array[Dictionary] = _analyze_resource(res_path, 0, walk)
-			if deps.size() > 0:
-				dependencies[res_path] = deps
-
-		total_resources = all_resources.size()
+	var full_path: String = resource_path
+	if not full_path.begins_with("res://"):
+		full_path = "res://" + full_path
+	if not FileAccess.file_exists(full_path):
+		return _log.failure(
+			_files.with_nearest_files("Resource file does not exist: " + full_path, full_path)
+		)
+	var walk: GdhDependencyWalk = GdhDependencyWalk.new(max_depth, include_built_in, circular_references)
+	dependencies[full_path] = _analyze_resource(full_path, 0, walk)
 
 	var references: int = 0
 	var distinct: Dictionary = {}
@@ -121,7 +95,8 @@ func get_dependencies(params: Dictionary) -> Dictionary:
 		"circular_references": circular_references,
 		"summary":
 		{
-			"total_resources": total_resources,
+			# The file the walk starts from, which a call always names one of.
+			"total_resources": 1,
 			# The files depended on, each once. The tree names a file again under everything that
 			# loads it, and counting its entries answered 11 for a scene with six dependencies.
 			"total_dependencies": distinct.size(),

package/build/godot/operations/editor_tools.gd

@@ -10,6 +10,7 @@ extends RefCounted
 const GdhAnimationTools = preload("../addons/gdharness_editor/tools/animation_tools.gd")
 const GdhResourceTools = preload("../addons/gdharness_editor/tools/resource_tools.gd")
 const GdhSceneTools = preload("../addons/gdharness_editor/tools/scene_tools.gd")
+const GdhSignalTools = preload("../addons/gdharness_editor/tools/signal_tools.gd")
 const GdhSceneFile = preload("../addons/gdharness_editor/scene_file.gd")
 
 const SCENE_COMMANDS: Array[String] = [
@@ -21,10 +22,8 @@ const SCENE_COMMANDS: Array[String] = [
 	"duplicate_node",
 	"reparent_node",
 	"delete_node",
-	"connect_signal",
-	"disconnect_signal",
-	"list_connections",
 ]
+const SIGNAL_COMMANDS: Array[String] = ["connect_signal", "disconnect_signal", "list_connections"]
 const RESOURCE_COMMANDS: Array[String] = [
 	"set_tilemap_cells",
 	"create_resource",
@@ -55,6 +54,8 @@ static func run(params: Dictionary) -> Dictionary:
 	var tools: Node = null
 	if command in SCENE_COMMANDS:
 		tools = GdhSceneTools.new()
+	elif command in SIGNAL_COMMANDS:
+		tools = GdhSignalTools.new()
 	elif command in RESOURCE_COMMANDS:
 		tools = GdhResourceTools.new()
 	elif command in ANIMATION_COMMANDS:

package/build/godot/operations/file_reads.gd

@@ -10,8 +10,8 @@ extends RefCounted
 ## without making a node. Loading the file still does what loading does in the game: static
 ## initialisers run, and a resource with a script is made with it.
 
-const GdhPropertyValues = preload("property_values.gd")
 const GdhRead = preload("reading.gd")
+const GdhSame = preload("same_values.gd")
 const GdhSerialisation = preload("serialisation.gd")
 
 
@@ -188,6 +188,12 @@ static func _lay(
 					path,
 					state.get_node_index(index)
 				)
+		# Every file on the way puts the node in its own groups: the scene making it, and each scene
+		# instancing or inheriting that one.
+		var grouped: Array[String] = nodes[path]["groups"]
+		for group: StringName in state.get_node_groups(index):
+			if not grouped.has(str(group)):
+				grouped.append(str(group))
 		var held: Dictionary = nodes[path]["properties"]
 		for property: int in state.get_node_property_count(index):
 			held[str(state.get_node_property_name(index, property))] = state.get_node_property_value(
@@ -281,7 +287,8 @@ static func _by_id(nodes: Dictionary, owner: String, id: int) -> String:
 
 static func _made(type: String) -> Dictionary:
 	var children: Array[String] = []
-	return {"name": "", "type": type, "properties": {}, "children": children}
+	var groups: Array[String] = []
+	return {"name": "", "type": type, "properties": {}, "children": children, "groups": groups}
 
 
 ## Puts [param path] among [param parent]'s children, at [param at] when the file says where (a node
@@ -317,6 +324,11 @@ static func _entry(
 		data["instanceOf"] = node["instanceOf"]
 		if node.has("editableChildren"):
 			data["editableChildren"] = node["editableChildren"]
+	var groups: Array[String] = node["groups"]
+	if not groups.is_empty():
+		var sorted: Array[String] = groups.duplicate()
+		sorted.sort()
+		data["groups"] = sorted
 	if include_properties:
 		var given: Dictionary = node["properties"]
 		data["properties"] = _stored(str(node["type"]), given)
@@ -419,7 +431,7 @@ static func resource(res_path: String, include_defaults: bool) -> Dictionary:
 				if scripted.has(property)
 				else ClassDB.class_get_property_default_value(loaded.get_class(), property)
 			)
-			if GdhPropertyValues.same(value, default):
+			if GdhSame.same(value, default):
 				continue
 		properties[property] = serialiser.serialize_value(value)
 	var answer: Dictionary = {