gdharness 1.2.35 → 1.2.37

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

@@ -4,6 +4,7 @@ extends Node
 ## Resource files, shaders, tilesets and themes, written through the open editor.
 
 const FileReads = preload("../file_reads.gd")
+const HeadlessCheck = preload("../headless_check.gd")
 const PropertyValues = preload("../property_values.gd")
 const Read = preload("../reading.gd")
 const SceneFile = preload("../scene_file.gd")
@@ -118,9 +119,12 @@ func _load_theme(theme_path: String) -> Theme:
 ## Read back because a property can be set and still not be saved: one without storage, a
 ## script variable that is not exported. Both were answered as changed.
 func _save_checked(resource: Resource, path: String, names: Array, previous: Variant) -> String:
-	var saving: Error = ResourceSaver.save(resource, path)
+	var saving: Error = SceneFile.save_keeping_uid(resource, path)
 	if saving != OK:
 		return "Failed to save %s: %s" % [path, error_string(saving)]
+	var unkept: String = _unkept_headless(resource, path, names, previous)
+	if not unkept.is_empty():
+		return "Nothing was written: " + unkept + HeadlessCheck.put_back(path, previous)
 	var loaded: Resource = ResourceLoader.load(path, "", ResourceLoader.CACHE_MODE_IGNORE)
 	var lost: String = ""
 	if loaded == null:
@@ -141,14 +145,50 @@ func _save_checked(resource: Resource, path: String, names: Array, previous: Var
 	if lost.is_empty():
 		_written(path)
 		return ""
+	return lost + HeadlessCheck.put_back(path, previous)
+
+
+## Outside the editor, puts back in the file just saved at [param path] what a script that is not a
+## tool changed and the call did not ask for, [param names] being what it asked for, and answers ""
+## or why that did not hold. See [HeadlessCheck].
+func _unkept_headless(resource: Resource, path: String, names: Array, previous: Variant) -> String:
+	if Engine.is_editor_hint():
+		return ""
+	var script: Script = resource.get_script()
+	var scripted: bool = script != null and not script.is_tool()
+	if not path.ends_with(".tres"):
+		if scripted or HeadlessCheck.holds_scripted_embedded(resource, {}):
+			return (
+				(
+					(
+						"%s is a binary resource with a script that is not a tool, and what that script "
+						+ "changed when a headless engine loaded it cannot be told apart from the file here. "
+					)
+					% path
+				)
+				+ HeadlessCheck.REMEDY
+			)
+		return ""
+	var before: String = ""
 	if previous is PackedByteArray:
 		var bytes: PackedByteArray = previous
-		var file: FileAccess = FileAccess.open(path, FileAccess.WRITE)
-		if file == null or not file.store_buffer(bytes):
-			return lost + " Putting the file back as it was failed too."
-	elif DirAccess.remove_absolute(ProjectSettings.globalize_path(path)) != OK:
-		return lost + " Removing the file it wrote failed too."
-	return lost
+		before = bytes.get_string_from_utf8()
+	var asked: Dictionary = {"script": true}
+	var reached: Dictionary = {}
+	for key: Variant in names:
+		var property: String = str(key)
+		asked[property] = true
+		asked[property.get_slice(":", 0)] = true
+		reached.merge(HeadlessCheck.reached(resource, property))
+	return HeadlessCheck.settle_saved(
+		path,
+		before,
+		HeadlessCheck.stored(resource).values(),
+		resource if scripted else null,
+		asked,
+		reached,
+		func() -> Error: return SceneFile.save_keeping_uid(resource, path)
+	)
 
 
 func create_resource(args: Dictionary) -> Dictionary:
@@ -321,7 +361,7 @@ func create_tileset(args: Dictionary) -> Dictionary:
 	var folder: String = SceneFile.make_folder_for(tileset_path)
 	if not folder.is_empty():
 		return {"ok": false, "error": folder}
-	var saving: Error = ResourceSaver.save(tileset, tileset_path)
+	var saving: Error = SceneFile.save_keeping_uid(tileset, tileset_path)
 	if saving != OK:
 		return {"ok": false, "error": "Failed to save %s: %s" % [tileset_path, error_string(saving)]}
 
@@ -443,6 +483,7 @@ func set_tilemap_cells(args: Dictionary) -> Dictionary:
 	# reports placing tiles and a scene that shows none.
 	var tile_set: TileSet = layered.tile_set if layered != null else single.tile_set
 
+	scene.asked(node, ["layer_%d/tile_data" % layer if layered != null else "tile_map_data"])
 	var wanted: Array = []
 	for index: int in placed.size():
 		var cell: Array = _cell(placed[index], index, tile_set)
@@ -621,6 +662,19 @@ func _cell_at(node: Node, layer: int, at: Vector2i) -> Array:
 	return []
 
 
+## Saves [param theme] over [param theme_path] with [param item] changed, answering "" or why not.
+func _save_theme(theme: Theme, theme_path: String, item: String) -> String:
+	var previous: PackedByteArray = FileAccess.get_file_as_bytes(theme_path)
+	var saving: Error = SceneFile.save_keeping_uid(theme, theme_path)
+	if saving != OK:
+		return "Failed to save %s: %s" % [theme_path, error_string(saving)]
+	var unkept: String = _unkept_headless(theme, theme_path, [item], previous)
+	if not unkept.is_empty():
+		return "Nothing was written: " + unkept + HeadlessCheck.put_back(theme_path, previous)
+	_written(theme_path)
+	return ""
+
+
 func set_theme_color(args: Dictionary) -> Dictionary:
 	var theme_path: String = _ensure_res_path(str(args.get("themePath", "")))
 	if theme_path == "res://":
@@ -644,11 +698,9 @@ func set_theme_color(args: Dictionary) -> Dictionary:
 	)
 	theme.set_color(color_name, control_type, color)
 
