gdharness 1.0.32 → 1.1.1

package/build/cli.js

@@ -16440,7 +16440,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "editor_rescan",
-      description: "Makes the running editor scan the project filesystem, so files written outside it are picked up. The scan is a change-detecting walk rather than an unconditional reparse, so a file another engine has already imported reads as settled and the walk does not look inside it: its class_name then stays out of the list the editor resolves against, however many times you scan. Any class in that state is named under unseenByEditor, which is what no check on disk can see, since the declaration and the cache are both correct there and only the editor disagrees. The cure is this call on its own, with no change to the declaring script: measured against a real editor on three platforms, with idle waits of the same length ruled out so the scan is credited rather than the time it takes, and reproduced in a second project against its own reproduction in 203ms. editor_launch restart also does it and costs a window, and project_import refresh_classes does not: it rewrites the cache and does not touch what the editor is holding. A scan writes .godot/global_script_class_cache.cfg from the list the editor is holding, so a class the editor cannot resolve goes out of that file with it. That is not a reason to refuse the scan, because on a class the editor has merely not walked yet the scan is the cure; what the answer does instead is name the loss under cacheLost and rebuild the cache from the files, naming what came back under cacheRestored, so no fresh engine, CI run or clone inherits the short file. An editor that lost classes is still holding the short list, so the note says to restart it before scanning again. The other direction is guarded the same way: a class the editor still holds for a script that was renamed or deleted comes back into the cache at a path that is not there, and the next engine to read it fails on \"Could not parse global class\" in whichever correct script shares the bare name, so the cache is rebuilt without it and the answer names it under cacheDropped; the editor goes on holding it until it is restarted, and every scan until then ends in that rebuild. A script or shader written outside the editor has no .uid sidecar until something imports it, and the scan writes one beside it, which a project that commits sidecars needs before the commit. Needs the editor connected.",
+      description: "Makes the running editor scan the project filesystem, so files written outside it are picked up. A scan or an import the editor is already running is waited out first rather than scanned over, which would start a second import over it, and the answer says how long under waitedForEditorScanMs. The scan is a change-detecting walk rather than an unconditional reparse, so a file another engine has already imported reads as settled and the walk does not look inside it: its class_name then stays out of the list the editor resolves against, however many times you scan. Any class in that state is named under unseenByEditor, which is what no check on disk can see, since the declaration and the cache are both correct there and only the editor disagrees. The cure is this call on its own, with no change to the declaring script: measured against a real editor on three platforms, with idle waits of the same length ruled out so the scan is credited rather than the time it takes, and reproduced in a second project against its own reproduction in 203ms. editor_launch restart also does it and costs a window, and project_import refresh_classes does not: it rewrites the cache and does not touch what the editor is holding. A scan writes .godot/global_script_class_cache.cfg from the list the editor is holding, so a class the editor cannot resolve goes out of that file with it. That is not a reason to refuse the scan, because on a class the editor has merely not walked yet the scan is the cure; what the answer does instead is name the loss under cacheLost and rebuild the cache from the files, naming what came back under cacheRestored, so no fresh engine, CI run or clone inherits the short file. An editor that lost classes is still holding the short list, so the note says to restart it before scanning again. The other direction is guarded the same way: a class the editor still holds for a script that was renamed or deleted comes back into the cache at a path that is not there, and the next engine to read it fails on \"Could not parse global class\" in whichever correct script shares the bare name, so the cache is rebuilt without it and the answer names it under cacheDropped; the editor goes on holding it until it is restarted, and every scan until then ends in that rebuild. A script or shader written outside the editor has no .uid sidecar until something imports it, and the scan writes one beside it, which a project that commits sidecars needs before the commit. Needs the editor connected.",
       parameters: {
         projectPath: PROJECT_PATH,
         timeoutMs: {
@@ -16546,7 +16546,7 @@ var init_tool_definitions = __esm(() => {
         says: {
           type: "string",
           ops: ["find"],
-          description: "find: part of what the node has written on it as drawn, the way the text op reads it, case-insensitively, which is how a button is reached by the word on it rather than by a generated path. Its own text, so a row is found by the label in it, and hidden nodes match. A bare word is a contains; write a glob and it is one, matched against the whole of what the node says, the same as namePattern. A label with a line break is matched with the break in the words, and a backslash followed by n counts as one."
+          description: "find: part of what the node has written on it as drawn, the way the text op reads it, case-insensitively, which is how a button is reached by the word on it rather than by a generated path. Its own text, so a row is found by the label in it, and hidden nodes match. A bare word is a contains; write a glob and it is one, matched against the whole of what the node says, the same as namePattern, and a glob that finds nothing says under note how many nodes it would find open at both ends. A label with a line break is matched with the break in the words, and a backslash followed by n counts as one."
         },
         limit: {
           type: "integer",
@@ -16596,7 +16596,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "runtime_invoke",
-      description: "Sets a property or calls a method on a node in the running game. Needs the game running with the runtime addon. A call that takes longer than timeoutMs is not cancelled: the answer is pending: true with a requestId, the call goes on and does everything it was asked, and op result with that requestId collects its reply once it comes.",
+      description: "Sets a property or calls a method on a node in the running game. Needs the game running with the runtime addon. The answer carries elapsed_usec, how long the call or the write took inside the game, measured around it there: the round trip to the game is a second or more, so timing from outside measures that instead. A call that takes longer than timeoutMs is not cancelled: the answer is pending: true with a requestId, the call goes on and does everything it was asked, and op result with that requestId collects its reply once it comes.",
       parameters: {
         projectPath: RUNNING_PROJECT_PATH,
         pid: RUNNING_PID,
@@ -41802,6 +41802,17 @@ class GodotServer {
     const nearest = descendantsIn(tree, root).filter((pid) => isEngine(pid) && !ancestorsIn(tree, pid, root).some((one) => one !== root && isEngine(one)));
     return nearest.length === 1 ? nearest[0] : undefined;
   }
+  async editorIsScanningOrImporting() {
+    if (!this.godotBridge.isConnected()) {
+      return false;
+    }
+    try {
+      const status = asParams(await this.godotBridge.invokeTool("scan_status", {}));
+      return status["scanning"] === true || status["importing"] === true;
+    } catch {
+      return false;
+    }
+  }
   async handleRescanFilesystem(args) {
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 30000;
     const started = Date.now();
@@ -41811,9 +41822,26 @@ class GodotServer {
     const blind = await this.classesTheEditorCannotSee(args);
     const atRisk = before === null ? [] : blind.unseen.filter((one) => before.has(one.className));
     const ghosts = blind.stillHeld ?? [];
-    const first = await this.handleViaBridge("rescan_filesystem", args);
-    if (first.isError) {
-      return first;
+    let waitedForEditorMs = 0;
+    let first;
+    for (;; ) {
+      const busySince = Date.now();
+      let wasBusy = false;
+      while (Date.now() - started < timeoutMs && await this.editorIsScanningOrImporting()) {
+        wasBusy = true;
+        await new Promise((settle) => setTimeout(settle, 100));
+      }
+      if (wasBusy) {
+        waitedForEditorMs += Date.now() - busySince;
+      }
+      first = await this.handleViaBridge("rescan_filesystem", args);
+      if (first.isError) {
+        return first;
+      }
+      const declined = asParams(JSON.parse(first.content[0]?.text ?? "{}"))["started"] === false;
+      if (!declined || Date.now() - started >= timeoutMs) {
+        break;
+      }
     }
     let busy = true;
     while (busy && Date.now() - started < timeoutMs) {
@@ -41872,6 +41900,7 @@ class GodotServer {
       ok: !busy && unseen.length === 0 && stillGone.length === 0 && stillAtMissingPaths.length === 0 && checked.unchecked === undefined,
       stillWorking: busy,
       waitedMs: Date.now() - started,
+      waitedForEditorScanMs: waitedForEditorMs > 0 ? waitedForEditorMs : undefined,
       heldBeforeReload: reloaded.heldBefore,
       reloadedMethods: reloaded.methods,
       reloadProblem: reloaded.problem,

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

@@ -656,10 +656,16 @@ func rescan_filesystem(args: Dictionary) -> Dictionary:
 		return {"ok": false, "error": "Editor plugin unavailable"}
 
 	var filesystem: EditorFileSystem = EditorInterface.get_resource_filesystem()
-	if not Read.as_bool(args.get("statusOnly", false)):
+	# Not over a scan or an import the editor is already running: a scan asked for then starts a
+	# second reimport over the first, and the editor logs "Task 'reimport' already exists" and two
+	# conditions from its progress dialog. Declined and said, so the caller waits and asks again.
+	var busy: bool = filesystem.is_scanning() or filesystem.is_importing()
+	var started: bool = false
+	if not Read.as_bool(args.get("statusOnly", false)) and not busy:
 		_scans_finished_at_request = _scans_finished
 		_scan_pending = true
 		filesystem.scan()
+		started = true
 
 	# Importing is reported separately from scanning, and a class is not registered until
 	# both are done, so a caller watching only one of them can look too early.
@@ -677,6 +683,7 @@ func rescan_filesystem(args: Dictionary) -> Dictionary:
 		_scan_pending = false
 	return {
 		"ok": true,
+		"started": started,
 		"scanning": scanning,
 		"importing": importing,
 		"pending": _scan_pending,

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

@@ -104,6 +104,15 @@ func find_nodes(params: Dictionary) -> Dictionary:
 	# find would have matched if the name had been read the way it was probably meant.
 	var literal: bool = _is_literal(wanted["name"])
 	var nearly: int = 0
+	# The same for the words: a glob is matched against the whole text, and one written as a prefix
+	# by habit, "Taken together*", missed the label whose sentence those words are in the middle of.
+	# Nothing found then read as the words not being on screen, which is the wrong conclusion when
+	# checking that a change to the text landed.
+	var widened_says: String = _widened(wanted["says"])
+	var widened: Dictionary[String, String] = {}
+	for filter: String in wanted:
+		widened[filter] = widened_says if filter == "says" else wanted[filter]
+	var nearly_said: int = 0
 	var hidden: int = 0
 	while not pending.is_empty():
 		var node: Node = pending.pop_front()
@@ -118,6 +127,12 @@ func find_nodes(params: Dictionary) -> Dictionary:
 				found.append(_found(node, wanted_property))
 		elif rest and literal and str(node.name).containsn(wanted["name"]):
 			nearly += 1
+		elif (
+			not widened_says.is_empty()
+			and _named(node, wanted["name"])
+			and _matches_apart_from_name(node, widened)
+		):
+			nearly_said += 1
 		# Internal children included, which they were not. A ConfirmationDialog builds its Yes and
 		# its No as internal nodes, and a ScrollContainer its bars, so a find over a screen for
 		# every Button came back without the two buttons the player is being asked to press:
@@ -141,6 +156,16 @@ func find_nodes(params: Dictionary) -> Dictionary:
 				% [nearly, holding, wanted["name"], wanted["name"]]
 			)
 		)
+	if found.is_empty() and nearly_said > 0:
+		(
+			notes
+			. append(
+				(
+					'says with a wildcard is matched as a glob against a node\'s whole text; "%s" would find %d node%s'
+					% [widened_says, nearly_said, "" if nearly_said == 1 else "s"]
+				)
+			)
+		)
 	# How many the filter took out, so a short answer is not read as a small screen. Left out
 	# entirely when nothing was hidden, which keeps a plain answer plain.
 	if hidden > 0:
@@ -234,6 +259,15 @@ static func _says(said: String, wanted: String) -> bool:
 	return said.containsn(words) if _is_literal(words) else said.matchn(words)
 
 
+## [param wanted], a glob, open at both ends so it matches its words anywhere in a text; "" when
+## it is not a glob, or already open at both ends, and so has nothing to suggest.
+static func _widened(wanted: String) -> String:
+	if wanted.is_empty() or _is_literal(wanted):
+		return ""
+	var open: String = "*" + wanted.lstrip("*").rstrip("*") + "*"
+	return "" if open == wanted else open
+
+
 ## [param wanted] as words on a screen: a backslash followed by n is a line break.
 ##
 ## A button with two lines on it was asked for with the break written as the two characters, the
@@ -624,7 +658,10 @@ func set_property(params: Dictionary) -> Dictionary:
 				"%s.%s is a typed %s: %s." % [reached["called"], named, _sort_of(old_value), typed["message"]]
 			}
 		given = typed["value"]
+	# 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 elapsed: int = Time.get_ticks_usec() - began
 	var now: Variant = Paths.read_under(holder, named)
 	# 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
@@ -658,7 +695,8 @@ func set_property(params: Dictionary) -> Dictionary:
 		"path": node_path,
 		"property": property,
 		"old_value": _values.serialize(old_value),
-		"new_value": _values.serialize(now)
+		"new_value": _values.serialize(now),
+		"elapsed_usec": elapsed
 	}
 
 
@@ -695,12 +733,15 @@ func call_method(params: Dictionary) -> Dictionary:
 		if Paths.method_of(spelled).is_empty():
 			spelled += "()"
 		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)
+			var read_for: int = Time.get_ticks_usec() - read_from
 			return {
 				"type": "method_result",
 				"path": node_path,
 				"method": method,
 				"result": _values.serialize(answered),
+				"elapsed_usec": read_for,
 			}
 		var why: String = (
 			"%s:%s takes no arguments" % [reached["called"], spelled]
@@ -772,9 +813,19 @@ func call_method(params: Dictionary) -> Dictionary:
 			given = typed["value"]
 		deserialized_args.append(given)
 
+	# 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.
+	var began: int = Time.get_ticks_usec()
 	var result: Variant = holder.callv(named, deserialized_args)
+	var elapsed: int = Time.get_ticks_usec() - began
 
-	return {"type": "method_result", "path": node_path, "method": method, "result": _values.serialize(result)}
+	return {
+		"type": "method_result",
+		"path": node_path,
+		"method": method,
+		"result": _values.serialize(result),
+		"elapsed_usec": elapsed
+	}
 
 
 ## [method _object_named] with the path first, which is the order [method Values.typed_like] calls

package/build/index.js

@@ -30566,7 +30566,7 @@ var TOOL_SPECS = [
   },
   {
     name: "editor_rescan",
-    description: "Makes the running editor scan the project filesystem, so files written outside it are picked up. The scan is a change-detecting walk rather than an unconditional reparse, so a file another engine has already imported reads as settled and the walk does not look inside it: its class_name then stays out of the list the editor resolves against, however many times you scan. Any class in that state is named under unseenByEditor, which is what no check on disk can see, since the declaration and the cache are both correct there and only the editor disagrees. The cure is this call on its own, with no change to the declaring script: measured against a real editor on three platforms, with idle waits of the same length ruled out so the scan is credited rather than the time it takes, and reproduced in a second project against its own reproduction in 203ms. editor_launch restart also does it and costs a window, and project_import refresh_classes does not: it rewrites the cache and does not touch what the editor is holding. A scan writes .godot/global_script_class_cache.cfg from the list the editor is holding, so a class the editor cannot resolve goes out of that file with it. That is not a reason to refuse the scan, because on a class the editor has merely not walked yet the scan is the cure; what the answer does instead is name the loss under cacheLost and rebuild the cache from the files, naming what came back under cacheRestored, so no fresh engine, CI run or clone inherits the short file. An editor that lost classes is still holding the short list, so the note says to restart it before scanning again. The other direction is guarded the same way: a class the editor still holds for a script that was renamed or deleted comes back into the cache at a path that is not there, and the next engine to read it fails on \"Could not parse global class\" in whichever correct script shares the bare name, so the cache is rebuilt without it and the answer names it under cacheDropped; the editor goes on holding it until it is restarted, and every scan until then ends in that rebuild. A script or shader written outside the editor has no .uid sidecar until something imports it, and the scan writes one beside it, which a project that commits sidecars needs before the commit. Needs the editor connected.",
+    description: "Makes the running editor scan the project filesystem, so files written outside it are picked up. A scan or an import the editor is already running is waited out first rather than scanned over, which would start a second import over it, and the answer says how long under waitedForEditorScanMs. The scan is a change-detecting walk rather than an unconditional reparse, so a file another engine has already imported reads as settled and the walk does not look inside it: its class_name then stays out of the list the editor resolves against, however many times you scan. Any class in that state is named under unseenByEditor, which is what no check on disk can see, since the declaration and the cache are both correct there and only the editor disagrees. The cure is this call on its own, with no change to the declaring script: measured against a real editor on three platforms, with idle waits of the same length ruled out so the scan is credited rather than the time it takes, and reproduced in a second project against its own reproduction in 203ms. editor_launch restart also does it and costs a window, and project_import refresh_classes does not: it rewrites the cache and does not touch what the editor is holding. A scan writes .godot/global_script_class_cache.cfg from the list the editor is holding, so a class the editor cannot resolve goes out of that file with it. That is not a reason to refuse the scan, because on a class the editor has merely not walked yet the scan is the cure; what the answer does instead is name the loss under cacheLost and rebuild the cache from the files, naming what came back under cacheRestored, so no fresh engine, CI run or clone inherits the short file. An editor that lost classes is still holding the short list, so the note says to restart it before scanning again. The other direction is guarded the same way: a class the editor still holds for a script that was renamed or deleted comes back into the cache at a path that is not there, and the next engine to read it fails on \"Could not parse global class\" in whichever correct script shares the bare name, so the cache is rebuilt without it and the answer names it under cacheDropped; the editor goes on holding it until it is restarted, and every scan until then ends in that rebuild. A script or shader written outside the editor has no .uid sidecar until something imports it, and the scan writes one beside it, which a project that commits sidecars needs before the commit. Needs the editor connected.",
     parameters: {
       projectPath: PROJECT_PATH,
       timeoutMs: {
@@ -30672,7 +30672,7 @@ var TOOL_SPECS = [
       says: {
         type: "string",
         ops: ["find"],
-        description: "find: part of what the node has written on it as drawn, the way the text op reads it, case-insensitively, which is how a button is reached by the word on it rather than by a generated path. Its own text, so a row is found by the label in it, and hidden nodes match. A bare word is a contains; write a glob and it is one, matched against the whole of what the node says, the same as namePattern. A label with a line break is matched with the break in the words, and a backslash followed by n counts as one."
+        description: "find: part of what the node has written on it as drawn, the way the text op reads it, case-insensitively, which is how a button is reached by the word on it rather than by a generated path. Its own text, so a row is found by the label in it, and hidden nodes match. A bare word is a contains; write a glob and it is one, matched against the whole of what the node says, the same as namePattern, and a glob that finds nothing says under note how many nodes it would find open at both ends. A label with a line break is matched with the break in the words, and a backslash followed by n counts as one."
       },
       limit: {
         type: "integer",
@@ -30722,7 +30722,7 @@ var TOOL_SPECS = [
   },
   {
     name: "runtime_invoke",
-    description: "Sets a property or calls a method on a node in the running game. Needs the game running with the runtime addon. A call that takes longer than timeoutMs is not cancelled: the answer is pending: true with a requestId, the call goes on and does everything it was asked, and op result with that requestId collects its reply once it comes.",
+    description: "Sets a property or calls a method on a node in the running game. Needs the game running with the runtime addon. The answer carries elapsed_usec, how long the call or the write took inside the game, measured around it there: the round trip to the game is a second or more, so timing from outside measures that instead. A call that takes longer than timeoutMs is not cancelled: the answer is pending: true with a requestId, the call goes on and does everything it was asked, and op result with that requestId collects its reply once it comes.",
     parameters: {
       projectPath: RUNNING_PROJECT_PATH,
       pid: RUNNING_PID,
@@ -34539,6 +34539,17 @@ class GodotServer {
     const nearest = descendantsIn(tree, root).filter((pid) => isEngine(pid) && !ancestorsIn(tree, pid, root).some((one) => one !== root && isEngine(one)));
     return nearest.length === 1 ? nearest[0] : undefined;
   }
+  async editorIsScanningOrImporting() {
+    if (!this.godotBridge.isConnected()) {
+      return false;
+    }
+    try {
+      const status = asParams(await this.godotBridge.invokeTool("scan_status", {}));
+      return status["scanning"] === true || status["importing"] === true;
+    } catch {
+      return false;
+    }
+  }
   async handleRescanFilesystem(args) {
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 30000;
     const started = Date.now();
@@ -34548,9 +34559,26 @@ class GodotServer {
     const blind = await this.classesTheEditorCannotSee(args);
     const atRisk = before === null ? [] : blind.unseen.filter((one) => before.has(one.className));
     const ghosts = blind.stillHeld ?? [];
-    const first = await this.handleViaBridge("rescan_filesystem", args);
-    if (first.isError) {
-      return first;
+    let waitedForEditorMs = 0;
+    let first;
+    for (;; ) {
+      const busySince = Date.now();
+      let wasBusy = false;
+      while (Date.now() - started < timeoutMs && await this.editorIsScanningOrImporting()) {
+        wasBusy = true;
+        await new Promise((settle) => setTimeout(settle, 100));
+      }
+      if (wasBusy) {
+        waitedForEditorMs += Date.now() - busySince;
+      }
+      first = await this.handleViaBridge("rescan_filesystem", args);
+      if (first.isError) {
+        return first;
+      }
+      const declined = asParams(JSON.parse(first.content[0]?.text ?? "{}"))["started"] === false;
+      if (!declined || Date.now() - started >= timeoutMs) {
+        break;
+      }
     }
     let busy = true;
     while (busy && Date.now() - started < timeoutMs) {
@@ -34609,6 +34637,7 @@ class GodotServer {
       ok: !busy && unseen.length === 0 && stillGone.length === 0 && stillAtMissingPaths.length === 0 && checked.unchecked === undefined,
       stillWorking: busy,
       waitedMs: Date.now() - started,
+      waitedForEditorScanMs: waitedForEditorMs > 0 ? waitedForEditorMs : undefined,
       heldBeforeReload: reloaded.heldBefore,
       reloadedMethods: reloaded.methods,
       reloadProblem: reloaded.problem,

package/package.json

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