gdharness 1.2.28 → 1.2.30

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

@@ -32,15 +32,16 @@ func set_property(params: Dictionary) -> Dictionary:
 	if node_path.is_empty() or property.is_empty():
 		return {"type": "error", "message": "Node path and property required"}
 
-	var standing: Dictionary = Values.node_at(_host.get_tree().root, node_path)
+	var standing: Dictionary = Values.target_at(_host.get_tree().root, node_path)
 	if standing.has("message"):
 		return standing
 	var node: Node = standing["node"]
+	var target: Object = standing["object"]
 
 	# Through a path as well, for the reason [method Paths.walk_to] gives, and read back off the same
 	# holder afterwards: a set that does not take says so by answering with the old value, which is
 	# how a typed container refusing a write is told from one accepting it.
-	var reached: Dictionary = Paths.walk_to(node, node_path, property)
+	var reached: Dictionary = Paths.walk_to(target, node_path, property)
 	if reached.has("message"):
 		return reached
 
@@ -60,70 +61,35 @@ func set_property(params: Dictionary) -> Dictionary:
 	if not Paths.can_read(holder, named):
 		return {"type": "error", "message": Paths.nothing_there(holder, named, str(reached["called"]))}
 	var old_value: Variant = Paths.read_under(holder, named)
-	# The same rule the call path holds: a value that cannot become what the property holds is
-	# refused rather than written. Writing it means the engine picks something, and what it picks
-	# for a word where a number goes is zero, which the answer then reports as the new value.
-	#
-	# A slot declaring nothing, an untyped or Variant property or an element of an untyped list, takes
-	# anything, and the engine stores what it is given there. What it holds now still says how a value
-	# of the same kind is meant, 5 into an int staying an int, and whether a path names an object, but
-	# a value of another kind is stored as sent: a word into one holding a number is the word, and a
-	# number into one holding a word is the number, not its text. The text null empties it when it
-	# holds an object or nothing, as a wait reads it on the same slot.
 	var slot: Dictionary = Values.slot_declared(holder, named)
 	var declared: int = slot["type"]
 	var declared_script: Script = slot["script"]
-	var wanted: int = declared if declared != TYPE_NIL else typeof(old_value)
-	var holds_objects: bool = (
-		declared == TYPE_OBJECT or (declared == TYPE_NIL and (old_value == null or old_value is Object))
-	)
-	var given: Variant
-	if holds_objects and names_no_object(value):
-		given = null
-	elif wanted == TYPE_OBJECT and (value is String or value is Dictionary):
-		var named_object: Dictionary = _object_named(
-			node, node_path, value, str(slot["class"]), declared_script
-		)
-		if named_object.has("message"):
-			return {
-				"type": "error",
-				"message": "%s.%s holds an object: %s" % [reached["called"], named, named_object["message"]]
-			}
-		given = named_object["object"]
-	else:
-		var as_sent: Variant = _values.fitted(value, TYPE_NIL)
-		if declared == TYPE_NIL and not Values.acceptable(as_sent, wanted):
-			given = as_sent
-		else:
-			given = _values.fitted(value, wanted)
-			if not Values.acceptable(given, wanted):
-				return {
-					"type": "error",
-					"message":
-					(
-						"%s.%s holds %s and the value given is %s, which cannot become one.%s"
-						% [
-							reached["called"],
-							named,
-							type_string(wanted),
-							type_string(typeof(given)),
-							_written_as(wanted)
-						]
-					)
-				}
-		var typed: Dictionary = _values.typed_like(given, old_value, _element_object.bind(node, node_path))
-		if typed.has("message"):
-			return {
-				"type": "error",
-				"message":
-				"%s.%s is a typed %s: %s." % [reached["called"], named, _sort_of(old_value), typed["message"]]
-			}
-		given = typed["value"]
+	var fitting: Dictionary = _value_for(value, slot, old_value, reached, node, node_path)
+	if fitting.has("message"):
+		return fitting
+	var given: Variant = fitting["value"]
+	# A component of a vector or a transform is written into a copy, which is put back where it was
+	# read from, setter and all; the read back is then taken off the game again, since the copy here
+	# says only what was written into it.
+	var chain: Array[Dictionary] = reached["chain"]
+	var copied: bool = Paths.composite(holder)
+	if copied:
+		var unwritable: String = Paths.unwritable_copy(chain)
+		if not unwritable.is_empty():
+			return {"type": "error", "message": unwritable}
 	# The write alone, setter included, which is where a property's cost is.
 	var began: int = Time.get_ticks_usec()
