gdharness 1.1.22 → 1.1.23

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

@@ -98,12 +98,21 @@ var _tried_announced: bool = false
 var _told_about_url: String = ""
 var _connecting_for: float = 0.0
 
+## Whether this editor was started by another editor, which is Godot's own restart and the project
+## manager opening a project: the new editor is the old one's child and has its environment, with
+## the variable this addon sets as it loads still naming the old one. Its arguments are gone, since
+## the engine consumes `--lsp-port`, `--dap-port` and `--log-file` and hands none of them back, so the
+## ports and the marker a server put in that environment describe the editor before this one.
+var _started_by_an_editor: bool = false
+
 
 func _ready() -> void:
 	_project_path = ProjectSettings.globalize_path("res://")
 	version_at_load = _loaded_version()
 	digest_at_load = _loaded_digest()
 	_keep_breakpoints_through_sessions()
+	var inherited: String = OS.get_environment(EDITOR_PID_VARIABLE)
+	_started_by_an_editor = not inherited.is_empty() and inherited != str(OS.get_process_id())
 	OS.set_environment(EDITOR_PID_VARIABLE, str(OS.get_process_id()))
 
 	_reconnect_timer = Timer.new()
@@ -306,7 +315,8 @@ func _handle_connect() -> void:
 			# Whether a server started this editor, which is the only kind that can be started again
 			# as itself: the engine hands back none of the arguments it was given, so the arguments
 			# have to come from whoever wrote them. See `restart_editor` in play_tools.gd.
-			"opened_by_a_server": _opened_by_a_server()
+			"opened_by_a_server": _opened_by_a_server() and not _started_by_an_editor,
+			"started_by_an_editor": _started_by_an_editor
 		}
 	)
 
@@ -338,7 +348,7 @@ static func _opened_by_a_server() -> bool:
 ## collided with the editor it was moved away from. Restarting is done by starting the editor again
 ## with the same arguments now, which is `editor_launch restart`, so there is nothing to persist.
 func _serves(variable: String, setting: String) -> int:
-	var asked: int = _asked_for(variable)
+	var asked: int = 0 if _started_by_an_editor else _asked_for(variable)
 	return asked if asked > 0 else _serving(setting)
 
 

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

@@ -416,8 +416,14 @@ func _send_error(client: StreamPeerTCP, request_id: Variant, message: String) ->
 	_send_response(client, {"type": "error", "message": message, "id": request_id})
 
 
+## Down with the window only when the close is taken. A game that asks before quitting turns
+## auto_accept_quit off and decides for itself, and one whose player answered No went on running
+## with no runtime and no announcement, so every later call said no game was running. A quit it
+## does take ends the tree, which [method _exit_tree] cleans up after.
 func _notification(what: int) -> void:
-	if what == NOTIFICATION_WM_CLOSE_REQUEST:
+	if what != NOTIFICATION_WM_CLOSE_REQUEST:
+		return
+	if not is_inside_tree() or get_tree().auto_accept_quit:
 		_cleanup()
 
 

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

@@ -13,7 +13,7 @@ func _init(host: Node) -> void:
 
 
 func capture_screenshot(params: Dictionary) -> Dictionary:
-	return await _capture(_host.get_tree().root, params)
+	return await _capture(_host.get_tree().root, params, true)
 
 
 func capture_viewport(params: Dictionary) -> Dictionary:
@@ -28,11 +28,53 @@ func capture_viewport(params: Dictionary) -> Dictionary:
 	if not node is Viewport:
 		return {"type": "error", "message": "Node is not a Viewport: " + viewport_path}
 	var viewport: Viewport = node
