gdharness 1.1.21 → 1.1.23

package/build/index.js

@@ -10058,23 +10058,24 @@ function sameCodeNote(addonVersion, serverVersion, addonDigest, shippedDigest) {
   }
   return `The editor loaded the ${addonVersion} addons, which are the same code this ${serverVersion} server ships, so nothing needs restarting; addonVersion changes at the next editor start.`;
 }
-function addonMismatch(addonVersion, serverVersion, addonDigest, shippedDigest) {
+function addonMismatch(addonVersion, serverVersion, addonDigest, shippedDigest, onDisk) {
   if (!editorIsStale(addonVersion, serverVersion, addonDigest, shippedDigest)) {
     return;
   }
   const reported = addonVersion ?? "";
+  const restart = onDisk !== undefined && onDisk !== shippedDigest ? `The project's own addons are not this server's either, so a restart would load the same code again: gdharness upgrade in the project installs the ${serverVersion} addons, and editor_launch restart then picks them up.` : "Restart it with editor_launch restart to pick this one up.";
   if (reported === serverVersion) {
-    return `The editor is running a different build of the ${reported} addon from the one this server ships. Restart it with editor_launch restart to pick this one up.`;
+    return `The editor is running a different build of the ${reported} addon from the one this server ships. ${restart}`;
   }
   const editor = reported === "" ? UNVERSIONED : `the ${reported} addon`;
   const both = `The editor is running ${editor} while this server ships ${serverVersion}.`;
   if (reported !== "" && isNewer(reported, serverVersion)) {
     return `${both} This server is the older half: reconnect it in your harness so it spawns ${reported}.`;
   }
-  return `${both} Restart it with editor_launch restart to pick the new one up.`;
+  return `${both} ${restart}`;
 }
-function markIfStale(answer, addonVersion, serverVersion, addonDigest, shippedDigest) {
-  const staleNote = addonMismatch(addonVersion, serverVersion, addonDigest, shippedDigest);
+function markIfStale(answer, addonVersion, serverVersion, addonDigest, shippedDigest, onDisk) {
+  const staleNote = addonMismatch(addonVersion, serverVersion, addonDigest, shippedDigest, onDisk);
   if (staleNote === undefined || typeof answer !== "object" || answer === null || Array.isArray(answer)) {
     return answer;
   }
@@ -10201,27 +10202,27 @@ function defectReport(where, error, context = {}) {
 }
 
 // src/server.ts
-import { execFile as execFile6, spawn as spawn3 } from "node:child_process";
+import { execFile as execFile5, spawn as spawn4 } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import {
   appendFileSync,
   closeSync as closeSync2,
   constants,
   copyFileSync,
-  existsSync as existsSync12,
+  existsSync as existsSync14,
   fstatSync,
   mkdirSync as mkdirSync10,
   openSync as openSync3,
   readdirSync as readdirSync8,
-  readFileSync as readFileSync17,
+  readFileSync as readFileSync18,
   readSync as readSync2,
   rmdirSync as rmdirSync2,
   statSync as statSync8
 } from "node:fs";
-import { basename as basename4, dirname as dirname11, extname as extname2, isAbsolute as isAbsolute3, join as join18, normalize as normalize2, relative as relative3 } from "node:path";
+import { basename as basename4, dirname as dirname12, extname as extname2, isAbsolute as isAbsolute3, join as join19, normalize as normalize2, relative as relative3 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
-import { promisify as promisify6 } from "node:util";
+import { promisify as promisify5 } from "node:util";
 
 // node_modules/zod/v3/helpers/util.js
 var util;
@@ -24863,6 +24864,7 @@ function editorArguments(projectPath, ports, logFile, hidden) {
   ];
 }
 var OPENED_BY_A_SERVER = "GDHARNESS_OPENED_BY_A_SERVER";
+var EDITOR_PID_VARIABLE = "GDHARNESS_EDITOR_PID";
 function userDataIn(home, variables = process.env) {
   const moved = ["APPDATA", "XDG_DATA_HOME"];
   const carried = {};
@@ -24914,6 +24916,12 @@ function resolveWithinProject(projectPath, candidatePath) {
     return { ok: false, reason: "Path contains a null byte." };
   }
   const withoutScheme = trimmed.startsWith(RESOURCE_SCHEME) ? trimmed.slice(RESOURCE_SCHEME.length) : trimmed;
+  if (withoutScheme.startsWith("uid://")) {
+    return {
+      ok: false,
+      reason: `Path '${trimmed}' is a UID, and a file is judged here by where it is on disk, which a UID does not say. Give the file's res:// path.`
+    };
+  }
   const scheme = OTHER_SCHEME.exec(withoutScheme);
   if (scheme) {
     return {
@@ -25457,6 +25465,12 @@ function parseAnnouncement(file, pid) {
     }
   };
 }
+function dialAddress(address) {
+  if (address === "*" || address === "0.0.0.0") {
+    return "127.0.0.1";
+  }
+  return address === "::" ? "::1" : address;
+}
 function runtimesAnnounced(directories = runtimeDirectories()) {
   const running = new Map;
   const unspoken = new Map;
@@ -25620,13 +25634,13 @@ async function announcedSince(projectPath, before, waiting = {}) {
   const directories = waiting.directories ?? runtimeDirectories();
   const until = Date.now() + Math.max(waiting.budgetMs ?? ANNOUNCE_BUDGET_MS, 0);
   for (;; ) {
-    const fresh = discoverRuntimes(directories).find((endpoint) => !before.has(endpoint.pid) && isSameDirectory(endpoint.project.path, projectPath) && (waiting.accept?.(endpoint) ?? true));
-    if (fresh !== undefined) {
+    const fresh = discoverRuntimes(directories).filter((endpoint) => !before.has(endpoint.pid) && isSameDirectory(endpoint.project.path, projectPath) && (waiting.accept?.(endpoint) ?? true));
+    if (fresh.length > 0) {
       return fresh;
     }
     const left = until - Date.now();
     if (left <= 0 || waiting.giveUp?.() === true) {
-      return null;
+      return [];
     }
     await delay(Math.min(LOOK_EVERY_MS, left));
   }
@@ -25761,7 +25775,7 @@ function runtimeRequest(endpoint, command, params, timeoutMs, keepListening = fa
     let late = false;
     let buffered = "";
     let welcomed = false;
-    const socket = createConnection({ port: endpoint.port, host: endpoint.address });
+    const socket = createConnection({ port: endpoint.port, host: dialAddress(endpoint.address) });
     let lateTimer = null;
     const finish = (reply) => {
       if (late) {
@@ -26033,6 +26047,10 @@ function callSignal() {
 import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync7, statSync as statSync2 } from "node:fs";
 import { join as join6 } from "node:path";
 var DECLARATION = /^(?:@[a-z_]+(?:\([^)\n]*\))?\s+)*class_name\s+([A-Za-z_][A-Za-z0-9_]*)/m;
+var TOOL = /^[ \t]*(?:@[a-z_]+(?:\([^)\n]*\))?[ \t]+)*@tool\b/m;
+function isToolScript(source) {
+  return TOOL.test(codeOf(source));
+}
 function declaredClasses(projectPath) {
   const declared = new Map;
   eachScript(projectPath, (script, source) => {
@@ -26072,7 +26090,7 @@ function scriptsNaming(projectPath, classes) {
     }
     const code = codeOf(source);
     if (classesNamedIn(code, named).length > 0) {
-      naming.push({ script, tool: /^\s*@tool\b/m.test(code) });
+      naming.push({ script, tool: TOOL.test(code) });
     }
   });
   return naming.sort((a, b) => a.script.localeCompare(b.script));
@@ -26279,6 +26297,19 @@ function classRemedy(entries) {
   const oneAtATime = declaring.length === 1 ? "" : " Take them one at a time: a rescan that brings in a class also reloads every script naming it and lists them under dependentsReloaded, so a script listed there needs no call of its own.";
   return `For ${entries.map(written).join(", ")}, run ${reload} first.${oneAtATime} In the one project ` + "that has reproduced a stale enum member, three times, the reload cleared it at once each time, " + "and the one plain editor_rescan tried left the diagnostic standing.";
 }
+function notReloadedNote(broughtIn, notReloaded) {
+  const tried = notReloaded.filter((one) => one.tool !== true).map((one) => one.scriptPath);
+  const tools = notReloaded.filter((one) => one.tool === true).map((one) => one.scriptPath);
+  const all = [...tried, ...tools];
+  const remedies = [];
+  if (tried.length > 0) {
+    remedies.push(`For ${tried.join(", ")}: editor_rescan with reloadScript on ${tried.length === 1 ? "it" : "each"}, or editor_launch restart.`);
+  }
+  if (tools.length > 0) {
+    remedies.push(`For ${tools.join(", ")}, ${tools.length === 1 ? "a @tool script" : "@tool scripts"}, which ${tools.length === 1 ? "runs" : "run"} inside the editor and ${tools.length === 1 ? "is" : "are"} not reloaded from inside a call: editor_launch restart.`);
+  }
+  return `The scan brought in ${broughtIn.join(", ")}, and ${all.join(", ")} ${all.length === 1 ? "names one of them and" : "name them and"} could not be reloaded, so the editor still holds what it compiled while it could not see the class and reports that to the language server. ${remedies.join(" ")}`;
+}
 function failedReloadNote(failed) {
   const missing = (before, after) => before.filter((name) => !after.includes(name));
   const lost = [
@@ -26287,7 +26318,17 @@ function failedReloadNote(failed) {
   ];
   const unchanged = lost.length === 0 && missing(failed.heldAfter, failed.heldBefore).length === 0 && missing(failed.constantsAfter, failed.constantsBefore).length === 0;
   const answered = failed.codeName === "" ? `error ${failed.code}` : `error ${failed.code}, ${failed.codeName}`;
-  const copy = unchanged ? "Nothing was reloaded: the copy the editor holds is as it was, with the members under heldBeforeReload and heldConstantsBeforeReload." : `The copy the editor holds changed even so${lost.length === 0 ? "" : `, and has lost ${lost.join(", ")}`}: anything diagnosed against it now is answered from what is left, and reloading it once it compiles rebuilds it.`;
+  const unusable = "A failed compile leaves the copy the editor holds unusable, measured on 4.7.2: the editor can make no instance of it, and one it already made has lost its methods, while its member lists read as before.";
+  let copy;
+  if (failed.restored === null) {
+    copy = `${unusable} This editor's addon does not put it back, so it stays that way until the script compiles: reload it then, or restart the editor with editor_launch restart.`;
+  } else if (!failed.restored) {
+    copy = `${unusable} The editor compiled it again from the text it was built from, and that failed too${failed.restoredAs === "" ? "" : ` (${failed.restoredAs})`}, so it stays that way until the script compiles: reload it then, or restart the editor with editor_launch restart.`;
+  } else if (unchanged) {
+    copy = "The copy the editor holds was compiled again from the text it was built from, which puts it back as it was, with the members under heldBeforeReload and heldConstantsBeforeReload.";
+  } else {
+    copy = `The copy the editor holds was compiled again from the text it was built from and changed even so${lost.length === 0 ? "" : `, and has lost ${lost.join(", ")}`}: anything diagnosed against it now is answered from what is left, and reloading it once it compiles rebuilds it.`;
+  }
   const order = failed.names.length === 0 ? "" : ` If they deny a member of ${failed.names.join(" or ")} that its file declares, the editor's copy of that class is behind: reload that class first with reloadScript and then this script, the order that cleared it in the one project that has met this.`;
   return `${failed.script} did not compile: Godot answered ${answered}. ${copy} ` + `script_diagnostics on it gives the errors.${order}`;
 }
@@ -26526,7 +26567,14 @@ function bindable(port, host) {
 var DEFAULT_DAP_PORT = 6006;
 var DAP_REQUEST_TIMEOUT_MS = 1e4;
 var SCOPES_TIMEOUT_MS = 20000;
+var STEP_LANDS_WITHIN_MS = 1e4;
 var VARIABLES_POLL_TIMEOUT_MS = 2000;
+function fileKey(path) {
+  return process.platform === "win32" ? path.replaceAll("\\", "/").toLowerCase() : path;
+}
+
+class ReadRefusal extends Refusal {
+}
 function said(body, field) {
   const value = body?.[field];
   return typeof value === "string" ? value : "";
@@ -26543,17 +26591,25 @@ class GodotDAPClient {
   outputBuffer = [];
   onOutput = null;
   maxOutputLines = 1000;
+  outputDropped = 0;
+  outputTaken = 0;
   initialized = false;
   attached = false;
   lastThreadId = 1;
   halt = null;
   holdKnown = false;
+  stops = 0;
   breakpoints = new Map;
+  spelled = new Map;
   inEditor = new Map;
   onBreakpointsChanged = null;
-  constructor(port = portFromEnv("GDHARNESS_DAP_PORT", DEFAULT_DAP_PORT), host = "127.0.0.1") {
+  scopesPatienceMs;
+  stepPatienceMs;
+  constructor(port = portFromEnv("GDHARNESS_DAP_PORT", DEFAULT_DAP_PORT), host = "127.0.0.1", patience = {}) {
     this.port = port;
     this.host = host;
+    this.scopesPatienceMs = patience.scopesMs ?? SCOPES_TIMEOUT_MS;
+    this.stepPatienceMs = patience.stepMs ?? STEP_LANDS_WITHIN_MS;
     this.pendingRequests = new Map;
   }
   async connect() {
@@ -26714,6 +26770,7 @@ class GodotDAPClient {
         }
       }
       if (this.outputBuffer.length > this.maxOutputLines) {
+        this.outputDropped += this.outputBuffer.length - this.maxOutputLines;
         this.outputBuffer = this.outputBuffer.slice(this.outputBuffer.length - this.maxOutputLines);
       }
       return;
@@ -26730,6 +26787,7 @@ class GodotDAPClient {
         text: said(body, "text")
       };
       this.holdKnown = true;
+      this.stops += 1;
       return;
     }
     if (eventName === "continued") {
@@ -26746,20 +26804,24 @@ class GodotDAPClient {
       if (typeof path !== "string" || typeof line !== "number") {
         return;
       }
+      const key = fileKey(path);
+      if (!this.spelled.has(key)) {
+        this.spelled.set(key, path);
+      }
       if (said(body, "reason") === "removed") {
-        this.inEditor.get(path)?.delete(line);
-        const held = this.breakpoints.get(path);
+        this.inEditor.get(key)?.delete(line);
+        const held = this.breakpoints.get(key);
         if (held?.delete(line) === true) {
           if (held.size === 0) {
-            this.breakpoints.delete(path);
+            this.breakpoints.delete(key);
           }
           this.onBreakpointsChanged?.(this.breakpointsHeld());
         }
         return;
       }
-      const known = this.inEditor.get(path) ?? new Set;
+      const known = this.inEditor.get(key) ?? new Set;
       known.add(line);
-      this.inEditor.set(path, known);
+      this.inEditor.set(key, known);
       return;
     }
     if (eventName === "terminated" || eventName === "exited") {
@@ -26842,24 +26904,44 @@ class GodotDAPClient {
   getOutput(clear = false) {
     const lines = [...this.outputBuffer];
     if (clear) {
+      this.outputTaken += lines.length;
       this.outputBuffer = [];
     }
     return lines;
   }
+  outputSoFar() {
+    const output = this.getOutput(false);
+    const notShown = this.outputDropped + this.outputTaken;
+    if (notShown === 0) {
+      return { lines: output.length, output };
+    }
+    const where = [
+      this.outputDropped > 0 ? `${this.outputDropped} fell out of this buffer, which keeps the last ${this.maxOutputLines}` : "",
+      this.outputTaken > 0 ? `${this.outputTaken} were moved into the run's log by an earlier read` : ""
+    ].filter((part) => part !== "");
+    return {
+      lines: output.length,
+      output,
+      notShown,
+      note: `${notShown} earlier ${notShown === 1 ? "line is" : "lines are"} not in this answer: ${where.join(", and ")}. editor_output reads what the server kept of the run's console.`
+    };
+  }
   async setBreakpoint(filePath, line) {
-    const wanted = new Set(this.breakpoints.get(filePath) ?? []);
+    const wanted = new Set(this.breakpoints.get(fileKey(filePath)) ?? []);
     wanted.add(line);
     return await this.sendBreakpoints(filePath, wanted);
   }
   async removeBreakpoint(filePath, line) {
-    const wanted = new Set(this.breakpoints.get(filePath) ?? []);
+    const wanted = new Set(this.breakpoints.get(fileKey(filePath)) ?? []);
     wanted.delete(line);
     return await this.sendBreakpoints(filePath, wanted, line);
   }
   async sendBreakpoints(filePath, mine, clearing) {
     await this.ensureConnected();
     await this.initialize();
-    const lines = new Set([...mine, ...this.inEditor.get(filePath) ?? []]);
+    const key = fileKey(filePath);
+    this.spelled.set(key, filePath);
+    const lines = new Set([...mine, ...this.inEditor.get(key) ?? []]);
     if (clearing !== undefined) {
       lines.delete(clearing);
     }
@@ -26869,14 +26951,14 @@ class GodotDAPClient {
       breakpoints: sorted.map((breakpointLine) => ({ line: breakpointLine }))
     });
     if (mine.size === 0) {
-      this.breakpoints.delete(filePath);
+      this.breakpoints.delete(key);
     } else {
-      this.breakpoints.set(filePath, new Set(mine));
+      this.breakpoints.set(key, new Set(mine));
     }
     if (lines.size === 0) {
-      this.inEditor.delete(filePath);
+      this.inEditor.delete(key);
     } else {
-      this.inEditor.set(filePath, lines);
+      this.inEditor.set(key, lines);
     }
     return answer;
   }
@@ -26885,11 +26967,11 @@ class GodotDAPClient {
   }
   breakpointsInEditor() {
     const theirs = [];
-    for (const [scriptPath, lines] of this.inEditor) {
-      const mine = this.breakpoints.get(scriptPath);
+    for (const [key, lines] of this.inEditor) {
+      const mine = this.breakpoints.get(key);
       const rest = Array.from(lines).filter((line) => !mine?.has(line)).sort((a, b) => a - b);
       if (rest.length > 0) {
-        theirs.push({ scriptPath, lines: rest });
+        theirs.push({ scriptPath: this.spelled.get(key) ?? key, lines: rest });
       }
     }
     return theirs;
@@ -26897,12 +26979,13 @@ class GodotDAPClient {
   async reapplyBreakpoints() {
     const applied = [];
     const refused = [];
-    for (const [filePath, lines] of Array.from(this.breakpoints)) {
+    for (const [key, lines] of Array.from(this.breakpoints)) {
+      const filePath = this.spelled.get(key) ?? key;
       try {
         await this.sendBreakpoints(filePath, lines);
         applied.push({ scriptPath: filePath, lines: Array.from(lines).sort((a, b) => a - b) });
       } catch (error) {
-        this.breakpoints.delete(filePath);
+        this.breakpoints.delete(key);
         refused.push({
           scriptPath: filePath,
           reason: error instanceof Error ? error.message : String(error)
@@ -26915,19 +26998,21 @@ class GodotDAPClient {
     return { applied, refused };
   }
   breakpointsHeld() {
-    return Array.from(this.breakpoints, ([scriptPath, lines]) => ({
-      scriptPath,
+    return Array.from(this.breakpoints, ([key, lines]) => ({
+      scriptPath: this.spelled.get(key) ?? key,
       lines: Array.from(lines).sort((a, b) => a - b)
     }));
   }
   holdBreakpoints(held) {
     for (const { scriptPath, lines } of held) {
-      const fileBreakpoints = this.breakpoints.get(scriptPath) ?? new Set;
+      const key = fileKey(scriptPath);
+      const fileBreakpoints = this.breakpoints.get(key) ?? new Set;
       for (const line of lines) {
         fileBreakpoints.add(line);
       }
       if (fileBreakpoints.size > 0) {
-        this.breakpoints.set(scriptPath, fileBreakpoints);
+        this.breakpoints.set(key, fileBreakpoints);
+        this.spelled.set(key, scriptPath);
       }
     }
   }
@@ -26938,15 +27023,16 @@ class GodotDAPClient {
     this.halt = null;
     this.holdKnown = true;
   }
-  async stepOver(threadId) {
-    await this.attach();
-    const resolvedThreadId = await this.resolveThreadId(threadId);
-    await this.sendRequest("next", { threadId: resolvedThreadId });
-  }
-  async stepInto(threadId) {
+  async step(command) {
     await this.attach();
-    const resolvedThreadId = await this.resolveThreadId(threadId);
-    await this.sendRequest("stepIn", { threadId: resolvedThreadId });
+    const resolvedThreadId = await this.resolveThreadId();
+    const before = this.stops;
+    await this.sendRequest(command, { threadId: resolvedThreadId });
+    const deadline = Date.now() + this.stepPatienceMs;
+    while (this.stops === before && this.connected && Date.now() < deadline) {
+      await delay2(50);
+    }
+    return this.stops !== before;
   }
   async getStackTrace(threadId) {
     await this.attach();
@@ -26972,16 +27058,16 @@ class GodotDAPClient {
       } catch {}
       await delay2(200);
     }
-    return [];
+    return null;
   }
   async getScopes(frameId) {
     await this.attach();
     const frames = await this.getStackTrace();
     const frame = frameId === undefined ? frames[0] : frames.find((each) => each["id"] === frameId);
     if (frame === undefined) {
-      return [];
+      throw new ReadRefusal(frames.length === 0 ? "The adapter gave no stack, so there is no frame to read variables from" : `The stack the adapter gives now has no frame ${String(frameId)}; its frames are ${frames.map((each) => String(each["id"])).join(", ")}. Read the stack again for the frames the game is at now`);
     }
-    const deadline = Date.now() + SCOPES_TIMEOUT_MS;
+    const deadline = Date.now() + this.scopesPatienceMs;
     let scopes = [];
     while (scopes.length === 0 && Date.now() < deadline) {
       try {
@@ -26993,6 +27079,9 @@ class GodotDAPClient {
       } catch {}
       await delay2(200);
     }
+    if (scopes.length === 0) {
+      throw new ReadRefusal(`The scopes of frame ${String(frame["id"])} did not arrive from the game within ${this.scopesPatienceMs / 1000}s. They come from the game through the editor, so a busy machine can take longer: ask again`);
+    }
     const named = [];
     for (const scope of scopes) {
       const reference = scope["variablesReference"];
@@ -27056,9 +27145,8 @@ async function handleDAPTool(client, toolName, args) {
   try {
     switch (toolName) {
       case "dap_get_output": {
-        const output = client.getOutput(false);
         return {
-          content: [{ type: "text", text: JSON.stringify({ lines: output.length, output }, null, 2) }]
+          content: [{ type: "text", text: JSON.stringify(client.outputSoFar(), null, 2) }]
         };
       }
       case "dap_set_breakpoint": {
@@ -27085,19 +27173,13 @@ async function handleDAPTool(client, toolName, args) {
       }
       case "dap_step_over":
       case "dap_step_into": {
-        if (toolName === "dap_step_into") {
-          await client.stepInto();
-        } else {
-          await client.stepOver();
-        }
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({ stepped: true, stack: await client.getStackTrace() }, null, 2)
-            }
-          ]
+        const heldAgain = await client.step(toolName === "dap_step_into" ? "stepIn" : "next");
+        const answer = heldAgain ? { stepped: true, heldAgain, stack: await client.getStackTrace() } : {
+          stepped: true,
+          heldAgain,
+          note: `The game had not stopped again ${client.stepPatienceMs / 1000}s after the step: the step is still running, it went on without stopping anywhere, or the game was not held when it was asked. debug_state stack answers once it stops.`
         };
+        return { content: [{ type: "text", text: JSON.stringify(answer, null, 2) }] };
       }
       case "dap_get_stack_trace": {
         const stack = await client.getStackTrace();
@@ -27108,8 +27190,14 @@ async function handleDAPTool(client, toolName, args) {
       case "dap_get_variables": {
         const frameId = typeof safeArgs.frameId === "number" ? safeArgs.frameId : undefined;
         const scopes = await client.getScopes(frameId);
+        const missing = scopes.filter((scope) => scope.variables === null).map((scope) => scope.name);
+        const answer = missing.length === 0 ? { scopes } : {
+          scopes,
+          valuesMissing: missing,
+          note: `The values of ${missing.join(", ")} did not arrive from the game within ${client.scopesPatienceMs / 1000}s, so they are unknown rather than empty. Ask again.`
+        };
         return {
-          content: [{ type: "text", text: JSON.stringify({ scopes }, null, 2) }]
+          content: [{ type: "text", text: JSON.stringify(answer, null, 2) }]
         };
       }
       default:
@@ -27117,10 +27205,12 @@ async function handleDAPTool(client, toolName, args) {
     }
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    const cure = toolName === "dap_set_breakpoint" || toolName === "dap_remove_breakpoint" ? "Breakpoints need the editor open, not a running game: editor_status says whether one is connected, and the path is the script as the project spells it." : "The debug tools answer for a game the editor is playing: start one with editor_run.";
+    const cure = error instanceof ReadRefusal ? "" : toolName === "dap_set_breakpoint" || toolName === "dap_remove_breakpoint" ? "Breakpoints need the editor open, not a running game: editor_status says whether one is connected, and the path is the script as the project spells it." : "The debug tools answer for a game the editor is playing: start one with editor_run.";
     return {
       isError: true,
-      content: [{ type: "text", text: `DAP tool '${toolName}' failed: ${message}. ${cure}` }]
+      content: [
+        { type: "text", text: `DAP tool '${toolName}' failed: ${message}.${cure === "" ? "" : ` ${cure}`}` }
+      ]
     };
   }
 }
@@ -27482,6 +27572,47 @@ function linesBefore(entries, at, collapsed, wanted) {
   return found.reverse();
 }
 
+// src/engine-run.ts
+import { spawn as spawn2 } from "node:child_process";
+function runEngine(executable, args, options = {}) {
+  return new Promise((resolve) => {
+    const log = new GameLog;
+    let failure = null;
+    const signal = callSignal();
+    const child = spawn2(executable, [...args], {
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true,
+      ...signal === undefined ? {} : { signal }
+    });
+    child.stdout.on("data", (chunk) => {
+      log.append("stdout", chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      log.append("stderr", chunk);
+    });
+    const { timeout } = options;
+    const timer = timeout === undefined ? undefined : setTimeout(() => {
+      failure ??= `it ran past its ${timeout.said}`;
+      child.kill();
+    }, timeout.ms);
+    child.on("error", (error) => {
+      failure ??= error.name === "AbortError" ? "the call was cancelled" : `it could not be started: ${error.message}`;
+    });
+    child.on("close", (code, closedBy) => {
+      clearTimeout(timer);
+      log.finish();
+      const started = child.pid !== undefined;
+      resolve({ log, exitCode: started ? code : null, exitSignal: closedBy, failure });
+    });
+  });
+}
+function howItEnded(run) {
+  if (run.failure !== null) {
+    return run.exitSignal === null ? run.failure : `ended by ${run.exitSignal}, because ${run.failure}`;
+  }
+  return run.exitSignal === null ? `exit code ${run.exitCode ?? "unknown"}` : `ended by ${run.exitSignal}`;
+}
+
 // src/godot-bridge.ts
 import { randomUUID } from "node:crypto";
 import { EventEmitter } from "node:events";
@@ -27519,7 +27650,10 @@ function mayYetConnect(listeningSince, now = Date.now()) {
   return listeningSince === undefined || now - listeningSince.getTime() < CONNECT_WINDOW_MS;
 }
 function theEditorHasComeBack(status, startedAt) {
-  return status.connected && (status.connectedAt?.getTime() ?? 0) > startedAt && status.addonVersion !== undefined;
+  return hasSaidWhoItIs(status) && (status.connectedAt?.getTime() ?? 0) > startedAt;
+}
+function hasSaidWhoItIs(status) {
+  return status.connected && status.addonVersion !== undefined;
 }
 function anEditorIsStillComing(listeningSince, launchedEditorIsAlive, now = Date.now()) {
   return mayYetConnect(listeningSince, now) || launchedEditorIsAlive;
@@ -27669,6 +27803,7 @@ class GodotBridge extends EventEmitter {
       dapPort: this.connectionInfo?.dapPort,
       debugPort: this.connectionInfo?.debugPort,
       openedByAServer: this.connectionInfo?.openedByAServer,
+      startedByAnEditor: this.connectionInfo?.startedByAnEditor,
       syncsBreakpoints: this.connectionInfo?.syncsBreakpoints,
       pendingRequests: this.pendingRequests.size,
       queuedResources: this.resourceQueues.size,
@@ -27814,6 +27949,7 @@ class GodotBridge extends EventEmitter {
           this.connectionInfo.dapPort = servedPort(message.dap_port);
           this.connectionInfo.debugPort = servedPort(message.debug_port);
           this.connectionInfo.openedByAServer = message.opened_by_a_server === true;
+          this.connectionInfo.startedByAnEditor = typeof message.started_by_an_editor === "boolean" ? message.started_by_an_editor : undefined;
           this.connectionInfo.syncsBreakpoints = typeof message.syncs_breakpoints === "boolean" ? message.syncs_breakpoints : undefined;
           this.log("info", `Godot ready: ${message.project_path}`);
           this.emitBridgeEvent("godot_connected", { projectPath: message.project_path });
@@ -28148,10 +28284,8 @@ class GodotLocator {
 }
 
 // src/headless.ts
-import { execFile as execFile3 } from "node:child_process";
-import { writeFileSync as writeFileSync8 } from "node:fs";
-import { join as join13 } from "node:path";
-import { promisify as promisify3 } from "node:util";
+import { existsSync as existsSync10, readFileSync as readFileSync12, realpathSync as realpathSync2, writeFileSync as writeFileSync8 } from "node:fs";
+import { dirname as dirname7, join as join13 } from "node:path";
 
 // src/reimport.ts
 import { createHash as createHash2 } from "node:crypto";
@@ -28277,7 +28411,6 @@ function lastTryOnExit() {
 }
 
 // src/headless.ts
-var run3 = promisify3(execFile3);
 function snakeCased(params) {
   const result = emptyRecord();
   for (const [key, value] of Object.entries(params)) {
@@ -28286,34 +28419,58 @@ function snakeCased(params) {
   }
   return result;
 }
-function lastJsonObject(stdout) {
-  const lines = stdout.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.startsWith("{"));
-  for (const line of lines.reverse()) {
-    try {
-      const parsed = JSON.parse(line);
-      if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
-        return parsed;
-      }
-    } catch {}
-  }
-  return null;
+function engineExtras(outcome) {
+  return {
+    ...outcome.messages.length > 0 ? { engine_messages: outcome.messages } : {},
+    ...outcome.messagesOmitted === undefined ? {} : { engine_messages_omitted: outcome.messagesOmitted },
+    ...outcome.afterAnswer === undefined ? {} : { engine_after_answer: outcome.afterAnswer }
+  };
 }
-function problems(stderr) {
-  const log = new GameLog;
-  log.append("stderr", stderr);
-  log.finish();
-  return log.select({ severity: "warning", sinceLastCall: false, limit: 200 }).entries;
+var OWN_ERROR = "[ERROR] ";
+var MESSAGES_KEPT = 200;
+var ERRORS_NAMED = 3;
+function problemsIn(log) {
+  return log.everything().flatMap((entry) => {
+    if (entry.severity !== "info") {
+      return [entry];
+    }
+    if (entry.source === "stderr" && entry.text.startsWith(OWN_ERROR)) {
+      return [{ ...entry, severity: "error", text: entry.text.slice(OWN_ERROR.length) }];
+    }
+    return [];
+  });
 }
-function reason(stdout, stderr) {
-  const own = stderr.split(/\r?\n/).filter((line) => line.startsWith("[ERROR] ")).map((line) => line.slice("[ERROR] ".length));
+function reported(problems) {
+  const omitted = Math.max(0, problems.length - MESSAGES_KEPT);
+  return omitted === 0 ? { messages: problems } : { messages: problems.slice(omitted), messagesOmitted: omitted };
+}
+function reason(log, problems) {
+  const own = log.everything().filter((entry) => entry.source === "stderr" && entry.severity === "info" && entry.text.startsWith(OWN_ERROR));
   if (own.length > 0) {
-    return own.join("; ");
-  }
-  const engine = problems(stderr).filter((entry) => entry.severity === "error").map((entry) => entry.text);
-  if (engine.length > 0) {
-    return engine.join("; ");
+    return own.map((entry) => entry.text.slice(OWN_ERROR.length)).join("; ");
+  }
+  const errors = problems.filter((entry) => entry.severity === "error").map((entry) => entry.text);
+  if (errors.length > 0) {
+    const rest = errors.length - ERRORS_NAMED;
+    return rest > 0 ? `${errors.slice(0, ERRORS_NAMED).join("; ")}; and ${rest} more error${rest === 1 ? "" : "s"}` : errors.join("; ");
+  }
+  const printed = log.everything().filter((entry) => entry.source === "stdout");
+  return printed.at(-1)?.text ?? "no output at all";
+}
+function scriptFault(problems, script) {
+  const spelled = (path) => `(${path.replaceAll("\\", "/").toLowerCase()}/`;
+  const directories = [...new Set([spelled(dirname7(script)), spelled(resolvedOr(dirname7(script)))])];
+  return problems.find((entry) => {
+    const at = entry.detail.find((line) => line.startsWith("at: "))?.replaceAll("\\", "/").toLowerCase();
+    return entry.severity === "error" && at !== undefined && directories.some((directory) => at.includes(directory));
+  });
+}
+function resolvedOr(path) {
+  try {
+    return realpathSync2.native(path);
+  } catch {
+    return path;
   }
-  return stdout.trim().split(/\r?\n/).at(-1) ?? "no output at all";
 }
 function librariesNotCopied(messages) {
   const found = new Set;
@@ -28353,30 +28510,33 @@ async function runImport(godotPath, projectPath, options = {}) {
 }
 async function importOnce(godotPath, projectPath) {
   const logDir = scratchDirectory("import");
+  let ran;
   try {
-    const { stderr } = await run3(godotPath, ["--headless", "--log-file", join13(logDir, "engine.log"), "--path", projectPath, "--import"], { signal: callSignal() });
-    return { ok: true, messages: problems(stderr) };
-  } catch (error) {
-    if (error instanceof Error && "stdout" in error && "stderr" in error) {
-      const failed = error;
-      return {
-        ok: false,
-        message: `the import pass failed (exit ${failed.code ?? "unknown"}): ${reason(failed.stdout, failed.stderr)}`,
-        messages: problems(failed.stderr)
-      };
-    }
-    return {
-      ok: false,
-      message: `the import pass could not be run: ${error instanceof Error ? error.message : String(error)}`,
-      messages: []
-    };
+    ran = await runEngine(godotPath, [
+      "--headless",
+      "--log-file",
+      join13(logDir, "engine.log"),
+      "--path",
+      projectPath,
+      "--import"
+    ]);
   } finally {
     discard(logDir);
   }
+  const problems = problemsIn(ran.log);
+  if (ran.exitCode === 0 && ran.failure === null) {
+    return { ok: true, ...reported(problems) };
+  }
+  return {
+    ok: false,
+    message: `the import pass failed (${howItEnded(ran)}): ${reason(ran.log, problems)}`,
+    ...reported(problems)
+  };
 }
 async function runOperation(engine, operation, params, projectPath) {
   const paramsDir = scratchDirectory("params");
   const paramsFile = join13(paramsDir, `${operation}.json`);
+  const answerFile = join13(paramsDir, "answer.json");
   writeFileSync8(paramsFile, JSON.stringify(snakeCased(params)), "utf8");
   const args = [
     "--headless",
@@ -28388,38 +28548,63 @@ async function runOperation(engine, operation, params, projectPath) {
     engine.script,
     operation,
     `@file:${paramsFile}`,
+    answerFile,
     ...engine.debug ? ["--debug-godot"] : []
   ];
-  let stdout;
-  let stderr;
+  let ran;
+  let answer;
   try {
-    ({ stdout, stderr } = await run3(engine.godotPath, args, { signal: callSignal() }));
-  } catch (error) {
-    if (error instanceof Error && "stdout" in error && "stderr" in error) {
-      const failed = error;
-      return {
-        ok: false,
-        message: `${operation} failed (exit ${failed.code ?? "unknown"}): ${reason(failed.stdout, failed.stderr)}`,
-        messages: problems(failed.stderr)
-      };
-    }
+    ran = await runEngine(engine.godotPath, args);
+    answer = answerIn(answerFile);
+  } finally {
+    discard(paramsDir);
+  }
+  const problems = problemsIn(ran.log);
+  if (answer.kind === "unreadable") {
     return {
       ok: false,
-      message: `${operation} could not be run: ${error instanceof Error ? error.message : String(error)}`,
-      messages: []
+      message: `${operation} wrote an answer that could not be read (${answer.why})`,
+      ...reported(problems)
+    };
+  }
+  if (answer.kind === "none") {
+    const ending = ran.exitCode === 0 && ran.failure === null ? "produced no result" : `failed (${howItEnded(ran)})`;
+    return {
+      ok: false,
+      message: `${operation} ${ending}: ${reason(ran.log, problems)}`,
+      ...reported(problems)
     };
-  } finally {
-    discard(paramsDir);
   }
-  const payload = lastJsonObject(stdout);
-  if (payload === null) {
+  const fault = scriptFault(problems, engine.script);
+  if (fault !== undefined) {
     return {
       ok: false,
-      message: `${operation} produced no result: ${reason(stdout, stderr)}`,
-      messages: problems(stderr)
+      message: `${operation} hit an error in the operations script, so its answer is left out: part of it was ` + `never computed. ${fault.text} (${fault.detail[0]?.slice("at: ".length) ?? "no location given"})`,
+      ...reported(problems)
+    };
+  }
+  const afterAnswer = ran.exitCode === 0 && ran.failure === null ? undefined : `The operation finished and wrote this answer, and then the engine did not exit cleanly (${howItEnded(ran)}). Anything it reported on the way out is under engine_messages.`;
+  return {
+    ok: true,
+    payload: answer.payload,
+    ...reported(problems),
+    ...afterAnswer === undefined ? {} : { afterAnswer }
+  };
+}
+function answerIn(file) {
+  if (!existsSync10(file)) {
+    return { kind: "none" };
+  }
+  const text = readFileSync12(file, "utf8");
+  try {
+    const parsed = JSON.parse(text);
+    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? { kind: "answer", payload: parsed } : { kind: "unreadable", why: `it is JSON but not an object: ${text.slice(0, 200)}` };
+  } catch (error) {
+    return {
+      kind: "unreadable",
+      why: `${error instanceof Error ? error.message : String(error)}: ${text.slice(0, 200)}`
     };
   }
-  return { ok: true, payload, messages: problems(stderr) };
 }
 
 // src/headless-operations.ts
@@ -28620,13 +28805,18 @@ function parseJUnit(xml) {
   const suiteElements = top.name === "testsuite" ? [top] : top.children.filter((child) => child.name === "testsuite");
   const suites = suiteElements.map((suite) => {
     const cases = suite.children.filter((child) => child.name === "testcase").map((element) => caseOf(suite, element));
+    const failures = cases.filter((entry) => entry.status === "failed").length;
+    const errors = cases.filter((entry) => entry.status === "error").length;
+    const written = (kind) => suite.children.filter((child) => child.name === "testcase").reduce((sum, element) => sum + element.children.filter((child) => child.name === kind).length, 0);
     return {
       name: suite.attributes["name"] ?? "",
       path: pathOf(suite),
       tests: cases.length,
       discovered: count(suite.attributes, "tests"),
-      failures: cases.filter((entry) => entry.status === "failed").length,
-      errors: cases.filter((entry) => entry.status === "error").length,
+      failures,
+      errors,
+      hookFailures: Math.max(0, count(suite.attributes, "failures") - written("failure")),
+      hookErrors: Math.max(0, count(suite.attributes, "errors") - written("error")),
       skipped: cases.filter((entry) => entry.status === "skipped").length,
       time: count(suite.attributes, "time"),
       cases
@@ -28637,13 +28827,22 @@ function parseJUnit(xml) {
     tests: all.length,
     failures: all.filter((entry) => entry.status === "failed").length,
     errors: all.filter((entry) => entry.status === "error").length,
+    hookFailures: suites.reduce((sum, suite) => sum + suite.hookFailures, 0),
+    hookErrors: suites.reduce((sum, suite) => sum + suite.hookErrors, 0),
     skipped: all.filter((entry) => entry.status === "skipped").length,
     time: suites.reduce((sum, suite) => sum + suite.time, 0),
     suites
   };
 }
+var HOOK_FAILURE = /^\s*(.*?)\s*\tat '(before|after)' in (res:\/\/.+?):(\d+)\s*$/;
+function hookFailuresPrinted(printed) {
+  return printed.flatMap((line) => {
+    const found = HOOK_FAILURE.exec(line);
+    return found === null ? [] : [{ hook: found[2] ?? "", path: found[3] ?? "", line: Number(found[4]), message: found[1] ?? "" }];
+  });
+}
 var NOTHING_RAN = /no test cases found/i;
-var NO_SUCH_PATH = /given directory or file does not exists:\s*(\S+)/i;
+var NO_SUCH_PATH = /given directory or file does not exists:\s*(.+?)\s*$/i;
 function whyNoReport(printed, asked) {
   const missing = printed.map((line) => NO_SUCH_PATH.exec(line)).find((found) => found !== null);
   if (missing !== undefined) {
@@ -28730,13 +28929,17 @@ function withActualsPrinted(failed, printed) {
     at: match[5] ?? "",
     ...readDiff(match[1] ?? "")
   }));
+  const used = new Set;
   return failed.map((entry) => {
     if (entry.detail === null) {
       return entry;
     }
     let detail = entry.detail;
     let recovered = false;
-    for (const diff of diffs) {
+    for (const [index, diff] of diffs.entries()) {
+      if (used.has(index)) {
+        continue;
+      }
       const wrong = ` but was
  '${diff.merged.replaceAll("\r", "")}'${diff.suffix}
 	at ${diff.at}`;
@@ -28745,6 +28948,7 @@ function withActualsPrinted(failed, printed) {
  '${diff.actual}'${diff.suffix}
 	at ${diff.at}`);
         recovered = true;
+        used.add(index);
       }
     }
     const quoted = QUOTED_EQUALITY.exec(detail);
@@ -28768,7 +28972,7 @@ function masked(expected, actual) {
   return `${expected}${actual}`.includes(MASKED_BRACKET) && allSpelled(expected) && allSpelled(actual);
 }
 var PRINTED_DICTIONARY = /^\{\n\t[\s\S]*\n {2}\}$/;
-var RUNNING_SUITE = /Run Test Suite:\s*(\S+)/;
+var RUNNING_SUITE = /Run Test Suite:\s*(res:\/\/.+?\.(?:gd|cs))(?=\s|$)/;
 var ORPHANS = /(\d+)\s+orphans/;
 var OVERALL = "Overall Summary";
 function orphansPrinted(printed) {
@@ -28803,13 +29007,24 @@ function orphansPrinted(printed) {
 }
 
 // src/lsp_client.ts
-import { realpathSync as realpathSync2 } from "node:fs";
+import { existsSync as existsSync11, realpathSync as realpathSync3 } from "node:fs";
 import { readFile, realpath } from "node:fs/promises";
 import { createConnection as createConnection3 } from "node:net";
-import { dirname as dirname7, resolve as resolve3 } from "node:path";
+import { dirname as dirname8, join as join14, resolve as resolve3 } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 var DEFAULT_LSP_PORT = 6005;
 var DIAGNOSTICS_TIMEOUT_MS = 5000;
+
+class ArgumentRefusal extends Refusal {
+}
+
+class AnotherProjectsServer extends Refusal {
+  serves;
+  constructor(port, serves, asked) {
+    super(`The language server on port ${port} belongs to the editor of ${serves}, not ${asked}.`);
+    this.serves = serves;
+  }
+}
 function diagnosticsKey(uri) {
   let decoded;
   try {
@@ -28821,7 +29036,7 @@ function diagnosticsKey(uri) {
     return decoded;
   }
   try {
-    return realpathSync2.native(fileURLToPath(decoded)).toLowerCase();
+    return realpathSync3.native(fileURLToPath(decoded)).toLowerCase();
   } catch {
     return decoded.toLowerCase();
   }
@@ -28838,8 +29053,10 @@ class GodotLSPClient {
   connectPromise = null;
   initialized = false;
   rootPath = null;
+  servedWorkspace = null;
   diagnosticsWaiters = new Map;
   documentVersions = new Map;
+  documentTurns = new Map;
   constructor(port = portFromEnv("GDHARNESS_LSP_PORT", DEFAULT_LSP_PORT), host = "127.0.0.1") {
     this.port = port;
     this.host = host;
@@ -28936,7 +29153,7 @@ class GodotLSPClient {
     if (this.initialized) {
       return;
     }
-    const rootPath = this.rootPath ?? dirname7(resolve3(filePath));
+    const rootPath = this.rootPath ?? dirname8(resolve3(filePath));
     await this.initialize(rootPath);
   }
   async sendRequest(method, params) {
@@ -29011,6 +29228,10 @@ class GodotLSPClient {
         }
       }
     }
+    if (message["method"] === "gdscript_client/changeWorkspace") {
+      const path = message["params"]?.["path"];
+      this.servedWorkspace = typeof path === "string" ? path : null;
+    }
     if (message["method"] === "textDocument/publishDiagnostics") {
       const params = message["params"];
       const paramsObject = params && typeof params === "object" ? params : null;
@@ -29113,10 +29334,14 @@ class GodotLSPClient {
       this.sendNotification("textDocument/didClose", { textDocument: { uri } });
     } catch {}
   }
+  forgetServedWorkspace() {
+    this.servedWorkspace = null;
+  }
   async initialize(rootPath) {
     await this.ensureConnected();
     const resolvedRootPath = resolve3(rootPath);
     const rootUri = pathToFileURL(resolvedRootPath).href;
+    this.forgetServedWorkspace();
     const result = await this.sendRequest("initialize", {
       processId: process.pid,
       rootPath: resolvedRootPath,
@@ -29142,60 +29367,82 @@ class GodotLSPClient {
         }
       ]
     });
+    const served = this.servedWorkspace;
+    if (served !== null && !isSameDirectory(served, resolvedRootPath)) {
+      throw new AnotherProjectsServer(this.port, served, resolvedRootPath);
+    }
     this.sendNotification("initialized", {});
     this.initialized = true;
     this.rootPath = resolvedRootPath;
     return result;
   }
-  async getDiagnostics(filePath, content) {
-    await this.ensureConnected();
-    await this.ensureInitializedForFile(filePath);
+  async withDocument(filePath, work) {
     const key = diagnosticsKey(this.toFileUri(filePath));
-    const diagnosticsPromise = new Promise((resolveDiagnostics, rejectDiagnostics) => {
-      const existing = this.diagnosticsWaiters.get(key);
-      if (existing) {
-        clearTimeout(existing.timer);
-      }
-      const timer = setTimeout(() => {
-        this.diagnosticsWaiters.delete(key);
-        rejectDiagnostics(new Error(`Godot published no diagnostics for ${key} within ${DIAGNOSTICS_TIMEOUT_MS}ms. ` + "The language server may not be running, or may not have this file in its workspace."));
-      }, DIAGNOSTICS_TIMEOUT_MS);
-      this.diagnosticsWaiters.set(key, {
-        resolve: resolveDiagnostics,
-        reject: rejectDiagnostics,
-        timer
-      });
-    });
-    let opened = null;
+    const before = this.documentTurns.get(key) ?? Promise.resolve();
+    let done = () => {};
+    const mine = new Promise((finished) => {
+      done = finished;
+    });
+    const turn = before.then(() => mine);
+    this.documentTurns.set(key, turn);
+    await before;
     try {
-      opened = this.syncDocument(filePath, content);
-      return await diagnosticsPromise;
-    } catch (error) {
-      const waiter = this.diagnosticsWaiters.get(key);
-      if (waiter) {
-        clearTimeout(waiter.timer);
-        this.diagnosticsWaiters.delete(key);
-      }
-      throw error;
+      return await work();
     } finally {
-      if (opened !== null) {
-        this.closeDocument(opened);
+      done();
+      if (this.documentTurns.get(key) === turn) {
+        this.documentTurns.delete(key);
       }
     }
   }
-  async getCompletions(filePath, content, line, character) {
+  async getDiagnostics(filePath, content) {
     await this.ensureConnected();
     await this.ensureInitializedForFile(filePath);
-    const uri = this.syncDocument(filePath, content);
-    let result;
-    try {
-      result = await this.sendRequest("textDocument/completion", {
-        textDocument: { uri },
-        position: { line, character }
+    return this.withDocument(filePath, async () => {
+      const key = diagnosticsKey(this.toFileUri(filePath));
+      const diagnosticsPromise = new Promise((resolveDiagnostics, rejectDiagnostics) => {
+        const timer = setTimeout(() => {
+          this.diagnosticsWaiters.delete(key);
+          rejectDiagnostics(new Error(`Godot published no diagnostics for ${key} within ${DIAGNOSTICS_TIMEOUT_MS}ms. ` + "The language server may not be running, or may not have this file in its workspace."));
+        }, DIAGNOSTICS_TIMEOUT_MS);
+        this.diagnosticsWaiters.set(key, {
+          resolve: resolveDiagnostics,
+          reject: rejectDiagnostics,
+          timer
+        });
       });
-    } finally {
-      this.closeDocument(uri);
-    }
+      let opened = null;
+      try {
+        opened = this.syncDocument(filePath, content);
+        return await diagnosticsPromise;
+      } catch (error) {
+        const waiter = this.diagnosticsWaiters.get(key);
+        if (waiter) {
+          clearTimeout(waiter.timer);
+          this.diagnosticsWaiters.delete(key);
+        }
+        throw error;
+      } finally {
+        if (opened !== null) {
+          this.closeDocument(opened);
+        }
+      }
+    });
+  }
+  async getCompletions(filePath, content, line, character) {
+    await this.ensureConnected();
+    await this.ensureInitializedForFile(filePath);
+    const result = await this.withDocument(filePath, async () => {
+      const uri = this.syncDocument(filePath, content);
+      try {
+        return await this.sendRequest("textDocument/completion", {
+          textDocument: { uri },
+          position: { line, character }
+        });
+      } finally {
+        this.closeDocument(uri);
+      }
+    });
     if (Array.isArray(result)) {
       return result;
     }
@@ -29210,28 +29457,31 @@ class GodotLSPClient {
   async getHover(filePath, content, line, character) {
     await this.ensureConnected();
     await this.ensureInitializedForFile(filePath);
-    const uri = this.syncDocument(filePath, content);
-    try {
-      return await this.sendRequest("textDocument/hover", {
-        textDocument: { uri },
-        position: { line, character }
-      });
-    } finally {
-      this.closeDocument(uri);
-    }
+    return this.withDocument(filePath, async () => {
+      const uri = this.syncDocument(filePath, content);
+      try {
+        return await this.sendRequest("textDocument/hover", {
+          textDocument: { uri },
+          position: { line, character }
+        });
+      } finally {
+        this.closeDocument(uri);
+      }
+    });
   }
   async getDocumentSymbols(filePath, content) {
     await this.ensureConnected();
     await this.ensureInitializedForFile(filePath);
-    const uri = this.syncDocument(filePath, content);
-    let result;
-    try {
-      result = await this.sendRequest("textDocument/documentSymbol", {
-        textDocument: { uri }
-      });
-    } finally {
-      this.closeDocument(uri);
-    }
+    const result = await this.withDocument(filePath, async () => {
+      const uri = this.syncDocument(filePath, content);
+      try {
+        return await this.sendRequest("textDocument/documentSymbol", {
+          textDocument: { uri }
+        });
+      } finally {
+        this.closeDocument(uri);
+      }
+    });
     return Array.isArray(result) ? result : [];
   }
   isConnected() {
@@ -29263,36 +29513,39 @@ async function resolveLSPPaths(projectPathValue, scriptPathValue) {
   try {
     projectPath = await realpath(requestedProjectPath);
   } catch {
-    throw new Refusal(`Project path does not exist: ${requestedProjectPath}`);
+    throw new ArgumentRefusal(`Project path does not exist: ${requestedProjectPath}`);
+  }
+  if (!existsSync11(join14(projectPath, "project.godot"))) {
+    throw new ArgumentRefusal(`Not a Godot project: ${projectPath}. Point projectPath at the directory holding project.godot.`);
   }
   const contained = resolveWithinProject(projectPath, scriptPathValue);
   if (!contained.ok) {
-    throw new Refusal(contained.reason);
+    throw new ArgumentRefusal(contained.reason);
   }
   let scriptPath;
   try {
     scriptPath = await realpath(contained.absolutePath);
   } catch {
-    throw new Refusal(`Script file does not exist: ${contained.absolutePath}`);
+    throw new ArgumentRefusal(`Script file does not exist: ${contained.absolutePath}`);
   }
   if (!isWithinRoot(projectPath, scriptPath)) {
-    throw new Refusal("scriptPath resolves outside the project root boundary.");
+    throw new ArgumentRefusal("scriptPath resolves outside the project root boundary.");
   }
   return { projectPath, scriptPath };
 }
 async function handleLSPTool(client, toolName, args) {
   try {
     if (!args || typeof args !== "object") {
-      throw new Refusal("Tool arguments must be an object.");
+      throw new ArgumentRefusal("Tool arguments must be an object.");
     }
     const parsedArgs = args;
     const projectPathValue = parsedArgs["projectPath"];
     const scriptPathValue = parsedArgs["scriptPath"];
     if (typeof projectPathValue !== "string" || projectPathValue.length === 0) {
-      throw new Refusal("Missing required argument: projectPath");
+      throw new ArgumentRefusal("Missing required argument: projectPath");
     }
     if (typeof scriptPathValue !== "string" || scriptPathValue.length === 0) {
-      throw new Refusal("Missing required argument: scriptPath");
+      throw new ArgumentRefusal("Missing required argument: scriptPath");
     }
     const { projectPath, scriptPath } = await resolveLSPPaths(projectPathValue, scriptPathValue);
     const content = await readFile(scriptPath, "utf8");
@@ -29306,7 +29559,7 @@ async function handleLSPTool(client, toolName, args) {
         const line = Number(parsedArgs["line"]);
         const character = Number(parsedArgs["character"]);
         if (!Number.isFinite(line) || !Number.isFinite(character)) {
-          throw new Refusal("Arguments line and character must be numbers.");
+          throw new ArgumentRefusal("Arguments line and character must be numbers.");
         }
         const completions = await client.getCompletions(scriptPath, content, line, character);
         return asToolResponse({ completions });
@@ -29315,7 +29568,7 @@ async function handleLSPTool(client, toolName, args) {
         const line = Number(parsedArgs["line"]);
         const character = Number(parsedArgs["character"]);
         if (!Number.isFinite(line) || !Number.isFinite(character)) {
-          throw new Refusal("Arguments line and character must be numbers.");
+          throw new ArgumentRefusal("Arguments line and character must be numbers.");
         }
         const hover = await client.getHover(scriptPath, content, line, character);
         return asToolResponse({ hover });
@@ -29329,13 +29582,15 @@ async function handleLSPTool(client, toolName, args) {
     }
   } catch (error) {
     return asToolResponse({
-      error: normalizeLSPError(error, client.port)
+      error: normalizeLSPError(error, client.port),
+      ...error instanceof AnotherProjectsServer ? { serves: error.serves } : {},
+      ...error instanceof ArgumentRefusal ? { refusedArguments: true } : {}
     });
   }
 }
 
 // src/outside.ts
-import { spawn as spawn2 } from "node:child_process";
+import { spawn as spawn3 } from "node:child_process";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function changesFrom(env, base) {
   const changes = {};
@@ -29369,7 +29624,7 @@ function readLaunched(printed) {
 }
 async function launchOutsideTheTree(spec, runtime = process.execPath, keeper = KEEPER_SCRIPT) {
   return await new Promise((resolve) => {
-    const launcher = spawn2(runtime, [keeper, "launch"], {
+    const launcher = spawn3(runtime, [keeper, "launch"], {
       stdio: ["pipe", "pipe", "pipe"],
       windowsHide: true
     });
@@ -29400,9 +29655,9 @@ async function launchOutsideTheTree(spec, runtime = process.execPath, keeper = K
 }
 
 // src/process-time.ts
-import { execFile as execFile4 } from "node:child_process";
-import { promisify as promisify4 } from "node:util";
-var run4 = promisify4(execFile4);
+import { execFile as execFile3 } from "node:child_process";
+import { promisify as promisify3 } from "node:util";
+var run3 = promisify3(execFile3);
 var ASK_TIMEOUT_MS2 = 6000;
 async function cpuSecondsOf(pid) {
   try {
@@ -29417,7 +29672,7 @@ async function secondsOnWindows(pid) {
   return Number.isFinite(seconds) ? seconds : undefined;
 }
 async function askPosix2(pid) {
-  const { stdout } = await run4("ps", ["-o", "time=", "-p", String(pid)], { timeout: ASK_TIMEOUT_MS2 });
+  const { stdout } = await run3("ps", ["-o", "time=", "-p", String(pid)], { timeout: ASK_TIMEOUT_MS2 });
   return secondsFromClock(stdout.trim());
 }
 function secondsFromClock(printed) {
@@ -29437,16 +29692,46 @@ function secondsFromClock(printed) {
 }
 
 // src/project-scan.ts
-import { existsSync as existsSync10, readdirSync as readdirSync5, readFileSync as readFileSync12 } from "node:fs";
-import { join as join14 } from "node:path";
+import { existsSync as existsSync12, readdirSync as readdirSync5, readFileSync as readFileSync13 } from "node:fs";
+import { join as join15 } from "node:path";
 var SKIPPED = new Set(["node_modules"]);
 function skipped(name) {
   return name.startsWith(".") || SKIPPED.has(name);
 }
 function steppedOver(directory) {
-  return existsSync10(join14(directory, ".gdignore"));
-}
-var ASSET_EXTENSIONS = new Set(["png", "jpg", "jpeg", "webp", "svg", "ttf", "otf", "wav", "mp3", "ogg"]);
+  return existsSync12(join15(directory, ".gdignore"));
+}
+var SCENE_EXTENSIONS = new Set(["tscn", "scn"]);
+var ASSET_EXTENSIONS = new Set([
+  "png",
+  "jpg",
+  "jpeg",
+  "webp",
+  "svg",
+  "bmp",
+  "tga",
+  "exr",
+  "hdr",
+  "ktx",
+  "dds",
+  "ttf",
+  "otf",
+  "woff",
+  "woff2",
+  "fnt",
+  "wav",
+  "mp3",
+  "ogg",
+  "glb",
+  "gltf",
+  "obj",
+  "fbx",
+  "blend",
+  "dae",
+  "ogv",
+  "gdshader",
+  "shader"
+]);
 function projectStructure(projectPath) {
   const structure = { scenes: 0, scripts: 0, assets: 0, other: 0 };
   const visit = (directory) => {
@@ -29458,10 +29743,10 @@ function projectStructure(projectPath) {
         continue;
       }
       if (entry.isDirectory()) {
-        visit(join14(directory, entry.name));
+        visit(join15(directory, entry.name));
       } else if (entry.isFile()) {
         const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
-        if (extension === "tscn") {
+        if (SCENE_EXTENSIONS.has(extension)) {
           structure.scenes += 1;
         } else if (extension === "gd" || extension === "cs") {
           structure.scripts += 1;
@@ -29489,14 +29774,14 @@ function scriptsWithoutUid(projectPath) {
       }
       const spelled = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
       if (entry.isDirectory()) {
-        visit(join14(directory, entry.name), spelled);
+        visit(join15(directory, entry.name), spelled);
         continue;
       }
       if (!entry.isFile()) {
         continue;
       }
       const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
-      if (CARRIES_A_UID.has(extension) && !existsSync10(join14(directory, `${entry.name}.uid`))) {
+      if (CARRIES_A_UID.has(extension) && !existsSync12(join15(directory, `${entry.name}.uid`))) {
         found.push(spelled);
       }
     }
@@ -29504,8 +29789,11 @@ function scriptsWithoutUid(projectPath) {
   visit(projectPath, "");
   return found.sort();
 }
+function isBinary(bytes) {
+  return bytes.subarray(0, 8000).includes(0);
+}
 function searchProject(projectPath, options) {
-  const extensions = new Set(options.fileTypes.map((ext) => ext.replace(/^\./, "").toLowerCase()).filter(Boolean));
+  const extensions = options.fileTypes === undefined ? null : new Set(options.fileTypes.map((ext) => ext.replace(/^\./, "").toLowerCase()).filter(Boolean));
   const result = {
     query: options.query,
     results: [],
@@ -29513,13 +29801,7 @@ function searchProject(projectPath, options) {
   };
   const regex = options.regex ? new RegExp(options.query, options.caseSensitive ? "" : "i") : null;
   const needle = options.caseSensitive ? options.query : options.query.toLowerCase();
-  const full = () => {
-    if (result.summary.total_matches >= options.maxResults) {
-      result.summary.truncated = true;
-      return true;
-    }
-    return false;
-  };
+  const full = () => result.summary.truncated;
   const visit = (directory) => {
     if (steppedOver(directory)) {
       return;
@@ -29531,27 +29813,32 @@ function searchProject(projectPath, options) {
       if (skipped(entry.name)) {
         continue;
       }
-      const entryPath = join14(directory, entry.name);
+      const entryPath = join15(directory, entry.name);
       if (entry.isDirectory()) {
         visit(entryPath);
         continue;
       }
       const extension = entry.name.includes(".") ? entry.name.split(".").pop()?.toLowerCase() ?? "" : "";
-      if (!entry.isFile() || !extensions.has(extension)) {
+      if (!entry.isFile() || extensions !== null && !extensions.has(extension)) {
+        continue;
+      }
+      const bytes = readFileSync13(entryPath);
+      if (extensions === null && isBinary(bytes)) {
         continue;
       }
       result.summary.files_searched += 1;
       const matches = [];
-      for (const [index, line] of readFileSync12(entryPath, "utf8").split(`
-`).entries()) {
-        if (full()) {
-          break;
+      for (const [index, line] of bytes.toString("utf8").split(/\r?\n/).entries()) {
+        const found = regex ? regex.exec(line) : (options.caseSensitive ? line : line.toLowerCase()).includes(needle) ? [options.query] : null;
+        if (found === null) {
+          continue;
         }
-        const match = regex ? regex.exec(line)?.[0] : (options.caseSensitive ? line : line.toLowerCase()).includes(needle) ? options.query : "";
-        if (match) {
-          matches.push({ line: index + 1, content: line.trim(), match });
-          result.summary.total_matches += 1;
+        if (result.summary.total_matches >= options.maxResults) {
+          result.summary.truncated = true;
+          break;
         }
+        matches.push({ line: index + 1, content: line.trim(), match: found[0] ?? "" });
+        result.summary.total_matches += 1;
       }
       if (matches.length > 0) {
         const relativePath = entryPath.slice(projectPath.length + 1).replace(/\\/g, "/");
@@ -29565,7 +29852,7 @@ function searchProject(projectPath, options) {
 }
 
 // src/resources.ts
-import { readFileSync as readFileSync13 } from "node:fs";
+import { readFileSync as readFileSync14, realpathSync as realpathSync4 } from "node:fs";
 import { extname, resolve as resolve4 } from "node:path";
 var STATIC_RESOURCES = [
   {
@@ -29599,7 +29886,7 @@ var RESOURCE_COUNT = STATIC_RESOURCES.length + RESOURCE_TEMPLATES.length;
 function ensureProjectPath(getProjectPath) {
   const projectPath = getProjectPath();
   if (!projectPath) {
-    throw new Refusal("Project path is not set. Set a Godot project path first.");
+    throw new Refusal("This server knows no project to read from: start it with GDHARNESS_PROJECT, connect an editor, or make any tool call naming a projectPath that holds project.godot.");
   }
   return resolve4(projectPath);
 }
@@ -29615,7 +29902,22 @@ function resolveProjectFile(projectPath, resourcePath) {
   if (!contained.ok) {
     throw new Refusal(contained.reason);
   }
-  return contained.absolutePath;
+  let root;
+  try {
+    root = realpathSync4.native(projectPath);
+  } catch {
+    throw new Refusal(`The project directory ${projectPath} is not there.`);
+  }
+  let real;
+  try {
+    real = realpathSync4.native(contained.absolutePath);
+  } catch {
+    throw new Refusal(`No file at ${resourcePath} in the project.`);
+  }
+  if (!isWithinRoot(root, real)) {
+    throw new Refusal(`${resourcePath} leads outside the project through a link, so it is not read.`);
+  }
+  return real;
 }
 function parseGodotUri(uri) {
   if (uri === "godot://project/info") {
@@ -29760,7 +30062,7 @@ function readResourceText(uri, getProjectPath) {
   const parsedUri = parseGodotUri(uri);
   if (parsedUri.kind === "project-info") {
     const projectFilePath = resolveProjectFile(projectPath, "project.godot");
-    const rawProject = readFileSync13(projectFilePath, "utf-8");
+    const rawProject = readFileSync14(projectFilePath, "utf-8");
     const parsedProject = parseProjectGodot(rawProject);
     return {
       mimeType: "application/json",
@@ -29769,7 +30071,7 @@ function readResourceText(uri, getProjectPath) {
   }
   const filePath = resolveProjectFile(projectPath, parsedUri.resourcePath);
   ensureAllowedExtension(parsedUri.kind, filePath);
-  const text = readFileSync13(filePath, "utf-8");
+  const text = readFileSync14(filePath, "utf-8");
   return {
     mimeType: parsedUri.kind === "script" ? "text/x-gdscript" : "text/plain",
     text
@@ -29806,15 +30108,15 @@ function setupResourceHandlers(mcp, getProjectPath) {
 }
 
 // src/restart-note.ts
-import { mkdirSync as mkdirSync7, readFileSync as readFileSync14, rmSync as rmSync6, writeFileSync as writeFileSync9 } from "node:fs";
-import { dirname as dirname8, join as join15 } from "node:path";
+import { mkdirSync as mkdirSync7, readFileSync as readFileSync15, rmSync as rmSync6, writeFileSync as writeFileSync9 } from "node:fs";
+import { dirname as dirname9, join as join16 } from "node:path";
 function restartNotePath(projectPath) {
-  return join15(projectPath, ".godot", "gdharness-restart.json");
+  return join16(projectPath, ".godot", "gdharness-restart.json");
 }
 function noteRestartBegun(note) {
   const path = restartNotePath(note.projectPath);
   try {
-    mkdirSync7(dirname8(path), { recursive: true });
+    mkdirSync7(dirname9(path), { recursive: true });
     writeFileSync9(path, `${JSON.stringify(note, null, 2)}
 `, "utf8");
   } catch (error) {
@@ -29823,7 +30125,7 @@ function noteRestartBegun(note) {
 }
 function restartOwed(projectPath) {
   try {
-    const parsed = JSON.parse(readFileSync14(restartNotePath(projectPath), "utf8"));
+    const parsed = JSON.parse(readFileSync15(restartNotePath(projectPath), "utf8"));
     if (typeof parsed !== "object" || parsed === null) {
       return null;
     }
@@ -29845,32 +30147,32 @@ function restartSettled(projectPath) {
 }
 
 // src/run-record.ts
-import { execFile as execFile5 } from "node:child_process";
+import { execFile as execFile4 } from "node:child_process";
 import { createHash as createHash3 } from "node:crypto";
 import {
   mkdirSync as mkdirSync8,
   openSync as openSync2,
   readdirSync as readdirSync6,
-  readFileSync as readFileSync15,
-  realpathSync as realpathSync3,
+  readFileSync as readFileSync16,
+  realpathSync as realpathSync5,
   rmSync as rmSync7,
   statSync as statSync6,
   writeFileSync as writeFileSync10
 } from "node:fs";
-import { basename as basename3, dirname as dirname9, join as join16, resolve as resolve5 } from "node:path";
-import { promisify as promisify5 } from "node:util";
-var execFileAsync = promisify5(execFile5);
+import { basename as basename3, dirname as dirname10, join as join17, resolve as resolve5 } from "node:path";
+import { promisify as promisify4 } from "node:util";
+var execFileAsync = promisify4(execFile4);
 function runsDirectory() {
-  return join16(runtimeDirectory(), "runs");
+  return join17(runtimeDirectory(), "runs");
 }
 function realAsFarAsItExists(path) {
   const missing = [];
   let at = path;
   for (;; ) {
     try {
-      return join16(realpathSync3.native(at), ...missing);
+      return join17(realpathSync5.native(at), ...missing);
     } catch {
-      const parent = dirname9(at);
+      const parent = dirname10(at);
       if (parent === at) {
         return path;
       }
@@ -29885,16 +30187,19 @@ function projectKey(projectPath) {
   return createHash3("sha256").update(folded.replaceAll("\\", "/")).digest("hex").slice(0, 16);
 }
 function runRecordPath(projectPath, directory = runtimeDirectory()) {
-  return join16(directory, "runs", `note-${projectKey(projectPath)}.json`);
+  return join17(directory, "runs", `note-${projectKey(projectPath)}.json`);
 }
 var SHARED_NOTE = "run.json";
 function openTranscript(startedAt) {
   mkdirSync8(runsDirectory(), { recursive: true });
-  const path = join16(runsDirectory(), `run-${startedAt}.log`);
+  const path = join17(runsDirectory(), `run-${startedAt}.log`);
   return { path, fd: openSync2(path, "a") };
 }
+function noteIsAbout(note, playing) {
+  return note.play !== undefined && playing !== null && note.play.play === playing.play && note.play.editorPid === playing.editorPid;
+}
 function editorNotePath(projectPath, directory = runtimeDirectory()) {
-  return join16(directory, "runs", `editor-${projectKey(projectPath)}.json`);
+  return join17(directory, "runs", `editor-${projectKey(projectPath)}.json`);
 }
 function writeEditorRunNote(note) {
   mkdirSync8(runsDirectory(), { recursive: true });
@@ -29902,7 +30207,7 @@ function writeEditorRunNote(note) {
 }
 function readEditorRunNote(projectPath) {
   for (const directory of runtimeDirectories()) {
-    const note = editorNoteAt(editorNotePath(projectPath, directory)) ?? editorNoteAt(join16(directory, "runs", "editor-run.json"));
+    const note = editorNoteAt(editorNotePath(projectPath, directory)) ?? editorNoteAt(join17(directory, "runs", "editor-run.json"));
     if (note !== null && isSameDirectory(note.projectPath, projectPath)) {
       return note;
     }
@@ -29912,7 +30217,7 @@ function readEditorRunNote(projectPath) {
 function editorNoteAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync15(path, "utf8"));
+    parsed = JSON.parse(readFileSync16(path, "utf8"));
   } catch {
     return null;
   }
@@ -29926,7 +30231,9 @@ function editorNoteAt(path) {
   if (typeof projectPath !== "string" || typeof transcript !== "string" || typeof startedAt !== "number") {
     return null;
   }
-  return { projectPath, transcript, startedAt };
+  const play = fields["play"];
+  const which = typeof play === "object" && play !== null && typeof play["play"] === "number" && typeof play["editorPid"] === "number" ? play : undefined;
+  return { projectPath, transcript, startedAt, ...which === undefined ? {} : { play: which } };
 }
 function readRunRecord(projectPath) {
   for (const directory of runtimeDirectories()) {
@@ -29934,7 +30241,7 @@ function readRunRecord(projectPath) {
     if (own !== null) {
       return own;
     }
-    const shared = recordAt(join16(directory, "runs", SHARED_NOTE));
+    const shared = recordAt(join17(directory, "runs", SHARED_NOTE));
     if (shared !== null && shared.projectPath !== "" && isSameDirectory(shared.projectPath, projectPath)) {
       return shared;
     }
@@ -29946,13 +30253,13 @@ function everyRunRecord() {
   for (const directory of runtimeDirectories()) {
     let entries;
     try {
-      entries = readdirSync6(join16(directory, "runs"));
+      entries = readdirSync6(join17(directory, "runs"));
     } catch {
       continue;
     }
     for (const entry of entries) {
       if (entry === SHARED_NOTE || entry.startsWith("note-") && entry.endsWith(".json")) {
-        const record = recordAt(join16(directory, "runs", entry));
+        const record = recordAt(join17(directory, "runs", entry));
         if (record !== null) {
           found.push(record);
         }
@@ -29964,7 +30271,7 @@ function everyRunRecord() {
 function recordAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync15(path, "utf8"));
+    parsed = JSON.parse(readFileSync16(path, "utf8"));
   } catch {
     return null;
   }
@@ -29983,7 +30290,9 @@ function recordAt(path) {
     pid,
     transcript,
     startedAt,
+    ...typeof fields["startedBy"] === "number" ? { startedBy: fields["startedBy"] } : {},
     projectPath: typeof fields["projectPath"] === "string" ? fields["projectPath"] : "",
+    ...typeof fields["servedBy"] === "string" && fields["servedBy"] !== "" ? { servedBy: fields["servedBy"] } : {},
     arguments: Array.isArray(args) ? args.filter((value) => typeof value === "string") : [],
     ...typeof fields["command"] === "string" ? { command: fields["command"] } : {},
     ...typeof fields["exitCode"] === "number" ? { exitCode: fields["exitCode"] } : {},
@@ -29992,7 +30301,8 @@ function recordAt(path) {
 }
 async function runningAs(pid) {
   if (process.platform === "win32") {
-    const answer = await windowsCommandLine(pid);
+    const read = await readWindowsCommandLine(pid);
+    const answer = "answer" in read ? read.answer : null;
     if (answer !== null) {
       const [, ...rest] = answer.split(`
 `);
@@ -30004,13 +30314,17 @@ async function runningAs(pid) {
       }
     }
     const image = await windowsImage(pid);
-    return image === null ? null : { kind: "image", text: image };
+    return image === null ? null : {
+      kind: "image",
+      text: image,
+      unread: "unread" in read ? read.unread : "Windows gave an empty command line"
+    };
   }
   try {
     const began = await startedAt(pid, null);
     const when = began === null ? {} : { startedAt: began };
     if (process.platform === "linux") {
-      const raw = readFileSync15(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
+      const raw = readFileSync16(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
       return raw === "" ? null : { kind: "commandLine", text: raw, ...when };
     }
     const args = (await execFileAsync("ps", ["-p", String(pid), "-o", "args="], { encoding: "utf8", timeout: 15000 })).stdout.trim();
@@ -30055,13 +30369,18 @@ function listeningPidInNetstat(printed, port) {
   }
   return null;
 }
-async function windowsCommandLine(pid) {
-  try {
-    const answer = (await askWindows(`$p = Get-CimInstance Win32_Process -Filter "ProcessId=${pid}"; if ($p) { $p.CreationDate.ToUniversalTime().ToString("o"); $p.CommandLine }`, 15000)).trim();
-    return answer === "" ? null : answer;
-  } catch {
-    return null;
+async function readWindowsCommandLine(pid, ask = askWindows) {
+  const query = `$p = Get-CimInstance Win32_Process -Filter "ProcessId=${pid}"; if ($p) { $p.CreationDate.ToUniversalTime().ToString("o"); $p.CommandLine }`;
+  let unread = "";
+  for (const withinMs of [15000, 45000]) {
+    try {
+      const answer = (await ask(query, withinMs)).trim();
+      return answer === "" ? { unread: "Windows gave no command line for it" } : { answer };
+    } catch (error) {
+      unread = errorMessage(error);
+    }
   }
+  return { unread };
 }
 async function startedAt(pid, windowsAnswer) {
   if (process.platform === "win32") {
@@ -30089,37 +30408,44 @@ async function windowsImage(pid) {
     return null;
   }
 }
-async function stillTheRecordedRun(record) {
-  return judgeRun(record, await runningAs(record.pid), "confirmed");
+async function whyNotStillTheRecordedRun(record) {
+  return whyNotTheRun(record, await runningAs(record.pid), "confirmed");
 }
 async function couldStillBeTheRecordedRun(record) {
   return judgeRun(record, await runningAs(record.pid), "possible");
 }
 var SAME_RUN_WINDOW_MS = 1e4;
 function judgeRun(record, running, needed) {
+  return whyNotTheRun(record, running, needed) === null;
+}
+function whyNotTheRun(record, running, needed) {
   if (running === null) {
-    return false;
+    return "the operating system would not describe that process";
   }
-  if (running.startedAt !== undefined && running.startedAt - record.startedAt > SAME_RUN_WINDOW_MS) {
-    return false;
+  const after = running.startedAt === undefined ? 0 : running.startedAt - (record.startedBy ?? record.startedAt);
+  if (after > SAME_RUN_WINDOW_MS) {
+    return `that process started ${Math.round(after / 1000)} seconds after the run had`;
   }
   const engine = record.command === undefined ? null : basename3(record.command);
   const said = process.platform === "win32" ? running.text.toLowerCase() : running.text;
   const wanted = engine === null || process.platform !== "win32" ? engine : engine.toLowerCase();
   if (wanted !== null && !said.includes(wanted)) {
-    return false;
+    return `that process is not ${engine ?? "the engine"}, which the run was started with`;
   }
   if (running.kind === "commandLine" && readCommandLine(running.text).editor) {
-    return false;
+    return "that process is an editor";
   }
   if (record.projectPath === "") {
-    return wanted !== null;
+    return wanted !== null ? null : "the record names neither the project nor the engine";
   }
   if (running.kind === "image") {
-    return needed === "possible" && wanted !== null;
+    if (wanted === null) {
+      return "the operating system named only its executable, and the record names no engine";
+    }
+    return needed === "possible" ? null : `the operating system named only its executable and not its command line (${running.unread ?? "no reason given"}), which is not enough to signal it on`;
   }
   const project = process.platform === "win32" ? record.projectPath.toLowerCase() : record.projectPath;
-  return said.includes(project);
+  return said.includes(project) ? null : `that process's command line does not name ${record.projectPath}`;
 }
 async function stillTheAnnouncedGame(pid, projectPath, announcedAt) {
   return judgeAnnouncedGame(await runningAs(pid), projectPath, announcedAt);
@@ -30139,7 +30465,7 @@ function judgeAnnouncedGame(running, projectPath, announcedAt) {
 }
 function clearRunRecord(projectPath) {
   for (const directory of runtimeDirectories()) {
-    const shared = join16(directory, "runs", SHARED_NOTE);
+    const shared = join17(directory, "runs", SHARED_NOTE);
     const sharedRecord = recordAt(shared);
     const ours = sharedRecord !== null && sharedRecord.projectPath !== "" && isSameDirectory(sharedRecord.projectPath, projectPath);
     for (const path of [runRecordPath(projectPath, directory), ...ours ? [shared] : []]) {
@@ -30169,7 +30495,7 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
     if (!entry.startsWith("run-") || !entry.endsWith(".log")) {
       continue;
     }
-    const path = join16(directory, entry);
+    const path = join17(directory, entry);
     if (kept.has(path) || ageMs(path, now) < keepMs) {
       continue;
     }
@@ -30180,19 +30506,20 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
 }
 
 // src/setup.ts
+import { spawnSync } from "node:child_process";
 import { createHash as createHash4 } from "node:crypto";
 import {
   cpSync,
-  existsSync as existsSync11,
+  existsSync as existsSync13,
   mkdirSync as mkdirSync9,
   readdirSync as readdirSync7,
-  readFileSync as readFileSync16,
+  readFileSync as readFileSync17,
   rmdirSync,
   rmSync as rmSync8,
   statSync as statSync7,
   writeFileSync as writeFileSync11
 } from "node:fs";
-import { dirname as dirname10, join as join17 } from "node:path";
+import { dirname as dirname11, join as join18 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 var ADDONS = ["gdharness_editor", "gdharness_runtime", "auto_reload"];
 var EDITOR_PLUGINS = ["gdharness_editor", "auto_reload"];
@@ -30209,21 +30536,21 @@ function editorAddonDigest(from = shippedAddonsDirectory()) {
       if (name === VERSION_MARKER || name === DIGEST_MARKER) {
         continue;
       }
-      const path = join17(directory, name);
+      const path = join18(directory, name);
       const inside = `${relative}/${name}`;
       if (statSync7(path).isDirectory()) {
         walk(path, inside);
       } else {
         hash.update(`${inside}
 `);
-        hash.update(readFileSync16(path));
+        hash.update(readFileSync17(path));
         hash.update(`
 `);
       }
     }
   };
   for (const name of EDITOR_PLUGINS) {
-    walk(join17(from, name), name);
+    walk(join18(from, name), name);
   }
   return hash.digest("hex");
 }
@@ -30238,17 +30565,132 @@ function shippedEditorDigest() {
   }
   return shippedDigest ?? undefined;
 }
+function installedEditorDigest(projectPath) {
+  const marker = join18(projectPath, "addons", ADDONS[0], DIGEST_MARKER);
+  if (!existsSync13(marker)) {
+    return null;
+  }
+  const said = readFileSync17(marker, "utf8").trim();
+  return said === "" ? null : said;
+}
 function shippedAddonsDirectory() {
-  return join17(dirname10(fileURLToPath3(import.meta.url)), "godot", "addons");
+  return join18(dirname11(fileURLToPath3(import.meta.url)), "godot", "addons");
 }
 function installedAddonVersion(projectPath) {
-  const marker = join17(projectPath, "addons", ADDONS[0], VERSION_MARKER);
-  if (!existsSync11(marker)) {
+  const marker = join18(projectPath, "addons", ADDONS[0], VERSION_MARKER);
+  if (!existsSync13(marker)) {
     return null;
   }
-  const said = readFileSync16(marker, "utf8").trim();
+  const said = readFileSync17(marker, "utf8").trim();
   return said === "" ? null : said;
 }
+function loaderAmong(projectPath, named) {
+  let byName = null;
+  for (const [entry, path] of named) {
+    if (entry === RUNTIME_AUTOLOAD.name || path === RUNTIME_AUTOLOAD.path) {
+      continue;
+    }
+    let source = null;
+    try {
+      source = readFileSync17(join18(projectPath, path), "utf8");
+    } catch {}
+    if (source?.includes(RUNTIME_AUTOLOAD.path)) {
+      return { name: entry, path, exists: true };
+    }
+    byName ??= path.toLowerCase().includes("gdharness") ? { name: entry, path, exists: source !== null } : null;
+  }
+  return byName;
+}
+function autoloadPaths(settings) {
+  const named = new Map;
+  for (const [name, value] of Object.entries(settings["autoload"] ?? {})) {
+    const said = typeof value === "string" ? value.replace(/^\*/, "") : "";
+    if (said.startsWith("res://")) {
+      named.set(name, said.slice("res://".length));
+    }
+  }
+  return named;
+}
+function trackedByGit(projectPath, wanted) {
+  if (wanted.length === 0) {
+    return new Set;
+  }
+  const asked = spawnSync("git", ["ls-files", "-z", "--", ...wanted], {
+    cwd: projectPath,
+    encoding: "utf8"
+  });
+  if (asked.status !== 0) {
+    return null;
+  }
+  return new Set(asked.stdout.split("\x00").filter(Boolean));
+}
+function enabledPlugins(settings) {
+  const raw = settings["editor_plugins"]?.["enabled"];
+  if (typeof raw !== "string") {
+    return [];
+  }
+  return [...raw.matchAll(/res:\/\/addons\/([^/"]+)\/plugin\.cfg/g)].map((match) => match[1] ?? "").filter(Boolean);
+}
+function inspectProject(projectPath) {
+  const problems = [];
+  const addons = ADDONS.map((name) => {
+    const directory = join18(projectPath, "addons", name);
+    const marker = join18(directory, VERSION_MARKER);
+    const installed = existsSync13(directory);
+    const version = existsSync13(marker) ? readFileSync17(marker, "utf8").trim() : null;
+    const current = version === SERVER_VERSION;
+    if (!installed) {
+      problems.push(`addons/${name} is not installed; run gdharness setup`);
+    } else if (!current) {
+      problems.push(`addons/${name} is ${version ?? "of an unknown version"}, this gdharness is ${SERVER_VERSION}; run gdharness setup`);
+    }
+    return { name, installed, version, current };
+  });
+  const settings = parseProjectGodot(readFileSync17(join18(projectPath, "project.godot"), "utf8"));
+  const pluginsEnabled = enabledPlugins(settings);
+  for (const name of EDITOR_PLUGINS) {
+    if (!pluginsEnabled.includes(name)) {
+      problems.push(`the ${name} plugin is not enabled in project.godot; run gdharness setup`);
+    }
+  }
+  const autoload = settings["autoload"];
+  const registered = autoload === undefined ? undefined : readString(autoload, RUNTIME_AUTOLOAD.name);
+  const runtimeAutoloadPath = typeof registered === "string" ? registered.replace(/^\*/, "") : null;
+  const named = autoloadPaths(settings);
+  const runtimeLoaderAutoload = loaderAmong(projectPath, named);
+  const runtimeAutoload = runtimeAutoloadPath !== null || runtimeLoaderAutoload !== null;
+  const tracked = trackedByGit(projectPath, [...named.values()]);
+  const addonMissing = (path) => addons.some((addon) => !addon.installed && path.startsWith(`addons/${addon.name}/`));
+  for (const [name, path] of named) {
+    if (!existsSync13(join18(projectPath, path))) {
+      if (!addonMissing(path)) {
+        problems.push(`the ${name} autoload names res://${path}, which is not in this project, so it boots with a missing script; restore that file, or point the autoload at one that is here`);
+      }
+      continue;
+    }
+    if (tracked !== null && !tracked.has(path)) {
+      problems.push(`the ${name} autoload names res://${path}, which git does not carry, so a clone boots with a missing script; commit that file, or point the autoload at one the project tracks`);
+    }
+  }
+  const cached = cachedClasses(projectPath);
+  const staleClasses = cached === null ? [] : staleAgainst(cached, projectPath);
+  if (cached === null) {
+    problems.push("no .godot/global_script_class_cache.cfg: the engine knows no class_name; run project_import refresh_classes or open the editor");
+  } else if (staleClasses.length > 0) {
+    problems.push(`the class cache does not list ${staleClasses.join(", ")}; run project_import refresh_classes or gdharness classes`);
+  }
+  return {
+    projectPath,
+    addons,
+    pluginsEnabled,
+    runtimeAutoload,
+    runtimeAutoloadPath,
+    runtimeLoaderAutoload,
+    staleClasses,
+    classCacheExists: cached !== null,
+    problems
+  };
+}
 
 // src/tool-definitions.ts
 var PROJECT_INFO_SECTIONS = [
@@ -30299,7 +30741,7 @@ var NODE_PATH = {
 };
 var PROPERTIES = {
   type: "object",
-  description: 'Properties to set, keyed by Godot property name. Vectors, colours and the like may be written as {"x": 1, "y": 2} or tagged {"_type": "Vector2", "x": 1, "y": 2}, which is the form a read answers with, so a value read off one node can be written straight to another.',
+  description: 'Properties to set, keyed by Godot property name. Vectors, colours and the like may be written as {"x": 1, "y": 2} or tagged {"_type": "Vector2", "x": 1, "y": 2}, which is the form a read answers with, so a value read off one node can be written straight to another. A property holding a node takes the path to it from the node being set, such as "../Player". Each value is read back once set, and one the engine changed or refused is refused with what it holds.',
   additionalProperties: true
 };
 var XY = {
@@ -30454,11 +30896,18 @@ var TOOL_SPECS = [
       },
       value: {
         blank: true,
-        description: 'The value to write. Engine types may be tagged, {"_type": "Vector2", "x": 1, "y": 2}. "" writes an empty string.'
+        description: 'The value to write. Engine types may be tagged, {"_type": "Vector2", "x": 1, "y": 2}, and infinity as {"_type": "float", "value": "inf"}, the form a read answers with. "" writes an empty string.'
       },
       name: { type: "string", description: "Autoload name." },
       path: { type: "string", description: "Autoload script or scene inside the project." },
-      enabled: { type: "boolean", description: "Autoloads: register enabled. Default true." },
+      enabled: {
+        type: "boolean",
+        description: "Autoloads: Godot 4 loads every autoload in the list, so false is refused. Use global: false to keep the name out of the global scope, or remove_autoload to stop it loading."
+      },
+      global: {
+        type: "boolean",
+        description: `Autoloads: make the name a global variable, the * in project.godot and the editor's "Global Variable" column. Default true. The autoload loads either way.`
+      },
       scenePath: SCENE_PATH,
       actionName: { type: "string", description: 'Input action name, such as "jump".' },
       events: INPUT_EVENTS,
@@ -30470,9 +30919,15 @@ var TOOL_SPECS = [
       },
       pluginName: { type: "string", description: "Folder name under addons/." },
       busName: { type: "string", description: "Audio bus name." },
-      parentBusIndex: { type: "number", description: "Audio buses: the bus to send to. Default 0, Master." },
+      parentBusIndex: {
+        type: "number",
+        description: "Audio buses: the bus to send to. Default 0, Master. The new bus goes right after it, so every later bus moves one along, and the answer lists them all."
+      },
       busIndex: { type: "number", description: "Audio bus index." },
-      effectIndex: { type: "number", description: "Slot on the bus for the effect." },
+      effectIndex: {
+        type: "number",
+        description: "Slot on the bus for the effect: the effect there is replaced, and one past the last adds one. Any other slot is refused."
+      },
       effectType: { type: "string", description: 'Effect class, such as "AudioEffectReverb".' },
       volumeDb: { type: "number", description: "Bus volume in decibels." }
     },
@@ -30491,7 +30946,7 @@ var TOOL_SPECS = [
       disable_plugin: { summary: "disable an addon", requires: ["pluginName"] },
       add_audio_bus: { summary: "add an audio bus", requires: ["busName"] },
       set_audio_bus_effect: {
-        summary: "add or configure an effect on a bus",
+        summary: "put an effect in a slot on a bus",
         requires: ["busIndex", "effectIndex", "effectType"]
       },
       set_audio_bus_volume: { summary: "set a bus volume", requires: ["busIndex", "volumeDb"] }
@@ -30530,7 +30985,11 @@ var TOOL_SPECS = [
         type: "boolean",
         description: "forward: include the engine's own res://. resources. Default false."
       },
-      fileTypes: { type: "array", items: { type: "string" }, description: "reverse: extensions to look in." }
+      fileTypes: {
+        type: "array",
+        items: { type: "string" },
+        description: 'reverse: extensions to look in, plus "godot" for project.godot, "cfg" for plugin.cfg and export_presets.cfg, and "import" for import sidecars. Default all of tscn, tres, gd, gdshader, godot, cfg and import, since an autoload, the main scene and a plugin script are named only in the settings files.'
+      }
     },
     requires: ["projectPath", "resourcePath"]
   },
@@ -30575,7 +31034,10 @@ var TOOL_SPECS = [
         summary: "reimport what status says is outdated or failed, one resource with resourcePath, or what is current as well with force. Through the open editor when one serves the project, so it reloads what it holds, waiting for it to finish; otherwise through the engine's own import pass. Answered from a second status read: reimported lists what is current now, notReimported what is not, with its status and reason, and via says which of the two did the work. stillImporting is an editor that had not finished within timeoutMs",
         requires: []
       },
-      uid: { summary: "the UID of one file", requires: ["resourcePath"] },
+      uid: {
+        summary: "the UID of one file and where it was read: a script's or shader's .uid file, an imported file's .import, or a scene's or resource's own header",
+        requires: ["resourcePath"]
+      },
       refresh_uids: {
         summary: "import the project so every script and shader has its .uid sidecar, and name under uidsCreated the ones this made and under stillWithoutUid the ones the engine would not import: it writes no scene and no script, so a project whose sidecars are all present is left untouched",
         requires: []
@@ -30636,11 +31098,11 @@ var TOOL_SPECS = [
   },
   {
     name: "scene_create",
-    description: "Creates a scene file, saves one, or saves a copy under a new path. Needs the editor connected.",
+    description: "Creates a scene file where none is, saves one, or saves a copy under a new path. A save of a scene open in the editor saves the editor's copy, unsaved changes included. Needs the editor connected.",
     parameters: {
       projectPath: PROJECT_PATH,
       scenePath: SCENE_PATH,
-      rootNodeType: { type: "string", description: "create: the root node class. Default Node2D." },
+      rootNodeType: { type: "string", description: "create: the root node class. Default Node." },
       newPath: { type: "string", description: "save_as: where the copy goes." }
     },
     requires: ["projectPath", "scenePath"],
@@ -30664,7 +31126,7 @@ var TOOL_SPECS = [
   },
   {
     name: "scene_node",
-    description: "One node in a scene file: add, read, set, duplicate, reparent or delete it, or paint TileMap cells. Any ClassDB node type can be added, so a NavigationRegion2D, an AnimationTree or a Camera3D is an add with that nodeType and its properties. A property holding a Resource takes the res:// path of one, so a texture, a material or a theme is a set like any other. Needs the editor connected.",
+    description: "One node in a scene file: add, read, set, duplicate, reparent or delete it, or paint TileMap cells. Any ClassDB node type can be added, so a NavigationRegion2D, an AnimationTree or a Camera3D is an add with that nodeType and its properties. A property holding a Resource takes the res:// path of one, so a texture, a material or a theme is a set like any other. A write is refused while the editor holds unsaved changes to the scene, and for a node that belongs to a scene this one instances or inherits. Needs the editor connected.",
     parameters: {
       projectPath: PROJECT_PATH,
       scenePath: SCENE_PATH,
@@ -30682,7 +31144,10 @@ var TOOL_SPECS = [
         type: "boolean",
         description: "get: include properties still at their default. Default false."
       },
-      layer: { type: "number", description: "set_tilemap_cells: the TileMap layer. Default 0." },
+      layer: {
+        type: "number",
+        description: "set_tilemap_cells: the layer of a TileMap. Default 0. A TileMapLayer is one layer."
+      },
       cells: TILEMAP_CELLS
     },
     requires: ["projectPath", "scenePath"],
@@ -30693,7 +31158,10 @@ var TOOL_SPECS = [
       duplicate: { summary: "copy a node and its children", requires: ["nodePath", "newName"] },
       reparent: { summary: "move a node under another parent", requires: ["nodePath", "newParentPath"] },
       delete: { summary: "remove a node and its children", requires: ["nodePath"] },
-      set_tilemap_cells: { summary: "place tiles in a TileMap", requires: ["nodePath", "cells"] }
+      set_tilemap_cells: {
+        summary: "place tiles in a TileMapLayer or TileMap",
+        requires: ["nodePath", "cells"]
+      }
     }
   },
   {
@@ -30781,13 +31249,16 @@ var TOOL_SPECS = [
   },
   {
     name: "script_edit",
-    description: "Creates a GDScript file, or adds functions, variables and signals to one. Every declaration written carries a type. create loads what it wrote under the project's own warning settings and answers with parses; the engine's reasons for a refusal come back under engine_messages.",
+    description: "Creates a GDScript file, or adds functions, variables and signals to one. Every declaration written carries a type. Both load what they wrote under the project's own warning settings and answer with parses; the engine's reasons for a refusal come back under engine_messages. create answers with the extends and class_name the engine read, and a script declaring a class_name is put in the project's class list, with registered saying whether it is there. modify makes every addition or none, and answers with the line each one is on in the file written.",
     parameters: {
       projectPath: PROJECT_PATH,
       scriptPath: SCRIPT_PATH,
-      className: { type: "string", description: "create: a class_name for the script." },
-      extends: { type: "string", description: "create: the base class. Default Node." },
-      content: { type: "string", description: "create: the whole file, instead of a template." },
+      className: { type: "string", description: "create: a class_name for the script. Not with content." },
+      extends: { type: "string", description: "create: the base class. Default Node. Not with content." },
+      content: {
+        type: "string",
+        description: "create: the whole file, written as given, instead of a template, className and extends."
+      },
       template: {
         type: "string",
         enum: ["singleton", "state_machine", "component", "resource"],
@@ -30878,13 +31349,13 @@ var TOOL_SPECS = [
   },
   {
     name: "editor_launch",
-    description: "Opens the Godot editor on a project, or restarts the one already connected. The editor is an ordinary visible one on the desktop in use, and on Windows it is shown without being activated, so opening or reopening it does not take the keyboard from whatever the user is typing in. hidden: true opens it headless instead and, on Windows, on a desktop of its own, where the games it plays go too; a hidden editor serves the bridge, the language server and the debug adapter as a visible one does. A game a visible editor plays opens as a window on the desktop in use. An editor goes on serving the addon it read at startup, so restart is what puts a gdharness upgrade into effect, and nothing else here restarts one; it saves open scenes on the way out and answers with the version that came back. An editor a server opened is started again by the server, visible unless hidden: true is passed again. One opened by hand restarts itself, which only one with a window can do, because the engine hands back none of the arguments it was started with. editor_status says which editor is connected and whether it is holding an old addon. Opening a project is a save and so is closing one, which is the part that is not obvious from outside: the editor imports the project on open and writes project.godot back, and Godot writes only what differs from its own defaults, so a key named deliberately at its default value is dropped either way. A restart says which under settingsDropped in its own answer because it waits for the editor to return. An open cannot, since it answers as soon as the process exists and the save happens during the import minutes later, so editor_status carries that reading once the editor has connected. Nothing else will say a key went until something depends on one. A restart of an editor this server opened is a quit and then a launch, and this server can be ended between them, usually by the reconnect the restart was being taken for: the editor is gone and nothing replaces it. That is written down before the quit, so the next server says so under restartInterrupted in editor_status rather than waiting for an editor that is not coming, and open finishes it, saying so under finishesRestart.",
+    description: "Opens the Godot editor on a project, or restarts the one already connected. The editor is an ordinary visible one on the desktop in use, and on Windows it is shown without being activated, so opening or reopening it does not take the keyboard from whatever the user is typing in. hidden: true opens it headless instead and, on Windows, on a desktop of its own, where the games it plays go too; a hidden editor serves the bridge, the language server and the debug adapter as a visible one does. A game a visible editor plays opens as a window on the desktop in use. An editor goes on serving the addon it read at startup, so restart is what puts a gdharness upgrade into effect, and nothing else here restarts one; it saves open scenes on the way out and answers with the version that came back. An editor a server opened is started again by the server, visible unless hidden: true is passed again, once the old one has gone: it waits 90 seconds for that, or GDHARNESS_EDITOR_RESTART_TIMEOUT_MS, and an old editor still running after it is not replaced, since the new one would find its ports held. One opened by hand restarts itself, which only one with a window can do, because the engine hands back none of the arguments it was started with. editor_status says which editor is connected and whether it is holding an old addon. Opening a project is a save and so is closing one, which is the part that is not obvious from outside: the editor imports the project on open and writes project.godot back, and Godot writes only what differs from its own defaults, so a key named deliberately at its default value is dropped either way. A restart says which under settingsDropped in its own answer because it waits for the editor to return. An open cannot, since it answers as soon as the process exists and the save happens during the import minutes later, so editor_status carries that reading once the editor has connected. Nothing else will say a key went until something depends on one. A restart of an editor this server opened is a quit and then a launch, and this server can be ended between them, usually by the reconnect the restart was being taken for: the editor is gone and nothing replaces it. That is written down before the quit, so the next server says so under restartInterrupted in editor_status rather than waiting for an editor that is not coming, and open finishes it, saying so under finishesRestart. An open is refused when the editor it would start could never reach this server: a project other than the one this server serves, whose editor dials that project's own server; a project without the gdharness editor addon installed and enabled; and a project whose editor a restart is already bringing back.",
     parameters: {
       projectPath: { ...PROJECT_PATH, ops: ["open"] },
       hidden: {
         type: "boolean",
         ops: ["open", "restart"],
-        description: "Open the editor headless and, on Windows, on a desktop of its own, so no window of it or of the games it plays appears. Default false: one visible editor, shown without taking the focus."
+        description: "Open the editor headless and, on Windows, on a desktop of its own, so no window of it or of the games it plays appears. Default false: one visible editor, shown without taking the focus. On restart only for an editor a server opened; one opened by hand comes back as it was, so hidden is refused there."
       }
     },
     requires: [],
@@ -30972,7 +31443,7 @@ var TOOL_SPECS = [
         requires: ["projectPath"]
       },
       stop: {
-        summary: "end the run and answer with what it printed last, naming the process ended under endedPid: for a run the editor plays, the number its game announced under, read at the stop rather than remembered, and the operating system hands a freed number to the next process, so it can equal the game before it. A game that started processes of its own keeps them unless andChildren says to end those too. stopped is false, with the number under notSignalled, when that number no longer answers as the process the run was started as and nothing was signalled",
+        summary: "end the run and answer with what it printed last, naming the process ended under endedPid: for a run the editor plays, the number its game announced under, read at the stop rather than remembered, and the operating system hands a freed number to the next process, so it can equal the game before it. A game that started processes of its own keeps them unless andChildren says to end those too. stopped is false, with the number under notSignalled, when that number no longer answers as the process the run was started as and nothing was signalled, and false with the number under stillGoing when what was told to end was still running ten seconds later",
         requires: []
       },
       check: {
@@ -30985,7 +31456,7 @@ var TOOL_SPECS = [
   },
   {
     name: "editor_output",
-    description: "What the project started by editor_run has printed, as entries with a severity: the errors and warnings the engine reported, each with where it happened, and everything else as info. For a run the editor plays the reports come from the game itself, through the runtime addon, since the editor's debugger relays what a game prints and not what it reports; a played game without the runtime addon answers here with its prints alone. Answers with the counts and the verdict as well as the entries. heldAt is three answers: null for a run this server knows is not held, running or over, an object for one it knows is held at a breakpoint, whether the adapter said so or the runtime did by accepting a connection and never answering, and absent with heldUnknown beside it for a server that connected to the debugger after the stop and has no runtime to ask, since the adapter reports a stop only to the sessions connected when it happened. A run that has quit still answers here, with running false and its exit code, until the next one starts; a run ended by a signal has no exit code, and exitSignal names the signal instead. A run this server started also answers with transcript, the file both its streams are written to: uncapped, written while the run is going, and the thing to read or tail for a long run rather than the engine's own log, which every engine start rotates away. Read the file for output and this answer for state: endedBy says whether gdharness ended the run, and a transcript that has stopped growing is a run between prints rather than a run that is over. running is asked of the operating system whenever there is a process to ask about, which is every run this server started and every editor-played run whose game announced its runtime. For an editor-played run that never announced, there is no process id here and running is the editor's answer, which can lag: one measured elsewhere reported a game as playing for fifteen seconds after its process had been ended from outside. editor_status names that game under runtimes, which does not depend on the editor answering. op: \"editor\" answers about the editor itself instead, which is a different log and the only way anything here can read what an editor printed: its console reaches no plugin, so the addon cannot scrape it, and an editor gdharness opened is asked for a log file as it starts. That covers the whole session from the editor's first line, which is where the output worth reading usually is, since the class cache, the plugins and the language server all say what they have to say before any harness has connected. The answer carries the entries in the order they were printed and, beside them under repeated, each message shape several lines share: how many, what varied in each slot of it and how many different values stood there, the first occurrence, and the ordinary lines above the group, found by walking back past the group rather than by counting lines. An editor somebody opened by hand has no console here and is refused saying so rather than answered empty, because an editor that printed nothing and an editor nobody captured are not the same thing.",
+    description: "What the project started by editor_run has printed, as entries with a severity: the errors and warnings the engine reported, each with where it happened, and everything else as info. For a run the editor plays the reports come from the game itself, through the runtime addon, since the editor's debugger relays what a game prints and not what it reports; a played game without the runtime addon answers here with its prints alone, with errorsUnread true and no clean, since what it raised reaches nothing here. Answers with the counts and the verdict as well as the entries. heldAt is three answers: null for a run this server knows is not held, running or over, an object for one it knows is held at a breakpoint, whether the adapter said so or the runtime did by accepting a connection and never answering, and absent with heldUnknown beside it for a server that connected to the debugger after the stop and has no runtime to ask, since the adapter reports a stop only to the sessions connected when it happened. A run that has quit still answers here, with running false and its exit code, until the next one starts; a run ended by a signal has no exit code, and exitSignal names the signal instead. A run this server started also answers with transcript, the file both its streams are written to: uncapped, written while the run is going, and the thing to read or tail for a long run rather than the engine's own log, which every engine start rotates away. Read the file for output and this answer for state: endedBy says whether gdharness ended the run, and a transcript that has stopped growing is a run between prints rather than a run that is over. running is asked of the operating system whenever there is a process to ask about, which is every run this server started and every editor-played run whose game announced its runtime. For an editor-played run that never announced, there is no process id here and running is the editor's answer, which can lag: one measured elsewhere reported a game as playing for fifteen seconds after its process had been ended from outside. editor_status names that game under runtimes, which does not depend on the editor answering. op: \"editor\" answers about the editor itself instead, which is a different log and the only way anything here can read what an editor printed: its console reaches no plugin, so the addon cannot scrape it, and an editor gdharness opened is asked for a log file as it starts. That covers the whole session from the editor's first line, which is where the output worth reading usually is, since the class cache, the plugins and the language server all say what they have to say before any harness has connected. The answer carries the entries in the order they were printed and, beside them under repeated, each message shape several lines share: how many, what varied in each slot of it and how many different values stood there, the first occurrence, and the ordinary lines above the group, found by walking back past the group rather than by counting lines. An editor somebody opened by hand has no console here and is refused saying so rather than answered empty, because an editor that printed nothing and an editor nobody captured are not the same thing.",
     parameters: {
       severity: {
         type: "string",
@@ -31033,7 +31504,7 @@ var TOOL_SPECS = [
   },
   {
     name: "editor_status",
-    description: "Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and whether a game with the runtime addon is reachable: runtimeConnected counts the games of the project this server serves, and runtimes lists every game on the machine with ofThisProject saying which is which, since a game of another project is reached only by naming its projectPath. playingInEditor is null when the editor was not asked or did not answer, which is not the same as a no: with no editor connected there is nobody to ask, and an editor that does not serve the question is given a moment and then left. A game can be playing while this is null, so read it as unanswered rather than as nothing playing, and use processActive and runtimes, which come from elsewhere and do not depend on the editor answering. editor.scan says whether the editor is scanning or importing and how many milliseconds ago its last scan finished (finishedMsAgo), or is null when it did not answer: the editor rewrites the class cache just after a scan, and editor_run waits that out before starting a game, saying so under waitedForEditorScanMs. Each game under runtimes is pinged with a short wait, so one held at a breakpoint is listed as unreachable rather than making this call wait out the runtime timeout; for the run this server is reporting on, heldAt says whether that is what it is, with the same three answers editor_output gives. A game the editor played announces the editor under editorPid, and so does whatever that game started for itself; a game some other server started announces none, which is how the two are told apart when both are running from one project. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means \"not reached yet\" as often as it means \"no editor\". True is worth waiting out; false is an editor that is not there. False beside restartInterrupted is one that an editor_launch restart on a previous server asked to quit, where the launch half never ran because that server was ended in between, usually by the reconnect the restart was taken for; editor_launch open finishes it. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. settingsDropped appears here once when the editor this server opened saved project.godot on its way in, which is the same reading editor_launch restart makes in its own answer. A game that has announced itself in a protocol this server does not speak is listed under unreadable rather than left out, with the protocol it speaks and whether the server or the addon is the older half. This happens during an upgrade that moves the runtime protocol, which most do not: installing replaces the addon on disk as soon as the pin moves, while a server that is already running stays on the version it started with, so the two speak different protocols until the server is reconnected. Those games are real and running, but no tool here can reach them until the halves match, so runtimes stays empty and runtimeConnected stays false. An upgrade that leaves the protocol alone opens no such window and this list stays empty through it. addonIsStale is decided by the code of the editor addons rather than their version, so an editor started before an upgrade that left that code alone reports the older addonVersion, is not stale, and addonNote says so: it needs no restart. port is the one the editor bridge is on; when that is not the one this server was configured with, portWanted names the configured one and portNote says why it moved and, when it was the server this one replaced, which pid kept it. A server replacing another of its project that holds the configured port waits for it to stand down and takes the port over, which takes a few seconds; bridgeHandover says so while it waits, and it moves only if that server has not let go within the wait.",
+    description: "Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and whether a game with the runtime addon is reachable: runtimeConnected counts the games of the project this server serves, and runtimes lists every game on the machine with ofThisProject saying which is which, since a game of another project is reached only by naming its projectPath. playingInEditor is null when the editor was not asked or did not answer, which is not the same as a no: with no editor connected there is nobody to ask, and an editor that does not serve the question is given a moment and then left. A game can be playing while this is null, so read it as unanswered rather than as nothing playing, and use processActive and runtimes, which come from elsewhere and do not depend on the editor answering. editor.scan says whether the editor is scanning or importing and how many milliseconds ago its last scan finished (finishedMsAgo), or is null when it did not answer: the editor rewrites the class cache just after a scan, and editor_run waits that out before starting a game, saying so under waitedForEditorScanMs. Each game under runtimes is pinged with a short wait, so one held at a breakpoint is listed as unreachable rather than making this call wait out the runtime timeout; for the run this server is reporting on, heldAt says whether that is what it is, with the same three answers editor_output gives. A game the editor played announces the editor under editorPid, and so does whatever that game started for itself; a game some other server started announces none, which is how the two are told apart when both are running from one project. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means \"not reached yet\" as often as it means \"no editor\". True is worth waiting out; false is an editor that is not there. False beside restartInterrupted is one that an editor_launch restart on a previous server asked to quit, where the launch half never ran because that server was ended in between, usually by the reconnect the restart was taken for; editor_launch open finishes it. True beside restartUnderway is a restart still in progress, its server alive and within the wait for the old editor to go: the editor is coming, and opening another would put two on one project. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. settingsDropped appears here once when the editor this server opened saved project.godot on its way in, which is the same reading editor_launch restart makes in its own answer. A game that has announced itself in a protocol this server does not speak is listed under unreadable rather than left out, with the protocol it speaks and whether the server or the addon is the older half. This happens during an upgrade that moves the runtime protocol, which most do not: installing replaces the addon on disk as soon as the pin moves, while a server that is already running stays on the version it started with, so the two speak different protocols until the server is reconnected. Those games are real and running, but no tool here can reach them until the halves match, so runtimes stays empty and runtimeConnected stays false. An upgrade that leaves the protocol alone opens no such window and this list stays empty through it. addonIsStale is decided by the code of the editor addons rather than their version, so an editor started before an upgrade that left that code alone reports the older addonVersion, is not stale, and addonNote says so: it needs no restart. port is the one the editor bridge is on; when that is not the one this server was configured with, portWanted names the configured one and portNote says why it moved and, when it was the server this one replaced, which pid kept it. A server replacing another of its project that holds the configured port waits for it to stand down and takes the port over, which takes a few seconds; bridgeHandover says so while it waits, and it moves only if that server has not let go within the wait. An editor that has connected and not yet greeted, which lasts a frame and longer while it imports, reports nothing about itself: greeting says so, addonIsStale is absent rather than guessed, and a restart asked then waits for the greeting to learn who opened it. startedByAnEditor is an editor another editor started, by Godot's own restart or the project manager, which has none of the arguments a server gave the one before it; startedByAnEditorNote says what that costs.",
     parameters: {},
     requires: []
   },
@@ -31049,7 +31520,7 @@ var TOOL_SPECS = [
       },
       reloadScript: {
         type: "string",
-        description: "A script to recompile in the editor after the scan, for the half a scan does not reach: a script the editor has loaded keeps the copy it built, that copy is refreshed when one of its dependencies changes rather than when it changes itself, and a scan leaves it alone. Measured here, a built copy comes back without a method added to it while script_diagnostics on the same script reads clean in the same window, so the copy the editor built and whatever the analyser resolves types against are not known to be one thing: reload for the copy, and read the diagnostics as a separate answer rather than as this one confirmed. This recompiles into the same object, so the holders that kept the stale copy alive see the new one. The methods it has afterwards come back under reloadedMethods, because a reload that compiled nothing and answered OK is the failure worth catching, and what it held before under heldBeforeReload. Its constants come back the same way, under heldConstantsBeforeReload and reloadedConstants, with each enum value as Kind.SHORT: an enum member is held as a constant and never shows among the methods. A script that does not compile is not reloaded: reloadProblem gives Godot's error, says whether the copy the editor holds survived, and names the classes the file uses, whose held copies being behind is what failed one before."
+        description: "A script to recompile in the editor after the scan, for the half a scan does not reach: a script the editor has loaded keeps the copy it built, that copy is refreshed when one of its dependencies changes rather than when it changes itself, and a scan leaves it alone. Measured here, a built copy comes back without a method added to it while script_diagnostics on the same script reads clean in the same window, so the copy the editor built and whatever the analyser resolves types against are not known to be one thing: reload for the copy, and read the diagnostics as a separate answer rather than as this one confirmed. This recompiles into the same object, so the holders that kept the stale copy alive see the new one. The methods it has afterwards come back under reloadedMethods, because a reload that compiled nothing and answered OK is the failure worth catching, and what it held before under heldBeforeReload. Its constants come back the same way, under heldConstantsBeforeReload and reloadedConstants, with each enum value as Kind.SHORT: an enum member is held as a constant and never shows among the methods. A script that does not compile is not reloaded: reloadProblem gives Godot's error, says whether the copy the editor holds survived, and names the classes the file uses, whose held copies being behind is what failed one before. A @tool script is not reloaded either, since it runs inside the editor and reloading one from inside a call can take the editor down: reloadProblem says so, and editor_launch restart recompiles it. A path spelled in another case than the file is reloaded under the spelling on disk, which is the one the editor holds its copy under, and that spelling comes back under reloadedAs."
       }
     },
     requires: ["projectPath"]
@@ -31072,6 +31543,7 @@ var TOOL_SPECS = [
           "physics2d",
           "physics3d",
           "audio",
+          "visual",
           "animation",
           "ui"
         ],
@@ -31111,7 +31583,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 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 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.'
       },
       depth: {
         type: "integer",
@@ -31150,13 +31622,14 @@ var TOOL_SPECS = [
       limit: {
         type: "integer",
         minimum: 1,
+        maximum: 5000,
         ops: ["find", "text"],
-        description: "find: the most nodes to answer with, default 100. text: the most lines, default 500, with omitted saying how many lines that left behind. A screen whose dialog sits under a long list is a screen read with omitted greater than zero, so raise this or point root at the dialog rather than reading the answer as what is on screen."
+        description: "find: the most nodes to answer with, default 100. text: the most lines, default 500, with omitted saying how many lines that left behind. At most 5000 for either. A screen whose dialog sits under a long list is a screen read with omitted greater than zero, so raise this or point root at the dialog rather than reading the answer as what is on screen."
       },
       includeHidden: {
         type: "boolean",
         ops: ["text", "find"],
-        description: "text: read hidden nodes as well, for checking that something is not showing. Default false. find: default true, since a find means the node whether or not it is drawn; false answers with what the player can actually see, which is how a panel that keeps a label for every line and hides the ones that do not is read. A node counts as hidden when anything above it is, and how many matches were left out comes back under hidden."
+        description: "text: read hidden nodes as well, for checking that something is not showing. Default false. find: default true, since a find means the node whether or not it is drawn; false answers with what the player can actually see, which is how a panel that keeps a label for every line and hides the ones that do not is read. A node counts as hidden when the engine would not draw it: a hidden Control, Node2D or Node3D above it hides it, a plain Node in between breaks that chain as it does for the engine, and a hidden canvas layer or window hides everything in it. How many matches were left out comes back under hidden."
       },
       metrics: {
         type: "array",
@@ -31195,7 +31668,7 @@ var TOOL_SPECS = [
   },
   {
     name: "runtime_invoke",
-    description: "Sets a property or calls a method on a node 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. 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 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.",
     parameters: {
       projectPath: RUNNING_PROJECT_PATH,
       pid: RUNNING_PID,
@@ -31207,12 +31680,12 @@ 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. The answer reads back off the same holder, and a write that leaves the property as it was, because the engine would not take it, is refused and says what the property still holds. 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 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.'
       },
       value: {
         ops: ["set"],
         blank: true,
-        description: `set: the value, fitted to the property's type. "" writes an empty string. A property typed as or holding an object takes a path naming one the game holds, the way call's args do, and holds that instance, or null, which the text null also means, to empty it. A typed list or map, such as Array[int] or Dictionary[String, int], takes a JSON list or object with each element fitted to its element type, and an element that cannot become one is refused by its index or key.`
+        description: `set: the value, fitted to the property's type. "" writes an empty string. A property typed as or holding an object takes a path naming one the game holds, the way call's args do, and holds that instance, or null, which the text null also means, to empty it. One declared as Variant or untyped takes anything, as the engine does: a value of the kind it holds is fitted to it, an int staying an int, and any other is stored as sent. A typed list or map, such as Array[int] or Dictionary[String, int], takes a JSON list or object with each element fitted to its element type, and an element that cannot become one is refused by its index or key, as is an object of another script than the one the list holds, whether or not that script has a class_name.`
       },
       method: {
         type: "string",
@@ -31222,7 +31695,7 @@ var TOOL_SPECS = [
       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. 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.`
       },
       timeoutMs: {
         type: "integer",
@@ -31255,7 +31728,7 @@ var TOOL_SPECS = [
   },
   {
     name: "runtime_capture",
-    description: "A picture of the running game: the whole screen or one viewport, as an image. Needs the game running with a window. A capture asked for before the game's first frame is drawn waits for that frame, since the game announces itself before it and the viewport holds nothing it drew until then.",
+    description: "A picture of the running game: the whole screen or one viewport, as an image. The whole screen includes the game's own dialogs and popups where they sit, also when a project opens them as windows of their own (subwindows not embedded). Needs the game running with a window. A capture asked for before the game's first frame is drawn waits for that frame, since the game announces itself before it and the viewport holds nothing it drew until then.",
     parameters: {
       projectPath: RUNNING_PROJECT_PATH,
       pid: RUNNING_PID,
@@ -31300,7 +31773,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, is not on screen. The matches are ranked the way a person picks what to press: a button before text that cannot be pressed, 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."
       },
       action: {
         type: "string",
@@ -31333,7 +31806,7 @@ var TOOL_SPECS = [
       replace: {
         type: "boolean",
         ops: ["text"],
-        description: 'text: true writes over what the field already says, which is what filling one in means. Default false types at the caret, so a field reading 2.1 typed "0.3" at reads 2.10.3. The answer says what the field holds afterwards either way.'
+        description: 'text: true writes over what the field already says, which is what filling one in means. Default false types at the caret, so a field reading 2.1 typed "0.3" at reads 2.10.3. The answer says what the field holds afterwards either way. A read-only field is refused.'
       },
       index: {
         type: "number",
@@ -31377,11 +31850,11 @@ var TOOL_SPECS = [
     requires: [],
     operations: {
       click: {
-        summary: "press and release on a Control, a frame apart, and answer with what was under the pointer and what became of the control: in_tree, removed or freed. The control is named by nodePath, or by says with the words on it, found under nodePath when both are given, and the answer then says under found which match it was. A control out of sight inside a ScrollContainer is scrolled to first, and scrolled_into_view says whether the view moved. A 3D node is clicked where it is drawn, and landed then says the interface did not swallow the press",
+        summary: "press and release on a Control, a frame apart, and answer with what was under the pointer and what became of the control: in_tree, removed or freed. The control is named by nodePath, or by says with the words on it, found under nodePath when both are given, and the answer then says under found which match it was. A control out of sight inside a ScrollContainer is scrolled to first, each container out from it a frame after the one inside, and scrolled_into_view says whether a scroll value changed. A disabled button, and a control that does not process (the game paused, say), are refused: the pointer reaches them and the press does nothing. A 3D node is clicked where it is drawn, and landed then 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",
         requires: []
       },
       choose: {
-        summary: "take an item out of a menu, by what it says or by where it is in the list. A menu's items are drawn rather than built, so there is nothing to click: the item takes the focus and Enter presses it, which is the engine's own path and needs no window. Answers with what was chosen, read before the press, 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 it shows now when it is still there",
+        summary: "take an item out of a menu, by what it says or by where it is in the list. A menu's items are drawn rather than built, so there is nothing to click: the menu is opened, the item is looked for in it as it stands then, since a game can fill a menu as it opens, and the item takes the focus and ui_accept presses it, which is the engine's own path, needs no window, and does not depend on what ui_accept is bound to. A disabled or hidden button in front of the menu is refused, and so is a press the menu did not take, which is heard rather than assumed. Answers with what was chosen, read before the press, 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 it shows now when it is still there",
         requires: ["nodePath"]
       },
       action: { summary: "press an action, or hold it", requires: ["action"] },
@@ -31390,7 +31863,7 @@ var TOOL_SPECS = [
         requires: ["keycode"]
       },
       text: {
-        summary: "type a string into the field being edited, a character at a time, and say what it landed in and what it holds afterwards, a secret field as its mask",
+        summary: "type a string into the field being edited, a character at a time, and say what it landed in and what it holds afterwards, a secret field as its mask. The field is the focus of the dialog that has the focus when one does, which is where the keys go",
         requires: ["text"]
       },
       mouse_click: {
@@ -31429,7 +31902,7 @@ var TOOL_SPECS = [
       },
       value: {
         ops: ["until"],
-        description: "until: the value to wait for, fitted to the property's type. On a property holding an object, whether declared to or untyped and holding one or null, the text null means null. One declared to hold an object refuses any value other than null, since it can never hold it."
+        description: "until: the value to wait for, fitted to the property's type and compared at the precision the property keeps, so -1.1 meets a 32-bit float holding -1.10000002. A value the property would have to cut is refused: a fraction on a whole number, a number other than 0 or 1 on a bool. On a property holding an object, whether declared to or untyped and holding one or null, the text null means null. One declared to hold an object refuses any value other than null, since it can never hold it."
       },
       says: {
         type: "string",
@@ -31478,7 +31951,7 @@ var TOOL_SPECS = [
   },
   {
     name: "debug_control",
-    description: "Continues or steps the debugged game through the editor's debug adapter, answering with the stack where it ended up. There is no pause and no step_out: Godot's adapter answers a pause by reporting the game stopped and leaving it running, and implements no stepOut at all, so hold the game where you want it with a breakpoint and step over or into from there.",
+    description: "Continues or steps the debugged game through the editor's debug adapter. A step waits for the game to stop again and answers with the stack where it ended up; one that has not stopped the game again within ten seconds answers heldAgain false and no stack. There is no pause and no step_out: Godot's adapter answers a pause by reporting the game stopped and leaving it running, and implements no stepOut at all, so hold the game where you want it with a breakpoint and step over or into from there.",
     parameters: {},
     requires: [],
     operations: {
@@ -31489,12 +31962,12 @@ var TOOL_SPECS = [
   },
   {
     name: "debug_state",
-    description: "Where the debugged game is stopped: the stack trace, what is in scope at a frame with the values, or the debug adapter's console output so far. A stop is reported by the editor's adapter only to the sessions connected when it happened, so a server that connected afterwards, which is every server after a reconnect, is shown a thread and no frames about a game still sitting at its breakpoint. That server asks the runtime instead: a held game accepts a connection and never answers, and the refusal then says held rather than running, and that the stack cannot be read from here. debug_control continue lets it go, and the next stop is one this session is told about, with its stack.",
+    description: "Where the debugged game is stopped: the stack trace, what is in scope at a frame with the values, or the debug adapter's console output so far, its last thousand lines, with any earlier ones counted under notShown. A stop is reported by the editor's adapter only to the sessions connected when it happened, so a server that connected afterwards, which is every server after a reconnect, is shown a thread and no frames about a game still sitting at its breakpoint. That server asks the runtime instead: a held game accepts a connection and never answers, and the refusal then says held rather than running, and that the stack cannot be read from here. debug_control continue lets it go, and the next stop is one this session is told about, with its stack.",
     parameters: {
       frameId: {
         type: "number",
         ops: ["variables"],
-        description: "variables: which frame, from a stack answer. Default the innermost."
+        description: "variables: which frame, from a stack answer. Default the innermost. A frame the stack no longer holds is refused, and a scope whose values did not arrive in time answers variables null and is named under valuesMissing."
       }
     },
     requires: [],
@@ -31555,9 +32028,16 @@ function buildToolDefinitions() {
 // src/server.ts
 var UPDATE_NOTICE_EVERY = 500;
 var FEEDBACK_NOTICE_EVERY = 250;
-var run5 = promisify6(execFile6);
-var __dirname2 = dirname11(fileURLToPath4(import.meta.url));
-var EDITOR_RESTART_TIMEOUT_MS = 90000;
+var run4 = promisify5(execFile5);
+var __dirname2 = dirname12(fileURLToPath4(import.meta.url));
+function editorRestartTimeoutMs() {
+  const override = Number.parseInt(envValue("GDHARNESS_EDITOR_RESTART_TIMEOUT_MS") ?? "", 10);
+  return Number.isInteger(override) && override > 0 ? override : 90000;
+}
+var GREETING_WAIT_MS = 1e4;
+function restartUnderway(note, now = Date.now()) {
+  return alive(note.byPid) && now - Date.parse(note.quitAt) < editorRestartTimeoutMs() + 30000;
+}
 var HOLD_PING_MS = 2000;
 var SLOWEST_FRAME_RATE = 20;
 function captureDestinationRefusal(outputPath, projects) {
@@ -31570,16 +32050,16 @@ function captureDestinationRefusal(outputPath, projects) {
   if (extname2(outputPath).toLowerCase() !== ".png") {
     return `outputPath ${outputPath} does not end in .png, which is what a capture is.`;
   }
-  const directory = realPathOr(dirname11(outputPath));
-  if (!existsSync12(directory)) {
-    return `outputPath's directory ${dirname11(outputPath)} does not exist; a capture creates no directories.`;
+  const directory = realPathOr(dirname12(outputPath));
+  if (!existsSync14(directory)) {
+    return `outputPath's directory ${dirname12(outputPath)} does not exist; a capture creates no directories.`;
   }
-  const where = join18(directory, basename4(outputPath));
+  const where = join19(directory, basename4(outputPath));
   const inside = projects.find((project) => project !== "" && isWithinRoot(realPathOr(project), where));
   if (inside !== undefined) {
     return `outputPath ${outputPath} is inside the project at ${inside}; a capture is saved outside it, so it never becomes part of the game.`;
   }
-  if (existsSync12(where)) {
+  if (existsSync14(where)) {
     return `outputPath ${outputPath} already exists; a capture is not written over a file. Name a new one.`;
   }
   return null;
@@ -31610,16 +32090,18 @@ function describeHalt(halt) {
 function exited(run) {
   return run.exitCode !== null || run.exitSignal !== null;
 }
-function endingOf(failed) {
-  return {
-    exitCode: typeof failed.code === "number" ? failed.code : null,
-    exitSignal: typeof failed.signal === "string" ? failed.signal : null,
-    failure: typeof failed.code === "string" ? failed.code : null
-  };
-}
 function howItExited(run) {
   return run.exitSignal === null ? `exit code ${run.exitCode ?? "unknown"}` : `ended by ${run.exitSignal}, with no exit code`;
 }
+function errorsUnread(run) {
+  return run.throughEditor && typeof run.errorReport !== "string";
+}
+function cleanVerdict(run) {
+  if (run.consoleLost === true || errorsUnread(run)) {
+    return;
+  }
+  return run.log.count("error") === 0;
+}
 function stillRunning(run) {
   if (run === null || exited(run) || run.endedUnwatched === true) {
     return false;
@@ -31636,6 +32118,11 @@ function stillRunning(run) {
   return true;
 }
 var PLAY_STARTS_WITHIN_MS = 30000;
+function playOf(answer) {
+  const play = readNumber(answer, "play");
+  const editorPid = readNumber(answer, "editorPid");
+  return play === undefined || editorPid === undefined ? null : { play, editorPid };
+}
 function runIsUp(run, editorSays, now = Date.now()) {
   if (run?.throughEditor !== true) {
     return stillRunning(run);
@@ -31685,11 +32172,19 @@ function stopVerdict(stop) {
     return {
       stopped: true,
       endedPid: stop.endedPid,
-      clean: stop.errors === 0,
+      clean: stop.clean,
       note: "This run was over before the stop, so nothing was ended here: editor_output has what it printed and how it ended. Anything that game started for itself, with OS.create_process or otherwise, is a separate process and may still be running.",
       withChildren: false
     };
   }
+  if (stop.ending === "unreached") {
+    return {
+      stopped: false,
+      notSignalled: stop.endedPid,
+      note: "Nothing was ended: the editor could not be asked to stop the scene it is playing, so the game may still be running. editor_status says whether the editor is connected and playing.",
+      withChildren: false
+    };
+  }
   if (stop.ending === "refused") {
     return {
       stopped: false,
@@ -31698,22 +32193,31 @@ function stopVerdict(stop) {
       withChildren: false
     };
   }
+  if (stop.ending === "lingering") {
+    const told = stop.throughEditor ? stop.endedPid === null ? "The editor was asked to stop the scene it is playing and was still playing it" : `The editor was asked to stop the scene it is playing, and its game, pid ${stop.endedPid}, was still running` : `pid ${stop.endedPid ?? "unknown"} was told to end and was still running`;
+    return {
+      stopped: false,
+      stillGoing: stop.endedPid,
+      note: `${told} ${STOP_WAIT_MS / 1000} seconds later, so it has not stopped. editor_status says when it has gone, and editor_run stop asks again.`,
+      withChildren: true
+    };
+  }
   return {
     stopped: true,
     endedPid: stop.endedPid,
-    clean: stop.errors === 0,
-    note: `${stop.throughEditor ? stop.endedPid === null ? "The editor was asked to stop the scene it is playing. Its game had not announced a runtime, so no process was named under endedPid, and its exit code stays with the editor." : "The editor was asked to stop the scene it is playing." : "The process named under endedPid was ended."}${stop.exitSignal === null ? "" : ` It was ended by ${stop.exitSignal} and so has no exit code.`}${stop.ending === "gone" ? "" : ` It had not exited ${STOP_WAIT_MS / 1000} seconds after being told to, so it may still be going: editor_status says whether it is.`}`,
+    clean: stop.clean,
+    note: `${stop.throughEditor ? stop.endedPid === null ? "The editor was asked to stop the scene it is playing. Its game had not announced a runtime, so no process was named under endedPid, and its exit code stays with the editor." : "The editor was asked to stop the scene it is playing." : "The process named under endedPid was ended."}${stop.exitSignal === null ? "" : ` It was ended by ${stop.exitSignal} and so has no exit code.`}`,
     withChildren: true
   };
 }
 function endedPreviousRun(ended) {
-  if (ended === null || ended.ending === "refused") {
+  if (ended?.ending !== "gone") {
     return;
   }
   return ended.pid ?? true;
 }
 function previousRunLeft(ended) {
-  return ended?.ending === "refused" && ended.pid !== null ? ended.pid : undefined;
+  return (ended?.ending === "refused" || ended?.ending === "lingering") && ended.pid !== null ? ended.pid : undefined;
 }
 var CONSOLE_WRAPPER = /_console(\.exe)?$/i;
 function engineNamesOf(executable) {
@@ -31790,8 +32294,13 @@ function endedToStartThis(ended) {
   if (ended.ending === "refused") {
     return ` ${which} was not ended: that pid no longer answers as the process the run was started as, so nothing was signalled. If it is still the game, it is running beside this one and you have to end it yourself; if it is not, it belongs to something else.`;
   }
-  const after = ended.ending === "lingering" ? ` It had not exited ${STOP_WAIT_MS / 1000} seconds after being told to, so it may still be running beside this one: editor_status says whether it is.` : "";
-  return ` ${which} was ended to start this one; its output is no longer what editor_output answers about.${after}`;
+  if (ended.ending === "unreached") {
+    return ` ${which} was not ended here: the editor could not be asked to stop it. The editor stops a play before starting the next, so it is not running beside this one if this start reached the editor.`;
+  }
+  if (ended.ending === "lingering") {
+    return ` ${which} was told to end to start this one and was still running ${STOP_WAIT_MS / 1000} seconds later, so it is running beside this one: editor_status says when it has gone.`;
+  }
+  return ` ${which} was ended to start this one; its output is no longer what editor_output answers about.`;
 }
 var LONGEST_BOOT_NOTED_MS = 5 * 60000;
 var MOST_GROUPS = 20;
@@ -31919,6 +32428,7 @@ var HANDOVER_MS = SUCCESSOR_CHECK_MS + 5000;
 var HANDOVER_POLL_MS = 250;
 var CACHE_WRITE_MS = 2000;
 var SCAN_WAIT_MS = 30000;
+var STREAMS_GRACE_MS = 2000;
 function scanWaitIn(payload) {
   const waited = readNumber(payload, "waitedForEditorScanMs");
   const note = readString(payload, "scanNote");
@@ -31931,19 +32441,58 @@ function withScanWait(outcome, scanned) {
   if (scanned.waitedMs === 0) {
     return outcome;
   }
-  const said = scanWaitAnswer(scanned);
+  const said = scanWaitAnswer(scanned, "engine");
   if (outcome.ok) {
     return { ...outcome, payload: { ...outcome.payload, ...said } };
   }
   return said.scanNote === undefined ? outcome : { ...outcome, message: `${outcome.message} ${said.scanNote}` };
 }
-function scanWaitAnswer(scanned) {
+function notRunNote(notRun, failFast) {
+  if (notRun <= 0) {
+    return;
+  }
+  const cases = `${notRun} case${notRun === 1 ? "" : "s"}`;
+  return failFast ? `This run stopped at the first failure in each suite it failed in, so ${cases} never ran and count as neither passed nor failed. Leave failFast out to run every case.` : `${cases} counted in ${notRun === 1 ? "its suite" : "their suites"} never ran and count as neither passed nor failed. failFast was not set, so it was not that: the suites below with notRun are the ones to read.`;
+}
+function exportAnswer(ending, asked, before, after) {
+  const { log } = ending;
+  const written = after !== null && after !== before;
+  const problems = log.select({ severity: "warning", sinceLastCall: false, limit: 200 });
+  const verdict = {
+    exported: ending.exitCode === 0 && ending.failure === null && log.count("error") === 0 && written,
+    ...asked,
+    exitCode: ending.exitCode,
+    exitSignal: ending.exitSignal ?? undefined,
+    failure: ending.failure ?? undefined,
+    errors: log.count("error"),
+    warnings: log.count("warning"),
+    entries: forAnswer(problems.entries),
+    ...problems.omitted === 0 ? {} : { entriesOmitted: problems.omitted }
+  };
+  if (verdict.exported) {
+    return { content: [{ type: "text", text: JSON.stringify(verdict, null, 2) }] };
+  }
+  const stale = !written && after !== null ? ` The ${asked.outputPath} there is from before this export, which did not write it.` : "";
+  const why = ending.exitSignal === null ? stale : ` The engine was ${howItEnded(ending)}, so it has no exit code.${stale}`;
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Export with preset '${asked.preset}' did not produce ${asked.outputPath}.${why}`
+      },
+      { type: "text", text: JSON.stringify(verdict, null, 2) }
+    ],
+    isError: true
+  };
+}
+function scanWaitAnswer(scanned, started = "game") {
   if (scanned.waitedMs === 0) {
     return {};
   }
+  const still = `The editor was still scanning the project after ${SCAN_WAIT_MS / 1000} seconds, so`;
   return {
     waitedForEditorScanMs: scanned.waitedMs,
-    scanNote: scanned.stillScanning ? `The editor was still scanning the project after ${SCAN_WAIT_MS / 1000} seconds, so this ` + "game started during the scan and may have read a class cache being rewritten. If " + 'editor_output shows "Could not find type" for a class that is declared, editor_rescan ' + "waits for the scan to finish, and a start after it reads the finished cache." : undefined
+    scanNote: !scanned.stillScanning ? undefined : started === "game" ? `${still} this game started during the scan and may have read a class cache being rewritten. If ` + 'editor_output shows "Could not find type" for a class that is declared, editor_rescan ' + "waits for the scan to finish, and a start after it reads the finished cache." : `${still} the engine answering this started during the scan and may have read a class cache being ` + "rewritten, and a class cache it wrote can be written over when the scan finishes. If " + 'engine_messages shows "Could not find type" for a class that is declared, editor_rescan waits ' + "for the scan to finish, and the same call after it reads the finished cache."
   };
 }
 var PLAYING_STATUS_MS = 1000;
@@ -32023,16 +32572,17 @@ var PROJECT_FILE_ARGUMENTS = [
   "path",
   "script"
 ];
-function escapingPropertyValue(properties) {
-  if (typeof properties !== "object" || properties === null) {
+function escapingPropertyValue(value) {
+  if (typeof value === "string") {
+    return /^(res|uid):\/\//.test(value) && value.split(/[/\\]/).includes("..") ? JSON.stringify(value) : undefined;
+  }
+  if (typeof value !== "object" || value === null) {
     return;
   }
-  for (const value of Object.values(properties)) {
-    if (typeof value !== "string" || !value.includes("/")) {
-      continue;
-    }
-    if (value.split(/[/\\]/).includes("..")) {
-      return JSON.stringify(value);
+  for (const item of Object.values(value)) {
+    const found = escapingPropertyValue(item);
+    if (found !== undefined) {
+      return found;
     }
   }
   return;
@@ -32070,7 +32620,7 @@ function aboveTheRunner(entry) {
 }
 function elsewhereIn(projectPath, asked) {
   const wanted = asked.replace(/^res:\/\//, "").replace(/\/+$/, "");
-  if (wanted === "" || existsSync12(join18(projectPath, wanted))) {
+  if (wanted === "" || existsSync14(join19(projectPath, wanted))) {
     return "";
   }
   const root = (wanted.split("/")[0] ?? "").toLowerCase();
@@ -32084,7 +32634,7 @@ function elsewhereIn(projectPath, asked) {
   return near.length === 0 ? "" : ` The project does have ${there}.`;
 }
 function hasMainScene(projectFile) {
-  const scene = parseProjectGodot(readFileSync17(projectFile, "utf8"))["application"]?.["run/main_scene"];
+  const scene = parseProjectGodot(readFileSync18(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "";
 }
 function runtimeAddonAnnouncesEditors(projectPath) {
@@ -32092,13 +32642,13 @@ function runtimeAddonAnnouncesEditors(projectPath) {
     return false;
   }
   try {
-    return readFileSync17(join18(projectPath, RUNTIME_AUTOLOAD.path), "utf8").includes('"editor_pid"');
+    return readFileSync18(join19(projectPath, RUNTIME_AUTOLOAD.path), "utf8").includes('"editor_pid"');
   } catch {
     return false;
   }
 }
 function editorPlaysHeadless(projectFile) {
-  const runArgs = parseProjectGodot(readFileSync17(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
+  const runArgs = parseProjectGodot(readFileSync18(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
   return typeof runArgs === "string" && /(?:^|\s)--headless(?:\s|$)/.test(runArgs);
 }
 function camelCased(params) {
@@ -32117,7 +32667,7 @@ function needsItsOwnProcess(asked) {
 class GodotServer {
   mcp;
   locator = new GodotLocator;
-  operationsScript = join18(__dirname2, "godot", "operations", "godot_operations.gd");
+  operationsScript = join19(__dirname2, "godot", "operations", "godot_operations.gd");
   godotBridge;
   tools = buildToolDefinitions();
   activeProcess = null;
@@ -32139,6 +32689,7 @@ class GodotServer {
   shutdownInitiated = false;
   launchedEditor = null;
   launchedFrom = null;
+  launchedDropped = null;
   ownProject;
   announcedAt = null;
   handingOverFrom = null;
@@ -32146,9 +32697,12 @@ class GodotServer {
   constructor() {
     this.ownProject = envValue("GDHARNESS_PROJECT") ?? null;
     this.godotBridge = getDefaultBridge(this.ownProject);
+    this.godotBridge.on("godot_connected", () => {
+      this.settleTheLaunchReading();
+    });
     this.mcp = new McpServer({ name: "gdharness", version: SERVER_VERSION }, { capabilities: { tools: {}, resources: {} } });
     this.setupToolHandlers();
-    setupResourceHandlers(this.mcp, () => this.lastProjectPath);
+    setupResourceHandlers(this.mcp, () => this.ourProject() ?? this.lastProjectPath);
     this.mcp.server.onerror = (error) => {
       console.error("[MCP Error]", error);
     };
@@ -32414,8 +32968,9 @@ class GodotServer {
       if (!checked.ok) {
         return checked.response;
       }
-      if (typeof args["projectPath"] === "string") {
-        this.lastProjectPath = args["projectPath"];
+      const named = args["projectPath"];
+      if (typeof named === "string" && existsSync14(join19(named, "project.godot"))) {
+        this.lastProjectPath = named;
       }
       this.updates.refresh();
       const answer = await withCallSignal(extra.signal, () => this.answered(spec.name, checked.op ?? "", args));
@@ -32455,6 +33010,17 @@ class GodotServer {
       return answer;
     }
     const moved = this.projectHasMovedOn();
+    if (moved !== null && !isNewer(moved, SERVER_VERSION)) {
+      this.noticedUpdate = true;
+      this.callsSinceNotice = 0;
+      return this.saying(answer, {
+        project_addons_behind_this_server: {
+          server_is: SERVER_VERSION,
+          project_is: moved,
+          what_to_do: `The project's gdharness addons are ${moved}, older than this ${SERVER_VERSION} server, so an ` + "editor restart loads the old code and reconnecting spawns this same server again. Tell the " + "user, and offer to run gdharness upgrade in the project, which replaces the addons with " + "this server's; ask first, since it changes files in their project. editor_launch restart " + "then loads them."
+        }
+      });
+    }
     if (moved !== null) {
       this.noticedUpdate = true;
       this.callsSinceNotice = 0;
@@ -32487,7 +33053,7 @@ class GodotServer {
     return this.saying(answer, {
       update_available: {
         ...notice,
-        what_to_do: "Tell the user a newer gdharness is out, with what changed, and offer to take it. " + "Only run the upgrade command if they say yes: it restarts their editor and the " + "MCP server has to be reconnected afterwards."
+        what_to_do: "Tell the user a newer gdharness is out, with what changed, and offer to take it. " + "Only run the upgrade command if they say yes: it replaces the addons in their project, " + "and afterwards the MCP server has to be reconnected and the editor restarted with " + "editor_launch restart."
       }
     });
   }
@@ -32504,6 +33070,11 @@ class GodotServer {
     const installed = installedAddonVersion(this.ownProject);
     return installed === null || installed === SERVER_VERSION ? null : installed;
   }
+  editorCodeOnDisk() {
+    const status = this.godotBridge.getStatus();
+    const project = (status.connected ? status.projectPath : undefined) ?? this.ownProject;
+    return project === null || project === "" ? undefined : installedEditorDigest(project);
+  }
   configDisagreement() {
     return this.ownProject === null ? null : configDisagrees(this.ownProject, SERVER_VERSION);
   }
@@ -32617,6 +33188,9 @@ class GodotServer {
         const contained = this.containProjectFiles(asks);
         return contained.ok ? await this.handleViaBridge(editorSide, contained.value) : contained.response;
       }
+      if (headless === "create_script") {
+        return await this.handleCreateScript(answerable);
+      }
       if (headless !== "refresh_class_cache") {
         return await this.headless(headless, answerable);
       }
@@ -32787,7 +33361,7 @@ class GodotServer {
           return await this.handleRuntimeCommand("click", {
             ...whichGame(args),
             path: readNonEmptyString(args, "nodePath") ?? "",
-            button: readString(args, "button") ?? "left",
+            button: args["button"] ?? "left",
             double: readBoolean(args, "doubleClick") ?? false,
             ...readNonEmptyString(args, "says") === undefined ? {} : { says: readNonEmptyString(args, "says") },
             ...args["index"] === undefined ? {} : { index: args["index"] }
@@ -32859,8 +33433,8 @@ class GodotServer {
     if (path === undefined) {
       return { ok: false, response: this.createErrorResponse("projectPath is required.") };
     }
-    const file = join18(path, "project.godot");
-    if (!existsSync12(file)) {
+    const file = join19(path, "project.godot");
+    if (!existsSync14(file)) {
       return {
         ok: false,
         response: this.createErrorResponse(`Not a Godot project: ${path}`, [
@@ -33070,13 +33644,30 @@ class GodotServer {
       }
       contained[key] = `res://${location.relativePath}`;
     }
-    const escaping = escapingPropertyValue(args["properties"]);
+    const escaping = escapingPropertyValue([args["properties"], args["track"]]);
     if (escaping !== undefined) {
       return {
         ok: false,
         response: this.createErrorResponse(`The property value ${escaping} resolves outside the project directory.`, PATH_SOLUTIONS)
       };
     }
+    const sources = args["sources"];
+    if (Array.isArray(sources)) {
+      const resolved = [];
+      for (const source of sources) {
+        const texture = typeof source === "object" && source !== null ? source["texture"] : undefined;
+        if (typeof texture !== "string") {
+          resolved.push(source);
+          continue;
+        }
+        const location = resolveWithinProject(projectPath, texture);
+        if (!location.ok) {
+          return { ok: false, response: this.createErrorResponse(location.reason, PATH_SOLUTIONS) };
+        }
+        resolved.push({ ...source, texture: `res://${location.relativePath}` });
+      }
+      contained["sources"] = resolved;
+    }
     const pluginName = readNonEmptyString(args, "pluginName");
     if (pluginName !== undefined) {
       const plugin = resolveWithinProject(projectPath, `addons/${pluginName}/plugin.cfg`);
@@ -33124,6 +33715,7 @@ class GodotServer {
     return this.answer(withScanWait({
       ok: true,
       messages: imported.messages,
+      ...imported.messagesOmitted === undefined ? {} : { messagesOmitted: imported.messagesOmitted },
       payload: {
         uidsCreated: given,
         stillWithoutUid: after,
@@ -33174,16 +33766,25 @@ class GodotServer {
     if (changed.length === 0) {
       return written;
     }
-    const taken = await this.editorTakes("adopt_project_settings", { settings: changed });
+    const adopting = {};
+    const taken = await this.editorTakes("adopt_project_settings", { settings: changed }, adopting);
+    if (taken["editorNote"] !== undefined) {
+      return this.jsonTextResponse({ ...answer, ...taken });
+    }
+    const adopted = Array.isArray(adopting["adopted"]) ? adopting["adopted"].map(String) : [];
+    const passedOver = changed.filter((name) => !adopted.includes(name));
     return this.jsonTextResponse({
       ...answer,
-      ...taken,
-      ...taken["editorNote"] === undefined ? { editorAdopted: changed } : {}
+      editorAdopted: adopted,
+      ...passedOver.length > 0 ? { editorPassedOver: passedOver } : {}
     });
   }
-  async editorTakes(command, args) {
+  async editorTakes(command, args, answered = {}) {
     try {
-      await this.godotBridge.invokeTool(command, args);
+      const result = await this.godotBridge.invokeTool(command, args);
+      if (typeof result === "object" && result !== null) {
+        Object.assign(answered, result);
+      }
       return {};
     } catch (error) {
       const message = errorMessage(error);
@@ -33221,7 +33822,19 @@ class GodotServer {
     }
     const applied = await this.reimport(project.value.path, readNonEmptyString(contained.value, "resourcePath"), true, readPositiveNumber(args, "timeoutMs") ?? REIMPORT_TIMEOUT_MS);
     if (!applied.ok) {
-      return applied.response;
+      const listed = written.payload["updated_options"];
+      const updated = Array.isArray(listed) ? listed.map(String) : [];
+      const which = updated.length === 0 ? "The options were" : `${updated.join(", ")} ${updated.length === 1 ? "was" : "were"}`;
+      return {
+        ...applied.response,
+        content: [
+          {
+            type: "text",
+            text: `${which} written to the import file, and the reimport that applies them failed, so the resource is still imported the old way until the editor's next scan or project_import reimport imports it. Why the reimport failed:`
+          },
+          ...applied.response.content
+        ]
+      };
     }
     return this.jsonTextResponse({ ...written.payload, reimport: applied.payload });
   }
@@ -33239,7 +33852,14 @@ class GodotServer {
         response: this.createErrorResponse(`${missingSource[0]} is not on disk, so there is nothing to import.`)
       };
     }
-    const targets = listed.filter((one) => one.status !== "missing_source" && (force || one.status !== "up_to_date")).map((one) => one.path);
+    const never = listed.find((one) => one.status === "not_imported");
+    if (resourcePath !== undefined && never !== undefined) {
+      return {
+        ok: false,
+        response: this.createErrorResponse(`${never.path} is not something the engine imports: ${never.reason ?? "it has no importer"}.`)
+      };
+    }
+    const targets = listed.filter((one) => one.status !== "missing_source" && one.status !== "not_imported" && (force || one.status !== "up_to_date")).map((one) => one.path);
     if (targets.length === 0) {
       return {
         ok: true,
@@ -33278,9 +33898,7 @@ class GodotServer {
       if (!imported.ok) {
         return { ok: false, response: this.answer(withScanWait(imported, scanned)) };
       }
-      if (imported.messages.length > 0) {
-        extra["engine_messages"] = imported.messages;
-      }
+      Object.assign(extra, engineExtras(imported));
       if (imported.extensionNote !== undefined) {
         extra["extensionNote"] = imported.extensionNote;
       }
@@ -33363,17 +33981,15 @@ class GodotServer {
     return withScanWait(outcome, scanned);
   }
   answer(outcome) {
+    const extras = engineExtras(outcome);
     if (!outcome.ok) {
       const response = this.createErrorResponse(outcome.message);
-      if (outcome.messages.length > 0) {
-        response.content.push({
-          type: "text",
-          text: JSON.stringify({ engine_messages: outcome.messages }, null, 2)
-        });
+      if (Object.keys(extras).length > 0) {
+        response.content.push({ type: "text", text: JSON.stringify(extras, null, 2) });
       }
       return response;
     }
-    return this.jsonTextResponse(outcome.messages.length > 0 ? { ...outcome.payload, engine_messages: outcome.messages } : outcome.payload);
+    return this.jsonTextResponse({ ...outcome.payload, ...extras });
   }
   async handleProjectInfo(args) {
     const include = readStringArray(args, "include") ?? [];
@@ -33389,7 +34005,7 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const application = parseProjectGodot(readFileSync17(project.value.file, "utf8"))["application"] ?? {};
+    const application = parseProjectGodot(readFileSync18(project.value.file, "utf8"))["application"] ?? {};
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
@@ -33406,10 +34022,14 @@ class GodotServer {
         continue;
       }
       const outcome = await this.operation(spec.operation, spec.params(args, detailed), project.value.path);
-      info[section] = outcome.ok ? outcome.messages.length > 0 ? { ...outcome.payload, engine_messages: outcome.messages } : outcome.payload : { error: outcome.message, engine_messages: outcome.messages };
+      info[section] = outcome.ok ? { ...outcome.payload, ...engineExtras(outcome) } : { error: outcome.message, ...engineExtras(outcome) };
     }
     return this.jsonTextResponse(info);
   }
+  fileTypes(args) {
+    const named = readStringArray(args, "fileTypes");
+    return named === undefined ? {} : { fileTypes: named };
+  }
   handleSearchProject(args) {
     const project = this.project(args);
     if (!project.ok) {
@@ -33418,16 +34038,7 @@ class GodotServer {
     try {
       return this.jsonTextResponse(searchProject(project.value.path, {
         query: readString(args, "query") ?? "",
-        fileTypes: readStringArray(args, "fileTypes") ?? [
-          "gd",
-          "tscn",
-          "tres",
-          "gdshader",
-          "cfg",
-          "md",
-          "txt",
-          "json"
-        ],
+        ...this.fileTypes(args),
         regex: readBoolean(args, "regex") ?? false,
         caseSensitive: readBoolean(args, "caseSensitive") ?? false,
         maxResults: readPositiveNumber(args, "maxResults") ?? 100
@@ -33450,18 +34061,18 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const folder = dirname11(output.absolutePath);
+    const folder = dirname12(output.absolutePath);
     try {
       mkdirSync10(folder, { recursive: true });
     } catch (error) {
-      return this.createErrorResponse(`Cannot create ${dirname11(output.relativePath)} to export into: ${errorMessage(error)}`);
+      return this.createErrorResponse(`Cannot create ${dirname12(output.relativePath)} to export into: ${errorMessage(error)}`);
     }
     const debug = readBoolean(args, "debug") ?? false;
     const exportLogs = scratchDirectory("export");
     const exportArgs = [
       "--headless",
       "--log-file",
-      join18(exportLogs, "engine.log"),
+      join19(exportLogs, "engine.log"),
       "--path",
       project.value.path,
       debug ? "--export-debug" : "--export-release",
@@ -33469,55 +34080,18 @@ class GodotServer {
       output.absolutePath
     ];
     this.logDebug(`Exporting: ${engine.value} ${exportArgs.join(" ")}`);
-    const log = new GameLog;
-    let ending = { exitCode: 0, exitSignal: null, failure: null };
+    const writtenAt = () => existsSync14(output.absolutePath) ? statSync8(output.absolutePath).mtimeMs : null;
+    const before = writtenAt();
+    let ending;
     try {
-      const { stdout, stderr } = await run5(engine.value, exportArgs, {
-        timeout: 300000,
-        maxBuffer: 64 * 1024 * 1024,
-        signal: callSignal()
-      });
-      log.append("stdout", stdout);
-      log.append("stderr", stderr);
-    } catch (error) {
-      if (!(error instanceof Error && ("stdout" in error) && ("stderr" in error))) {
-        return this.createErrorResponse(`Export could not be run: ${errorMessage(error)}`);
-      }
-      const failed = error;
-      log.append("stdout", failed.stdout);
-      log.append("stderr", failed.stderr);
-      ending = endingOf(failed);
+      ending = await runEngine(engine.value, exportArgs, { timeout: { ms: 300000, said: "five minutes" } });
     } finally {
       discard(exportLogs);
     }
-    log.finish();
-    const problems = log.select({ severity: "warning", sinceLastCall: false, limit: 200 });
-    const verdict = {
-      exported: ending.exitCode === 0 && log.count("error") === 0 && existsSync12(output.absolutePath),
-      preset,
-      outputPath: output.relativePath,
-      debug,
-      exitCode: ending.exitCode,
-      exitSignal: ending.exitSignal ?? undefined,
-      failure: ending.failure ?? undefined,
-      errors: log.count("error"),
-      warnings: log.count("warning"),
-      entries: forAnswer(problems.entries)
-    };
-    if (!verdict.exported) {
-      const why = ending.exitSignal === null ? ending.failure === null ? "" : ` The engine was ended by Node (${ending.failure}), so it has no exit code.` : ` The engine was ended by ${ending.exitSignal}, so it has no exit code: the export ran past its five minutes or the call was cancelled.`;
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Export with preset '${preset}' did not produce ${output.relativePath}.${why}`
-          },
-          { type: "text", text: JSON.stringify(verdict, null, 2) }
-        ],
-        isError: true
-      };
+    if (ending.exitSignal === null && ending.exitCode === null) {
+      return this.createErrorResponse(`Export could not be run: ${ending.failure ?? "the engine gave no exit status"}`);
     }
-    return this.jsonTextResponse(verdict);
+    return exportAnswer(ending, { preset, outputPath: output.relativePath, debug }, before, writtenAt());
   }
   async handleRunTests(args) {
     const project = this.project(args);
@@ -33529,7 +34103,7 @@ class GodotServer {
       return contained.response;
     }
     const runner = "addons/gdUnit4/bin/GdUnitCmdTool.gd";
-    if (!existsSync12(join18(project.value.path, runner))) {
+    if (!existsSync14(join19(project.value.path, runner))) {
       return this.createErrorResponse(`gdUnit4 is not installed in this project: no ${runner}.`, [
         "Install gdUnit4 under addons/gdUnit4, from https://github.com/godot-gdunit-labs/gdUnit4"
       ]);
@@ -33595,21 +34169,22 @@ class GodotServer {
     if (timedOut && run.process.pid !== undefined) {
       await untilGone([run.process.pid]);
     }
-    const reportsDir = join18(project.value.path, ".godot", ...ours.split("/"));
+    await run.settled;
+    const reportsDir = join19(project.value.path, ".godot", ...ours.split("/"));
     let report = null;
     let reportProblem = null;
     try {
-      const written = existsSync12(reportsDir) ? readdirSync8(reportsDir).filter((name) => name.startsWith("report_")).sort((a, b) => Number(a.slice("report_".length)) - Number(b.slice("report_".length))) : [];
+      const written = existsSync14(reportsDir) ? readdirSync8(reportsDir).filter((name) => name.startsWith("report_")).sort((a, b) => Number(a.slice("report_".length)) - Number(b.slice("report_".length))) : [];
       const newest = written.at(-1);
       if (newest !== undefined) {
-        report = parseJUnit(readFileSync17(join18(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync18(join19(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
     } finally {
       discard(reportsDir, userData);
       try {
-        rmdirSync2(dirname11(reportsDir));
+        rmdirSync2(dirname12(reportsDir));
       } catch {}
     }
     const engineEntries = run.log.select({ severity: "warning", sinceLastCall: false, limit: 200 }).entries.map(aboveTheRunner);
@@ -33622,7 +34197,11 @@ class GodotServer {
       105: "script errors"
     };
     const exitCode = run.exitCode;
-    const printed = run.log.select({ severity: "info", sinceLastCall: false, limit: 200 }).entries;
+    const printed = run.log.select({
+      severity: "info",
+      sinceLastCall: false,
+      limit: Number.POSITIVE_INFINITY
+    }).entries;
     const said = printed.map((entry) => entry.text);
     const nothingRan = timedOut ? null : whyNoReport(said, asked);
     const cutShort = timedOut ? timedOutVerdict(timeoutMs, silentForMs) : null;
@@ -33638,7 +34217,7 @@ class GodotServer {
       ...echoed.omitted > 0 ? { printedOmitted: echoed.omitted } : {}
     };
     if (report === null) {
-      const note = nothingRan !== null ? `No tests ran: ${verdict}.${elsewhereIn(project.value.path, asked)}` : scriptErrors.length > 0 ? scriptErrorsNote(scriptErrors) : `The test run wrote no report (${verdict}${reportProblem ? `; ${reportProblem}` : ""}).`;
+      const note = nothingRan !== null ? `No tests ran: ${verdict}.${elsewhereIn(project.value.path, asked)}` : 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}).`;
       return {
         content: [
           { type: "text", text: note },
@@ -33675,10 +34254,21 @@ class GodotServer {
       orphans: suite.orphans,
       message: `${suite.orphans} node${suite.orphans === 1 ? "" : "s"} were still in the tree when this suite finished. A node built in a test and neither freed nor added to the tree is the usual cause; free it, or add it with auto_free().`
     }));
-    const unclean = report.suites.filter((suite) => suite.failures > 0 || suite.errors > 0 || suite.skipped > 0 || orphansIn(suite.path) > 0);
+    const unclean = report.suites.filter((suite) => suite.failures > 0 || suite.errors > 0 || suite.hookFailures > 0 || suite.hookErrors > 0 || suite.skipped > 0 || orphansIn(suite.path) > 0);
+    const hooksPrinted = hookFailuresPrinted(said);
+    const hookFailures = report.suites.filter((suite) => suite.hookFailures + suite.hookErrors > 0).flatMap((suite) => {
+      const printedHere = hooksPrinted.filter((hook) => hook.path === suite.path);
+      return printedHere.length > 0 ? printedHere.map((hook) => ({ suite: suite.name, ...hook })) : [
+        {
+          suite: suite.name,
+          path: suite.path,
+          message: "gdUnit4 counted a failure in this suite that none of its cases carry, which is what a failed before() or after() leaves, and printed no line saying which."
+        }
+      ];
+    });
     const notRun = report.suites.reduce((sum, suite) => sum + Math.max(0, suite.discovered - suite.tests), 0);
     return this.jsonTextResponse({
-      passed: !timedOut && exitCode === 0 && report.failures === 0 && report.errors === 0,
+      passed: !timedOut && exitCode === 0 && nothingRan === null && report.tests > 0 && report.failures === 0 && report.errors === 0 && hookFailures.length === 0,
       verdict,
       ...timedOut ? { timedOut, hung, silentForMs } : {},
       exitCode,
@@ -33689,13 +34279,14 @@ class GodotServer {
       skipped: report.skipped,
       time: report.time,
       failed,
+      hookFailures: hookFailures.length > 0 ? hookFailures : undefined,
       warnings: warnings.length > 0 ? warnings : undefined,
       orphans: orphans.total > 0 ? orphans.total : undefined,
       notRun: notRun > 0 ? notRun : undefined,
       ...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." : notRun > 0 ? `This run stopped at the first failure in each suite it failed in, so ${notRun} case${notRun === 1 ? "" : "s"} never ran and count as neither passed nor failed. Leave failFast out to run every case.` : undefined,
+      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),
       suites: unclean.map((suite) => ({
         name: suite.name,
         path: suite.path,
@@ -33703,6 +34294,7 @@ class GodotServer {
         notRun: suite.discovered > suite.tests ? suite.discovered - suite.tests : undefined,
         failures: suite.failures,
         errors: suite.errors,
+        hookFailures: suite.hookFailures + suite.hookErrors > 0 ? suite.hookFailures + suite.hookErrors : undefined,
         skipped: suite.skipped,
         orphans: orphansIn(suite.path) > 0 ? orphansIn(suite.path) : undefined,
         time: suite.time
@@ -33716,7 +34308,7 @@ class GodotServer {
   }
   async godotVersion(godotPath) {
     try {
-      const { stdout } = await run5(godotPath, ["--version"], { timeout: 1e4 });
+      const { stdout } = await run4(godotPath, ["--version"], { timeout: 1e4 });
       this.lastGodotVersion = stdout.trim();
       return this.lastGodotVersion;
     } catch (error) {
@@ -33728,8 +34320,18 @@ class GodotServer {
     const answer = await this.handleLSP("lsp_get_diagnostics", args);
     const payload = asParams(JSON.parse(answer.content[0]?.text ?? "{}"));
     if (payload["error"] !== undefined) {
-      const reason = payload["error"];
-      return this.createErrorResponse(`Diagnostics unavailable: ${typeof reason === "string" ? reason : JSON.stringify(reason)}`, [
+      const reason = typeof payload["error"] === "string" ? payload["error"] : JSON.stringify(payload["error"]);
+      if (payload["refusedArguments"] === true) {
+        return this.createErrorResponse(reason);
+      }
+      if (typeof payload["serves"] === "string") {
+        return this.createErrorResponse(`Diagnostics 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"
+        ]);
+      }
+      return this.createErrorResponse(`Diagnostics 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"
       ]);
@@ -33747,7 +34349,7 @@ class GodotServer {
       warnings: diagnostics.length - errors,
       diagnostics,
       ...disagrees
-    }, this.godotBridge.getStatus().addonVersion, SERVER_VERSION, this.godotBridge.getStatus().addonDigest, shippedEditorDigest()));
+    }, this.godotBridge.getStatus().addonVersion, SERVER_VERSION, this.godotBridge.getStatus().addonDigest, shippedEditorDigest(), this.editorCodeOnDisk()));
   }
   whereTheFileDisagrees(diagnostics, args) {
     const messages = diagnostics.map((entry) => asParams(entry)["message"]).filter((message) => typeof message === "string");
@@ -33760,11 +34362,11 @@ class GodotServer {
     const cached = cachedClasses(projectPath);
     const contradicted = cached === null ? [] : contradictedDiagnostics(messages, cached, (resourcePath) => {
       const contained = resolveWithinProject(projectPath, resourcePath);
-      if (!contained.ok || !existsSync12(contained.absolutePath)) {
+      if (!contained.ok || !existsSync14(contained.absolutePath)) {
         return null;
       }
       try {
-        return readFileSync17(contained.absolutePath, "utf8");
+        return readFileSync18(contained.absolutePath, "utf8");
       } catch {
         return null;
       }
@@ -33820,11 +34422,11 @@ class GodotServer {
   }
   sourceOfClass(projectPath, resourcePath) {
     const contained = resolveWithinProject(projectPath, resourcePath);
-    if (!contained.ok || !existsSync12(contained.absolutePath)) {
+    if (!contained.ok || !existsSync14(contained.absolutePath)) {
       return null;
     }
     try {
-      return readFileSync17(contained.absolutePath, "utf8");
+      return readFileSync18(contained.absolutePath, "utf8");
     } catch {
       return null;
     }
@@ -33898,7 +34500,7 @@ class GodotServer {
   }
   breakpointsAtRisk() {
     const status = this.godotBridge.getStatus();
-    if (!status.connected || status.syncsBreakpoints === true) {
+    if (!hasSaidWhoItIs(status) || status.syncsBreakpoints === true) {
       return {};
     }
     return {
@@ -33953,26 +34555,34 @@ class GodotServer {
       restartSettled(this.ownProject);
       return null;
     }
-    return owed;
+    return { note: owed, underway: restartUnderway(owed) };
   }
   async getEditorStatusPayload() {
     const status = this.godotBridge.getStatus();
     const launchedIsUp = !status.connected && await this.launchedEditorIsUp();
     const isPortConflict = this.bridgeStartupError?.includes("EADDRINUSE") ?? false;
-    const stale = status.connected && editorIsStale(status.addonVersion, SERVER_VERSION, status.addonDigest, shippedEditorDigest());
+    const greeted = hasSaidWhoItIs(status);
+    const stale = greeted && editorIsStale(status.addonVersion, SERVER_VERSION, status.addonDigest, shippedEditorDigest());
     const unfinished = this.restartLeftUnfinished(status.connected);
     return {
       ...status,
       serverVersion: SERVER_VERSION,
-      addonIsStale: status.connected ? stale : undefined,
+      addonIsStale: greeted ? stale : undefined,
+      greeting: status.connected && !greeted ? "The editor has connected and has not yet said who it is: its project, pid, addon version and ports arrive with its greeting a moment after the socket opens, later while it imports. Ask again for them." : undefined,
       bridgeAvailable: this.bridgeStartupError === null,
-      mayYetConnect: status.connected ? undefined : unfinished !== null ? false : anEditorIsStillComing(status.listeningSince, launchedIsUp),
-      restartInterrupted: unfinished === null ? undefined : {
-        quitEditorPid: unfinished.editorPid,
-        quitAt: unfinished.quitAt,
-        byServerPid: unfinished.byPid,
+      mayYetConnect: status.connected ? undefined : unfinished !== null ? unfinished.underway : anEditorIsStillComing(status.listeningSince, launchedIsUp),
+      restartInterrupted: unfinished === null || unfinished.underway ? undefined : {
+        quitEditorPid: unfinished.note.editorPid,
+        quitAt: unfinished.note.quitAt,
+        byServerPid: unfinished.note.byPid,
         note: "A restart begun by a previous gdharness server asked this project's editor to quit, and that server was ended before it could start the editor again, so nothing is coming. editor_launch open starts one, and clears this."
       },
+      restartUnderway: unfinished === null || !unfinished.underway ? undefined : {
+        quitEditorPid: unfinished.note.editorPid,
+        quitAt: unfinished.note.quitAt,
+        byServerPid: unfinished.note.byPid,
+        note: `A restart of this project's editor is under way: gdharness server pid ${unfinished.note.byPid} asked it to quit at ${unfinished.note.quitAt} and is starting it again. Wait for it rather than opening another.`
+      },
       awaitingLaunchedEditor: status.connected || !launchedIsUp ? undefined : this.launchedEditor?.pid ?? undefined,
       ...status.connected ? this.whatTheLaunchedEditorDropped() : {},
       startupError: this.bridgeStartupError,
@@ -33982,8 +34592,9 @@ class GodotServer {
         port: this.godotBridge.configuredPort,
         note: `The gdharness server this one replaced, pid ${this.handingOverFrom}, still holds port ${this.godotBridge.configuredPort} and is standing down; this server takes the port when it lets go, and takes another after ${HANDOVER_MS / 1000} seconds if it does not.`
       },
-      staleNote: stale ? addonMismatch(status.addonVersion, SERVER_VERSION, status.addonDigest, shippedEditorDigest()) : undefined,
-      addonNote: status.connected ? sameCodeNote(status.addonVersion, SERVER_VERSION, status.addonDigest, shippedEditorDigest()) : undefined,
+      staleNote: stale ? addonMismatch(status.addonVersion, SERVER_VERSION, status.addonDigest, shippedEditorDigest(), this.editorCodeOnDisk()) : undefined,
+      addonNote: greeted ? sameCodeNote(status.addonVersion, SERVER_VERSION, status.addonDigest, shippedEditorDigest()) : undefined,
+      startedByAnEditorNote: status.startedByAnEditor === true ? "Another editor started this one: Godot's own restart, or the project manager opening a project. None of the arguments a server gave the editor before it reached this one, so it serves the ports its editor settings name (and none at all while another editor holds those, when the script and debug tools reach that editor instead), its console is not captured, and it restarts itself. Close it and use editor_launch open to have an editor this server started." : undefined,
       ...this.breakpointsAtRisk(),
       retryingBridge: this.bridgeRetry === null ? undefined : true,
       announcedAt: this.announcedAt ?? undefined,
@@ -34012,7 +34623,8 @@ class GodotServer {
       return {
         playing: readBoolean(asParams(answer), "playing") ?? false,
         scene: readString(asParams(answer), "scenePath") ?? "",
-        debugPort: readNumber(asParams(answer), "debugPort")
+        debugPort: readNumber(asParams(answer), "debugPort"),
+        play: playOf(asParams(answer))
       };
     } catch {
       return null;
@@ -34108,7 +34720,7 @@ class GodotServer {
       return null;
     }
     try {
-      return settingKeys(readFileSync17(join18(projectPath, "project.godot"), "utf8"));
+      return settingKeys(readFileSync18(join19(projectPath, "project.godot"), "utf8"));
     } catch {
       return null;
     }
@@ -34121,17 +34733,33 @@ class GodotServer {
         "editor_status says whether the bridge is up and what has reached it"
       ]);
     }
-    const settingsBefore = this.settingKeysOf(before.projectPath);
+    if (!hasSaidWhoItIs(before)) {
+      const settled = await this.waitForBridge(() => hasSaidWhoItIs(this.godotBridge.getStatus()) || !this.godotBridge.isConnected(), Date.now() + GREETING_WAIT_MS);
+      if (!settled) {
+        return this.createErrorResponse(`The editor has connected and has not said who it is within ${GREETING_WAIT_MS / 1000}s, so whether this server or the editor itself restarts it cannot be told.`, [
+          "editor_status says when it has, under greeting while it has not",
+          "Then ask for the restart again"
+        ]);
+      }
+      return this.handleRestartEditor(args);
+    }
     const mine = before.openedByAServer === true && before.projectPath !== undefined;
+    if (!mine && args["hidden"] === true) {
+      return this.createErrorResponse("This editor was opened by hand, and restarts itself as it was, so it cannot come back hidden.", [
+        "Close it, then editor_launch open with hidden: true starts a hidden one this server can restart",
+        "editor_launch restart without hidden restarts it as it is"
+      ]);
+    }
+    const settingsBefore = this.settingKeysOf(before.projectPath);
     const asked = mine ? await this.startItAgain(before.projectPath ?? "", before.editorPid, args["hidden"] === true) : await this.handleViaBridge("restart_editor", {});
     if (asked.isError === true) {
       return asked;
     }
     const startedAt = before.connectedAt?.getTime() ?? 0;
     const began = Date.now();
-    const back = await this.waitForBridge(() => theEditorHasComeBack(this.godotBridge.getStatus(), startedAt), began + EDITOR_RESTART_TIMEOUT_MS);
+    const back = await this.waitForBridge(() => theEditorHasComeBack(this.godotBridge.getStatus(), startedAt), began + editorRestartTimeoutMs());
     if (!back) {
-      return this.createErrorResponse(`The editor was asked to restart and has not come back within ${EDITOR_RESTART_TIMEOUT_MS / 1000}s.`, [
+      return this.createErrorResponse(`The editor was asked to restart and has not come back within ${editorRestartTimeoutMs() / 1000}s.`, [
         "It may be asking what to do about an unsaved scene: look at the editor window",
         "An addon that no longer parses stops the editor reaching this server",
         "editor_status says whether anything has reached the bridge since"
@@ -34145,18 +34773,27 @@ class GodotServer {
       addonVersion: now.addonVersion,
       serverVersion: SERVER_VERSION,
       addonIsStale: editorIsStale(now.addonVersion, SERVER_VERSION, now.addonDigest, shippedEditorDigest()),
-      staleNote: addonMismatch(now.addonVersion, SERVER_VERSION, now.addonDigest, shippedEditorDigest()),
+      staleNote: addonMismatch(now.addonVersion, SERVER_VERSION, now.addonDigest, shippedEditorDigest(), this.editorCodeOnDisk()),
       ...this.whatTheEditorDropped(settingsBefore, after),
       tookMs: Date.now() - began
     });
   }
-  whatTheLaunchedEditorDropped() {
+  settleTheLaunchReading() {
     const watched = this.launchedFrom;
-    if (watched === null) {
-      return {};
+    const status = this.godotBridge.getStatus();
+    if (watched === null || !hasSaidWhoItIs(status)) {
+      return;
     }
     this.launchedFrom = null;
-    return this.whatTheEditorDropped(watched.before, this.settingKeysOf(watched.projectPath));
+    if (status.editorPid === undefined || status.editorPid !== this.launchedEditor?.pid) {
+      return;
+    }
+    this.launchedDropped = this.whatTheEditorDropped(watched.before, this.settingKeysOf(watched.projectPath));
+  }
+  whatTheLaunchedEditorDropped() {
+    const dropped = this.launchedDropped ?? {};
+    this.launchedDropped = null;
+    return dropped;
   }
   whatTheEditorDropped(before, after) {
     return settingsDroppedReport(before, after);
@@ -34182,7 +34819,14 @@ class GodotServer {
       restartSettled(projectPath);
       return asked;
     }
-    await this.waitForBridge(() => !alive(editorPid), Date.now() + EDITOR_RESTART_TIMEOUT_MS);
+    const gone = await this.waitForBridge(() => !alive(editorPid), Date.now() + editorRestartTimeoutMs());
+    if (!gone) {
+      restartSettled(projectPath);
+      return this.createErrorResponse(`The editor was asked to go and pid ${editorPid ?? "unknown"} is still running after ${editorRestartTimeoutMs() / 1000}s, so no replacement was started: it would find the language server and debug adapter ports still held.`, [
+        "It may be asking what to do about unsaved changes, or a script may be holding up its exit",
+        `editor_launch open starts one on ${projectPath} once it has gone`
+      ]);
+    }
     const opened = await this.openAnEditor(engine.value, projectPath, ports, hidden);
     restartSettled(projectPath);
     if (opened.error !== null) {
@@ -34213,6 +34857,10 @@ class GodotServer {
         "Another project wants its own gdharness server, which is its own harness session"
       ]);
     }
+    const refused = this.anEditorThatCannotConnect(project.value.path);
+    if (refused !== null) {
+      return refused;
+    }
     const engine = await this.engine();
     if (!engine.ok) {
       return engine.response;
@@ -34237,6 +34885,27 @@ class GodotServer {
       settingsNote: before === null ? "project.godot could not be read before this editor was opened, so nothing here will be able to say what the import saved away. Opening a project rewrites the file and drops any key sitting at its own default." : before.size === 0 ? undefined : "Opening a project imports it and saves project.godot, and Godot drops any key sitting at its own default. editor_status names anything lost under settingsDropped once this editor has connected."
     });
   }
+  anEditorThatCannotConnect(projectPath) {
+    if (this.ownProject !== null && !isSameDirectory(this.ownProject, projectPath)) {
+      return this.createErrorResponse(`This server serves ${this.ownProject}, and an editor of ${projectPath} would dial that project's own server rather than this one.`, [
+        "Open it from that project's own gdharness session",
+        `editor_launch with projectPath ${this.ownProject} opens the editor this server serves`
+      ]);
+    }
+    const report = inspectProject(projectPath);
+    const installed = report.addons.some((addon) => addon.name === "gdharness_editor" && addon.installed);
+    if (!installed || !report.pluginsEnabled.includes("gdharness_editor")) {
+      return this.createErrorResponse(`The gdharness editor addon is not ${installed ? "enabled" : "installed"} in ${projectPath}, so an editor opened on it would never reach this server.`, installed ? [
+        "gdharness setup in the project enables it",
+        "Or enable it under Project Settings, Plugins, in an editor opened by hand"
+      ] : ["gdharness setup in the project installs and enables it"]);
+    }
+    const owed = restartOwed(projectPath);
+    if (owed !== null && restartUnderway(owed)) {
+      return this.createErrorResponse(`A restart of this project's editor is under way: gdharness server pid ${owed.byPid} asked it to quit at ${owed.quitAt} and is starting it again, so opening another would put two editors on one project.`, ["editor_status says when it has connected"]);
+    }
+    return null;
+  }
   async openAnEditor(engine, projectPath, ports, hidden) {
     clearEditorLog(projectPath);
     const launched = await launchOutsideTheTree({
@@ -34271,6 +34940,13 @@ class GodotServer {
     if (!project.ok) {
       return project.response;
     }
+    const open = this.godotBridge.isConnected() ? this.godotBridge.getStatus().projectPath : undefined;
+    if (op !== "check" && open !== undefined && open !== "" && !isSameDirectory(open, project.value.path)) {
+      return this.createErrorResponse(`This start names ${project.value.path}, and the editor on this bridge has ${open} open.`, [
+        "editor_status names the project this server's editor is showing",
+        "One server serves one editor: start a second server for the other project"
+      ]);
+    }
     const scene = readNonEmptyString(args, "scene");
     const sceneToRun = scene !== undefined ? resolveWithinProject(project.value.path, scene) : null;
     if (sceneToRun && !sceneToRun.ok) {
@@ -34365,7 +35041,7 @@ class GodotServer {
   }
   async runtimeUp(projectPath, before, budget, withArgs) {
     const budgetMs = budget.ms;
-    if (!existsSync12(join18(projectPath, RUNTIME_AUTOLOAD.path))) {
+    if (!existsSync14(join19(projectPath, RUNTIME_AUTOLOAD.path))) {
       return runtimeVerdict(null, { addon: false, budgetMs, heldAt: null, running: false, withArgs });
     }
     let asking = null;
@@ -34374,7 +35050,7 @@ class GodotServer {
     let editorAsks = 0;
     const waitBegan = Date.now();
     const lastSaid = () => editorSaysGoing ? "playing" : "not playing";
-    const endpoint = await announcedSince(projectPath, before, {
+    const fresh = await announcedSince(projectPath, before, {
       budgetMs,
       accept: (one) => this.isTheGameOf(this.activeProcess, one, projectPath),
       giveUp: () => {
@@ -34398,11 +35074,19 @@ class GodotServer {
       }
     });
     const asked = editorAsks === 0 ? "editor not asked" : `editor asked ${editorAsks === 1 ? "once" : `${editorAsks} times`}, last said ${lastSaid()}`;
-    this.logDebug(`announce wait ended after ${Date.now() - waitBegan}ms: ${endpoint === null ? "nothing announced" : `pid ${endpoint.pid} announced`}, ${asked}`);
+    this.logDebug(`announce wait ended after ${Date.now() - waitBegan}ms: ${fresh.length === 0 ? "nothing announced" : `pid ${fresh.map((one) => one.pid).join(", ")} announced`}, ${asked}`);
     const going = await this.currentRun();
+    const endpoint = await this.theRunsAmong(going, fresh);
     if (endpoint !== null && going !== null && going.announcedPid === undefined) {
       this.tie(going, endpoint);
     }
+    if (endpoint === null && fresh.length > 1) {
+      return {
+        listening: true,
+        pids: fresh.map((one) => one.pid),
+        note: `${fresh.length} games of this project announced at once and none could be told from the process tree as this run's own game rather than one it started, so none is taken as its runtime. editor_status lists them under runtimes.`
+      };
+    }
     return runtimeVerdict(endpoint, {
       addon: true,
       budgetMs,
@@ -34486,7 +35170,13 @@ class GodotServer {
     };
     this.activeProcess = played;
     this.watchThePlayedConsole();
-    writeEditorRunNote({ projectPath, transcript: transcript.path, startedAt });
+    const which = playOf(playAnswer);
+    writeEditorRunNote({
+      projectPath,
+      transcript: transcript.path,
+      startedAt,
+      ...which === null ? {} : { play: which }
+    });
     sweepTranscripts();
     return this.jsonTextResponse({
       started: true,
@@ -34601,7 +35291,7 @@ class GodotServer {
       return 0;
     }
     try {
-      return reportAlreadyInTranscript(readFileSync17(game.transcript), readFileSync17(report));
+      return reportAlreadyInTranscript(readFileSync18(game.transcript), readFileSync18(report));
     } catch (error) {
       this.logDebug(`Could not compare a picked-up run's report with its transcript: ${errorMessage(error)}`);
       return 0;
@@ -34615,6 +35305,18 @@ class GodotServer {
     game.brokeOn = halt.text;
     game.log.record("error", halt.text);
   }
+  async untilTheEditorStopsPlaying(withinMs = STOP_WAIT_MS) {
+    const deadline = Date.now() + withinMs;
+    for (;; ) {
+      if ((await this.editorPlayingState())?.playing === false) {
+        return true;
+      }
+      if (Date.now() >= deadline) {
+        return false;
+      }
+      await delay3(100);
+    }
+  }
   async endActiveGame(reason, going) {
     const running = this.activeProcess;
     const project = running?.projectPath ?? this.ourProject();
@@ -34633,8 +35335,16 @@ class GodotServer {
     running.endedHere = reason;
     const announced = this.announcedPidOf(running);
     if (running.throughEditor) {
-      await this.handleViaBridge("stop_playing", {});
-      return await untilGone(announced === undefined ? [] : [announced]) ? "gone" : "lingering";
+      const asked = await this.handleViaBridge("stop_playing", {});
+      if (asked.isError === true) {
+        running.endedHere = null;
+        running.log.record("warning", `This run was not ended here: the editor could not be asked to stop it (${asked.content[0]?.text ?? "no reason given"}).`);
+        return "unreached";
+      }
+      if (announced === undefined) {
+        return await this.untilTheEditorStopsPlaying() ? "gone" : "lingering";
+      }
+      return await untilGone([announced]) ? "gone" : "lingering";
     }
     if (running.pid === null) {
       return "gone";
@@ -34643,23 +35353,30 @@ class GodotServer {
       pid: running.pid,
       transcript: running.transcript ?? "",
       startedAt: running.startedAt,
+      ...running.startedBy === undefined ? {} : { startedBy: running.startedBy },
       projectPath: running.projectPath ?? "",
       arguments: [],
       ...running.command === undefined ? {} : { command: running.command }
     };
-    if (!await stillTheRecordedRun(startedAs)) {
+    const why = await whyNotStillTheRecordedRun(startedAs);
+    if (why !== null) {
       clearTheRecord();
       running.endedHere = null;
-      running.log.record("warning", `This run was not ended here: pid ${running.pid} no longer answers as the process the run was started as, so nothing was signalled. If that process is still the game, end it yourself; if it is not, it belongs to something else.`);
+      running.log.record("warning", `This run was not ended here: pid ${running.pid} no longer answers as the process the run was started as (${why}), so nothing was signalled. If that process is still the game, end it yourself; if it is not, it belongs to something else.`);
       return "refused";
     }
     const signalled = await runningAs(running.pid);
     const described = signalled === null ? "nothing it would name" : `${signalled.kind}: ${signalled.text}`;
     let landed = true;
+    let declined = null;
     try {
       process.kill(running.pid);
-    } catch {
+    } catch (error) {
       landed = false;
+      const code = error.code;
+      if (code !== "ESRCH") {
+        declined = code ?? errorMessage(error);
+      }
     }
     const gone = await untilGone([running.pid]);
     if (gone) {
@@ -34670,11 +35387,11 @@ class GodotServer {
       running.exitSignal = "SIGTERM";
     }
     clearTheRecord();
-    running.log.record("info", landed ? `gdharness ended pid ${running.pid}, which the operating system described as ${described}.` : `gdharness signalled pid ${running.pid} and it was already gone; the operating system had described it as ${described}.`);
+    running.log.record(gone ? "info" : "warning", declined !== null ? `gdharness could not signal pid ${running.pid}: the operating system refused it (${declined}). It had described that process as ${described}.` : !gone ? `gdharness signalled pid ${running.pid}, which the operating system described as ${described}, and it was still running ${STOP_WAIT_MS / 1000} seconds later.` : landed ? `gdharness ended pid ${running.pid}, which the operating system described as ${described}.` : `gdharness signalled pid ${running.pid} and it was already gone; the operating system had described it as ${described}.`);
     return gone ? "gone" : "lingering";
   }
   spawnGame(godotPath, cmdArgs, env) {
-    const child = spawn3(godotPath, cmdArgs, { stdio: ["ignore", "pipe", "pipe"], ...env ? { env } : {} });
+    const child = spawn4(godotPath, cmdArgs, { stdio: ["ignore", "pipe", "pipe"], ...env ? { env } : {} });
     const cancelled = callSignal();
     if (cancelled !== undefined) {
       const end = () => {
@@ -34714,7 +35431,6 @@ class GodotServer {
     });
     child.on("exit", (code, signal) => {
       this.logDebug(`Godot process exited with code ${code ?? "none"}, signal ${signal ?? "none"}`);
-      log.finish();
       started.exitCode = code;
       started.exitSignal = code === null ? signal : null;
     });
@@ -34724,7 +35440,28 @@ class GodotServer {
 `);
       started.exitCode = -1;
     });
-    return started;
+    const settled = new Promise((resolve) => {
+      let open = 2;
+      const done = () => {
+        log.finish();
+        resolve();
+      };
+      const closed = () => {
+        open -= 1;
+        if (open === 0) {
+          done();
+        }
+      };
+      child.stdout.once("close", closed);
+      child.stderr.once("close", closed);
+      child.once("exit", () => {
+        setTimeout(done, STREAMS_GRACE_MS).unref();
+      });
+      child.once("error", () => {
+        done();
+      });
+    });
+    return Object.assign(started, { settled });
   }
   async launchKeptGame(godotPath, cmdArgs, projectPath, env, desktop) {
     const startedAt = Date.now();
@@ -34734,12 +35471,13 @@ class GodotServer {
       command: godotPath,
       args: cmdArgs,
       ...env === undefined ? {} : { env },
-      run: { transcript: transcript.path, startedAt, projectPath },
+      run: { transcript: transcript.path, startedAt, projectPath, ...this.servedBy() },
       ...desktop === undefined ? {} : { desktop }
     });
     if ("error" in launched) {
       return launched;
     }
+    const startedBy = Date.now();
     sweepTranscripts();
     return {
       pid: launched.pid,
@@ -34748,6 +35486,7 @@ class GodotServer {
       readOffset: 0,
       projectPath,
       startedAt,
+      startedBy,
       command: godotPath,
       exitCode: null,
       exitSignal: null,
@@ -34806,7 +35545,8 @@ class GodotServer {
       this.logDebug(`Picked up an editor-played run without its adapter: ${errorMessage(error)}`);
     }
     const project = this.godotBridge.getStatus().projectPath ?? null;
-    const note = project === null ? null : readEditorRunNote(project);
+    const recorded = project === null ? null : readEditorRunNote(project);
+    const note = recorded !== null && noteIsAbout(recorded, playing.play) ? recorded : null;
     const picked = {
       pid: null,
       log: new GameLog,
@@ -34863,6 +35603,31 @@ class GodotServer {
     const its = await this.tiedThroughTheTree(run, running);
     return its !== undefined && running.some((one) => one.pid === its) ? its : undefined;
   }
+  async theRunsAmong(run, fresh) {
+    if (fresh.length === 1) {
+      return fresh[0] ?? null;
+    }
+    if (fresh.length === 0 || run === null) {
+      return null;
+    }
+    const pid = run.announcedPid ?? await this.tiedThroughTheTree(run, fresh);
+    return fresh.find((one) => one.pid === pid) ?? null;
+  }
+  async tieThePlayedGame(run) {
+    if (!run.throughEditor || run.errorReport !== undefined || run.announcedPid !== undefined) {
+      return;
+    }
+    const announced = runtimesAnnounced().running;
+    if (this.announcedPidOf(run, announced) !== undefined || !stillRunning(run)) {
+      return;
+    }
+    const among = this.announcedOfTheRunsProject(run, announced).map((one) => one.pid).sort((one, other) => one - other).join(",");
+    if (among === "" || run.treeReadFor === among) {
+      return;
+    }
+    run.treeReadFor = among;
+    await this.tiedThroughTheTree(run, announced);
+  }
   async tiedThroughTheTree(run, announced) {
     if (run.announcedPid !== undefined) {
       return run.announcedPid;
@@ -34941,8 +35706,9 @@ class GodotServer {
   }
   async adoptRecordedRun() {
     const project = this.ourProject();
-    const record = project === null ? null : readRunRecord(project);
-    if (record === null || !this.couldBeOurs(record.projectPath)) {
+    const found = project === null ? [] : [readRunRecord(project), this.startedForUs(project)];
+    const record = found.reduce((newest, one) => one !== null && (newest === null || one.startedAt > newest.startedAt) ? one : newest, null);
+    if (record === null || !(this.couldBeOurs(record.projectPath) || this.couldBeOurs(record.servedBy ?? ""))) {
       return null;
     }
     const adopted = {
@@ -34952,6 +35718,7 @@ class GodotServer {
       readOffset: 0,
       projectPath: record.projectPath === "" ? null : record.projectPath,
       startedAt: record.startedAt,
+      ...record.startedBy === undefined ? {} : { startedBy: record.startedBy },
       ...record.command === undefined ? {} : { command: record.command },
       exitCode: null,
       exitSignal: null,
@@ -34972,6 +35739,13 @@ class GodotServer {
     this.activeProcess = adopted;
     return adopted;
   }
+  servedBy() {
+    const mine = this.ourProject();
+    return mine === null ? {} : { servedBy: mine };
+  }
+  startedForUs(project) {
+    return everyRunRecord().find((one) => one.servedBy !== undefined && isSameDirectory(one.servedBy, project) && !(one.projectPath !== "" && isSameDirectory(one.projectPath, project))) ?? null;
+  }
   nothingOfOursIsRunning() {
     const status = this.godotBridge.getStatus();
     const noEditor = !status.connected ? " No editor is connected, so a game the editor is playing cannot be seen from here at all:" + " editor_status says whether one is on its way, and a run of yours that is still up is" + " reachable again once it is." : "";
@@ -35063,6 +35837,7 @@ class GodotServer {
         resolve(false);
       });
     });
+    await boot.settled;
     const errors = boot.log.count("error");
     const warnings = boot.log.count("warning");
     return this.jsonTextResponse({
@@ -35137,22 +35912,20 @@ class GodotServer {
   }
   async handleEditorConsole(args) {
     const status = this.godotBridge.getStatus();
-    const projectPath = status.projectPath ?? this.ownProject ?? undefined;
-    if (projectPath === undefined) {
-      return this.createErrorResponse("No editor is connected, so there is no console to read.", [
-        "editor_status says whether one is connected and whether it may yet be",
-        "editor_launch opens one, and an editor opened here has its console captured"
-      ]);
+    const greeted = hasSaidWhoItIs(status);
+    const launched = greeted ? null : this.launchedEditor?.pid ?? null;
+    if (!greeted && launched === null && status.connected) {
+      return this.createErrorResponse("The editor has connected and has not yet said who it is, so whose console to read cannot be told yet.", ["Ask again in a moment; editor_status shows greeting until it has"]);
     }
-    const launched = status.connected ? null : this.launchedEditor?.pid ?? null;
-    if (!status.connected && launched === null) {
+    const projectPath = status.projectPath ?? this.ownProject ?? undefined;
+    if (projectPath === undefined || !greeted && launched === null) {
       return this.createErrorResponse("No editor is connected, so there is no console to read.", [
         "editor_status says whether one is connected and whether it may yet be",
         "editor_launch opens one, and an editor opened here has its console captured"
       ]);
     }
-    const editorPid = status.connected ? status.editorPid ?? null : launched;
-    const console2 = editorConsole(projectPath, editorPid, status.connected ? status.openedByAServer === true : true);
+    const editorPid = greeted ? status.editorPid ?? null : launched;
+    const console2 = editorConsole(projectPath, editorPid, greeted ? status.openedByAServer === true : true);
     if ("kind" in console2) {
       return this.createErrorResponse(theConsoleWasNotCaptured(console2, projectPath), [
         "editor_launch restart replaces this editor with one whose console is captured",
@@ -35204,6 +35977,7 @@ class GodotServer {
     if (!run) {
       return this.createErrorResponse(this.nothingOfOursIsRunning());
     }
+    await this.tieThePlayedGame(run);
     this.drainEditorOutput(run);
     this.drainTranscript(run);
     const going = await this.runStillGoing(run);
@@ -35239,7 +36013,7 @@ class GodotServer {
       notes.push(endedWithoutACode({
         throughEditor: run.throughEditor,
         announced: announced !== undefined || run.announcedPid !== undefined,
-        couldAnnounce: run.projectPath !== null && existsSync12(join18(run.projectPath, RUNTIME_AUTOLOAD.path)),
+        couldAnnounce: run.projectPath !== null && existsSync14(join19(run.projectPath, RUNTIME_AUTOLOAD.path)),
         endedHere: typeof run.endedHere === "string",
         pickedUp: run.pickedUp === true
       }));
@@ -35247,6 +36021,9 @@ class GodotServer {
     if (run.pickedUpPlaying === true) {
       notes.push(run.transcript !== null ? "The editor was already playing this when this server reached it, and what it printed before that has been read back from its transcript. It is the run the editor is holding now, which is the one the debug_* tools answer for." : run.consoleFromReport === true ? "The editor was already playing this when this server reached it, and the server that started it left no transcript, so what is below was read back from the file the game's runtime writes its console to, which begins where the runtime started: the engine's own start-up before that is only in the editor. It is the run the editor is holding now, which is the one the debug_* tools answer for." : "The editor was already playing this when this server reached it, and the server that started it left no transcript, so this is not the run from its start: what it printed before that is only in the editor. It is the run the editor is holding now, which is the one the debug_* tools answer for.");
     }
+    if (errorsUnread(run)) {
+      notes.push("The editor plays this run and no report from its game's runtime addon has been found, so what the game raised with push_error and the engine's own errors are not counted here: the editor's debugger relays what a game prints and not what it reports. errors counts what was heard, and clean is left out rather than said. A game with the runtime addon writes that report once it announces itself.");
+    }
     if (run.consoleLost === true) {
       const back = this.dapClient?.isConnected() === true;
       notes.push(`The debug adapter this run's console arrives over went away while the run was going, so what is below has a hole in it and the counts are of what was heard rather than of what was printed. ${back ? "It is connected again, and the line marking where is in the log." : "It is still gone, so nothing further will arrive here."} The project's own user://logs/godot.log has the rest, and "no entries" here means "not heard" rather than a quiet run.`);
@@ -35262,8 +36039,9 @@ class GodotServer {
       pid: run.pid ?? announced ?? run.announcedPid ?? null,
       errors: run.log.count("error"),
       warnings: run.log.count("warning"),
-      clean: run.consoleLost === true ? undefined : run.log.count("error") === 0,
+      clean: cleanVerdict(run),
       consoleLost: run.consoleLost === true ? true : undefined,
+      errorsUnread: errorsUnread(run) ? true : undefined,
       ...hold,
       endedUnwatched: run.endedUnwatched === true ? true : undefined,
       endedBy: stillRunning(run) ? undefined : run.endedHere ?? null,
@@ -35298,6 +36076,7 @@ class GodotServer {
     if (elsewhere !== null) {
       return elsewhere;
     }
+    await this.tieThePlayedGame(stopped);
     this.drainEditorOutput(stopped);
     this.drainTranscript(stopped);
     const wasRunning = await this.runStillGoing(stopped);
@@ -35306,7 +36085,7 @@ class GodotServer {
     const children = readBoolean(args, "andChildren") === true && wasRunning ? await this.whatTheRunStarted(stopped) : null;
     this.logDebug("Stopping the running game");
     const ending = await this.endActiveGame("editor_run stop", wasRunning);
-    const refused = ending === "refused";
+    const refused = ending === "refused" || ending === "unreached";
     const ended = children === null || refused ? null : endChildrenAmong(children);
     if (wasRunning && !refused) {
       for (const pid of new Set([endedPid, announcedPid])) {
@@ -35321,13 +36100,14 @@ class GodotServer {
       endedPid,
       throughEditor: stopped.throughEditor,
       exitSignal: stopped.exitSignal,
-      errors: stopped.log.count("error")
+      clean: cleanVerdict(stopped)
     });
     return this.jsonTextResponse({
       stopped: verdict.stopped,
       through: stopped.throughEditor ? "editor" : "gdharness",
       endedPid: verdict.endedPid,
       notSignalled: verdict.notSignalled,
+      stillGoing: verdict.stillGoing,
       ...childrenFields(ended),
       exitedBeforeStop: !wasRunning,
       exitCode: stopped.exitCode,
@@ -35335,6 +36115,7 @@ class GodotServer {
       errors: stopped.log.count("error"),
       warnings: stopped.log.count("warning"),
       clean: verdict.clean,
+      errorsUnread: errorsUnread(stopped) ? true : undefined,
       note: verdict.withChildren ? `${verdict.note} ${aboutTheChildren(ended, stopped.throughEditor)}` : verdict.note,
       entries: forAnswer(stopped.log.select({ severity: "warning", sinceLastCall: false, limit: 200 }).entries)
     });
@@ -35384,12 +36165,13 @@ class GodotServer {
       await announcementEnded(pid);
     }
     return this.jsonTextResponse({
-      stopped: true,
+      stopped: gone,
       through: "gdharness",
-      endedPid: pid,
+      endedPid: gone ? pid : undefined,
+      stillGoing: gone ? undefined : pid,
       ...childrenFields(ended),
       exitedBeforeStop: !landed,
-      note: `${landed ? `pid ${pid} was ended: a game of this project that no server here was holding,` : `pid ${pid} had already gone when it was signalled: a game of this project that no server here was holding,`} identified by its announcement and by its command line, ${read.executable} run with --path ${read.projectPath ?? ""}. Nothing here read what it printed or holds its exit code, so neither is in this answer.${gone ? "" : ` It had not exited ${STOP_WAIT_MS / 1000} seconds after being told to, so it may still be going: editor_status says whether it is.`} ${aboutTheChildren(ended, false)}`
+      note: `${!gone ? `pid ${pid} was told to end and was still running ${STOP_WAIT_MS / 1000} seconds later, so it has not stopped: a game of this project that no server here was holding,` : landed ? `pid ${pid} was ended: a game of this project that no server here was holding,` : `pid ${pid} had already gone when it was signalled: a game of this project that no server here was holding,`} identified by its announcement and by its command line, ${read.executable} run with --path ${read.projectPath ?? ""}. Nothing here read what it printed or holds its exit code, so neither is in this answer.${gone ? "" : " editor_status says when it has gone."} ${aboutTheChildren(ended, false)}`
     });
   }
   async whatTheRunStarted(run) {
@@ -35536,7 +36318,8 @@ class GodotServer {
       }
     }
     const after = projectPath === "" || busy ? null : cachedClasses(projectPath);
-    const lost = before === null || after === null ? [] : [...before.keys()].filter((name) => !after.has(name));
+    const declaredNow = before === null || after === null ? null : declaredClasses(projectPath);
+    const lost = before === null || after === null || declaredNow === null ? [] : [...before.keys()].filter((name) => !after.has(name) && declaredNow.has(name));
     if (lost.length > 0) {
       this.noteAShortListEditor(projectPath);
     }
@@ -35547,7 +36330,12 @@ class GodotServer {
     const stillAtMissingPaths = atMissingPaths.filter((name) => !dropped.includes(name));
     const reloading = readNonEmptyString(args, "reloadScript");
     let reloaded = {};
-    if (reloading !== undefined) {
+    const reloadingSource = reloading === undefined || projectPath === "" ? null : this.sourceOfClass(projectPath, reloading);
+    if (reloading !== undefined && reloadingSource !== null && isToolScript(reloadingSource)) {
+      reloaded = {
+        problem: `${reloading} is a @tool script, which runs inside the editor, so it is not reloaded from inside a call: editor_launch restart recompiles it.`
+      };
+    } else if (reloading !== undefined) {
       try {
         const answer = asParams(await this.godotBridge.invokeTool("reload_script", { ...args, scriptPath: reloading }));
         const methods = readArray(answer, "methods");
@@ -35555,29 +36343,36 @@ class GodotServer {
           const found = readArray(answer, field);
           return found ? { [field]: found.map(String) } : {};
         };
+        const asResource = (path) => path.startsWith("res://") ? path : `res://${path.replace(/^\/+/, "")}`;
+        const script = asResource(readString(answer, "script") ?? reloading);
+        const spelling = script === asResource(reloading) ? {} : { as: script };
         const failed = answer["failed"];
         if (typeof failed === "number" && failed !== 0) {
           reloaded = {
+            ...spelling,
             ...listed("heldBefore"),
             ...listed("heldConstantsBefore"),
             problem: failedReloadNote({
-              script: reloading,
+              script,
               code: failed,
               codeName: readString(answer, "failedAs") ?? "",
               heldBefore: listed("heldBefore")["heldBefore"] ?? [],
               heldAfter: methods?.map(String) ?? [],
               constantsBefore: listed("heldConstantsBefore")["heldConstantsBefore"] ?? [],
               constantsAfter: listed("constants")["constants"] ?? [],
-              names: projectPath === "" ? [] : this.classesAScriptNames(projectPath, reloading)
+              names: projectPath === "" ? [] : this.classesAScriptNames(projectPath, script),
+              restored: typeof answer["restored"] === "boolean" ? answer["restored"] : null,
+              restoredAs: readString(answer, "restoredAs") ?? ""
             })
           };
         } else {
           reloaded = methods ? {
+            ...spelling,
             methods: methods.map(String),
             ...listed("heldBefore"),
             ...listed("constants"),
             ...listed("heldConstantsBefore")
-          } : { problem: `the editor would not say what ${reloading} has after reloading it` };
+          } : { problem: `the editor would not say what ${script} has after reloading it` };
         }
       } catch (error) {
         reloaded = { problem: `${reloading} could not be reloaded: ${errorMessage(error)}` };
@@ -35585,7 +36380,7 @@ class GodotServer {
     }
     const checked = busy ? { unseen: [] } : await this.classesTheEditorCannotSee(args);
     const unseen = checked.unseen;
-    const broughtIn = blind.unseen.map((one) => one.className).filter((name) => !unseen.some((still) => still.className === name));
+    const broughtIn = busy ? [] : blind.unseen.map((one) => one.className).filter((name) => !unseen.some((still) => still.className === name));
     const dependents = busy || projectPath === "" || broughtIn.length === 0 ? null : await this.reloadDependents(projectPath, broughtIn);
     const stillGone = lost.filter((name) => !restored.includes(name));
     const notes = [];
@@ -35599,7 +36394,7 @@ class GodotServer {
       notes.push("The scan finished and these classes are still not in the list the editor resolves against, so every use of them reads as an unknown identifier. Its walk skips a file another engine has already imported. Rescan again on its own, which is the measured cure and needs no change to the declaring script, or restart the editor with editor_launch restart.");
     }
     if (dependents !== null && dependents.notReloaded.length > 0) {
-      notes.push(`The scan brought in ${broughtIn.join(", ")}, and ${dependents.notReloaded.map((one) => one.scriptPath).join(", ")} ${dependents.notReloaded.length === 1 ? "names one of them and" : "name them and"} could not be reloaded, so the editor still holds what it compiled while it could not see the class and reports that to the language server. editor_rescan with reloadScript on each, or editor_launch restart.`);
+      notes.push(notReloadedNote(broughtIn, dependents.notReloaded));
     }
     for (const group of uidsDuplicatedOnDisk) {
       notes.push(`${group.join(" and ")} name one UID in their .uid files, so Godot keeps one path for it and every engine warns "UID duplicate detected". Delete the .uid of the one that is a copy and rescan: the editor writes it a UID of its own.`);
@@ -35614,6 +36409,7 @@ class GodotServer {
       stillWorking: busy,
       waitedMs: Date.now() - started,
       waitedForEditorScanMs: waitedForEditorMs > 0 ? waitedForEditorMs : undefined,
+      reloadedAs: reloaded.as,
       heldBeforeReload: reloaded.heldBefore,
       reloadedMethods: reloaded.methods,
       heldConstantsBeforeReload: reloaded.heldConstantsBefore,
@@ -35640,7 +36436,8 @@ class GodotServer {
       if (tool) {
         notReloaded.push({
           scriptPath,
-          problem: "a @tool script, which runs inside the editor, so it is not reloaded from here; editor_launch restart recompiles it"
+          problem: "a @tool script, which runs inside the editor, so it is not reloaded from here; editor_launch restart recompiles it",
+          tool: true
         });
         continue;
       }
@@ -35648,9 +36445,10 @@ class GodotServer {
         const answer = asParams(await this.godotBridge.invokeTool("reload_script", { scriptPath }));
         const failed = answer["failed"];
         if (typeof failed === "number" && failed !== 0) {
+          const left = answer["restored"] === true ? "" : answer["restored"] === false ? "; compiling it again from the text it was built from failed too, so the editor holds it unusable until it compiles" : "; a failed compile leaves the copy the editor holds unusable until it compiles, and this editor does not put it back";
           notReloaded.push({
             scriptPath,
-            problem: `it did not compile: Godot answered error ${failed}${readString(answer, "failedAs") ? `, ${readString(answer, "failedAs")}` : ""}`
+            problem: `it did not compile: Godot answered error ${failed}${readString(answer, "failedAs") ? `, ${readString(answer, "failedAs")}` : ""}${left}`
           });
         } else if (readArray(answer, "methods") === undefined) {
           notReloaded.push({
@@ -35722,6 +36520,35 @@ class GodotServer {
       }
     };
   }
+  async handleCreateScript(args) {
+    const project = this.project(args);
+    if (!project.ok) {
+      return project.response;
+    }
+    const contained = this.containProjectFiles(args);
+    if (!contained.ok) {
+      return contained.response;
+    }
+    const { op: _op, projectPath: _projectPath, ...params } = contained.value;
+    const created = await this.operation("create_script", params, project.value.path);
+    const declared = created.ok ? readString(created.payload, "class_name") ?? "" : "";
+    if (!created.ok || declared === "") {
+      return this.answer(created);
+    }
+    const rebuilt = await this.rebuildClassCache(project.value.path);
+    const registered = cachedClasses(project.value.path)?.get(declared) === readString(created.payload, "full_path");
+    const answered = this.answer({
+      ...created,
+      payload: {
+        ...created.payload,
+        registered,
+        ...registered ? {} : {
+          registrationNote: rebuilt.ok ? `The class list was rebuilt and does not hold ${declared} at this script, so nothing started next resolves it by name. project_import refresh_classes says what the list holds and why.` : `The class list could not be rebuilt, so nothing started next resolves ${declared} by name: ${rebuilt.message}`
+        }
+      }
+    });
+    return this.godotBridge.isConnected() ? await this.alsoSayWhatTheEditorCannotSee(answered, args) : answered;
+  }
   async alsoSayWhatTheEditorCannotSee(answered, args) {
     const first = answered.content[0];
     if (answered.isError || first?.type !== "text" || typeof first.text !== "string") {
@@ -35794,7 +36621,7 @@ class GodotServer {
       ]);
     }
     try {
-      return this.jsonTextResponse(markIfStale(await this.godotBridge.invokeTool(toolName, args), this.godotBridge.getStatus().addonVersion, SERVER_VERSION, this.godotBridge.getStatus().addonDigest, shippedEditorDigest()));
+      return this.jsonTextResponse(markIfStale(await this.godotBridge.invokeTool(toolName, args), this.godotBridge.getStatus().addonVersion, SERVER_VERSION, this.godotBridge.getStatus().addonDigest, shippedEditorDigest(), this.editorCodeOnDisk()));
     } catch (error) {
       return this.createErrorResponse(`The editor answered ${toolName} with an error: ${errorMessage(error)}`);
     }
@@ -35850,7 +36677,7 @@ class GodotServer {
   async ownRunOnItsWay(projectPath, budgetMs) {
     const run = await this.currentRun();
     const project = projectPath ?? run?.projectPath ?? null;
-    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync12(join18(project, RUNTIME_AUTOLOAD.path)) || !await this.runStillGoing(run)) {
+    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync14(join19(project, RUNTIME_AUTOLOAD.path)) || !await this.runStillGoing(run)) {
       return null;
     }
     const already = runtimesAnnounced().running;
@@ -35874,11 +36701,15 @@ class GodotServer {
       const seconds = Math.round((Date.now() - run.startedAt) / 1000);
       return `The game this server started (${which}) has been running for ${seconds}s and has not announced its runtime, so there is nothing to talk to. A game that keeps the runtime off, as a project's own loader can for some scenes, never announces; editor_output says what it has printed.`;
     }
-    const endpoint = await announcedSince(project, new Set(already.map((one) => one.pid)), {
+    const fresh = await announcedSince(project, new Set(already.map((one) => one.pid)), {
       budgetMs: Math.min(budgetMs, remaining),
       accept: (one) => this.isTheGameOf(this.activeProcess, one, project),
       giveUp: () => this.activeProcess !== run || this.dapClient?.isStopped() === true || !stillRunning(run)
     });
+    const endpoint = await this.theRunsAmong(run, fresh);
+    if (fresh.length > 0 && endpoint === null) {
+      return null;
+    }
     if (endpoint !== null) {
       const tiedMeanwhile = () => run.announcedPid !== undefined;
       if (!tiedMeanwhile()) {
@@ -35930,7 +36761,7 @@ class GodotServer {
       }
     }
     const screenshotDir = expectsScreenshot ? scratchDirectory("runtime-screenshot") : null;
-    const screenshotPath = screenshotDir ? join18(screenshotDir, "capture.png") : null;
+    const screenshotPath = screenshotDir ? join19(screenshotDir, "capture.png") : null;
     try {
       const reply = await runtimeRequest(choice.endpoint, command, screenshotPath ? { ...params, output_path: screenshotPath } : params, timeoutMs, !expectsScreenshot);
       if (!reply.ok && reply.requestId !== undefined) {
@@ -35971,7 +36802,7 @@ class GodotServer {
             type: "text",
             text: `Screenshot captured: ${dimensions}${chosenAmongSeveral ? ` from pid ${own}, the game this server holds` : ""}${saveTo === null ? "" : `. Saved to ${saveTo}`}`
           },
-          { type: "image", data: readFileSync17(screenshotPath).toString("base64"), mimeType: "image/png" }
+          { type: "image", data: readFileSync18(screenshotPath).toString("base64"), mimeType: "image/png" }
         ]
       };
     } finally {
@@ -36068,6 +36899,7 @@ class GodotServer {
   }
 }
 async function runGodotServer() {
+  delete process.env[EDITOR_PID_VARIABLE];
   const server = new GodotServer;
   await server.run();
 }