gdharness 1.3.4 → 1.3.5

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

@@ -85,6 +85,30 @@ static func engine_constants(target: Object, property: String) -> Dictionary:
 	return values
 
 
+## [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.
+##
+## An enum is written by the name of a value as well as its number, since the name is what the script
+## and the inspector show and the number is only where the value happens to sit. Tried as the script
+## spells it, then as the hint does, then as the engine's constant.
+static func enum_by_name(target: Object, declared: Dictionary, word: String, holder: String) -> Array:
+	var property: String = str(declared.get("name", ""))
+	var choices: Dictionary = enum_of(target, declared)
+	var chosen: Variant = enum_named(choices, word)
+	if chosen == null:
+		chosen = enum_named(enum_values(str(declared.get("hint_string", ""))), word)
+	var constants: Dictionary = {}
+	if chosen == null:
+		constants = engine_constants(target, property)
+		chosen = enum_named(constants, word)
+	if chosen != null:
+		return [true, chosen]
+	if word.strip_edges().is_valid_int():
+		return [false, ""]
+	return [false, enum_refusal(holder, property, word, choices, constants)]
+
+
 static func enum_refusal(
 	holder: String, property: String, word: String, choices: Dictionary, constants: Dictionary = {}
 ) -> String:

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

@@ -420,25 +420,12 @@ func value_for(target: Object, declared: Dictionary, raw: Variant) -> Array:
 	var hint: int = GdhRead.as_int(declared.get("hint", PROPERTY_HINT_NONE))
 	if expected_type == TYPE_OBJECT and hint == PROPERTY_HINT_NODE_TYPE:
 		return _node_reference(target, property, raw)
-	# An enum is written by the name of a value as well as its number, since the name is what the
-	# script and the inspector show and the number is only where the value happens to sit.
 	if expected_type == TYPE_INT and hint == PROPERTY_HINT_ENUM and typeof(raw) == TYPE_STRING:
-		var choices: Dictionary = GdhDeclared.enum_of(target, declared)
-		var chosen: Variant = GdhDeclared.enum_named(choices, str(raw))
-		if chosen == null:
-			var hinted: Dictionary = GdhDeclared.enum_values(str(declared.get("hint_string", "")))
-			chosen = GdhDeclared.enum_named(hinted, str(raw))
-		var constants: Dictionary = {}
-		if chosen == null:
-			constants = GdhDeclared.engine_constants(target, property)
-			chosen = GdhDeclared.enum_named(constants, str(raw))
-		if chosen != null:
-			return [true, chosen]
-		if not str(raw).strip_edges().is_valid_int():
-			var why: String = GdhDeclared.enum_refusal(
-				GdhPropertyPaths.class_called(target), property, str(raw), choices, constants
-			)
-			return [false, why]
+		var by_name: Array = GdhDeclared.enum_by_name(
+			target, declared, str(raw), GdhPropertyPaths.class_called(target)
+		)
+		if by_name[0] or not str(by_name[1]).is_empty():
+			return by_name
 
 	# A resource-valued property takes the path of one, which is how a caller names a TileSet,
 	# a material or a theme: there is no other way to hand a tool a Resource.

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

@@ -177,20 +177,28 @@ func _method_names(script: GDScript) -> Array[String]:
 	return names
 
 
-## The script's own constants, and the keys of each one that is a Dictionary as `Kind.SHORT`, which
-## is how the copy holds a named enum: a stale enum member is denied as a member of the enum rather
-## than of the class. A constant Dictionary that is not an enum is listed the same way, since the
-## map does not tell the two apart.
+## The script's constants, those of the scripts it extends included as its methods include theirs,
+## and the keys of each one that is a Dictionary as `Kind.SHORT`, which is how the copy holds a named
+## enum: a stale enum member is denied as a member of the enum rather than of the class. A constant
+## Dictionary that is not an enum is listed the same way, since the map does not tell the two apart.
+## The engine's map holds only the script's own, so a script extending a class_name listed every
+## method it inherited and none of the constants.
 func _constant_names(script: GDScript) -> Array[String]:
 	var names: Array[String] = []
