gdharness 1.3.3 → 1.3.5

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

@@ -17,9 +17,6 @@ const GdhScreen = preload("runtime_screen.gd")
 const GdhTargets = preload("runtime_targets.gd")
 const GdhMouse = preload("runtime_mouse.gd")
 
-## The distance from a capital letter to its small one in Unicode. A keycode holds the capital.
-const TO_SMALL: int = 32
-
 ## Set, to the desktop's name, for a process gdharness started on a desktop of its own and for
 ## everything that process starts. Kept in step with `DESKTOP_VARIABLE` in src/desktop.ts.
 const DESKTOP_VARIABLE: String = "GDHARNESS_DESKTOP"
@@ -161,10 +158,11 @@ func inject_action(params: Dictionary) -> Dictionary:
 	var frames: int = holding
 
 	_say_action(action, whole or held, strength)
+	var lasted: Variant = null
 	if whole:
 		# A frame between the halves at least, as a click has: a listener that acts on the press and
 		# a listener that acts on the release both get their own frame to do it in.
-		await _held(frames)
+		lasted = await GdhValues.hold(_host.get_tree(), frames)
 		_say_action(action, false, strength)
 		await _host.get_tree().process_frame
 
@@ -175,15 +173,10 @@ func inject_action(params: Dictionary) -> Dictionary:
 		"pressed": held and not whole,
 		"whole": whole,
 		"held_frames": GdhValues.held_answer(whole, frames),
+		"held_for": lasted,
 	}
 
 
-## Waits out [param frames] process frames, which is how long a whole press is held down.
-func _held(frames: int) -> void:
-	for _frame: int in frames:
-		await _host.get_tree().process_frame
-
-
 func _say_action(action: String, down: bool, strength: float) -> void:
 	var event: InputEventAction = InputEventAction.new()
 	event.action = action
@@ -197,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:
@@ -212,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
@@ -237,11 +228,12 @@ func inject_key(params: Dictionary) -> Dictionary:
 	# TextEdit insert `unicode` and never consult the keycode, so an injected key could press any
 	# action in the map and still type nothing into a search box. Godot's keycodes for printable
 	# keys are the code points themselves, which is what makes this a mapping and not a table.
-	event.unicode = _glyph_of(event.keycode, event.shift_pressed)
+	event.unicode = GdhValues.glyph_of(event.keycode, event.shift_pressed)
 
 	Input.parse_input_event(event)
+	var lasted: Variant = null
 	if whole:
-		await _held(frames)
+		lasted = await GdhValues.hold(_host.get_tree(), frames)
 		var up: InputEventKey = event.duplicate()
 		up.pressed = false
 		Input.parse_input_event(up)
@@ -251,6 +243,7 @@ func inject_key(params: Dictionary) -> Dictionary:
 		"type": "input_injected",
 		"input_type": "key",
 		"held_frames": GdhValues.held_answer(whole, frames),
+		"held_for": lasted,
 		"keycode": event.keycode,
 		"physical_keycode": event.physical_keycode,
 		"shift": event.shift_pressed,
@@ -262,19 +255,6 @@ func inject_key(params: Dictionary) -> Dictionary:
 	}
 
 
-## The character a key produces, or nothing for a key that produces none.
-##
-## Godot's keycodes below [constant KEY_SPECIAL] are the Unicode code points of the keys that
-## print something, so the mapping is the value itself. Letters are held as their capitals, which
-## is the one place the shift a caller asked for changes the answer rather than the key.
-func _glyph_of(keycode: Key, shifted: bool) -> int:
-	if keycode >= KEY_SPECIAL:
-		return 0
-	if keycode >= KEY_A and keycode <= KEY_Z and not shifted:
-		return keycode + TO_SMALL
-	return keycode
-
-
 ## Clicks a mouse button at a position, and lets go of it again unless asked to hold it.
 ##
 ## The whole click by default, for the reason [method inject_action] is the whole press, and
