gdharness 1.3.47 → 1.3.49

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

@@ -61,9 +61,16 @@ func get_tree(params: Dictionary) -> Dictionary:
 		return reached
 	var root: Node = reached["node"]
 
+	# A game whose first scene hands over to another shows a tree that names neither, so which
+	# scene is showing was guessed from the project's documentation.
+	var scene: Node = _host.get_tree().current_scene
+	var showing: Variant = null
+	if scene != null:
+		showing = { "path": str(scene.get_path()), "file": scene.scene_file_path }
 	return {
 		"type": "tree",
 		"root": _serialize_node_tree(root, 0, max_depth, include_properties, named),
+		"current_scene": showing,
 	}
 
 
@@ -600,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(),
@@ -614,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/runtime_words.gd

@@ -163,7 +163,7 @@ static func pressable_words(from: Node, open: Callable, most: int) -> String:
 			if offered.size() == most:
 				return ", ".join(offered) + ", and more"
 			offered.append(quoted)
-		var children: Array[Node] = node.get_children()
+		var children: Array[Node] = node.get_children(true)
 		for index: int in range(children.size() - 1, -1, -1):
 			pending.push_front(children[index])
 	return ", ".join(offered)

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.
 ##

package/build/godot/operations/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/operations/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/operations/dependencies.gd

@@ -530,6 +530,20 @@ static func _comment_of(line: String) -> String:
 
 # How a line that names the resource by path uses it.
 func _path_reference_kind(line: String, file_path: String) -> String:
+	var placed: String = _placed_kind(line, file_path)
+	if not placed.is_empty():
+		return placed
+	var trimmed: String = GdhPatterns.without_annotations(line)
+	if "preload(" in trimmed:
+		return "preload"
+	if "load(" in trimmed:
+		return "load"
+	return "path"
+
+
+# The kind a reference on [param line] has by the file it is in or by how the line starts, or ""
+# when neither says.
+static func _placed_kind(line: String, file_path: String) -> String:
 	match file_path.get_file():
 		"project.godot":
 			return "setting"
@@ -546,11 +560,31 @@ func _path_reference_kind(line: String, file_path: String) -> String:
 		return "ext_resource"
 	if trimmed.begins_with("#include"):
 		return "include"
-	if "preload(" in trimmed:
+	return ""
+
+
+# The kind of the reference [param found] is in [param content], read from [param path], by the
+# call its path is handed to rather than by the line, which can name a second file another way: a
+# path only written in a string, which nothing in the file may load, read as a load.
+static func _forward_kind(content: String, found: RegExMatch, path: String) -> String:
+	var matched: String = found.get_string()
+	if matched.begins_with("preload("):
 		return "preload"
-	if "load(" in trimmed:
+	if matched.begins_with("load("):
 		return "load"
-	return "path"
+	var start: int = found.get_start()
+	var line_start: int = content.rfind("\n", start) + 1
+	var line_end: int = content.find("\n", start)
+	var line: String = content.substr(
+		line_start, (content.length() if line_end == -1 else line_end) - line_start
+	)
+	var before: String = content.substr(line_start, start - line_start).rstrip("\"'")
+	if before.ends_with("preload("):
+		return "preload"
+	if before.ends_with("load("):
+		return "load"
+	var placed: String = _placed_kind(line, path)
+	return "path" if placed.is_empty() else placed
 
 
 func _regex_escaped(text: String) -> String:
@@ -633,8 +667,14 @@ func _depend(dep_info: Dictionary, current_depth: int, walk: GdhDependencyWalk)
 	# tree answered that file as a dependency of itself.
 	if dep_path in walk.path_stack:
 		var cycle: Array[String] = walk.path_stack.slice(walk.path_stack.find(dep_path))
-		cycle.append(dep_path)
-		if not cycle in walk.circular_references:
+		# Kept by a key that is the same wherever the walk entered the cycle: compared as written,
+		# one cycle met from two of its files was listed twice, and comparing each against every
+		# cycle found so far grew with the square of their number, sixteen thousand on three
+		# hundred scripts typed by each other's class names.
+		var key: String = _cycle_key(cycle)
+		if not walk.cycles_seen.has(key):
+			walk.cycles_seen[key] = true
+			cycle.append(dep_path)
 			walk.circular_references.append(cycle)
 		dep_info["circular"] = true
 		return false
@@ -660,6 +700,16 @@ func _depend(dep_info: Dictionary, current_depth: int, walk: GdhDependencyWalk)
 	return walked["cut"]
 
 
+## [param cycle], the files of one cycle in the order the walk met them, turned to start at the
+## first of them in sorting order, so the cycle met from any of its files keys the same.
+static func _cycle_key(cycle: Array[String]) -> String:
+	var first: int = 0
+	for at: int in cycle.size():
+		if cycle[at] < cycle[first]:
+			first = at
+	return "\n".join(PackedStringArray(cycle.slice(first) + cycle.slice(0, first)))
+
+
 ## What [param path] names, each file once, as the entries the tree lists it by; read once a walk.
 func _references(path: String, walk: GdhDependencyWalk) -> Array[Dictionary]:
 	if walk.references.has(path):
