gdharness 1.3.37 → 1.3.38

package/build/cli.js

@@ -16657,7 +16657,7 @@ var init_tool_definitions = __esm(() => {
         direction: {
           type: "string",
           enum: ["forward", "reverse"],
-          description: "forward: what this resource loads, with each reference closing a cycle marked circular and the cycle under circular_references, a script's dependencies including every script whose class_name it uses, marked by_class with the name, and the script of every autoload it names, marked by_autoload with the autoload's name. An ext_resource whose uid names another file than its path is followed to that file, as the engine loads it, with the path written under stale_path, and a shader's #include is followed as the preprocessor reads it, relative to the shader. A file the depth stops at carries beyond_depth, how many files it names that were not walked. summary.total_resources is the file asked about, so 1; total_dependencies counts each file reached, directly or through another, once however many places load it; total_references counts the entries in the tree, and missing names every file referenced that does not exist, with the files referring to it. reverse: every file that refers to it and how, for a file that is gone as well while anything still refers to it, answered with exists: false (a missing file nothing refers to is refused, naming the nearest files), a scene instancing it, a script extending, preloading or loading it, and for a script with a class_name every use of that name, and for an autoload's script every use of the autoload's name, with autoload naming it. Each reference carries a kind: ext_resource, extends, preload, load, include or path for a reference by path, with stale_path when an ext_resource reaches it by its uid under another path; setting, plugin, export_preset and import for one in project.godot, a plugin.cfg, export_presets.cfg or an import sidecar; class_name for a use of the declared name, the declaration itself being the script asked about; autoload for code naming the autoload. Three kinds are not uses: doc is a name inside a ## documentation comment, which renaming would break in the generated docs; comment is one in ordinary prose, which it would only make stale; and stale_path is an ext_resource naming it by a path the engine does not load, since its uid leads to the file under loads. summary.in_code is the count with those left out, which is the number to read when the question is whether anything still uses this. Default forward."
+          description: "forward: what this resource loads, with each reference closing a cycle marked circular and the cycle under circular_references, a script's dependencies including every script whose class_name it uses, marked by_class with the name, and the script of every autoload it names, marked by_autoload with the autoload's name. An ext_resource whose uid names another file than its path is followed to that file, as the engine loads it, with the path written under stale_path; one whose uid names no file the project has is followed by its path, as the engine does after warning, with the uid under unknown_uid; and a load or preload of a uid the project does not know is listed under that uid as missing. A shader's #include is followed as the preprocessor reads it, relative to the shader. A file the depth stops at carries beyond_depth, how many files it names that were not walked. summary.total_resources is the file asked about, so 1; total_dependencies counts each file reached, directly or through another, once however many places load it; total_references counts the entries in the tree, and missing names every file referenced that does not exist, with the files referring to it. reverse: every file that refers to it and how, for a file that is gone as well while anything still refers to it, answered with exists: false (a missing file nothing refers to is refused, naming the nearest files), a scene instancing it, a script extending, preloading or loading it, and for a script with a class_name every use of that name, and for an autoload's script every use of the autoload's name, with autoload naming it. Each reference carries a kind: ext_resource, extends, preload, load, include or path for a reference by path, with stale_path when an ext_resource reaches it by its uid under another path, and unknown_uid when one names it by path beside a uid naming no file; setting, plugin, export_preset and import for one in project.godot, a plugin.cfg, export_presets.cfg or an import sidecar; class_name for a use of the declared name, the declaration itself being the script asked about; autoload for code naming the autoload. Three kinds are not uses: doc is a name inside a ## documentation comment, which renaming would break in the generated docs; comment is one in ordinary prose, which it would only make stale; and stale_path is an ext_resource naming it by a path the engine does not load, since its uid leads to the file under loads. summary.in_code is the count with those left out, which is the number to read when the question is whether anything still uses this. Default forward."
         },
         depth: { type: "number", description: "forward: how many levels to follow. Default unlimited." },
         includeBuiltin: {
@@ -16676,7 +16676,7 @@ var init_tool_definitions = __esm(() => {
       name: "project_import",
       title: "Asset imports",
       description: "The import pipeline: what needs importing, how a resource is imported, reimports, UIDs, and the global class list the editor and the engine read.",
-      answer: "reimport is answered from a second status read: reimported lists what is current now, notReimported what is not, one entry per status and reason with the paths sharing them, and via says which of the two did the work. importedByTheScan names what the editor's scan imported first, and alsoImported, on a reimport of one resourcePath, the others it imported. wroteInProject names, by source, what an import wrote into the project itself rather than under .godot, such as the .translation a CSV gives each language, which version control sees and internationalization/locale/translations names. When nothing needed reimporting, the two lists are empty, a note says so, and there is no via. A whole-project reimport also answers missingSource, the .import files whose source is not beside them, empty when there are none, even when nothing needed reimporting; one resourcePath leaves it out. stillImporting is an editor that had not finished within timeoutMs.",
+      answer: "reimport is answered from a second status read: reimported lists what is current now, notReimported what is not, one entry per status and reason with the paths sharing them, and via says which of the two did the work. importedByTheScan names what the editor's scan imported first, and alsoImported, on a reimport of one resourcePath, the others it imported. wroteInProject names, by source, what an import wrote into the project itself rather than under .godot, such as the .translation a CSV gives each language, which version control sees and internationalization/locale/translations names. The import gives every script without a .uid sidecar one, as the editor's scan does, and uidsWritten names those scripts, counted per addon under uidsWrittenInAddons for the ones inside an addon. When nothing needed reimporting, the two lists are empty, a note says so, and there is no via. A whole-project reimport also answers missingSource, the .import files whose source is not beside them, empty when there are none, even when nothing needed reimporting; one resourcePath leaves it out. stillImporting is an editor that had not finished within timeoutMs.",
       parameters: {
         projectPath: PROJECT_PATH,
         resourcePath: { ...RESOURCE_PATH, ops: ["status", "options", "set_options", "uid", "reimport"] },
@@ -17343,7 +17343,7 @@ var init_tool_definitions = __esm(() => {
       operations: {
         structure: {
           effect: "read",
-          summary: "functions, variables (static ones marked is_static; one written with := has the type of a literal or built-in constructor it is given, marked inferred, as a constant always does), signals, constants, enums, inner_classes (each with its name, line and extends, and its own members in these same fields), class_name, extends and line_count, read from the file, and dependencies: the paths it loads or preloads as written, then the scripts declaring each project class_name its code uses, which classes_used names with the class; autoloads_used names each autoload the code uses by its global name, with the autoload's script, which the project loads rather than this script, so it is not under dependencies. A member or inner class with a ## documentation comment directly above it carries the comment's text as doc, and the script's own, the ## block above class_name or extends or one followed by a blank line before any member, comes back as class_doc",
+          summary: `functions (each parameter's default the source text after its =, so = null reads "null", and null for a parameter with none), variables (static ones marked is_static; one written with := has the type of a literal or built-in constructor it is given, marked inferred, as a constant always does), signals, constants, enums, inner_classes (each with its name, line and extends, and its own members in these same fields), class_name, extends and line_count, read from the file, and dependencies: the paths it loads or preloads as written, then the scripts declaring each project class_name its code uses, which classes_used names with the class; autoloads_used names each autoload the code uses by its global name, with the autoload's script, which the project loads rather than this script, so it is not under dependencies. A member or inner class with a ## documentation comment directly above it carries the comment's text as doc, and the script's own, the ## block above class_name or extends or one followed by a blank line before any member, comes back as class_doc`,
           requires: []
         },
         symbols: {
@@ -18077,7 +18077,7 @@ var init_tool_definitions = __esm(() => {
       name: "runtime_input",
       title: "Send input to the game",
       description: "Input to the running game: a whole click on a Control or a 3D node named by path or on a control named by the words on it, an item chosen out of a menu, typing into whatever has the focus, or a raw action, key, mouse button, mouse motion or drag. All of it works headless, where the viewport is the project's window size and the GUI only takes what is inside it. On gdharness's own desktop, where a windowed run goes, Windows refuses to say where the pointer is: every pointer answer there carries pointer_on_hidden_desktop, and the first of the run pointer_note saying why it matters: get_mouse_position() on the root window, and the mouse positions derived from it, read a meaningless position, while what reads the event itself (the control under it, hover, tooltips, input handlers) gets the injected position. A native window no real pointer has entered gets no hover from Godot, so the runtime supplies it there and the answers say hover_supplied.",
-      answer: `click: what was under the pointer, and what became of the control: in_tree, removed or freed. A button answers pressed_signal, whether its pressed signal fired during the click. Named by says, found says which match it was, its index being the index argument that presses the same match again, found.item names the tab, list entry, tree row or menu bar title pressed (kind; index, the item's own number in its control, which is not found.index; says; and for a row the column of the cell saying the words), and found.pressedOn says "the words" for words in a RichTextLabel pressed where they are drawn, or "the middle of the label" with a note saying why they could not be placed; on a rich label link_pressed says whether the press reached a link, with link_meta giving the meta the label reports clicked, an empty one included. A control scrolled into view first is scrolled each container out from it a frame after the one inside, and scrolled_into_view says whether a scroll value changed. A button in toggle mode, a CheckBox or CheckButton included, answers pressed with before and after, its button_pressed either side of the click: the same value twice is a click the game undid, and after is null when the click freed it. A refusal for a pointer turned off names where mouse_behavior_recursive was set. On a 3D node landed says the interface did not swallow the press: no control under the pointer stopped it, a control letting the pointer pass included, and every viewport on the way out from the room had the pointer over what shows the room. choose: what was chosen, read before the press, which is heard rather than assumed; what became of the control named (in_tree, removed or freed, since a game can rebuild its screen on the pick); and what the button in front of the menu shows now when it is still there. A menu is opened rather than clicked because its items are drawn rather than built, and the item is looked for as the menu stands once open, since a game can fill a menu as it opens. action, key, mouse_click and joypad_button: the event as it was sent, with whole saying whether the press was let go of again and pressed whether it is left held down (true only after pressed true), for a key the keycode, physical_keycode and unicode it carried, and for a controller button its number, its name and the device. mouse_motion: the position and the relative movement sent. mouse_drag: from, to, motions sent and relative_total. joypad_motion: the axis by number and name, the value and the device. key, mouse_click, click, joypad_button and joypad_motion answer actions, the InputMap actions the event also presses; for a motion, those its direction reaches past their deadzone, and none for one inside it. mouse_click, mouse_motion and mouse_drag answer hovered, the control under the pointer once the events are handled, or null over none; the other events are aimed at nothing. mouse_click with a press, and mouse_drag, answer press_went_to, the path of what the press went to (a control, or a window embedded over the point), read before it, or null when nothing there takes the pointer; given nodePath naming a Control, landed says whether that is the control or inside it. A click that did not land on a control whose mouse_filter is ignore, as a Label's is, says so under why_not_landed, and one on a control with something drawn over it names that, a window stacked above the one the control is in among them. An action, a key, a joypad_button or a joypad_motion answers focused with the path of the Control holding the keyboard focus when it went in, since that Control gets it before the game's _unhandled_input: Space or Enter on a focused button presses the button, and a stick or dpad pressing ui_down moves a focused list's selection, or the focus, and never reaches the game's handler. Where the press moved the focus, focused_after names the Control holding it once the event was handled, or null when nothing does. A mouse_click, mouse_motion or mouse_drag given nodePath answers it under path, its points in the pixels of the window they went to, and that window under window when it is not the game's own. One with a point outside the viewport it went to says so under outside_viewport, with the viewport's rectangle, since no control there receives it.`,
+      answer: `click: what was under the pointer, and what became of the control: in_tree, removed or freed. A button answers pressed_signal, whether its pressed signal fired during the click. Named by says, found says which match it was, its index being the index argument that presses the same match again, found.item names the tab, list entry, tree row or menu bar title pressed (kind; index, the item's own number in its control, which is not found.index; says; and for a row the column of the cell saying the words), and found.pressedOn says "the words" for words in a RichTextLabel pressed where they are drawn, or "the middle of the label" with a note saying why they could not be placed; on a rich label link_pressed says whether the press reached a link, with link_meta giving the meta the label reports clicked, an empty one included. A control scrolled into view first is scrolled each container out from it a frame after the one inside, and scrolled_into_view says whether a scroll value changed. A button in toggle mode, a CheckBox or CheckButton included, answers pressed with before and after, its button_pressed either side of the click: the same value twice is a click the game undid, and after is null when the click freed it. A refusal for a pointer turned off names where mouse_behavior_recursive was set. On a 3D node landed says the interface did not swallow the press: no control under the pointer stopped it, a control letting the pointer pass included, and every viewport on the way out from the room had the pointer over what shows the room. choose: what was chosen, read before the press, which is heard rather than assumed; what became of the control named (in_tree, removed or freed, since a game can rebuild its screen on the pick); and what the button in front of the menu shows now when it is still there. A menu is opened rather than clicked because its items are drawn rather than built, and the item is looked for as the menu stands once open, since a game can fill a menu as it opens. action, key, mouse_click and joypad_button: the event as it was sent, with whole saying whether the press was let go of again and pressed whether it is left held down (true only after pressed true), for a key the keycode, physical_keycode and unicode it carried, and for a controller button its number, its name and the device. mouse_motion: the position and the relative movement sent. mouse_drag: from, to, motions sent and relative_total. joypad_motion: the axis by number and name, the value and the device. key, mouse_click, click, joypad_button and joypad_motion answer actions, the InputMap actions the event also presses; for a motion, those its direction reaches past their deadzone, and none for one inside it. mouse_click, mouse_motion and mouse_drag answer hovered, the control under the pointer once the events are handled, or null over none; the other events are aimed at nothing. mouse_click with a press, and mouse_drag, answer press_went_to, the path of what the press went to (a control, or a window embedded over the point), read before it, or null when nothing there takes the pointer; given nodePath naming a Control, landed says whether that is the control or inside it. A click that did not land on a control whose mouse_filter is ignore, as a Label's is, says so under why_not_landed, and one on a control with something drawn over it names that, a window stacked above the one the control is in among them. An action, a key, a joypad_button or a joypad_motion answers focused with the path of the Control holding the keyboard focus when it went in, since that Control gets it before the game's _unhandled_input: Space or Enter on a focused button presses the button, and a stick or dpad pressing ui_down moves a focused list's selection, or the focus, and never reaches the game's handler. Where the press moved the focus, focused_after names the Control holding it once the event was handled, or null when nothing does. A key that a focused LineEdit or TextEdit took as typing names that field under typed_into, with what it holds under holds, since a field being edited keeps the key from the game's _unhandled_input. editing_ended true, on a key or on text, is a LineEdit that stopped being edited, as Enter does by submitting it: it keeps the focus, and nothing typed into it lands until it is clicked again. text with the focus on a control that is no LineEdit or TextEdit answers holds null and a note saying so, since a focused button takes a space or Enter as a press. A mouse_click, mouse_motion or mouse_drag given nodePath answers it under path, its points in the pixels of the window they went to, and that window under window when it is not the game's own. One with a point outside the viewport it went to says so under outside_viewport, with the viewport's rectangle, since no control there receives it.`,
       parameters: {
         projectPath: RUNNING_PROJECT_PATH,
         pid: RUNNING_PID,
@@ -51932,8 +51932,18 @@ class GodotServer {
     if (!contained.ok) {
       return contained.response;
     }
+    const unminted = scriptsWithoutUid(project.value.path);
     const outcome = await this.reimport(project.value.path, readNonEmptyString(contained.value, "resourcePath"), args["force"] === true, readPositiveNumber(args, "timeoutMs") ?? REIMPORT_TIMEOUT_MS);
-    return outcome.ok ? this.jsonTextResponse(outcome.payload) : outcome.response;
+    if (!outcome.ok) {
+      return outcome.response;
+    }
+    const stillUnminted = scriptsWithoutUid(project.value.path);
+    const uids = withAddonPathsCounted(unminted.filter((script) => !stillUnminted.includes(script)).map((script) => `res://${script}`));
+    return this.jsonTextResponse({
+      ...outcome.payload,
+      ...uids.own.length === 0 ? {} : { uidsWritten: uids.own },
+      ...Object.keys(uids.inAddons).length === 0 ? {} : { uidsWrittenInAddons: uids.inAddons }
+    });
   }
   editorHasOpen(projectPath) {
     const open = this.godotBridge.getStatus().projectPath;

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

@@ -296,6 +296,7 @@ static func _misfit(source: Node, signal_name: String, callable: Callable, flags
 	if flags & Object.CONNECT_APPEND_SOURCE_OBJECT:
 		passed.append({"name": "source", "type": TYPE_OBJECT, "class_name": source.get_class()})
 	passed = passed.slice(0, maxi(passed.size() - callable.get_unbound_arguments_count(), 0))
+	var from_signal: int = passed.size()
 	for bound: Variant in callable.get_bound_arguments():
 		var bound_class: String = ""
 		if bound is Object:
@@ -310,7 +311,25 @@ static func _misfit(source: Node, signal_name: String, callable: Callable, flags
 		return "%s passes %s, and %s needs %d%s" % [signal_name, _count(passed.size()), method, needed, FAILS]
 	if passed.size() > parameters.size():
 		var most: String = "none" if parameters.is_empty() else "at most %d" % parameters.size()
-		return "%s passes %s, and %s takes %s%s" % [signal_name, _count(passed.size()), method, most, FAILS]
+		# Said with the misfit, since unbinds is what a connection to a method wanting less is for, and
+		# only when the extra arguments are the signal's: a bound one is not dropped by unbinding.
+		var extra: int = passed.size() - parameters.size()
+		var remedy: String = (
+			(
+				" Connected with unbinds %d, the last %s the signal passes %s left out."
+				% [
+					extra + callable.get_unbound_arguments_count(),
+					"argument" if extra == 1 else "%d arguments" % extra,
+					"is" if extra == 1 else "are",
+				]
+			)
+			if extra <= from_signal
+			else ""
+		)
+		return (
+			"%s passes %s, and %s takes %s%s%s"
+			% [signal_name, _count(passed.size()), method, most, FAILS, remedy]
+		)
 	for at: int in passed.size():
 		var given: Dictionary = passed[at]
 		var parameter: Dictionary = parameters[at]

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

@@ -16,6 +16,8 @@ const GdhItems = preload("runtime_items.gd")
 const GdhScreen = preload("runtime_screen.gd")
 const GdhTargets = preload("runtime_targets.gd")
 const GdhMouse = preload("runtime_mouse.gd")
+const GdhTyping = preload("runtime_typing.gd")
+const GdhSays = preload("runtime_says.gd")
 
 ## 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.
@@ -276,6 +278,8 @@ func inject_key(params: Dictionary) -> Dictionary:
 	event.unicode = GdhValues.glyph_of(event.keycode, event.shift_pressed)
 
 	var focused: String = GdhValues.focus_path(_host)
+	var field: Control = GdhTyping.focus_owner(_host.get_tree().root)
+	var before: Dictionary = GdhTyping.field_before(field)
 	Input.parse_input_event(event)
 	var lasted: Variant = null
 	if whole:
@@ -300,7 +304,7 @@ func inject_key(params: Dictionary) -> Dictionary:
 		"pressed": held and not whole,
 		"whole": whole,
 	}
-	return GdhValues.focus_noted(answer, focused, _host)
+	return GdhTyping.field_noted(GdhValues.focus_noted(answer, focused, _host), field, before)
 
 
 ## Clicks a mouse button at a position, and lets go of it again unless asked to hold it.
@@ -601,7 +605,7 @@ func click(params: Dictionary) -> Dictionary:
 		item_scrolled = placed_item["scrolled"]
 	var rich: RichTextLabel = control as RichTextLabel
 	if found != null and rich != null and named_point == null:
-		var placed: Dictionary = GdhTargets.point_on_words(rich, wanted)
+		var placed: Dictionary = GdhSays.point_on_words(rich, wanted)
 		var found_here: Dictionary = found
 		if placed.has("point"):
 			aim = placed["point"]

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

@@ -170,3 +170,57 @@ static func widened(wanted: String) -> String:
 ## an n, so the two characters mean the break to everybody who writes them.
 static func as_said(wanted: String) -> String:
 	return spaced(wanted.replace("\\n", "\n"))
+
+
+## Where [param label] draws the words [param wanted] matched in it, in the label's own space, when
+## they are part of its text: {"point"} on their middle, {"unplaced"} saying why there is none, or
+## {} when the words are the whole text, whose middle is the label's.
+##
+## A line of a dispatch names two people, each a link to their page, and a press on the label's
+## middle landed on the second name when the first was asked for, so the game opened the wrong page.
+## Godot answers which line a character is on, where that line is and how wide it is drawn, and
+## nothing narrower, so the place along the line is the font's measure of the text before the
+## words. A line in another font or holding an image measures off from what is drawn, which a wide
+## line with nothing between the words and its start hardly does.
+static func point_on_words(label: RichTextLabel, wanted: String) -> Dictionary:
+	var text: String = spaced(GdhWords.said_by(label))
+	var start: int = -1
+	var length: int = 0
+	for words: String in alternatives(wanted):
+		if not is_plain(words):
+			continue
+		var at: int = text.findn(words)
+		if at >= 0 and (start < 0 or at < start):
+			start = at
+			length = words.length()
+	if start < 0:
+		return {"unplaced": "the words were matched as a pattern, which names no one place in the text"}
+	if text.strip_edges().length() == length:
+		return {}
+	var line: int = label.get_character_line(start)
+	var shown: Vector2i = label.get_line_range(line)
+	if line < 0 or shown.x > start:
+		return {"unplaced": "the label could not say which line the words are on"}
+	var on_line: int = mini(length, shown.y - start) if shown.y > start else length
+	var font: Font = label.get_theme_font("normal_font")
+	var font_size: int = label.get_theme_font_size("normal_font_size")
+	var before: float = _width(font, font_size, text.substr(shown.x, start - shown.x))
+	var across: float = _width(font, font_size, text.substr(start, on_line))
+	var frame: StyleBox = label.get_theme_stylebox("normal")
+	var left: float = frame.get_margin(SIDE_LEFT)
+	var room: float = label.size.x - left - frame.get_margin(SIDE_RIGHT)
+	var spare: float = maxf(room - label.get_line_width(line), 0.0)
+	var aligned: float = 0.0
+	if label.horizontal_alignment == HORIZONTAL_ALIGNMENT_CENTER:
+		aligned = spare * 0.5
+	elif label.horizontal_alignment == HORIZONTAL_ALIGNMENT_RIGHT:
+		aligned = spare
+	var scrolled: float = label.get_v_scroll_bar().value if label.scroll_active else 0.0
+	var x: float = clampf(left + aligned + before + across * 0.5, left, left + room)
+	var top: float = frame.get_margin(SIDE_TOP) + label.get_line_offset(line) - scrolled
+	return {"point": Vector2(x, top + label.get_line_height(line) * 0.5)}
+
+
+## How wide [param font] at [param font_size] draws [param words] on one line.
+static func _width(font: Font, font_size: int, words: String) -> float:
+	return font.get_string_size(words, HORIZONTAL_ALIGNMENT_LEFT, -1, font_size).x

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

@@ -12,6 +12,8 @@ const GdhWords = preload("runtime_words.gd")
 
 ## How many of the controls saying the same words a refusal names, with the index for each.
 const LISTED_CANDIDATES: int = 10
+## How many hidden controls saying the words a refusal names.
+const NAMED_HIDDEN: int = 3
 
 ## Node.ProcessMode as its names, for a refusal to say which one is in force.
 const PROCESS_MODES: Dictionary[int, String] = {
@@ -63,7 +65,7 @@ static func control_saying(root: Node, root_path: String, wanted: String, which:
 	var exact: Array[bool] = []
 	# Whether the words are only inside longer words there, "out" in "Scout".
 	var inside: Array[bool] = []
-	var hidden: int = 0
+	var hidden: Array[Node] = []
 	# Controls saying exactly the words that a click cannot reach, kept to say what a match on screen
 	# that only says them as part of more stands in for.
 	var exact_out_of_reach: Array[Node] = []
@@ -77,7 +79,7 @@ static func control_saying(root: Node, root_path: String, wanted: String, which:
 		var node: Node = pending.pop_front()
 		if node is Control and GdhSays.says(node, wanted):
 			if not GdhQueries.shown(node):
-				hidden += 1
+				hidden.append(node)
 				if _says_exactly(GdhWords.said_by(node), wanted):
 					exact_out_of_reach.append(node)
 					out_of_reach_as.append("hidden")
@@ -451,10 +453,21 @@ static func _offered_note(from: Node, drawn: Array[Node], areas: Array[Rect2]) -
 	return "" if words.is_empty() else "; the buttons on screen say %s" % words
 
 
-static func _hidden_note(hidden: int) -> String:
-	if hidden == 0:
+## What to add to a refusal that found nothing on screen, when words matched hidden controls: how
+## many, and the first few by path with what hides each. A count alone left a caller with nothing to
+## show, since the control saying the words is rarely the node a game hides.
+static func _hidden_note(hidden: Array[Node]) -> String:
+	if hidden.is_empty():
 		return ""
-	return "; %d hidden control%s" % [hidden, " says it" if hidden == 1 else "s say it"]
+	var named: Array[String] = []
+	for node: Node in hidden.slice(0, NAMED_HIDDEN):
+		named.append("%s%s" % [node.get_path(), why_hidden(node)])
+	if hidden.size() == 1:
+		return "; 1 hidden control says it, %s" % named[0]
+	return (
+		"; %d hidden controls say it, among them %s and %s"
+		% [hidden.size(), ", ".join(named.slice(0, -1)), named[-1]]
+	)
 
 
 ## What to add to a refusal that found nothing on screen, when words matched controls a click cannot
@@ -870,60 +883,6 @@ static func _clipped_away(
 	return false
 
 
-## Where [param label] draws the words [param wanted] matched in it, in the label's own space, when
-## they are part of its text: {"point"} on their middle, {"unplaced"} saying why there is none, or
-## {} when the words are the whole text, whose middle is the label's.
-##
-## A line of a dispatch names two people, each a link to their page, and a press on the label's
-## middle landed on the second name when the first was asked for, so the game opened the wrong page.
-## Godot answers which line a character is on, where that line is and how wide it is drawn, and
-## nothing narrower, so the place along the line is the font's measure of the text before the
-## words. A line in another font or holding an image measures off from what is drawn, which a wide
-## line with nothing between the words and its start hardly does.
-static func point_on_words(label: RichTextLabel, wanted: String) -> Dictionary:
-	var text: String = GdhSays.spaced(GdhWords.said_by(label))
-	var start: int = -1
-	var length: int = 0
-	for words: String in GdhSays.alternatives(wanted):
-		if not GdhSays.is_plain(words):
-			continue
-		var at: int = text.findn(words)
-		if at >= 0 and (start < 0 or at < start):
-			start = at
-			length = words.length()
-	if start < 0:
-		return {"unplaced": "the words were matched as a pattern, which names no one place in the text"}
-	if text.strip_edges().length() == length:
-		return {}
-	var line: int = label.get_character_line(start)
-	var shown: Vector2i = label.get_line_range(line)
-	if line < 0 or shown.x > start:
-		return {"unplaced": "the label could not say which line the words are on"}
-	var on_line: int = mini(length, shown.y - start) if shown.y > start else length
-	var font: Font = label.get_theme_font("normal_font")
-	var font_size: int = label.get_theme_font_size("normal_font_size")
-	var before: float = _width(font, font_size, text.substr(shown.x, start - shown.x))
-	var across: float = _width(font, font_size, text.substr(start, on_line))
-	var frame: StyleBox = label.get_theme_stylebox("normal")
-	var left: float = frame.get_margin(SIDE_LEFT)
-	var room: float = label.size.x - left - frame.get_margin(SIDE_RIGHT)
-	var spare: float = maxf(room - label.get_line_width(line), 0.0)
-	var aligned: float = 0.0
-	if label.horizontal_alignment == HORIZONTAL_ALIGNMENT_CENTER:
-		aligned = spare * 0.5
-	elif label.horizontal_alignment == HORIZONTAL_ALIGNMENT_RIGHT:
-		aligned = spare
-	var scrolled: float = label.get_v_scroll_bar().value if label.scroll_active else 0.0
-	var x: float = clampf(left + aligned + before + across * 0.5, left, left + room)
-	var top: float = frame.get_margin(SIDE_TOP) + label.get_line_offset(line) - scrolled
-	return {"point": Vector2(x, top + label.get_line_height(line) * 0.5)}
-
-
-## How wide [param font] at [param font_size] draws [param words] on one line.
-static func _width(font: Font, font_size: int, words: String) -> float:
-	return font.get_string_size(words, HORIZONTAL_ALIGNMENT_LEFT, -1, font_size).x
-
-
 ## The canvas layer [param control] is drawn on, 0 for the viewport's own canvas.
 static func _layer_of(control: Control) -> int:
 	var layer: CanvasLayer = control.get_canvas_layer_node()

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

@@ -59,6 +59,7 @@ func inject_text(params: Dictionary) -> Dictionary:
 	if focused != null:
 		into = str(focused.get_path())
 
+	var before: Dictionary = field_before(focused)
 	var replaced: bool = over and _select_everything(focused)
 	# Emptying a field is a real thing to ask for and the one shape of filling one in that types no
 	# characters. The selection is standing, so the key a player presses over one is what clears it.
@@ -70,7 +71,7 @@ func inject_text(params: Dictionary) -> Dictionary:
 	var holds: Variant = null
 	if is_instance_valid(focused):
 		holds = _what_it_holds(focused)
-	return {
+	var answer: Dictionary = {
 		"type": "input_injected",
 		"input_type": "text",
 		"text": text,
@@ -79,6 +80,61 @@ func inject_text(params: Dictionary) -> Dictionary:
 		"replaced": replaced,
 		"holds": holds,
 	}
+	if ended_editing(focused, before):
+		answer["editing_ended"] = true
+	# A control drawing its own field takes characters in its gui_input, so typing at one is not
+	# refused; but a focused button answered that the text went into it, which read as typed.
+	if into != null and before.is_empty():
+		answer["note"] = (
+			(
+				"%s has the focus and is no LineEdit or TextEdit, so each character reached it as a key"
+				+ " press and went on to the game's input unless it kept it, and a focused button takes a"
+				+ " space or Enter as a press of it. Click a field first to type into one."
+			)
+			% into
+		)
+	return answer
+
+
+## What [param focused] says and whether it is being edited, read before keys go in, for
+## [method field_noted] and [method ended_editing] to compare with; empty where the focus is no
+## field. A [TextEdit] has no editing state of its own and counts as always edited.
+static func field_before(focused: Control) -> Dictionary:
+	var field: LineEdit = focused as LineEdit
+	if field != null:
+		return {"text": field.text, "editing": field.is_editing()}
+	var box: TextEdit = focused as TextEdit
+	if box != null:
+		return {"text": box.text, "editing": true}
+	return {}
+
+
+## Whether [param focused], read as [param before], stopped being edited, as a [LineEdit] does when
+## it is submitted: it keeps the focus and drops every key after, so a caller reading only the focus
+## typed next into nothing.
+static func ended_editing(focused: Control, before: Dictionary) -> bool:
+	var was: bool = before.get("editing", false)
+	if not was or not is_instance_valid(focused):
+		return false
+	var field: LineEdit = focused as LineEdit
+	return field != null and not field.is_editing()
+
+
+## [param said] with what a key did to [param focused], the field read before it as [param before]:
+## typed_into and holds where its text changed, and editing_ended where it stopped being edited. A
+## field being edited takes a printable key as typing and keeps it from the game's _unhandled_input,
+## so Space into a name field pressed no jump, and an answer naming only the focus did not say why.
+static func field_noted(said: Dictionary, focused: Control, before: Dictionary) -> Dictionary:
+	if before.is_empty() or not is_instance_valid(focused):
+		return said
+	var field: LineEdit = focused as LineEdit
+	var now: String = field.text if field != null else (focused as TextEdit).text
+	if now != before["text"]:
+		said["typed_into"] = str(focused.get_path())
+		said["holds"] = _what_it_holds(focused)
+	if ended_editing(focused, before):
+		said["editing_ended"] = true
+	return said
 
 
 ## The control keys pushed into [param viewport] go to: its focus, or the focus of the window

package/build/godot/operations/dependencies.gd

@@ -82,6 +82,8 @@ func get_dependencies(params: Dictionary) -> Dictionary:
 	var full_path: String = resource_path
 	if not full_path.begins_with("res://"):
 		full_path = "res://" + full_path
+	if DirAccess.dir_exists_absolute(full_path):
+		return _log.failure(_folder_refusal(full_path))
 	if not FileAccess.file_exists(full_path):
 		return _log.failure(
 			_files.with_nearest_files("Resource file does not exist: " + full_path, full_path)
@@ -193,6 +195,11 @@ func _loaded_and_missing(script: String) -> Array[String]:
 				named[path] = true
 	var missing: Array[String] = []
 	for path: String in loaded:
+		# Left as written by the resolution, which is a uid the project does not know.
+		if path.begins_with("uid://"):
+			if not named.has(path) and not missing.has(path):
+				missing.append(path)
+			continue
 		if not path.begins_with("res://") or path.begins_with("res://.") or path.get_extension().is_empty():
 			continue
 		if not named.has(path) and not FileAccess.file_exists(path) and not missing.has(path):
@@ -217,6 +224,15 @@ static func _named_by_settings() -> Array[String]:
 	return named
 
 
+## The refusal for [param path], a folder: a walk follows one file, and a folder was refused as a
+## file that does not exist, about a folder the caller could see.
+static func _folder_refusal(path: String) -> String:
+	return (
+		"%s is a folder, and project_dependencies follows one file: name a file in it."
+		% path.trim_suffix("/")
+	)
+
+
 ## One line for [param entry], one of [method missing_references].
 static func missing_line(entry: Dictionary) -> String:
 	var referring: Array = entry.get("referenced_by", [])
@@ -235,6 +251,8 @@ func find_resource_usages(params: Dictionary) -> Dictionary:
 
 	if not resource_path.begins_with("res://"):
 		resource_path = "res://" + resource_path
+	if DirAccess.dir_exists_absolute(resource_path):
+		return _log.failure(_folder_refusal(resource_path))
 	# A file that is gone is searched for all the same, since what still refers to it is what a
 	# caller asks about one, and the forward walk of a scene had just named it missing. Refused only
 	# when nothing refers to it either, which is a path written wrong.
@@ -331,6 +349,11 @@ func find_resource_usages(params: Dictionary) -> Dictionary:
 				kind = _path_reference_kind(line, file_path)
 				if not loaded.is_empty() and written_path != loaded:
 					extra["stale_path"] = written_path
+				var unknown_uid: String = (
+					_unknown_uid_of(line) if trimmed.begins_with("[ext_resource") else ""
+				)
+				if not unknown_uid.is_empty():
+					extra["unknown_uid"] = unknown_uid
 			elif by_its_autoload:
 				kind = "autoload"
 			else:
@@ -570,6 +593,7 @@ func _analyze_resource(path: String, current_depth: int, walk: GdhDependencyWalk
 		elif path.get_extension() in SHADER_KINDS:
 			content = _shader_code(content)
 		var moved: Dictionary = _moved_by_uid(content)
+		var unknown: Dictionary = _unknown_uids(content, path)
 
 		for pattern: String in REFERENCE_PATTERNS:
 			var regex: RegEx = GdhPatterns.compiled(pattern)
@@ -577,6 +601,12 @@ func _analyze_resource(path: String, current_depth: int, walk: GdhDependencyWalk
 				var written: String = _resolved(_referenced_path(m.get_string()), path)
 				var dep_path: String = str(moved.get(written, written))
 
+				# A uid the project does not know names no file, and loading it fails: passed over as
+				# no res:// path, a script's load of one went unsaid while the game printed
+				# "Unrecognized UID" at that line.
+				if dep_path.begins_with("uid://"):
+					_depend(deps, path, dep_path, {}, current_depth, walk)
+					continue
 				if not dep_path.begins_with("res://"):
 					continue
 				# A literal naming a directory, or the start of a path a script builds as it runs
@@ -590,14 +620,10 @@ func _analyze_resource(path: String, current_depth: int, walk: GdhDependencyWalk
 				if not walk.include_built_in and dep_path.begins_with("res://."):
 					continue
 
-				_depend(
-					deps,
-					path,
-					dep_path,
-					{"stale_path": written} if dep_path != written else {},
-					current_depth,
-					walk
-				)
+				var named_by: Dictionary = {"stale_path": written} if dep_path != written else {}
+				if unknown.has(dep_path):
+					named_by["unknown_uid"] = unknown[dep_path]
+				_depend(deps, path, dep_path, named_by, current_depth, walk)
 
 		# A script uses another by its class_name as surely as by a preload, and only the reverse walk
 		# looked for that: asked what a script depends on, the answer left out the script it typed a
@@ -633,7 +659,11 @@ func _depend(
 	for existing: Dictionary in deps:
 		if existing.get("path", "") == dep_path:
 			return
-	var dep_info: Dictionary = {"path": dep_path, "exists": FileAccess.file_exists(dep_path)}
+	# A uid still written as one is one the project does not know, and asked about, the engine prints
+	# an error for it.
+	var dep_info: Dictionary = {
+		"path": dep_path, "exists": not dep_path.begins_with("uid://") and FileAccess.file_exists(dep_path)
+	}
 	dep_info.merge(named_by)
 	# Marked where the reference closing the cycle is. Marked inside the file reached again, the tree
 	# answered that file as a dependency of itself.
@@ -743,6 +773,25 @@ static func _moved_by_uid(content: String) -> Dictionary:
 	return moved
 
 
+# The ext_resource paths in [param content], read from [param from], whose uid names no file the
+# project has, each with that uid. The engine warns that the uid is invalid and loads the path, and
+# the walk followed the path saying nothing, so an export was the first to mention it.
+static func _unknown_uids(content: String, from: String) -> Dictionary:
+	var unknown: Dictionary = {}
+	for line: RegExMatch in GdhPatterns.compiled("\\[ext_resource[^\\]]*\\]").search_all(content):
+		var uid: String = _unknown_uid_of(line.get_string())
+		var at: RegExMatch = GdhPatterns.compiled('path="([^"]+)"').search(line.get_string())
+		if at != null and not uid.is_empty():
+			unknown[_resolved(at.get_string(1), from)] = uid
+	return unknown
+
+
+# The uid an ext_resource [param entry] carries when it names no file the project has, or empty.
+static func _unknown_uid_of(entry: String) -> String:
+	var uid: RegExMatch = GdhPatterns.compiled('uid="(uid://[^"]+)"').search(entry)
+	return "" if uid == null or not _loaded_by_uid(entry).is_empty() else uid.get_string(1)
+
+
 # The file an ext_resource [param entry] is loaded from by its uid, or empty when it carries none
 # the project knows, and the engine falls back to the path.
 static func _loaded_by_uid(entry: String) -> String:

package/package.json

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