gdharness 1.1.45 → 1.1.46

package/build/cli.js

@@ -17588,13 +17588,13 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "project_test",
-      description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Suites where everything passed are counted rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines. The class list is rebuilt first, so a suite written a moment ago is found, and the rebuild's answer is under classes, with the classes each addon declares counted under addedInAddons and changedInAddons rather than named: a class it puts back that the cache had after the last rebuild is named under classes.lostSinceLastRebuild, which is the editor writing its shorter list over the file on every save until restarted. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. On macOS the engine reads user:// off HOME and the run writes where the player keeps theirs, which the answer says under savesNote rather than leaving to be found in a save list. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. A run where nothing failed but nodes were left in the tree comes back under warnings, with the count per suite: gdUnit4 decides its verdict on those and keeps them out of its report, so they are read off what it printed. Needs gdUnit4 under addons/gdUnit4.",
+      description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Suites where everything passed are counted rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines. The class list is rebuilt first, so a suite written a moment ago is found, and the rebuild's answer is under classes, with the classes each addon declares counted under addedInAddons and changedInAddons rather than named: a class it puts back that the cache had after the last rebuild is named under classes.lostSinceLastRebuild, which is the editor writing its shorter list over the file on every save until restarted. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. On macOS the engine reads user:// off HOME and the run writes where the player keeps theirs, which the answer says under savesNote rather than leaving to be found in a save list. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. A script that does not load stops gdUnit4 before any suite runs: its errors come back in full under scriptErrors, and the scripts that failed only because one they depend on did are listed by path under failedThroughDependency. A run where nothing failed but nodes were left in the tree comes back under warnings, with the count per suite: gdUnit4 decides its verdict on those and keeps them out of its report, so they are read off what it printed. Needs gdUnit4 under addons/gdUnit4.",
       parameters: {
         projectPath: PROJECT_PATH,
         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. A run where any entry is not there is refused before the engine starts, naming each one. Default test."
+          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. Default test."
         },
         ignore: {
           type: "array",
@@ -17908,7 +17908,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "editor_run",
-      description: "The run: starting the project, stopping it, or booting it once to see whether it comes up clean. start keeps it running and collecting output until it quits or is stopped, windowed where there is a display and headless where there is not, unless headless says otherwise; only runtime_capture needs the window. A run that quits on its own is kept, so a scene that prints an answer and quits is start, then editor_output until running is false. What runs is a scene: a SceneTree script is not an entry point here, so put the script on the root of a scene of its own and name that in scene. args hands the game its own flags, the ones it reads with OS.get_cmdline_user_args(), and a run carrying any is started by this server rather than by the editor. check boots it headless for a few frames, waits for it to quit, and answers with the verdict: whether it came up, and every error and warning it printed on the way. start and check both wait first for a scan the open editor is running and for the class cache it writes just after, since a game booted in between resolves no global class, as does every other engine this server starts on the project; waitedForEditorScanMs says how long, and scanNote says when a scan ran past thirty seconds and the game started during it. A start waits for the game to become something the runtime_* tools can talk to and says which it is under runtime: listening with the port it took, or why not, so the first call after a start does not have to be made twice. When it is not listening, mayYetAnnounce says whether that is final: false is a runtime that is not coming, true is a game still on its way up, which editor_status will see and runtimeWaitMs waits longer for. A start this server made also answers with transcript, the file both the run's streams are written to, so a watch on it can be armed off the start rather than off a second call.",
+      description: "The run: starting the project, stopping it, or booting it once to see whether it comes up clean. start keeps it running and collecting output until it quits or is stopped, windowed where there is a display and headless where there is not, unless headless says otherwise; only runtime_capture needs the window. A run that quits on its own is kept, so a scene that prints an answer and quits is start, then editor_output until running is false. What runs is a scene: a SceneTree script is not an entry point here, so put the script on the root of a scene of its own and name that in scene. args hands the game its own flags, the ones it reads with OS.get_cmdline_user_args(), and a run carrying any is started by this server rather than by the editor. check boots it headless for a few frames, waits for it to quit, and answers with the verdict: whether it came up, and every error and warning it printed on the way. start and check both wait first for a scan the open editor is running and for the class cache it writes just after, since a game booted in between resolves no global class, as does every other engine this server starts on the project; waitedForEditorScanMs says how long, and scanNote says when a scan ran past thirty seconds and the game started during it. A start waits for the game to become something the runtime_* tools can talk to and says which it is under runtime: listening with the port it took, or why not, so the first call after a start does not have to be made twice. When it is not listening, mayYetAnnounce says whether that is final: false is a runtime that is not coming, true is a game still on its way up, which editor_status will see and runtimeWaitMs waits longer for, and the note then says what a runtime_* call naming no projectPath meets until it announces. A start this server made also answers with transcript, the file both the run's streams are written to, so a watch on it can be armed off the start rather than off a second call.",
       parameters: {
         projectPath: {
           ...PROJECT_PATH,
@@ -18124,7 +18124,7 @@ var init_tool_definitions = __esm(() => {
         property: {
           type: "string",
           ops: ["property", "find"],
-          description: 'property: which one to read. find: read this one off every node matched, so a panel of labels is one call rather than one per label. Colons read through what a node holds, "_game:clock:speed", which is where a game keeps what is worth asking about. A number or a key steps into a list or a map, "_game:run:roster:0:traits", which is how the lists a game keeps its state in are walked: a roster, a board, an in-tray. A packed list, such as a PackedStringArray, steps the same way. A negative number counts from the end. A step written as a call, "get_viewport():gui_get_focus_owner()", calls a method that takes no arguments and only reads (an engine method the engine marks as reading, or a game method not declared -> void, so queue_free() is refused) and walks into what it returned, which is how a question only a method answers is read in one call: which control holds the focus in the viewport this one is in. A list or a map answers the calls that read it and take no arguments, "_game:run:board:size()" or "_game:inbox:keys()", and not those that change it, such as clear() or sort(). A step that is not there is named, and says what was there instead.'
+          description: 'property: which one to read. find: read this one off every node matched, so a panel of labels is one call rather than one per label. Colons read through what a node holds, "_game:clock:speed", which is where a game keeps what is worth asking about. A number or a key steps into a list or a map, "_game:run:roster:0:traits", which is how the lists a game keeps its state in are walked: a roster, a board, an in-tray. A packed list, such as a PackedStringArray, steps the same way. A negative number counts from the end. A step written as a call, "get_viewport():gui_get_focus_owner()", calls a method that only reads (an engine method the engine marks as reading, or a game method not declared -> void, so queue_free() is refused) and walks into what it returned, which is how a question only a method answers is read in one call: which control holds the focus in the viewport this one is in. An engine method that reads takes literal arguments in its brackets, words in double quotes, numbers, true, false or null, so a control\'s theme is read where it is drawn: \'get_theme_stylebox("panel"):content_margin_top\' or \'get_theme_constant("separation")\'. A game method is given none in a path, since nothing marks one as only reading; runtime_invoke call takes those. A list or a map answers the calls that read it and take no arguments, "_game:run:board:size()" or "_game:inbox:keys()", and not those that change it, such as clear() or sort(). A step that is not there is named, and says what was there instead.'
         },
         depth: {
           type: "integer",
@@ -18221,7 +18221,7 @@ var init_tool_definitions = __esm(() => {
         property: {
           type: "string",
           ops: ["set"],
-          description: 'set: which one to write. Colons write through what a node holds, "_game:run:day", and a number or a key steps into a list or a map on the way, "_game:run:roster:0:name", a negative number counting from the end, and a step written as a call, "get_viewport():gui_embed_subwindows", walks through what a method taking no arguments returned. A map keyed by numbers is stepped into by the number, "_game:units:3". The answer reads back off the same holder, and a write that leaves the property as it was is refused and says what it still holds: the engine not taking it and a setter keeping the value look the same, so the refusal names neither. A write of the value the property already holds, at its own precision, as a float given in 64 bits to a property keeping 32, is not refused: it answers unchanged: true.'
+          description: 'set: which one to write. Colons write through what a node holds, "_game:run:day", and a number or a key steps into a list or a map on the way, "_game:run:roster:0:name", a negative number counting from the end, and a step written as a call, "get_viewport():gui_embed_subwindows", walks through what a reading method returned, as runtime_inspect property describes. A map keyed by numbers is stepped into by the number, "_game:units:3". The answer reads back off the same holder, and a write that leaves the property as it was is refused and says what it still holds: the engine not taking it and a setter keeping the value look the same, so the refusal names neither. A write of the value the property already holds, at its own precision, as a float given in 64 bits to a property keeping 32, is not refused: it answers unchanged: true.'
         },
         value: {
           ops: ["set"],
@@ -18231,12 +18231,18 @@ var init_tool_definitions = __esm(() => {
         method: {
           type: "string",
           ops: ["call"],
-          description: 'call: which one to call. Colons call through what a node holds, "_game:run:advance", the same way a property is written through them, a list or a map is stepped into by index or key, "_game:run:roster:0:retire", and a step written as a call walks through what a method taking no arguments returned, "get_viewport():gui_get_focus_owner".'
+          description: 'call: which one to call. Colons call through what a node holds, "_game:run:advance", the same way a property is written through them, a list or a map is stepped into by index or key, "_game:run:roster:0:retire", and a step written as a call walks through what a reading method returned, "get_viewport():gui_get_focus_owner", as runtime_inspect property describes.'
         },
         args: {
           type: "array",
           ops: ["call"],
-          description: `call: the arguments, fitted to the method's parameter types. A parameter typed as an object takes a path naming one the game holds and is handed that instance: a colon path read from nodePath, "_game:run:wares:3", or one starting at a node, "/root/Main/Hud" or "/root/Main:_game:run". A path that reaches no object, or an object of another class than the parameter declares, is refused, and so are too few or too many arguments. The engine names a parameter typed as a script class without class_name by the class the script extends, so an object of that class with another script passes that check and the engine refuses the call: the answer says the method did not run, with the engine's reason. A parameter typed as a list or map, such as Array[int] or Array[Gear], is built from a JSON list or object element by element, objects named by their paths.`
+          description: `call: the arguments, fitted to the method's parameter types. A parameter typed as an object takes a path naming one the game holds and is handed that instance: a colon path read from nodePath, "_game:run:wares:3", or one starting at a node, "/root/Main/Hud" or "/root/Main:_game:run". A path that reaches no object, or an object of another class than the parameter declares, is refused, and so are too few or too many arguments. The engine names a parameter typed as a script class without class_name by the class the script extends, so an object of that class with another script passes that check and the engine refuses the call: the answer says the method did not run, with the engine's reason. A parameter typed as a list or map, such as Array[int] or Array[Gear], is built from a JSON list or object element by element, objects named by their paths. The method itself takes its arguments here only: brackets on it holding arguments are refused.`
+        },
+        properties: {
+          type: ["boolean", "array"],
+          items: { type: "string" },
+          ops: ["call"],
+          description: 'call: read the object the call answered with in the same answer, under result_properties: true for every variable its script declares, or a list of names, each a colon path walked from that object the way property paths are ("dead_allowed", "terms:0:name"). A name that is not there is listed under result_properties_missing with why, and a result that is not an object answers properties_note instead. Without it an object comes back as its class and id only.'
         },
         timeoutMs: {
           type: "integer",
@@ -18318,7 +18324,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "runtime_input",
-      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 or mouse motion. All of it works headless, where the window is 64 by 64 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: the pointer ops answer with pointer_note there, because 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.",
+      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 or mouse motion. All of it works headless, where the window is 64 by 64 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.",
       parameters: {
         projectPath: RUNNING_PROJECT_PATH,
         pid: RUNNING_PID,
@@ -18330,7 +18336,7 @@ var init_tool_definitions = __esm(() => {
         says: {
           type: "string",
           ops: ["click"],
-          description: "click: the words on the control to click, matched the way runtime_inspect find matches says (a plain word is contained in the text, a pattern with * or ? is a glob over it, and | separates alternatives), among the controls on screen, and pressed in the same frame it was found in, so a panel rebuilding between a find and a click cannot free it first. Words on a label inside a button press the button. A control with something drawn over its centre that would take the pointer, such as a screen shown over it or a dialog stacked above its own, is not on screen; nor is one on a hidden canvas layer, one outside the viewport, or one a container clips away that a click does not scroll. The refusal counts those apart. The matches are ranked the way a person picks what to press: an enabled button before anything else, a disabled one included, then a control whose whole text, or one whole line of it such as the title on a card, is the words before one saying them as part of more, and the best one is pressed; found.picked says why. Several matches at the best rank are refused with each one listed, and index picks one."
+          description: "click: the words on the control to click, matched the way runtime_inspect find matches says (a plain word is contained in the text, a pattern with * or ? is a glob over it, and | separates alternatives), among the controls on screen, and pressed in the same frame it was found in, so a panel rebuilding between a find and a click cannot free it first. Words on a label inside a button press the button. A control with something drawn over its centre that would take the pointer, such as a screen shown over it or a dialog stacked above its own, is not on screen; nor is one on a hidden canvas layer, one outside the viewport, or one a container clips away that a click does not scroll. The refusal counts those apart. The matches are ranked the way a person picks what to press: an enabled button before anything else, a disabled one included, then a control whose whole text, or one whole line of it such as the title on a card, is the words before one saying them as part of more, and the best one is pressed; found.picked says why. Several matches at the best rank are refused with each one listed, and index picks one. A match saying the words only as part of more is named under found.partOf, and is refused when a control saying exactly the words is hidden, off the screen or covered, since it would stand in for that one; index presses it anyway. An empty field says its placeholder. An item of an open menu is drawn by the menu rather than held as a control, so a click finds none, and the refusal names the menu and the choose call that picks it."
         },
         action: {
           type: "string",
@@ -41895,10 +41901,13 @@ function runtimeVerdict(endpoint, after) {
   return {
     listening: false,
     mayYetAnnounce: after.running,
-    note: after.running ? `nothing announced itself within ${after.budgetMs}ms${sized} and ${state}, so it may announce a moment from now: editor_status says whether it has, and editor_run start takes runtimeWaitMs to wait longer than this${after.withArgs ? ", which a run carrying its own arguments may well need, since whatever they ask the game to do before its first frame is inside this wait" : ""}` : `nothing announced itself within ${after.budgetMs}ms${sized} and the game is no longer running, so nothing is going to: editor_output has what it printed on the way down`,
+    note: after.running ? `nothing announced itself within ${after.budgetMs}ms${sized} and ${state}, so it may announce a moment from now: editor_status says whether it has, and editor_run start takes runtimeWaitMs to wait longer than this${after.withArgs ? ", which a run carrying its own arguments may well need, since whatever they ask the game to do before its first frame is inside this wait" : ""}. ${untilItAnnounces(after.servesAProject)}` : `nothing announced itself within ${after.budgetMs}ms${sized} and the game is no longer running, so nothing is going to: editor_output has what it printed on the way down`,
     heldAt: null
   };
 }
+function untilItAnnounces(servesAProject) {
+  return servesAProject ? "Until it does, a runtime_* call for it waits briefly and is then refused, and another project's game answers only a call whose projectPath names that project." : "Until it does, a runtime_* call naming no projectPath reaches whichever game is the only one announced, another project's included, so pass projectPath to be sure the answer is this game's.";
+}
 function isOfType(value, kind) {
   switch (kind) {
     case "string":
@@ -42073,18 +42082,29 @@ function settingsNamedBy(op, args) {
       return [];
   }
 }
+function foldedScriptErrors(errors) {
+  const scriptErrors = errors.filter((error) => !error.message.includes(DEPENDED_FAILED));
+  const own = new Set(scriptErrors.map((error) => error.path));
+  return {
+    scriptErrors,
+    failedThroughDependency: [...new Set(errors.map((error) => error.path))].filter((path) => !own.has(path))
+  };
+}
+function nonEmpty(lists) {
+  return Object.fromEntries(Object.entries(lists).filter(([, list]) => list.length > 0));
+}
 function scriptErrorsNote(errors) {
+  const { scriptErrors: own, failedThroughDependency: dependents } = foldedScriptErrors(errors);
   const causes = new Map;
-  for (const error of errors) {
-    if (!error.message.includes(DEPENDED_FAILED) && !causes.has(error.path)) {
+  for (const error of own) {
+    if (!causes.has(error.path)) {
       causes.set(error.path, error);
     }
   }
-  const dependents = [...new Set(errors.map((error) => error.path))].filter((path) => !causes.has(path));
   const scripts = causes.size + dependents.length;
   const named = [...causes.values()].map((error) => `${error.line === null ? error.path : `${error.path}:${error.line}`} ${error.message}${/[.!?]\)?$/.test(error.message) ? "" : "."}`).join(" ");
   const following = dependents.length === 0 ? "" : causes.size === 0 ? `${dependents.join(", ")} ${dependents.length === 1 ? "depends" : "depend"} on a script that did not compile, and gdUnit4 named none with an error of its own: script_diagnostics on one of them finds it.` : `${dependents.length === 1 ? "One more" : `${dependents.length} more`} failed only because a script ${dependents.length === 1 ? "it depends" : "they depend"} on did: ${dependents.join(", ")}.`;
-  const more = errors.filter((error) => !error.message.includes(DEPENDED_FAILED)).length - causes.size;
+  const more = own.length - causes.size;
   const rest = more > 0 ? `${more === 1 ? "One more error" : `${more} more errors`} in ${causes.size === 1 ? "that script" : "those scripts"} ${more === 1 ? "is" : "are"} under scriptErrors.` : "";
   return [
     `No tests ran: gdUnit4 could not load ${scripts === 1 ? "one script" : `${scripts} scripts`} while looking for suites, and it runs no suite at all when one fails to load.`,
@@ -42917,7 +42937,8 @@ class GodotServer {
           ...whichGame(args),
           path: readNonEmptyString(args, "nodePath") ?? "",
           method: readString(args, "method") ?? "",
-          args: readArray(args, "args") ?? []
+          args: readArray(args, "args") ?? [],
+          ...args["properties"] === undefined ? {} : { properties: args["properties"] }
         }, patience);
       }
       case "runtime_capture":
@@ -43711,9 +43732,9 @@ class GodotServer {
     if (!paths.ok) {
       return this.createErrorResponse(paths.reason, PATH_SOLUTIONS);
     }
-    const asked = paths.value;
-    const missing = asked.filter((path) => !existsSync19(join24(project.value.path, path.slice("res://".length))));
-    if (missing.length > 0) {
+    const missing = paths.value.filter((path) => !existsSync19(join24(project.value.path, path.slice("res://".length))));
+    const asked = paths.value.filter((path) => !missing.includes(path));
+    if (asked.length === 0) {
       const verdict = `nothing at ${missing.join(" and ")}`;
       return {
         content: [
@@ -43830,7 +43851,10 @@ class GodotServer {
     const hung = cutShort?.hung ?? false;
     const scriptErrors = timedOut || exitCode !== 105 ? [] : scriptErrorsPrinted(said);
     const brokenScripts = new Set(scriptErrors.map((error) => error.path)).size;
-    const verdict = cutShort !== null ? cutShort.verdict : nothingRan ?? (brokenScripts > 0 ? `script errors in ${brokenScripts === 1 ? "one script" : `${brokenScripts} scripts`}, so no suite ran` : undefined) ?? (exitCode === null ? undefined : verdicts[exitCode]) ?? (run.exitSignal === null ? `exit ${exitCode ?? "unknown"}` : howItExited(run));
+    const ranAs = cutShort !== null ? cutShort.verdict : nothingRan ?? (brokenScripts > 0 ? `script errors in ${brokenScripts === 1 ? "one script" : `${brokenScripts} scripts`}, so no suite ran` : undefined) ?? (exitCode === null ? undefined : verdicts[exitCode]) ?? (run.exitSignal === null ? `exit ${exitCode ?? "unknown"}` : howItExited(run));
+    const nothingAt = missing.join(" and ");
+    const verdict = missing.length === 0 ? ranAs : `${ranAs}; nothing at ${nothingAt}`;
+    const missingNote = missing.length === 0 ? undefined : `Nothing at ${nothingAt}, so ${missing.length === 1 ? "it was" : "they were"} left out and only ${asked.join(", ")} ran; a run of fewer paths than were asked for is not called a pass.${elsewhereIn(project.value.path, missing[0] ?? "")}`;
     const savesNote = savesStayPut() && nothingRan === null ? SAVES_NOT_MOVED_NOTE : undefined;
     const marker = readNonEmptyString(args, "printed");
     const echoed = marker === undefined ? undefined : run.log.select({ severity: "info", sinceLastCall: false, contains: marker, limit: 200 });
@@ -43839,7 +43863,8 @@ class GodotServer {
       ...echoed.omitted > 0 ? { printedOmitted: echoed.omitted } : {}
     };
     if (report === null) {
-      const note = nothingRan !== null ? `No tests ran: ${verdict}.` : scriptErrors.length > 0 ? scriptErrorsNote(scriptErrors) : reportProblem !== null ? `The test run's report could not be read (${reportProblem}); the engine's own verdict was ${verdict}.` : `The test run wrote no report (${verdict}).`;
+      const said = nothingRan !== null ? `No tests ran: ${ranAs}.` : scriptErrors.length > 0 ? scriptErrorsNote(scriptErrors) : reportProblem !== null ? `The test run's report could not be read (${reportProblem}); the engine's own verdict was ${ranAs}.` : `The test run wrote no report (${ranAs}).`;
+      const note = missingNote === undefined ? said : `${said} ${missingNote}`;
       return {
         content: [
           { type: "text", text: note },
@@ -43853,7 +43878,8 @@ class GodotServer {
               exitSignal: run.exitSignal ?? undefined,
               hung,
               ...timedOut ? { timedOut, silentForMs } : {},
-              ...scriptErrors.length > 0 ? { scriptErrors } : {},
+              ...missing.length > 0 ? { missing } : {},
+              ...nonEmpty(foldedScriptErrors(scriptErrors)),
               arguments: cmdArgs,
               entries: forAnswer(printed.slice(0, 60).map(aboveTheRunner)),
               ...printedLines,
@@ -43890,8 +43916,9 @@ class GodotServer {
     });
     const notRun = report.suites.reduce((sum, suite) => sum + Math.max(0, suite.discovered - suite.tests), 0);
     return this.jsonTextResponse({
-      passed: !timedOut && exitCode === 0 && nothingRan === null && report.tests > 0 && report.failures === 0 && report.errors === 0 && hookFailures.length === 0,
+      passed: !timedOut && exitCode === 0 && nothingRan === null && report.tests > 0 && report.failures === 0 && report.errors === 0 && hookFailures.length === 0 && missing.length === 0,
       verdict,
+      ...missing.length > 0 ? { missing } : {},
       ...timedOut ? { timedOut, hung, silentForMs } : {},
       exitCode,
       exitSignal: run.exitSignal ?? undefined,
@@ -43908,7 +43935,10 @@ class GodotServer {
       ...printedLines,
       savesNote,
       ...scanned,
-      note: verdict.startsWith("warnings") && warnings.length === 0 ? "gdUnit4 exits 101 for orphan nodes when nothing failed, and this run printed no count of them: orphan reporting may be off in the project settings." : notRunNote(notRun, readBoolean(args, "failFast") === true),
+      note: [
+        missingNote,
+        ranAs.startsWith("warnings") && warnings.length === 0 ? "gdUnit4 exits 101 for orphan nodes when nothing failed, and this run printed no count of them: orphan reporting may be off in the project settings." : notRunNote(notRun, readBoolean(args, "failFast") === true)
+      ].filter((part) => part !== undefined).join(" ") || undefined,
       suites: unclean.map((suite) => ({
         name: suite.name,
         path: suite.path,
@@ -44682,7 +44712,14 @@ class GodotServer {
   async runtimeUp(projectPath, before, budget, withArgs) {
     const budgetMs = budget.ms;
     if (!existsSync19(join24(projectPath, RUNTIME_AUTOLOAD.path))) {
-      return runtimeVerdict(null, { addon: false, budgetMs, heldAt: null, running: false, withArgs });
+      return runtimeVerdict(null, {
+        addon: false,
+        budgetMs,
+        heldAt: null,
+        running: false,
+        withArgs,
+        servesAProject: this.ownProject !== null
+      });
     }
     let asking = null;
     let editorAskedAt = 0;
@@ -44734,6 +44771,7 @@ class GodotServer {
       heldAt: this.dapClient?.whereItStopped() ?? null,
       running: endpoint !== null || going !== null && await this.runStillGoing(going),
       withArgs,
+      servesAProject: this.ownProject !== null,
       ...going?.throughEditor === true ? { playingSeen: going.seenPlaying === true } : {}
     });
   }
@@ -47978,7 +48016,7 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
 | Where a control is, and whether it is visible | \`runtime_inspect\` \`find\`, \`rect\` |
 | What a property reads right now, on a node whose path you already hold | \`runtime_inspect\` \`property\`, \`runtime_invoke\` |
 | What a property on an object a node holds reads | the same two, with colons: \`_game:clock:speed\` |
-| Which control holds the focus, or anything only a method answers | the same path with a step written as a call, \`get_viewport():gui_get_focus_owner\`, which calls a method taking no arguments that only reads and walks into what it returned |
+| Which control holds the focus, or anything only a method answers | the same path with a step written as a call, \`get_viewport():gui_get_focus_owner\`, which calls a method that only reads and walks into what it returned; an engine method takes literal arguments in the brackets, \`get_theme_constant("separation")\` |
 | Press a button | \`runtime_input click\` with \`says\` and the words on it, which finds it and presses it in the same frame and says what was under the pointer. A \`find\` and then a click by the path it answered is two calls over a generated path, and a panel that rebuilds between them frees the button first; \`nodePath\` narrows where \`says\` looks, and several matches are refused with an \`index\` for each |
 | Press the next thing after a click that changed screen | \`runtime_wait until\` with \`says\` and a word the new screen shows (no \`nodePath\` needed: without one the whole game is searched), then the click. A click sent straight after a screen change lands on a control the new screen is about to free, answers \`landed: true\`, and does nothing; a frame count is a number nobody can pick correctly across a cold start and a warm one, and waiting for the words answered in about 130ms where twenty frames had not been enough |
 | Fill in a field | \`runtime_input click\` on it, then \`runtime_input text\` with \`replace\`; a submitted field has to be clicked again |

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

@@ -233,13 +233,17 @@ func call_method(params: Dictionary) -> Dictionary:
 			var read_from: int = Time.get_ticks_usec()
 			var answered: Variant = Paths.read_under(reached["holder"], spelled)
 			var read_for: int = Time.get_ticks_usec() - read_from
-			return {
+			var listed: Dictionary = {
 				"type": "method_result",
 				"path": node_path,
 				"method": method,
 				"result": _values.serialize(answered),
 				"elapsed_usec": read_for,
 			}
+			var asked_of_it: Variant = params.get("properties")
+			if _reads_the_result(asked_of_it):
+				listed.merge(_read_off_result(answered, asked_of_it))
+			return listed
 		var why: String = (
 			"%s:%s takes no arguments" % [reached["called"], spelled]
 			if Paths.can_read(reached["holder"], spelled)
@@ -258,10 +262,11 @@ func call_method(params: Dictionary) -> Dictionary:
 	# The method a call ends on is the one being called whether or not it carries the brackets a
 	# step along the way would: "get_viewport():gui_get_focus_owner()" is the same call as without
 	# the last pair.
+	var not_called: String = _not_a_method_to_call(holder, named, str(reached["called"]))
+	if not not_called.is_empty():
+		return {"type": "error", "message": not_called}
 	if not Paths.method_of(named).is_empty():
 		named = Paths.method_of(named)
-	if not holder.has_method(named):
-		return {"type": "error", "message": "%s has no method %s" % [reached["called"], named]}
 
 	# Checked before the call rather than left to it. `callv` raises inside the game when an
 	# argument cannot be converted, and an error raised in a game somebody is playing holds it at a
@@ -360,9 +365,98 @@ func call_method(params: Dictionary) -> Dictionary:
 		answer["errors"] = caught.raised.slice(0, ERRORS_KEPT)
 		if caught.raised.size() > ERRORS_KEPT:
 			answer["errors_not_shown"] = caught.raised.size() - ERRORS_KEPT
+	var asked: Variant = params.get("properties")
+	if _reads_the_result(asked):
+		answer.merge(_read_off_result(result, asked))
 	return answer
 
 
+## Why [param named], the last step of a call's method, names no method of [param holder] to call, or
+## "" when it does. Brackets on it holding arguments are refused rather than read: the arguments are
+## taken from args alone, so a call is never made with half of them in one place and half in the
+## other, or with the bracketed ones quietly dropped.
+static func _not_a_method_to_call(holder: Object, named: String, called: String) -> String:
+	var method: String = named
+	if not Paths.method_of(named).is_empty():
+		var bracketed: Dictionary = Paths.arguments_of(named)
+		var in_brackets: Array = bracketed.get("args", [])
+		if bracketed.has("message") or not in_brackets.is_empty():
+			return (
+				"%s:%s: the method a call ends on takes its arguments under args, not in its brackets"
+				% [called, named]
+			)
+		method = Paths.method_of(named)
+	return "" if holder.has_method(method) else "%s has no method %s" % [called, method]
+
+
+## Whether a call's `properties` asks for its result to be read: true, or a list of names.
+static func _reads_the_result(asked: Variant) -> bool:
+	return asked is Array or (asked is bool and asked)
+
+
+## What [param asked] reads off the object a call answered with: every variable its script declares
+## when [param asked] is true, or the properties a list names, each a path walked from the object.
+##
+## In the same answer because an object handed back is otherwise only its class and an id, and
+## reading one field of it meant finding the same object again by a path into the game's private
+## state, which works only where the caller already knows a key. A name that is not there is listed
+## rather than refusing the answer, since the call has run by then and its result is what was asked.
+func _read_off_result(result: Variant, asked: Variant) -> Dictionary:
+	if result is Object and not is_instance_valid(result):
+		return {
+			"properties_note": "the call answered an object that has since been freed, so nothing was read"
+		}
+	if not result is Object:
+		return {
+			"properties_note":
+			"the call answered %s, which has no properties to read" % type_string(typeof(result))
+		}
+	var object: Object = result
+	var wanted: Array[String] = []
+	if asked is Array:
+		for name: Variant in asked:
+			wanted.append(str(name))
+	else:
+		wanted = _script_variables(object)
+	var read: Dictionary = {}
+	var missing: Array[String] = []
+	for path: String in wanted:
+		var walked: Dictionary = _walk_from(object, path)
+		if walked.has("message"):
+			missing.append(str(walked["message"]))
+		else:
+			read[path] = _values.serialize(walked["value"])
+	var answered: Dictionary = {"result_properties": read}
+	if not missing.is_empty():
+		answered["result_properties_missing"] = missing
+	return answered
+
+
+## The variables the script attached to [param object] declares, in the order it declares them.
+static func _script_variables(object: Object) -> Array[String]:
+	var names: Array[String] = []
+	for entry: Dictionary in object.get_property_list():
+		var usage: int = entry.get("usage", 0)
+		if usage & PROPERTY_USAGE_SCRIPT_VARIABLE != 0:
+			names.append(str(entry.get("name", "")))
+	return names
+
+
+## What [param path] reads walked from [param object], as {"value"}, or {"message"} naming the step
+## that is not there, by the same rules a path read from a node follows.
+static func _walk_from(object: Object, path: String) -> Dictionary:
+	var holder: Variant = object
+	var called: String = "the result"
+	for named: String in Paths.steps_of(path):
+		if not (holder is Object or holder is Array or holder is Dictionary or Paths.packed(holder)):
+			return {"message": "%s holds no object to read %s off" % [called, named]}
+		if not Paths.can_read(holder, named):
+			return {"message": Paths.nothing_there(holder, named, called)}
+		holder = Paths.read_under(holder, named)
+		called = "%s:%s" % [called, named]
+	return {"value": holder}
+
+
 ## Why [param given] arguments are the wrong number for [param method], or "" when they are not.
 ##
 ## Asked before the call, because `callv` given the wrong number refuses inside the game and returns

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

@@ -25,6 +25,9 @@ const HEADLESS_VIEWPORT: Vector2 = Vector2(64, 64)
 ## everything that process starts. Kept in step with `DESKTOP_VARIABLE` in src/desktop.ts.
 const DESKTOP_VARIABLE: String = "GDHARNESS_DESKTOP"
 
+## Whether this run has had the pointer note in full; the game process is the run.
+static var _pointer_explained: bool = false
+
 var _host: Node
 var _values: Values
 
@@ -60,13 +63,21 @@ func _init(host: Node, values: Values) -> void:
 ## that would take the screen. What reads the injected event is right, tooltips included, since the
 ## engine places a tooltip from the motion that reached the control.
 static func _pointer_noted(answer: Dictionary) -> Dictionary:
-	if OS.get_environment(DESKTOP_VARIABLE) != "":
+	if OS.get_environment(DESKTOP_VARIABLE) == "":
+		return answer
+	# The fact on every answer and the explanation on the first of the run: a session sends dozens of
+	# pointer calls to one game, and the same four hundred characters on each was most of what came
+	# back.
+	answer["pointer_on_hidden_desktop"] = true
+	if not _pointer_explained:
+		_pointer_explained = true
 		answer["pointer_note"] = (
 			"This game is on gdharness's own desktop, where Windows refuses to say where the"
 			+ " pointer is, so get_mouse_position() on the root window, and get_global_mouse_position()"
 			+ " and get_local_mouse_position() on what is drawn there, read a meaningless position"
 			+ " rather than where this put it. What reads the event itself gets this position: the"
-			+ " control under the pointer, its hover and tooltip, and the game's input handlers."
+			+ " control under the pointer, its hover and tooltip, and the game's input handlers. Said"
+			+ " once a run; pointer_on_hidden_desktop marks every answer it applies to."
 		)
 	return answer
 

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

@@ -83,19 +83,21 @@ const READS_ONLY: String = ", and a path, which a wait reads every frame, only c
 ## at a time rather than handed to that method, which answers null for a path that goes wrong
 ## halfway along and for one that ends on null.
 ##
-## A step written as a call, "get_viewport()", calls a method of that name that takes no arguments
-## and walks into what it returned. Some of what hangs off a node is only reachable by asking:
-## which control holds the focus is a question for the viewport a control is in, and the viewport
-## is a method's answer rather than a property. Spelled with the brackets so a reader sees a call
-## where one happens, and so a method can never shadow a property of the same name. A list or a map
-## answers the calls that read it, "board:size()" or "inbox:keys()", listed in [constant LIST_CALLS]
-## and [constant MAP_CALLS].
+## A step written as a call, "get_viewport()", calls a method of that name and walks into what it
+## returned. Some of what hangs off a node is only reachable by asking: which control holds the
+## focus is a question for the viewport a control is in, and the viewport is a method's answer
+## rather than a property. Spelled with the brackets so a reader sees a call where one happens, and
+## so a method can never shadow a property of the same name. A list or a map answers the calls that
+## read it, "board:size()" or "inbox:keys()", listed in [constant LIST_CALLS] and
+## [constant MAP_CALLS]. An engine method that reads takes literal arguments in the brackets,
+## "get_theme_stylebox(\"panel\"):content_margin_top", since what a control's theme gives it is only
+## reachable by naming what is asked for; see [method arguments_of].
 ##
 ## Answers with a `message` instead when a step along the way is not there or holds something that
 ## is not an object, naming the step rather than the whole path: "/root/Main:_game has no property
 ## clocks" is a typo found, and "no property _game:clocks:speed" is a puzzle.
 static func walk_to(node: Node, node_path: String, reaching: String) -> Dictionary:
-	var parts: PackedStringArray = reaching.split(":")
+	var parts: PackedStringArray = steps_of(reaching)
 	var holder: Variant = node
 	var called: String = node_path
 	for step: int in parts.size() - 1:
@@ -187,26 +189,33 @@ static func nothing_under(holder: Variant, named: String, called: String) -> Str
 ## first one. An index reads the way a property does, and a negative one counts from the end the
 ## way GDScript's own does, so reading the last of something does not mean asking how many first.
 static func can_read(holder: Variant, named: String) -> bool:
+	var method: String = method_of(named)
+	var given: Dictionary = arguments_of(named) if not method.is_empty() else {"args": []}
+	if given.has("message"):
+		return false
+	var args: Array = given["args"]
 	if holder is Array:
 		var items: Array = holder
-		var list_call: String = method_of(named)
-		if not list_call.is_empty():
-			return list_call in LIST_CALLS and not (items.is_empty() and list_call in NEEDS_AN_ELEMENT)
+		if not method.is_empty():
+			return (
+				args.is_empty()
+				and method in LIST_CALLS
+				and not (items.is_empty() and method in NEEDS_AN_ELEMENT)
+			)
 		return _index_in(named, items.size()) != -1
 	if packed(holder):
-		if not method_of(named).is_empty():
-			return method_of(named) in PACKED_CALLS
+		if not method.is_empty():
+			return args.is_empty() and method in PACKED_CALLS
 		return _index_in(named, len(holder)) != -1
 	if holder is Dictionary:
 		var map: Dictionary = holder
-		if not method_of(named).is_empty():
-			return method_of(named) in MAP_CALLS
+		if not method.is_empty():
+			return args.is_empty() and method in MAP_CALLS
 		return not _key_in(map, named).is_empty()
 	if holder is Object:
 		var object: Object = holder
-		var method: String = method_of(named)
 		if not method.is_empty():
-			return call_refused(object, method, "").is_empty()
+			return call_refused(object, method, "", args.size()).is_empty()
 		return _has_property(object, named)
 	return false
 
@@ -236,24 +245,103 @@ static func _key_in(map: Dictionary, named: String) -> Array:
 	return []
 
 
-## The method a step written as a call names, "get_viewport()" being get_viewport, or "" for a
-## step that is a name.
+## [param reaching] split into its steps at each colon, except one inside a call's brackets or a
+## quoted argument: `get_node("/root/Main"):name` is two steps, and split at every colon a quoted
+## argument holding one became a step that names nothing.
+static func steps_of(reaching: String) -> PackedStringArray:
+	var steps: PackedStringArray = []
+	var step: String = ""
+	var depth: int = 0
+	var quoted: bool = false
+	var escaped: bool = false
+	for character: String in reaching:
+		if quoted:
+			if escaped:
+				escaped = false
+			elif character == "\\":
+				escaped = true
+			elif character == '"':
+				quoted = false
+		elif character == '"':
+			quoted = true
+		elif character == "(":
+			depth += 1
+		elif character == ")":
+			depth = maxi(depth - 1, 0)
+		elif character == ":" and depth == 0:
+			var _kept: bool = steps.push_back(step)
+			step = ""
+			continue
+		step += character
+	var _last: bool = steps.push_back(step)
+	return steps
+
+
+## The method a step written as a call names, "get_viewport()" being get_viewport and
+## `get_theme_constant("separation")` get_theme_constant, or "" for a step that is a name.
 static func method_of(named: String) -> String:
-	return named.trim_suffix("()") if named.ends_with("()") else ""
+	if not named.ends_with(")"):
+		return ""
+	var opened: int = named.find("(")
+	if opened < 1:
+		return ""
+	var method: String = named.substr(0, opened)
+	return method if method.is_valid_ascii_identifier() else ""
 
 
-## How many arguments [param method] on [param object] has to be given, or -1 when there is no such
-## method. Read off the method list rather than [method Object.has_method], because a path can only
-## call a method with nothing, and a method with a required argument called with nothing raises
-## inside the game rather than answering.
-static func _arguments_required(object: Object, method: String) -> int:
+## The arguments a call step gives in its brackets, as {"args"}, or {"message"} saying why they are
+## not ones a path can give.
+##
+## Literals only: words in double quotes, numbers, true, false and null, read as JSON reads them, a
+## whole number as an int. A path names what is read, and an argument that was itself a path or an
+## object would make a read depend on other state in a way the step does not show.
+static func arguments_of(named: String) -> Dictionary:
+	var inside: String = named.substr(named.find("(") + 1, named.length() - named.find("(") - 2).strip_edges()
+	if inside.is_empty():
+		return {"args": []}
+	var reader: JSON = JSON.new()
+	var parsed: Variant = reader.data if reader.parse("[%s]" % inside) == OK else null
+	if not parsed is Array:
+		return {"message": _not_literals(named)}
+	var args: Array = []
+	for given: Variant in parsed:
+		if given is float:
+			var number: float = given
+			if number == floorf(number) and absf(number) < 9.0e15:
+				args.append(int(number))
+			else:
+				args.append(number)
+		elif given == null or given is String or given is bool:
+			args.append(given)
+		else:
+			return {"message": _not_literals(named)}
+	return {"args": args}
+
+
+static func _not_literals(named: String) -> String:
+	return (
+		"%s: a path gives a call literal arguments only, words in double quotes, numbers, true, false or null"
+		% named
+	)
+
+
+## How many arguments [param method] on [param object] takes, as {"least", "most", "any_more"}, or
+## an empty map when there is no such method. Read off the method list rather than
+## [method Object.has_method], because a method given too few or too many raises inside the game
+## rather than answering.
+static func _arity(object: Object, method: String) -> Dictionary:
 	for entry: Dictionary in object.get_method_list():
 		if str(entry.get("name", "")) != method:
 			continue
 		var params: Array = entry.get("args", [])
 		var defaults: Array = entry.get("default_args", [])
-		return params.size() - defaults.size()
-	return -1
+		var flags: int = entry.get("flags", 0)
+		return {
+			"least": params.size() - defaults.size(),
+			"most": params.size(),
+			"any_more": flags & METHOD_FLAG_VARARG != 0,
+		}
+	return {}
 
 
 ## Why a path may not call [param method] on [param object], said about [param called_as], or ""
@@ -265,16 +353,36 @@ static func _arguments_required(object: Object, method: String) -> int:
 ## doing something and answering nothing, and one left untyped is trusted. Without this a find
 ## with property "queue_free()" freed every node it matched, and a wait on "advance_day()" called
 ## it once a frame and then reported the state it had driven the game to.
-static func call_refused(object: Object, method: String, called_as: String) -> String:
-	var required: int = _arguments_required(object, method)
-	if required == -1:
+##
+## Given [param given] arguments, a call is the engine's and marked as reading, or it is refused. A
+## game's method taking arguments is trusted on nothing at all: one answering a value can as well
+## change what it was asked about, and runtime_invoke call is how one is called on purpose.
+static func call_refused(object: Object, method: String, called_as: String, given: int = 0) -> String:
+	var arity: Dictionary = _arity(object, method)
+	if arity.is_empty():
 		return "%s has no method %s" % [called_as, method]
-	if required > 0:
+	var least: int = arity["least"]
+	var most: int = arity["most"]
+	var any_more: bool = arity["any_more"]
+	var scripted: Dictionary = _script_method(object, method)
+	if not scripted.is_empty() and (given > 0 or least > 0):
+		var why: String = (
+			"since nothing marks one as only reading%s; runtime_invoke call takes them" % READS_ONLY
+		)
 		return (
-			"%s.%s takes %d argument%s, and a path can only call a method that takes none"
-			% [called_as, method, required, "" if required == 1 else "s"]
+			"%s.%s is the game's own and a path gives a game's method no arguments, %s"
+			% [called_as, method, why]
+		)
+	if given < least or (given > most and not any_more):
+		var takes: String = "%d" % least
+		if any_more:
+			takes = "at least %d" % least
+		elif most != least:
+			takes = "%d to %d" % [least, most]
+		return (
+			'%s.%s takes %s argument%s and the path gives it %d, in the brackets as in %s("name")'
+			% [called_as, method, takes, "" if takes == "1" else "s", given, method]
 		)
-	var scripted: Dictionary = _script_method(object, method)
 	if not scripted.is_empty():
 		var returned: Dictionary = scripted.get("return", {})
 		var usage: int = returned.get("usage", 0)
@@ -350,7 +458,8 @@ static func read_under(holder: Variant, named: String) -> Variant:
 	var object: Object = holder
 	var method: String = method_of(named)
 	if not method.is_empty():
-		return object.call(method)
+		var args: Array = arguments_of(named)["args"]
+		return object.callv(method, args)
 	return object.get(named)
 
 
@@ -374,20 +483,25 @@ static func _index_in(named: String, size: int) -> int:
 ## the whole path, because the step is the typo.
 static func nothing_there(holder: Variant, named: String, called_as: String) -> String:
 	var container_call: String = method_of(named)
+	var given: Dictionary = arguments_of(named) if not container_call.is_empty() else {"args": []}
+	if given.has("message"):
+		return "%s:%s" % [called_as, given["message"]]
+	var given_args: Array = given["args"]
+	var given_count: int = given_args.size()
 	if holder is Array:
 		var items: Array = holder
 		if container_call in NEEDS_AN_ELEMENT and items.is_empty():
 			return "%s is an empty list, so it has no %s" % [called_as, named]
 		if not container_call.is_empty():
-			return container_calls_refused(called_as, "a list", container_call)
+			return container_calls_refused(called_as, "a list", container_call, given_count)
 		return "%s is a list of %d, so there is no %s in it" % [called_as, items.size(), named]
 	if packed(holder):
 		if not container_call.is_empty():
-			return container_calls_refused(called_as, "a packed list", container_call)
+			return container_calls_refused(called_as, "a packed list", container_call, given_count)
 		return "%s is a packed list of %d, so there is no %s in it" % [called_as, len(holder), named]
 	if holder is Dictionary:
 		if not container_call.is_empty():
-			return container_calls_refused(called_as, "a map", container_call)
+			return container_calls_refused(called_as, "a map", container_call, given_count)
 		var map: Dictionary = holder
 		var keys: Array = map.keys()
 		# A key reading as the step and still not reached is one of a type a step cannot spell, and
@@ -410,7 +524,7 @@ static func nothing_there(holder: Variant, named: String, called_as: String) ->
 	var object: Object = holder
 	var method: String = method_of(named)
 	if not method.is_empty():
-		return call_refused(object, method, called_as)
+		return call_refused(object, method, called_as, given_count)
 	# A method spelled as a property is the likeliest thing behind a name the object has no property
 	# for, and the caller is one pair of brackets away from what they meant.
 	if object.has_method(named):
@@ -422,13 +536,18 @@ static func nothing_there(holder: Variant, named: String, called_as: String) ->
 
 
 ## Why [param method] is not a call a path makes on [param sort] ("a list", "a packed list" or "a
-## map"), naming the calls it does make.
-static func container_calls_refused(called_as: String, sort: String, method: String) -> String:
+## map"), naming the calls it does make, or that it makes this one with no arguments when
+## [param given] were.
+static func container_calls_refused(
+	called_as: String, sort: String, method: String, given: int = 0
+) -> String:
 	var calls: Array[String] = MAP_CALLS
 	if sort == "a list":
 		calls = LIST_CALLS
 	elif sort == "a packed list":
 		calls = PACKED_CALLS
+	if given > 0 and method in calls:
+		return "%s is %s, and a path calls %s() on one with no arguments" % [called_as, sort, method]
 	var spelled: Array[String] = []
 	for each: String in calls:
 		spelled.append(each + "()")

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

@@ -42,12 +42,19 @@ static func control_saying(root: Node, root_path: String, wanted: String, which:
 	var said: Array[String] = []
 	var exact: Array[bool] = []
 	var hidden: int = 0
+	# 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] = []
+	var out_of_reach_as: Array[String] = []
 	var pending: Array[Node] = [reached["node"]]
 	while not pending.is_empty():
 		var node: Node = pending.pop_front()
 		if node is Control and Says.says(node, wanted):
 			if not Queries.shown(node):
 				hidden += 1
+				if _says_exactly(Words.said_by(node), wanted):
+					exact_out_of_reach.append(node)
+					out_of_reach_as.append("hidden")
 			else:
 				var control: Control = node
 				var target: Control = _pressed_through(control)
@@ -74,12 +81,18 @@ static func control_saying(root: Node, root_path: String, wanted: String, which:
 	for index: int in matched.size():
 		if _off_screen(matched[index]):
 			outside += 1
+			if exact[index]:
+				exact_out_of_reach.append(matched[index])
+				out_of_reach_as.append("outside what the screen shows")
 			continue
 		var over: Node = _cover_of(matched[index], drawn, areas)
 		if over == null:
 			open.append(index)
 		else:
 			covered += 1
+			if exact[index]:
+				exact_out_of_reach.append(matched[index])
+				out_of_reach_as.append("under %s, which is drawn over it" % over.get_path())
 			if cover == null:
 				cover = over
 	# Stable, so matches of one rank keep the order they are drawn in.
@@ -92,10 +105,12 @@ static func control_saying(root: Node, root_path: String, wanted: String, which:
 	var targets: Array[Control] = []
 	var ranks: Array[int] = []
 	var lines: Array[String] = []
+	var wholes: Array[bool] = []
 	for index: int in open:
 		targets.append(matched[index])
 		ranks.append(_rank(matched[index], exact[index]))
 		lines.append(said[index])
+		wholes.append(exact[index])
 
 	var under: String = "" if root_path == "/root" else " under %s" % root_path
 	if targets.is_empty():
@@ -103,8 +118,15 @@ static func control_saying(root: Node, root_path: String, wanted: String, which:
 			"type": "error",
 			"message":
 			(
-				'no control on screen%s says "%s", so nothing was clicked%s%s%s'
-				% [under, wanted, _hidden_note(hidden), _outside_note(outside), _covered_note(covered, cover)]
+				'no control on screen%s says "%s", so nothing was clicked%s%s%s%s'
+				% [
+					under,
+					wanted,
+					_hidden_note(hidden),
+					_outside_note(outside),
+					_covered_note(covered, cover),
+					_open_menu_note(root, wanted),
+				]
 			)
 		}
 	var best: int = ranks.count(ranks[0])
@@ -129,7 +151,33 @@ static func control_saying(root: Node, root_path: String, wanted: String, which:
 				% [str(which), targets.size(), plural, under, wanted, _candidates(targets, lines)]
 			)
 		}
+	# A word inside a sentence on screen, while a control saying exactly that word is out of reach: the
+	# sentence is a stand-in, not the control meant. A tab reading "Out" sat in a collapsed drawer, and
+	# a click on it pressed a dispatch saying somebody "fell out in the hall". Pressed only when asked
+	# for by index, which is the caller saying the sentence is what they meant.
+	if which == null and not wholes[index] and not exact_out_of_reach.is_empty():
+		return {
+			"type": "error",
+			"message":
+			(
+				(
+					'no control on screen%s says exactly "%s", so nothing was clicked: %s %s says it as part of'
+					+ ' "%s", while %s; pass index %d to press that one anyway, or bring the other into view'
+				)
+				% [
+					under,
+					wanted,
+					"the one on screen," if targets.size() == 1 else "the best match on screen,",
+					targets[index].get_path(),
+					_shortened(lines[index]),
+					_out_of_reach_exactly(exact_out_of_reach, out_of_reach_as),
+					index,
+				]
+			)
+		}
 	var found: Dictionary = {"says": wanted, "index": index, "of": targets.size()}
+	if not wholes[index]:
+		found["partOf"] = _shortened(lines[index])
 	if which == null and targets.size() > 1:
 		var others: String = (
 			"the other one on screen %s" % _passed_over(ranks[0], true)
@@ -515,10 +563,48 @@ static func _layer_of(control: Control) -> int:
 static func _candidates(targets: Array[Control], said: Array[String]) -> String:
 	var named: Array[String] = []
 	for index: int in mini(targets.size(), LISTED_CANDIDATES):
-		var words: String = said[index].replace("\n", " ")
-		if words.length() > 60:
-			words = words.substr(0, 57) + "..."
-		named.append('%d %s ("%s")' % [index, targets[index].get_path(), words])
+		named.append('%d %s ("%s")' % [index, targets[index].get_path(), _shortened(said[index])])
 	if targets.size() > LISTED_CANDIDATES:
 		named.append("and %d more" % (targets.size() - LISTED_CANDIDATES))
 	return "; ".join(named)
+
+
+## What to add to a refusal that found nothing on screen, when an open menu has an item saying the
+## words: a menu draws its items rather than holding a control for each, so a click finds none, while
+## a wait for the words finds the item. A wait met on "Leave the hall" was followed by a click on it
+## refused as nothing on screen saying it, with no word of the call that chooses it.
+static func _open_menu_note(root: Node, wanted: String) -> String:
+	var pending: Array[Node] = [root]
+	while not pending.is_empty():
+		var node: Node = pending.pop_back()
+		var menu: PopupMenu = node as PopupMenu
+		if menu != null and menu.visible:
+			for item: int in menu.item_count:
+				var text: String = menu.get_item_text(item)
+				if Says.matches(text, wanted):
+					var owner: Node = menu.get_parent()
+					var named: Node = owner if owner is MenuButton or owner is OptionButton else menu
+					return (
+						(
+							'; the open menu %s has an item saying it, "%s", which a click cannot reach:'
+							+ ' choose it with runtime_input choose, path %s and text "%s"'
+						)
+						% [menu.get_path(), text, named.get_path(), text]
+					)
+		pending.append_array(node.get_children(true))
+	return ""
+
+
+## [param words] on one line and at most sixty characters, for naming a control by what it says.
+static func _shortened(words: String) -> String:
+	var flat: String = words.replace("\n", " ").strip_edges()
+	return flat if flat.length() <= 60 else flat.substr(0, 57) + "..."
+
+
+## The controls in [param nodes], each saying the words exactly and out of a click's reach for the
+## reason [param why] holds at the same place, as the end of a sentence.
+static func _out_of_reach_exactly(nodes: Array[Node], why: Array[String]) -> String:
+	var first: String = "%s, %s" % [nodes[0].get_path(), why[0]]
+	if nodes.size() == 1:
+		return "1 control says exactly that and cannot be clicked: %s" % first
+	return "%d controls say exactly that and cannot be clicked, such as %s" % [nodes.size(), first]

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

@@ -139,12 +139,16 @@ static func _text_of(node: Node) -> String:
 	if not text is String:
 		return ""
 	var words: String = text
-	# What somebody typed is drawn as typed, never translated.
+	# What somebody typed is drawn as typed, never translated. An empty field draws its placeholder
+	# instead, which is what a player reads it by: a search field was found by nothing it showed.
 	if node is LineEdit:
 		var field: LineEdit = node
+		if words.is_empty():
+			return field.atr(field.placeholder_text).strip_edges()
 		return masked(field) if field.secret else words.strip_edges()
 	if node is TextEdit:
-		return words.strip_edges()
+		var area: TextEdit = node
+		return (area.atr(area.placeholder_text) if words.is_empty() else words).strip_edges()
 	words = node.atr(words)
 	if node is Label3D:
 		var sign_text: Label3D = node

package/build/index.js

@@ -33085,13 +33085,13 @@ var TOOL_SPECS = [
   },
   {
     name: "project_test",
-    description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Suites where everything passed are counted rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines. The class list is rebuilt first, so a suite written a moment ago is found, and the rebuild's answer is under classes, with the classes each addon declares counted under addedInAddons and changedInAddons rather than named: a class it puts back that the cache had after the last rebuild is named under classes.lostSinceLastRebuild, which is the editor writing its shorter list over the file on every save until restarted. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. On macOS the engine reads user:// off HOME and the run writes where the player keeps theirs, which the answer says under savesNote rather than leaving to be found in a save list. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. A run where nothing failed but nodes were left in the tree comes back under warnings, with the count per suite: gdUnit4 decides its verdict on those and keeps them out of its report, so they are read off what it printed. Needs gdUnit4 under addons/gdUnit4.",
+    description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Suites where everything passed are counted rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines. The class list is rebuilt first, so a suite written a moment ago is found, and the rebuild's answer is under classes, with the classes each addon declares counted under addedInAddons and changedInAddons rather than named: a class it puts back that the cache had after the last rebuild is named under classes.lostSinceLastRebuild, which is the editor writing its shorter list over the file on every save until restarted. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. On macOS the engine reads user:// off HOME and the run writes where the player keeps theirs, which the answer says under savesNote rather than leaving to be found in a save list. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. A script that does not load stops gdUnit4 before any suite runs: its errors come back in full under scriptErrors, and the scripts that failed only because one they depend on did are listed by path under failedThroughDependency. A run where nothing failed but nodes were left in the tree comes back under warnings, with the count per suite: gdUnit4 decides its verdict on those and keeps them out of its report, so they are read off what it printed. Needs gdUnit4 under addons/gdUnit4.",
     parameters: {
       projectPath: PROJECT_PATH,
       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. A run where any entry is not there is refused before the engine starts, naming each one. Default test."
+        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. Default test."
       },
       ignore: {
         type: "array",
@@ -33405,7 +33405,7 @@ var TOOL_SPECS = [
   },
   {
     name: "editor_run",
-    description: "The run: starting the project, stopping it, or booting it once to see whether it comes up clean. start keeps it running and collecting output until it quits or is stopped, windowed where there is a display and headless where there is not, unless headless says otherwise; only runtime_capture needs the window. A run that quits on its own is kept, so a scene that prints an answer and quits is start, then editor_output until running is false. What runs is a scene: a SceneTree script is not an entry point here, so put the script on the root of a scene of its own and name that in scene. args hands the game its own flags, the ones it reads with OS.get_cmdline_user_args(), and a run carrying any is started by this server rather than by the editor. check boots it headless for a few frames, waits for it to quit, and answers with the verdict: whether it came up, and every error and warning it printed on the way. start and check both wait first for a scan the open editor is running and for the class cache it writes just after, since a game booted in between resolves no global class, as does every other engine this server starts on the project; waitedForEditorScanMs says how long, and scanNote says when a scan ran past thirty seconds and the game started during it. A start waits for the game to become something the runtime_* tools can talk to and says which it is under runtime: listening with the port it took, or why not, so the first call after a start does not have to be made twice. When it is not listening, mayYetAnnounce says whether that is final: false is a runtime that is not coming, true is a game still on its way up, which editor_status will see and runtimeWaitMs waits longer for. A start this server made also answers with transcript, the file both the run's streams are written to, so a watch on it can be armed off the start rather than off a second call.",
+    description: "The run: starting the project, stopping it, or booting it once to see whether it comes up clean. start keeps it running and collecting output until it quits or is stopped, windowed where there is a display and headless where there is not, unless headless says otherwise; only runtime_capture needs the window. A run that quits on its own is kept, so a scene that prints an answer and quits is start, then editor_output until running is false. What runs is a scene: a SceneTree script is not an entry point here, so put the script on the root of a scene of its own and name that in scene. args hands the game its own flags, the ones it reads with OS.get_cmdline_user_args(), and a run carrying any is started by this server rather than by the editor. check boots it headless for a few frames, waits for it to quit, and answers with the verdict: whether it came up, and every error and warning it printed on the way. start and check both wait first for a scan the open editor is running and for the class cache it writes just after, since a game booted in between resolves no global class, as does every other engine this server starts on the project; waitedForEditorScanMs says how long, and scanNote says when a scan ran past thirty seconds and the game started during it. A start waits for the game to become something the runtime_* tools can talk to and says which it is under runtime: listening with the port it took, or why not, so the first call after a start does not have to be made twice. When it is not listening, mayYetAnnounce says whether that is final: false is a runtime that is not coming, true is a game still on its way up, which editor_status will see and runtimeWaitMs waits longer for, and the note then says what a runtime_* call naming no projectPath meets until it announces. A start this server made also answers with transcript, the file both the run's streams are written to, so a watch on it can be armed off the start rather than off a second call.",
     parameters: {
       projectPath: {
         ...PROJECT_PATH,
@@ -33621,7 +33621,7 @@ var TOOL_SPECS = [
       property: {
         type: "string",
         ops: ["property", "find"],
-        description: 'property: which one to read. find: read this one off every node matched, so a panel of labels is one call rather than one per label. Colons read through what a node holds, "_game:clock:speed", which is where a game keeps what is worth asking about. A number or a key steps into a list or a map, "_game:run:roster:0:traits", which is how the lists a game keeps its state in are walked: a roster, a board, an in-tray. A packed list, such as a PackedStringArray, steps the same way. A negative number counts from the end. A step written as a call, "get_viewport():gui_get_focus_owner()", calls a method that takes no arguments and only reads (an engine method the engine marks as reading, or a game method not declared -> void, so queue_free() is refused) and walks into what it returned, which is how a question only a method answers is read in one call: which control holds the focus in the viewport this one is in. A list or a map answers the calls that read it and take no arguments, "_game:run:board:size()" or "_game:inbox:keys()", and not those that change it, such as clear() or sort(). A step that is not there is named, and says what was there instead.'
+        description: 'property: which one to read. find: read this one off every node matched, so a panel of labels is one call rather than one per label. Colons read through what a node holds, "_game:clock:speed", which is where a game keeps what is worth asking about. A number or a key steps into a list or a map, "_game:run:roster:0:traits", which is how the lists a game keeps its state in are walked: a roster, a board, an in-tray. A packed list, such as a PackedStringArray, steps the same way. A negative number counts from the end. A step written as a call, "get_viewport():gui_get_focus_owner()", calls a method that only reads (an engine method the engine marks as reading, or a game method not declared -> void, so queue_free() is refused) and walks into what it returned, which is how a question only a method answers is read in one call: which control holds the focus in the viewport this one is in. An engine method that reads takes literal arguments in its brackets, words in double quotes, numbers, true, false or null, so a control\'s theme is read where it is drawn: \'get_theme_stylebox("panel"):content_margin_top\' or \'get_theme_constant("separation")\'. A game method is given none in a path, since nothing marks one as only reading; runtime_invoke call takes those. A list or a map answers the calls that read it and take no arguments, "_game:run:board:size()" or "_game:inbox:keys()", and not those that change it, such as clear() or sort(). A step that is not there is named, and says what was there instead.'
       },
       depth: {
         type: "integer",
@@ -33718,7 +33718,7 @@ var TOOL_SPECS = [
       property: {
         type: "string",
         ops: ["set"],
-        description: 'set: which one to write. Colons write through what a node holds, "_game:run:day", and a number or a key steps into a list or a map on the way, "_game:run:roster:0:name", a negative number counting from the end, and a step written as a call, "get_viewport():gui_embed_subwindows", walks through what a method taking no arguments returned. A map keyed by numbers is stepped into by the number, "_game:units:3". The answer reads back off the same holder, and a write that leaves the property as it was is refused and says what it still holds: the engine not taking it and a setter keeping the value look the same, so the refusal names neither. A write of the value the property already holds, at its own precision, as a float given in 64 bits to a property keeping 32, is not refused: it answers unchanged: true.'
+        description: 'set: which one to write. Colons write through what a node holds, "_game:run:day", and a number or a key steps into a list or a map on the way, "_game:run:roster:0:name", a negative number counting from the end, and a step written as a call, "get_viewport():gui_embed_subwindows", walks through what a reading method returned, as runtime_inspect property describes. A map keyed by numbers is stepped into by the number, "_game:units:3". The answer reads back off the same holder, and a write that leaves the property as it was is refused and says what it still holds: the engine not taking it and a setter keeping the value look the same, so the refusal names neither. A write of the value the property already holds, at its own precision, as a float given in 64 bits to a property keeping 32, is not refused: it answers unchanged: true.'
       },
       value: {
         ops: ["set"],
@@ -33728,12 +33728,18 @@ var TOOL_SPECS = [
       method: {
         type: "string",
         ops: ["call"],
-        description: 'call: which one to call. Colons call through what a node holds, "_game:run:advance", the same way a property is written through them, a list or a map is stepped into by index or key, "_game:run:roster:0:retire", and a step written as a call walks through what a method taking no arguments returned, "get_viewport():gui_get_focus_owner".'
+        description: 'call: which one to call. Colons call through what a node holds, "_game:run:advance", the same way a property is written through them, a list or a map is stepped into by index or key, "_game:run:roster:0:retire", and a step written as a call walks through what a reading method returned, "get_viewport():gui_get_focus_owner", as runtime_inspect property describes.'
       },
       args: {
         type: "array",
         ops: ["call"],
-        description: `call: the arguments, fitted to the method's parameter types. A parameter typed as an object takes a path naming one the game holds and is handed that instance: a colon path read from nodePath, "_game:run:wares:3", or one starting at a node, "/root/Main/Hud" or "/root/Main:_game:run". A path that reaches no object, or an object of another class than the parameter declares, is refused, and so are too few or too many arguments. The engine names a parameter typed as a script class without class_name by the class the script extends, so an object of that class with another script passes that check and the engine refuses the call: the answer says the method did not run, with the engine's reason. A parameter typed as a list or map, such as Array[int] or Array[Gear], is built from a JSON list or object element by element, objects named by their paths.`
+        description: `call: the arguments, fitted to the method's parameter types. A parameter typed as an object takes a path naming one the game holds and is handed that instance: a colon path read from nodePath, "_game:run:wares:3", or one starting at a node, "/root/Main/Hud" or "/root/Main:_game:run". A path that reaches no object, or an object of another class than the parameter declares, is refused, and so are too few or too many arguments. The engine names a parameter typed as a script class without class_name by the class the script extends, so an object of that class with another script passes that check and the engine refuses the call: the answer says the method did not run, with the engine's reason. A parameter typed as a list or map, such as Array[int] or Array[Gear], is built from a JSON list or object element by element, objects named by their paths. The method itself takes its arguments here only: brackets on it holding arguments are refused.`
+      },
+      properties: {
+        type: ["boolean", "array"],
+        items: { type: "string" },
+        ops: ["call"],
+        description: 'call: read the object the call answered with in the same answer, under result_properties: true for every variable its script declares, or a list of names, each a colon path walked from that object the way property paths are ("dead_allowed", "terms:0:name"). A name that is not there is listed under result_properties_missing with why, and a result that is not an object answers properties_note instead. Without it an object comes back as its class and id only.'
       },
       timeoutMs: {
         type: "integer",
@@ -33815,7 +33821,7 @@ var TOOL_SPECS = [
   },
   {
     name: "runtime_input",
-    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 or mouse motion. All of it works headless, where the window is 64 by 64 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: the pointer ops answer with pointer_note there, because 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.",
+    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 or mouse motion. All of it works headless, where the window is 64 by 64 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.",
     parameters: {
       projectPath: RUNNING_PROJECT_PATH,
       pid: RUNNING_PID,
@@ -33827,7 +33833,7 @@ var TOOL_SPECS = [
       says: {
         type: "string",
         ops: ["click"],
-        description: "click: the words on the control to click, matched the way runtime_inspect find matches says (a plain word is contained in the text, a pattern with * or ? is a glob over it, and | separates alternatives), among the controls on screen, and pressed in the same frame it was found in, so a panel rebuilding between a find and a click cannot free it first. Words on a label inside a button press the button. A control with something drawn over its centre that would take the pointer, such as a screen shown over it or a dialog stacked above its own, is not on screen; nor is one on a hidden canvas layer, one outside the viewport, or one a container clips away that a click does not scroll. The refusal counts those apart. The matches are ranked the way a person picks what to press: an enabled button before anything else, a disabled one included, then a control whose whole text, or one whole line of it such as the title on a card, is the words before one saying them as part of more, and the best one is pressed; found.picked says why. Several matches at the best rank are refused with each one listed, and index picks one."
+        description: "click: the words on the control to click, matched the way runtime_inspect find matches says (a plain word is contained in the text, a pattern with * or ? is a glob over it, and | separates alternatives), among the controls on screen, and pressed in the same frame it was found in, so a panel rebuilding between a find and a click cannot free it first. Words on a label inside a button press the button. A control with something drawn over its centre that would take the pointer, such as a screen shown over it or a dialog stacked above its own, is not on screen; nor is one on a hidden canvas layer, one outside the viewport, or one a container clips away that a click does not scroll. The refusal counts those apart. The matches are ranked the way a person picks what to press: an enabled button before anything else, a disabled one included, then a control whose whole text, or one whole line of it such as the title on a card, is the words before one saying them as part of more, and the best one is pressed; found.picked says why. Several matches at the best rank are refused with each one listed, and index picks one. A match saying the words only as part of more is named under found.partOf, and is refused when a control saying exactly the words is hidden, off the screen or covered, since it would stand in for that one; index presses it anyway. An empty field says its placeholder. An item of an open menu is drawn by the menu rather than held as a control, so a click finds none, and the refusal names the menu and the choose call that picks it."
       },
       action: {
         type: "string",
@@ -34411,10 +34417,13 @@ function runtimeVerdict(endpoint, after) {
   return {
     listening: false,
     mayYetAnnounce: after.running,
-    note: after.running ? `nothing announced itself within ${after.budgetMs}ms${sized} and ${state}, so it may announce a moment from now: editor_status says whether it has, and editor_run start takes runtimeWaitMs to wait longer than this${after.withArgs ? ", which a run carrying its own arguments may well need, since whatever they ask the game to do before its first frame is inside this wait" : ""}` : `nothing announced itself within ${after.budgetMs}ms${sized} and the game is no longer running, so nothing is going to: editor_output has what it printed on the way down`,
+    note: after.running ? `nothing announced itself within ${after.budgetMs}ms${sized} and ${state}, so it may announce a moment from now: editor_status says whether it has, and editor_run start takes runtimeWaitMs to wait longer than this${after.withArgs ? ", which a run carrying its own arguments may well need, since whatever they ask the game to do before its first frame is inside this wait" : ""}. ${untilItAnnounces(after.servesAProject)}` : `nothing announced itself within ${after.budgetMs}ms${sized} and the game is no longer running, so nothing is going to: editor_output has what it printed on the way down`,
     heldAt: null
   };
 }
+function untilItAnnounces(servesAProject) {
+  return servesAProject ? "Until it does, a runtime_* call for it waits briefly and is then refused, and another project's game answers only a call whose projectPath names that project." : "Until it does, a runtime_* call naming no projectPath reaches whichever game is the only one announced, another project's included, so pass projectPath to be sure the answer is this game's.";
+}
 function isOfType(value, kind) {
   switch (kind) {
     case "string":
@@ -34615,18 +34624,29 @@ function settingsNamedBy(op, args) {
 }
 var STALLED_AFTER_MS = 30000;
 var DEPENDED_FAILED = "Failed to compile depended scripts";
+function foldedScriptErrors(errors) {
+  const scriptErrors = errors.filter((error) => !error.message.includes(DEPENDED_FAILED));
+  const own = new Set(scriptErrors.map((error) => error.path));
+  return {
+    scriptErrors,
+    failedThroughDependency: [...new Set(errors.map((error) => error.path))].filter((path) => !own.has(path))
+  };
+}
+function nonEmpty(lists) {
+  return Object.fromEntries(Object.entries(lists).filter(([, list]) => list.length > 0));
+}
 function scriptErrorsNote(errors) {
+  const { scriptErrors: own, failedThroughDependency: dependents } = foldedScriptErrors(errors);
   const causes = new Map;
-  for (const error of errors) {
-    if (!error.message.includes(DEPENDED_FAILED) && !causes.has(error.path)) {
+  for (const error of own) {
+    if (!causes.has(error.path)) {
       causes.set(error.path, error);
     }
   }
-  const dependents = [...new Set(errors.map((error) => error.path))].filter((path) => !causes.has(path));
   const scripts = causes.size + dependents.length;
   const named = [...causes.values()].map((error) => `${error.line === null ? error.path : `${error.path}:${error.line}`} ${error.message}${/[.!?]\)?$/.test(error.message) ? "" : "."}`).join(" ");
   const following = dependents.length === 0 ? "" : causes.size === 0 ? `${dependents.join(", ")} ${dependents.length === 1 ? "depends" : "depend"} on a script that did not compile, and gdUnit4 named none with an error of its own: script_diagnostics on one of them finds it.` : `${dependents.length === 1 ? "One more" : `${dependents.length} more`} failed only because a script ${dependents.length === 1 ? "it depends" : "they depend"} on did: ${dependents.join(", ")}.`;
-  const more = errors.filter((error) => !error.message.includes(DEPENDED_FAILED)).length - causes.size;
+  const more = own.length - causes.size;
   const rest = more > 0 ? `${more === 1 ? "One more error" : `${more} more errors`} in ${causes.size === 1 ? "that script" : "those scripts"} ${more === 1 ? "is" : "are"} under scriptErrors.` : "";
   return [
     `No tests ran: gdUnit4 could not load ${scripts === 1 ? "one script" : `${scripts} scripts`} while looking for suites, and it runs no suite at all when one fails to load.`,
@@ -35491,7 +35511,8 @@ class GodotServer {
           ...whichGame(args),
           path: readNonEmptyString(args, "nodePath") ?? "",
           method: readString(args, "method") ?? "",
-          args: readArray(args, "args") ?? []
+          args: readArray(args, "args") ?? [],
+          ...args["properties"] === undefined ? {} : { properties: args["properties"] }
         }, patience);
       }
       case "runtime_capture":
@@ -36285,9 +36306,9 @@ class GodotServer {
     if (!paths.ok) {
       return this.createErrorResponse(paths.reason, PATH_SOLUTIONS);
     }
-    const asked = paths.value;
-    const missing = asked.filter((path) => !existsSync16(join20(project.value.path, path.slice("res://".length))));
-    if (missing.length > 0) {
+    const missing = paths.value.filter((path) => !existsSync16(join20(project.value.path, path.slice("res://".length))));
+    const asked = paths.value.filter((path) => !missing.includes(path));
+    if (asked.length === 0) {
       const verdict = `nothing at ${missing.join(" and ")}`;
       return {
         content: [
@@ -36404,7 +36425,10 @@ class GodotServer {
     const hung = cutShort?.hung ?? false;
     const scriptErrors = timedOut || exitCode !== 105 ? [] : scriptErrorsPrinted(said);
     const brokenScripts = new Set(scriptErrors.map((error) => error.path)).size;
-    const verdict = cutShort !== null ? cutShort.verdict : nothingRan ?? (brokenScripts > 0 ? `script errors in ${brokenScripts === 1 ? "one script" : `${brokenScripts} scripts`}, so no suite ran` : undefined) ?? (exitCode === null ? undefined : verdicts[exitCode]) ?? (run.exitSignal === null ? `exit ${exitCode ?? "unknown"}` : howItExited(run));
+    const ranAs = cutShort !== null ? cutShort.verdict : nothingRan ?? (brokenScripts > 0 ? `script errors in ${brokenScripts === 1 ? "one script" : `${brokenScripts} scripts`}, so no suite ran` : undefined) ?? (exitCode === null ? undefined : verdicts[exitCode]) ?? (run.exitSignal === null ? `exit ${exitCode ?? "unknown"}` : howItExited(run));
+    const nothingAt = missing.join(" and ");
+    const verdict = missing.length === 0 ? ranAs : `${ranAs}; nothing at ${nothingAt}`;
+    const missingNote = missing.length === 0 ? undefined : `Nothing at ${nothingAt}, so ${missing.length === 1 ? "it was" : "they were"} left out and only ${asked.join(", ")} ran; a run of fewer paths than were asked for is not called a pass.${elsewhereIn(project.value.path, missing[0] ?? "")}`;
     const savesNote = savesStayPut() && nothingRan === null ? SAVES_NOT_MOVED_NOTE : undefined;
     const marker = readNonEmptyString(args, "printed");
     const echoed = marker === undefined ? undefined : run.log.select({ severity: "info", sinceLastCall: false, contains: marker, limit: 200 });
@@ -36413,7 +36437,8 @@ class GodotServer {
       ...echoed.omitted > 0 ? { printedOmitted: echoed.omitted } : {}
     };
     if (report === null) {
-      const note = nothingRan !== null ? `No tests ran: ${verdict}.` : scriptErrors.length > 0 ? scriptErrorsNote(scriptErrors) : reportProblem !== null ? `The test run's report could not be read (${reportProblem}); the engine's own verdict was ${verdict}.` : `The test run wrote no report (${verdict}).`;
+      const said = nothingRan !== null ? `No tests ran: ${ranAs}.` : scriptErrors.length > 0 ? scriptErrorsNote(scriptErrors) : reportProblem !== null ? `The test run's report could not be read (${reportProblem}); the engine's own verdict was ${ranAs}.` : `The test run wrote no report (${ranAs}).`;
+      const note = missingNote === undefined ? said : `${said} ${missingNote}`;
       return {
         content: [
           { type: "text", text: note },
@@ -36427,7 +36452,8 @@ class GodotServer {
               exitSignal: run.exitSignal ?? undefined,
               hung,
               ...timedOut ? { timedOut, silentForMs } : {},
-              ...scriptErrors.length > 0 ? { scriptErrors } : {},
+              ...missing.length > 0 ? { missing } : {},
+              ...nonEmpty(foldedScriptErrors(scriptErrors)),
               arguments: cmdArgs,
               entries: forAnswer(printed.slice(0, 60).map(aboveTheRunner)),
               ...printedLines,
@@ -36464,8 +36490,9 @@ class GodotServer {
     });
     const notRun = report.suites.reduce((sum, suite) => sum + Math.max(0, suite.discovered - suite.tests), 0);
     return this.jsonTextResponse({
-      passed: !timedOut && exitCode === 0 && nothingRan === null && report.tests > 0 && report.failures === 0 && report.errors === 0 && hookFailures.length === 0,
+      passed: !timedOut && exitCode === 0 && nothingRan === null && report.tests > 0 && report.failures === 0 && report.errors === 0 && hookFailures.length === 0 && missing.length === 0,
       verdict,
+      ...missing.length > 0 ? { missing } : {},
       ...timedOut ? { timedOut, hung, silentForMs } : {},
       exitCode,
       exitSignal: run.exitSignal ?? undefined,
@@ -36482,7 +36509,10 @@ class GodotServer {
       ...printedLines,
       savesNote,
       ...scanned,
-      note: verdict.startsWith("warnings") && warnings.length === 0 ? "gdUnit4 exits 101 for orphan nodes when nothing failed, and this run printed no count of them: orphan reporting may be off in the project settings." : notRunNote(notRun, readBoolean(args, "failFast") === true),
+      note: [
+        missingNote,
+        ranAs.startsWith("warnings") && warnings.length === 0 ? "gdUnit4 exits 101 for orphan nodes when nothing failed, and this run printed no count of them: orphan reporting may be off in the project settings." : notRunNote(notRun, readBoolean(args, "failFast") === true)
+      ].filter((part) => part !== undefined).join(" ") || undefined,
       suites: unclean.map((suite) => ({
         name: suite.name,
         path: suite.path,
@@ -37256,7 +37286,14 @@ class GodotServer {
   async runtimeUp(projectPath, before, budget, withArgs) {
     const budgetMs = budget.ms;
     if (!existsSync16(join20(projectPath, RUNTIME_AUTOLOAD.path))) {
-      return runtimeVerdict(null, { addon: false, budgetMs, heldAt: null, running: false, withArgs });
+      return runtimeVerdict(null, {
+        addon: false,
+        budgetMs,
+        heldAt: null,
+        running: false,
+        withArgs,
+        servesAProject: this.ownProject !== null
+      });
     }
     let asking = null;
     let editorAskedAt = 0;
@@ -37308,6 +37345,7 @@ class GodotServer {
       heldAt: this.dapClient?.whereItStopped() ?? null,
       running: endpoint !== null || going !== null && await this.runStillGoing(going),
       withArgs,
+      servesAProject: this.ownProject !== null,
       ...going?.throughEditor === true ? { playingSeen: going.seenPlaying === true } : {}
     });
   }

package/package.json

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