-	var constants: Dictionary = script.get_script_constant_map()
-	for named: Variant in constants:
-		var value: Variant = constants[named]
-		names.append(str(named))
-		if value is Dictionary:
-			var values: Dictionary = value
-			for member: Variant in values:
-				names.append("%s.%s" % [named, member])
+	var holder: Script = script
+	while holder != null:
+		var constants: Dictionary = holder.get_script_constant_map()
+		for named: Variant in constants:
+			var value: Variant = constants[named]
+			if not names.has(str(named)):
+				names.append(str(named))
+			if value is Dictionary:
+				var values: Dictionary = value
+				for member: Variant in values:
+					var listed: String = "%s.%s" % [named, member]
+					if not names.has(listed):
+						names.append(listed)
+		holder = holder.get_base_script()
 	names.sort()
 	return names
 

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

@@ -0,0 +1,293 @@
+@tool
+extends RefCounted
+
+## What a property declares beyond its type: the values of its enum and the range it is exported
+## with, for taking a value by name and for saying when a value written lies outside them.
+
+const GdhRead = preload("reading.gd")
+
+
+## The values an enum hint names, by name, from its hint string: "SWORD:0,SHIELD:1" as a script
+## declares one, or "Add,Subtract" as an engine property does, each name then taking the number
+## after the one before it.
+static func enum_values(hint_string: String) -> Dictionary:
+	var values: Dictionary = {}
+	var next: int = 0
+	for entry: String in hint_string.split(",", false):
+		var name: String = entry.get_slice(":", 0).strip_edges()
+		var number: String = entry.get_slice(":", 1).strip_edges() if ":" in entry else ""
+		var value: int = number.to_int() if number.is_valid_int() else next
+		values[name] = value
+		next = value + 1
+	return values
+
+
+## The values of the enum [param declared] declares, by name, spelt as the script of [param target]
+## spells them when it declares that enum. The engine's hint capitalises each name, "SWORD" as
+## "Sword", and a refusal listing those named values the script never spells.
+static func enum_of(target: Object, declared: Dictionary) -> Dictionary:
+	var hinted: Dictionary = enum_values(str(declared.get("hint_string", "")))
+	var attached: Variant = target.get_script()
+	if not attached is Script:
+		return hinted
+	var script: Script = attached
+	for constant: Variant in script.get_script_constant_map().values():
+		if not constant is Dictionary:
+			continue
+		var values: Dictionary = constant
+		if values.size() != hinted.size():
+			continue
+		var spelt: Dictionary = {}
+		for name: Variant in values:
+			if hinted.get(str(name).capitalize()) == values[name]:
+				spelt[str(name)] = values[name]
+		if spelt.size() == hinted.size():
+			return spelt
+	return hinted
+
+
+## The number [param word] names among [param choices], matched as written and then ignoring case,
+## or null when it names none.
+static func enum_named(choices: Dictionary, word: String) -> Variant:
+	var wanted: String = word.strip_edges()
+	if choices.has(wanted):
+		return choices[wanted]
+	for name: String in choices:
+		if name.to_lower() == wanted.to_lower():
+			return choices[name]
+	return null
+
+
+## The values of the engine enum [param property] of [param target] holds, by the constants its
+## class declares them as: blend_mode's Add is BLEND_MODE_ADD in a script, and the hint gives only
+## the inspector's word. Empty for an enum a script declares.
+##
+## The enum is named by the setter's argument, as Node.ProcessMode, since the property list gives
+## an engine enum property no class of its own.
+static func engine_constants(target: Object, property: String) -> Dictionary:
+	var values: Dictionary = {}
+	var engine_class: String = target.get_class()
+	var setter: String = str(ClassDB.class_get_property_setter(engine_class, property))
+	if setter.is_empty():
+		return values
+	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
+	var holder: String = named.get_slice(".", 0)
+	if named.count(".") != 1 or not ClassDB.class_exists(holder):
+		return values
+	for constant: String in ClassDB.class_get_enum_constants(holder, named.get_slice(".", 1)):
+		values[constant] = ClassDB.class_get_integer_constant(holder, constant)
+	return values
+
+
+## [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.
+##
+## An enum is written by the name of a value as well as its number, since the name is what the script
+## and the inspector show and the number is only where the value happens to sit. Tried as the script
+## spells it, then as the hint does, then as the engine's constant.
+static func enum_by_name(target: Object, declared: Dictionary, word: String, holder: String) -> Array:
+	var property: String = str(declared.get("name", ""))
+	var choices: Dictionary = enum_of(target, declared)
+	var chosen: Variant = enum_named(choices, word)
+	if chosen == null:
+		chosen = enum_named(enum_values(str(declared.get("hint_string", ""))), word)
+	var constants: Dictionary = {}
+	if chosen == null:
+		constants = engine_constants(target, property)
+		chosen = enum_named(constants, word)
+	if chosen != null:
+		return [true, chosen]
+	if word.strip_edges().is_valid_int():
+		return [false, ""]
+	return [false, enum_refusal(holder, property, word, choices, constants)]
+
+
+static func enum_refusal(
+	holder: String, property: String, word: String, choices: Dictionary, constants: Dictionary = {}
+) -> String:
+	var ways: String = "by name or by number"
+	if not constants.is_empty():
+		ways = "by name, by number or by the engine's constant, such as %s" % str(constants.keys()[0])
+	var said: String = (
+		"%s.%s is an enum, and %s is none of its values: send %s %s"
+		% [holder, property, word, _listed(choices), ways]
+	)
+	var named: PackedStringArray = PackedStringArray(choices.keys())
+	named.append_array(PackedStringArray(constants.keys()))
+	var close: PackedStringArray = GdhRead.nearest(word, named)
+	if close.is_empty():
+		return said + "."
+	return said + ". The nearest %s %s." % ["is" if close.size() == 1 else "are", ", ".join(close)]
+
+
+## Why [param value], shown as [param shown], lies outside what [param declared] allows, an export
+## range or an enum's values, or "" when it does not. A range marked or_greater or or_less is open
+## on that side.
+static func outside(target: Object, declared: Dictionary, value: Variant, shown: String) -> String:
+	var hint: int = GdhRead.as_int(declared.get("hint", PROPERTY_HINT_NONE))
+	var hint_string: String = str(declared.get("hint_string", ""))
+	var property: String = str(declared.get("name", ""))
+	if hint == PROPERTY_HINT_ENUM and (typeof(value) == TYPE_STRING or typeof(value) == TYPE_STRING_NAME):
+		var names: PackedStringArray = PackedStringArray(enum_values(hint_string).keys())
+		if names.is_empty() or names.has(str(value)):
+			return ""
+		return (
+			(
+				"%s is none of the names %s lists: %s, which the inspector holds it to; the engine "
+				+ "stores it as given."
+			)
+			% [shown, property, ", ".join(names)]
+		)
+	if typeof(value) != TYPE_INT and typeof(value) != TYPE_FLOAT:
+		return ""
+	var number: float = GdhRead.as_float(value)
+	if hint == PROPERTY_HINT_ENUM and typeof(value) == TYPE_INT:
+		var choices: Dictionary = enum_of(target, declared)
+		if choices.is_empty() or choices.values().has(value):
+			return ""
+		return "%d is none of the values %s declares: %s." % [value, property, _listed(choices)]
+	if hint != PROPERTY_HINT_RANGE:
+		return ""
+	var parts: PackedStringArray = []
+	for part: String in hint_string.split(","):
+		var _added: bool = parts.append(part.strip_edges())
+	if parts.size() < 2 or not parts[0].is_valid_float() or not parts[1].is_valid_float():
+		return ""
+	var low: float = parts[0].to_float()
+	var high: float = parts[1].to_float()
+	if (number <= high or parts.has("or_greater")) and (number >= low or parts.has("or_less")):
+		return ""
+	return (
+		(
+			"%s is outside the range %s declares, %s to %s, which the inspector holds it to; the "
+			+ "engine stores it as given."
+		)
+		% [shown, property, _bound(low), _bound(high)]
+	)
+
+
+static func _listed(choices: Dictionary) -> String:
+	var listed: PackedStringArray = []
+	for name: String in choices:
+		var _added: bool = listed.append("%s (%d)" % [name, choices[name]])
+	return ", ".join(listed)
+
+
+## A range's end as the script wrote it: the engine's hint gives @export_range(0, 10) as 0.0 and 10.0.
+static func _bound(end: float) -> String:
+	return str(int(end)) if end == floorf(end) and absf(end) < 1e15 else str(end)
+
+
+## Puts back on [param built] what its script set as it was attached and was not among
+## [param wanted], to the defaults it declares, outside the editor. Attaching runs the script's _init
+## there, which the editor never runs for a script that is not a tool, so a resource_name _init chose
+## was saved as if asked for. A property whose default the engine cannot report is left as made.
+static func unmade(built: Resource, wanted: Dictionary) -> void:
+	var attached: Variant = built.get_script()
+	if Engine.is_editor_hint() or not attached is Script:
+		return
+	var script: Script = attached
+	var asked: Dictionary = {}
+	for key: Variant in wanted:
+		asked[str(key).get_slice(":", 0)] = true
+	for entry: Dictionary in built.get_property_list():
+		var name: String = str(entry["name"])
+		var usage: int = GdhRead.as_int(entry["usage"])
+		if usage & PROPERTY_USAGE_STORAGE == 0 or name == "script" or asked.has(name):
+			continue
+		var declared: Variant = ClassDB.class_get_property_default_value(built.get_class(), name)
+		if usage & PROPERTY_USAGE_SCRIPT_VARIABLE:
+			declared = script.get_property_default_value(name)
+		var held: Variant = built.get(name)
+		if declared != null and not (typeof(held) == typeof(declared) and held == declared):
+			built.set(name, declared)
+
+
+## The element types a typed Array or Dictionary property declares: [element] for an array,
+## [key, value] for a dictionary, [] when nothing is declared.
+##
+## Read from the declaration because the value cannot say: a script's exported `Array[int]` sits
+## behind a placeholder in the editor, and measured on 4.7.2 that placeholder stores [1.5, 2.0]
+## as given, which the game then fails to load into the typed array.
+static func elements_of(declared: Dictionary) -> Array:
+	var type: int = GdhRead.as_int(declared.get("type", TYPE_NIL), TYPE_NIL)
+	var hint: int = GdhRead.as_int(declared.get("hint", PROPERTY_HINT_NONE))
+	var wanted: String = str(declared.get("hint_string", ""))
+	if wanted.is_empty():
+		return []
+	if hint == PROPERTY_HINT_TYPE_STRING:
+		var parts: PackedStringArray = wanted.split(";")
+		if type == TYPE_ARRAY and parts.size() == 1:
+			return [_type_in_hint(parts[0])]
+		if type == TYPE_DICTIONARY and parts.size() == 2:
+			return [_type_in_hint(parts[0]), _type_in_hint(parts[1])]
+		return []
+	if hint == PROPERTY_HINT_ARRAY_TYPE and type == TYPE_ARRAY:
+		return [_type_named(wanted)]
+	if hint == PROPERTY_HINT_DICTIONARY_TYPE and type == TYPE_DICTIONARY:
+		var parts: PackedStringArray = wanted.split(";")
+		if parts.size() == 2:
+			return [_type_named(parts[0]), _type_named(parts[1])]
+	return []
+
+
+## The type at the front of one entry of a type-string hint, "2:" or "24/17:Texture2D".
+static func _type_in_hint(entry: String) -> int:
+	var number: String = entry.get_slice(":", 0).get_slice("/", 0)
+	return number.to_int() if number.is_valid_int() else TYPE_NIL
+
+
+## The Variant type [param name] names, or TYPE_OBJECT for a class.
+static func _type_named(name: String) -> int:
+	var named: String = name.get_slice(":", 0).strip_edges()
+	for type: int in TYPE_MAX:
+		if type_string(type) == named:
+			return type
+	return TYPE_OBJECT if not named.is_empty() else TYPE_NIL
+
+
+## The class the objects of a typed list or map hold, and whether they are nodes, as
+## [class, nodes], read from entry [param at] of [param declared]'s hint: "24/17:Item" in a type
+## string, "Item" in an array or dictionary type.
+static func object_kind(declared: Dictionary, at: int) -> Array:
+	var entry: String = str(declared.get("hint_string", "")).get_slice(";", at)
+	if GdhRead.as_int(declared.get("hint", PROPERTY_HINT_NONE)) != PROPERTY_HINT_TYPE_STRING:
+		return [entry.strip_edges(), false]
+	var nodes: bool = entry.get_slice(":", 0).get_slice("/", 1) == str(PROPERTY_HINT_NODE_TYPE)
+	return [entry.get_slice(":", 1), nodes]
+
+
+## The base class and script that type a list or map holding [param wanted], as [class, script],
+## or [] when nothing in the project or the engine is called that.
+static func object_typing(wanted: String) -> Array:
+	if ClassDB.class_exists(wanted):
+		return [StringName(wanted), null]
+	var script: Script = script_class(wanted)
+	return [] if script == null else [script.get_instance_base_type(), script]
+
+
+## The script declaring the class_name [param name], or null.
+static func script_class(name: String) -> Script:
+	for entry: Dictionary in ProjectSettings.get_global_class_list():
+		if str(entry.get("class", "")) == name:
+			return load(str(entry.get("path", ""))) as Script
+	return null
+
+
+## Whether [param value] is the class [param name] names, an engine class or a script's class_name.
+static func is_a(value: Object, name: String) -> bool:
+	if value.is_class(name):
+		return true
+	var script: Script = value.get_script()
+	while script != null:
+		if str(script.get_global_name()) == name:
+			return true
+		script = script.get_base_script()
+	return false

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