@@ -314,21 +294,24 @@ func inject_mouse_click(params: Dictionary) -> Dictionary:
 	var _moved: Vector2 = _arrive(position)
 	var supplied: bool = _follow_in_the_window(position)
 	Input.parse_input_event(_button(position, button, whole or held, double))
+	var lasted: Variant = null
 	if notch:
 		Input.parse_input_event(_button(position, button, false, false))
 	elif whole:
 		# A frame between the halves at least, as inject_action has, so a control that acts on the
 		# press and one that acts on the release each get a frame to do it in.
-		await _held(frames)
+		lasted = await GdhValues.hold(_host.get_tree(), frames)
 		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",
 				"input_type": "mouse_click",
 				"held_frames": GdhValues.held_answer(whole and not notch, frames),
+				"held_for": lasted,
 				"position": [position.x, position.y],
 				"button": button,
 				"pressed": held and not whole,
@@ -338,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
@@ -362,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",
@@ -373,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:
@@ -422,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",
@@ -436,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_pad.gd

@@ -69,11 +69,11 @@ func inject_joypad_button(params: Dictionary) -> Dictionary:
 	var frames: int = holding
 
 	Input.parse_input_event(_button(button, device, whole or held))
+	var lasted: Variant = null
 	if whole:
 		# A frame between the halves at least, as a key has, so a game that acts on the press and one
 		# that acts on the release each get a frame to do it in.
-		for _frame: int in frames:
-			await _host.get_tree().process_frame
+		lasted = await GdhValues.hold(_host.get_tree(), frames)
 		Input.parse_input_event(_button(button, device, false))
 		await _host.get_tree().process_frame
 
@@ -81,6 +81,7 @@ func inject_joypad_button(params: Dictionary) -> Dictionary:
 		"type": "input_injected",
 		"input_type": "joypad_button",
 		"held_frames": GdhValues.held_answer(whole, frames),
+		"held_for": lasted,
 		"button": button,
 		"button_name": _name_of(button, JOY_BUTTONS),
 		"device": device,

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

@@ -4,6 +4,7 @@ extends RefCounted
 ## run off the game the node keeps. Every op that reads, writes, calls or waits on a game's state
 ## walks the same way, so the walk and what it says when a step is not there live in one place.
 
+const GdhRead = preload("reading.gd")
 const GdhSerialisation = preload("serialisation.gd")
 const GdhValues = preload("runtime_values.gd")
 
@@ -640,7 +641,7 @@ static func nothing_there(holder: Variant, named: String, called_as: String) ->
 			"%s has no property %s; it has a method of that name, which a path calls as %s()"
 			% [called_as, named, named]
 		)
-	return "%s has no property %s" % [called_as, named]
+	return GdhRead.near_property("%s has no property %s" % [called_as, named], object, named)
 
 
 ## Why [param method] is not a call a path makes on [param sort] ("a list", "a packed list" or "a

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

@@ -126,6 +126,58 @@ static func held_answer(whole: bool, frames: int) -> Variant:
 	return null
 
 
+## Waits out [param frames] process frames of [param tree], how long a whole press is held down,
+## and answers how long that was by the clock and in physics ticks. A process frame is no set
+## time: a headless game draws nothing and runs them as fast as it can, so thirty held a movement
+## read in _physics_process for twelve ticks, a fifth of a second, where a caller counting sixty
+## frames a second expected half of one.
+static func hold(tree: SceneTree, frames: int) -> Dictionary:
+	var began_usec: int = Time.get_ticks_usec()
+	var began_tick: int = Engine.get_physics_frames()
+	for _frame: int in frames:
+		await tree.process_frame
+	return {
+		"seconds": snappedf((Time.get_ticks_usec() - began_usec) / 1000000.0, 0.001),
+		"physics_frames": Engine.get_physics_frames() - began_tick,
+	}
+
+
+## The character a key produces, or nothing for a key that produces none.
+##
+## Godot's keycodes below [constant KEY_SPECIAL] are the Unicode code points of the keys that
+## print something, so the mapping is the value itself. Letters are held as their capitals, which
+## is the one place the shift a caller asked for changes the answer rather than the key: the small
+## letter is 32 above its capital.
+static func glyph_of(keycode: Key, shifted: bool) -> int:
+	if keycode >= KEY_SPECIAL:
+		return 0
+	if keycode >= KEY_A and keycode <= KEY_Z and not shifted:
+		return keycode + 32
+	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].
@@ -227,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
@@ -243,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():
@@ -251,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
@@ -259,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
@@ -268,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:

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