@@ -688,12 +738,13 @@ func _references(path: String, walk: GdhDependencyWalk) -> Array[Dictionary]:
 			for m: RegExMatch in regex.search_all(content):
 				var written: String = _resolved(_referenced_path(m.get_string()), path)
 				var dep_path: String = str(moved.get(written, written))
+				var kind: String = _forward_kind(content, m, path)
 
 				# A uid the project does not know names no file, and loading it fails: passed over
 				# as no res:// path, a script's load of one went unsaid while the game printed
 				# "Unrecognized UID" at that line.
 				if dep_path.begins_with("uid://"):
-					_name(deps, path, dep_path, {})
+					_name(deps, path, dep_path, { "kind": kind })
 					continue
 				if not dep_path.begins_with("res://"):
 					continue
@@ -709,7 +760,9 @@ func _references(path: String, walk: GdhDependencyWalk) -> Array[Dictionary]:
 				if not walk.include_built_in and dep_path.begins_with("res://."):
 					continue
 
-				var named_by: Dictionary = { "stale_path": written } if dep_path != written else {}
+				var named_by: Dictionary = { "kind": kind }
+				if dep_path != written:
+					named_by["stale_path"] = written
 				if unknown.has(dep_path):
 					named_by["unknown_uid"] = unknown[dep_path]
 				_name(deps, path, dep_path, named_by)
@@ -730,8 +783,8 @@ func _references(path: String, walk: GdhDependencyWalk) -> Array[Dictionary]:
 
 # Adds [param dep_path] to [param deps], what [param path] depends on, once however many times it
 # is named. [param named_by] is the class or autoload name it was named by, as by_class or
-# by_autoload, and the path written when the engine loads another, as stale_path; empty for a path
-# that is the file.
+# by_autoload, or for a path its kind, with the path written when the engine loads another as
+# stale_path.
 func _name(deps: Array[Dictionary], path: String, dep_path: String, named_by: Dictionary) -> void:
 	if dep_path == path:
 		return
@@ -962,6 +1015,9 @@ class GdhDependencyWalk:
 
 	var circular_references: Array
 
+	## Each cycle in circular_references, by [method _cycle_key].
+	var cycles_seen: Dictionary[String, bool] = {}
+
 	func _init(p_max_depth: int, p_include_built_in: bool, p_circular_references: Array) -> void:
 		max_depth = p_max_depth
 		include_built_in = p_include_built_in

package/build/godot/operations/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/operations/import_pipeline.gd

@@ -212,7 +212,7 @@ func set_import_options(params: Dictionary) -> Dictionary:
 	var refused: Array[String] = []
 	for key: Variant in options:
 		var name: String = str(key)
-		var held: Variant = config.get_value("params", name, null)
+		var held: Variant = _held(config, name)
 		var given: Variant = _values.deserialize_value(options[key])
 		var value: Variant = _as_option(_values.fitted(options[key], typeof(held)), held)
 		if value is Dictionary:
@@ -248,7 +248,7 @@ func set_import_options(params: Dictionary) -> Dictionary:
 	var unchanged_keys: Array[String] = []
 	var changes: Dictionary = {}
 	for name: String in fitted_values:
-		var held: Variant = config.get_value("params", name, null)
+		var held: Variant = _held(config, name)
 		var value: Variant = fitted_values[name]
 		if held != null and typeof(held) == typeof(value) and held == value:
 			unchanged_keys.append(name)
@@ -275,6 +275,14 @@ func set_import_options(params: Dictionary) -> Dictionary:
 	return answer
 
 
+## What the option [param name] holds in [param config]'s params, or null when it holds none. Asked
+## with a default of null, the engine prints an error for a key the file does not have.
+static func _held(config: ConfigFile, name: String) -> Variant:
+	if not config.has_section_key("params", name):
+		return null
+	return config.get_value("params", name)
+
+
 ## [param given] as the option holds it. Every JSON number arrives as a float, and an enum option
 ## such as compress/mode written as 1.0 is kept that way by the import, so a whole number becomes
 ## an int unless the option already holds a float.

package/build/godot/operations/project_config.gd

@@ -413,6 +413,9 @@ func add_autoload(params: Dictionary) -> Dictionary:
 		return _log.failure(
 			GdhFileWalk.new().with_nearest_files("Autoload file does not exist: " + path, path)
 		)
+	var unloadable: String = _not_an_autoload(path)
+	if not unloadable.is_empty():
+		return _log.failure(unloadable)
 
 	# Through ProjectSettings so the file is saved the way the editor saves it, which includes
 	# putting Godot's header back and dropping any comment somebody wrote into the file by hand.
@@ -453,6 +456,38 @@ func add_autoload(params: Dictionary) -> Dictionary:
 	return answer
 
 