-	return await _capture(viewport, params)
+	if not viewport is SubViewport:
+		return await _capture(viewport, params)
+	# Drawn now rather than taken as it stands. A SubViewport the game does not redraw every frame
+	# (disabled, a spent update-once, or update-when-visible behind a hidden container) keeps the
+	# last frame it drew, and that frame was answered as the viewport now. One update is asked for
+	# and the game's own mode put back after it.
+	var sub: SubViewport = viewport
+	var mode: SubViewport.UpdateMode = sub.render_target_update_mode
+	# Nothing is drawn without a window, so the frame waited for below may never come; the capture
+	# refuses that state itself.
+	if mode == SubViewport.UPDATE_ALWAYS or not _host.get_tree().root.can_draw():
+		return await _capture(viewport, params)
+	sub.render_target_update_mode = SubViewport.UPDATE_ONCE
+	await RenderingServer.frame_post_draw
+	var answer: Dictionary = await _capture(viewport, params)
+	sub.render_target_update_mode = mode
+	return answer
+
+
+## Lays the game's own windows that the root viewport does not draw over [param image], where
+## they sit on screen.
+##
+## With subwindows not embedded, a dialog or a menu's popup is a window of the operating system's
+## with a render target of its own, so a screenshot of the root viewport was the screen without the
+## dialog the game was showing. In tree order, so a window added later lies over an earlier one.
+func _lay_native_windows(image: Image) -> void:
+	var root: Window = _host.get_tree().root
+	if root.gui_embed_subwindows:
+		return
+	var pending: Array[Node] = [root]
+	while not pending.is_empty():
+		var node: Node = pending.pop_back()
+		var children: Array[Node] = node.get_children(true)
+		for index: int in range(children.size() - 1, -1, -1):
+			pending.append(children[index])
+		if node == root or not node is Window:
+			continue
+		var window: Window = node
+		if not window.visible or window.is_embedded():
+			continue
+		var drawn: Image = window.get_texture().get_image()
+		if drawn == null or drawn.is_empty():
+			continue
+		drawn.convert(image.get_format())
+		image.blend_rect(drawn, Rect2i(Vector2i.ZERO, drawn.get_size()), window.position - root.position)
 
 
-## The server names the file, so a game cannot point it at a path of its own choosing; a call
-## with no path is a call the server did not make.
 ## The size a capture drawn at [param drawn] is scaled to, from the width and height asked for, 0
 ## being not asked. One side alone keeps the picture's proportions, since that is what asking for a
 ## smaller picture means: it was ignored unless both came, so the full-size picture was sent back.
@@ -46,7 +88,9 @@ static func scaled_to(drawn: Vector2i, width: int, height: int) -> Vector2i:
 	return drawn
 
 
-func _capture(viewport: Viewport, params: Dictionary) -> Dictionary:
+## The server names the file, so a game cannot point it at a path of its own choosing; a call
+## with no path is a call the server did not make.
+func _capture(viewport: Viewport, params: Dictionary, with_windows: bool = false) -> Dictionary:
 	var requested_path: String = str(params.get("output_path", ""))
 	if requested_path.is_empty():
 		return {"type": "error", "message": "output_path required"}
@@ -80,6 +124,8 @@ func _capture(viewport: Viewport, params: Dictionary) -> Dictionary:
 	var image: Image = viewport_texture.get_image()
 	if image == null:
 		return {"type": "error", "message": "Failed to capture viewport image"}