-	var save_result: Error = ResourceSaver.save(theme, theme_path)
-	if save_result != OK:
-		return {"ok": false, "error": "Failed to save %s: %s" % [theme_path, error_string(save_result)]}
-
-	_written(theme_path)
+	var unsaved: String = _save_theme(theme, theme_path, "%s/colors/%s" % [control_type, color_name])
+	if not unsaved.is_empty():
+		return {"ok": false, "error": unsaved}
 
 	var saved: Theme = _load_theme(theme_path)
 	if saved == null or not saved.has_color(color_name, control_type):
@@ -680,11 +732,9 @@ func set_theme_font_size(args: Dictionary) -> Dictionary:
 
 	theme.set_font_size(font_size_name, control_type, Read.as_int(args.get("size", 0)))
 
-	var save_result: Error = ResourceSaver.save(theme, theme_path)
-	if save_result != OK:
-		return {"ok": false, "error": "Failed to save %s: %s" % [theme_path, error_string(save_result)]}
-
-	_written(theme_path)
+	var unsaved: String = _save_theme(theme, theme_path, "%s/font_sizes/%s" % [control_type, font_size_name])
+	if not unsaved.is_empty():
+		return {"ok": false, "error": unsaved}
 
 	var saved: Theme = _load_theme(theme_path)
 	if saved == null or not saved.has_font_size(font_size_name, control_type):

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

@@ -90,7 +90,7 @@ func _missing_on(node: Node, missing: String) -> String:
 	if probe.reload() == OK:
 		return missing
 	return (
-		"%s. Its script, %s, does not compile, so the editor knows none of what it declares."
+		"%s. Its script, %s, does not compile, so none of what it declares is known here."
 		% [missing, script.resource_path]
 	)
 
@@ -213,6 +213,10 @@ func create_scene(args: Dictionary) -> Dictionary:
 
 	var root: Node = ClassDB.instantiate(root_node_type)
 	root.name = root_node_name
+	var scene: SceneFile = SceneFile.new()
+	scene.root = root
+	scene.path = scene_path
+	scene.asked(root, ["script"])
 
 	if not script_path.is_empty():
 		var full_script_path: String = _to_scene_res_path(project_path, script_path)
@@ -238,9 +242,6 @@ func create_scene(args: Dictionary) -> Dictionary:
 	if not folder.is_empty():
 		root.free()
 		return {"ok": false, "error": folder}
-	var scene: SceneFile = SceneFile.new()
-	scene.root = root
-	scene.path = scene_path
 	var written: Dictionary = scene.write()
 	if not written.is_empty():
 		return written