+## Why the file at [param path] cannot be an autoload, or empty when it can, as the editor's
+## Autoload
+## tab judges it: a scene, or a script whose instances are nodes. Written anyway, a script extending
+## RefCounted saved fine and every start of the game then failed to instantiate it. A script that
+## does not compile is let through, since it may be one being written, and its errors are its own.
+static func _not_an_autoload(path: String) -> String:
+	var refused: String = "%s is %s, and an autoload is a scene or a script extending Node"
+	if not ResourceLoader.exists(path):
+		return (refused + "; nothing was written.") % [path, "a file Godot does not load"]
+	var loaded: Resource = load(path)
+	if loaded is PackedScene:
+		return ""
+	if not loaded is Script:
+		var kind: String = "nothing Godot could load"
+		if loaded != null:
+			kind = "a " + loaded.get_class()
+		return (refused + "; nothing was written.") % [path, kind]
+	var script: Script = loaded
+	if not script.can_instantiate():
+		return ""
+	var base: StringName = script.get_instance_base_type()
+	if ClassDB.is_parent_class(base, "Node"):
+		return ""
+	return (
+		(
+			"%s extends %s, which is not a Node, and Godot instantiates an autoload under the root "
+			+ "as a node, so every start of the game would fail to load it; nothing was written."
+		)
+		% [path, base]
+	)
+
+
 ## Why [param name] cannot name an autoload, or empty when it can. The editor's Autoload tab refuses
 ## the same names: an autoload named after an engine class or a built-in type takes that name in
 ## every script, so an autoload called Input made every Input.is_action_pressed call the autoload.

package/build/godot/operations/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/operations/resource_files.gd

@@ -36,10 +36,9 @@ func get_uid(params: Dictionary) -> Dictionary:
 	var answer: Dictionary = { "file": file_path, "absolute_path": absolute_path }
 	var found: Dictionary = uid_of(file_path)
 	if found.is_empty():
-		answer["exists"] = false
+		answer["uid"] = null
 		answer["message"] = _why_none(file_path)
 		return answer
-	answer["exists"] = true
 	answer.merge(found)
 	return answer
 

package/build/godot/operations/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/tests/listed.gd

@@ -357,6 +357,9 @@ class GdhRunner:
 	var case_began: bool = false
 	## The suite running, which a case's own event does not carry.
 	var suite_running: String = ""
+	## Whether gdUnit4 has minimised the window, or is about to, and it is not back yet: it does as
+	## its runner starts, and after every suite.
+	var minimise_pending: bool = true
 
 	## As the run ends, the marker of the walk's newest end, and every script held past the walk, on
 	## an engine whose walk can stop part way ([GdhShutdownWalk]).
@@ -446,7 +449,11 @@ class GdhRunner:
 			GdUnitEvent.SESSION_START:
 				if not GdhIndexedSession.indexes_itself(_test_session):
 					_test_session = GdhIndexedSession.of(_test_session)
+				var tree: SceneTree = get_tree()
+				if not tree.process_frame.is_connected(drawn_window):
+					var _watched: int = tree.process_frame.connect(drawn_window)
 			GdUnitEvent.TESTSUITE_BEFORE:
+				drawn_window()
 				suite_running = event.resource_path()
 				orphans_at_suite = orphan_ids()
 				orphans_named.clear()
@@ -461,6 +468,9 @@ class GdhRunner:
 			GdUnitEvent.TESTCASE_AFTER:
 				cases_ended += 1
 		super(event)
+		# gdUnit4 minimises the window once the suite's end is reported.
+		if event.type() == GdUnitEvent.TESTSUITE_AFTER:
+			minimise_pending = true
 		# After gdUnit4's own report of the case, so the line falls under it.
 		if event.orphan_nodes() == 0:
 			return
@@ -478,6 +488,21 @@ class GdhRunner:
 				"after", left.filter(func(id: int) -> bool: return not orphans_from_before.has(id))
 			)
 
+	## The window back from minimised, which gdUnit4 makes it as its runner starts and after every
+	## suite, and where Godot draws nothing: a suite given a window to render in waited for a
+	## frame_post_draw that never came. Called as a suite begins, ahead of its before(), and every
+	## frame after, since on macOS the minimise is an animation that reads as windowed until it
+	## ends, and a window not yet minimised cannot be put back. Only once for each minimise of
+	## gdUnit4's, so a suite minimising the window itself keeps it minimised.
+	func drawn_window() -> void:
+		if not minimise_pending or DisplayServer.get_name() == "headless":
+			return
+		if Engine.is_embedded_in_editor():
+			return
+		if DisplayServer.window_get_mode() == DisplayServer.WINDOW_MODE_MINIMIZED:
+			DisplayServer.window_set_mode(DisplayServer.WINDOW_MODE_WINDOWED)
+			minimise_pending = false
+
 	## The orphans now that were not there in [param before] and no line has named yet.
 	func new_orphans(before: Dictionary[int, bool]) -> Array[int]:
 		var found: Array[int] = []