-	Paths.write(holder, named, given)
+	var written: Variant = Paths.write(holder, named, given)
+	if copied:
+		Paths.write_back(chain, written)
 	var elapsed: int = Time.get_ticks_usec() - began
 	var now: Variant = Paths.read_under(holder, named)
+	if copied:
+		var again: Dictionary = Paths.walk_to(target, node_path, property)
+		if again.has("message"):
+			return again
+		var reread: Variant = again["holder"]
+		now = Paths.read_under(reread, named) if Paths.can_read(reread, named) else null
 	# Read back rather than trusted. The engine drops a write it will not take without a word, and
 	# the answer then showed the old value as the new one, shaped as a success: a typed container
 	# refusing a plain list did exactly that. A value the property changed on the way in, a setter
@@ -183,6 +149,131 @@ func set_property(params: Dictionary) -> Dictionary:
 	return answer
 
 
+## What [param sent] becomes as argument [param index] of the method [param named] on the holder
+## [param reached] ends at, as [method Paths.walk_to] answered it, as `{"value": ...}`, or the refusal
+## saying why it cannot become one: a number the parameter would have to cut, a value that cannot be
+## converted, or a list or map that cannot be built as the typed one the parameter takes.
+func _argument_for(
+	sent: Variant, index: int, reached: Dictionary, named: String, node: Node, node_path: String
+) -> Dictionary:
+	var holder: Object = reached["holder"]
+	var called: String = reached["called"]
+	var wants: int = _values.parameter_type(holder, named, index)
+	if Values.cuts(sent, wants):
+		return {
+			"type": "error",
+			"message":
+			(
+				"%s.%s takes %s as argument %d and was given %s, which it would have to be cut to fit"
+				% [called, named, type_string(wants), index + 1, JSON.stringify(sent)]
+			)
+		}
+	var given: Variant = _values.fitted(sent, wants)
+	if not Values.acceptable(given, wants):
+		return {
+			"type": "error",
+			"message":
+			(
+				"%s.%s takes %s as argument %d and was given %s, which cannot be converted.%s"
+				% [
+					called,
+					named,
+					type_string(wants),
+					index + 1,
+					type_string(typeof(given)),
+					_written_as(wants)
+				]
+			)
+		}
+	# A typed list or map is built as one, since a plain one handed to such a parameter raises
+	# inside the game, which is what every check here exists to stop.
+	var container: Variant = _values.parameter_container(holder, named, index)
+	if container == null:
+		return {"value": given}
+	var typed: Dictionary = _values.typed_like(given, container, _element_object.bind(node, node_path))
+	if typed.has("message"):
+		return {
+			"type": "error",
+			"message":
+			(
+				"%s.%s takes a typed %s as argument %d: %s."
+				% [called, named, _sort_of(container), index + 1, typed["message"]]
+			)
+		}
+	return {"value": typed["value"]}
+
+
+## What [param value] becomes written into the slot [param reached] ends on, as
+## [method Paths.walk_to] answered it, as `{"value": ...}`, or the refusal saying why it cannot become
+## one.
+##
+## The same rule the call path holds: a value that cannot become what the property holds is
+## refused rather than written. Writing it means the engine picks something, and what it picks
+## for a word where a number goes is zero, which the answer then reports as the new value. So is a
+## number a whole number or a truth would have to cut, since converting one truncates.
+##
+## A slot declaring nothing, an untyped or Variant property or an element of an untyped list, takes
+## anything, and the engine stores what it is given there. What it holds now still says how a value
+## of the same kind is meant, 5 into an int staying an int, and whether a path names an object, but
+## a value of another kind is stored as sent: a word into one holding a number is the word, a
+## fraction into one holding a whole number is the fraction, and a number into one holding a word is
+## the number, not its text. The text null empties it when it holds an object or nothing, as a wait
+## reads it on the same slot.
+func _value_for(
+	value: Variant, slot: Dictionary, old_value: Variant, reached: Dictionary, node: Node, node_path: String
+) -> Dictionary:
+	var named: String = reached["name"]
+	var called: String = reached["called"]
+	var declared: int = slot["type"]
+	var declared_script: Script = slot["script"]
+	var wanted: int = declared if declared != TYPE_NIL else typeof(old_value)
+	var holds_objects: bool = (
+		declared == TYPE_OBJECT or (declared == TYPE_NIL and (old_value == null or old_value is Object))
+	)
+	if holds_objects and names_no_object(value):
+		return {"value": null}
+	if wanted == TYPE_OBJECT and (value is String or value is Dictionary):
+		var named_object: Dictionary = _object_named(
+			node, node_path, value, str(slot["class"]), declared_script
+		)
+		if named_object.has("message"):
+			return {
+				"type": "error",
+				"message": "%s.%s holds an object: %s" % [called, named, named_object["message"]]
+			}
+		return {"value": named_object["object"]}
+	var as_sent: Variant = _values.fitted(value, TYPE_NIL)
+	var cut: bool = Values.cuts(value, wanted)
+	var given: Variant = as_sent
+	if declared != TYPE_NIL and cut:
+		return {
+			"type": "error",
+			"message":
+			(
+				"%s.%s holds %s and the value given is %s, which it would have to be cut to fit"
+				% [called, named, type_string(wanted), JSON.stringify(value)]
+			)
+		}
+	if declared != TYPE_NIL or (not cut and Values.acceptable(as_sent, wanted)):
+		given = _values.fitted(value, wanted)
+		if not Values.acceptable(given, wanted):
+			return {
+				"type": "error",
+				"message":
+				(
+					"%s.%s holds %s and the value given is %s, which cannot become one.%s"
+					% [called, named, type_string(wanted), type_string(typeof(given)), _written_as(wanted)]
+				)
+			}
+	var typed: Dictionary = _values.typed_like(given, old_value, _element_object.bind(node, node_path))
+	if typed.has("message"):
+		return {
+			"type": "error",
+			"message": "%s.%s is a typed %s: %s." % [called, named, _sort_of(old_value), typed["message"]]
+		}
+	return {"value": typed["value"]}
+
+
 ## Whether [param given] is the value [param held] already is, at the precision the property keeps.
 ##
 ## A float arrives as 64 bits and most engine properties keep 32: Camera3D.h_offset given -1.1