@@ -307,6 +308,10 @@ func add_node(args: Dictionary) -> Dictionary:
 	parent.add_child(new_node)
 	Placing.place(new_node, place)
 	Placing.own(new_node, root)
+	var unsettled: String = scene.settle()
+	if not unsettled.is_empty():
+		return scene.refuse("Nothing was written: " + unsettled)
+	scene.asked(new_node, properties.keys())
 	var refused_property: String = _properties.write_all(new_node, properties)
 	if not refused_property.is_empty():
 		return scene.refuse(refused_property)
@@ -415,6 +420,7 @@ func duplicate_node(args: Dictionary) -> Dictionary:
 	target_parent.add_child(duplicated_node)
 	Placing.own(duplicated_node, root)
 	Placing.reconnect(copies, source)
+	scene.copied(copies)
 
 	var new_path: String = scene.path_of(duplicated_node)
 	var written: Dictionary = scene.write(
@@ -530,6 +536,7 @@ func set_node_properties(args: Dictionary) -> Dictionary:
 		if not unusable.is_empty():
 			return scene.refuse(unusable)
 
+	scene.asked(node, properties.keys())
 	var refused_property: String = _properties.write_all(node, properties)
 	if not refused_property.is_empty():
 		return scene.refuse(_missing_on(node, refused_property))
@@ -570,12 +577,10 @@ func get_node_properties(args: Dictionary) -> Dictionary:
 	var props: Dictionary = _properties_of(node, include_defaults, scene.set_here(node))
 	var cells: Dictionary = ResourceTools.cells_of(node)
 	scene.close()
-	var answer: Dictionary = {
-		"ok": true,
-		"nodePath": node_path,
-		"properties": props,
-		"unsavedInEditor": SceneFile.unsaved(scene_path)
-	}
+	var answer: Dictionary = {"ok": true, "nodePath": node_path, "properties": props}
+	# Only an editor holds anything unsaved; a headless engine answering false would say it looked.
+	if Engine.is_editor_hint():
+		answer["unsavedInEditor"] = SceneFile.unsaved(scene_path)
 	answer.merge(cells)
 	# An empty answer read as a node with nothing on it, rather than one with nothing changed.
 	if props.is_empty() and not include_defaults:
@@ -600,7 +605,10 @@ func save_scene(args: Dictionary) -> Dictionary:
 			return {"ok": false, "error": unsaved}
 
 	var open_root: Node = null
-	for open: Node in EditorInterface.get_open_scene_roots():
+	var open_roots: Array[Node] = []
+	if Engine.is_editor_hint():
+		open_roots = EditorInterface.get_open_scene_roots()
+	for open: Node in open_roots:
 		if open.scene_file_path == scene_path:
 			open_root = open
 	if open_root != null and target_path == scene_path:
@@ -618,7 +626,7 @@ func save_scene(args: Dictionary) -> Dictionary:
 		written = SceneFile.save_packed(packed, target_path)
 	else:
 		var scene: SceneFile = SceneFile.new()
-		var refused: Dictionary = scene.open(scene_path, false)
+		var refused: Dictionary = scene.open(scene_path, true)
 		if not refused.is_empty():
 			return refused
 		scene.path = target_path
@@ -897,4 +905,7 @@ func list_connections(args: Dictionary) -> Dictionary:
 				)
 
 	scene.close()
-	return {"ok": true, "connections": connections, "unsavedInEditor": SceneFile.unsaved(scene_path)}
+	var listed: Dictionary = {"ok": true, "connections": connections}
+	if Engine.is_editor_hint():
+		listed["unsavedInEditor"] = SceneFile.unsaved(scene_path)
+	return listed

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

@@ -12,8 +12,10 @@ const REFUSED: String = "Error calling method from 'callv': "
 
 ## The engine's reason for refusing the call, without [constant REFUSED], or "" when it ran.
 var refused: String = ""
-## What was reported while it ran, a line each, warnings marked as such.
+## The errors reported while it ran, a line each.
 var raised: Array[String] = []
+## The warnings reported while it ran, a line each.
+var warned: Array[String] = []
 
 
 func _log_message(_message: String, _error: bool) -> void:
