gdharness 1.3.37 → 1.3.39

package/build/cli.js

@@ -11334,7 +11334,8 @@ import {
   readSync,
   rmSync as rmSync4,
   statSync as statSync5,
-  writeFileSync as writeFileSync4
+  writeFileSync as writeFileSync4,
+  writeSync as writeSync2
 } from "node:fs";
 import { availableParallelism, freemem, totalmem } from "node:os";
 import { isAbsolute as isAbsolute3, join as join7, relative as relative3, resolve as resolve3, sep as sep2 } from "node:path";
@@ -11489,6 +11490,7 @@ async function watchedEngine(launch, args, directory, log, silenceSeconds, silen
   const output = openSync2(log, "w");
   let child;
   let stop;
+  let piped = null;
   let helper = null;
   try {
     if (process6.platform === "win32") {
@@ -11512,11 +11514,13 @@ async function watchedEngine(launch, args, directory, log, silenceSeconds, silen
         stop: stopFile,
         step: helper.step
       });
-      child = spawnHidden(wrapper.command, wrapper.args, {
-        stdio: ["ignore", output, output],
+      const helped = spawnHidden(wrapper.command, wrapper.args, {
+        stdio: ["ignore", "pipe", "pipe"],
         env: { ...env, [DESKTOP_VARIABLE]: HIDDEN_DESKTOP },
         cwd: directory
       });
+      piped = [helped.stdout, helped.stderr];
+      child = helped;
       stop = () => {
         writeFileSync4(stopFile, "");
       };
@@ -11533,7 +11537,9 @@ async function watchedEngine(launch, args, directory, log, silenceSeconds, silen
       };
     }
   } finally {
-    closeSync2(output);
+    if (piped === null) {
+      closeSync2(output);
+    }
   }
   launch.running.add(stop);
   let ended = null;
@@ -11546,6 +11552,7 @@ async function watchedEngine(launch, args, directory, log, silenceSeconds, silen
       });
     })
   ]);