@@ -211,15 +302,16 @@ func call_method(params: Dictionary) -> Dictionary:
 	if node_path.is_empty() or method.is_empty():
 		return {"type": "error", "message": "Node path and method required"}
 
-	var standing: Dictionary = Values.node_at(_host.get_tree().root, node_path)
+	var standing: Dictionary = Values.target_at(_host.get_tree().root, node_path)
 	if standing.has("message"):
 		return standing
 	var node: Node = standing["node"]
+	var target: Object = standing["object"]
 
 	# Through a path as well, for the reason [method Paths.walk_to] gives. What a game does hangs off its
 	# nodes as much as its state does, so reading `_game:run:day` while being unable to call
 	# `_game:run:advance` answers half of what a node holds and refuses the other half.
-	var reached: Dictionary = Paths.walk_to(node, node_path, method)
+	var reached: Dictionary = Paths.walk_to(target, node_path, method)
 	if reached.has("message"):
 		return reached
 
@@ -235,6 +327,12 @@ func call_method(params: Dictionary) -> Dictionary:
 		var spelled: String = str(reached["name"])
 		if Paths.method_of(spelled).is_empty():
 			spelled += "()"
+		# A vector or a transform has no element to call a method on: it is read by its components.
+		if Paths.composite(reached["holder"]):
+			return {
+				"type": "error",
+				"message": Paths.nothing_there(reached["holder"], spelled, str(reached["called"]))
+			}
 		if args.is_empty() and Paths.can_read(reached["holder"], spelled):
 			var read_from: int = Time.get_ticks_usec()
 			var answered: Variant = Paths.read_under(reached["holder"], spelled)
