gdharness 1.2.35 → 1.2.36

package/build/index.js

@@ -35215,7 +35215,7 @@ var TOOL_SPECS = [
       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: {
@@ -35692,7 +35692,7 @@ var TOOL_SPECS = [
     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: {
@@ -35713,7 +35713,7 @@ var TOOL_SPECS = [
     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_PATH2,
       scriptPath: {
@@ -36171,7 +36171,7 @@ var TOOL_SPECS = [
       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",
@@ -36202,7 +36202,7 @@ var TOOL_SPECS = [
       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: {
@@ -36222,12 +36222,12 @@ var TOOL_SPECS = [
       },
       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: []
       }
     },
@@ -36236,7 +36236,7 @@ var TOOL_SPECS = [
   {
     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,
@@ -36356,7 +36356,7 @@ var TOOL_SPECS = [
   {
     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,
@@ -36553,10 +36553,16 @@ var TOOL_SPECS = [
       },
       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"],
@@ -36596,6 +36602,11 @@ var TOOL_SPECS = [
       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: {
@@ -37249,6 +37260,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) {
@@ -38252,6 +38269,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."
+  };
+}
 var EXTERNAL_MEMBER = 'Could not resolve external class member "';
 function isDirectory(path) {
   try {
@@ -40442,6 +40466,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();
@@ -40451,12 +40479,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;
@@ -40477,12 +40524,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());
   }
@@ -40494,6 +40597,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;
     }
@@ -40653,24 +40766,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) {
@@ -43724,9 +43837,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 };
   }
@@ -43992,6 +44105,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));
@@ -44157,7 +44275,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"]);
@@ -44168,7 +44297,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,

package/package.json

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