gdharness 0.8.0 → 0.9.0

package/build/cli.js

@@ -15966,7 +15966,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "runtime_wait",
-      description: "Lets the running game get on with it and answers when something has happened: a number of frames, a signal, or a property reaching a value. Needs the game running with the runtime addon.",
+      description: "Lets the running game get on with it and answers when something has happened: a number of frames, a signal, a property reaching a value, or words appearing on a screen. Needs the game running with the runtime addon.",
       parameters: {
         projectPath: RUNNING_PROJECT_PATH,
         frames: {
@@ -15978,6 +15978,11 @@ var init_tool_definitions = __esm(() => {
         signal: { type: "string", ops: ["signal"], description: "signal: the signal name." },
         property: { type: "string", ops: ["until"], description: "until: the property name." },
         value: { ops: ["until"], description: "until: the value to wait for, fitted to the property's type." },
+        says: {
+          type: "string",
+          ops: ["until"],
+          description: "until: wait for these words to appear anywhere under nodePath 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, hidden nodes included."
+        },
         timeoutMs: {
           type: "number",
           ops: ["signal", "until"],
@@ -15992,8 +15997,8 @@ var init_tool_definitions = __esm(() => {
           requires: ["nodePath", "signal"]
         },
         until: {
-          summary: "wait for a property to read as a value and answer with what it read",
-          requires: ["nodePath", "property", "value"]
+          summary: "wait for a property to read as a value, or for words to appear under a node, and answer with what it found",
+          requires: ["nodePath"]
         }
       }
     },
@@ -37542,6 +37547,7 @@ class GodotServer {
       path: nodePath,
       property: readString(args, "property") ?? "",
       value: args["value"],
+      ...readNonEmptyString(args, "says") === undefined ? {} : { says: readNonEmptyString(args, "says") },
       timeout_ms: timeoutMs
     }, patience);
   }
@@ -38927,7 +38933,7 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
 | Answer a dialog | \`runtime_input click\` on its button, or \`key\` Escape to dismiss it: an [AcceptDialog] reads that key itself and never asks the InputMap, so \`ui_cancel\` leaves it standing |
 | Press a bound key | \`runtime_input action\` or \`key\`, a whole press unless you hold it |
 | Where a 3D node is on screen | \`runtime_inspect\` \`rect\`, rather than unprojecting by hand |
-| Wait for something | \`runtime_wait\`, never a sleep |
+| Wait for something | \`runtime_wait\`, never a sleep; \`until\` with \`says\` for a panel that rebuilds its own labels |
 | A picture, for a person who asked to see one | \`runtime_capture\` |
 
 These need the runtime autoload, which \`gdharness setup\` registers. \`runtime_capture\` needs a

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

@@ -131,7 +131,7 @@ func _matches(node: Node, wanted: Dictionary[String, String]) -> bool:
 	# What this node says, rather than everything said underneath it. A row is then found by the
 	# label in it, and the path answered is that label's, which is where the words a caller is
 	# looking at actually are: matching every container above it would answer with the screen.
-	if not wanted["says"].is_empty() and not _said_by(node).containsn(wanted["says"]):
+	if not wanted["says"].is_empty() and not said_by(node).containsn(wanted["says"]):
 		return false
 	var script: Variant = node.get_script()
 	if not wanted["script"].is_empty():
@@ -206,7 +206,7 @@ func _read_into(node: Node, include_hidden: bool, most: int, into: PackedStringA
 		return
 	if not include_hidden and not _drawn(node):
 		return
-	var said: String = _said_by(node)
+	var said: String = said_by(node)
 	if not said.is_empty():
 		into.append(said)
 	for child: Node in node.get_children(true):
@@ -224,7 +224,11 @@ static func _drawn(node: Node) -> bool:
 
 ## What one node says, or "" for a node that says nothing. Anything with a `text` property, which
 ## is every label, button and field the interface is built out of.
-static func _said_by(node: Node) -> String:
+##
+## 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.
+static func said_by(node: Node) -> String:
 	for property: Dictionary in node.get_property_list():
 		if str(property.get("name", "")) == "text" and int(property.get("type", 0)) == TYPE_STRING:
 			return str(node.get("text")).strip_edges()

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

@@ -3,6 +3,7 @@ extends RefCounted
 ## The commands that take time: they let the game run and answer when what was waited for has
 ## happened, or when the time ran out, so the caller never sleeps for a guessed length.
 
+const Queries = preload("runtime_queries.gd")
 const Values = preload("runtime_values.gd")
 
 ## The longest one wait may last, whatever the request says: past this the server has long
@@ -78,22 +79,27 @@ func wait_signal(params: Dictionary) -> Dictionary:
 	}
 
 
-## Waits until a property reads as the value given, or the time runs out, and answers with
-## what it read last either way.
+## Waits until a property reads as the value given, or until something under the path says what
+## was given, or the time runs out, and answers with what it read last either way.
 func wait_until(params: Dictionary) -> Dictionary:
 	var node_path: String = str(params.get("path", ""))
 	var property: String = str(params.get("property", ""))
+	var says: String = str(params.get("says", ""))
 	var timeout_ms: int = int(params.get("timeout_ms", 5000))
 	if timeout_ms < 1 or timeout_ms > CEILING_MSEC:
 		return _out_of_range("timeout_ms", timeout_ms, 1, CEILING_MSEC)
-	if node_path.is_empty() or property.is_empty():
-		return {"type": "error", "message": "Node path and property required"}
+	if node_path.is_empty():
+		return {"type": "error", "message": "Node path required"}
+	if _host.get_tree().root.get_node_or_null(node_path) == null:
+		return {"type": "error", "message": "Node not found: " + node_path}
+	if not says.is_empty():
+		return await _wait_until_said(node_path, says, timeout_ms)
+	if property.is_empty():
+		return {"type": "error", "message": "A property and a value, or says, are required"}
 	if not params.has("value"):
 		return {"type": "error", "message": "A value to wait for is required"}
 
 	var node: Node = _host.get_tree().root.get_node_or_null(node_path)
-	if node == null:
-		return {"type": "error", "message": "Node not found: " + node_path}
 
 	var current: Variant = node.get(property)
 	var wanted: Variant = _values.fitted(params["value"], typeof(current))
@@ -114,6 +120,45 @@ func wait_until(params: Dictionary) -> Dictionary:
 	}
 
 
+## Waits until something under [param node_path] has [param said] written on it.
+##
+## A screen rather than one node, because a panel following a clock builds its labels again every
+## time it redraws and the engine names those `@Label@1163`. A wait holding one of them is waiting
+## on a node that was freed a frame later, and that is what it answered: the date along the top of a
+## hall could not be waited on at all. What a caller is watching for is a word arriving on a screen,
+## and the screen is the part that stays put.
+func _wait_until_said(node_path: String, said: String, timeout_ms: int) -> Dictionary:
+	var started: int = Time.get_ticks_msec()
+	var found: bool = _anything_says(node_path, said)
+	while not found and Time.get_ticks_msec() - started < timeout_ms:
+		await _host.get_tree().process_frame
+		found = _anything_says(node_path, said)
+
+	return {
+		"type": "condition",
+		"path": node_path,
+		"says": said,
+		"met": found,
+		"elapsed_ms": Time.get_ticks_msec() - started,
+	}
+
+
+## Whether anything under [param node_path] says [param said], the node itself included. Hidden
+## nodes count, for the reason a find answers off them: a caller may be waiting for a dialog that
+## is built before it is shown.
+func _anything_says(node_path: String, said: String) -> bool:
+	var root: Node = _host.get_tree().root.get_node_or_null(node_path)
+	if root == null:
+		return false
+	var pending: Array[Node] = [root]
+	while not pending.is_empty():
+		var node: Node = pending.pop_back()
+		if Queries.said_by(node).containsn(said):
+			return true
+		pending.append_array(node.get_children(true))
+	return false
+
+
 func _signal_arity(node: Node, signal_name: String) -> int:
 	for entry: Dictionary in node.get_signal_list():
 		if entry.get("name", "") == signal_name:

package/build/index.js

@@ -28519,7 +28519,7 @@ var TOOL_SPECS = [
   },
   {
     name: "runtime_wait",
-    description: "Lets the running game get on with it and answers when something has happened: a number of frames, a signal, or a property reaching a value. Needs the game running with the runtime addon.",
+    description: "Lets the running game get on with it and answers when something has happened: a number of frames, a signal, a property reaching a value, or words appearing on a screen. Needs the game running with the runtime addon.",
     parameters: {
       projectPath: RUNNING_PROJECT_PATH,
       frames: {
@@ -28531,6 +28531,11 @@ var TOOL_SPECS = [
       signal: { type: "string", ops: ["signal"], description: "signal: the signal name." },
       property: { type: "string", ops: ["until"], description: "until: the property name." },
       value: { ops: ["until"], description: "until: the value to wait for, fitted to the property's type." },
+      says: {
+        type: "string",
+        ops: ["until"],
+        description: "until: wait for these words to appear anywhere under nodePath 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, hidden nodes included."
+      },
       timeoutMs: {
         type: "number",
         ops: ["signal", "until"],
@@ -28545,8 +28550,8 @@ var TOOL_SPECS = [
         requires: ["nodePath", "signal"]
       },
       until: {
-        summary: "wait for a property to read as a value and answer with what it read",
-        requires: ["nodePath", "property", "value"]
+        summary: "wait for a property to read as a value, or for words to appear under a node, and answer with what it found",
+        requires: ["nodePath"]
       }
     }
   },
@@ -30323,6 +30328,7 @@ class GodotServer {
       path: nodePath,
       property: readString(args, "property") ?? "",
       value: args["value"],
+      ...readNonEmptyString(args, "says") === undefined ? {} : { says: readNonEmptyString(args, "says") },
       timeout_ms: timeoutMs
     }, patience);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdharness",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "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",