@@ -301,41 +399,10 @@ func call_method(params: Dictionary) -> Dictionary:
 				by_engine_class[index + 1] = [declared, Values.class_of(resolved)]
 			deserialized_args.append(named_object["object"])
 			continue
-		var given: Variant = _values.fitted(args[index], wants)
-		if not Values.acceptable(given, wants):
-			return {
-				"type": "error",
-				"message":
-				(
-					"%s.%s takes %s as argument %d and was given %s, which cannot be converted.%s"
-					% [
-						reached["called"],
-						named,
-						type_string(wants),
-						index + 1,
-						type_string(typeof(given)),
-						_written_as(wants)
-					]
-				)
-			}
-		# A typed list or map is built as one, since a plain one handed to such a parameter raises
-		# inside the game, which is what every check here exists to stop.
-		var container: Variant = _values.parameter_container(holder, named, index)
-		if container != null:
-			var typed: Dictionary = _values.typed_like(
-				given, container, _element_object.bind(node, node_path)
-			)
-			if typed.has("message"):
-				return {
-					"type": "error",
-					"message":
-					(
-						"%s.%s takes a typed %s as argument %d: %s."
-						% [reached["called"], named, _sort_of(container), index + 1, typed["message"]]
-					)
-				}
-			given = typed["value"]
-		deserialized_args.append(given)
+		var argument: Dictionary = _argument_for(args[index], index, reached, named, node, node_path)
+		if argument.has("message"):
+			return argument
+		deserialized_args.append(argument["value"])
 
 	# Timed around the call alone, since the bridge's round trip is a second or more and swamps what
 	# one click's work costs; the frame metrics read whichever frame is last, which is not this one.
@@ -461,8 +528,11 @@ static func _walk_from(object: Object, path: String) -> Dictionary:
 	var holder: Variant = object
 	var called: String = "the result"
 	for named: String in Paths.steps_of(path):
-		if not (holder is Object or holder is Array or holder is Dictionary or Paths.packed(holder)):
-			return {"message": "%s holds no object to read %s off" % [called, named]}
+		if not Paths.can_hold(holder):
+			return {
+				"message":
+				"%s holds %s, which has nothing to read %s off" % [called, type_string(typeof(holder)), named]
+			}
 		if not Paths.can_read(holder, named):
 			return {"message": Paths.nothing_there(holder, named, called)}
 		holder = Paths.read_under(holder, named)

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

@@ -122,12 +122,16 @@ func inject_action(params: Dictionary) -> Dictionary:
 
 	if not InputMap.has_action(action):
 		return {"type": "error", "message": "Action not found: " + action}
+	var holding: Variant = Values.held_for(params)
+	if holding is String:
+		return {"type": "error", "message": holding}
+	var frames: int = holding
 
 	_say_action(action, whole or held, strength)
 	if whole:
-		# A frame between the halves, 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 _host.get_tree().process_frame
+		# 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)
 		_say_action(action, false, strength)
 		await _host.get_tree().process_frame
 
@@ -137,9 +141,16 @@ func inject_action(params: Dictionary) -> Dictionary:
 		"action": action,
 		"pressed": held and not whole,
 		"whole": whole,
+		"held_frames": Values.held_answer(whole, frames),
 	}
 
 
+## 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
@@ -160,6 +171,10 @@ func inject_key(params: Dictionary) -> Dictionary:
 		if not named.is_empty() and key_label.is_empty():
 			key_label = named
 	var keycode: int = 0 if keycode_raw is String else Read.as_int(keycode_raw)
