gdharness 1.1.21 → 1.1.22

package/build/index.js

@@ -10201,27 +10201,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;
@@ -24914,6 +24914,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 {
@@ -25620,13 +25626,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));
   }
@@ -26033,6 +26039,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 +26082,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 +26289,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 +26310,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 +26559,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 +26583,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 +26762,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 +26779,7 @@ class GodotDAPClient {
         text: said(body, "text")
       };
       this.holdKnown = true;
+      this.stops += 1;
       return;
     }
     if (eventName === "continued") {
@@ -26746,20 +26796,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 +26896,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 +26943,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 +26959,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 +26971,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 +26990,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 +27015,16 @@ class GodotDAPClient {
     this.halt = null;
     this.holdKnown = true;
   }
-  async stepOver(threadId) {
+  async step(command) {
     await this.attach();
-    const resolvedThreadId = await this.resolveThreadId(threadId);
-    await this.sendRequest("next", { threadId: resolvedThreadId });
-  }
-  async stepInto(threadId) {
-    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 +27050,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 +27071,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 +27137,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 +27165,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 +27182,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 +27197,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 +27564,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";
@@ -28148,10 +28271,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 +28398,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 +28406,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 reported(problems) {
+  const omitted = Math.max(0, problems.length - MESSAGES_KEPT);
+  return omitted === 0 ? { messages: problems } : { messages: problems.slice(omitted), messagesOmitted: omitted };
 }
-function reason(stdout, stderr) {
-  const own = stderr.split(/\r?\n/).filter((line) => line.startsWith("[ERROR] ")).map((line) => line.slice("[ERROR] ".length));
+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 +28497,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 +28535,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)
     };
-  } finally {
-    discard(paramsDir);
   }
-  const payload = lastJsonObject(stdout);
-  if (payload === null) {
+  if (answer.kind === "none") {
+    const ending = ran.exitCode === 0 && ran.failure === null ? "produced no result" : `failed (${howItEnded(ran)})`;
     return {
       ok: false,
-      message: `${operation} produced no result: ${reason(stdout, stderr)}`,
-      messages: problems(stderr)
+      message: `${operation} ${ending}: ${reason(ran.log, problems)}`,
+      ...reported(problems)
+    };
+  }
+  const fault = scriptFault(problems, engine.script);
+  if (fault !== undefined) {
+    return {
+      ok: false,
+      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 +28792,17 @@ 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;
     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") - failures),
+      hookErrors: Math.max(0, count(suite.attributes, "errors") - errors),
       skipped: cases.filter((entry) => entry.status === "skipped").length,
       time: count(suite.attributes, "time"),
       cases
@@ -28637,13 +28813,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 +28915,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 +28934,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 +28958,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 +28993,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 +29022,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 +29039,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 +29139,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 +29214,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 +29320,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 +29353,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 +29443,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 +29499,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 +29545,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 +29554,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 +29568,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 +29610,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 +29641,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 +29658,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,14 +29678,14 @@ 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"));
+  return existsSync12(join15(directory, ".gdignore"));
 }
 var ASSET_EXTENSIONS = new Set(["png", "jpg", "jpeg", "webp", "svg", "ttf", "otf", "wav", "mp3", "ogg"]);
 function projectStructure(projectPath) {
@@ -29458,7 +29699,7 @@ 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") {
@@ -29489,14 +29730,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);
       }
     }
@@ -29531,7 +29772,7 @@ 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;
@@ -29542,7 +29783,7 @@ function searchProject(projectPath, options) {
       }
       result.summary.files_searched += 1;
       const matches = [];
-      for (const [index, line] of readFileSync12(entryPath, "utf8").split(`
+      for (const [index, line] of readFileSync13(entryPath, "utf8").split(`
 `).entries()) {
         if (full()) {
           break;
@@ -29565,7 +29806,7 @@ function searchProject(projectPath, options) {
 }
 
 // src/resources.ts
-import { readFileSync as readFileSync13 } from "node:fs";
+import { readFileSync as readFileSync14 } from "node:fs";
 import { extname, resolve as resolve4 } from "node:path";
 var STATIC_RESOURCES = [
   {
@@ -29760,7 +30001,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 +30010,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 +30047,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 +30064,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 +30086,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 realpathSync4,
   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(realpathSync4.native(at), ...missing);
     } catch {
-      const parent = dirname9(at);
+      const parent = dirname10(at);
       if (parent === at) {
         return path;
       }
@@ -29885,16 +30126,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 +30146,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 +30156,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 +30170,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 +30180,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 +30192,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 +30210,7 @@ function everyRunRecord() {
 function recordAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync15(path, "utf8"));
+    parsed = JSON.parse(readFileSync16(path, "utf8"));
   } catch {
     return null;
   }
@@ -30010,7 +30256,7 @@ async function runningAs(pid) {
     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();
@@ -30139,7 +30385,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 +30415,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;
     }
@@ -30183,16 +30429,16 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
 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 +30455,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");
 }
@@ -30239,14 +30485,14 @@ function shippedEditorDigest() {
   return shippedDigest ?? undefined;
 }
 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;
 }
 
@@ -30299,7 +30545,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 +30700,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 +30723,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 +30750,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 +30789,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 +30838,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 +30902,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 +30930,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 +30948,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 +30962,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 +31053,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"],
@@ -30985,7 +31260,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",
@@ -31049,7 +31324,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"]
@@ -31195,7 +31470,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 +31482,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 +31497,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",
@@ -31300,7 +31575,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 +31608,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 +31652,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 +31665,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: {
@@ -31478,7 +31753,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 +31764,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,8 +31830,8 @@ 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 run4 = promisify5(execFile5);
+var __dirname2 = dirname12(fileURLToPath4(import.meta.url));
 var EDITOR_RESTART_TIMEOUT_MS = 90000;
 var HOLD_PING_MS = 2000;
 var SLOWEST_FRAME_RATE = 20;
@@ -31570,16 +31845,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 +31885,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 +31913,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 +31967,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,
@@ -31701,13 +31991,13 @@ function stopVerdict(stop) {
   return {
     stopped: true,
     endedPid: stop.endedPid,
-    clean: stop.errors === 0,
+    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.`}${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.`}`,
     withChildren: true
   };
 }
 function endedPreviousRun(ended) {
-  if (ended === null || ended.ending === "refused") {
+  if (ended === null || ended.ending === "refused" || ended.ending === "unreached") {
     return;
   }
   return ended.pid ?? true;
@@ -31790,6 +32080,9 @@ 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.`;
   }
+  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.`;
+  }
   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}`;
 }
@@ -31919,6 +32212,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 +32225,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 +32356,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 +32404,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 +32418,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 +32426,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 +32451,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;
@@ -32617,6 +32951,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 +33124,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 +33196,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 +33407,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 +33478,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 +33529,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 +33585,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 +33615,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 +33661,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 +33744,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 +33768,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,7 +33785,7 @@ 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);
   }
@@ -33450,18 +33829,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 +33848,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 +33871,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 +33937,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 +33965,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 +33985,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 +34022,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 +34047,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 +34062,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 +34076,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 +34088,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"
       ]);
@@ -33760,11 +34130,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 +34190,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;
     }
@@ -34012,7 +34382,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 +34479,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;
     }
@@ -34271,6 +34642,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 +34743,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 +34752,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 +34776,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 +34872,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 +34993,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 +35007,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 +35037,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";
@@ -34674,7 +35086,7 @@ class GodotServer {
     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 +35126,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 +35135,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();
@@ -34806,7 +35238,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 +35296,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;
@@ -35063,6 +35521,7 @@ class GodotServer {
         resolve(false);
       });
     });
+    await boot.settled;
     const errors = boot.log.count("error");
     const warnings = boot.log.count("warning");
     return this.jsonTextResponse({
@@ -35204,6 +35663,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 +35699,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 +35707,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 +35725,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 +35762,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 +35771,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,7 +35786,7 @@ class GodotServer {
       endedPid,
       throughEditor: stopped.throughEditor,
       exitSignal: stopped.exitSignal,
-      errors: stopped.log.count("error")
+      clean: cleanVerdict(stopped)
     });
     return this.jsonTextResponse({
       stopped: verdict.stopped,
@@ -35335,6 +35800,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)
     });
@@ -35547,7 +36013,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 +36026,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)}` };
@@ -35599,7 +36077,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 +36092,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 +36119,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 +36128,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 +36203,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") {
@@ -35850,7 +36360,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 +36384,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 +36444,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 +36485,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 {