gdharness 1.2.35 → 1.2.36

package/build/cli.js

@@ -11483,7 +11483,7 @@ var init_tool_definitions = __esm(() => {
         direction: {
           type: "string",
           enum: ["forward", "reverse"],
-          description: "forward: what this resource loads, with cycles reported. reverse: every file that refers to it and how, a scene instancing it, a script extending, preloading or loading it, and for a script with a class_name every use of that name. Each reference carries a kind, and two of them are mentions rather than uses: doc is a name inside a ## documentation comment, which renaming would break in the generated docs, and comment is one in ordinary prose, which it would only make stale. summary.in_code is the count with both of those left out, which is the number to read when the question is whether anything still uses this. Default forward."
+          description: "forward: what this resource loads, with cycles reported, a script's dependencies including every script whose class_name it uses, marked by_class with the name. summary.total_dependencies counts each file once however many places load it, and total_references counts the entries in the tree. reverse: every file that refers to it and how, a scene instancing it, a script extending, preloading or loading it, and for a script with a class_name every use of that name. Each reference carries a kind: ext_resource, extends, preload, load or path for a reference by path; setting, plugin, export_preset and import for one in project.godot, a plugin.cfg, export_presets.cfg or an import sidecar; class_name for a use of the declared name, the declaration itself being the script asked about. Two kinds are mentions rather than uses: doc is a name inside a ## documentation comment, which renaming would break in the generated docs, and comment is one in ordinary prose, which it would only make stale. summary.in_code is the count with both of those left out, which is the number to read when the question is whether anything still uses this. Default forward."
         },
         depth: { type: "number", description: "forward: how many levels to follow. Default unlimited." },
         includeBuiltin: {
@@ -11960,7 +11960,7 @@ var init_tool_definitions = __esm(() => {
       operations: {
         structure: {
           effect: "read",
-          summary: "functions, variables, signals, class_name and extends, read from the file",
+          summary: "functions, variables, signals, class_name and extends, read from the file, and dependencies: the paths it loads or preloads as written, then the scripts declaring each project class_name its code uses, which classes_used names with the class",
           requires: []
         },
         symbols: {
@@ -11981,7 +11981,7 @@ var init_tool_definitions = __esm(() => {
       name: "script_diagnostics",
       title: "Script diagnostics",
       effect: "read",
-      description: "Errors and warnings for a script, or for several, from the editor's language server, and whether each is clean. Needs the editor running. Each diagnostic carries its severity (error or warning), its message, and where it is as the editor shows it: line and column counted from 1, and endLine and endColumn just past its end. Diagnostics are checked against the project's own files, and the two that the files disprove are named rather than passed on: a member the class cache's file declares, or a project class it extends does, a method, property, constant, static function or enum member, comes back under contradictedByTheFile with the script declaring it, and so does one a diagnostic names alone as an external class member, read against the class it is looked up on in the line it is on; and a class this project declares that the diagnostic could not resolve comes back under typesTheEditorHasNotLoaded, with inTheClassCache saying whether a launched game would resolve it. staleAnalysis then says what to do, and for both states it is editor_rescan first: it asks the editor already running, starts nothing, and has cleared each in every reproduction measured. Two exceptions are named when they apply. For an enum member, constant or static function of a global class the reload comes first: in the one project that has reproduced a stale enum member, editor_rescan with reloadScript on the declaring script cleared it and a plain rescan did not. And an editor whose last scan wrote the class cache shorter than the file holds a list behind the files and writes it on every scan, so on that editor the rescan loads nothing and staleAnalysis says editor_launch restart instead. What follows differs: for a stale analysed type, editor_rescan with reloadScript recompiles the held copy and editor_launch restart is the last resort that costs a window; for a class missing from the cache, project_import refresh_classes rewrites the cache from disk at the cost of a short headless engine, which matters beside a running bench.",
+      description: "Errors and warnings for a script, or for several, from the editor's language server, and whether each is clean. With no editor of this project open, so no language server of it to ask, a short headless engine compiles the scripts instead and the answer says checkedBy: engine: every error that stops a script compiling, with its line and no column, dependenciesWithErrors naming the other scripts that failed while it loaded, and warnings null, since the engine reports warnings only to an editor. Each diagnostic carries its severity (error or warning), its message, and where it is as the editor shows it: line and column counted from 1, and endLine and endColumn just past its end. Diagnostics are checked against the project's own files, and the two that the files disprove are named rather than passed on: a member the class cache's file declares, or a project class it extends does, a method, property, constant, static function or enum member, comes back under contradictedByTheFile with the script declaring it, and so does one a diagnostic names alone as an external class member, read against the class it is looked up on in the line it is on; and a class this project declares that the diagnostic could not resolve comes back under typesTheEditorHasNotLoaded, with inTheClassCache saying whether a launched game would resolve it. staleAnalysis then says what to do, and for both states it is editor_rescan first: it asks the editor already running, starts nothing, and has cleared each in every reproduction measured. Two exceptions are named when they apply. For an enum member, constant or static function of a global class the reload comes first: in the one project that has reproduced a stale enum member, editor_rescan with reloadScript on the declaring script cleared it and a plain rescan did not. And an editor whose last scan wrote the class cache shorter than the file holds a list behind the files and writes it on every scan, so on that editor the rescan loads nothing and staleAnalysis says editor_launch restart instead. What follows differs: for a stale analysed type, editor_rescan with reloadScript recompiles the held copy and editor_launch restart is the last resort that costs a window; for a class missing from the cache, project_import refresh_classes rewrites the cache from disk at the cost of a short headless engine, which matters beside a running bench.",
       parameters: {
         projectPath: PROJECT_PATH,
         scriptPath: {
@@ -12439,7 +12439,7 @@ var init_tool_definitions = __esm(() => {
         says: {
           type: "string",
           ops: ["find", "accessibility"],
-          description: 'accessibility: only the elements whose name or value says these words, matched as find matches them, with what they hold. find: part of what the node has written on it as drawn, the way the text op reads it, case-insensitively and with a typed space matching any space the game draws (a non-breaking one included), which is how a button is reached by the word on it rather than by a generated path. Its own text, so a row is found by the label in it, and hidden nodes match. A bare word is a contains; write a glob and it is one, matched against the whole of what the node says, the same as namePattern, and a glob that finds nothing says under note how many nodes it would find open at both ends. A label with a line break is matched with the break in the words, and a backslash followed by n counts as one. Alternatives separated by | match when any one of them does, each by these rules ("*won*|*lost*"); write \\| for a bar that is part of the words.'
+          description: 'accessibility: only the elements whose name, value or value_text says these words, matched as find matches them, with what they hold. find: part of what the node has written on it as drawn, the way the text op reads it, case-insensitively and with a typed space matching any space the game draws (a non-breaking one included), which is how a button is reached by the word on it rather than by a generated path. Its own text, so a row is found by the label in it, and hidden nodes match. A bare word is a contains; write a glob and it is one, matched against the whole of what the node says, the same as namePattern, and a glob that finds nothing says under note how many nodes it would find open at both ends. A label with a line break is matched with the break in the words, and a backslash followed by n counts as one. Alternatives separated by | match when any one of them does, each by these rules ("*won*|*lost*"); write \\| for a bar that is part of the words.'
         },
         limit: {
           type: "integer",
@@ -12470,7 +12470,7 @@ var init_tool_definitions = __esm(() => {
         tree: { effect: "read", summary: "the live scene tree", requires: [] },
         text: {
           effect: "read",
-          summary: "every line of text under nodePath, the values in its fields included, in the order somebody reads the screen, leaving out what is hidden and everything under it. Every line reads as drawn: rich text without its tags, text only as far as it has been typed out, a translation rather than its key, an upper-case label in capitals and a secret field as its mask. Tab titles, menu bar titles, list items, a tree's column titles and rows, and an open menu's items and the titles of its separators read a line each",
+          summary: "every line of text under nodePath, the values in its fields included, in reading order, leaving out what is hidden and everything under it. Every line reads as drawn: rich text without its tags, text only as far as it has been typed out, a translation rather than its key, an upper-case label in capitals and a secret field as its mask. Tab titles, menu bar titles, list items, a tree's column titles and rows, and an open menu's items and the titles of its separators read a line each",
           requires: []
         },
         find: {
@@ -12490,12 +12490,12 @@ var init_tool_definitions = __esm(() => {
         },
         metrics: {
           effect: "read",
-          summary: "frame time, memory, draw calls and the rest. frame_time is the mean wall time of a frame over the last frames_timed frames (up to 120, timed by the game itself, physics and the wait for the display included), frame_time_max the slowest of them, both in seconds and null before a frame has passed; vsync says whether a frame waits for the display, and max_fps is the game's frame-rate cap, 0 for none. physics_steps_per_second is the physics steps taken a second over those frames, fewer than physics_ticks_per_second when a frame needs more than max_physics_steps_per_frame or the editor's Game view slows it. fps, process_time_max and physics_time are the engine's monitors, which it sets once a second: the frames counted in the last second, and the slowest process and physics step in it, so they trail a change by up to a second and the last two are a worst case rather than the frame. The memory, object and render counts are read as asked. memory_static is what the engine allocated on the CPU side, in bytes; render_video_mem_used, render_texture_mem_used and render_buffer_mem_used are what the renderer has on the GPU, in bytes, which memory_static does not count",
+          summary: "frame time, memory, draw calls and the rest. frame_time is the mean wall time of a frame over the last frames_timed frames (up to 120, timed by the game, physics and the wait for the display included), frame_time_max the slowest of them, both in seconds and null before a frame has passed; vsync says whether a frame waits for the display, and max_fps is the game's frame-rate cap, 0 for none. physics_steps_per_second is the physics steps taken a second over those frames, fewer than physics_ticks_per_second when a frame needs more than max_physics_steps_per_frame or the editor's Game view slows it. fps, process_time_max and physics_time are the engine's monitors, which it sets once a second: the frames counted in the last second, and the slowest process and physics step in it, so they trail a change by up to a second and the last two are a worst case rather than the frame. Memory, object and render counts are read as asked. memory_static is what the engine allocated on the CPU side, in bytes; render_video_mem_used, render_texture_mem_used and render_buffer_mem_used are what the renderer has on the GPU, in bytes, which memory_static does not count",
           requires: []
         },
         accessibility: {
           effect: "read",
-          summary: "what the game tells a screen reader, read through UI Automation as a Windows screen reader reads it, under windows: one tree per window, each element with its role (text for static text, button, check_box, group for a control holding others), name, value, description, placeholder, bounds in the window's pixels, the actions a reader is offered (click, focus, toggle, set_value, select, expand_collapse, scroll_into_view), and focused on the one with the focus. node is the node that made the element; an element a node made as a part of itself has part_of, the node drawn around it that holds its words, or part_of_candidates where several are, and part: announcement marks the text a window announces through. An empty name is read as nothing: static text takes it from accessibility_update_set_value, and _note counts the text elements on screen with none. tooltip is the node's tooltip_text, which a Windows reader is not told. With nothing focused, the engine calls GdharnessRuntime focused. Needs a windowed run on Windows started with engineArgs [\"--accessibility\", \"always\"] or accessibility_support at Always Active, since the engine builds the tree only when asked; reading takes a second or two",
+          summary: `what the game tells a screen reader, read through UI Automation as a Windows screen reader does, under windows: one tree per window, each element with its role (text for static text, button, check_box, group for a control holding others), name, value, value_text (a range's spoken words, such as "75%"), description, placeholder, bounds in the window's pixels, the actions a reader is offered (click, focus, toggle, set_value, select, expand_collapse, scroll_into_view), and focused on the focused one. node is the node that made the element; a part a node made of itself has part_of, the node drawn around it that holds its words, or part_of_candidates where several are, and part: announcement marks the text a window announces through. An empty name reads as nothing: static text takes it from accessibility_update_set_value, and _note counts the text elements on screen with none. tooltip is the node's tooltip_text, which a Windows reader is not told. With nothing focused, the engine calls GdharnessRuntime focused. Needs a windowed Windows run started with engineArgs ["--accessibility", "always"] or accessibility_support at Always Active, since the engine builds the tree only when asked; reading takes a second or two`,
           requires: []
         }
       },
@@ -12504,7 +12504,7 @@ var init_tool_definitions = __esm(() => {
     {
       name: "runtime_invoke",
       title: "Set or call in the running game",
-      description: "Sets a property or calls a method on a node, or on one of the engine singletons nodePath names, in the running game. Needs the game running with the runtime addon. The answer carries elapsed_usec, how long the call or the write took inside the game, measured around it there: the round trip to the game is a second or more, so timing from outside measures that instead. Errors and warnings the engine reported while a called method ran come back under errors, the first 20, with errors_not_shown counting the rest. A call that takes longer than timeoutMs is not cancelled: the answer is pending: true with a requestId, the call goes on and does everything it was asked, and op result with that requestId collects its reply once it comes.",
+      description: "Sets a property or calls a method on a node, or on one of the engine singletons nodePath names, in the running game. Needs the game running with the runtime addon. The answer carries elapsed_usec, how long the call or the write took inside the game, measured around it there: the round trip to the game is a second or more, so timing from outside measures that instead. Errors the engine reported while a called method ran come back under errors and warnings under warnings, the first 20 of each, with errors_not_shown and warnings_not_shown counting the rest. A call that takes longer than timeoutMs is not cancelled: the answer is pending: true with a requestId, the call goes on and does everything it was asked, and op result with that requestId collects its reply once it comes.",
       parameters: {
         projectPath: RUNNING_PROJECT_PATH,
         pid: RUNNING_PID,
@@ -12624,7 +12624,7 @@ var init_tool_definitions = __esm(() => {
     {
       name: "runtime_input",
       title: "Send input to the game",
-      description: "Input to the running game: a whole click on a Control or a 3D node named by path or on a control named by the words on it, an item chosen out of a menu, typing into whatever has the focus, or a raw action, key, mouse button, mouse motion or drag. All of it works headless, where the 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. A native window no real pointer has entered gets no hover from Godot, so the runtime supplies it there and the answers say hover_supplied.",
+      description: "Input to the running game: a whole click on a Control or a 3D node named by path or on a control named by the words on it, an item chosen out of a menu, typing into whatever has the focus, or a raw action, key, mouse button, mouse motion or drag. All of it works headless, where the viewport is the project's window size and the GUI only takes what is inside it. On gdharness's own desktop, where a windowed run goes, Windows refuses to say where the pointer is: every pointer answer there carries pointer_on_hidden_desktop, and the first of the run pointer_note saying why it matters: get_mouse_position() on the root window, and the mouse positions derived from it, read a meaningless position, while what reads the event itself (the control under it, hover, tooltips, input handlers) gets the injected position. A native window no real pointer has entered gets no hover from Godot, so the runtime supplies it there and the answers say hover_supplied.",
       answer: 'click: what was under the pointer, and what became of the control: in_tree, removed or freed. Named by says, found says which match it was, and found.pressedOn says "the words" for words in a RichTextLabel pressed where they are drawn, or "the middle of the label" with a note saying why they could not be placed; on a rich label link_pressed says whether the press reached a link, with link_meta giving the meta the label reports clicked, an empty one included. A control scrolled into view first is scrolled each container out from it a frame after the one inside, and scrolled_into_view says whether a scroll value changed. A button in toggle mode, a CheckBox or CheckButton included, answers pressed with before and after, its button_pressed either side of the click: the same value twice is a click the game undid, and after is null when the click freed it. A refusal for a pointer turned off names where mouse_behavior_recursive was set. On a 3D node landed says the interface did not swallow the press: no control under the pointer stopped it, a control letting the pointer pass included, and every viewport on the way out from the room had the pointer over what shows the room. choose: what was chosen, read before the press, which is heard rather than assumed; what became of the control named (in_tree, removed or freed, since a game can rebuild its screen on the pick); and what the button in front of the menu shows now when it is still there. A menu is opened rather than clicked because its items are drawn rather than built, and the item is looked for as the menu stands once open, since a game can fill a menu as it opens. action, key, mouse_click and joypad_button: the event as it was sent, with whole saying whether the press was let go of again, for a key the keycode, physical_keycode and unicode it carried, and for a controller button its number, its name and the device. mouse_motion: the position and the relative movement sent. mouse_drag: from, to, motions sent and relative_total. joypad_motion: the axis by number and name, the value and the device. None of these is aimed at anything, so none says what the event reached: click on a nodePath or says answers what was under the pointer.',
       parameters: {
         projectPath: RUNNING_PROJECT_PATH,
@@ -12821,10 +12821,16 @@ var init_tool_definitions = __esm(() => {
         },
         nodePath: {
           type: "string",
-          ops: ["signal", "until"],
-          description: "signal, until: the node. Needed for a signal and for a property; for says it defaults to /root, the whole screen."
+          ops: ["signal", "watch", "until"],
+          description: "signal, watch, until: the node. Needed for a signal without a watch, a watch and a property; for says it defaults to /root, the whole screen."
+        },
+        signal: { type: "string", ops: ["signal", "watch"], description: "signal, watch: the signal name." },
+        watch: {
+          type: "integer",
+          minimum: 1,
+          ops: ["signal"],
+          description: "signal: the watch an earlier watch answered, in place of nodePath and signal. Answers at once, with fired_before_wait, when the signal fired after the watch was armed, and otherwise waits for it; times counts how often it fired, and args is what the first carried. The watch goes with the answer."
         },
-        signal: { type: "string", ops: ["signal"], description: "signal: the signal name." },
         property: {
           type: "string",
           ops: ["until"],
@@ -12864,6 +12870,11 @@ var init_tool_definitions = __esm(() => {
         signal: {
           effect: "read",
           summary: "wait for a signal and answer with what it carried",
+          requires: []
+        },
+        watch: {
+          effect: "read",
+          summary: "start recording a signal and answer at once with a watch; arm it before the call meant to set the signal off, then collect it with signal and the watch. A client can run a call sent beside a wait only after the wait answers, so a wait sent with the call misses it",
           requires: ["nodePath", "signal"]
         },
         until: {
@@ -44595,6 +44606,12 @@ function endedWithoutACode(run) {
   }
   return `The editor stopped playing this run. ${kept} What it printed is below.`;
 }
+function ourRunEnded(run, now) {
+  const which = `${run.throughEditor ? "played in the editor" : "started"}${run.pid === null ? "" : ` (pid ${run.pid})`}`;
+  const when = run.endedAt === undefined ? "" : ` ${Math.max(0, Math.round((now - run.endedAt) / 1000))}s ago`;
+  const how = run.endedThrough === "close" ? "this server asked it to close" : run.endedThrough === "keeper" ? "this server ended it through the keeper holding it" : run.endedThrough === "signal" ? "this server signalled it" : run.endedThrough === "editor" ? "this server asked the editor to stop it" : run.exitCode !== null ? `it exited by itself with code ${run.exitCode}` : run.exitSignal === null ? "it is no longer running" : `it was ended by ${run.exitSignal}`;
+  return `No game with the runtime addon is running: the game this server ${which} ended${when}, and ${how}. editor_output has what it printed, and editor_run start runs it again.`;
+}
 function stopVerdict(stop) {
   const notClosed = stop.notClosedBecause === undefined ? "" : ` It was asked to close first and was not ended by that: ${stop.notClosedBecause}.`;
   if (!stop.wasRunning) {
@@ -45521,6 +45538,13 @@ function scriptsToDiagnose(projectPath, given) {
   }
   return { ok: true, value: unique };
 }
+function engineChecked(why) {
+  return {
+    checkedBy: "engine",
+    languageServer: why,
+    note: "No editor of this project is open to ask, so a headless engine compiled the scripts the way loading them does. It reports every error that stops a script compiling, at its line and without a column, and no warnings, which the engine tells only an editor: warnings is null rather than 0. editor_launch with hidden: true opens this project's editor without a window, and its language server reports both."
+  };
+}
 function isDirectory(path) {
   try {
     return statSync13(path).isDirectory();
@@ -47709,6 +47733,10 @@ class GodotServer {
     }
     if (scripts?.value == null) {
       const one = await this.diagnosticsOf(args);
+      if ("noLanguageServer" in one) {
+        const checked = project.ok ? await this.engineDiagnostics(project.value.path, [readString(args, "scriptPath") ?? ""], one.noLanguageServer) : { refusal: project.response };
+        return "refusal" in checked ? checked.refusal : this.jsonTextResponse({ ...checked.answers[0], ...engineChecked(one.noLanguageServer.reason) });
+      }
       return "refusal" in one ? one.refusal : this.jsonTextResponse(this.markedIfStale(one.answer));
     }
     const progress = callProgress();
@@ -47718,12 +47746,31 @@ class GodotServer {
     let errors = 0;
     let warnings = 0;
     let unread = 0;
+    let byEngine = null;
     for (const [at, scriptPath] of scripts.value.entries()) {
       if (cancelled?.aborted === true) {
         return this.createErrorResponse(`Cancelled after ${at} of ${scripts.value.length} scripts.`);
       }
       progress?.(at + 1, `${at + 1} of ${scripts.value.length}: ${scriptPath}`);
       const one = await this.diagnosticsOf({ ...args, scriptPath });
+      if ("noLanguageServer" in one) {
+        const rest = scripts.value.slice(at);
+        progress?.(at + 1, `${rest.length} script(s) left, compiled by a headless engine`);
+        const checked = await this.engineDiagnostics(project.ok ? project.value.path : "", rest, one.noLanguageServer);
+        if ("refusal" in checked) {
+          return checked.refusal;
+        }
+        for (const answer of checked.answers) {
+          errors += Number(answer["errors"]);
+          if (readArray(answer, "diagnostics")?.length === 0) {
+            nothingReported.push(String(answer["scriptPath"]));
+          } else {
+            reported.push(answer);
+          }
+        }
+        byEngine = one.noLanguageServer.reason;
+        break;
+      }
       if ("refusal" in one) {
         if (!one.perScript) {
           return one.refusal;
@@ -47744,12 +47791,68 @@ class GodotServer {
       clean: errors === 0 && unread === 0,
       scriptsChecked: scripts.value.length,
       errors,
-      warnings,
+      warnings: byEngine === null ? warnings : null,
       ...unread > 0 ? { scriptsNotRead: unread } : {},
       scripts: reported,
-      nothingReported
+      nothingReported,
+      ...byEngine === null ? {} : engineChecked(byEngine)
     }));
   }
+  async compileScripts(projectPath, paths) {
+    const payload = { checked: [], failed: [], scripts: [] };
+    const messages = [];
+    let left = [...paths];
+    while (left.length > 0) {
+      const ran = await this.operation("check_scripts", { paths: left }, projectPath);
+      if (!ran.ok) {
+        return { ok: false, message: ran.message };
+      }
+      const checked = (readArray(ran.payload, "checked") ?? []).map(String);
+      if (checked.length === 0) {
+        return { ok: false, message: `check_scripts read none of ${left.length} script(s)` };
+      }
+      payload.checked.push(...checked);
+      payload.failed.push(...(readArray(ran.payload, "failed") ?? []).map(String));
+      payload.scripts.push(...readArray(ran.payload, "scripts") ?? []);
+      messages.push(...ran.messages);
+      left = left.slice(checked.length);
+    }
+    return { ok: true, payload, extras: engineExtras({ messages }) };
+  }
+  async engineDiagnostics(projectPath, scripts, why) {
+    const named = scripts.map((script) => {
+      const contained = resolveWithinProject(projectPath, script);
+      return contained.ok ? `res://${contained.relativePath}` : script;
+    });
+    const checked = await this.compileScripts(projectPath, named);
+    if (!checked.ok) {
+      return {
+        refusal: this.createErrorResponse(`Diagnostics unavailable: ${why.reason.replace(/\.?$/, ".")} No headless engine could compile the scripts instead: ${checked.message}`, why.solutions)
+      };
+    }
+    const failures = new Map((readArray(checked.payload, "scripts") ?? []).map((entry) => [
+      String(asParams(entry)["path"]),
+      asParams(entry)
+    ]));
+    return {
+      answers: scripts.map((scriptPath, at) => {
+        const failure = failures.get(named[at] ?? "");
+        const diagnostics = (readArray(failure ?? {}, "errors") ?? []).map((entry) => {
+          const { line, message } = asParams(entry);
+          return { severity: "error", message, ...typeof line === "number" && line > 0 ? { line } : {} };
+        });
+        const dependencies = readArray(failure ?? {}, "dependencies_with_errors");
+        return {
+          scriptPath,
+          clean: diagnostics.length === 0,
+          errors: diagnostics.length,
+          warnings: null,
+          diagnostics,
+          ...dependencies === undefined ? {} : { dependenciesWithErrors: dependencies }
+        };
+      })
+    };
+  }
   markedIfStale(answer) {
     return markIfStale(answer, this.godotBridge.getStatus().addonVersion, SERVER_VERSION, this.godotBridge.getStatus().addonDigest, shippedEditorDigest(), this.editorCodeOnDisk());
   }
@@ -47761,6 +47864,16 @@ class GodotServer {
     const answer = await this.handleLSP("lsp_get_diagnostics", args);
     const payload = asParams(JSON.parse(answer.content[0]?.text ?? "{}"));
     const refused = this.languageServerRefusal(payload, "Diagnostics");
+    const project = this.project(args);
+    const ownEditor = project.ok && this.editorHasOpen(project.value.path);
+    if (refused !== null && !refused.perScript && payload["stillReading"] !== true && !ownEditor) {
+      return {
+        noLanguageServer: {
+          reason: typeof payload["error"] === "string" ? payload["error"] : JSON.stringify(payload["error"]),
+          solutions: this.languageServerSolutions(payload)
+        }
+      };
+    }
     if (refused !== null) {
       return refused;
     }
@@ -47920,24 +48033,24 @@ class GodotServer {
     if (payload["stillReading"] === true) {
       return { refusal: this.createErrorResponse(`${asked} unavailable: ${reason}`), perScript: false };
     }
-    if (typeof payload["serves"] === "string") {
-      return {
-        refusal: this.createErrorResponse(`${asked} unavailable: ${reason}`, [
-          "editor_status names the editor on the bridge and the port it says it serves",
-          "editor_launch opens this project's own editor, on a language server port of its own",
-          "GDHARNESS_LSP_PORT points this server at the right one"
-        ]),
-        perScript: false
-      };
-    }
     return {
-      refusal: this.createErrorResponse(`${asked} unavailable: ${reason}`, [
-        `Ensure the Godot editor is running with its language server enabled, on port ${this.editorServes("lspPort", "GDHARNESS_LSP_PORT", DEFAULT_LSP_PORT)}`,
-        "GDHARNESS_LSP_PORT points this server at another one"
-      ]),
-      perScript: payload["aboutThisFile"] === true
+      refusal: this.createErrorResponse(`${asked} unavailable: ${reason}`, this.languageServerSolutions(payload)),
+      perScript: typeof payload["serves"] !== "string" && payload["aboutThisFile"] === true
     };
   }
+  languageServerSolutions(payload) {
+    if (typeof payload["serves"] === "string") {
+      return [
+        ...this.godotBridge.getStatus().connected ? ["editor_status names the editor on the bridge and the port it says it serves"] : [],
+        "editor_launch opens this project's own editor, on a language server port of its own",
+        "GDHARNESS_LSP_PORT points this server at the right one"
+      ];
+    }
+    return [
+      `Ensure the Godot editor is running with its language server enabled, on port ${this.editorServes("lspPort", "GDHARNESS_LSP_PORT", DEFAULT_LSP_PORT)}`,
+      "GDHARNESS_LSP_PORT points this server at another one"
+    ];
+  }
   async lsp() {
     const port = this.editorServes("lspPort", "GDHARNESS_LSP_PORT", DEFAULT_LSP_PORT);
     if (this.lspClient !== null && this.lspClient.port !== port) {
@@ -50991,9 +51104,9 @@ class GodotServer {
       ok &&= rebuilt.ok;
     }
     if (changed.length > 0) {
-      const compiled = await this.operation("check_scripts", { paths: [...changed] }, projectPath);
-      report["compiled"] = compiled.ok ? { ...compiled.payload, ...engineExtras(compiled) } : { problem: compiled.message };
-      ok &&= compiled.ok && (readArray(compiled.payload, "failed") ?? []).length === 0;
+      const compiled = await this.compileScripts(projectPath, [...changed]);
+      report["compiled"] = compiled.ok ? { ...compiled.payload, ...compiled.extras } : { problem: compiled.message };
+      ok &&= compiled.ok && compiled.payload.failed.length === 0;
     }
     return { ok, report };
   }
@@ -51259,6 +51372,11 @@ class GodotServer {
     const own = typeof pid === "number" ? undefined : await this.ownGameAmong(announced.running, wanted) ?? await this.ownGameThroughTheTree(announced.running, wanted);
     const choice = chooseRuntime(announced.running, wanted, announced.unspoken, typeof pid === "number" ? pid : own);
     if ("problem" in choice) {
+      const ended = this.activeProcess;
+      const nothingAnnounced = typeof pid !== "number" && announced.unspoken.length === 0 && !announced.running.some((one) => wanted === undefined || isSameDirectory(one.project.path, wanted));
+      if (nothingAnnounced && ended !== null && !stillRunning(ended) && (wanted === undefined || ended.projectPath === null || isSameDirectory(ended.projectPath, wanted))) {
+        return this.createErrorResponse(ourRunEnded({ ...ended, pid: ended.pid ?? ended.announcedPid ?? null }, Date.now()));
+      }
       return this.createErrorResponse(choice.problem);
     }
     const ofProject = announced.running.filter((one) => wanted === undefined || isSameDirectory(one.project.path, wanted));
@@ -51424,7 +51542,18 @@ ${staleNote}`}`
       const waited = patienceForFrames(frames, this.runtimeTimeoutMs());
       return await this.handleRuntimeCommand("wait_frames", { ...whichGame(args), frames }, { tool: "runtime_wait", op, patience: waited });
     }
+    if (op === "watch") {
+      return await this.handleRuntimeCommand("watch_signal", {
+        ...whichGame(args),
+        path: readNonEmptyString(args, "nodePath") ?? "",
+        signal: readString(args, "signal") ?? ""
+      }, { tool: "runtime_wait", op });
+    }
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 5000;
+    const watch = readPositiveNumber(args, "watch");
+    if (op === "signal" && watch === undefined && (readNonEmptyString(args, "nodePath") === undefined || readNonEmptyString(args, "signal") === undefined)) {
+      return this.createErrorResponse("runtime_wait signal needs nodePath and signal, or the watch an earlier runtime_wait watch answered.");
+    }
     const asked = readNonEmptyString(args, "nodePath");
     if (asked === undefined && op === "until" && readNonEmptyString(args, "says") === undefined) {
       return this.createErrorResponse("runtime_wait until needs nodePath to wait for a property: the property belongs to that node.", ["With says instead of property, nodePath can be left out and the whole game is searched"]);
@@ -51435,7 +51564,8 @@ ${staleNote}`}`
       ...whichGame(args),
       path: nodePath,
       signal: readString(args, "signal") ?? "",
-      timeout_ms: timeoutMs
+      timeout_ms: timeoutMs,
+      ...watch === undefined ? {} : { watch }
     }, { tool: "runtime_wait", op, patience }) : await this.handleRuntimeCommand("wait_until", {
       ...whichGame(args),
       path: nodePath,
@@ -52671,7 +52801,9 @@ so take it off when the question it was for is answered.
 \`resource_edit read\` for a resource: both read the file through the editor when one serves the
 project and through a headless engine when none does, with the same answer. \`scene_node\`,
 \`scene_signal\` and the other \`resource_edit\` ops but \`move\` change it through the editor, so the
-files keep their formatting. \`script_diagnostics\` and \`script_info\` come from the editor's own language server.
+files keep their formatting. \`script_info\` comes from the editor's own language server, and so does
+\`script_diagnostics\` when this project's editor is open; without it a headless engine compiles the
+scripts and reports their errors, with lines but no columns and no warnings.
 
 \`project_info\`, \`project_dependencies\`, \`project_settings\`, \`project_import\`,
 \`project_export\`, \`project_test\`, \`script_edit\`, \`script_info structure\` and

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

@@ -12,8 +12,10 @@ const REFUSED: String = "Error calling method from 'callv': "
 
 ## The engine's reason for refusing the call, without [constant REFUSED], or "" when it ran.
 var refused: String = ""
-## What was reported while it ran, a line each, warnings marked as such.
+## The errors reported while it ran, a line each.
 var raised: Array[String] = []
+## The warnings reported while it ran, a line each.
+var warned: Array[String] = []
 
 
 func _log_message(_message: String, _error: bool) -> void:
@@ -39,4 +41,7 @@ func _log_error(
 	if function == "callv" and text.begins_with(REFUSED) and refused.is_empty():
 		refused = text.trim_prefix(REFUSED)
 		return
-	raised.append(("WARNING: " if error_type == ERROR_TYPE_WARNING else "") + text)
+	if error_type == ERROR_TYPE_WARNING:
+		warned.append(text)
+	else:
+		raised.append(text)

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

@@ -108,6 +108,9 @@ try {
     }
     $p = Patterned $element 'RangeValue'
     if ($p) {
+      # A reader speaks the Value pattern's words, such as "75%" for a slider whose game sets them,
+      # and the number would otherwise replace them.
+      if ($node.Contains('value') -and "$($node.value)") { $node.value_text = $node.value }
       $node.value = $p.Current.Value
       $node.range = @($p.Current.Minimum, $p.Current.Maximum)
       if (-not $p.Current.IsReadOnly) { $actions += 'set_value' }
@@ -389,17 +392,18 @@ static func _narrow(result: Dictionary, params: Dictionary) -> void:
 
 
 ## Whether [param element] is made by the node at [param under] or one below it, and says
-## [param said], each where asked: words as find matches them, in the element's name or value.
+## [param said], each where asked: words as find matches them, in the element's name, value or
+## value_text.
 static func _matches(element: Dictionary, under: String, said: String) -> bool:
 	if not under.is_empty():
 		var path: String = str(element.get("node", element.get("part_of", "")))
 		if path != under and not path.begins_with(under + "/"):
 			return false
 	if not said.is_empty():
-		var name: String = str(element.get("name", ""))
-		var value: String = str(element.get("value", ""))
-		if not Says.matches(name, said) and not Says.matches(value, said):
-			return false
+		for field: String in ["name", "value", "value_text"]:
+			if element.has(field) and Says.matches(str(element[field]), said):
+				return true
+		return false
 	return true
 
 

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

@@ -18,6 +18,7 @@ const InputCommands = preload("runtime_input.gd")
 const Pad = preload("runtime_pad.gd")
 const Queries = preload("runtime_queries.gd")
 const Read = preload("reading.gd")
+const Targets = preload("runtime_targets.gd")
 const Typing = preload("runtime_typing.gd")
 const Values = preload("runtime_values.gd")
 const Waits = preload("runtime_waits.gd")
@@ -153,6 +154,7 @@ func _init() -> void:
 		"choose": _typing.choose,
 		"wait_frames": _waits.wait_frames,
 		"wait_signal": _waits.wait_signal,
+		"watch_signal": _waits.watch_signal,
 		"wait_until": _waits.wait_until,
 		"send_profile": _send_profile_now,
 		"close_game": _close_game,
@@ -160,6 +162,36 @@ func _init() -> void:
 	_wait_for_the_profiler()
 
 
+## Gives a game with no window the size the project opens its window at. Measured: a
+## headless engine's root viewport is 64 by 64 whatever the project settings or --resolution say, so
+## a headless game laid its interface out in 64 pixels, and a button every windowed run shows was
+## refused as off screen. The root takes a size set once the autoloads are in the tree, before the
+## main scene enters it, and the scene lays out at it from its first frame. A size set at the
+## autoload's construction does not hold: the root is a 100 by 100 placeholder then, and the engine
+## gives it the 64 by 64 afterwards. A script run is not a game and keeps the viewport its own code
+## gives it, and a release build is left as the engine made it.
+func _size_a_windowless_game() -> void:
+	if DisplayServer.get_name() != "headless" or _script_run() or not OS.is_debug_build():
+		return
+	var root: Window = get_tree().root
+	if Vector2(root.size) != Targets.HEADLESS_VIEWPORT:
+		return
+	root.size = Vector2i(_window_dimension("width", 1152), _window_dimension("height", 648))
+
+
+## The window's [param axis] as the project opens it: the override when one is set, otherwise the
+## viewport's size, whose engine default is [param fallback].
+static func _window_dimension(axis: String, fallback: int) -> int:
+	var override: int = Read.as_int(
+		ProjectSettings.get_setting("display/window/size/window_%s_override" % axis, 0)
+	)
+	if override > 0:
+		return override
+	return Read.as_int(
+		ProjectSettings.get_setting("display/window/size/viewport_%s" % axis, fallback), fallback
+	)
+
+
 ## Holds the game's start until the profiler is on, when whatever started the game asked for a
 ## profile from its start. The debugger switches the profiler on with a message the game reads only
 ## on a poll, which comes every [constant POLLS_PER_READ] lines of script, so the main scene's _ready
@@ -197,6 +229,7 @@ func _ready() -> void:
 	# even be un-paused over the socket. A debug server has to stay responsive while the game
 	# is frozen, to inspect, capture, inject or resume it.
 	process_mode = Node.PROCESS_MODE_ALWAYS
+	_size_a_windowless_game()
 	var watched: int = get_tree().root.tree_exiting.connect(_send_the_profile)
 	if watched != OK:
 		push_error("gdharness could not watch for the game quitting: %d" % watched)

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

@@ -441,16 +441,24 @@ func call_method(params: Dictionary) -> Dictionary:
 		"result": _values.serialize(result),
 		"elapsed_usec": elapsed
 	}
-	if not caught.raised.is_empty():
-		answer["errors"] = caught.raised.slice(0, ERRORS_KEPT)
-		if caught.raised.size() > ERRORS_KEPT:
-			answer["errors_not_shown"] = caught.raised.size() - ERRORS_KEPT
+	_keep_reported(answer, "errors", caught.raised)
+	_keep_reported(answer, "warnings", caught.warned)
 	var asked: Variant = params.get("properties")
 	if _reads_the_result(asked):
 		answer.merge(_read_off_result(result, asked))
 	return answer
 
 
+## Puts the first [constant ERRORS_KEPT] of [param reported] in [param answer] under [param field],
+## with how many more there were, when anything was reported.
+static func _keep_reported(answer: Dictionary, field: String, reported: Array[String]) -> void:
+	if reported.is_empty():
+		return
+	answer[field] = reported.slice(0, ERRORS_KEPT)
+	if reported.size() > ERRORS_KEPT:
+		answer[field + "_not_shown"] = reported.size() - ERRORS_KEPT
+
+
 ## 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

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

@@ -412,17 +412,19 @@ static func _outside_note(outside: int, root: Node) -> String:
 ## headless game's button twenty pixels in from the corner was refused as off screen, and the
 ## refusal read as though the button were not there.
 ##
-## The size is only claimed where it is true: the rect is printed beside this, so naming 64 by 64
-## over a viewport somebody has resized says two different things in one sentence.
+## The size named is the one in force, which the rect printed beside it agrees with. A game the
+## runtime started headless has the size the project opens its window at, and a window of that size
+## would not reach the control either, so only the engine's own 64 by 64 is answered with a window.
 static func no_window_note(viewport: Viewport, root: Window) -> String:
 	if viewport != root or root.can_draw():
 		return ""
-	if viewport.get_visible_rect().size == HEADLESS_VIEWPORT:
+	var size: Vector2 = viewport.get_visible_rect().size
+	if size == HEADLESS_VIEWPORT:
 		return (
 			". This game has no window, and a game with no window has a 64 by 64 viewport whatever "
 			+ "the project settings say: run it with a window to reach this control"
 		)
-	return ". This game has no window: run it with a window to reach this control"
+	return ". This game has no window, and its viewport is %d by %d" % [roundi(size.x), roundi(size.y)]
 
 
 ## What to add to a refusal that found nothing on screen, when the controls saying it are covered.
@@ -771,7 +773,7 @@ static func _where_it_lands(target: Control, point: Vector2) -> Dictionary[Scrol
 ## Whether a click could not reach [param target] however it scrolled: its centre, where the click
 ## would bring it, outside its viewport or the one showing that on the screen, or clipped away by a
 ## container the click does not scroll. A drawer parked off the side of the screen, or anything
-## outside the 64 by 64 viewport of a game with no window, was listed among the controls on screen.
+## outside the viewport of a game with no window, was listed among the controls on screen.
 static func _off_screen(target: Control) -> bool:
 	var moves: Dictionary[ScrollContainer, Vector2] = _scrolls_for(target)
 	var point: Vector2 = _centre_of(target) + _moved_by(target, moves)