@@ -0,0 +1 @@
+uid://c2r5ain6am9gy

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

@@ -360,6 +360,10 @@ func _process(_delta: float) -> void:
 			break
 		_clients.append(client)
 		_send_welcome(client)
+		# Out before the request that came with it is read: a request can hold the game in a
+		# breakpoint before the frame's drain, and the server, never welcomed, took a game held
+		# inside its call for one that had not taken it. A client gone already is dropped below.
+		var _welcomed: bool = _drain(client)
 
 	var gone: Array[StreamPeerTCP] = []
 	for client: StreamPeerTCP in _clients:

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

@@ -5,6 +5,7 @@ extends RefCounted
 ## back what the engine did rather than trusting that it did it.
 
 const GdhCallErrors = preload("call_errors.gd")
+const GdhDeclared = preload("declared_values.gd")
 const GdhPaths = preload("runtime_paths.gd")
 const GdhRead = preload("reading.gd")
 const GdhValues = preload("runtime_values.gd")
@@ -146,6 +147,15 @@ func set_property(params: Dictionary) -> Dictionary:
 	}
 	if already and unmoved:
 		answer["unchanged"] = true
+	# The engine stores a number past an export range, or one no enum value has, as given; only the
+	# inspector holds a property to them, so the game now holds a value its own script never expected.
+	if holder is Object:
+		var owner: Object = holder
+		var shown: String = JSON.stringify(_values.serialize(now), "", false)
+		var declaration: Dictionary = slot["declared"]
+		var outside: String = GdhDeclared.outside(owner, declaration, now, shown)
+		if not outside.is_empty():
+			answer["outside_declared"] = outside
 	return answer
 
 