@@ -39,4 +41,7 @@ func _log_error(
 	if function == "callv" and text.begins_with(REFUSED) and refused.is_empty():
 		refused = text.trim_prefix(REFUSED)
 		return
-	raised.append(("WARNING: " if error_type == ERROR_TYPE_WARNING else "") + text)
+	if error_type == ERROR_TYPE_WARNING:
+		warned.append(text)
+	else:
+		raised.append(text)

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

@@ -108,6 +108,9 @@ try {
     }
     $p = Patterned $element 'RangeValue'
     if ($p) {
+      # A reader speaks the Value pattern's words, such as "75%" for a slider whose game sets them,
+      # and the number would otherwise replace them.
+      if ($node.Contains('value') -and "$($node.value)") { $node.value_text = $node.value }
       $node.value = $p.Current.Value
       $node.range = @($p.Current.Minimum, $p.Current.Maximum)
       if (-not $p.Current.IsReadOnly) { $actions += 'set_value' }
@@ -389,17 +392,18 @@ static func _narrow(result: Dictionary, params: Dictionary) -> void:
 
 
 ## Whether [param element] is made by the node at [param under] or one below it, and says
-## [param said], each where asked: words as find matches them, in the element's name or value.
+## [param said], each where asked: words as find matches them, in the element's name, value or
+## value_text.
 static func _matches(element: Dictionary, under: String, said: String) -> bool:
 	if not under.is_empty():
 		var path: String = str(element.get("node", element.get("part_of", "")))
 		if path != under and not path.begins_with(under + "/"):
 			return false
 	if not said.is_empty():
-		var name: String = str(element.get("name", ""))
-		var value: String = str(element.get("value", ""))
-		if not Says.matches(name, said) and not Says.matches(value, said):
-			return false
+		for field: String in ["name", "value", "value_text"]:
+			if element.has(field) and Says.matches(str(element[field]), said):
+				return true
+		return false
 	return true
 
 

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

@@ -18,6 +18,7 @@ const InputCommands = preload("runtime_input.gd")
 const Pad = preload("runtime_pad.gd")
 const Queries = preload("runtime_queries.gd")
 const Read = preload("reading.gd")
+const Targets = preload("runtime_targets.gd")
 const Typing = preload("runtime_typing.gd")
 const Values = preload("runtime_values.gd")
 const Waits = preload("runtime_waits.gd")
@@ -153,6 +154,7 @@ func _init() -> void:
 		"choose": _typing.choose,
 		"wait_frames": _waits.wait_frames,
 		"wait_signal": _waits.wait_signal,
+		"watch_signal": _waits.watch_signal,
 		"wait_until": _waits.wait_until,
 		"send_profile": _send_profile_now,
 		"close_game": _close_game,
@@ -160,6 +162,36 @@ func _init() -> void:
 	_wait_for_the_profiler()
 
 
+## Gives a game with no window the size the project opens its window at. Measured: a
+## headless engine's root viewport is 64 by 64 whatever the project settings or --resolution say, so
+## a headless game laid its interface out in 64 pixels, and a button every windowed run shows was
+## refused as off screen. The root takes a size set once the autoloads are in the tree, before the
+## main scene enters it, and the scene lays out at it from its first frame. A size set at the
+## autoload's construction does not hold: the root is a 100 by 100 placeholder then, and the engine
+## gives it the 64 by 64 afterwards. A script run is not a game and keeps the viewport its own code
+## gives it, and a release build is left as the engine made it.
+func _size_a_windowless_game() -> void:
+	if DisplayServer.get_name() != "headless" or _script_run() or not OS.is_debug_build():
+		return
+	var root: Window = get_tree().root
+	if Vector2(root.size) != Targets.HEADLESS_VIEWPORT:
+		return
+	root.size = Vector2i(_window_dimension("width", 1152), _window_dimension("height", 648))
+
+
+## The window's [param axis] as the project opens it: the override when one is set, otherwise the
+## viewport's size, whose engine default is [param fallback].
+static func _window_dimension(axis: String, fallback: int) -> int:
+	var override: int = Read.as_int(
+		ProjectSettings.get_setting("display/window/size/window_%s_override" % axis, 0)
+	)
+	if override > 0:
+		return override
+	return Read.as_int(
+		ProjectSettings.get_setting("display/window/size/viewport_%s" % axis, fallback), fallback
+	)
+
+
 ## Holds the game's start until the profiler is on, when whatever started the game asked for a
 ## profile from its start. The debugger switches the profiler on with a message the game reads only
 ## on a poll, which comes every [constant POLLS_PER_READ] lines of script, so the main scene's _ready
@@ -197,6 +229,7 @@ func _ready() -> void:
 	# even be un-paused over the socket. A debug server has to stay responsive while the game
 	# is frozen, to inspect, capture, inject or resume it.
 	process_mode = Node.PROCESS_MODE_ALWAYS
+	_size_a_windowless_game()
 	var watched: int = get_tree().root.tree_exiting.connect(_send_the_profile)
 	if watched != OK:
 		push_error("gdharness could not watch for the game quitting: %d" % watched)

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

@@ -168,6 +168,12 @@ func _argument_for(
 				% [called, named, type_string(wants), index + 1, JSON.stringify(sent)]
 			)
 		}
+	var rounded: String = Values.inexact(sent, wants)
+	if not rounded.is_empty():
+		return {
+			"type": "error",
+			"message": "%s.%s takes int as argument %d: %s." % [called, named, index + 1, rounded]
+		}
 	var given: Variant = _values.fitted(sent, wants)
 	if not Values.acceptable(given, wants):
 		return {
@@ -242,6 +248,9 @@ func _value_for(
 				"message": "%s.%s holds an object: %s" % [called, named, named_object["message"]]
 			}
 		return {"value": named_object["object"]}
+	var rounded: String = Values.inexact(value, wanted)
+	if not rounded.is_empty():
+		return {"type": "error", "message": "%s.%s holds int: %s." % [called, named, rounded]}
 	var as_sent: Variant = _values.fitted(value, TYPE_NIL)
 	var cut: bool = Values.cuts(value, wanted)
 	var given: Variant = as_sent
@@ -441,16 +450,24 @@ func call_method(params: Dictionary) -> Dictionary:
 		"result": _values.serialize(result),
 		"elapsed_usec": elapsed
 	}
-	if not caught.raised.is_empty():
-		answer["errors"] = caught.raised.slice(0, ERRORS_KEPT)
-		if caught.raised.size() > ERRORS_KEPT:
-			answer["errors_not_shown"] = caught.raised.size() - ERRORS_KEPT
+	_keep_reported(answer, "errors", caught.raised)
+	_keep_reported(answer, "warnings", caught.warned)
 	var asked: Variant = params.get("properties")
 	if _reads_the_result(asked):
 		answer.merge(_read_off_result(result, asked))
 	return answer
 
 
+## Puts the first [constant ERRORS_KEPT] of [param reported] in [param answer] under [param field],
+## with how many more there were, when anything was reported.
+static func _keep_reported(answer: Dictionary, field: String, reported: Array[String]) -> void:
+	if reported.is_empty():
+		return
+	answer[field] = reported.slice(0, ERRORS_KEPT)
+	if reported.size() > ERRORS_KEPT:
+		answer[field + "_not_shown"] = reported.size() - ERRORS_KEPT
+
+
 ## Why [param named], the last step of a call's method, names no method of [param holder] to call, or
 ## "" when it does. Brackets on it holding arguments are refused rather than read: the arguments are
 ## taken from args alone, so a call is never made with half of them in one place and half in the

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

@@ -412,17 +412,19 @@ static func _outside_note(outside: int, root: Node) -> String:
 ## headless game's button twenty pixels in from the corner was refused as off screen, and the
 ## refusal read as though the button were not there.
 ##
-## The size is only claimed where it is true: the rect is printed beside this, so naming 64 by 64
-## over a viewport somebody has resized says two different things in one sentence.
+## The size named is the one in force, which the rect printed beside it agrees with. A game the
+## runtime started headless has the size the project opens its window at, and a window of that size
+## would not reach the control either, so only the engine's own 64 by 64 is answered with a window.
 static func no_window_note(viewport: Viewport, root: Window) -> String:
 	if viewport != root or root.can_draw():
 		return ""
-	if viewport.get_visible_rect().size == HEADLESS_VIEWPORT:
+	var size: Vector2 = viewport.get_visible_rect().size
+	if size == HEADLESS_VIEWPORT:
 		return (
 			". This game has no window, and a game with no window has a 64 by 64 viewport whatever "
 			+ "the project settings say: run it with a window to reach this control"
 		)
-	return ". This game has no window: run it with a window to reach this control"
+	return ". This game has no window, and its viewport is %d by %d" % [roundi(size.x), roundi(size.y)]
 
 
 ## What to add to a refusal that found nothing on screen, when the controls saying it are covered.
@@ -771,7 +773,7 @@ static func _where_it_lands(target: Control, point: Vector2) -> Dictionary[Scrol
 ## Whether a click could not reach [param target] however it scrolled: its centre, where the click
 ## would bring it, outside its viewport or the one showing that on the screen, or clipped away by a
 ## container the click does not scroll. A drawer parked off the side of the screen, or anything
-## outside the 64 by 64 viewport of a game with no window, was listed among the controls on screen.
+## outside the viewport of a game with no window, was listed among the controls on screen.
 static func _off_screen(target: Control) -> bool:
 	var moves: Dictionary[ScrollContainer, Vector2] = _scrolls_for(target)
 	var point: Vector2 = _centre_of(target) + _moved_by(target, moves)

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

@@ -156,6 +156,11 @@ static func cuts(given: Variant, type: int) -> bool:
 	return not (whole and (value == 0.0 or value == 1.0))
 
 
+## Why [param given] may not be the whole number sent, or "": see [method Serialisation.inexact].
+static func inexact(given: Variant, type: int) -> String:
+	return Serialisation.inexact(given, type)
+
+
 ## How a value of [param type] is written to be read as one, or empty when it is not built from fields.
 static func written_as(type: int) -> String:
 	return Serialisation.written_as(type)

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

@@ -26,8 +26,13 @@ const LOOKS_APART: int = 9
 ## two looks and a wait for 32 never sees it.
 const COMPARES: Array[String] = ["==", "!=", ">=", "<=", ">", "<"]
 
+## The most signal watches kept at once; arming one past this lets the oldest go.
+const MOST_WATCHES: int = 16
+
 var _host: Node
 var _values: Values
+var _watches: Dictionary[int, Watch] = {}
+var _next_watch: int = 1
 
 
 func _init(host: Node, values: Values) -> void:
@@ -56,13 +61,16 @@ func wait_frames(params: Dictionary) -> Dictionary:
 	return {"type": "waited", "frames": frames, "elapsed_ms": Time.get_ticks_msec() - started}
 
 
-## Waits for a signal to fire, and answers with what it carried, or that the time ran out.
+## Waits for a signal to fire, and answers with what it carried, or that the time ran out. Given a
+## watch, collects that instead: see [method watch_signal].
 func wait_signal(params: Dictionary) -> Dictionary:
 	var node_path: String = str(params.get("path", ""))
 	var signal_name: String = str(params.get("signal", ""))
 	var timeout_ms: int = Read.as_int(params.get("timeout_ms", 5000), 5000)
 	if timeout_ms < 1 or timeout_ms > CEILING_MSEC:
 		return _out_of_range("timeout_ms", timeout_ms, 1, CEILING_MSEC)
+	if params.has("watch"):
+		return await _collect(Read.as_int(params["watch"], 0), timeout_ms)
 	if node_path.is_empty() or signal_name.is_empty():
 		return {"type": "error", "message": "Node path and signal name required"}
 
@@ -84,7 +92,7 @@ func wait_signal(params: Dictionary) -> Dictionary:
 	if not catcher.fired and is_instance_valid(node) and node.is_connected(signal_name, callable):
 		node.disconnect(signal_name, callable)
 
-	return {
+	var answer: Dictionary = {
 		"type": "signal",
 		"path": node_path,
 		"signal": signal_name,
@@ -92,6 +100,90 @@ func wait_signal(params: Dictionary) -> Dictionary:
 		"args": _values.serialize(catcher.args),
 		"elapsed_ms": Time.get_ticks_msec() - started,
 	}
+	if not catcher.fired:
+		answer["note"] = (
+			"If a call meant to set the signal off was sent beside this wait, it may have run only after"
+			+ " the wait answered, as a client can run its calls in turn: arm runtime_wait watch first,"
+			+ " make the call, then wait with signal and that watch"
+		)
+	return answer
+
+
+## Starts recording a signal and answers at once with the watch to collect it by.
+##
+## A wait sent beside the call meant to set its signal off does not see it when the client runs the
+## two in turn: Claude Code ran a key press only after the signal wait beside it had answered, so the
+## wait ran out and the press landed after it. A watch is armed before the call and collected after.
+func watch_signal(params: Dictionary) -> Dictionary:
+	var node_path: String = str(params.get("path", ""))
+	var signal_name: String = str(params.get("signal", ""))
+	if node_path.is_empty() or signal_name.is_empty():
+		return {"type": "error", "message": "Node path and signal name required"}
+	var standing: Dictionary = Values.node_at(_host.get_tree().root, node_path)
+	if standing.has("message"):
+		return standing
+	var node: Node = standing["node"]
+	if not node.has_signal(signal_name):
+		return {"type": "error", "message": "%s has no signal %s" % [node_path, signal_name]}
+	var watch: Watch = Watch.new(node, node_path, signal_name)
+	var listening: Error = node.connect(signal_name, watch.catcher._on_fired)
+	if listening != OK:
+		return {"type": "error", "message": "Could not listen to signal: " + signal_name}
+	while _watches.size() >= MOST_WATCHES:
+		var oldest: int = _watches.keys().min()
+		_let_go(oldest)
+	var id: int = _next_watch
+	_next_watch += 1
+	_watches[id] = watch
+	return {"type": "watching", "watch": id, "path": node_path, "signal": signal_name}
+
+
+## Answers at once with the first emission recorded since watch [param id] was armed, otherwise
+## waits for the next until the time runs out. The watch goes either way.
+func _collect(id: int, timeout_ms: int) -> Dictionary:
+	if not _watches.has(id):
+		return {
+			"type": "error",
+			"message":
+			(
+				(
+					"No watch %d is armed in this game: it was collected already, %d armed after it let it"
+					+ " go, or the game started again since"
+				)
+				% [id, MOST_WATCHES]
+			),
+		}
+	var watch: Watch = _watches[id]
+	var started: int = Time.get_ticks_msec()
+	var before: bool = watch.catcher.fired
+	while not watch.catcher.fired and Time.get_ticks_msec() - started < timeout_ms:
+		await _host.get_tree().process_frame
+	_let_go(id)
+	var answer: Dictionary = {
+		"type": "signal",
+		"path": watch.node_path,
+		"signal": watch.signal_name,
+		"watch": id,
+		"fired": watch.catcher.fired,
+		"times": watch.catcher.times,
+		"args": _values.serialize(watch.catcher.args),
+		"elapsed_ms": Time.get_ticks_msec() - started,
+	}
+	if before:
+		answer["fired_before_wait"] = true
+	return answer
+
+
+func _let_go(id: int) -> void:
+	var watch: Watch = _watches.get(id)
+	var _gone: bool = _watches.erase(id)
+	if watch == null:
+		return
+	var held: Object = watch.node.get_ref()
+	var node: Node = held as Node
+	var callable: Callable = watch.catcher._on_fired
+	if node != null and node.is_connected(watch.signal_name, callable):
+		node.disconnect(watch.signal_name, callable)
 
 
 ## Waits until a property reads as the value given, or until something under the path says what
@@ -163,6 +255,9 @@ func wait_until(params: Dictionary) -> Dictionary:
 	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 rounded: String = Values.inexact(params["value"], typeof(current))
+	if refused.is_empty() and not rounded.is_empty():
+		refused = "%s.%s holds int: %s." % [node_path, property, rounded]
 	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 = (
@@ -492,8 +587,26 @@ func _anything_says(node_path: String, said: String, include_hidden: bool) -> bo
 class SignalCatcher:
 	extends RefCounted
 	var fired: bool = false
+	## How many times it fired; [member args] holds what the first carried.
+	var times: int = 0
 	var args: Array = []
 
 	func _on_fired(...carried: Array) -> void:
+		if not fired:
+			args = carried
 		fired = true
-		args = carried
+		times += 1
+
+
+## A signal recorded from when it was armed until it is collected.
+class Watch:
+	extends RefCounted
+	var node: WeakRef
+	var node_path: String
+	var signal_name: String
+	var catcher: SignalCatcher = SignalCatcher.new()
+
+	func _init(watched: Node, path: String, named: String) -> void:
+		node = weakref(watched)
+		node_path = path
+		signal_name = named