gdharness 1.3.48 → 1.3.49

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/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/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_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.

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

@@ -607,7 +607,7 @@ func get_rect(params: Dictionary) -> Dictionary:
 	if node is Control:
 		var control: Control = node
 		var canvas_rect: Rect2 = control.get_global_rect()
-		return {
+		var answer: Dictionary = {
 			"type": "rect",
 			"path": node_path,
 			"visible": control.is_visible_in_tree(),
@@ -621,6 +621,19 @@ func get_rect(params: Dictionary) -> Dictionary:
 				)
 			),
 		}
+		# Visible and in view read as clickable for a button under a dialog covering the screen,
+		# which a click by its words refused. Loaded here, since runtime_targets preloads this
+		# script.
+		if answer["visible"] and answer["in_view"]:
+			var own: Script = get_script()
+			var targets: GDScript = load(
+				own.resource_path.get_base_dir().path_join("runtime_targets.gd")
+			)
+			var over: Variant = targets.call("drawn_over", control)
+			if over is Node:
+				var cover: Node = over
+				answer["drawn_over"] = str(cover.get_path())
+		return answer
 	if node is Node2D:
 		var item: Node2D = node
 		var canvas_position: Vector2 = item.get_global_transform_with_canvas().origin

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

@@ -250,7 +250,7 @@ static func control_saying(
 			(
 				(
 					'no %s on screen%s says exactly "%s", so nothing was clicked: %s %s says it as '
-					+ 'part of "%s", while %s; pass index %d to press that one anyway'
+					+ 'part of "%s", while %s; pass index %d to press %s anyway'
 				)
 				% [
 					"button" if exact_elsewhere.size() > exact_out_of_reach.size() else "control",
@@ -261,6 +261,7 @@ static func control_saying(
 					_shortened(lines[index]),
 					_out_of_reach_exactly(exact_elsewhere, elsewhere_as),
 					index,
+					targets[index].get_path(),
 				]
 			),
 		}
@@ -272,7 +273,7 @@ static func control_saying(
 				(
 					'no control on screen%s says "%s" as a word of its own, so nothing was '
 					+ 'clicked: %s %s has it only inside a longer word, "%s"; pass index %d to '
-					+ "press that one anyway"
+					+ "press %s anyway"
 				)
 				% [
 					under,
@@ -281,6 +282,7 @@ static func control_saying(
 					targets[index].get_path(),
 					_shortened(lines[index]),
 					index,
+					targets[index].get_path(),
 				]
 			),
 		}
@@ -871,8 +873,8 @@ static func _where_it_lands(
 	var half: Vector2 = (drawn * Rect2(Vector2.ZERO, target.size)).size * 0.5
 	var moves: Dictionary[ScrollContainer, Vector2] = {}
 	var landed: Vector2 = point
-	var walk: Node = target.get_parent()
-	while walk != null and not (walk is Viewport):
+	var walk: CanvasItem = _drawn_inside(target)
+	while walk != null:
 		var holder: ScrollContainer = walk as ScrollContainer
 		if holder != null:
 			var shown: Rect2 = (
@@ -887,7 +889,7 @@ static func _where_it_lands(
 			if next != landed:
 				moves[holder] = next - landed
 			landed = next
-		walk = walk.get_parent()
+		walk = _drawn_inside(walk)
 	return moves
 
 
@@ -919,8 +921,8 @@ static func _off_screen(target: Control, aim: Vector2) -> bool:
 static func _clipped_away(
 	control: Control, point: Vector2, moves: Dictionary[ScrollContainer, Vector2]
 ) -> bool:
-	var walk: Node = control.get_parent()
-	while walk != null and not (walk is Viewport):
+	var walk: CanvasItem = _drawn_inside(control)
+	while walk != null:
 		var holder: Control = walk as Control
 		if (
 			holder != null
@@ -928,10 +930,21 @@ static func _clipped_away(
 			and not _holds(holder, point - _moved_by(holder, moves))
 		):
 			return true
-		walk = walk.get_parent()
+		walk = _drawn_inside(walk)
 	return false
 
 
+## The canvas item [param item] is drawn inside, which is what can clip it and what moves it, or
+## null where its drawing starts afresh: under a CanvasLayer, a viewport or a node that is not a
+## canvas item, or when it is top_level. A clipping Control above a CanvasLayer clips nothing on the
+## layer, and judged against one, every button of a reader drawn on a layer under a clipping desk
+## was refused as off the screen where it sat above the desk's top edge.
+static func _drawn_inside(item: CanvasItem) -> CanvasItem:
+	if item.top_level:
+		return null
+	return item.get_parent() as CanvasItem
+
+
 ## The canvas layer [param control] is drawn on, 0 for the viewport's own canvas.
 static func _layer_of(control: Control) -> int:
 	var layer: CanvasLayer = control.get_canvas_layer_node()

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

@@ -8,6 +8,7 @@ const GdhPaths = preload("runtime_paths.gd")
 const GdhQueries = preload("runtime_queries.gd")
 const GdhRead = preload("reading.gd")
 const GdhSays = preload("runtime_says.gd")
+const GdhShapes = preload("value_shapes.gd")
 const GdhValues = preload("runtime_values.gd")
 ## The longest one wait may last, whatever the request says: past this the server has long
 ## since given up on the reply.
@@ -490,7 +491,7 @@ func wait_until(params: Dictionary) -> Dictionary:
 				"%s.%s is declared to hold an object and the value to wait for is %s, which it can"
 				+ " never hold: wait for null, or for the object's own value on a property of it."
 			)
-			% [node_path, property, type_string(typeof(wanted))]
+			% [node_path, property, GdhShapes.kind(wanted)]
 		)
 	if not refused.is_empty():
 		return { "type": "error", "message": refused }
@@ -679,7 +680,7 @@ static func _not_comparable(
 	current: Variant, wanted: Variant, node_path: String, property: String
 ) -> String:
 	var types: Array[String] = [
-		node_path, property, type_string(typeof(current)), type_string(typeof(wanted)),
+		node_path, property, type_string(typeof(current)), GdhShapes.kind(wanted),
 	]
 	# A value that cannot become what the property holds is said as that, which names the remedy,
 	# before the comparison it would also fail; an object on either side is said as the comparison.

package/build/godot/addons/gdharness_runtime/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.
 ##