+	if with_windows:
+		_lay_native_windows(image)
 
 	var drawn: Vector2i = Vector2i(image.get_width(), image.get_height())
 	var target: Vector2i = scaled_to(

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

@@ -132,7 +132,7 @@ func set_property(params: Dictionary) -> Dictionary:
 	#
 	# Judged by what reads back alone, so a value of another kind than the one held, which cannot be
 	# compared with it, is still caught when the engine drops it.
-	var already: bool = _held_already(given, old_value)
+	var already: bool = held_already(given, old_value)
 	var unmoved: bool = Values.comparable(now, old_value) and now == old_value
 	if unmoved and not already:
 		var why: String = (
@@ -187,7 +187,7 @@ func set_property(params: Dictionary) -> Dictionary:
 ## property whose setter ignored a value differing from the held one below 32 bits: it is answered
 ## unchanged rather than refused. Vectors and colours hold 32-bit parts in the value itself, so they
 ## already compare at the property's precision.
-static func _held_already(given: Variant, held: Variant) -> bool:
+static func held_already(given: Variant, held: Variant) -> bool:
 	if not Values.comparable(given, held):
 		return false
 	if given == held:

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

@@ -67,6 +67,9 @@ const PACKED: Array[int] = [
 ## The calls an empty list has nothing to answer, which the engine reports as an error when asked.
 const NEEDS_AN_ELEMENT: Array[String] = ["front", "back", "pick_random"]
 
+## Said after every call a path refuses for doing something rather than reading.
+const READS_ONLY: String = ", and a path, which a wait reads every frame, only calls methods that read"
+
 
 ## What [param reaching] names something on, which is the node itself until the name has a colon
 ## in it, and the last name along that path.
@@ -203,7 +206,7 @@ static func can_read(holder: Variant, named: String) -> bool:
 		var object: Object = holder
 		var method: String = method_of(named)
 		if not method.is_empty():
-			return _arguments_required(object, method) == 0
+			return call_refused(object, method, "").is_empty()
 		return _has_property(object, named)
 	return false
 
@@ -245,6 +248,62 @@ static func _arguments_required(object: Object, method: String) -> int:
 	return -1
 
 
+## Why a path may not call [param method] on [param object], said about [param called_as], or ""
+## when it may.
+##
+## A path is read, and a wait reads it every frame, so a call in one has to be a read. The engine
+## marks its own reading methods const and `queue_free()`, `free()` and `set_name()` not, measured on
+## 4.7.2. A game's methods carry no such mark, so one declared `-> void` is taken at its word, as
+## doing something and answering nothing, and one left untyped is trusted. Without this a find
+## with property "queue_free()" freed every node it matched, and a wait on "advance_day()" called
+## it once a frame and then reported the state it had driven the game to.
+static func call_refused(object: Object, method: String, called_as: String) -> String:
+	var required: int = _arguments_required(object, method)
+	if required == -1:
+		return "%s has no method %s" % [called_as, method]
+	if required > 0:
+		return (
+			"%s.%s takes %d argument%s, and a path can only call a method that takes none"
+			% [called_as, method, required, "" if required == 1 else "s"]
+		)
+	var scripted: Dictionary = _script_method(object, method)
+	if not scripted.is_empty():
+		var returned: Dictionary = scripted.get("return", {})
+		var usage: int = returned.get("usage", 0)
+		var type: int = returned.get("type", TYPE_NIL)
+		if type == TYPE_NIL and usage & PROPERTY_USAGE_NIL_IS_VARIANT == 0:
+			return (
+				"%s.%s is declared -> void, so it does something rather than answering%s"
+				% [called_as, method, READS_ONLY]
+			)
+		return ""
+	if _native_flags(object, method) & METHOD_FLAG_CONST == 0:
+		return "%s.%s changes what it is called on rather than reading it%s" % [called_as, method, READS_ONLY]
+	return ""
+
+
+## The entry a script attached to [param object] declares for [param method], or an empty one when
+## the method is the engine's.
+static func _script_method(object: Object, method: String) -> Dictionary:
+	var attached: Variant = object.get_script()
+	if not attached is Script:
+		return {}
+	var script: Script = attached
+	for entry: Dictionary in script.get_script_method_list():
+		if str(entry.get("name", "")) == method:
+			return entry
+	return {}
+
+
+## The flags the engine declares [param method] with on [param object].
+static func _native_flags(object: Object, method: String) -> int:
+	for entry: Dictionary in object.get_method_list():
+		if str(entry.get("name", "")) == method:
+			var flags: int = entry.get("flags", 0)
+			return flags
+	return 0
+
+
 ## Put [param value] where [param named] points. Only ever called once [method can_read] agrees,
 ## and lists and maps are reference types, so writing into one reaches the game's own copy.
 static func write(holder: Variant, named: String, value: Variant) -> void:
@@ -343,13 +402,7 @@ static func nothing_there(holder: Variant, named: String, called_as: String) ->
 	var object: Object = holder
 	var method: String = method_of(named)
 	if not method.is_empty():
-		var required: int = _arguments_required(object, method)
-		if required == -1:
-			return "%s has no method %s" % [called_as, method]
-		return (
-			"%s.%s takes %d argument%s, and a path can only call a method that takes none"
-			% [called_as, method, required, "" if required == 1 else "s"]
-		)
+		return call_refused(object, method, called_as)
 	# A method spelled as a property is the likeliest thing behind a name the object has no property
 	# for, and the caller is one pair of brackets away from what they meant.
 	if object.has_method(named):

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

@@ -14,7 +14,6 @@ const Words = preload("runtime_words.gd")
 ## The most nodes one find answers with, unless asked for fewer: enough for any real query and
 ## far short of the tree dump a query exists to avoid.
 const FIND_LIMIT: int = 100
-const FIND_LIMIT_CEILING: int = 1000
 
 ## What a find can be narrowed by, which is also what it refuses to answer without. Named once so
 ## the refusal lists the same set the walk reads.
@@ -24,6 +23,11 @@ const FILTERS: PackedStringArray = ["class", "script", "name", "group", "says"]
 ## thousand is a tree somebody pointed this at by mistake.
 const READ_LIMIT: int = 500
 
+## The most either can be asked for. A limit above it is refused rather than cut to it: the ceiling
+## was the default for a read, so the remedy its own answer gave, raising the limit, changed nothing
+## and said nothing, and a caller told to raise a number that stays put concludes the screen moved.
+const LIMIT_CEILING: int = 5000
+
 var _host: Node
 var _values: Values
 
@@ -88,7 +92,11 @@ func find_nodes(params: Dictionary) -> Dictionary:
 		wanted[filter] = str(params.get(filter, ""))
 	var wanted_property: String = str(params.get("property", ""))
 	var include_hidden: bool = Read.as_bool(params.get("include_hidden", true), true)
-	var limit: int = clampi(Read.as_int(params.get("limit", FIND_LIMIT), FIND_LIMIT), 1, FIND_LIMIT_CEILING)
+	var limit: int = Read.as_int(params.get("limit", FIND_LIMIT), FIND_LIMIT)
+	if limit < 1 or limit > LIMIT_CEILING:
+		return {
+			"type": "error", "message": "limit is from 1 to %d, and %d was asked for" % [LIMIT_CEILING, limit]
+		}
 
 	if not _anything_asked(wanted):
 		return {"type": "error", "message": "find_nodes needs at least one of " + ", ".join(FILTERS)}
@@ -116,6 +124,10 @@ func find_nodes(params: Dictionary) -> Dictionary:
 	for filter: String in wanted:
 		widened[filter] = widened_says if filter == "says" else wanted[filter]
 	var nearly_said: int = 0
+	# The near misses the same find would leave out as hidden, kept apart: the note says what a
+	# query would find, and counting these in it named a query that, asked, found none of them.
+	var nearly_hidden: int = 0
+	var nearly_said_hidden: int = 0
 	var hidden: int = 0
 	while not pending.is_empty():
 		var node: Node = pending.pop_front()
@@ -129,13 +141,19 @@ func find_nodes(params: Dictionary) -> Dictionary:
 			else:
 				found.append(_found(node, wanted_property))
 		elif rest and literal and str(node.name).containsn(wanted["name"]):
-			nearly += 1
+			if include_hidden or shown(node):
+				nearly += 1
+			else:
+				nearly_hidden += 1
 		elif (
 			not widened_says.is_empty()
 			and _named(node, wanted["name"])
 			and _matches_apart_from_name(node, widened)
 		):
-			nearly_said += 1
+			if include_hidden or shown(node):
+				nearly_said += 1
+			else:
+				nearly_said_hidden += 1
 		# Internal children included, which they were not. A ConfirmationDialog builds its Yes and
 		# its No as internal nodes, and a ScrollContainer its bars, so a find over a screen for
 		# every Button came back without the two buttons the player is being asked to press:
@@ -151,21 +169,39 @@ func find_nodes(params: Dictionary) -> Dictionary:
 	# Nothing found is the one answer that cannot be told apart from having asked the wrong
 	# question, and a name written without a wildcard is the way an agent writes "contains".
 	# Said only when it changes the answer, so a genuine nothing stays a plain nothing.
-	if found.is_empty() and nearly > 0:
-		var holding: String = "names contain" if nearly > 1 else "name contains"
-		notes.append(
-			(
-				'name is matched as a glob against the whole name; %d node %s "%s", which "*%s*" would find'
-				% [nearly, holding, wanted["name"], wanted["name"]]
+	if found.is_empty() and nearly + nearly_hidden > 0:
+		var named_near: int = nearly if nearly > 0 else nearly_hidden
+		var holding: String = "names contain" if named_near > 1 else "name contains"
+		(
+			notes
+			. append(
+				(
+					'name is matched as a glob against the whole name; %d %snode %s "%s", which "*%s*"%s would find'
+					% [
+						named_near,
+						"" if nearly > 0 else "hidden ",
+						holding,
+						wanted["name"],
+						wanted["name"],
+						"" if nearly > 0 else " with includeHidden true",
+					]
+				)
 			)
 		)
-	if found.is_empty() and nearly_said > 0:
+	if found.is_empty() and nearly_said + nearly_said_hidden > 0:
+		var said_near: int = nearly_said if nearly_said > 0 else nearly_said_hidden
 		(
 			notes
 			. append(
 				(
-					'says with a wildcard is matched as a glob against a node\'s whole text; "%s" would find %d node%s'
-					% [widened_says, nearly_said, "" if nearly_said == 1 else "s"]
+					'says with a wildcard is matched as a glob against a node\'s whole text; "%s"%s would find %d %snode%s'
+					% [
+						widened_says,
+						"" if nearly_said > 0 else " with includeHidden true",
+						said_near,
+						"" if nearly_said > 0 else "hidden ",
+						"" if said_near == 1 else "s",
+					]
 				)
 			)
 		)
@@ -184,17 +220,52 @@ func find_nodes(params: Dictionary) -> Dictionary:
 	return answer
 
 
-## Whether the player can see [param node], its ancestors counted.
+## Whether the player can see [param node], by the rule the engine draws by.
 ##
-## Not [method CanvasItem.is_visible_in_tree] on its own, because only the nodes that draw have it:
-## a plain Node sitting between a hidden panel and a label has no visibility to ask about, and the
-## label answers that it is visible while nothing of it is on screen. Walking up is what makes a
-## row hidden because the panel holding it is hidden, which is what somebody checking a screen is
-## asking about. A wait on words asks the same, so it reads this too.
+## A CanvasItem's visibility comes down through CanvasItem parents only, and one whose parent is not
+## a CanvasItem starts again from its canvas: measured on 4.7.2, a Label under a plain Node under a
+## hidden panel, and one under a hidden Node3D, both answer visible in tree, while one straight under
+## the panel does not. Walking every ancestor called those two hidden, so their words were left off
+## a screen that showed them and a wait on them ran out. What a CanvasItem's rule leaves out is its
+## canvas: a hidden layer hides everything drawn on it while each item keeps its own flag, and a
+## hidden window everything in it. A wait on words asks the same, so it reads this too.
 static func shown(node: Node) -> bool:
+	var item: CanvasItem = node as CanvasItem
+	if item != null:
+		return item.is_visible_in_tree() and _on_a_shown_canvas(item)
+	var spatial: Node3D = node as Node3D
+	if spatial != null:
+		return spatial.is_visible_in_tree() and _in_shown_windows(spatial)
+	var layer: CanvasLayer = node as CanvasLayer
+	if layer != null:
+		return layer.visible and _in_shown_windows(layer)
+	var window: Window = node as Window
+	if window != null:
+		return window.visible and _in_shown_windows(window.get_parent())
+	# A node that draws nothing is shown when what it sits in is.
+	var parent: Node = node.get_parent()
+	return parent == null or shown(parent)
+
+
+## Whether the canvas [param item] is drawn on is showing: its layer, and the windows around it.
+static func _on_a_shown_canvas(item: CanvasItem) -> bool:
+	var walk: Node = item.get_parent()
+	while walk != null:
+		var layer: CanvasLayer = walk as CanvasLayer
+		if layer != null:
+			return layer.visible and _in_shown_windows(layer)
+		if walk is Viewport:
+			return _in_shown_windows(walk)
+		walk = walk.get_parent()
+	return true
+
+
+## Whether every window [param node] sits in is showing, itself included when it is one.
+static func _in_shown_windows(node: Node) -> bool:
 	var walk: Node = node
 	while walk != null:
-		if not _drawn(walk):
+		var window: Window = walk as Window
+		if window != null and not window.visible:
 			return false
 		walk = walk.get_parent()
 	return true
@@ -304,7 +375,11 @@ static func _script_is(attached: Script, wanted: String) -> bool:
 func read_text(params: Dictionary) -> Dictionary:
 	var root_path: String = str(params.get("root", "/root"))
 	var include_hidden: bool = Read.as_bool(params.get("include_hidden", false))
-	var limit: int = clampi(Read.as_int(params.get("limit", READ_LIMIT), READ_LIMIT), 1, READ_LIMIT)
+	var limit: int = Read.as_int(params.get("limit", READ_LIMIT), READ_LIMIT)
+	if limit < 1 or limit > LIMIT_CEILING:
+		return {
+			"type": "error", "message": "limit is from 1 to %d, and %d was asked for" % [LIMIT_CEILING, limit]
+		}
 
 	var reached: Dictionary = Values.node_at(_host.get_tree().root, root_path)
 	if reached.has("message"):
@@ -338,41 +413,22 @@ func read_text(params: Dictionary) -> Dictionary:
 ## until it is opened, and reading a closed menu would put every item on the screen.
 ## Fills [param into] up to [param most] lines and answers with how many further lines the rest of
 ## the subtree says, which is what the caller is told rather than left to infer.
+##
+## Asked of each node rather than cut off at the first hidden one, since a hidden panel does not
+## hide a label reached through a plain Node: see [method shown].
 func _read_into(node: Node, include_hidden: bool, most: int, into: Array[String]) -> int:
-	if not include_hidden and not _drawn(node):
-		return 0
 	var left_out: int = 0
-	for said: String in Words.lines_said_by(node):
-		if into.size() < most:
-			into.append(said)
-		else:
-			left_out += 1
+	if include_hidden or shown(node):
+		for said: String in Words.lines_said_by(node):
+			if into.size() < most:
+				into.append(said)
+			else:
+				left_out += 1
 	for child: Node in node.get_children(true):
 		left_out += _read_into(child, include_hidden, most, into)
 	return left_out
 
 
-## Whether [param node] is on the screen at all, for the three kinds of thing that can be hidden.
-##
-## A Node3D among them because a hidden one draws nothing, Label3D included: reading a screen or
-## finding what is on it counted a hidden 3D subtree as showing, which is the one answer neither
-## question wants.
-static func _drawn(node: Node) -> bool:
-	var control: CanvasItem = node as CanvasItem
-	if control != null:
-		return control.visible
-	# A hidden layer hides everything drawn on it, a pause menu's for one, while each of those keeps
-	# its own visible flag, so read as shown it matched the words of a menu nobody could see.
-	var layer: CanvasLayer = node as CanvasLayer
-	if layer != null:
-		return layer.visible
-	var spatial: Node3D = node as Node3D
-	if spatial != null:
-		return spatial.visible
-	var window: Window = node as Window
-	return window == null or window.visible
-
-
 ## Where a node is on screen: a Control's rectangle, a Node2D's position, or the place a 3D node
 ## is drawn in, in both the canvas coordinates the node reports and the window pixels input
 ## arrives in. The two differ whenever the project stretches its viewport, which is what made a

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

@@ -69,7 +69,6 @@ func wait_signal(params: Dictionary) -> Dictionary:
 		return {"type": "error", "message": "%s has no signal %s" % [node_path, signal_name]}
 
 	var catcher: SignalCatcher = SignalCatcher.new()
-	catcher.arity = _signal_arity(node, signal_name)
 	var callable: Callable = catcher._on_fired
 	var listening: Error = node.connect(signal_name, callable, CONNECT_ONE_SHOT)
 	if listening != OK:
@@ -153,6 +152,8 @@ func wait_until(params: Dictionary) -> Dictionary:
 	if holds_objects and Changes.names_no_object(wanted):
 		wanted = null
 	var refused: String = _not_comparable(current, wanted, node_path, property)
+	if refused.is_empty():
+		refused = _cut_to_fit(params["value"], typeof(current), node_path, property)
 	var never_held: bool = typeof(wanted) != TYPE_NIL and typeof(wanted) != TYPE_OBJECT
 	if refused.is_empty() and declared == TYPE_OBJECT and never_held:
 		refused = (
@@ -169,9 +170,12 @@ func wait_until(params: Dictionary) -> Dictionary:
 	var frames: int = 0
 	# The type is checked every time round, not only at the top: a property that holds an object a
 	# frame later is the same error arriving late.
+	# At the precision the property keeps, as set compares: a float arrives as 64 bits and most
+	# engine properties keep 32, so h_offset waited on as -1.1 read -1.10000002384186 every frame and
+	# the wait ran out on a value the game had reached.
 	while (
 		Values.comparable(current, wanted)
-		and current != wanted
+		and not Changes.held_already(wanted, current)
 		and Time.get_ticks_msec() - started < timeout_ms
 	):
 		await _host.get_tree().process_frame
@@ -187,13 +191,42 @@ func wait_until(params: Dictionary) -> Dictionary:
 		"type": "condition",
 		"path": node_path,
 		"property": property,
-		"met": Values.comparable(current, wanted) and current == wanted,
+		"met": Changes.held_already(wanted, current),
 		"value": _values.serialize(current),
 		"elapsed_ms": Time.get_ticks_msec() - started,
 		"frames": frames,
 	}
 
 
+## Why [param given] would have to be cut to be waited on a whole number or a truth, or "" when not.
+##
+## A number arrives from JSON as a float, so one is converted to what the property holds, and the
+## conversion truncates: 3.5 waited on an int became 3 and 0.2 on a bool became true, and a property
+## already holding that answered met at once, about a state nobody asked for.
+static func _cut_to_fit(given: Variant, type: int, node_path: String, property: String) -> String:
+	if type != TYPE_INT and type != TYPE_BOOL:
+		return ""
+	var number: Variant = given
+	if given is String:
+		var text: String = given
+		number = Read.json_or_null(text)
+	if typeof(number) != TYPE_FLOAT and typeof(number) != TYPE_INT:
+		return ""
+	var value: float = Read.as_float(number)
+	var whole: bool = value == floorf(value)
+	if type == TYPE_INT and whole:
+		return ""
+	if type == TYPE_BOOL and whole and (value == 0.0 or value == 1.0):
+		return ""
+	return (
+		(
+			"%s.%s holds %s and the value to wait for is %s, which it would have to be cut to fit:"
+			+ " waiting on it would answer about a state nobody asked for."
+		)
+		% [node_path, property, type_string(type), str(given)]
+	)
+
+
 ## Why [param wanted] cannot be waited for against [param current], or "" when it can.
 ##
 ## Refused before anything is evaluated, because the evaluation is what does the damage: an object
@@ -342,26 +375,15 @@ func _anything_says(node_path: String, said: String, include_hidden: bool) -> bo
 	return false
 
 
-func _signal_arity(node: Node, signal_name: String) -> int:
-	for entry: Dictionary in node.get_signal_list():
-		if entry.get("name", "") == signal_name:
-			var declared: Array = entry.get("args", [])
-			return declared.size()
-	return 0
-
-
 ## Remembers that a signal fired and what it carried, for a wait that polls rather than
-## awaits the signal directly, so the wait can also give up. The handler accepts up to five
-## arguments, which covers every signal the engine declares, and records as many as the signal
-## has.
+## awaits the signal directly, so the wait can also give up. Takes any number of arguments: a
+## handler of five fixed ones covered the engine's signals, and a game's own signal with six was
+## never delivered to it, so the wait ran out and said the signal had not fired.
 class SignalCatcher:
 	extends RefCounted
 	var fired: bool = false
-	var arity: int = 0
 	var args: Array = []
 
-	func _on_fired(
-		a: Variant = null, b: Variant = null, c: Variant = null, d: Variant = null, e: Variant = null
-	) -> void:
+	func _on_fired(...carried: Array) -> void:
 		fired = true
-		args = [a, b, c, d, e].slice(0, mini(arity, 5))
+		args = carried