@@ -4,6 +4,7 @@ extends RefCounted
 ## happened, or when the time ran out, so the caller never sleeps for a guessed length.
 
 const GdhChanges = preload("runtime_changes.gd")
+const GdhDeclared = preload("declared_values.gd")
 const GdhPaths = preload("runtime_paths.gd")
 const GdhQueries = preload("runtime_queries.gd")
 const GdhRead = preload("reading.gd")
@@ -51,6 +52,13 @@ static func _out_of_range(named: String, asked: int, least: int, most: int) -> D
 	}
 
 
+## The refusal for [param signal_name], which [param node] lacks, naming the nearest signals it has,
+## or every one when none is near: a name to send instead.
+static func _no_signal(node: Node, node_path: String, signal_name: String) -> Dictionary:
+	var said: String = "%s has no signal %s" % [node_path, signal_name]
+	return {"type": "error", "message": GdhRead.offered(said, signal_name, GdhRead.signals_of(node)) + "."}
+
+
 func wait_frames(params: Dictionary) -> Dictionary:
 	var frames: int = GdhRead.as_int(params.get("frames", 1), 1)
 	if frames < 1 or frames > MOST_FRAMES:
@@ -79,7 +87,7 @@ func wait_signal(params: Dictionary) -> Dictionary:
 		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]}
+		return _no_signal(node, node_path, signal_name)
 
 	var catcher: GdhSignalCatcher = GdhSignalCatcher.new()
 	var callable: Callable = catcher._on_fired
@@ -124,7 +132,7 @@ func watch_signal(params: Dictionary) -> Dictionary:
 		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]}
+		return _no_signal(node, node_path, signal_name)
 	var watch: GdhWatch = GdhWatch.new(node, node_path, signal_name)
 	var listening: Error = node.connect(signal_name, watch.catcher._on_fired)
 	if listening != OK:
@@ -240,7 +248,9 @@ func wait_until(params: Dictionary) -> Dictionary:
 	var current: Variant = watched["value"]
 	if compare in [">=", "<=", ">", "<"]:
 		return await _wait_in_order(node, params, current, timeout_ms)
-	var wanted: Variant = _values.fitted(params["value"], typeof(current))
+	var by_name: Array = _enum_by_name(watched, params["value"], node_path)
+	var sent: Variant = by_name[1] if not by_name.is_empty() and by_name[0] else params["value"]
+	var wanted: Variant = _values.fitted(sent, typeof(current))
 	# Read against what the property is declared as, not only against what it holds this frame: an
 	# object property holding null holds nothing typed, so any value was taken as it came and compared
 	# with null until the time ran out. #772 waited a minute for "null" that way and answered met
@@ -252,10 +262,13 @@ func wait_until(params: Dictionary) -> Dictionary:
 	var holds_objects: bool = declared == TYPE_OBJECT or untyped_object
 	if holds_objects and GdhChanges.names_no_object(wanted):
 		wanted = null
-	var refused: String = _not_comparable(current, wanted, node_path, property)
+	# A word no value of an enum is called, refused naming the values before it is compared as text.
+	var refused: String = "" if by_name.is_empty() or by_name[0] else str(by_name[1])
 	if refused.is_empty():
