gdharness 1.0.24 → 1.0.26

package/build/cli.js

@@ -16489,7 +16489,7 @@ var init_tool_definitions = __esm(() => {
         property: {
           type: "string",
           ops: ["property", "find"],
-          description: 'property: which one to read. find: read this one off every node matched, so a panel of labels is one call rather than one per label. Colons read through what a node holds, "_game:clock:speed", which is where a game keeps what is worth asking about. A number or a key steps into a list or a map, "_game:run:roster:0:traits", which is how the lists a game keeps its state in are walked: a roster, a board, an in-tray. A negative number counts from the end. A step written as a call, "get_viewport():gui_get_focus_owner()", calls a method that takes no arguments and walks into what it returned, which is how a question only a method answers is read in one call: which control holds the focus in the viewport this one is in. A list or a map answers the calls that read it and take no arguments, "_game:run:board:size()" or "_game:inbox:keys()", and not those that change it, such as clear() or sort(). A step that is not there is named, and says what was there instead.'
+          description: 'property: which one to read. find: read this one off every node matched, so a panel of labels is one call rather than one per label. Colons read through what a node holds, "_game:clock:speed", which is where a game keeps what is worth asking about. A number or a key steps into a list or a map, "_game:run:roster:0:traits", which is how the lists a game keeps its state in are walked: a roster, a board, an in-tray. A packed list, such as a PackedStringArray, steps the same way. A negative number counts from the end. A step written as a call, "get_viewport():gui_get_focus_owner()", calls a method that takes no arguments and walks into what it returned, which is how a question only a method answers is read in one call: which control holds the focus in the viewport this one is in. A list or a map answers the calls that read it and take no arguments, "_game:run:board:size()" or "_game:inbox:keys()", and not those that change it, such as clear() or sort(). A step that is not there is named, and says what was there instead.'
         },
         depth: { type: "number", ops: ["tree"], description: "tree: levels to descend. Default 3." },
         includeProperties: {
@@ -16779,7 +16779,7 @@ var init_tool_definitions = __esm(() => {
         says: {
           type: "string",
           ops: ["until"],
-          description: "until: wait for these words to appear anywhere under nodePath, or anywhere in the game when no nodePath is given, instead of for a property, which is how a panel that rebuilds its labels is waited on at all: the labels are named afresh each redraw and the panel is what stays put. Case-insensitive, part of a line, on a node the player can see unless includeHidden says otherwise; a label with a line break is matched with the break in the words, and a backslash followed by n counts as one. Instead of, not as well as: a call carrying this and a property is refused, because they ask about different things and answering one of them silently is how a caller watches a screen believing they are watching a property."
+          description: "until: wait for these words to appear anywhere under nodePath, or anywhere in the game when no nodePath is given, instead of for a property, which is how a panel that rebuilds its labels is waited on at all: the labels are named afresh each redraw and the panel is what stays put. Case-insensitive, part of a line, on a node the player can see unless includeHidden says otherwise; a label with a line break is matched with the break in the words, and a backslash followed by n counts as one. Instead of, not as well as: a call carrying this and a property is refused, because they ask about different things and answering one of them silently is how a caller watches a screen believing they are watching a property. It looks every frame while a look is cheap and less often on a screen large enough for a look to cost a real share of a frame, so the game keeps its speed; the answer counts the frames the wait spanned and the looks it took."
         },
         includeHidden: {
           type: "boolean",

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

@@ -48,6 +48,22 @@ const MAP_CALLS: Array[String] = [
 	"get_typed_value_class_name",
 	"get_typed_value_script",
 ]
+## The calls a path makes on a packed list, which has fewer than a list: measured on 4.7.2, it has no
+## front(), back(), max(), min() or hash().
+const PACKED_CALLS: Array[String] = ["size", "is_empty", "duplicate", "to_byte_array"]
+## The packed lists, which a game keeps names and points in as often as it keeps them in an Array.
+const PACKED: Array[int] = [
+	TYPE_PACKED_BYTE_ARRAY,
+	TYPE_PACKED_INT32_ARRAY,
+	TYPE_PACKED_INT64_ARRAY,
+	TYPE_PACKED_FLOAT32_ARRAY,
+	TYPE_PACKED_FLOAT64_ARRAY,
+	TYPE_PACKED_STRING_ARRAY,
+	TYPE_PACKED_VECTOR2_ARRAY,
+	TYPE_PACKED_VECTOR3_ARRAY,
+	TYPE_PACKED_COLOR_ARRAY,
+	TYPE_PACKED_VECTOR4_ARRAY,
+]
 ## The calls an empty list has nothing to answer, which the engine reports as an error when asked.
 const NEEDS_AN_ELEMENT: Array[String] = ["front", "back", "pick_random"]
 
@@ -142,7 +158,13 @@ static func object_at(root: Node, node: Node, node_path: String, given: Variant)
 ## 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
+	return value is Object or value is Array or value is Dictionary or packed(value)
+
+
+## Whether [param value] is a packed list. Stepped into the way a list is, by index, and a write into
+## one reaches the game's own copy, since packed lists share their storage until one is duplicated.
+static func packed(value: Variant) -> bool:
+	return typeof(value) in PACKED
 
 
 ## What is wrong with reading [param named] off [param holder], or "" when nothing is.
@@ -168,6 +190,10 @@ static func can_read(holder: Variant, named: String) -> bool:
 		if not list_call.is_empty():
 			return list_call in LIST_CALLS and not (items.is_empty() and list_call in NEEDS_AN_ELEMENT)
 		return _index_in(named, items.size()) != -1
+	if packed(holder):
+		if not method_of(named).is_empty():
+			return method_of(named) in PACKED_CALLS
+		return _index_in(named, len(holder)) != -1
 	if holder is Dictionary:
 		var map: Dictionary = holder
 		if not method_of(named).is_empty():
@@ -209,6 +235,10 @@ static func write(holder: Variant, named: String, value: Variant) -> void:
 		var items: Array = holder
 		items[_index_in(named, items.size())] = value
 		return
+	if packed(holder):
+		var list: Variant = holder
+		list[_index_in(named, len(holder))] = value
+		return
 	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
@@ -225,11 +255,14 @@ static func write(holder: Variant, named: String, value: Variant) -> void:
 ## What [param holder] holds under [param named], or answers to it when [param named] is a call.
 ## Only ever called once [method can_read] agrees.
 static func read_under(holder: Variant, named: String) -> Variant:
-	if (holder is Array or holder is Dictionary) and not method_of(named).is_empty():
+	if (holder is Array or holder is Dictionary or packed(holder)) and not method_of(named).is_empty():
 		return Callable.create(holder, method_of(named)).call()
 	if holder is Array:
 		var items: Array = holder
 		return items[_index_in(named, items.size())]
+	if packed(holder):
+		var list: Variant = holder
+		return list[_index_in(named, len(holder))]
 	if holder is Dictionary:
 		var map: Dictionary = holder
 		if map.has(named):
@@ -269,6 +302,10 @@ static func nothing_there(holder: Variant, named: String, called_as: String) ->
 		if not container_call.is_empty():
 			return container_calls_refused(called_as, "a list", container_call)
 		return "%s is a list of %d, so there is no %s in it" % [called_as, items.size(), named]
+	if packed(holder):
+		if not container_call.is_empty():
+			return container_calls_refused(called_as, "a packed list", container_call)
+		return "%s is a packed list of %d, so there is no %s in it" % [called_as, len(holder), named]
 	if holder is Dictionary:
 		if not container_call.is_empty():
 			return container_calls_refused(called_as, "a map", container_call)
@@ -303,10 +340,14 @@ static func nothing_there(holder: Variant, named: String, called_as: String) ->
 	return "%s has no property %s" % [called_as, named]
 
 
-## Why [param method] is not a call a path makes on [param sort] ("a list" or "a map"), naming
-## the calls it does make.
+## Why [param method] is not a call a path makes on [param sort] ("a list", "a packed list" or "a
+## map"), naming the calls it does make.
 static func container_calls_refused(called_as: String, sort: String, method: String) -> String:
-	var calls: Array[String] = LIST_CALLS if sort == "a list" else MAP_CALLS
+	var calls: Array[String] = MAP_CALLS
+	if sort == "a list":
+		calls = LIST_CALLS
+	elif sort == "a packed list":
+		calls = PACKED_CALLS
 	var spelled: Array[String] = []
 	for each: String in calls:
 		spelled.append(each + "()")

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

@@ -379,11 +379,17 @@ static func _drawn(node: Node) -> bool:
 ## Public because three questions are the same question: what a screen reads as, which nodes say a
 ## given word, and whether anything has come to say it yet. Two copies of what a node says is how
 ## the three of them come to disagree about a SpinBox.
+##
+## Read rather than looked up in the property list, which the engine builds afresh on every call: a
+## wait asks this of every node on the screen every frame, and on a hall of 3,500 nodes the lookup
+## took the game it was watching from 60 frames a second to 11. A node without the property reads
+## as null, which is not a string.
 static func said_by(node: Node) -> String:
-	for property: Dictionary in node.get_property_list():
-		if str(property.get("name", "")) == "text" and Read.as_int(property.get("type", 0)) == TYPE_STRING:
-			return str(node.get("text")).strip_edges()
-	return ""
+	var text: Variant = node.get("text")
+	if not text is String:
+		return ""
+	var words: String = text
+	return words.strip_edges()
 
 
 func get_rect(params: Dictionary) -> Dictionary:
@@ -699,7 +705,11 @@ func call_method(params: Dictionary) -> Dictionary:
 	# rather than as "has no method", which reads as a misspelling of a method that was never going
 	# to be there, and with the element spelled out, since a method on what it holds is the usual aim.
 	if not reached["holder"] is Object:
-		var sort: String = "a list" if reached["holder"] is Array else "a map"
+		var sort: String = "a list"
+		if reached["holder"] is Dictionary:
+			sort = "a map"
+		elif Paths.packed(reached["holder"]):
+			sort = "a packed list"
 		var spelled: String = str(reached["name"])
 		if Paths.method_of(spelled).is_empty():
 			spelled += "()"

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

@@ -15,6 +15,10 @@ const CEILING_MSEC: int = 120000
 ## The most frames one wait may cover, which is about half a minute of a game drawing slowly.
 const MOST_FRAMES: int = 600
 
+## How long a wait for words leaves between looks, as a multiple of what the last look took: nine
+## gives looking about a tenth of the time.
+const LOOKS_APART: int = 9
+
 var _host: Node
 var _values: Values
 
@@ -140,6 +144,7 @@ func wait_until(params: Dictionary) -> Dictionary:
 		return {"type": "error", "message": refused}
 
 	var started: int = Time.get_ticks_msec()
+	var frames: int = 0
 	# The type is checked every time round, not only at the top: a property that holds an object a
 	# frame later is the same error arriving late.
 	while (
@@ -148,6 +153,7 @@ func wait_until(params: Dictionary) -> Dictionary:
 		and Time.get_ticks_msec() - started < timeout_ms
 	):
 		await _host.get_tree().process_frame
+		frames += 1
 		if not is_instance_valid(node):
 			return {"type": "error", "message": "%s was freed while waiting" % node_path}
 		watched = _watched(node, node_path, property)
@@ -162,6 +168,7 @@ func wait_until(params: Dictionary) -> Dictionary:
 		"met": Values.comparable(current, wanted) and current == wanted,
 		"value": _values.serialize(current),
 		"elapsed_ms": Time.get_ticks_msec() - started,
+		"frames": frames,
 	}
 
 
@@ -232,13 +239,36 @@ static func _watched(node: Node, node_path: String, property: String) -> Diction
 ## answered met in two milliseconds while the sweep was still animating, and every wait on that
 ## screen fell back to counting frames. [param include_hidden] asks the other question, for a
 ## caller waiting on words a hidden node holds.
+##
+## Paced by what a look costs, so the watching leaves the game its speed: every frame while a look is
+## cheap, and on a screen large enough for one to cost a real share of a frame, often enough that
+## looking takes about a tenth of the time. Every frame on a hall of 3,500 nodes held the game at a
+## sixth of its frame rate, and its clock, which advances by the frame's delta, lost three quarters
+## of its time, so a wait for a date timed out on a clock that turned a day every thirty seconds.
+## The answer says how many frames the wait spanned and how many looks it took, which is how a
+## caller sees what it cost.
 func _wait_until_said(node_path: String, said: String, timeout_ms: int, include_hidden: bool) -> Dictionary:
 	var started: int = Time.get_ticks_msec()
 	var words: String = Queries.as_said(said)
-	var found: bool = _anything_says(node_path, words, include_hidden)
-	while not found and Time.get_ticks_msec() - started < timeout_ms:
+	var frames: int = 0
+	var looks: int = 0
+	var next_look: int = 0
+	var found: bool = false
+	while true:
+		if Time.get_ticks_usec() >= next_look:
+			var looking: int = Time.get_ticks_usec()
+			found = _anything_says(node_path, words, include_hidden)
+			looks += 1
+			next_look = Time.get_ticks_usec() + (Time.get_ticks_usec() - looking) * LOOKS_APART
+		if found or Time.get_ticks_msec() - started >= timeout_ms:
+			break
 		await _host.get_tree().process_frame
+		frames += 1
+	# One more look at the end, so words that arrived between two paced looks are not answered as
+	# never having come.
+	if not found:
 		found = _anything_says(node_path, words, include_hidden)
+		looks += 1
 
 	return {
 		"type": "condition",
@@ -247,6 +277,8 @@ func _wait_until_said(node_path: String, said: String, timeout_ms: int, include_
 		"met": found,
 		"include_hidden": include_hidden,
 		"elapsed_ms": Time.get_ticks_msec() - started,
+		"frames": frames,
+		"looks": looks,
 	}
 
 

package/build/index.js

@@ -30496,7 +30496,7 @@ var TOOL_SPECS = [
       property: {
         type: "string",
         ops: ["property", "find"],
-        description: 'property: which one to read. find: read this one off every node matched, so a panel of labels is one call rather than one per label. Colons read through what a node holds, "_game:clock:speed", which is where a game keeps what is worth asking about. A number or a key steps into a list or a map, "_game:run:roster:0:traits", which is how the lists a game keeps its state in are walked: a roster, a board, an in-tray. A negative number counts from the end. A step written as a call, "get_viewport():gui_get_focus_owner()", calls a method that takes no arguments and walks into what it returned, which is how a question only a method answers is read in one call: which control holds the focus in the viewport this one is in. A list or a map answers the calls that read it and take no arguments, "_game:run:board:size()" or "_game:inbox:keys()", and not those that change it, such as clear() or sort(). A step that is not there is named, and says what was there instead.'
+        description: 'property: which one to read. find: read this one off every node matched, so a panel of labels is one call rather than one per label. Colons read through what a node holds, "_game:clock:speed", which is where a game keeps what is worth asking about. A number or a key steps into a list or a map, "_game:run:roster:0:traits", which is how the lists a game keeps its state in are walked: a roster, a board, an in-tray. A packed list, such as a PackedStringArray, steps the same way. A negative number counts from the end. A step written as a call, "get_viewport():gui_get_focus_owner()", calls a method that takes no arguments and walks into what it returned, which is how a question only a method answers is read in one call: which control holds the focus in the viewport this one is in. A list or a map answers the calls that read it and take no arguments, "_game:run:board:size()" or "_game:inbox:keys()", and not those that change it, such as clear() or sort(). A step that is not there is named, and says what was there instead.'
       },
       depth: { type: "number", ops: ["tree"], description: "tree: levels to descend. Default 3." },
       includeProperties: {
@@ -30786,7 +30786,7 @@ var TOOL_SPECS = [
       says: {
         type: "string",
         ops: ["until"],
-        description: "until: wait for these words to appear anywhere under nodePath, or anywhere in the game when no nodePath is given, instead of for a property, which is how a panel that rebuilds its labels is waited on at all: the labels are named afresh each redraw and the panel is what stays put. Case-insensitive, part of a line, on a node the player can see unless includeHidden says otherwise; a label with a line break is matched with the break in the words, and a backslash followed by n counts as one. Instead of, not as well as: a call carrying this and a property is refused, because they ask about different things and answering one of them silently is how a caller watches a screen believing they are watching a property."
+        description: "until: wait for these words to appear anywhere under nodePath, or anywhere in the game when no nodePath is given, instead of for a property, which is how a panel that rebuilds its labels is waited on at all: the labels are named afresh each redraw and the panel is what stays put. Case-insensitive, part of a line, on a node the player can see unless includeHidden says otherwise; a label with a line break is matched with the break in the words, and a backslash followed by n counts as one. Instead of, not as well as: a call carrying this and a property is refused, because they ask about different things and answering one of them silently is how a caller watches a screen believing they are watching a property. It looks every frame while a look is cheap and less often on a screen large enough for a look to cost a real share of a frame, so the game keeps its speed; the answer counts the frames the wait spanned and the looks it took."
       },
       includeHidden: {
         type: "boolean",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdharness",
-  "version": "1.0.24",
+  "version": "1.0.26",
   "mcpName": "io.github.Aureliolo/gdharness",
   "description": "A harness for driving a Godot 4 project from an agent: editor addons, a runtime bridge into the running game, an MCP server in front of them, and a CLI that installs and diagnoses the Godot side.",
   "type": "module",