+	var holding: Variant = Values.held_for(params)
+	if holding is String:
+		return {"type": "error", "message": holding}
+	var frames: int = holding
 
 	var event: InputEventKey = InputEventKey.new()
 	event.pressed = whole or held
@@ -193,7 +208,7 @@ func inject_key(params: Dictionary) -> Dictionary:
 
 	Input.parse_input_event(event)
 	if whole:
-		await _host.get_tree().process_frame
+		await _held(frames)
 		var up: InputEventKey = event.duplicate()
 		up.pressed = false
 		Input.parse_input_event(up)
@@ -202,6 +217,7 @@ func inject_key(params: Dictionary) -> Dictionary:
 	return {
 		"type": "input_injected",
 		"input_type": "key",
+		"held_frames": Values.held_answer(whole, frames),
 		"keycode": event.keycode,
 		"physical_keycode": event.physical_keycode,
 		"shift": event.shift_pressed,
@@ -266,6 +282,15 @@ func inject_mouse_click(params: Dictionary) -> Dictionary:
 	# than under the pointer, landing true and doing nothing, until a release was sent by hand.
 	var notch: bool = held and _mask_of(button) == 0
 	var whole: bool = notch or not params.has("pressed")
+	var holding: Variant = Values.held_for(params)
+	if holding is String:
+		return {"type": "error", "message": holding}
+	var frames: int = holding
+	if notch and params.has("holdFrames"):
+		return {
+			"type": "error",
+			"message": "A wheel step is pressed and let go at once, so holdFrames cannot hold one."
+		}
 
 	# A button pressed somewhere puts the pointer there: the motion after a held press measures
 	# its drag from the press, which is where a real pointer would be.
@@ -274,9 +299,9 @@ func inject_mouse_click(params: Dictionary) -> Dictionary:
 	if notch:
 		Input.parse_input_event(_button(position, button, false, false))
 	elif whole:
-		# A frame between the halves, 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 _host.get_tree().process_frame
+		# 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)
 		Input.parse_input_event(_button(position, button, false, false))
 		await _host.get_tree().process_frame
 
@@ -284,6 +309,7 @@ func inject_mouse_click(params: Dictionary) -> Dictionary:
 		{
 			"type": "input_injected",
 			"input_type": "mouse_click",
+			"held_frames": Values.held_answer(whole and not notch, frames),
 			"position": [position.x, position.y],
 			"button": button,
 			"pressed": held and not whole,

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

@@ -9,6 +9,7 @@ extends RefCounted
 ## calling the game's own methods. The engine still fires the actions bound to a button from these.
 
 const Read = preload("reading.gd")
+const Values = preload("runtime_values.gd")
 
 ## Controller buttons by the names Godot gives them, for a caller naming one rather than numbering it.
 const JOY_BUTTONS: Dictionary[String, int] = {
@@ -62,18 +63,24 @@ func inject_joypad_button(params: Dictionary) -> Dictionary:
 	var device: int = Read.as_int(params.get("device", 0), 0)
 	var held: bool = Read.as_bool(params.get("pressed", true), true)
 	var whole: bool = not params.has("pressed")
+	var holding: Variant = Values.held_for(params)
+	if holding is String:
+		return {"type": "error", "message": holding}
+	var frames: int = holding
 
 	Input.parse_input_event(_button(button, device, whole or held))
 	if whole:
-		# A frame between the halves, 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.
-		await _host.get_tree().process_frame
+		# 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
 		Input.parse_input_event(_button(button, device, false))
 		await _host.get_tree().process_frame
 
 	return {
 		"type": "input_injected",
 		"input_type": "joypad_button",
+		"held_frames": Values.held_answer(whole, frames),
 		"button": button,
 		"button_name": _name_of(button, JOY_BUTTONS),
 		"device": device,

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

@@ -93,23 +93,37 @@ const READS_ONLY: String = ", and a path, which a wait reads every frame, only c
 ## "get_theme_stylebox(\"panel\"):content_margin_top", since what a control's theme gives it is only
 ## reachable by naming what is asked for; see [method arguments_of].
 ##
+## A step into a vector, a colour, a rectangle or a transform reads one of its components,
+## "size:x" or "global_transform:origin:y", by the names GDScript gives them; see
+## [method Values.components_of].
+##
 ## Answers with a `message` instead when a step along the way is not there or holds something that
 ## is not an object, naming the step rather than the whole path: "/root/Main:_game has no property
-## clocks" is a typo found, and "no property _game:clocks:speed" is a puzzle.
-static func walk_to(node: Node, node_path: String, reaching: String) -> Dictionary:
+## clocks" is a typo found, and "no property _game:clocks:speed" is a puzzle. Answers `chain` as
+## well, each holder walked through and the step taken off it, for [method write_back].
+static func walk_to(node: Object, node_path: String, reaching: String) -> Dictionary:
 	var parts: PackedStringArray = steps_of(reaching)
 	var holder: Variant = node
 	var called: String = node_path
+	var chain: Array[Dictionary] = []
 	for step: int in parts.size() - 1:
 		var named: String = parts[step]
 		if not can_read(holder, named):
 			return {"type": "error", "message": nothing_there(holder, named, called)}
+		chain.append({"holder": holder, "named": named, "called": called})
 		holder = read_under(holder, named)
 		called = "%s:%s" % [called, named]
-		if not _can_hold(holder):
+		if not can_hold(holder):
 			var wanted: String = parts[step + 1]
-			return {"type": "error", "message": "%s holds no object to read %s off" % [called, wanted]}
-	return {"holder": holder, "name": parts[parts.size() - 1], "called": called}
+			return {
+				"type": "error",
+				"message":
+				(
+					"%s holds %s, which has nothing to read %s off"
+					% [called, type_string(typeof(holder)), wanted]
+				)
+			}
+	return {"holder": holder, "name": parts[parts.size() - 1], "called": called, "chain": chain}
 
 
 ## The object [param given] names for a method's argument, as `{"object": ...}`, or as
@@ -160,10 +174,17 @@ static func object_at(root: Node, node: Node, node_path: String, given: Variant)
 	return {"object": value}
 
 
-## Whether a step can be taken into [param value] at all: an object, a list or a map can be walked
-## into, and a number or a string is where a path ends whether the caller meant it to or not.
-static func _can_hold(value: Variant) -> bool:
-	return value is Object or value is Array or value is Dictionary or packed(value)
+## Whether a step can be taken into [param value] at all: an object, a list, a map or a value with
+## components can be walked into, and a number or a string is where a path ends whether the caller
+## meant it to or not.
+static func can_hold(value: Variant) -> bool:
+	return value is Object or value is Array or value is Dictionary or packed(value) or composite(value)
+
+
+## Whether [param value] is read by its components, a vector or a colour or a transform, and is a
+## copy wherever it is read from.
+static func composite(value: Variant) -> bool:
+	return not Values.components_of(value).is_empty()
 
 
 ## Whether [param value] is a packed list. Stepped into the way a list is, by index, and a write into
@@ -212,6 +233,8 @@ static func can_read(holder: Variant, named: String) -> bool:
 		if not method.is_empty():
 			return args.is_empty() and method in MAP_CALLS
 		return not _key_in(map, named).is_empty()
+	if composite(holder):
+		return method.is_empty() and named in Values.components_of(holder)
 	if holder is Object:
 		var object: Object = holder
 		if not method.is_empty():
@@ -420,25 +443,62 @@ static func _native_flags(object: Object, method: String) -> int:
 	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:
+## Put [param value] where [param named] points, and answer the holder written into. Only ever
+## called once [method can_read] agrees. Lists and maps are reference types, so writing into one
+## reaches the game's own copy; a vector or a transform is a copy, and the one answered is the
+## changed copy, for [method write_back] to put where it came from.
+static func write(holder: Variant, named: String, value: Variant) -> Variant:
 	if holder is Array:
 		var items: Array = holder
 		items[_index_in(named, items.size())] = value
-		return
+		return holder
 	if packed(holder):
 		var list: Variant = holder
 		list[_index_in(named, len(holder))] = value
-		return
+		return holder
 	if holder is Dictionary:
 		var map: Dictionary = holder
 		# Written back under the key it was found under, since a map keyed by StringName and one
 		# keyed by String both read the same way and a write to the wrong one adds a second entry.
 		map[_key_in(map, named)[0]] = value
-		return
+		return holder
+	if composite(holder):
+		var changed: Variant = holder
+		changed[named] = value
+		return changed
 	var object: Object = holder
 	object.set(named, value)
+	return holder
+
+
+## Why a write into [param chain]'s last holder, a copy, cannot reach the game, or "" when it can:
+## each copy is put back where it was read from on the way up, and a step that was a call answered
+## a copy the game does not keep anywhere. [param chain] is the one [method walk_to] answered.
+static func unwritable_copy(chain: Array[Dictionary]) -> String:
+	for index: int in range(chain.size() - 1, -1, -1):
+		var link: Dictionary = chain[index]
+		var named: String = link["named"]
+		if not method_of(named).is_empty():
+			return (
+				"%s:%s is what a call answered, a copy the game keeps nowhere, so a part of it is not a place to write"
+				% [link["called"], named]
+			)
+		if not composite(link["holder"]):
+			return ""
+	return ""
+
+
+## Puts [param changed], the copy a write into a vector or a transform changed, back where
+## [param chain] read it from, and every copy it was read out of back where that came from, up to
+## the first holder keeping its own: an object, whose setter runs, a list or a map.
+static func write_back(chain: Array[Dictionary], changed: Variant) -> void:
+	var value: Variant = changed
+	for index: int in range(chain.size() - 1, -1, -1):
+		var link: Dictionary = chain[index]
+		var holder: Variant = link["holder"]
+		value = write(holder, str(link["named"]), value)
+		if not composite(holder):
+			return
 
 
 ## What [param holder] holds under [param named], or answers to it when [param named] is a call.
@@ -455,6 +515,8 @@ static func read_under(holder: Variant, named: String) -> Variant:
 	if holder is Dictionary:
 		var map: Dictionary = holder
 		return map[_key_in(map, named)[0]]
+	if composite(holder):
+		return holder[named]
 	var object: Object = holder
 	var method: String = method_of(named)
 	if not method.is_empty():
@@ -521,6 +583,18 @@ static func nothing_there(holder: Variant, named: String, called_as: String) ->
 		if keys.size() > 8:
 			rest = " and %d more" % [keys.size() - 8]
 		return "%s has no key %s; it is keyed by %s%s" % [called_as, named, ", ".join(some), rest]
+	if composite(holder):
+		var kind: String = type_string(typeof(holder))
+		var sort: String = ("an " if kind.left(1) in ["A", "E", "I", "O", "U"] else "a ") + kind
+		var has: String = ", ".join(Values.components_of(holder))
+		if not container_call.is_empty():
+			return (
+				"%s is %s, which a path reads by its components, %s, and makes no call on"
+				% [called_as, sort, has]
+			)
+		return "%s is %s, so it has no %s; it has %s" % [called_as, sort, named, has]
+	if not holder is Object:
+		return "%s is %s, which has nothing to read %s off" % [called_as, type_string(typeof(holder)), named]
 	var object: Object = holder
 	var method: String = method_of(named)
 	if not method.is_empty():

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

@@ -634,12 +634,12 @@ func get_property(params: Dictionary) -> Dictionary:
 	if node_path.is_empty() or property.is_empty():
 		return {"type": "error", "message": "Node path and property required"}
 
-	var standing: Dictionary = Values.node_at(_host.get_tree().root, node_path)
+	var standing: Dictionary = Values.target_at(_host.get_tree().root, node_path)
 	if standing.has("message"):
 		return standing
-	var node: Node = standing["node"]
+	var target: Object = standing["object"]
 
-	var reached: Dictionary = Paths.walk_to(node, node_path, property)
+	var reached: Dictionary = Paths.walk_to(target, node_path, property)
 	if reached.has("message"):
 		return reached