-		refused = _cut_to_fit(params["value"], typeof(current), node_path, property)
-	var rounded: String = GdhValues.inexact(params["value"], typeof(current))
+		refused = _not_comparable(current, wanted, node_path, property)
+	if refused.is_empty():
+		refused = _cut_to_fit(sent, typeof(current), node_path, property)
+	var rounded: String = GdhValues.inexact(sent, 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
@@ -469,6 +482,20 @@ static func _not_comparable(current: Variant, wanted: Variant, node_path: String
 	return ""
 
 
+## [param sent] as the number of the value an enum property names by it, as
+## [method GdhDeclared.enum_by_name] answers, for a word waited for on what [param watched] read; []
+## when the property is no enum or the value no word.
+static func _enum_by_name(watched: Dictionary, sent: Variant, node_path: String) -> Array:
+	var declaration: Dictionary = watched["declaration"]
+	var enum_hint: bool = GdhRead.as_int(declaration.get("hint", PROPERTY_HINT_NONE)) == PROPERTY_HINT_ENUM
+	if watched["declared"] != TYPE_INT or not enum_hint or not sent is String:
+		return []
+	if not watched["holder"] is Object:
+		return []
+	var owner: Object = watched["holder"]
+	return GdhDeclared.enum_by_name(owner, declaration, str(sent), node_path)
+
+
 ## What [param property] reads as on [param node] right now, under `value`, or a `message` saying
 ## why it cannot be read.
 ##
@@ -486,18 +513,24 @@ static func _watched(node: Node, node_path: String, property: String) -> Diction
 	var missing: String = GdhPaths.nothing_under(holder, named, str(reached["called"]))
 	if not missing.is_empty():
 		return {"type": "error", "message": missing}
-	return {"value": GdhPaths.read_under(holder, named), "declared": _declared_type(holder, named)}
+	var slot: Dictionary = _declared_slot(holder, named)
+	return {
+		"value": GdhPaths.read_under(holder, named),
+		"declared": slot["type"],
+		"declaration": slot["declared"],
+		"holder": holder,
+	}
 
 
-## The type [param named] is declared with on [param holder], read the way a set reads it, so the two
-## refuse the same values: a property's declaration, or a typed list's or map's element type. Read
-## off properties alone, an element of an Array[Node] holding null declares nothing, and a wait for 5
-## on it runs out the timeout while a set of 5 on it is refused at once. TYPE_NIL for anything
-## declaring none, and for a call, whose answer nothing declares.
-static func _declared_type(holder: Variant, named: String) -> int:
+## What [param named] is declared with on [param holder], as [method GdhValues.slot_declared] answers,
+## read the way a set reads it, so the two refuse the same values: a property's declaration, or a
+## typed list's or map's element type. Read off properties alone, an element of an Array[Node] holding
+## null declares nothing, and a wait for 5 on it runs out the timeout while a set of 5 on it is refused
+## at once. TYPE_NIL for anything declaring none, and for a call, whose answer nothing declares.
+static func _declared_slot(holder: Variant, named: String) -> Dictionary:
 	if not GdhPaths.method_of(named).is_empty():
-		return TYPE_NIL
-	return GdhValues.slot_declared(holder, named)["type"]
+		return {"type": TYPE_NIL, "class": "", "script": null, "declared": {}}
+	return GdhValues.slot_declared(holder, named)
 
 
 ## Waits until something under [param node_path] has [param said] written on it.

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

@@ -121,6 +121,10 @@ const BUILDERS: Dictionary = {
 	"Dictionary": "_build_dictionary",
 }
 
+## The built-in resources being described, outermost first, so one holding itself somewhere inside
+## is answered by its class rather than without end.
+var _describing: Array[Resource] = []
+
 
 # Converts a Godot value into something JSON can carry. A type with no entry in the table
 # passes through as itself, which is what the JSON-native ones want.
@@ -665,9 +669,21 @@ func _serialize_object(value: Object) -> Variant:
 		return _describe_input_event(event)
 	if value is Resource:
 		var resource: Resource = value
-		if resource.resource_path.is_empty():
-			return {"class": resource.get_class(), "_type": "Resource"}
-		return {"path": resource.resource_path, "class": resource.get_class(), "_type": "Resource"}
+		# A file's built-in resources load with a path of the file's own and "::", which no other
+		# file can refer to.
+		if resource.resource_path.is_empty() or resource.resource_path.contains("::"):
+			return _describe_built_in(resource)
+		var filed: Dictionary = {
+			"path": resource.resource_path, "class": resource.get_class(), "_type": "Resource"
+		}
+		# The engine class of a resource with a script is the one its script extends, so a Stats
+		# file read as a Resource and nothing said it was a Stats.
+		var attached: Variant = resource.get_script()
+		if attached is Script:
+			var script: Script = attached
+			if not script.get_global_name().is_empty():
+				filed["scriptClass"] = str(script.get_global_name())
+		return filed
 	if value is Node:
 		var node: Node = value
 		if node.is_inside_tree():
@@ -675,6 +691,62 @@ func _serialize_object(value: Object) -> Variant:
 	return _describe_object(value)
 
 
+## A resource built into the file it was read from, in the form a write builds one from: its class
+## under _type beside every property it stores away from its default. As its class alone it said
+## nothing of what it held, so a CollisionShape2D's radius could not be read, and it could not be
+## written back.
+func _describe_built_in(resource: Resource) -> Dictionary:
+	if _describing.has(resource):
+		return {"class": resource.get_class(), "_type": "Resource"}
+	_describing.append(resource)
+	var described: Dictionary = {"_type": resource.get_class()}
+	var attached: Variant = resource.get_script()
+	var script: Script = null
+	if attached is Script:
+		script = attached
+		described["script"] = serialize_value(script)
+	var fresh: Object = _fresh(script)
+	for property: Dictionary in resource.get_property_list():
+		var usage: int = property.get("usage", 0)
+		var name: String = str(property.get("name", ""))
+		if (
+			not (usage & PROPERTY_USAGE_STORAGE)
+			or name == "script"
+			or (name.begins_with("resource_") and name != "resource_name")
+		):
+			continue
+		var held: Variant = resource.get(name)
+		var default: Variant = ClassDB.class_get_property_default_value(resource.get_class(), name)
+		if fresh != null:
+			default = fresh.get(name)
+		elif script != null and usage & PROPERTY_USAGE_SCRIPT_VARIABLE:
+			default = script.get_property_default_value(name)
+		if typeof(held) == typeof(default) and held == default:
+			continue
+		described[name] = serialize_value(held)
+	_describing.pop_back()
+	return described
+
+
+## A new instance of [param script] to read defaults off, or null where none should be made. What
+## the script's own code sets as it is made (a resource_name in _init, a list built by a
+## constructor, which the engine reports no default for) is then a default rather than a value
+## the file holds. None is made for a script whose _init needs arguments, nor in the editor for one
+## that is not a tool: the editor never runs those, and can_instantiate says so.
+static func _fresh(script: Script) -> Object:
+	if script == null or not script.can_instantiate():
+		return null
+	for method: Dictionary in script.get_script_method_list():
+		if str(method.get("name", "")) == "_init":
+			var arguments: Array = method.get("args", [])
+			var defaults: Array = method.get("default_args", [])
+			if arguments.size() > defaults.size():
+				return null
+	# Called by name: new() is declared on each kind of script rather than on Script.
+	var made: Variant = script.call("new")
+	return made if made is Object else null
+
+
 ## An input event, by what it is bound to: the engine's own words for it and every field it stores
 ## away from its default. As a bare resource it was its class and nothing else, so an input action
 ## read back from project.godot could not say whether it was bound to Space or to a joypad button.