+  const copied = piped === null ? null : copiedInto(output, piped, exited);
   const finished = { now: false };
   exited.then(() => {
     finished.now = true;
@@ -11598,12 +11605,42 @@ async function watchedEngine(launch, args, directory, log, silenceSeconds, silen
   }
   const { code, signal } = await exited;
   const freeBytes = code !== null && code >>> 0 >= WINDOWS_EXCEPTION ? freemem() : undefined;
+  if (copied !== null) {
+    await copied;
+    closeSync2(output);
+  }
   const failed = helper === null ? null : helperFailure(helper.error);
   if (failed !== null && helper !== null) {
     ended ??= `the engine could not be started ${helper.how}: ${failed}`;
   }
   return { code, signal, ended, ...freeBytes === undefined ? {} : { freeBytes } };
 }
+function copiedInto(output, streams, exited) {
+  let writing = true;
+  const ended = streams.map((stream) => new Promise((settle) => {
+    stream.on("data", (chunk) => {
+      if (!writing) {
+        return;
+      }
+      try {
+        writeSync2(output, chunk);
+      } catch {
+        writing = false;
+      }
+    });
+    stream.once("close", settle);
+  }));
+  const all = Promise.all(ended).then(() => {
+    return;
+  });
+  const drained = exited.then(() => delay2(DRAIN_MS, undefined, { ref: false }));
+  return Promise.race([all, drained]).then(() => {
+    writing = false;
+    for (const stream of streams) {
+      stream.destroy();
+    }
+  });
+}
 function endTree(child) {
   if (child.pid === undefined) {
     return;
@@ -11616,7 +11653,7 @@ function endTree(child) {
     process6.kill(-child.pid, "SIGKILL");
   } catch {}
 }
-var EngineUsageError, MOST_ENGINES = 4, SILENCE_FLOOR_SECONDS = 300, CONTROL_SEQUENCE, WINDOWS_EXCEPTION = 3221225472, MEMORY_KEPT, MEMORY_PER_ENGINE, LOOK_MS = 500, COMMIT_ASK_MS = 15000, AUTOLOAD_FAILED = "Failed to instantiate an autoload", KEPT_RUN_DIRECTORIES = 5;
+var EngineUsageError, MOST_ENGINES = 4, SILENCE_FLOOR_SECONDS = 300, CONTROL_SEQUENCE, WINDOWS_EXCEPTION = 3221225472, MEMORY_KEPT, MEMORY_PER_ENGINE, LOOK_MS = 500, COMMIT_ASK_MS = 15000, AUTOLOAD_FAILED = "Failed to instantiate an autoload", KEPT_RUN_DIRECTORIES = 5, DRAIN_MS = 5000;
 var init_engine_launch = __esm(() => {
   init_alive();
   init_desktop();
@@ -11744,7 +11781,7 @@ import {
   rmSync as rmSync6,
   statSync as statSync6,
   watch,
-  writeSync as writeSync2
+  writeSync as writeSync3
 } from "node:fs";
 import { availableParallelism as availableParallelism2, homedir as homedir2 } from "node:os";
 import { join as join8, resolve as resolve4 } from "node:path";
@@ -11970,7 +12007,7 @@ class EngineSlots {
       return false;
     }
     try {
-      writeSync2(made, JSON.stringify(this.holder));
+      writeSync3(made, JSON.stringify(this.holder));
     } finally {
       closeSync3(made);
     }
@@ -12084,7 +12121,7 @@ async function inASlot(body) {
     held.release();
   }
 }
-var SLOTS_VARIABLE = "GODOT_ENGINE_SLOTS", SLOT_COUNT_VARIABLE = "GODOT_ENGINE_SLOT_COUNT", PROCESSORS_A_SLOT = 5, START_TOLERANCE_MS = 2000, UNWRITTEN_MS = 1e4, SLOT_LOOK_MS = 1000, SLOT_SETTLE_MS = 50, WAIT_SAID_MS = 20000, COMMAND_WAIT_SAID_MS = 2000, START_READ_MS = 1e4, WAITING_FOLDER = "waiting", waitsMarked = 0, ours, saidTo, takenBy;
+var SLOTS_VARIABLE = "GODOT_ENGINE_SLOTS", SLOT_COUNT_VARIABLE = "GODOT_ENGINE_SLOT_COUNT", PROCESSORS_A_SLOT = 2, START_TOLERANCE_MS = 2000, UNWRITTEN_MS = 1e4, SLOT_LOOK_MS = 1000, SLOT_SETTLE_MS = 50, WAIT_SAID_MS = 20000, COMMAND_WAIT_SAID_MS = 2000, START_READ_MS = 1e4, WAITING_FOLDER = "waiting", waitsMarked = 0, ours, saidTo, takenBy;
 var init_engine_slots = __esm(() => {
   init_alive();
   init_call_signal();
@@ -16657,7 +16694,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 +16713,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 +17380,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: {
@@ -17364,7 +17401,7 @@ var init_tool_definitions = __esm(() => {
       name: "script_diagnostics",
       title: "Script diagnostics",
       effect: "read",
-      description: "Errors and warnings for a script, or for several, from the editor's language server, and whether each is clean. With no editor of this project open, so no language server of it to ask, a short headless engine compiles the scripts instead and the answer says checkedBy: engine rather than language server: every error that stops a script compiling, up to its first syntax error, with its line and no column (a call to a method another class lacks is not one, since GDScript checks those only on self: the object may be a subclass that has it, so it fails at run time instead), dependenciesWithErrors naming the other scripts that failed while it loaded, typesMissingFromTheClassCache naming a class the project declares that the engine could not resolve because the class cache lacks it, with staleAnalysis saying what rewrites the cache, and warnings null, since the engine reports warnings only to an editor. Of several scripts, a language server that stops answering partway leaves the rest to the engine, and checkedBy then says language server, then engine, with checkedByLanguageServer counting the scripts it answered. Each diagnostic carries its severity (error or warning), its message, and where it is as the editor shows it: line and column counted from 1, and endLine and endColumn just past its end. Diagnostics are checked against the project's own files, and the two that the files disprove are named rather than passed on: a member the class cache's file declares, or a project class it extends does, a method, property, constant, static function or enum member, comes back under contradictedByTheFile with the script declaring it, and so does one a diagnostic names alone as an external class member, read against the class it is looked up on in the line it is on; and a class this project declares that the diagnostic could not resolve comes back under typesTheEditorHasNotLoaded, with inTheClassCache saying whether a launched game would resolve it. staleAnalysis then says what to do, and for both states it is editor_rescan first: it asks the editor already running, starts nothing, and has cleared each in every reproduction measured. Two exceptions are named when they apply. For an enum member, constant or static function of a global class the reload comes first: in the one project that has reproduced a stale enum member, editor_rescan with reloadScript on the declaring script cleared it and a plain rescan did not. And an editor whose last scan wrote the class cache shorter than the file holds a list behind the files and writes it on every scan, so on that editor the rescan loads nothing and staleAnalysis says editor_launch restart instead. What follows differs: for a stale analysed type, editor_rescan with reloadScript recompiles the held copy and editor_launch restart is the last resort that costs a window; for a class missing from the cache, project_import refresh_classes rewrites the cache from disk at the cost of a short headless engine, which matters beside a running bench.",
+      description: "Errors and warnings for a script, or for several, from the editor's language server, and whether each is clean. With no editor of this project open, so no language server of it to ask, a short headless engine compiles the scripts instead and the answer says checkedBy: engine rather than language server: every error that stops a script compiling, up to its first syntax error, with its line and no column (a call to a method another class lacks is not one, since GDScript checks those only on self: the object may be a subclass that has it, so it fails at run time instead), dependenciesWithErrors naming the other scripts that failed while it loaded, typesMissingFromTheClassCache naming a class the project declares that the engine could not resolve because the class cache lacks it, with staleAnalysis saying what rewrites the cache, and the warnings at the levels the project sets, which a second engine reports by raising each warning set to warn as an error for that run only, each at its line with no column, warnings being null when that engine could not answer. Of several scripts, a language server that stops answering partway leaves the rest to the engine, and checkedBy then says language server, then engine, with checkedByLanguageServer counting the scripts it answered. Each diagnostic carries its severity (error or warning), its message, and where it is as the editor shows it: line and column counted from 1, and endLine and endColumn just past its end. Diagnostics are checked against the project's own files, and the two that the files disprove are named rather than passed on: a member the class cache's file declares, or a project class it extends does, a method, property, constant, static function or enum member, comes back under contradictedByTheFile with the script declaring it, and so does one a diagnostic names alone as an external class member, read against the class it is looked up on in the line it is on; and a class this project declares that the diagnostic could not resolve comes back under typesTheEditorHasNotLoaded, with inTheClassCache saying whether a launched game would resolve it. staleAnalysis then says what to do, and for both states it is editor_rescan first: it asks the editor already running, starts nothing, and has cleared each in every reproduction measured. Two exceptions are named when they apply. For an enum member, constant or static function of a global class the reload comes first: in the one project that has reproduced a stale enum member, editor_rescan with reloadScript on the declaring script cleared it and a plain rescan did not. And an editor whose last scan wrote the class cache shorter than the file holds a list behind the files and writes it on every scan, so on that editor the rescan loads nothing and staleAnalysis says editor_launch restart instead. What follows differs: for a stale analysed type, editor_rescan with reloadScript recompiles the held copy and editor_launch restart is the last resort that costs a window; for a class missing from the cache, project_import refresh_classes rewrites the cache from disk at the cost of a short headless engine, which matters beside a running bench.",
       parameters: {
         projectPath: PROJECT_PATH,
         scriptPath: {
@@ -18077,7 +18114,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,
@@ -18665,6 +18702,7 @@ class ProjectScripts {
   suite(path) {
     const cases = new Set;
     let said;
+    let together;
     let guessed = false;
     const seen = new Set;
     let at = path;
@@ -18679,13 +18717,21 @@ class ProjectScripts {
       }
       const declared = NEEDS_WINDOW.exec(read.code)?.[1];
       said ??= declared === undefined ? undefined : declared === "true";
+      const kept = TOGETHER.exec(read.code)?.[1];
+      together ??= kept === undefined ? undefined : kept === "true";
       guessed ||= this.guessWindow && SCENE_RUNNER.test(read.code);
       const base = this.base(at);
       if (base === null) {
         return null;
       }
       if ("name" in base ? base.name === SUITE_BASE : base.path === this.classes.get(SUITE_BASE)) {
-        return cases.size > 0 ? { path, cases: [...cases].sort(), windowed: said ?? guessed, headless: said === false } : null;
+        return cases.size > 0 ? {
+          path,
+          cases: [...cases].sort(),
+          windowed: said ?? guessed,
+          headless: said === false,
+          together: together === true
+        } : null;
       }
       if ("name" in base) {
         return null;
@@ -18808,6 +18854,10 @@ function rowsAfter(before, measured, cutShort) {
 function round(seconds) {
   return Math.round(seconds * 1000) / 1000;
 }
+function splitPastFor(suites, times, engines) {
+  const whole = unitsOf(suites, times, Number.POSITIVE_INFINITY).reduce((sum, unit) => sum + unit.cost, 0);
+  return Math.max(SPLIT_PAST_SECONDS, whole / Math.max(1, engines));
+}
 function median(values) {
   if (values.length === 0) {
     return;
@@ -18834,7 +18884,7 @@ function unitsOf(suites, times, splitPast = SPLIT_PAST_SECONDS) {
       windowed: suite.windowed,
       headless: suite.headless
     };
-    if (suite.windowed || whole <= splitPast) {
+    if (suite.windowed || suite.together || whole <= splitPast) {
       return [wholly];
     }
     const units = suite.cases.flatMap((func) => {
@@ -19003,13 +19053,14 @@ function viewportOf(projectPath) {
   const height = /^window\/size\/viewport_height\s*=\s*(\d+)/m.exec(text)?.[1];
   return width === undefined || height === undefined ? null : { width: Number(width), height: Number(height) };
 }
-var SUITE_BASE = "GdUnitTestSuite", CASE_PREFIX = "test_", NEEDS_WINDOW, TEST_DIRECTORIES, SCENE_RUNNER, NOT_SEARCHED_SETTING = "gdharness/tests/not_searched", GUESS_WINDOW_SETTING = "gdharness/tests/scene_runner_needs_window", UNTIMED_CASE = 0.02, SPLIT_PAST_SECONDS = 10, ENGINE_START_SECONDS = 5, SHARE_FLOOR_SECONDS;
+var SUITE_BASE = "GdUnitTestSuite", CASE_PREFIX = "test_", NEEDS_WINDOW, TOGETHER, TEST_DIRECTORIES, SCENE_RUNNER, NOT_SEARCHED_SETTING = "gdharness/tests/not_searched", GUESS_WINDOW_SETTING = "gdharness/tests/scene_runner_needs_window", UNTIMED_CASE = 0.02, SPLIT_PAST_SECONDS = 10, ENGINE_START_SECONDS = 5, SHARE_FLOOR_SECONDS;
 var init_suite_plan = __esm(() => {
   init_class_cache();
   init_gdscript_source();
   init_resources();
   init_whole_file();
   NEEDS_WINDOW = /^const\s+GDHARNESS_NEEDS_WINDOW\b[^=\n]*=\s*(true|false)\b/m;
+  TOGETHER = /^const\s+GDHARNESS_TOGETHER\b[^=\n]*=\s*(true|false)\b/m;
   TEST_DIRECTORIES = ["tests", "test"];
   SCENE_RUNNER = /\bscene_runner\s*\(/;
   SHARE_FLOOR_SECONDS = 6 * ENGINE_START_SECONDS;
@@ -50416,9 +50467,13 @@ function engineChecked(why) {
   return {
     checkedBy: "engine",
     languageServer: why,
-    note: "No editor of this project is open to ask, so a headless engine compiled the scripts the way loading them does. It reports every error that stops a script compiling, at its line and without a column, but stops reading a script at its first syntax error, so an error after one shows once it is fixed. It reports no warnings, which the engine tells only an editor: warnings is null rather than 0. editor_launch with hidden: true opens this project's editor without a window, and its language server reports both. Until then clean says only that every script compiles."
+    note: "No editor of this project is open to ask, so a headless engine compiled the scripts the way loading them does. It reports every error that stops a script compiling, at its line and without a column, but stops reading a script at its first syntax error, so an error after one shows once it is fixed. A second engine reports the warnings, at the levels the project sets, by raising each warning set to warn as an error for that run only, since the engine tells a warning as one only to an editor; each comes at its line without a column, and warnings is null when that engine could not answer. editor_launch with hidden: true opens this project's editor without a window, and its language server reports both with their columns."
   };
 }
+function asWarning(raised) {
+  const bare = raised.endsWith(RAISED_WARNING) ? raised.slice(0, -RAISED_WARNING.length) : raised;
+  return bare.startsWith(PARSE_ERROR2) ? bare.slice(PARSE_ERROR2.length) : bare;
+}
 function isDirectory(path) {
   try {
     return statSync20(path).isDirectory();
@@ -51932,8 +51987,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;
@@ -53196,6 +53261,7 @@ ${error.text}`;
     const nothingReported = [];
     let errors = 0;
     let warnings = 0;
+    let engineWarned = 0;
     let unread = 0;
     let byEngine = null;
     let byServer = 0;
@@ -53214,6 +53280,7 @@ ${error.text}`;
         }
         for (const answer of checked.answers) {
           errors += Number(answer["errors"]);
+          engineWarned = answer["warnings"] === null || engineWarned === null ? null : engineWarned + Number(answer["warnings"]);
           if (readArray(answer, "diagnostics")?.length === 0) {
             nothingReported.push(String(answer["scriptPath"]));
           } else {
@@ -53244,7 +53311,7 @@ ${error.text}`;
       clean: errors === 0 && unread === 0,
       scriptsChecked: scripts.value.length,
       errors,
-      warnings: byEngine === null ? warnings : null,
+      warnings: engineWarned === null ? null : warnings + engineWarned,
       ...unread > 0 ? { scriptsNotRead: unread } : {},
       scripts: reported,
       nothingReported,
@@ -53279,6 +53346,20 @@ ${error.text}`;
     }
     return { ok: true, payload, extras: engineExtras({ messages }) };
   }
+  async engineWarnings(projectPath, paths) {
+    const ran = await this.operation("check_warnings", { paths: [...paths] }, projectPath);
+    if (!ran.ok) {
+      this.logDebug(`check_warnings did not answer: ${ran.message}`);
+      return null;
+    }
+    return new Map((readArray(ran.payload, "scripts") ?? []).map((entry) => [
+      String(asParams(entry)["path"]),
+      (readArray(asParams(entry), "warnings") ?? []).map((warning) => ({
+        line: Number(asParams(warning)["line"]),
+        message: String(asParams(warning)["message"])
+      }))
+    ]));
+  }
   async engineDiagnostics(projectPath, scripts, why) {
     const named = scripts.map((script) => {
       const contained = resolveWithinProject(projectPath, script);
@@ -53295,21 +53376,25 @@ ${error.text}`;
       asParams(entry)
     ]));
     const errorsOf = scripts.map((_, at) => readArray(failures.get(named[at] ?? "") ?? {}, "errors") ?? []);
+    const warned = await this.engineWarnings(projectPath, named);
     const uncachedPer = uncachedFor(projectPath, errorsOf.map((errors) => errors.map((entry) => String(asParams(entry)["message"]))));
     return {
       answers: scripts.map((scriptPath, at) => {
         const failure = failures.get(named[at] ?? "");
-        const diagnostics = (errorsOf[at] ?? []).map((entry) => {
+        const errors = (errorsOf[at] ?? []).map((entry) => {
           const { line, message } = asParams(entry);
           return { severity: "error", message, ...typeof line === "number" && line > 0 ? { line } : {} };
         });
+        const raised = new Set(errors.map(({ message, line }) => `${line ?? 0}:${String(message)}`));
+        const warnings = warned === null ? [] : (warned.get(named[at] ?? "") ?? []).filter(({ line, message }) => !raised.has(`${line}:${message}`)).map(({ line, message }) => ({ severity: "warning", message: asWarning(message), line }));
+        const diagnostics = [...errors, ...warnings].sort((a, b) => (a.line ?? 0) - (b.line ?? 0));
         const dependencies = readArray(failure ?? {}, "dependencies_with_errors");
         const uncached = uncachedPer[at] ?? [];
         return {
           scriptPath,
-          clean: diagnostics.length === 0,
-          errors: diagnostics.length,
-          warnings: null,
+          clean: errors.length === 0,
+          errors: errors.length,
+          warnings: warned === null ? null : warnings.length,
           diagnostics,
           ...dependencies === undefined ? {} : { dependenciesWithErrors: dependencies },
           ...uncached.length === 0 ? {} : {
@@ -57659,7 +57744,7 @@ async function runGodotServer() {
   const server = new GodotServer;
   await server.run();
 }
-var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, FAILED_BUDGET = 1e6, ANSWER_BUDGET = 4000000, __dirname2, PARENT_ASKED_AFTER_MS = 5000, EDITOR_SERVERS_START_MS = 20000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, ALONGSIDE_NOTE = "Another call on this game was running while this one was: calls sent together run together and are answered as each finishes, so this answer is not from after the other. Send a call meant to come after another once that one has answered.", OWN_DEBUGGER = " Its debugger is the keeper holding it rather than the editor, so the debug_* tools answer for it all the same: breakpoints stop it, and debug_control pause breaks into it wherever it is, which the editor offers no way to do.", PLAY_STARTS_WITHIN_MS = 30000, KEEPER_ANSWER_MS = 15000, KEEPER_DEBUG_MS, EXIT_REPORTED_WITHIN_MS = 2000, SUCCESSOR_SOUGHT_WITHIN_MS = 20000, CLOSE_ASK_MS = 3000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, PROFILE_SEND_MS = 5000, MOST_GROUPS = 20, RUNTIME_LISTENING_LINE = "[gdharness] runtime listening on ", VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, CONSOLE_WATCH_MS = 250, BOUNDARY_WAIT_MS = 2000, HANDOVER_MS, HANDOVER_POLL_MS = 250, CACHE_WRITE_MS = 2000, STREAMS_GRACE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_SETTLED_MS = 500, REIMPORT_TIMEOUT_MS = 300000, OPS_ELSEWHERE, AUDIO_BUS_OPS, STALLED_AFTER_MS = 30000, TEST_HEARTBEAT_MS = 20000, DEPENDED_FAILED = "Failed to compile depended scripts", LOOPING_AFTER = 100, WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, DESTINATION_ARGUMENTS, OUTPUT_PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/", PROFILE_FUNCTIONS = 30, PROFILER_ON_MS = 3000, PROPERTY_PLACES = "It is a property, so each place says whether it writes it (access write), which runs its set block, or reads it (access read), which runs its get block: withinCalls on a read says nothing of the set block, nor on a write of the get block unless the write is a compound one such as +=. Inside the property's own blocks its name is the value stored, which the engine reads and writes without running them, so those lines are not listed.", CALLERS_FOUND_BY_NAME = "Found by name in the project's scripts, since the engine's profiler counts calls and time per function and records nothing about who made them: a method of the same name on another class is listed too, unless one class was asked about and it is called through another class by name or through a variable declared as one. Each place carries the profile's numbers for the function it is written in.", MOST_ENGINE_ENTRIES = 200, MOST_PRINTED_LINES = 50, MOST_UNDECLARED_ERRORS = 20, ERROR_ASSERT = "GdUnitGodotErrorAssertImpl.gd", EXTERNAL_MEMBER = 'Could not resolve external class member "', STATIC_LIST_HINT;
+var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, FAILED_BUDGET = 1e6, ANSWER_BUDGET = 4000000, __dirname2, PARENT_ASKED_AFTER_MS = 5000, EDITOR_SERVERS_START_MS = 20000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, ALONGSIDE_NOTE = "Another call on this game was running while this one was: calls sent together run together and are answered as each finishes, so this answer is not from after the other. Send a call meant to come after another once that one has answered.", OWN_DEBUGGER = " Its debugger is the keeper holding it rather than the editor, so the debug_* tools answer for it all the same: breakpoints stop it, and debug_control pause breaks into it wherever it is, which the editor offers no way to do.", PLAY_STARTS_WITHIN_MS = 30000, KEEPER_ANSWER_MS = 15000, KEEPER_DEBUG_MS, EXIT_REPORTED_WITHIN_MS = 2000, SUCCESSOR_SOUGHT_WITHIN_MS = 20000, CLOSE_ASK_MS = 3000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, PROFILE_SEND_MS = 5000, MOST_GROUPS = 20, RUNTIME_LISTENING_LINE = "[gdharness] runtime listening on ", VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, CONSOLE_WATCH_MS = 250, BOUNDARY_WAIT_MS = 2000, HANDOVER_MS, HANDOVER_POLL_MS = 250, CACHE_WRITE_MS = 2000, STREAMS_GRACE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_SETTLED_MS = 500, REIMPORT_TIMEOUT_MS = 300000, OPS_ELSEWHERE, AUDIO_BUS_OPS, STALLED_AFTER_MS = 30000, TEST_HEARTBEAT_MS = 20000, DEPENDED_FAILED = "Failed to compile depended scripts", LOOPING_AFTER = 100, WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, DESTINATION_ARGUMENTS, OUTPUT_PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/", PROFILE_FUNCTIONS = 30, PROFILER_ON_MS = 3000, PROPERTY_PLACES = "It is a property, so each place says whether it writes it (access write), which runs its set block, or reads it (access read), which runs its get block: withinCalls on a read says nothing of the set block, nor on a write of the get block unless the write is a compound one such as +=. Inside the property's own blocks its name is the value stored, which the engine reads and writes without running them, so those lines are not listed.", CALLERS_FOUND_BY_NAME = "Found by name in the project's scripts, since the engine's profiler counts calls and time per function and records nothing about who made them: a method of the same name on another class is listed too, unless one class was asked about and it is called through another class by name or through a variable declared as one. Each place carries the profile's numbers for the function it is written in.", MOST_ENGINE_ENTRIES = 200, MOST_PRINTED_LINES = 50, MOST_UNDECLARED_ERRORS = 20, ERROR_ASSERT = "GdUnitGodotErrorAssertImpl.gd", RAISED_WARNING = " (Warning treated as error.)", PARSE_ERROR2 = "Parse Error: ", EXTERNAL_MEMBER = 'Could not resolve external class member "', STATIC_LIST_HINT;
 var init_server = __esm(() => {
   init_dist2();
   init_stdio();
@@ -59106,7 +59191,6 @@ ${existsSync23(path) ? readFileSync22(path, "latin1") : "missing"}`)
       }
     }
     const times = readTimes(timesFile);
-    const units = unitsOf(suites, times);
     const memory = await memoryAvailable();
     if (memory.unread !== undefined) {
       console.log(`Windows did not say how much memory it can still commit (${memory.unread}), so engines are sized by the physical memory free.`);
@@ -59115,9 +59199,13 @@ ${existsSync23(path) ? readFileSync22(path, "latin1") : "missing"}`)
     if (options.cores !== null && process14.platform === "darwin") {
       console.log("macOS offers no way to hold a process to some processors, so --cores holds only the number of engines here.");
     }
+    const splitPast = splitPastFor(suites, times, room.engines);
+    const units = unitsOf(suites, times, splitPast);
+    const past = splitPast > SPLIT_PAST_SECONDS ? `an engine's share of this run (${String(Math.round(splitPast))} s)` : `${String(SPLIT_PAST_SECONDS)} s`;
     const plans = options.order === null ? dealt(units, declared, room.engines) : [inOneEngine(ordered(units, options.order), declared)];
     const functions = suites.reduce((sum, suite) => sum + suite.cases.length, 0);
-    const how = options.order === null ? `${windowedSaid(plans)}${roomSaid(plans.length, lanesOf(plans), lanesOf(dealt(units, declared, options.engines)), room.held, options.engines)}` : options.order === "reversed" ? ", in reverse order of path" : `, shuffled by ${String(options.order)}`;
+    const asked = unitsOf(suites, times, splitPastFor(suites, times, options.engines));
+    const how = options.order === null ? `${windowedSaid(plans)}${roomSaid(plans.length, lanesOf(plans), lanesOf(dealt(asked, declared, options.engines)), room.held, options.engines)}` : options.order === "reversed" ? ", in reverse order of path" : `, shuffled by ${String(options.order)}`;
     console.log(`${plural(functions, "test function")} in ${plural(suites.length, "suite")} over ${plural(plans.length, "engine")}${how}.`);
     const windowedAnyway = headlessInAWindow(plans, units);
     if (windowedAnyway.length > 0) {
@@ -59126,13 +59214,18 @@ ${existsSync23(path) ? readFileSync22(path, "latin1") : "missing"}`)
     }
     const split = [...new Set(units.map((unit) => unit.suite))].filter((path) => units.filter((unit) => unit.suite === path && unit.row === undefined).length > 1);
     if (plans.length > 1 && split.length > 0) {
-      console.log(`Dealt out case by case, since ${split.length === 1 ? "it" : "each"} took more than ${String(SPLIT_PAST_SECONDS)} s last time: ${named(split)}.`);
+      console.log(`Dealt out case by case, since ${split.length === 1 ? "it" : "each"} took more than ${past} last time: ${named(split)}.`);
     }
     const byRows = [
       ...new Set(units.flatMap((unit) => unit.row === undefined ? [] : [`${unit.suite} > ${unit.cases[0] ?? ""}`]))
     ];
     if (plans.length > 1 && byRows.length > 0) {
-      console.log(`Dealt out row by row, since ${byRows.length === 1 ? "it" : "each"} took more than ${String(SPLIT_PAST_SECONDS)} s last time: ${named(byRows)}.`);
+      console.log(`Dealt out row by row, since ${byRows.length === 1 ? "it" : "each"} took more than ${past} last time: ${named(byRows)}.`);
+    }
+    const keptWhole = units.flatMap((unit) => unit.cost > splitPast && !unit.windowed && suites.some((s) => s.path === unit.suite && s.together) ? [unit.suite] : []);
+    if (options.order === null && room.engines > 1 && keptWhole.length > 0) {
+      const one = keptWhole.length === 1;
+      console.log(`Kept whole in one engine, since ${one ? "it declares" : "each declares"} GDHARNESS_TOGETHER: ${named(keptWhole)}.`);
     }
     const lanes = [...new Set(plans.map((plan) => plan.lane))].map((lane) => plans.flatMap((plan, index) => plan.lane === lane ? [{ plan, index }] : []));
     const taken = [];

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/build/godot/operations/godot_operations.gd

@@ -51,6 +51,7 @@ const BEGUN: String = "[gdharness] begun"
 ## scene or a resource, loads the scripts of the file it opens.
 const AFTER_THE_AUTOLOADS: Array[String] = [
 	"check_scripts",
+	"check_warnings",
 	"create_script",
 	# An exporter made in _init, before an editor's main loop has started, crashed the engine.
 	"export_options",
@@ -99,6 +100,8 @@ func _init() -> void:
 	var params: Dictionary = read
 
 	_log.info("Executing operation: " + operation)
+	if operation == "check_warnings":
+		GdhScriptCheck.raise_warnings()
 
 	var answer_path: String = args[answer_index]
 	if operation in AFTER_THE_AUTOLOADS:
@@ -279,6 +282,8 @@ func _run(operation: String, params: Dictionary) -> Dictionary:
 			payload = GdhRenameChecks.new(_log).names_taken(params)
 		"check_scripts":
 			payload = GdhScriptCheck.new(_log).check_scripts(params)
+		"check_warnings":
+			payload = GdhScriptCheck.new(_log).check_warnings(params)
 
 		# Plugins and input
 		"list_plugins":

package/build/godot/operations/script_check.gd

@@ -19,6 +19,15 @@ const GdhLog = preload("logger.gd")
 ## Where the engine raises a script's compile errors from.
 const RELOAD: String = "GDScript::reload"
 
+## What the engine puts on the end of a warning it raised as an error. Kept in step with
+## `RAISED_WARNING` in src/server.ts.
+const RAISED: String = " (Warning treated as error.)"
+
+## Where the project's warning levels are, each 0 to ignore, 1 to warn and 2 to raise as an error.
+const WARNING_LEVELS: String = "debug/gdscript/warnings/"
+const WARN: int = 1
+const ERROR_LEVEL: int = 2
+
 var _log: GdhLog
 
 
@@ -112,3 +121,52 @@ func check_scripts(params: Dictionary) -> Dictionary:
 		break
 	OS.remove_logger(caught)
 	return {"checked": checked, "failed": failed, "scripts": scripts}
+
+
+## Raises every warning the project sets to warn so that the engine reports it as an error, which is
+## the one way it reports a warning outside an editor or a debugger. Not saved. The analyser reads
+## the levels again only once the settings change has been flushed, at the next frame, so this is
+## called in `_init` and the scripts are loaded after it; the project's autoloads, compiled before
+## that frame, compile under the project's own levels. A warning set to ignore stays ignored, and
+## @warning_ignore and the directory rules hold as they do in the editor, since the analyser applies
+## them itself.
+static func raise_warnings() -> void:
+	for property: Dictionary in ProjectSettings.get_property_list():
+		var setting: String = str(property.get("name", ""))
+		if (
+			not setting.begins_with(WARNING_LEVELS)
+			or GdhRead.as_int(property.get("type", TYPE_NIL)) != TYPE_INT
+		):
+			continue
+		if GdhRead.as_int(ProjectSettings.get_setting(setting)) == WARN:
+			ProjectSettings.set_setting(setting, ERROR_LEVEL)
+
+
+## The warnings of each script in [code]paths[/code], under the levels [method raise_warnings] left:
+## [code]scripts[/code] holds each that has any, with its warnings' lines and the engine's messages
+## as raised. The analyser runs before anything is compiled, so a script whose dependency failed on a
+## warning still reports its own, and loading on past a failure loses nothing; only what is raised at
+## the script's own path is its, since a dependency is read on its own entry as well.
+func check_warnings(params: Dictionary) -> Dictionary:
+	var asked: Array = params.get("paths", [])
+	var caught: GdhCaught = GdhCaught.new()
+	OS.add_logger(caught)
+	var checked: Array[String] = []
+	var scripts: Array[Dictionary] = []
+	for entry: Variant in asked:
+		var path: String = str(entry)
+		checked.append(path)
+		caught.raised.clear()
+		var _loaded: Resource = ResourceLoader.load(path, "", ResourceLoader.CACHE_MODE_IGNORE)
+		var warnings: Array[Dictionary] = []
+		for error: Dictionary in caught.raised:
+			var message: String = str(error["message"])
+			if str(error["path"]) != path or not message.ends_with(RAISED):
+				continue
+			var found: Dictionary = {"line": GdhRead.as_int(error["line"]), "message": message}
+			if not found in warnings:
+				warnings.append(found)
+		if not warnings.is_empty():
+			scripts.append({"path": path, "warnings": warnings})
+	OS.remove_logger(caught)
+	return {"checked": checked, "scripts": scripts}

package/package.json

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