gdharness 1.3.47 → 1.3.49

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

@@ -16,6 +16,22 @@ const UPDATE_MODE_NAMES: Dictionary[int, String] = {
 	Animation.UPDATE_DISCRETE: "discrete",
 	Animation.UPDATE_CAPTURE: "capture",
 }
+const INTERPOLATION_NAMES: Dictionary[int, String] = {
+	Animation.INTERPOLATION_NEAREST: "nearest",
+	Animation.INTERPOLATION_LINEAR: "linear",
+	Animation.INTERPOLATION_CUBIC: "cubic",
+	Animation.INTERPOLATION_LINEAR_ANGLE: "linear_angle",
+	Animation.INTERPOLATION_CUBIC_ANGLE: "cubic_angle",
+}
+## The track types whose keys are blended between, so how they are and whether a looping animation
+## blends its last key into its first say how the track moves.
+const INTERPOLATED_TYPES: Array[int] = [
+	Animation.TYPE_VALUE,
+	Animation.TYPE_POSITION_3D,
+	Animation.TYPE_ROTATION_3D,
+	Animation.TYPE_SCALE_3D,
+	Animation.TYPE_BLEND_SHAPE,
+]
 const TRACK_TYPE_NAMES: Dictionary[int, String] = {
 	Animation.TYPE_VALUE: "property",
 	Animation.TYPE_POSITION_3D: "position_3d",
@@ -174,6 +190,10 @@ static func _track(anim: Animation, track: int, values: GdhSerialisation) -> Dic
 	if kind == Animation.TYPE_VALUE:
 		var mode: int = anim.value_track_get_update_mode(track)
 		shaped["update"] = UPDATE_MODE_NAMES.get(mode, str(mode))
+	if kind in INTERPOLATED_TYPES:
+		var interpolation: int = anim.track_get_interpolation_type(track)
+		shaped["interpolation"] = INTERPOLATION_NAMES.get(interpolation, str(interpolation))
+		shaped["loopWrap"] = anim.track_get_interpolation_loop_wrap(track)
 	var keyframes: Array[Dictionary] = []
 	var methods: Dictionary = {}
 	for key: int in anim.track_get_key_count(track):

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

@@ -113,6 +113,41 @@ static func engine_constants(target: Object, property: String) -> Dictionary:
 	return values
 
 
+## The number [param word] names as a constant of the global enum the property [param declared] of
+## [param target] holds, such as VERTICAL_ALIGNMENT_BOTTOM, or null when it names none. ClassDB
+## lists no global enum and Expression reads no global constant, so a word spelt from the enum's
+## name and a value the hint gives is compiled, and taken only when the engine reads it as that
+## value: ORIENTATION_VERTICAL is spelt so and is not a constant, which is HORIZONTAL or VERTICAL.
+static func _global_constant(target: Object, declared: Dictionary, word: String) -> Variant:
+	var engine_class: String = target.get_class()
+	var setter: String = str(
+		ClassDB.class_get_property_setter(engine_class, str(declared.get("name", "")))
+	)
+	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
+	if named.is_empty() or "." in named:
+		return null
+	var wanted: String = word.strip_edges().to_upper()
+	var hinted: Dictionary = enum_values(str(declared.get("hint_string", "")))
+	for value_word: String in hinted:
+		var constant: String = (
+			named.to_snake_case().to_upper() + "_" + value_word.to_upper().replace(" ", "_")
+		)
+		if constant != wanted:
+			continue
+		var reader: GDScript = GDScript.new()
+		reader.source_code = "extends RefCounted\nconst READ = %s\n" % constant
+		if (reader.reload() == OK
+				and reader.get_script_constant_map().get("READ") == hinted[value_word]):
+			return hinted[value_word]
+	return null
+
+
 ## [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.
@@ -132,6 +167,8 @@ static func enum_by_name(
 	if chosen == null:
 		constants = engine_constants(target, property)
 		chosen = enum_named(constants, word)
+	if chosen == null and constants.is_empty():
+		chosen = _global_constant(target, declared, word)
 	if chosen != null:
 		return [true, chosen]
 	if word.strip_edges().is_valid_int():

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

@@ -356,6 +356,12 @@ static func _entry(
 	var data: Dictionary = {
 		"name": node["name"], "type": node["type"], "path": path, "children": children,
 	}
+	var given_values: Dictionary = node["properties"]
+	var attached: Variant = given_values.get("script")
+	if attached is Script:
+		var script: Script = attached
+		if not str(script.get_global_name()).is_empty():
+			data["scriptClass"] = str(script.get_global_name())
 	# The root's file is the scene being read, so only another node's names a second scene.
 	if path != "." and node.has("instanceOf"):
 		data["instanceOf"] = node["instanceOf"]

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

@@ -118,7 +118,7 @@ func cannot_hold(
 	if not GdhSerialisation.acceptable(value, expected_type):
 		var shape: String = "%s.%s is %s and the value given is %s, which cannot become one."
 		var remedy: String = GdhShapes.remedy(value, expected_type)
-		return shape % [holder, property, held, _kind(value)] + remedy + cost
+		return shape % [holder, property, held, GdhShapes.kind(value)] + remedy + cost
 
 	# And the same question of each element, because a list is accepted for a packed or typed array
 	# whatever is in it: a polygon written as [{"x": 1}] passes the check above and lands as one
@@ -132,7 +132,12 @@ func cannot_hold(
 			if not GdhSerialisation.acceptable(items[index], element):
 				var shape: String = "%s.%s is %s and item %d of the list given is %s, not %s."
 				var named: Array = [
-					holder, property, held, index, _kind(items[index]), type_string(element),
+					holder,
+					property,
+					held,
+					index,
+					GdhShapes.kind(items[index]),
+					type_string(element),
 				]
 				return shape % named + GdhShapes.remedy(items[index], element) + cost
 			# A list of polygons is a list of lists of points, and each point is read as one too.
@@ -151,7 +156,7 @@ func cannot_hold(
 						type_string(inner),
 						at,
 						index,
-						_kind(points[at]),
+						GdhShapes.kind(points[at]),
 						type_string(inner),
 					]
 					return nested % said + GdhShapes.remedy(points[at], inner) + cost
@@ -173,14 +178,6 @@ func cannot_hold(
 	return ""
 
 
-## What [param value] is, as a refusal names it. A number arrives from JSON as a float whether or
-## not it has a fraction, so [1, 2] given for a list of words was called a list of floats.
-static func _kind(value: Variant) -> String:
-	if value is int or value is float:
-		return "a number"
-	return type_string(typeof(value))
-
-
 ## Writes each of [param properties] onto [param target], stopping at the first it cannot write and
 ## answering with why, or "" when every one of them went on and holds what was given.
 ##

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

@@ -109,6 +109,9 @@ func add_animation_track(args: Dictionary) -> Dictionary:
 	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))
+		var blended: int = anim.track_get_interpolation_type(track_idx)
+		answer["interpolation"] = GdhAnimationReads.INTERPOLATION_NAMES.get(blended, str(blended))
+		answer["loopWrap"] = anim.track_get_interpolation_loop_wrap(track_idx)
 	if built[3]:
 		answer["existingTrack"] = true
 	var replaced: Array = built[5]
@@ -165,6 +168,7 @@ func _add_track(
 	var kind: Animation.TrackType = Animation.TYPE_VALUE
 	var path: NodePath = NodePath(target_path)
 	var update: int = -1
+	var interpolation: int = -1
 	if track_type == "property":
 		var prop_name: String = str(track.get("property", ""))
 		if prop_name.is_empty():
@@ -175,6 +179,11 @@ func _add_track(
 		)
 		if named != null:
 			update = GdhRead.as_int(named)
+		var blended: Variant = GdhAnimationReads.INTERPOLATION_NAMES.find_key(
+			str(track.get("interpolation", ""))
+		)
+		if blended != null:
+			interpolation = GdhRead.as_int(blended)
 		var values: Array = _key_values(target, prop_name, keyframes)
 		if not values[0]:
 			return _not_added(str(values[1]))
@@ -196,6 +205,12 @@ func _add_track(
 				misfit = _key_misfit(target, method_name, arguments, index)
 		method_found = target.has_method(method_name)
 		kind = Animation.TYPE_METHOD
+		# A method key is called at its time and never blended, so neither has anything to set.
+		for blending: String in ["interpolation", "loopWrap"]:
+			if track.has(blending):
+				return _not_added(
+					"track.%s is for property tracks; a method key is not blended." % blending
+				)
 	else:
 		return _not_added(
 			(
@@ -250,6 +265,10 @@ func _add_track(
 			_as_the_editor_makes(anim, track_idx, player, target)
 	if update >= 0:
 		anim.value_track_set_update_mode(track_idx, update as Animation.UpdateMode)
+	if interpolation >= 0:
+		anim.track_set_interpolation_type(track_idx, interpolation as Animation.InterpolationType)
+	if track.has("loopWrap"):
+		anim.track_set_interpolation_loop_wrap(track_idx, GdhRead.as_bool(track["loopWrap"]))
 	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:

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

@@ -14,6 +14,12 @@ const HEADLESS_DISPLAY: String = "headless"
 ## for every editor on the machine, and bound only while a game runs.
 const DEBUGGER_SETTING: String = "network/debug/remote_port"
 const LOOPBACK: String = "127.0.0.1"
+## Set in the environment of an editor the server started on its hidden desktop, and so in every
+## game it plays. Kept in step with `DESKTOP_VARIABLE` in the server's desktop module.
+const DESKTOP_VARIABLE: String = "GDHARNESS_DESKTOP"
+const RUN_ARGS_SETTING: String = "editor/run/main_run_args"
+## Kept in step with `HIDDEN_WINDOW_FPS` in the server's launch module.
+const HIDDEN_WINDOW_FPS: int = 60
 
 var _editor_plugin: EditorPlugin = null
 ## Which play this is, counted up for every one the editor starts, whoever starts it. What a server
@@ -80,10 +86,26 @@ func play_scene(args: Dictionary) -> Dictionary:
 
 	var debugger: int = _a_port_for_the_debugger()
 
+	var held: String = str(ProjectSettings.get_setting(RUN_ARGS_SETTING, ""))
+	var given: String = with_hidden_window_flags(
+		held,
+		OS.get_name() == "Windows" and not OS.get_environment(DESKTOP_VARIABLE).is_empty(),
+		GdhRead.as_int(ProjectSettings.get_setting("application/run/max_fps", 0)) > 0,
+	)
+	# The editor builds the game's command line from the text its run instances dialog holds, which
+	# it fetches from the setting on settings_changed. The project emits that a frame later, so it
+	# is emitted here on both sides of the play, and no frame passes in which anything could save
+	# the project with the flags in it.
+	if given != held:
+		ProjectSettings.set_setting(RUN_ARGS_SETTING, given)
+		ProjectSettings.settings_changed.emit()
 	if full_path.is_empty():
 		EditorInterface.play_main_scene()
 	else:
 		EditorInterface.play_custom_scene(full_path)
+	if given != held:
+		ProjectSettings.set_setting(RUN_ARGS_SETTING, held)
+		ProjectSettings.settings_changed.emit()
 
 	_play += 1
 	_was_playing = EditorInterface.is_playing_scene()
@@ -99,6 +121,26 @@ func play_scene(args: Dictionary) -> Dictionary:
 	}
 
 
+## [param held], the project's run arguments, with the flags a window on the hidden desktop starts
+## with put in front when [param hidden] says the editor is there: the server's `hiddenWindowFlags`
+## gives the reason. Nothing is added for a game the arguments already play headless, and no cap
+## where [param capped] says the project sets one or the arguments do. In front because a `--` in
+## them makes everything after it the game's own; after `%command%` when they hold one, since what
+## goes before it is the command that runs the engine.
+static func with_hidden_window_flags(held: String, hidden: bool, capped: bool) -> String:
+	var words: PackedStringArray = held.split(" ", false)
+	if not hidden or words.has("--headless"):
+		return held
+	var flags: String = "--disable-vsync"
+	if not capped and not words.has("--max-fps"):
+		flags += " --max-fps %d" % HIDDEN_WINDOW_FPS
+	var placeholder: int = held.find("%command%")
+	if placeholder == -1:
+		return (flags + " " + held).strip_edges()
+	var after: int = placeholder + "%command%".length()
+	return held.substr(0, after) + " " + flags + held.substr(after)
+
+
 ## Gives this editor's debugger a port of its own, and answers the one the game will be sent to.
 ##
 ## The editor binds this while a game runs, out of a setting shared by every editor on the

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

@@ -212,7 +212,7 @@ func create_resource(args: Dictionary) -> Dictionary:
 			"ok": false,
 			"error":
 			(
-				"%s is neither an engine class nor a class_name a script in this project declares."
+				"%s is neither an engine class nor a class_name in the project's class list."
 				% resource_type
 			),
 		}

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

@@ -50,9 +50,16 @@ static func what_to_add(node_type: String, instance_path: String, scene_path: St
 
 
 ## The refusal for [param given], sent as [param argument], which names no node class, with the
-## node classes nearest it, so "Node2DD" is offered Node2D.
+## node classes nearest it, so "Node2DD" is offered Node2D. A name that is no engine class at all
+## may
+## have been meant as a class_name, which is taken too.
 static func not_a_node_class(argument: String, given: String) -> String:
 	var said: String = "%s must be a node class, and %s is not one" % [argument, given]
+	if not ClassDB.class_exists(given):
+		said = (
+			"%s must be a node class or a class_name in the project's class list, and %s is neither"
+			% [argument, given]
+		)
 	var classes: PackedStringArray = ClassDB.get_inheriters_from_class("Node")
 	var _added: bool = classes.append("Node")
 	var close: PackedStringArray = GdhRead.nearest(given, classes)

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

@@ -234,6 +234,15 @@ static func packed_from(items: Array, type: int, fit: Callable) -> Variant:
 	return type_convert(built, type)
 
 
+## What [param value] is, as a refusal names it. A number arrives from JSON as a float whether or
+## not it has a fraction, so [1, 2] given for a list of words was called a list of floats, and 5
+## given for a Vector2 was called a float.
+static func kind(value: Variant) -> String:
+	if value is int or value is float:
+		return "a number"
+	return type_string(typeof(value))
+
+
 ## The sentences a refusal of [param value] where a [param type] goes ends with: which of its keys
 ## kept it from being read as one, and how one is written. Empty for a type not built from fields.
 ##

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

@@ -113,6 +113,41 @@ static func engine_constants(target: Object, property: String) -> Dictionary:
 	return values
 
 
+## The number [param word] names as a constant of the global enum the property [param declared] of
+## [param target] holds, such as VERTICAL_ALIGNMENT_BOTTOM, or null when it names none. ClassDB
+## lists no global enum and Expression reads no global constant, so a word spelt from the enum's
+## name and a value the hint gives is compiled, and taken only when the engine reads it as that
+## value: ORIENTATION_VERTICAL is spelt so and is not a constant, which is HORIZONTAL or VERTICAL.
+static func _global_constant(target: Object, declared: Dictionary, word: String) -> Variant:
+	var engine_class: String = target.get_class()
+	var setter: String = str(
+		ClassDB.class_get_property_setter(engine_class, str(declared.get("name", "")))
+	)
+	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
+	if named.is_empty() or "." in named:
+		return null
+	var wanted: String = word.strip_edges().to_upper()
+	var hinted: Dictionary = enum_values(str(declared.get("hint_string", "")))
+	for value_word: String in hinted:
+		var constant: String = (
+			named.to_snake_case().to_upper() + "_" + value_word.to_upper().replace(" ", "_")
+		)
+		if constant != wanted:
+			continue
+		var reader: GDScript = GDScript.new()
+		reader.source_code = "extends RefCounted\nconst READ = %s\n" % constant
+		if (reader.reload() == OK
+				and reader.get_script_constant_map().get("READ") == hinted[value_word]):
+			return hinted[value_word]
+	return null
+
+
 ## [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.
@@ -132,6 +167,8 @@ static func enum_by_name(
 	if chosen == null:
 		constants = engine_constants(target, property)
 		chosen = enum_named(constants, word)
+	if chosen == null and constants.is_empty():
+		chosen = _global_constant(target, declared, word)
 	if chosen != null:
 		return [true, chosen]
 	if word.strip_edges().is_valid_int():

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

@@ -40,6 +40,7 @@ const WALK: String = r"""
 $ErrorActionPreference = 'Stop'
 function Answer($value) {
   [System.IO.File]::WriteAllText($Out, (ConvertTo-Json -InputObject $value -Depth 100 -Compress))
+  Mark 'answered'
 }
 function Mark($stage) {
   [System.IO.File]::AppendAllText($Progress, "$stage $([DateTimeOffset]::UtcNow.ToUnixTimeMilliseconds())`n")
@@ -280,14 +281,24 @@ func get_accessibility(params: Dictionary) -> Dictionary:
 	var looked_at: int = began_at
 	while OS.is_process_running(pid):
 		var now: int = Time.get_ticks_msec()
-		if not walking and now - looked_at >= LOOK_MS:
+		if now - looked_at >= LOOK_MS:
 			looked_at = now
-			if FileAccess.get_file_as_string(progress).contains("loaded "):
+			var marked: String = FileAccess.get_file_as_string(progress)
+			if not walking and marked.contains("loaded "):
 				walking = true
 				deadline = _deadline(began_at, now, handles.size())
+			# The answer is whole once it is marked, so the read is done whatever the client does
+			# after it, and a client slow to exit costs the read nothing.
+			if marked.contains("answered "):
+				var _ended: Error = OS.kill(pid)
+				break
 		if now > deadline:
 			var _killed: Error = OS.kill(pid)
-			var reached: String = _reached(FileAccess.get_file_as_string(progress), started_ms)
+			var reached: String = _reached(
+				FileAccess.get_file_as_string(progress),
+				started_ms,
+				int(Time.get_unix_time_from_system() * 1000.0)
+			)
 			var _gone: Error = DirAccess.remove_absolute(progress)
 			return _refused(
 				(
@@ -743,19 +754,22 @@ static func _marks(progress: String) -> Array:
 	return marks
 
 
-## How far a client started at [param started_ms] got by the marks in [param progress], said for a
-## caller whose read it stopped: the time went to starting PowerShell, loading UI Automation, or the
-## walks, and which tells a loaded machine from a window that never answers.
-static func _reached(progress: String, started_ms: int) -> String:
+## How far a client started at [param started_ms] and stopped at [param stopped_ms] got by the marks
+## in [param progress], said for a caller whose read it stopped: the time went to starting
+## PowerShell, loading UI Automation, the walks, or after the last walk, and which tells a loaded
+## machine from a window that never answers.
+static func _reached(progress: String, started_ms: int, stopped_ms: int) -> String:
 	var marks: Array = _marks(progress)
 	var at: Dictionary = {}
 	var walks: int = 0
 	var last: String = ""
+	var last_at: int = 0
 	for mark: Array in marks:
 		var stage: String = mark[0]
 		if stage.begins_with("walked "):
 			walks += 1
 			last = stage.trim_prefix("walked ")
+			last_at = mark[1]
 		elif not at.has(stage):
 			at[stage] = mark[1]
 	if not at.has("began"):
@@ -775,9 +789,18 @@ static func _reached(progress: String, started_ms: int) -> String:
 	return (
 		(
 			"PowerShell began the client after %d ms and loaded UI Automation in %d ms, and the "
-			+ "windows were walked %d time%s, the last finding %s element%s"
+			+ "windows were walked %d time%s, the last finding %s element%s and ending %d ms "
+			+ "before the client was stopped"
 		)
-		% [began, loaded, walks, "" if walks == 1 else "s", last, "" if last == "1" else "s"]
+		% [
+			began,
+			loaded,
+			walks,
+			"" if walks == 1 else "s",
+			last,
+			"" if last == "1" else "s",
+			stopped_ms - last_at,
+		]
 	)
 
 

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

@@ -7,6 +7,7 @@ const GdhCallErrors = preload("call_errors.gd")
 const GdhDeclared = preload("declared_values.gd")
 const GdhPaths = preload("runtime_paths.gd")
 const GdhRead = preload("reading.gd")
+const GdhShapes = preload("value_shapes.gd")
 const GdhValues = preload("runtime_values.gd")
 ## The most errors a call's answer carries, which is enough to see what the method ran into and
 ## short of a method reporting one per element of a list of thousands.
@@ -254,7 +255,7 @@ func _argument_for(
 					named,
 					type_string(wants),
 					index + 1,
-					type_string(typeof(given)),
+					GdhShapes.kind(sent),
 					GdhValues.remedy(sent, wants),
 				]
 			),
@@ -379,7 +380,7 @@ func _value_for(
 						called,
 						named,
 						type_string(wanted),
-						type_string(typeof(given)),
+						GdhShapes.kind(value),
 						GdhValues.remedy(value, wanted),
 					]
 				),

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

@@ -160,7 +160,7 @@ func _hover(viewport: Viewport, point: Vector2) -> void:
 	var inside: Vector2 = container.get_global_transform_with_canvas().affine_inverse() * point
 	if container.stretch:
 		inside /= container.stretch_shrink
-	for child: Node in container.get_children():
+	for child: Node in container.get_children(true):
 		var shown: SubViewport = child as SubViewport
 		if shown != null and not shown.gui_disable_input:
 			_hover(shown, shown.get_final_transform().affine_inverse() * inside)
@@ -179,7 +179,7 @@ func _drop(viewport: Viewport, until: int) -> void:
 	var over: Control = instance_from_id(top) as Control
 	var container: SubViewportContainer = over as SubViewportContainer
 	if container != null:
-		for child: Node in container.get_children():
+		for child: Node in container.get_children(true):
 			var shown: SubViewport = child as SubViewport
 			if shown != null:
 				_drop(shown, 0)
@@ -264,7 +264,7 @@ func _pressed_at(viewport: Viewport, point: Vector2) -> Node:
 	var inside: Vector2 = container.get_global_transform_with_canvas().affine_inverse() * point
 	if container.stretch:
 		inside /= container.stretch_shrink
-	for child: Node in container.get_children():
+	for child: Node in container.get_children(true):
 		var shown: SubViewport = child as SubViewport
 		if shown != null and not shown.gui_disable_input:
 			var within: Node = _pressed_at(
@@ -277,9 +277,11 @@ func _pressed_at(viewport: Viewport, point: Vector2) -> Node:
 
 ## The controls [param node] holds that the engine keeps as roots of [param node]'s viewport: drawn
 ## on their own, or with no control above them. Not into another viewport, a window or a
-## SubViewport, whose controls are that one's.
+## SubViewport, whose controls are that one's. Internal children count, as they do for the engine,
+## though get_children leaves them out unless asked: a layer added with INTERNAL_MODE_BACK was
+## passed over, and the press predicted for the control under it.
 static func _gather_roots(node: Node, roots: Array[Control]) -> void:
-	for child: Node in node.get_children():
+	for child: Node in node.get_children(true):
 		if child is Viewport:
 			continue
 		var control: Control = child as Control
@@ -331,8 +333,8 @@ func _at(item: CanvasItem, point: Vector2, holder: Transform2D) -> Control:
 	var control: Control = item as Control
 	var local: Vector2 = matrix.affine_inverse() * point
 	if control == null or not control.is_clipping_contents() or _has_point(control, local):
-		for index: int in range(item.get_child_count() - 1, -1, -1):
-			var child: CanvasItem = item.get_child(index) as CanvasItem
+		for index: int in range(item.get_child_count(true) - 1, -1, -1):
+			var child: CanvasItem = item.get_child(index, true) as CanvasItem
 			if child == null or child.top_level:
 				continue
 			var found: Control = _at(child, point, matrix)

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

@@ -338,19 +338,23 @@ static func walk_to(node: Object, node_path: String, reaching: String) -> Dictio
 ##
 ## A colon path read from [param node], the node the call was made on, the way the method's own
 ## path is: "_ladder:shop:_wares:-15". One beginning with a slash starts at the node it names
-## instead, "/root/Main/Hud" or "/root/Main:_game:run". The record runtime_inspect answers an object
-## with is not accepted, because its id is a 64-bit number and does not survive being sent as JSON:
-## a rounded id names another object or none, and the path names the one meant.
+## instead, "/root/Main/Hud" or "/root/Main:_game:run". A res:// or uid:// path names a resource
+## file, which is loaded the way the game loads one, so a resource the game already holds is handed
+## over as that instance. The records a read answers a node and a filed resource with carry such a
+## path and are taken as it. The record runtime_inspect answers any other object with is not
+## accepted, because its id is a 64-bit number and does not survive being sent as JSON: a rounded id
+## names another object or none, and the path names the one meant.
 static func object_at(root: Node, node: Node, node_path: String, given: Variant) -> Dictionary:
+	var named: Variant = given
 	if given is Dictionary:
-		return {
-			"message":
-			(
-				"an object is named by its path, not by the record runtime_inspect answered with:"
-				+ " its id does not survive the trip as a number"
-			),
-		}
-	var path: String = given
+		var record: Dictionary = given
+		var tag: String = str(record.get("_type", ""))
+		if not (tag in ["Node", "Resource"] and record.get("path") is String):
+			return { "message": _no_path_in(record) }
+		named = record["path"]
+	var path: String = named
+	if path.begins_with("res://") or path.begins_with("uid://"):
+		return _resource_at(path)
 	var start: Node = node
 	var start_path: String = node_path
 	var reaching: String = path
@@ -382,6 +386,63 @@ static func object_at(root: Node, node: Node, node_path: String, given: Variant)
 	return { "object": value }
 
 
+## Why [param record], a dictionary given where an object goes, names none. A resource built into a
+## scene is read as its class beside its properties and has no path; the runtime builds no resource
+## from those, so the remedy is the file, not the path the other records are told to use.
+static func _no_path_in(record: Dictionary) -> String:
+	if record.has("id"):
+		return (
+			"an object is named by its path, not by the record runtime_inspect answered with:"
+			+ " its id does not survive the trip as a number"
+		)
+	var sort: String = str(record.get("_type", record.get("class", "")))
+	if sort.is_empty():
+		return (
+			"an object is named by its path, or a resource by the res:// path of its file, and a"
+			+ " dictionary names neither"
+		)
+	return (
+		(
+			"a resource is named by the res:// path of its file, and the %s given has none: a"
+			+ " resource built into a scene has no path, and the game builds none from its"
+			+ " properties"
+		)
+		% sort
+	)
+
+
+## The resource at [param path], a res:// or uid:// path, as `{"object": ...}`, or
+## `{"message": ...}` saying why there is none to hand over.
+static func _resource_at(path: String) -> Dictionary:
+	if path.contains("::"):
+		return {
+			"message":
+			(
+				"%s is a resource built into %s, and only that file can refer to it"
+				% [path, path.get_slice("::", 0)]
+			),
+		}
+	if not ResourceLoader.exists(path):
+		# An image or a sound nobody has imported is a file the engine has no loader for, and "No
+		# resource at" sent a caller looking for a file that was there.
+		if path.begins_with("res://") and FileAccess.file_exists(path):
+			return {
+				"message":
+				(
+					(
+						"%s is there, but it has never been imported, so the game has no resource "
+						+ "to load from it. project_import reimport with resourcePath %s imports it"
+					)
+					% [path, path]
+				),
+			}
+		return { "message": "No resource at %s" % path }
+	var loaded: Resource = load(path)
+	if loaded == null:
+		return { "message": "%s did not load; the game's output says why" % path }
+	return { "object": loaded }
+
+
 ## Whether a step can be taken into [param value] at all: an object, a list, a map or a value with
 ## components can be walked into, and a number or a string is where a path ends whether the caller
 ## meant it to or not.