gdharness 1.3.39 → 1.3.41

package/build/cli.js

@@ -852,7 +852,18 @@ public static class GdharnessDesktop {
   }
 
   [DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
-  static extern IntPtr CreateDesktopW(string name, IntPtr device, IntPtr mode, uint flags, uint access, IntPtr attributes);
+  static extern IntPtr CreateDesktopExW(string name, IntPtr device, IntPtr mode, uint flags, uint access, IntPtr attributes, uint heapKilobytes, IntPtr reserved);
+  [DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
+  static extern IntPtr CreateWindowStationW(string name, uint flags, uint access, IntPtr attributes);
+  [DllImport("user32.dll", SetLastError = true)] static extern IntPtr GetProcessWindowStation();
+  [DllImport("user32.dll", SetLastError = true)] static extern bool SetProcessWindowStation(IntPtr station);
+  [DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
+  static extern bool GetUserObjectInformationW(IntPtr handle, int index, StringBuilder into, int size, out int needed);
+  const uint WindowStationAllAccess = 0x37F;
+  const int ObjectName = 2;
+  // What Windows gives an interactive desktop. A non-interactive station's desktops get a small
+  // fraction of that by default, and one desktop here holds every engine a run starts.
+  const uint DesktopHeapKilobytes = 20480;
 
   [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
   static extern bool CreateProcessW(string application, StringBuilder commandLine, IntPtr processAttributes, IntPtr threadAttributes, bool inherit, uint flags, IntPtr environment, string directory, ref StartupInfo startup, out Started started);
@@ -943,12 +954,34 @@ public static class GdharnessDesktop {
     StartupInfo startup = new StartupInfo();
     startup.cb = Marshal.SizeOf(typeof(StartupInfo));
     if (desktop.Length > 0) {
-      Step(stepFile, "creating the " + desktop + " desktop");
-      IntPtr held = CreateDesktopW(desktop, IntPtr.Zero, IntPtr.Zero, 0, GenericAll, IntPtr.Zero);
+      Step(stepFile, "opening the session's own window station");
+      IntPtr station = CreateWindowStationW(null, 0, WindowStationAllAccess, IntPtr.Zero);
+      if (station == IntPtr.Zero) {
+        throw new Win32Exception(Marshal.GetLastWin32Error(), "CreateWindowStationW");
+      }
+      StringBuilder stationName = new StringBuilder(256);
+      int needed;
+      if (!GetUserObjectInformationW(station, ObjectName, stationName, stationName.Capacity * 2, out needed)) {
+        throw new Win32Exception(Marshal.GetLastWin32Error(), "GetUserObjectInformationW");
+      }
+      // A desktop is made in the calling process's station, so this one is the caller's while it is.
+      IntPtr own = GetProcessWindowStation();
+      if (!SetProcessWindowStation(station)) {
+        throw new Win32Exception(Marshal.GetLastWin32Error(), "SetProcessWindowStation");
+      }
+      IntPtr held;
+      int made;
+      try {
+        Step(stepFile, "creating the " + desktop + " desktop");
+        held = CreateDesktopExW(desktop, IntPtr.Zero, IntPtr.Zero, 0, GenericAll, IntPtr.Zero, DesktopHeapKilobytes, IntPtr.Zero);
+        made = Marshal.GetLastWin32Error();
+      } finally {
+        SetProcessWindowStation(own);
+      }
       if (held == IntPtr.Zero) {
-        throw new Win32Exception(Marshal.GetLastWin32Error(), "CreateDesktopW " + desktop);
+        throw new Win32Exception(made, "CreateDesktopExW " + stationName + "\\\\" + desktop);
       }
-      startup.desktop = desktop;
+      startup.desktop = stationName + "\\\\" + desktop;
     }
     startup.flags = UseStdHandles;
     if (noActivate) {
@@ -12877,7 +12910,7 @@ var init_doc_cache = __esm(() => {
 
 // src/project-scan.ts
 import { existsSync as existsSync9, readdirSync as readdirSync6, readFileSync as readFileSync8, statSync as statSync9 } from "node:fs";
-import { basename as basename5, extname, join as join11 } from "node:path";
+import { basename as basename5, extname, join as join11, relative as relative4, sep as sep3 } from "node:path";
 function skipped(name) {
   return name.startsWith(".") || SKIPPED.has(name);
 }
@@ -13037,6 +13070,20 @@ function pathsInUidCache(projectPath) {
   }
   return new Set(paths.values());
 }
+function steppedOverAround(projectPath, place) {
+  let at = projectPath;
+  for (const step of relative4(projectPath, place).split(sep3).filter((part) => part !== "")) {
+    at = join11(at, step);
+    if (!statSync9(at).isDirectory()) {
+      break;
+    }
+    const why = skipped(step) ? step.startsWith(".") ? "its name starts with a dot" : `it is ${step}` : gdignored(at) ? "it holds a .gdignore" : installedByUs(at) ? "gdharness installed it" : null;
+    if (why !== null) {
+      return { folder: `res://${relative4(projectPath, at).split(sep3).join("/")}/`, why };
+    }
+  }
+  return null;
+}
 function isBinary(bytes) {
   return bytes.subarray(0, 8000).includes(0);
 }
@@ -13162,8 +13209,8 @@ function searchProject(projectPath, options) {
       result.summary.files_with_matches += 1;
     }
   };
-  const visit = (directory) => {
-    if (steppedOver(directory)) {
+  const visit = (directory, named = false) => {
+    if (!named && steppedOver(directory)) {
       if (gdignored(directory)) {
         notSearched.push(`res://${directory.slice(projectPath.length + 1).replace(/\\/g, "/")}/`);
       }
@@ -13186,20 +13233,17 @@ function searchProject(projectPath, options) {
   };
   const within = options.within ?? projectPath;
   if (statSync9(within).isDirectory()) {
-    visit(within);
+    visit(within, true);
   } else {
     searchFile(within, basename5(within));
   }
   const answered = notSearched.length === 0 ? result : { ...result, not_searched: notSearched };
-  if (extensions === null || result.summary.files_searched > 0) {
-    return answered;
-  }
-  const asked = [...extensions].join(", ");
-  const there = [...met].sort().join(", ");
-  return {
-    ...answered,
-    note: met.size === 0 ? `No file was searched: there is no file there to search.` : `No file was searched: none there has the extension ${asked}. The extensions there are ${there}.`
-  };
+  const around = options.within === undefined ? null : steppedOverAround(projectPath, within);
+  const notes = [
+    around === null ? undefined : `${around.folder} is searched because path names it; a search of the whole project steps over it, since ${around.why}.`,
+    extensions === null || result.summary.files_searched > 0 ? undefined : met.size === 0 ? "No file was searched: there is no file there to search." : `No file was searched: none there has the extension ${[...extensions].join(", ")}. The extensions there are ${[...met].sort().join(", ")}.`
+  ].filter((note) => note !== undefined);
+  return notes.length === 0 ? answered : { ...answered, note: notes.join(" ") };
 }
 var SKIPPED, VERSION_MARKER = ".gdharness-version", SCENE_EXTENSIONS, SIDECAR_EXTENSIONS, ASSET_EXTENSIONS, CARRIES_A_UID, BINARY_EXTENSIONS;
 var init_project_scan = __esm(() => {
@@ -16400,8 +16444,14 @@ var init_tool_definitions = __esm(() => {
           type: "string",
           description: "Variables: the initial value. Constants: the value, which a constant needs. As written in GDScript."
         },
-        isExport: { type: "boolean", description: "Variables: add @export." },
-        exportHint: { type: "string", description: 'Variables: the export hint, such as "range(0, 100)".' },
+        isExport: {
+          type: "boolean",
+          description: "Variables: add @export. Default true when exportHint is given."
+        },
+        exportHint: {
+          type: "string",
+          description: 'Variables: the export hint, such as "range(0, 100)", written as @export_range(0, 100). Refused beside isExport false.'
+        },
         isOnready: { type: "boolean", description: "Variables: add @onready." },
         position: {
           type: "string",
@@ -16504,7 +16554,7 @@ var init_tool_definitions = __esm(() => {
     {
       name: "project_settings",
       title: "Project settings",
-      description: "Reads or writes project.godot (settings, autoloads, the main scene, input actions and plugins) and the audio bus layout, default_bus_layout.tres unless audio/buses/default_bus_layout names another. project_info include lists the autoloads, input actions and audio buses as the project holds them. A write with an editor open on the project is handed to the editor, which takes the settings the write changed or names from the file (named under editorAdopted), including a setting the file already held, since the editor can hold another value after the file was put back, or reloads the bus layout, so it answers the new values and does not save the old ones back over them. editorNote is an editor that could not take the write, or one on another release's addon that was not asked, which still holds the old values until editor_launch restart. An enabled plugin's code still loads on the editor's next start. set answers old_value and new_value, with was_new true when project.godot did not set the setting before, and was_default true when what it held was the engine's own default, which old_value then is. add_input_action on an action that exists, one of the engine's ui_ actions included, replaces its events, and its deadzone when one is given, and answers was_new false with what it held under old_events and old_deadzone. A set of the value the setting already holds, in the same type, writes nothing and answers unchanged true and saved false. unset takes a setting's line out of project.godot, the way back from a set of a misspelt name, and answers removed, old_value and default_value, the value that holds now (null for a setting the engine does not declare; for an override, name.feature, holds is the base setting's value its builds read now); on one the file does not set it answers removed false and writes nothing. Every write changes only the lines of the settings it names and keeps every other line as the file had it, in its place: the engine's own save would sort a dictionary's keys and write what a project_settings_override file laid over the project. get answers exists, true for any setting the engine knows, at_default, true when the value is the engine's own default and so has no line in project.godot, and overrides, the value each feature's override holds. An override answers override_of, its base setting, and one project.godot does not set answers exists false with holds, the base setting's value. Each setting under prefix carries at_default too, so a family read separates what the project sets from the engine's defaults; it is absent for a setting the engine registers no default for, such as an input action the project added, which only the project can have set.",
+      description: "Reads or writes project.godot (settings, autoloads, the main scene, input actions and plugins) and the audio bus layout, default_bus_layout.tres unless audio/buses/default_bus_layout names another. project_info include lists the autoloads, input actions and audio buses as the project holds them. A write with an editor open on the project is handed to the editor, which takes the settings the write changed or names from the file (named under editorAdopted), including a setting the file already held, since the editor can hold another value after the file was put back, or reloads the bus layout, so it answers the new values and does not save the old ones back over them. editorNote is an editor that could not take the write, or one on another release's addon that was not asked, which still holds the old values until editor_launch restart. An enabled plugin's code still loads on the editor's next start, and enable_plugin notes a script it would not load. set answers old_value and new_value, with was_new true when project.godot did not set the setting before, and was_default true when what it held was the engine's own default, which old_value then is. add_input_action on an action that exists, one of the engine's ui_ actions included, replaces its events, and its deadzone when one is given, and answers was_new false with what it held under old_events and old_deadzone. A set of the value the setting already holds, in the same type, writes nothing and answers unchanged true and saved false. unset takes a setting's line out of project.godot, the way back from a set of a misspelt name, and answers removed, old_value and default_value, the value that holds now (null for a setting the engine does not declare; for an override, name.feature, holds is the base setting's value its builds read now); on one the file does not set it answers removed false and writes nothing, its note naming the nearest settings when the engine does not declare it either. Every write changes only the lines of the settings it names and keeps every other line as the file had it, in its place: the engine's own save would sort a dictionary's keys and write what a project_settings_override file laid over the project. get answers exists, true for any setting the engine knows, at_default, true when the value is the engine's own default and so has no line in project.godot, and overrides, the value each feature's override holds. An override answers override_of, its base setting, and one project.godot does not set answers exists false with holds, the base setting's value. Each setting under prefix carries at_default too, so a family read separates what the project sets from the engine's defaults; it is absent for a setting the engine registers no default for, such as an input action the project added, which only the project can have set.",
       parameters: {
         projectPath: PROJECT_PATH,
         setting: {
@@ -16664,7 +16714,7 @@ var init_tool_definitions = __esm(() => {
       name: "project_search",
       title: "Search the project",
       effect: "read",
-      description: "Searches text or a regular expression across project files and returns file paths with line numbers, one entry per line that holds the query, however often it holds it; total_matches counts those lines. What the engine steps over is not searched: directories spelled with a dot, node_modules, and any directory holding a .gdignore, which not_searched names when the search passed one. A vendored engine or an export directory is therefore absent from the results rather than matching the code you are looking for in a copy nobody runs. The addons gdharness installed are not searched either, since nobody on the project wrote them.",
+      description: "Searches text or a regular expression across project files and returns file paths with line numbers, one entry per line that holds the query, however often it holds it; total_matches counts those lines. What the engine steps over is not searched: directories spelled with a dot, node_modules, and any directory holding a .gdignore, which not_searched names when the search passed one. A vendored engine or an export directory is therefore absent from the results rather than matching the code you are looking for in a copy nobody runs. The addons gdharness installed are not searched either, since nobody on the project wrote them. A path naming one of those folders, or a place inside one, is searched as asked, and note says the whole-project search steps over it. Each line is searched on its own, so a query holding a line break is refused.",
       parameters: {
         projectPath: PROJECT_PATH,
         query: { type: "string", description: "The text or pattern to find." },
@@ -16679,7 +16729,11 @@ var init_tool_definitions = __esm(() => {
         },
         regex: { type: "boolean", description: "Read the query as a regular expression. Default false." },
         caseSensitive: { type: "boolean", description: "Default false." },
-        maxResults: { type: "number", description: "Default 100." }
+        maxResults: {
+          type: "integer",
+          minimum: 1,
+          description: "How many matching lines to answer. Default 100."
+        }
       },
       requires: ["projectPath", "query"]
     },
@@ -16696,7 +16750,11 @@ var init_tool_definitions = __esm(() => {
           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; 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." },
+        depth: {
+          type: "integer",
+          minimum: 1,
+          description: "forward: how many levels to follow, 1 being what the file loads itself. Default unlimited."
+        },
         includeBuiltin: {
           type: "boolean",
           description: "forward: include the engine's own res://. resources. Default false."
@@ -16873,7 +16931,7 @@ var init_tool_definitions = __esm(() => {
         path: {
           type: ["string", "array"],
           items: { type: "string" },
-          description: "A test directory or suite file inside the project, or a list of them, all run on one engine: a named set of suites boots once rather than once per suite. An entry given twice, or a suite inside a directory also listed, runs once. An entry that is not there is left out and named under missing, the rest run, and such a run is never called passed; when no entry is there the run is refused before the engine starts, naming each one. A script named that declares no test_ function at the top level is refused the same way, and so is a directory holding no suite. A script that declares test_ functions and does not extend GdUnitTestSuite, which gdUnit4 never runs and never mentions, is refused when named, and under a directory run whole it is named under notSuites and the run is not called passed. Default tests and test, those the project has, which is where gdharness test looks."
+          description: 'A test directory or suite file inside the project, or a list of them, all run on one engine: a named set of suites boots once rather than once per suite. An entry given twice, or a suite inside a directory also listed, runs once. An entry "suite.gd:test_name" runs that case alone, as gdharness test reads it and as tests runs it, so it cannot share the list with a whole suite or a directory. An entry that is not there is left out and named under missing, the rest run, and such a run is never called passed; when no entry is there the run is refused before the engine starts, naming each one. A script named that declares no test_ function at the top level is refused the same way, and so is a directory holding no suite. A script that declares test_ functions and does not extend GdUnitTestSuite, which gdUnit4 never runs and never mentions, is refused when named, and under a directory run whole it is named under notSuites and the run is not called passed. Default tests and test, those the project has, which is where gdharness test looks.'
         },
         ignore: {
           type: "array",
@@ -16916,7 +16974,7 @@ var init_tool_definitions = __esm(() => {
         rootNodeType: {
           type: "string",
           ops: ["create"],
-          description: "create: the root node class, an engine class or a class_name a project script declares, which the root is made as with that script attached. Default Node."
+          description: "create: the root node class, an engine class or a class_name a project script declares, which the root is made as with that script attached. Default Node. The answer names the root as scene_node get does: rootNodeType its engine class, with scriptClass for a class_name."
         },
         rootNodeName: {
           type: "string",
@@ -16952,8 +17010,9 @@ var init_tool_definitions = __esm(() => {
         projectPath: PROJECT_PATH,
         scenePath: SCENE_PATH,
         depth: {
-          type: "number",
-          description: "How many levels to descend. Default: all. A node at the last level that has children of its own lists none and says how many under childrenNotListed."
+          type: "integer",
+          minimum: 0,
+          description: "How many levels to descend, 0 being the root alone. Default: all. A node at the last level that has children of its own lists none and says how many under childrenNotListed."
         },
         includeProperties: {
           type: "boolean",
@@ -16961,7 +17020,7 @@ var init_tool_definitions = __esm(() => {
         },
         includeDefaults: {
           type: "boolean",
-          description: "With includeProperties, list every stored property, defaults included: a Control has about a hundred, and ten of them ran to fifty-seven thousand characters. Default false."
+          description: "List every stored property, defaults included, which turns includeProperties on when it is left out: a Control has about a hundred, and ten of them ran to fifty-seven thousand characters. Default false."
         }
       },
       requires: ["projectPath", "scenePath"]
@@ -16986,7 +17045,7 @@ var init_tool_definitions = __esm(() => {
         nodeType: {
           type: "string",
           ops: ["add"],
-          description: `add: the node class, such as "CharacterBody2D", or a class_name a project script declares, which the node is made as with that script attached. Give this or instancePath. The answer's nodeType is the class of the node made, for an instance the class of its scene's root.`
+          description: `add: the node class, such as "CharacterBody2D", or a class_name a project script declares, which the node is made as with that script attached. Give this or instancePath. The answer names the node made as get does: nodeType its engine class, for an instance the class of its scene's root, with scriptClass when its script declares a class_name.`
         },
         instancePath: {
           type: "string",
@@ -17084,7 +17143,7 @@ var init_tool_definitions = __esm(() => {
     {
       name: "scene_signal",
       title: "Scene signals",
-      description: `Signal connections in a scene file. Each connection answers with its flags as the number and as flagNames; persist is on every connection, since a scene saves no other kind. A connection carries binds, the values passed after the signal's own, and unbinds, how many of the signal's own are dropped first, as the editor's connect dialog offers them; each is answered only when there is one. A connect of a pair already connected says alreadyConnected, with flagsBefore, bindsBefore and unbindsBefore when it changed them, and keeps the binds and unbinds it had unless the call gives new ones. A connect to a method the target does not have is still written, as the editor's own dialog allows, since the method may be written next; methodFound false says so, and until the method exists the signal fails each time it is emitted. One whose method cannot take what the signal passes, with its binds and unbinds (too few or too many arguments, an object where the method takes a value or the reverse, or an engine class unrelated to the one it takes), is written too, and answers argumentsFit false with misfit saying why; list gives each connection its methodFound, and misfit when it has one. list marks editable false on a connection an instanced scene makes inside itself, which only that scene can change. ${WITHOUT_AN_EDITOR} ${ALSO_SAVED}`,
+      description: `Signal connections in a scene file. Each connection answers with its flags as the number and as flagNames; persist is on every connection, since a scene saves no other kind. A connection carries binds, the values passed after the signal's own, and unbinds, how many of the signal's own are dropped first, as the editor's connect dialog offers them; each is answered only when there is one. A connect of a pair already connected says alreadyConnected, with flagsBefore, bindsBefore and unbindsBefore when it changed them, and keeps the binds and unbinds it had unless the call gives new ones. A connect to a method the target does not have is still written, as the editor's own dialog allows, since the method may be written next; methodFound false says so, and until the method exists the signal fails each time it is emitted. One whose method cannot take what the signal passes, with its binds and unbinds (too few or too many arguments, an object where the method takes a value or the reverse, or an engine class unrelated to the one it takes), is written too, and answers argumentsFit false with misfit saying why; list gives each connection its methodFound, and misfit when it has one. list marks editable false on a connection a scene this one instances or inherits makes, on its own root as well as inside it, and names that scene under madeIn; only that scene can change it, so a disconnect of one is refused. ${WITHOUT_AN_EDITOR} ${ALSO_SAVED}`,
       parameters: {
         projectPath: PROJECT_PATH,
         scenePath: SCENE_PATH,
@@ -17152,7 +17211,7 @@ var init_tool_definitions = __esm(() => {
         animationName: {
           type: "string",
           ops: ["read", "create", "add_track", "remove_track", "set", "rename", "remove", "add_state"],
-          description: "The animation in the player. A name before a slash is the library it is in, as moves/walk. read: the one to answer with whole, its tracks a list; without it, read lists them, each with the number of its tracks under tracks. create: a library the player does not have is made in the scene and named under libraryMade. add_state: the one that state plays. One the player does not have yet is written all the same, answering animationFound false and why under animationMissing."
+          description: "The animation in the player. A name before a slash is the library it is in, as moves/walk. read: the one to answer with whole, its tracks a list; without it, read lists them, each with the number of its tracks under tracks. create: a library the player does not have is made in the scene and named under libraryMade, where an empty name is the default library of the player, the one a name without a slash is in. add_state: the one that state plays. One the player does not have yet is written all the same, answering animationFound false and why under animationMissing."
         },
         newName: {
           type: "string",
@@ -17582,7 +17641,7 @@ var init_tool_definitions = __esm(() => {
           type: ["string", "array"],
           items: { type: "string" },
           ops: ["start"],
-          description: "start: gdUnit4 suites to play instead of a scene, a suite file or a test directory inside the project or a list of them, as project_test's path takes them. They run in the tests addon's suites scene through the runner gdharness test uses, so with profile: true the profile names what the suites cost by function, which project_test and gdharness test cannot show, since the profiler never sees a script run. The run quits with gdUnit4's exit code; read it with editor_output until running is false, then profile. Takes no scene or executable, and needs gdUnit4 and the tests addon of this release in the project."
+          description: "start: gdUnit4 suites to play instead of a scene, a suite file or a test directory inside the project or a list of them, as project_test's path takes them, though always whole: an entry naming one case is refused. They run in the tests addon's suites scene through the runner gdharness test uses, so with profile: true the profile names what the suites cost by function, which project_test and gdharness test cannot show, since the profiler never sees a script run. The run quits with gdUnit4's exit code; read it with editor_output until running is false, then profile. Takes no scene or executable, and needs gdUnit4 and the tests addon of this release in the project."
         },
         args: {
           type: "array",
@@ -17604,7 +17663,7 @@ var init_tool_definitions = __esm(() => {
         visible: {
           type: "boolean",
           ops: ["start"],
-          description: "start: on Windows, show the window on the desktop in use. By default a windowed run this server starts goes on a desktop of its own, where it renders and runtime_capture works but the window never shows and never takes the keyboard. A game a visible editor plays opens on the desktop in use, and one a hidden editor (editor_launch hidden: true) plays goes on its desktop. Elsewhere than Windows the window shows either way. Default false."
+          description: "start: on Windows, show the window on the desktop in use. By default a windowed run this server starts goes on a desktop of its own, where it renders and runtime_capture works but the window never shows and never takes the keyboard or the pointer. A game a visible editor plays opens on the desktop in use, and one a hidden editor (editor_launch hidden: true) plays goes on its desktop. Elsewhere than Windows the window shows either way. Default false."
         },
         silent: {
           type: "boolean",
@@ -18386,7 +18445,7 @@ var init_tool_definitions = __esm(() => {
     {
       name: "debug_breakpoint",
       title: "Breakpoints",
-      description: "Sets, removes or lists breakpoints. A set on a script that is not there, past its last line, or on a line holding no code, blank or only a comment, is refused, as nothing would ever stop there; a remove takes any line, and with no editor connected answers removed false, saying why, when none was held there. Set them first, then editor_run, and the game stops where you asked. With the editor connected it goes through the editor's debug adapter; with none, it is held here. A game this server starts itself, which editor_run start does for a run given args, savesIn, env or silent, for a headless run of a project whose editor plays its games with a window, or with no editor, is handed every breakpoint held here as it starts, and one set while that game runs reaches it, and the set answers once the game has taken it, which it does between frames, so a call made after the answer stops there (runningGame says so). The editor keeps a breakpoint set this way for one play, so every breakpoint this server holds is sent again before each play editor_run starts, and the start answer lists them under breakpoints. The set is also kept in the project, for the server that comes after a reconnect: a breakpoint stays until it is removed here, whichever server set it. Every answer lists the whole set under held, and the breakpoints the user set in the editor's own gutter under setInEditor; setting one here never takes those away, and removing a line here clears it whoever set it. Godot clears every breakpoint in the editor when a debug session opens unless network/debug_adapter/sync_breakpoints is on, which the addon turns on as it loads; an editor where it was turned off again is said so under breakpointsAtRisk, here and in editor_status.",
+      description: "Sets, removes or lists breakpoints. A set on a script that is not there, past its last line, or on a line holding no code, blank or only a comment, is refused, as nothing would ever stop there; a remove takes any line, and with no editor connected answers removed false, saying why, when none was held there. Set them first, then editor_run, and the game stops where you asked. With the editor connected it goes through the editor's debug adapter; with none, it is held here. A game this server starts itself, which editor_run start does for a run given args, savesIn, env or silent, for a headless run of a project whose editor plays its games with a window, or with no editor, is handed every breakpoint held here as it starts, and one set while that game runs reaches it, and the set answers once the game has taken it, which it does between frames, so a call made after the answer stops there (runningGame says so). Such a game does not stop on a script error, so a run that meets one carries on past it: editor_output has the error with where it happened, and a breakpoint on that line stops the game before the line runs. The editor keeps a breakpoint set this way for one play, so every breakpoint this server holds is sent again before each play editor_run starts, and the start answer lists them under breakpoints. The set is also kept in the project, for the server that comes after a reconnect: a breakpoint stays until it is removed here, whichever server set it. Every answer lists the whole set under held, and the breakpoints the user set in the editor's own gutter under setInEditor; setting one here never takes those away, and removing a line here clears it whoever set it. Godot clears every breakpoint in the editor when a debug session opens unless network/debug_adapter/sync_breakpoints is on, which the addon turns on as it loads; an editor where it was turned off again is said so under breakpointsAtRisk, here and in editor_status.",
       parameters: {
         projectPath: PROJECT_PATH,
         scriptPath: { ...SCRIPT_PATH, ops: ["set", "remove"] },
@@ -41398,7 +41457,7 @@ var init_boot_note = __esm(() => {
 
 // src/breakpoint-note.ts
 import { mkdirSync as mkdirSync12, readFileSync as readFileSync26, rmSync as rmSync13, writeFileSync as writeFileSync14 } from "node:fs";
-import { dirname as dirname16, isAbsolute as isAbsolute7, join as join31, relative as relative5 } from "node:path";
+import { dirname as dirname16, isAbsolute as isAbsolute7, join as join31, relative as relative6 } from "node:path";
 function breakpointNotePath(projectPath) {
   return join31(projectPath, ".godot", "gdharness-breakpoints.json");
 }
@@ -41413,7 +41472,7 @@ function writeBreakpointNote(projectPath, held) {
     }
     const note = {
       breakpoints: inside.map((one) => ({
-        script: relative5(root, one.scriptPath).replaceAll("\\", "/"),
+        script: relative6(root, one.scriptPath).replaceAll("\\", "/"),
         lines: [...one.lines]
       }))
     };
@@ -41450,7 +41509,7 @@ function readBreakpointNote(projectPath) {
   }
 }
 function withinProject(projectPath, scriptPath) {
-  const rel = relative5(projectPath, scriptPath);
+  const rel = relative6(projectPath, scriptPath);
   return rel !== "" && !rel.startsWith("..") && !isAbsolute7(rel);
 }
 var init_breakpoint_note = __esm(() => {
@@ -43343,9 +43402,9 @@ var init_rename = __esm(() => {
 
 // src/rename-symbol.ts
 import { existsSync as existsSync30, mkdirSync as mkdirSync17, readdirSync as readdirSync16, realpathSync as realpathSync4, rmSync as rmSync16, writeFileSync as writeFileSync18 } from "node:fs";
-import { basename as basename9, dirname as dirname21, join as join36, relative as relative6, resolve as resolve12 } from "node:path";
+import { basename as basename9, dirname as dirname21, join as join36, relative as relative7, resolve as resolve12 } from "node:path";
 function resourcePathOf(projectPath, absolute) {
-  const inside = relative6(onDiskSpelling(projectPath), onDiskSpelling(absolute));
+  const inside = relative7(onDiskSpelling(projectPath), onDiskSpelling(absolute));
   if (inside === "" || inside.startsWith("..") || /^[A-Za-z]:/.test(inside)) {
     return null;
   }
@@ -43851,7 +43910,7 @@ import {
   statSync as statSync17,
   writeFileSync as writeFileSync19
 } from "node:fs";
-import { basename as basename10, dirname as dirname22, extname as extname3, join as join37, relative as relative7 } from "node:path";
+import { basename as basename10, dirname as dirname22, extname as extname3, join as join37, relative as relative8 } from "node:path";
 function filesUnder(directory) {
   return readdirSync17(directory, { withFileTypes: true }).flatMap((entry) => {
     const path = join37(directory, entry.name);
@@ -43912,7 +43971,7 @@ function binaryResources(projectPath) {
   return found;
 }
 function targetPathOf(projectPath, absolute) {
-  const inside = relative7(onDiskSpelling(projectPath), join37(onDiskSpelling(dirname22(absolute)), basename10(absolute)));
+  const inside = relative8(onDiskSpelling(projectPath), join37(onDiskSpelling(dirname22(absolute)), basename10(absolute)));
   if (inside === "" || inside.startsWith("..") || /^[A-Za-z]:/.test(inside)) {
     return null;
   }
@@ -47875,7 +47934,14 @@ function similarity(one, other) {
   const shared = ones.filter((pair) => others.includes(pair)).length;
   return 2 * shared / (ones.length + others.length);
 }
-function withNearestFiles(said, wanted, files) {
+function withNearestFiles(said, wanted, files, beside) {
+  const stem = (path) => (path.split("/").pop() ?? path).replace(/\.[^.]*$/, "");
+  const named = said.split(/[\s,;]+/).map((word) => word.replace(/[.:]+$/, ""));
+  const namesakes = beside.filter((file) => file !== wanted && stem(file) === stem(wanted) && !named.includes(file)).sort();
+  if (namesakes.length > 0) {
+    const alone = namesakes.length === 1;
+    return `${said}. The ${alone ? "file" : "files"} of that name beside it ${alone ? "is" : "are"} ${namesakes.join(", ")}.`;
+  }
   const extension = /\.([^./]+)$/.exec(wanted)?.[1];
   if (extension === undefined) {
     return said;
@@ -47883,7 +47949,6 @@ function withNearestFiles(said, wanted, files) {
   if (files.length === 0) {
     return `${said}. The project holds no .${extension} file.`;
   }
-  const stem = (path) => (path.split("/").pop() ?? path).replace(/\.[^.]*$/, "");
   const close = nearest(stem(wanted), files.map((file) => stem(file)));
   const offered = files.filter((file) => close.includes(stem(file)));
   if (offered.length > 0) {
@@ -48861,7 +48926,7 @@ var init_server_instructions = __esm(() => {
 
 // src/suites-scene.ts
 import { existsSync as existsSync32, mkdirSync as mkdirSync22, writeFileSync as writeFileSync21 } from "node:fs";
-import { join as join41, relative as relative8, sep as sep4 } from "node:path";
+import { join as join41, relative as relative9, sep as sep5 } from "node:path";
 function hasSuitesScene(projectPath) {
   return existsSync32(join41(projectPath, SUITES_SCENE));
 }
@@ -48885,7 +48950,7 @@ function suitesSceneArgs(projectPath, suites) {
     "-c",
     "--ignoreHeadlessMode",
     "-rd",
-    `res://${relative8(projectPath, join41(directory, "reports")).split(sep4).join("/")}`,
+    `res://${relative9(projectPath, join41(directory, "reports")).split(sep5).join("/")}`,
     "-rc",
     "1"
   ];
@@ -48900,6 +48965,44 @@ var init_suites_scene = __esm(() => {
 // src/test-selection.ts
 import { existsSync as existsSync33 } from "node:fs";
 import { basename as basename12, join as join42 } from "node:path";
+function casesOutOfPath(projectPath, given, tests) {
+  const entries = Array.isArray(given) ? given : [given];
+  const cases = [];
+  const whole = [];
+  const path = entries.map((entry) => {
+    const caseAt = typeof entry === "string" ? CASE_AFTER_SCRIPT.exec(entry.trim()) : null;
+    const suite = caseAt === null ? null : resolveWithinProject(projectPath, caseAt[1] ?? "");
+    if (caseAt === null || suite === null || !suite.ok) {
+      if (typeof entry === "string") {
+        whole.push(entry);
+      }
+      return entry;
+    }
+    cases.push(`res://${suite.relativePath}:${caseAt[2] ?? ""}`);
+    return `res://${suite.relativePath}`;
+  });
+  if (cases.length === 0) {
+    return { ok: true, path: given, tests };
+  }
+  if (whole.length > 0) {
+    return {
+      ok: false,
+      reason: `path names ${cases.length === 1 ? "a case" : "cases"}, ${cases.join(", ")}, beside ${whole.join(", ")}, and a run with cases named runs only those: run the cases on their own, and the rest in a run of its own.`
+    };
+  }
+  const named = tests === undefined || tests === null ? [] : Array.isArray(tests) ? tests : [tests];
+  return { ok: true, path: [...new Set(path)], tests: [...named, ...cases] };
+}
+function caseInSuites(given) {
+  const entries = Array.isArray(given) ? given : [given];
+  const cased = entries.filter((entry) => typeof entry === "string" && CASE_AFTER_SCRIPT.test(entry.trim()));
+  const first = cased[0];
+  if (first === undefined) {
+    return null;
+  }
+  const file = CASE_AFTER_SCRIPT.exec(first.trim())?.[1] ?? first;
+  return `suites plays whole suites, and ${cased.join(", ")} ${cased.length === 1 ? "names" : "name"} one case: name the file, ${file}, to play every case in it, or run the case alone with project_test, whose path takes ${first}.`;
+}
 function casesIn(scripts, suite) {
   return scripts.suite(suite)?.cases ?? scripts.script(suite)?.funcs.filter((name) => name.startsWith("test_")) ?? [];
 }
@@ -48961,9 +49064,12 @@ function selectTests(projectPath, asked, given) {
   const ignore = declared.filter((one) => suites.includes(one.suite) && !chosen.has(`${one.suite}:${one.test}`)).map((one) => `${one.suite}:${one.test}`);
   return { ok: true, value: { suites, ignore, selected } };
 }
+var CASE_AFTER_SCRIPT;
 var init_test_selection = __esm(() => {
+  init_paths();
   init_project_scan();
   init_suite_plan();
+  CASE_AFTER_SCRIPT = /^(.*\.gd):(\w+)$/;
 });
 
 // src/server.ts
@@ -48985,7 +49091,7 @@ import {
   statSync as statSync20,
   writeFileSync as writeFileSync22
 } from "node:fs";
-import { basename as basename13, dirname as dirname25, extname as extname4, isAbsolute as isAbsolute8, join as join43, normalize as normalize2, relative as relative9 } from "node:path";
+import { basename as basename13, dirname as dirname25, extname as extname4, isAbsolute as isAbsolute8, join as join43, normalize as normalize2, relative as relative10 } from "node:path";
 import { setTimeout as delay7 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 function editorRestartTimeoutMs() {
@@ -49142,7 +49248,7 @@ function keptGameRequest(tool, op, args) {
   }
 }
 function projectSpelling(projectPath, absolutePath) {
-  return `res://${relative9(realAsFarAsItExists(projectPath), realAsFarAsItExists(absolutePath)).replaceAll("\\", "/")}`;
+  return `res://${relative10(realAsFarAsItExists(projectPath), realAsFarAsItExists(absolutePath)).replaceAll("\\", "/")}`;
 }
 function whichGame(args) {
   return { projectPath: args["projectPath"], pid: args["pid"] };
@@ -50049,7 +50155,7 @@ function failedVerdict(report) {
   const last = parts.pop();
   return last === undefined ? "failures" : parts.length === 0 ? last : `${parts.join(", ")} and ${last}`;
 }
-function timedOutVerdict(timeoutMs, silentForMs, repeating = null) {
+function timedOutVerdict(timeoutMs, silentForMs, repeating = null, printedAnything = true) {
   const quiet = Math.round(silentForMs);
   if (repeating !== null) {
     return {
@@ -50057,6 +50163,12 @@ function timedOutVerdict(timeoutMs, silentForMs, repeating = null) {
       hung: false
     };
   }
+  if (!printedAnything && timeoutMs < STALLED_AFTER_MS) {
+    return {
+      verdict: `timed out after ${timeoutMs} ms before the engine printed anything, so it may still have been starting: timeoutMs counts milliseconds, and the default is ${TEST_TIMEOUT_MS}`,
+      hung: false
+    };
+  }
   return quiet >= Math.min(STALLED_AFTER_MS, timeoutMs / 2) ? {
     verdict: `hung: killed after ${timeoutMs} ms, having printed nothing for the last ${quiet} ms`,
     hung: true
@@ -51285,13 +51397,20 @@ class GodotServer {
         return await this.handleRunTests(args);
       case "scene_create":
         return op === "create" ? await editorOrEngine("create_scene", "writes") : await editorOrEngine("save_scene", "writes");
-      case "scene_tree":
+      case "scene_tree": {
+        const defaults = readBoolean(args, "includeDefaults") ?? false;
+        const asked = readBoolean(args, "includeProperties");
+        if (defaults && asked === false) {
+          return this.createErrorResponse("includeDefaults lists the defaults among the properties, and includeProperties false lists none: leave includeProperties out, or set it true.");
+        }
+        const properties = asked ?? defaults;
         return await this.readFromFile(args, "scenePath", "read_scene_tree", (file) => ({
           scenePath: file,
           depth: readNumber(args, "depth") ?? -1,
-          includeProperties: readBoolean(args, "includeProperties") ?? false,
-          includeDefaults: readBoolean(args, "includeDefaults") ?? false
-        }), async () => await bridge("list_scene_nodes"));
+          includeProperties: properties,
+          includeDefaults: defaults
+        }), async () => await bridge("list_scene_nodes", { includeProperties: properties }));
+      }
       case "scene_node":
         switch (op) {
           case "add":
@@ -52448,6 +52567,9 @@ class GodotServer {
     if (!project.ok) {
       return project.response;
     }
+    if (/[\r\n]/.test(readString(args, "query") ?? "")) {
+      return this.createErrorResponse("query holds a line break, and project_search matches one line at a time: search for one of its lines.");
+    }
     const given = readNonEmptyString(args, "path");
     const place = given === undefined ? null : resolveWithinProject(project.value.path, given, { root: true });
     if (place !== null && !place.ok) {
@@ -52697,10 +52819,18 @@ ${platform}`;
     ticker.unref();
     return ticker;
   }
-  async handleRunTests(args) {
+  async handleRunTests(given) {
+    const project = this.project(given);
+    if (!project.ok) {
+      return project.response;
+    }
+    const split = casesOutOfPath(project.value.path, given["path"], given["tests"]);
+    if (!split.ok) {
+      return this.createErrorResponse(split.reason);
+    }
+    const args = split.path === given["path"] ? given : { ...given, path: split.path, tests: split.tests };
     const ran = await this.runTests(args);
-    const project = this.project(args);
-    if (!project.ok || callSignal()?.aborted === true) {
+    if (callSignal()?.aborted === true) {
       return ran;
     }
     const paths = testPathsIn(project.value.path, args["path"]);
@@ -52859,7 +52989,7 @@ ${platform}`;
       "--expected-out",
       expectedFile
     ];
-    const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 600000;
+    const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? TEST_TIMEOUT_MS;
     this.logDebug(`Running tests: ${engine.value} ${cmdArgs.join(" ")}`);
     const helperFiles = {
       spec: join43(userData, "spec"),
@@ -52872,12 +53002,15 @@ ${platform}`;
     const run = await this.spawnGame(engine.value, cmdArgs, userDataIn(userData), onDesktop ? { directory: project.value.path, files: helperFiles } : undefined);
     const console2 = [];
     let lastSaid = Date.now();
+    let saidAnything = false;
     run.process.stdout?.on("data", (data) => {
       console2.push(data);
       lastSaid = Date.now();
+      saidAnything = true;
     });
     run.process.stderr?.on("data", () => {
       lastSaid = Date.now();
+      saidAnything = true;
     });
     const reporting = this.reportTestProgress(run.log);
     const autoloaded = scriptsAutoloaded(project.value.path);
@@ -52970,7 +53103,7 @@ ${platform}`;
     }).entries;
     const said = printed.map((entry) => entry.text);
     const nothingRan = timedOut || notCompiled !== null ? null : whyNoReport(said, asked.join(" and "));
-    const cutShort = timedOut && notCompiled === null ? timedOutVerdict(timeoutMs, silentForMs, repeatingScriptError(run.log.all, (entry) => run.log.raisedByScript(entry))) : null;
+    const cutShort = timedOut && notCompiled === null ? timedOutVerdict(timeoutMs, silentForMs, repeatingScriptError(run.log.all, (entry) => run.log.raisedByScript(entry)), saidAnything) : null;
     const hung = cutShort?.hung ?? false;
     const printedErrors = notCompiled !== null ? compileErrorsIn(run.log.all) : timedOut || exitCode !== 105 ? [] : scriptErrorsPrinted(said);
     const declaring = printedErrors.some((error) => unresolvedClassIn(error.message) !== null) ? await originsOf(printedErrors, declaredClasses(project.value.path), checkWithEngine(engine.value, project.value.path)) : { origins: [], unconfirmed: [] };
@@ -53323,7 +53456,10 @@ ${error.text}`;
   missingScript(projectPath, relativePath) {
     const scripts = projectFiles(projectPath, [".gd"]).map((script) => `res://${script}`);
     const wanted = `res://${relativePath}`;
-    return this.createErrorResponse(withNearestFiles(`Script file does not exist: ${wanted}`, wanted, scripts));
+    const folder = dirname25(relativePath.replaceAll("\\", "/"));
+    const inFolder = join43(projectPath, folder);
+    const beside = existsSync34(inFolder) ? readdirSync19(inFolder, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => `res://${folder === "." ? "" : `${folder}/`}${entry.name}`) : [];
+    return this.createErrorResponse(withNearestFiles(`Script file does not exist: ${wanted}`, wanted, scripts, beside));
   }
   async compileScripts(projectPath, paths) {
     const payload = { checked: [], failed: [], scripts: [] };
@@ -54404,6 +54540,10 @@ ${error.text}`;
     if (args["scene"] !== undefined || args["executable"] !== undefined) {
       return refused("suites plays the suites in the tests addon's own scene, so it takes no scene and no executable: leave those out.");
     }
+    const cased = caseInSuites(args["suites"]);
+    if (cased !== null) {
+      return refused(cased);
+    }
     const paths = testPathsIn(projectPath, args["suites"], "suites");
     if (!paths.ok) {
       return refused(paths.reason, PATH_SOLUTIONS);
@@ -54593,6 +54733,9 @@ ${error.text}`;
     let editorAskedAt = 0;
     let editorSaysGoing = true;
     let editorAsks = 0;
+    let holding = null;
+    let keeperAskedAt = 0;
+    let heldHere = null;
     const waitBegan = Date.now();
     const runBegan = Math.min(this.activeProcess?.startedAt ?? waitBegan, waitBegan);
     const lastSaid = () => editorSaysGoing ? "playing" : "not playing";
@@ -54605,7 +54748,19 @@ ${error.text}`;
         }
         const run = this.activeProcess;
         if (run === null || !run.throughEditor) {
-          return !stillRunning(run);
+          if (!stillRunning(run)) {
+            return true;
+          }
+          const keeper = run?.keeper;
+          if (keeper !== undefined && holding === null && Date.now() - keeperAskedAt >= RUN_POLL_MS) {
+            keeperAskedAt = Date.now();
+            holding = this.keptHold(keeper).then((held) => {
+              heldHere = held;
+            }).finally(() => {
+              holding = null;
+            });
+          }
+          return heldHere !== null;
         }
         if (asking === null && Date.now() - editorAskedAt >= RUN_POLL_MS) {
           editorAskedAt = Date.now();
@@ -54641,7 +54796,7 @@ ${error.text}`;
       addon: true,
       budgetMs,
       ...budget.sizedToMs === undefined ? {} : { sizedToMs: budget.sizedToMs },
-      heldAt: this.dapClient?.whereItStopped() ?? null,
+      heldAt: going === null || going.throughEditor ? this.dapClient?.whereItStopped() ?? null : endpoint === null && running && going.keeper !== undefined ? await this.keptHold(going.keeper) : null,
       running,
       withArgs,
       servesAProject: this.ownProject !== null,
@@ -56729,7 +56884,12 @@ ${error.text}`;
       return contained.response;
     }
     const { op: _op, projectPath: _projectPath, ...params } = contained.value;
-    const created = await this.operation("create_script", params, project.value.path);
+    const stale = await this.refreshStaleClasses(project.value.path);
+    if (!stale.ok) {
+      return stale.response;
+    }
+    const loaded = await this.operation("create_script", params, project.value.path);
+    const created = loaded.ok && stale.value.length > 0 ? { ...loaded, payload: { ...loaded.payload, classesRebuiltFirst: stale.value } } : loaded;
     const declared = created.ok ? readString(created.payload, "class_name") ?? "" : "";
     if (!created.ok || declared === "") {
       return this.answer(created);
@@ -56766,8 +56926,26 @@ ${error.text}`;
     });
   }
   async handleModifyScript(args) {
-    const written = await this.headless("modify_script", args);
     const project = this.project(args);
+    const stale = project.ok ? await this.refreshStaleClasses(project.value.path) : null;
+    if (stale !== null && !stale.ok) {
+      return stale.response;
+    }
+    const loaded = await this.headless("modify_script", args);
+    const first = loaded.content[0];
+    const written = stale === null || stale.value.length === 0 || loaded.isError === true || first?.type !== "text" || !first.text.trimStart().startsWith("{") ? loaded : {
+      ...loaded,
+      content: [
+        {
+          ...first,
+          text: answerJson({
+            ...asParams(JSON.parse(first.text)),
+            classesRebuiltFirst: stale.value
+          })
+        },
+        ...loaded.content.slice(1)
+      ]
+    };
     const scriptPath = readNonEmptyString(args, "scriptPath");
     if (written.isError === true || !project.ok || scriptPath === undefined || !this.editorHasOpen(project.value.path)) {
       return written;
@@ -57744,7 +57922,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", RAISED_WARNING = " (Warning treated as error.)", PARSE_ERROR2 = "Parse Error: ", 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_TIMEOUT_MS = 600000, 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();
@@ -58235,7 +58413,7 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
 These need the runtime autoload, which \`gdharness setup\` registers. \`runtime_capture\` needs a
 window and refuses headless rather than handing back the last frame anything drew. On Windows a
 windowed run this server starts is on a desktop of its own, where it draws and can be captured but
-never shows or takes the keyboard.
+never shows or takes the keyboard or the pointer.
 
 The autoload reads these settings and no others. \`${BIND_ADDRESS_SETTING}\`
 is \`127.0.0.1\` and should stay there: the command set includes \`call_method\`, \`set_property\`
@@ -58748,7 +58926,7 @@ import {
   writeFileSync as writeFileSync12
 } from "node:fs";
 import { availableParallelism as availableParallelism4 } from "node:os";
-import { dirname as dirname13, join as join27, relative as relative4, resolve as resolve10, sep as sep3 } from "node:path";
+import { dirname as dirname13, join as join27, relative as relative5, resolve as resolve10, sep as sep4 } from "node:path";
 import process14 from "node:process";
 
 // src/suite-fingerprint.ts
@@ -58913,6 +59091,7 @@ function getLocalVersion() {
 }
 
 // src/suite-run.ts
+var LAST_RUN_FILE = "last-run.json";
 var SLOWEST_NAMED = 5;
 var SILENCE_TIMES_TAKEN = 4;
 function silenceWhile(running, times, floorSeconds) {
@@ -59083,14 +59262,14 @@ class RunLogs {
     return this.kept ?? this.directory;
   }
   named(path) {
-    return this.kept === null ? path : join27(this.kept, relative4(this.directory, path));
+    return this.kept === null ? path : join27(this.kept, relative5(this.directory, path));
   }
   keep() {
     if (this.kept === null) {
       return;
     }
     for (const file of readdirSync14(this.directory, { recursive: true, encoding: "utf8" })) {
-      if (file.endsWith(".log") && file.split(sep3).length === 2) {
+      if (file.endsWith(".log") && file.split(sep4).length === 2) {
         mkdirSync10(dirname13(join27(this.kept, file)), { recursive: true });
         copyFileSync(join27(this.directory, file), join27(this.kept, file));
       }
@@ -59108,6 +59287,7 @@ async function runTestCommand(options, godotPath) {
   const state = join27(home, ".godot", "gdharness");
   const timesFile = join27(state, "suite-times.json");
   const passedFile = join27(state, "suite-passed.json");
+  const lastRunFile = join27(state, LAST_RUN_FILE);
   let suites = selectedSuites(scripts, options);
   const uncollected = uncollectedSaid(scripts.uncollectedUnder(searchedRoots(options)));
   const wholeSuites = suites.map((suite) => scripts.suite(suite.path) ?? suite);
@@ -59155,7 +59335,7 @@ async function runTestCommand(options, godotPath) {
       const imported = await importProject(launch);
       if (imported !== null) {
         logs.keep();
-        writeEarlyResult(options.resultFile, startedAt, [`the import failed: ${imported}`], logs.shown);
+        writeEarlyResult({ resultFile: options.resultFile, lastRunFile, engines: options.engines }, startedAt, [`the import failed: ${imported}`], logs.shown);
         console.log(`The import failed, so no suite ran: ${imported}`);
         return 1;
       }
@@ -59180,7 +59360,7 @@ ${existsSync23(path) ? readFileSync22(path, "latin1") : "missing"}`)
       if (suites.length === 0) {
         console.log("Nothing has changed since every suite last passed.");
         rmSync12(runDirectory, { recursive: true, force: true });
-        writeEarlyResult(options.resultFile, startedAt, uncollected, null);
+        writeEarlyResult({ resultFile: options.resultFile, lastRunFile, engines: options.engines }, startedAt, uncollected, null);
         if (uncollected.length === 0) {
           return 0;
         }
@@ -59206,26 +59386,31 @@ ${existsSync23(path) ? readFileSync22(path, "latin1") : "missing"}`)
     const functions = suites.reduce((sum, suite) => sum + suite.cases.length, 0);
     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 dealing = [];
+    const say = (line) => {
+      dealing.push(line);
+      console.log(line);
+    };
+    say(`${plural(functions, "test function")} in ${plural(suites.length, "suite")} over ${plural(plans.length, "engine")}${how}.`);
     const windowedAnyway = headlessInAWindow(plans, units);
     if (windowedAnyway.length > 0) {
       const one = windowedAnyway.length === 1;
-      console.log(`${named(windowedAnyway)} ${one ? "says it runs" : "say they run"} headless and ${one ? "runs" : "run"} with a window here, since an ordered run is one engine and a suite in it needs a window. Run ${one ? "it" : "them"} without the windowed suites to run ${one ? "it" : "them"} headless.`);
+      say(`${named(windowedAnyway)} ${one ? "says it runs" : "say they run"} headless and ${one ? "runs" : "run"} with a window here, since an ordered run is one engine and a suite in it needs a window. Run ${one ? "it" : "them"} without the windowed suites to run ${one ? "it" : "them"} headless.`);
     }
     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 ${past} last time: ${named(split)}.`);
+      say(`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 ${past} last time: ${named(byRows)}.`);
+      say(`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)}.`);
+      say(`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 = [];
@@ -59238,11 +59423,11 @@ ${existsSync23(path) ? readFileSync22(path, "latin1") : "missing"}`)
     }
     const shared = options.order === null && lanes.length > 1 && taken.length < lanes.length;
     if (shared) {
-      console.log(sharesSaid(taken.length, lanes.length));
+      say(sharesSaid(taken.length, lanes.length));
     }
     let ran = shared ? await runShares(launch, units, declared, lanes.length, taken, times) : (await Promise.all(lanes.map((lane, at) => runLane(launch, lane, times, taken[at] ?? null)))).flat().sort((a, b) => a.index - b.index);
     if (ran.some((engine) => engine.verdict.starved) && ran.some((engine) => !engine.verdict.passed)) {
-      console.log("An engine ran out of memory, so every engine that failed runs again, one at a time.");
+      say("An engine ran out of memory, so every engine that failed runs again, one at a time.");
       const again = [];
       for (const engine of ran) {
         again.push(engine.verdict.passed ? engine : await runEngine2(launch, engine.plan, engine.index, times, "again"));
@@ -59252,7 +59437,13 @@ ${existsSync23(path) ? readFileSync22(path, "latin1") : "missing"}`)
     writeJson(timesFile, timesAfter(readTimes(timesFile), wholeSuites, ran.map((engine) => engine.printed), (path) => scripts.suite(path), new Set(ran.flatMap((engine) => engine.plan.suites.filter((suite) => (engine.printed.suites.get(suite.path)?.closed ?? null) === null).flatMap((suite) => suite.cases.map((func) => `${suite.path}:${func}`))))));
     const across = rowsAcross(ran.map((engine) => ({ handed: engine.plan.suites, printed: engine.printed })));
     recordPassed(passedFile, ran, printsOf, new Set(across.map((fault) => fault.suite)));
-    return report(ran, across.map((fault) => fault.fault), uncollected, startedAt, logs, options.printOutput, options.resultFile);
+    return report(ran, across.map((fault) => fault.fault), uncollected, startedAt, logs, options.printOutput, {
+      resultFile: options.resultFile,
+      lastRunFile,
+      dealing,
+      engines: options.engines,
+      slotsFree: taken.length
+    });
   } finally {
     process14.off("SIGINT", interrupted);
     process14.off("SIGTERM", interrupted);
@@ -59417,7 +59608,7 @@ async function runEngine2(launch, plan, index, times, again = "", slot = null) {
     ...plan.windowed ? [] : ["--ignoreHeadlessMode"],
     "-c",
     "-rd",
-    `res://${relative4(launch.projectPath, join27(directory, "reports")).split(sep3).join("/")}`,
+    `res://${relative5(launch.projectPath, join27(directory, "reports")).split(sep4).join("/")}`,
     "-rc",
     "1",
     "--",
@@ -59459,6 +59650,7 @@ async function runEngine2(launch, plan, index, times, again = "", slot = null) {
     printed,
     verdict: written === null ? judged : { ...judged, passed: false, faults: [...judged.faults, written] },
     log,
+    began,
     seconds: (Date.now() - began) / 1000,
     again: again !== ""
   };
@@ -59469,11 +59661,11 @@ function reportsFault(reports) {
   if (files.length === 0) {
     return null;
   }
-  const shown = files.slice(0, REPORT_FILES_NAMED).map((file) => file.split(sep3).join("/"));
+  const shown = files.slice(0, REPORT_FILES_NAMED).map((file) => file.split(sep4).join("/"));
   const more = files.length - shown.length;
   return `gdUnit4 wrote ${plural(files.length, "file")} into ${reports} (${shown.join(", ")}${more > 0 ? ` and ${String(more)} more` : ""}), a report the runner had turned off, so the gdUnit4 installed no longer honours a session hook marked off; report it to gdharness with gdUnit4's version`;
 }
-function report(ran, across, uncollected, startedAt, logs, printOutput, resultFile) {
+function report(ran, across, uncollected, startedAt, logs, printOutput, targets) {
   if (printOutput) {
     for (const engine of ran) {
       console.log("");
@@ -59550,27 +59742,31 @@ ${readFileSync22(engine.log, "utf8")}`);
   } else {
     logs.keep();
   }
-  if (resultFile !== null) {
-    writeJson(resultFile, {
-      passed,
-      seconds: took,
-      problems: [
-        ...failed.flatMap((engine) => engine.verdict.faults.map((fault) => `engine ${String(engine.index)}: ${fault}`)),
-        ...across,
-        ...uncollected
-      ],
-      suites: closed,
-      engines: ran.map((engine) => ({
-        index: engine.index,
-        seconds: engine.seconds,
-        dealt: engine.plan.cost,
-        passed: engine.verdict.passed,
-        windowed: engine.plan.windowed,
-        log: passed ? null : logs.named(engine.log)
-      })),
-      logs: passed ? null : logs.shown
-    });
-  }
+  writeResult(targets, {
+    passed,
+    seconds: took,
+    problems: [
+      ...failed.flatMap((engine) => engine.verdict.faults.map((fault) => `engine ${String(engine.index)}: ${fault}`)),
+      ...across,
+      ...uncollected
+    ],
+    suites: closed,
+    engines: ran.map((engine) => ({
+      index: engine.index,
+      lane: engine.plan.lane,
+      startedAfter: (engine.began - startedAt) / 1000,
+      seconds: engine.seconds,
+      dealt: engine.plan.cost,
+      passed: engine.verdict.passed,
+      windowed: engine.plan.windowed,
+      suites: engine.plan.suites.map((suite) => suite.path),
+      log: passed ? null : logs.named(engine.log)
+    })),
+    logs: passed ? null : logs.shown,
+    enginesAsked: targets.engines,
+    slotsFree: targets.slotsFree,
+    dealing: targets.dealing
+  });
   if (passed) {
     console.log(`Passed: ${totals}`);
     return 0;
@@ -59580,16 +59776,23 @@ ${readFileSync22(engine.log, "utf8")}`);
   console.log(`Every engine's output is kept under ${logs.shown} until ${String(KEPT_RUN_DIRECTORIES)} later runs have failed.`);
   return 1;
 }
-function writeEarlyResult(file, startedAt, problems, logs) {
-  if (file !== null) {
-    writeJson(file, {
-      passed: problems.length === 0,
-      seconds: (Date.now() - startedAt) / 1000,
-      problems,
-      suites: [],
-      engines: [],
-      logs
-    });
+function writeEarlyResult(targets, startedAt, problems, logs) {
+  writeResult(targets, {
+    passed: problems.length === 0,
+    seconds: (Date.now() - startedAt) / 1000,
+    problems,
+    suites: [],
+    engines: [],
+    logs,
+    enginesAsked: targets.engines,
+    slotsFree: 0,
+    dealing: []
+  });
+}
+function writeResult(targets, result) {
+  writeJson(targets.lastRunFile, result);
+  if (targets.resultFile !== null) {
+    writeJson(targets.resultFile, result);
   }
 }
 function printUncollected(uncollected) {