@@ -240,6 +250,15 @@ func _value_for(
 	var declared: int = slot["type"]
 	var declared_script: Script = slot["script"]
 	var wanted: int = declared if declared != TYPE_NIL else typeof(old_value)
+	var declaration: Dictionary = slot["declared"]
+	var enum_hint: bool = GdhRead.as_int(declaration.get("hint", PROPERTY_HINT_NONE)) == PROPERTY_HINT_ENUM
+	if declared == TYPE_INT and enum_hint and value is String and reached["holder"] is Object:
+		var owner: Object = reached["holder"]
+		var by_name: Array = GdhDeclared.enum_by_name(owner, declaration, str(value), called)
+		if by_name[0]:
+			return {"value": by_name[1]}
+		if not str(by_name[1]).is_empty():
+			return {"type": "error", "message": by_name[1]}
 	var holds_objects: bool = (
 		declared == TYPE_OBJECT or (declared == TYPE_NIL and (old_value == null or old_value is Object))
 	)
@@ -433,8 +452,15 @@ func call_method(params: Dictionary) -> Dictionary:
 	OS.add_logger(caught)
 	var began: int = Time.get_ticks_usec()
 	var result: Variant = holder.callv(named, deserialized_args)
-	var elapsed: int = Time.get_ticks_usec() - began
 	OS.remove_logger(caught)
+	# A method that awaits hands back its state at the first await and its value only when it ends,
+	# so the answer waits for the value; one that takes longer than the server waits is collected by
+	# its requestId like any slow call.
+	var state: Object = result if result is Object else null
+	var awaited: bool = state != null and state.get_class() == "GDScriptFunctionState"
+	if awaited:
+		result = await Signal(state, &"completed")
+	var elapsed: int = Time.get_ticks_usec() - began
 
 	if not caught.refused.is_empty():
 		var message: String = (
@@ -463,6 +489,8 @@ func call_method(params: Dictionary) -> Dictionary:
 		"result": _values.serialize(result),
 		"elapsed_usec": elapsed
 	}
+	if awaited:
+		answer["awaited"] = true
 	_keep_reported(answer, "errors", caught.raised)
 	_keep_reported(answer, "warnings", caught.warned)
 	var asked: Variant = params.get("properties")

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

@@ -190,12 +190,7 @@ func inject_key(params: Dictionary) -> Dictionary:
 	var keycode_raw: Variant = params.get("keycode", 0)
 	var held: bool = GdhRead.as_bool(params.get("pressed", true), true)
 	var whole: bool = not params.has("pressed")
-	var key_label: String = str(params.get("key_label", ""))
-
-	if keycode_raw is String:
-		var named: String = keycode_raw
-		if not named.is_empty() and key_label.is_empty():
-			key_label = named
+	var named: String = keycode_raw if keycode_raw is String else ""
 	var keycode: int = 0 if keycode_raw is String else GdhRead.as_int(keycode_raw)
 	var holding: Variant = GdhValues.held_for(params)
 	if holding is String:
@@ -205,14 +200,17 @@ func inject_key(params: Dictionary) -> Dictionary:
 	var event: InputEventKey = InputEventKey.new()
 	event.pressed = whole or held
 
-	if not key_label.is_empty():
-		event.keycode = OS.find_keycode_from_string(key_label)
+	if not named.is_empty():
+		event.keycode = OS.find_keycode_from_string(named)
 		if event.keycode == KEY_NONE:
-			return {"type": "error", "message": "Invalid key_label: " + key_label}
+			return {"type": "error", "message": GdhValues.unknown_key(named)}
 	elif keycode > 0:
 		event.keycode = keycode as Key
 	else:
-		return {"type": "error", "message": "keycode or key_label required"}
+		return {
+			"type": "error",
+			"message": 'keycode is required: a key name, such as "Space" or "A", or its Godot keycode.'
+		}
 
 	# A key event from a real keyboard carries all three, and InputMap consults whichever one
 	# the bound event declares: keycode first, then physical_keycode, then key_label. An
@@ -306,7 +304,8 @@ func inject_mouse_click(params: Dictionary) -> Dictionary:
 		Input.parse_input_event(_button(position, button, false, false))
 		await _host.get_tree().process_frame
 
-	return _pointer_noted(
+	var at: Array[Vector2] = [position]
+	var said: Dictionary = _pointer_noted(
 		_hover_noted(
 			{
 				"type": "input_injected",
@@ -322,6 +321,7 @@ func inject_mouse_click(params: Dictionary) -> Dictionary:
 			supplied
 		)
 	)
+	return GdhMouse.outside_noted(said, _host.get_viewport(), at)
 
 
 ## Moves the pointer to a position, with the movement the event carries taken from where the
@@ -346,7 +346,8 @@ func inject_mouse_motion(params: Dictionary) -> Dictionary:
 	var supplied: bool = _follow_in_the_window(position)
 	Input.parse_input_event(_motion(position, relative))
 
-	return _pointer_noted(
+	var at: Array[Vector2] = [position]
+	var said: Dictionary = _pointer_noted(
 		_hover_noted(
 			{
 				"type": "input_injected",
@@ -357,6 +358,7 @@ func inject_mouse_motion(params: Dictionary) -> Dictionary:
 			supplied
 		)
 	)
+	return GdhMouse.outside_noted(said, _host.get_viewport(), at)
 
 
 ## Drags with a mouse button from one point to another, through any points between, as a hand does:
@@ -406,7 +408,7 @@ func inject_mouse_drag(params: Dictionary) -> Dictionary:
 	Input.parse_input_event(_button(end, button, false, false))
 	await _host.get_tree().process_frame
 
-	return _pointer_noted(
+	var said: Dictionary = _pointer_noted(
 		_hover_noted(
 			{
 				"type": "input_injected",
@@ -420,6 +422,7 @@ func inject_mouse_drag(params: Dictionary) -> Dictionary:
 			supplied
 		)
 	)
+	return GdhMouse.outside_noted(said, _host.get_viewport(), points)
 
 
 ## Whether [param centre] is somewhere a click can reach it: inside the viewport, and inside every

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

@@ -65,6 +65,24 @@ static func mask_of(button: int) -> int:
 	return 1 << (button - 1)
 
 
+## [param answer], saying so when one of [param points] lies outside [param viewport]: the GUI picks
+## what is under the pointer only inside it, so such a press or motion reaches no control, and its
+## answer read the same as one that landed.
+static func outside_noted(answer: Dictionary, viewport: Viewport, points: Array[Vector2]) -> Dictionary:
+	var shown: Rect2 = viewport.get_visible_rect()
+	for point: Vector2 in points:
+		if not shown.has_point(point):
+			answer["outside_viewport"] = (
+				(
+					"%s is outside the window's viewport, %s, so no control there receives it; the game's"
+					% [point, shown]
+				)
+				+ " _input and _unhandled_input still do."
+			)
+			break
+	return answer
+
+
 ## What to say about a name that is not a mouse button, with the ones that are.
 static func no_such_button(named: Variant) -> Dictionary:
 	return {

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

@@ -156,6 +156,28 @@ static func glyph_of(keycode: Key, shifted: bool) -> int:
 	return keycode
 
 
+## The refusal for [param name], which no key is called, with the key names nearest it. Read from the
+## engine's own names, printable keys and the special ones above [constant KEY_SPECIAL], since the
+## game takes any name OS.find_keycode_from_string does.
+static func unknown_key(name: String) -> String:
+	var names: PackedStringArray = []
+	for code: int in range(32, 127) + range(KEY_SPECIAL + 1, KEY_SPECIAL + 0x100):
+		var spelled: String = OS.get_keycode_string(code as Key)
+		if not spelled.is_empty() and OS.find_keycode_from_string(spelled) == code:
+			var _named: bool = names.append(spelled)
+	var close: PackedStringArray = GdhRead.nearest(name, names)
+	var said: String = "No key is called %s." % name
+	if close.size() == 1:
+		said += " The nearest key name is %s." % close[0]
+	elif not close.is_empty():
+		said += " The nearest key names are %s." % ", ".join(close)
+	return (
+		said
+		+ ' A key is named as Godot names it, such as "Space", "Enter", "Escape", "A" or "F1",'
+		+ " or given by its keycode."
+	)
+
+
 ## What [param path] names: a node under [param root], as [method node_at] reads it, or an engine
 ## singleton by its name. Answers the object under "object", and under "node" the node that objects
 ## named in a value are found from, which for a singleton is [param root].
@@ -257,9 +279,11 @@ func parameter_class(object: Object, method: String, index: int) -> String:
 
 
 ## What the slot [param named] on [param holder] declares it holds, as `{"type": int, "class":
-## String, "script": Script or null}`: a property's declaration, or the element type of a typed list
-## or the value type of a typed map. TYPE_NIL when nothing is declared, which is also what a
-## property declared as Variant or left untyped reads as: either way it takes anything.
+## String, "script": Script or null, "declared": Dictionary}`: a property's declaration, or the
+## element type of a typed list or the value type of a typed map. TYPE_NIL when nothing is declared,
+## which is also what a property declared as Variant or left untyped reads as: either way it takes
+## anything. declared is the property's entry in the property list, which carries its enum or
+## range, and empty for anything that is not a property.
 ##
 ## Asked rather than read off the value in the slot, because an object slot can be empty: a
 ## property typed `Gear` holding null reads as TYPE_NIL, and anything written into it passed the
@@ -273,7 +297,7 @@ static func slot_declared(holder: Variant, named: String) -> Dictionary:
 	# form's an integer, a rectangle's size a vector of the same form.
 	if named in GdhSerialisation.components_of(holder):
 		var component: Variant = holder[named]
-		return {"type": typeof(component), "class": "", "script": null}
+		return {"type": typeof(component), "class": "", "script": null, "declared": {}}
 	if holder is Array:
 		var items: Array = holder
 		if items.is_typed():
@@ -281,6 +305,7 @@ static func slot_declared(holder: Variant, named: String) -> Dictionary:
 				"type": items.get_typed_builtin(),
 				"class": _typed_class(items.get_typed_script(), items.get_typed_class_name()),
 				"script": _script_or_null(items.get_typed_script()),
+				"declared": {},
 			}
 	elif holder is Dictionary:
 		var map: Dictionary = holder
@@ -289,6 +314,7 @@ static func slot_declared(holder: Variant, named: String) -> Dictionary:
 				"type": map.get_typed_value_builtin(),
 				"class": _typed_class(map.get_typed_value_script(), map.get_typed_value_class_name()),
 				"script": _script_or_null(map.get_typed_value_script()),
+				"declared": {},
 			}
 	elif holder is Object:
 		var object: Object = holder
@@ -298,8 +324,9 @@ static func slot_declared(holder: Variant, named: String) -> Dictionary:
 					"type": GdhRead.as_int(entry.get("type", TYPE_NIL), TYPE_NIL),
 					"class": str(entry.get("class_name", "")),
 					"script": null,
+					"declared": entry,
 				}
-	return {"type": TYPE_NIL, "class": "", "script": null}
+	return {"type": TYPE_NIL, "class": "", "script": null, "declared": {}}
 
 
 static func _script_or_null(typed: Variant) -> Script: