gdharness 1.1.21 → 1.1.23

package/build/cli.js

@@ -662,7 +662,7 @@ function environmentFor(options, variables = process.env) {
   const base = options.savesIn === undefined ? { ...variables } : userDataIn(options.savesIn, variables);
   return { ...base, ...options.env, GDHARNESS_RUNTIME_DIR: options.runtimeDirectory };
 }
-var OPENED_BY_A_SERVER = "GDHARNESS_OPENED_BY_A_SERVER", RESERVED_VARIABLE_PREFIX = "GDHARNESS_", SAVES_NOT_MOVED_NOTE = "On macOS the engine reads user:// off HOME and ignores the variables that move it elsewhere, measured on Godot 4.7.2, so this run wrote its saves where the player keeps theirs. A suite that saves a game has written into the same folder as the copy being played, and one that tidies up after itself may have removed real saves.";
+var OPENED_BY_A_SERVER = "GDHARNESS_OPENED_BY_A_SERVER", EDITOR_PID_VARIABLE = "GDHARNESS_EDITOR_PID", RESERVED_VARIABLE_PREFIX = "GDHARNESS_", SAVES_NOT_MOVED_NOTE = "On macOS the engine reads user:// off HOME and ignores the variables that move it elsewhere, measured on Godot 4.7.2, so this run wrote its saves where the player keeps theirs. A suite that saves a game has written into the same folder as the copy being played, and one that tidies up after itself may have removed real saves.";
 
 // src/godot-path.ts
 import { execFile as execFile2 } from "node:child_process";
@@ -7712,6 +7712,14 @@ function alongside(execPath, name) {
 }
 var init_runner = () => {};
 
+// src/dictionary.ts
+function emptyRecord() {
+  return Object.create(null);
+}
+function dictionary(entries) {
+  return Object.assign(emptyRecord(), entries);
+}
+
 // src/call-signal.ts
 import { AsyncLocalStorage } from "node:async_hooks";
 function withCallSignal(signal, answer) {
@@ -7725,14 +7733,6 @@ var init_call_signal = __esm(() => {
   current = new AsyncLocalStorage;
 });
 
-// src/dictionary.ts
-function emptyRecord() {
-  return Object.create(null);
-}
-function dictionary(entries) {
-  return Object.assign(emptyRecord(), entries);
-}
-
 // src/game-log.ts
 import { StringDecoder } from "node:string_decoder";
 function announced(line) {
@@ -7850,6 +7850,51 @@ var init_game_log = __esm(() => {
   };
 });
 
+// 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}`;
+}
+var init_engine_run = __esm(() => {
+  init_call_signal();
+  init_game_log();
+});
+
 // src/reimport.ts
 import { createHash } from "node:crypto";
 import { existsSync as existsSync5, readFileSync as readFileSync3, rmSync as rmSync3, statSync as statSync2, utimesSync, writeFileSync as writeFileSync3 } from "node:fs";
@@ -7993,10 +8038,8 @@ var init_scratch = __esm(() => {
 });
 
 // src/headless.ts
-import { execFile as execFile3 } from "node:child_process";
-import { writeFileSync as writeFileSync4 } from "node:fs";
-import { join as join7 } from "node:path";
-import { promisify as promisify3 } from "node:util";
+import { existsSync as existsSync7, readFileSync as readFileSync4, realpathSync, writeFileSync as writeFileSync4 } from "node:fs";
+import { dirname as dirname4, join as join7 } from "node:path";
 function snakeCased(params) {
   const result = emptyRecord();
   for (const [key, value] of Object.entries(params)) {
@@ -8005,34 +8048,55 @@ 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;
+function problemsIn(log) {
+  return log.everything().flatMap((entry) => {
+    if (entry.severity !== "info") {
+      return [entry];
+    }
+    if (entry.source === "stderr" && entry.text.startsWith(OWN_ERROR)) {
+      return [{ ...entry, severity: "error", text: entry.text.slice(OWN_ERROR.length) }];
+    }
+    return [];
+  });
 }
-function reason(stdout, stderr) {
-  const own = stderr.split(/\r?\n/).filter((line) => line.startsWith("[ERROR] ")).map((line) => line.slice("[ERROR] ".length));
+function reported(problems) {
+  const omitted = Math.max(0, problems.length - MESSAGES_KEPT);
+  return omitted === 0 ? { messages: problems } : { messages: problems.slice(omitted), messagesOmitted: omitted };
+}
+function reason(log, problems) {
+  const own = log.everything().filter((entry) => entry.source === "stderr" && entry.severity === "info" && entry.text.startsWith(OWN_ERROR));
   if (own.length > 0) {
-    return own.join("; ");
+    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 engine = problems(stderr).filter((entry) => entry.severity === "error").map((entry) => entry.text);
-  if (engine.length > 0) {
-    return engine.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(dirname4(script)), spelled(resolvedOr(dirname4(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 realpathSync.native(path);
+  } catch {
+    return path;
   }
-  return stdout.trim().split(/\r?\n/).at(-1) ?? "no output at all";
 }
 function librariesNotCopied(messages) {
   const found = new Set;
@@ -8072,30 +8136,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", join7(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",
+      join7(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 = join7(paramsDir, `${operation}.json`);
+  const answerFile = join7(paramsDir, "answer.json");
   writeFileSync4(paramsFile, JSON.stringify(snakeCased(params)), "utf8");
   const args = [
     "--headless",
@@ -8107,50 +8174,73 @@ async function runOperation(engine, operation, params, projectPath) {
     engine.script,
     operation,
     `@file:${paramsFile}`,
+    answerFile,
     ...engine.debug ? ["--debug-godot"] : []
   ];
-  let stdout;
-  let stderr;
+  let ran;
+  let answer;
   try {
-    ({ stdout, stderr } = await run3(engine.godotPath, args, { signal: callSignal() }));
-  } catch (error) {
-    if (error instanceof Error && "stdout" in error && "stderr" in error) {
-      const failed = error;
-      return {
-        ok: false,
-        message: `${operation} failed (exit ${failed.code ?? "unknown"}): ${reason(failed.stdout, failed.stderr)}`,
-        messages: problems(failed.stderr)
-      };
-    }
+    ran = await runEngine(engine.godotPath, args);
+    answer = answerIn(answerFile);
+  } finally {
+    discard(paramsDir);
+  }
+  const problems = problemsIn(ran.log);
+  if (answer.kind === "unreadable") {
     return {
       ok: false,
-      message: `${operation} could not be run: ${error instanceof Error ? error.message : String(error)}`,
-      messages: []
+      message: `${operation} wrote an answer that could not be read (${answer.why})`,
+      ...reported(problems)
+    };
+  }
+  if (answer.kind === "none") {
+    const ending = ran.exitCode === 0 && ran.failure === null ? "produced no result" : `failed (${howItEnded(ran)})`;
+    return {
+      ok: false,
+      message: `${operation} ${ending}: ${reason(ran.log, problems)}`,
+      ...reported(problems)
     };
-  } finally {
-    discard(paramsDir);
   }
-  const payload = lastJsonObject(stdout);
-  if (payload === null) {
+  const fault = scriptFault(problems, engine.script);
+  if (fault !== undefined) {
     return {
       ok: false,
-      message: `${operation} produced no result: ${reason(stdout, stderr)}`,
-      messages: problems(stderr)
+      message: `${operation} hit an error in the operations script, so its answer is left out: part of it was ` + `never computed. ${fault.text} (${fault.detail[0]?.slice("at: ".length) ?? "no location given"})`,
+      ...reported(problems)
+    };
+  }
+  const afterAnswer = ran.exitCode === 0 && ran.failure === null ? undefined : `The operation finished and wrote this answer, and then the engine did not exit cleanly (${howItEnded(ran)}). Anything it reported on the way out is under engine_messages.`;
+  return {
+    ok: true,
+    payload: answer.payload,
+    ...reported(problems),
+    ...afterAnswer === undefined ? {} : { afterAnswer }
+  };
+}
+function answerIn(file) {
+  if (!existsSync7(file)) {
+    return { kind: "none" };
+  }
+  const text = readFileSync4(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) };
 }
-var run3;
+var OWN_ERROR = "[ERROR] ", MESSAGES_KEPT = 200, ERRORS_NAMED = 3;
 var init_headless = __esm(() => {
-  init_call_signal();
-  init_game_log();
+  init_engine_run();
   init_reimport();
   init_scratch();
-  run3 = promisify3(execFile3);
 });
 
 // src/update-check.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync5 } from "node:fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "node:fs";
 import { homedir as homedir3, tmpdir as tmpdir2 } from "node:os";
 import { join as join8 } from "node:path";
 function packageUrl(root) {
@@ -8192,10 +8282,10 @@ function cacheFile(environment = process.env) {
 }
 function readCache(path) {
   try {
-    if (!existsSync7(path)) {
+    if (!existsSync8(path)) {
       return null;
     }
-    const parsed = JSON.parse(readFileSync4(path, "utf8"));
+    const parsed = JSON.parse(readFileSync5(path, "utf8"));
     if (typeof parsed !== "object" || parsed === null) {
       return null;
     }
@@ -8343,7 +8433,7 @@ var init_update_check = __esm(() => {
 });
 
 // src/server-version.ts
-import { readFileSync as readFileSync5 } from "node:fs";
+import { readFileSync as readFileSync6 } from "node:fs";
 function editorIsStale(addonVersion, serverVersion, addonDigest, shippedDigest) {
   if (addonDigest !== undefined && addonDigest !== "" && shippedDigest !== undefined) {
     return addonDigest !== shippedDigest;
@@ -8356,23 +8446,24 @@ function sameCodeNote(addonVersion, serverVersion, addonDigest, shippedDigest) {
   }
   return `The editor loaded the ${addonVersion} addons, which are the same code this ${serverVersion} server ships, so nothing needs restarting; addonVersion changes at the next editor start.`;
 }
-function addonMismatch(addonVersion, serverVersion, addonDigest, shippedDigest) {
+function addonMismatch(addonVersion, serverVersion, addonDigest, shippedDigest, onDisk) {
   if (!editorIsStale(addonVersion, serverVersion, addonDigest, shippedDigest)) {
     return;
   }
   const reported = addonVersion ?? "";
+  const restart = onDisk !== undefined && onDisk !== shippedDigest ? `The project's own addons are not this server's either, so a restart would load the same code again: gdharness upgrade in the project installs the ${serverVersion} addons, and editor_launch restart then picks them up.` : "Restart it with editor_launch restart to pick this one up.";
   if (reported === serverVersion) {
-    return `The editor is running a different build of the ${reported} addon from the one this server ships. Restart it with editor_launch restart to pick this one up.`;
+    return `The editor is running a different build of the ${reported} addon from the one this server ships. ${restart}`;
   }
   const editor = reported === "" ? UNVERSIONED : `the ${reported} addon`;
   const both = `The editor is running ${editor} while this server ships ${serverVersion}.`;
   if (reported !== "" && isNewer(reported, serverVersion)) {
     return `${both} This server is the older half: reconnect it in your harness so it spawns ${reported}.`;
   }
-  return `${both} Restart it with editor_launch restart to pick the new one up.`;
+  return `${both} ${restart}`;
 }
-function markIfStale(answer, addonVersion, serverVersion, addonDigest, shippedDigest) {
-  const staleNote = addonMismatch(addonVersion, serverVersion, addonDigest, shippedDigest);
+function markIfStale(answer, addonVersion, serverVersion, addonDigest, shippedDigest, onDisk) {
+  const staleNote = addonMismatch(addonVersion, serverVersion, addonDigest, shippedDigest, onDisk);
   if (staleNote === undefined || typeof answer !== "object" || answer === null || Array.isArray(answer)) {
     return answer;
   }
@@ -8385,7 +8476,7 @@ var init_server_version = __esm(() => {
   GODOT_DEBUG_MODE_DEFAULT = process.env["GODOT_DEBUG"] === "true" || DEBUG_MODE;
   SERVER_VERSION = (() => {
     try {
-      const pkg = JSON.parse(readFileSync5(new URL("../package.json", import.meta.url), "utf8"));
+      const pkg = JSON.parse(readFileSync6(new URL("../package.json", import.meta.url), "utf8"));
       return typeof pkg.version === "string" ? pkg.version : "0.0.0";
     } catch {
       return "0.0.0";
@@ -8518,9 +8609,79 @@ var init_issues = __esm(() => {
   ENHANCEMENT_URL = `${NEW_ISSUE}?template=feature_request.md`;
 });
 
+// src/paths.ts
+import { realpathSync as realpathSync2 } from "node:fs";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+function realPathOr(path) {
+  try {
+    return realpathSync2.native(path);
+  } catch {
+    return path;
+  }
+}
+function isSameDirectory(onePath, otherPath) {
+  return relative(realPathOr(resolve(onePath)), realPathOr(resolve(otherPath))) === "";
+}
+function isWithinRoot(rootPath, candidatePath) {
+  const step = relative(resolve(rootPath), resolve(candidatePath));
+  return step !== ".." && !step.startsWith(`..${sep}`) && !isAbsolute(step);
+}
+function resolveWithinProject(projectPath, candidatePath) {
+  const trimmed = candidatePath.trim();
+  if (trimmed === "") {
+    return { ok: false, reason: "Path is empty." };
+  }
+  if (trimmed.includes("\x00")) {
+    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 {
+      ok: false,
+      reason: `Path '${trimmed}' uses the '${scheme[0]}' scheme, which names somewhere other than this project.`
+    };
+  }
+  if (withoutScheme.startsWith("/") || withoutScheme.startsWith("\\") || isAbsolute(withoutScheme)) {
+    return {
+      ok: false,
+      reason: `Path '${trimmed}' is absolute; give a path inside the project, such as 'scenes/main.tscn'.`
+    };
+  }
+  if (withoutScheme.includes(":")) {
+    return {
+      ok: false,
+      reason: `Path '${trimmed}' contains ':', which no file inside a project is named with.`
+    };
+  }
+  const root = resolve(projectPath);
+  const absolutePath = resolve(root, withoutScheme);
+  if (!isWithinRoot(root, absolutePath)) {
+    return { ok: false, reason: `Path '${trimmed}' resolves outside the project directory.` };
+  }
+  const relativePath = relative(root, absolutePath).split(sep).join("/");
+  if (relativePath === "") {
+    return { ok: false, reason: `Path '${trimmed}' is the project directory itself, not a file in it.` };
+  }
+  return { ok: true, absolutePath, relativePath };
+}
+var RESOURCE_SCHEME = "res://", OTHER_SCHEME;
+var init_paths = __esm(() => {
+  OTHER_SCHEME = /^[a-zA-Z][a-zA-Z\d+.-]+:\/\//;
+});
+
 // src/class-cache.ts
-import { existsSync as existsSync8, readdirSync as readdirSync3, readFileSync as readFileSync6, statSync as statSync3 } from "node:fs";
+import { existsSync as existsSync9, readdirSync as readdirSync3, readFileSync as readFileSync7, statSync as statSync3 } from "node:fs";
 import { join as join9 } from "node:path";
+function isToolScript(source) {
+  return TOOL.test(codeOf(source));
+}
 function declaredClasses(projectPath) {
   const declared = new Map;
   eachScript(projectPath, (script, source) => {
@@ -8533,7 +8694,7 @@ function declaredClasses(projectPath) {
 }
 function eachScript(projectPath, each) {
   const visit = (directory, prefix) => {
-    if (existsSync8(join9(directory, ".gdignore"))) {
+    if (existsSync9(join9(directory, ".gdignore"))) {
       return;
     }
     for (const entry of readdirSync3(directory, { withFileTypes: true })) {
@@ -8544,7 +8705,7 @@ function eachScript(projectPath, each) {
       if (entry.isDirectory()) {
         visit(path, `${prefix}${entry.name}/`);
       } else if (entry.isFile() && entry.name.endsWith(".gd")) {
-        each(`res://${prefix}${entry.name}`, readFileSync6(path, "utf8"));
+        each(`res://${prefix}${entry.name}`, readFileSync7(path, "utf8"));
       }
     }
   };
@@ -8560,7 +8721,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));
@@ -8594,11 +8755,11 @@ function codeOf(source) {
 }
 function cachedClasses(projectPath) {
   const cache = join9(projectPath, ".godot", "global_script_class_cache.cfg");
-  if (!existsSync8(cache)) {
+  if (!existsSync9(cache)) {
     return null;
   }
   const listed = new Map;
-  const text = readFileSync6(cache, "utf8");
+  const text = readFileSync7(cache, "utf8");
   for (const entry of text.matchAll(/"class":\s*&"([^"]+)"[\s\S]*?"path":\s*"([^"]+)"/g)) {
     listed.set(entry[1] ?? "", entry[2] ?? "");
   }
@@ -8767,6 +8928,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 = [
@@ -8775,7 +8949,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}`;
 }
@@ -8808,7 +8992,7 @@ function declaredSince(projectPath, paths, names, since) {
   });
 }
 function cachedAtMissingPaths(cached, projectPath) {
-  return [...cached].filter(([, path]) => path.startsWith("res://") && !existsSync8(join9(projectPath, path.slice("res://".length)))).map(([name]) => name).sort();
+  return [...cached].filter(([, path]) => path.startsWith("res://") && !existsSync9(join9(projectPath, path.slice("res://".length)))).map(([name]) => name).sort();
 }
 function staleAgainst(cached, projectPath) {
   return [...declaredClasses(projectPath)].filter(([name, path]) => cached.get(name) !== path).map(([name]) => name);
@@ -8825,9 +9009,10 @@ function unseenByEditor(projectPath, editorHolds) {
   const held = new Set(editorHolds);
   return [...declaredClasses(projectPath)].filter(([name]) => !held.has(name)).map(([className, path]) => ({ className, path })).sort((one, other) => one.className < other.className ? -1 : one.className > other.className ? 1 : 0);
 }
-var DECLARATION;
+var DECLARATION, TOOL;
 var init_class_cache = __esm(() => {
   DECLARATION = /^(?:@[a-z_]+(?:\([^)\n]*\))?\s+)*class_name\s+([A-Za-z_][A-Za-z0-9_]*)/m;
+  TOOL = /^[ \t]*(?:@[a-z_]+(?:\([^)\n]*\))?[ \t]+)*@tool\b/m;
 });
 
 // node_modules/zod/v4/core/util.js
@@ -15933,74 +16118,13 @@ var init_types = __esm(() => {
   };
 });
 
-// src/paths.ts
-import { realpathSync } from "node:fs";
-import { isAbsolute, relative, resolve, sep } from "node:path";
-function realPathOr(path) {
-  try {
-    return realpathSync.native(path);
-  } catch {
-    return path;
-  }
-}
-function isSameDirectory(onePath, otherPath) {
-  return relative(realPathOr(resolve(onePath)), realPathOr(resolve(otherPath))) === "";
-}
-function isWithinRoot(rootPath, candidatePath) {
-  const step = relative(resolve(rootPath), resolve(candidatePath));
-  return step !== ".." && !step.startsWith(`..${sep}`) && !isAbsolute(step);
-}
-function resolveWithinProject(projectPath, candidatePath) {
-  const trimmed = candidatePath.trim();
-  if (trimmed === "") {
-    return { ok: false, reason: "Path is empty." };
-  }
-  if (trimmed.includes("\x00")) {
-    return { ok: false, reason: "Path contains a null byte." };
-  }
-  const withoutScheme = trimmed.startsWith(RESOURCE_SCHEME) ? trimmed.slice(RESOURCE_SCHEME.length) : trimmed;
-  const scheme = OTHER_SCHEME.exec(withoutScheme);
-  if (scheme) {
-    return {
-      ok: false,
-      reason: `Path '${trimmed}' uses the '${scheme[0]}' scheme, which names somewhere other than this project.`
-    };
-  }
-  if (withoutScheme.startsWith("/") || withoutScheme.startsWith("\\") || isAbsolute(withoutScheme)) {
-    return {
-      ok: false,
-      reason: `Path '${trimmed}' is absolute; give a path inside the project, such as 'scenes/main.tscn'.`
-    };
-  }
-  if (withoutScheme.includes(":")) {
-    return {
-      ok: false,
-      reason: `Path '${trimmed}' contains ':', which no file inside a project is named with.`
-    };
-  }
-  const root = resolve(projectPath);
-  const absolutePath = resolve(root, withoutScheme);
-  if (!isWithinRoot(root, absolutePath)) {
-    return { ok: false, reason: `Path '${trimmed}' resolves outside the project directory.` };
-  }
-  const relativePath = relative(root, absolutePath).split(sep).join("/");
-  if (relativePath === "") {
-    return { ok: false, reason: `Path '${trimmed}' is the project directory itself, not a file in it.` };
-  }
-  return { ok: true, absolutePath, relativePath };
-}
-var RESOURCE_SCHEME = "res://", OTHER_SCHEME;
-var init_paths = __esm(() => {
-  OTHER_SCHEME = /^[a-zA-Z][a-zA-Z\d+.-]+:\/\//;
-});
-
 // src/resources.ts
-import { readFileSync as readFileSync7 } from "node:fs";
+import { readFileSync as readFileSync8, realpathSync as realpathSync3 } from "node:fs";
 import { extname, resolve as resolve2 } from "node:path";
 function ensureProjectPath(getProjectPath) {
   const projectPath = getProjectPath();
   if (!projectPath) {
-    throw new Refusal("Project path is not set. Set a Godot project path first.");
+    throw new Refusal("This server knows no project to read from: start it with GDHARNESS_PROJECT, connect an editor, or make any tool call naming a projectPath that holds project.godot.");
   }
   return resolve2(projectPath);
 }
@@ -16016,7 +16140,22 @@ function resolveProjectFile(projectPath, resourcePath) {
   if (!contained.ok) {
     throw new Refusal(contained.reason);
   }
-  return contained.absolutePath;
+  let root;
+  try {
+    root = realpathSync3.native(projectPath);
+  } catch {
+    throw new Refusal(`The project directory ${projectPath} is not there.`);
+  }
+  let real;
+  try {
+    real = realpathSync3.native(contained.absolutePath);
+  } catch {
+    throw new Refusal(`No file at ${resourcePath} in the project.`);
+  }
+  if (!isWithinRoot(root, real)) {
+    throw new Refusal(`${resourcePath} leads outside the project through a link, so it is not read.`);
+  }
+  return real;
 }
 function parseGodotUri(uri) {
   if (uri === "godot://project/info") {
@@ -16161,7 +16300,7 @@ function readResourceText(uri, getProjectPath) {
   const parsedUri = parseGodotUri(uri);
   if (parsedUri.kind === "project-info") {
     const projectFilePath = resolveProjectFile(projectPath, "project.godot");
-    const rawProject = readFileSync7(projectFilePath, "utf-8");
+    const rawProject = readFileSync8(projectFilePath, "utf-8");
     const parsedProject = parseProjectGodot(rawProject);
     return {
       mimeType: "application/json",
@@ -16170,7 +16309,7 @@ function readResourceText(uri, getProjectPath) {
   }
   const filePath = resolveProjectFile(projectPath, parsedUri.resourcePath);
   ensureAllowedExtension(parsedUri.kind, filePath);
-  const text = readFileSync7(filePath, "utf-8");
+  const text = readFileSync8(filePath, "utf-8");
   return {
     mimeType: parsedUri.kind === "script" ? "text/x-gdscript" : "text/plain",
     text
@@ -16302,16 +16441,16 @@ import { spawnSync } from "node:child_process";
 import { createHash as createHash3 } from "node:crypto";
 import {
   cpSync,
-  existsSync as existsSync9,
+  existsSync as existsSync10,
   mkdirSync as mkdirSync4,
   readdirSync as readdirSync4,
-  readFileSync as readFileSync8,
+  readFileSync as readFileSync9,
   rmdirSync,
   rmSync as rmSync5,
   statSync as statSync4,
   writeFileSync as writeFileSync6
 } from "node:fs";
-import { dirname as dirname4, join as join10 } from "node:path";
+import { dirname as dirname5, join as join10 } from "node:path";
 import { fileURLToPath } from "node:url";
 function editorAddonDigest(from = shippedAddonsDirectory()) {
   const hash = createHash3("sha256");
@@ -16327,7 +16466,7 @@ function editorAddonDigest(from = shippedAddonsDirectory()) {
       } else {
         hash.update(`${inside}
 `);
-        hash.update(readFileSync8(path));
+        hash.update(readFileSync9(path));
         hash.update(`
 `);
       }
@@ -16350,29 +16489,29 @@ function shippedEditorDigest() {
 }
 function installedEditorDigest(projectPath) {
   const marker = join10(projectPath, "addons", ADDONS[0], DIGEST_MARKER);
-  if (!existsSync9(marker)) {
+  if (!existsSync10(marker)) {
     return null;
   }
-  const said = readFileSync8(marker, "utf8").trim();
+  const said = readFileSync9(marker, "utf8").trim();
   return said === "" ? null : said;
 }
 function shippedAddonsDirectory() {
-  return join10(dirname4(fileURLToPath(import.meta.url)), "godot", "addons");
+  return join10(dirname5(fileURLToPath(import.meta.url)), "godot", "addons");
 }
 function shippedOperationsScript() {
-  return join10(dirname4(fileURLToPath(import.meta.url)), "godot", "operations", "godot_operations.gd");
+  return join10(dirname5(fileURLToPath(import.meta.url)), "godot", "operations", "godot_operations.gd");
 }
 function installAddons(projectPath, from = shippedAddonsDirectory()) {
   const installed = [];
   for (const name of ADDONS) {
     const source = join10(from, name);
-    if (!existsSync9(join10(source, name === "gdharness_runtime" ? "runtime_autoload.gd" : "plugin.cfg"))) {
+    if (!existsSync10(join10(source, name === "gdharness_runtime" ? "runtime_autoload.gd" : "plugin.cfg"))) {
       throw new Error(`The package holds no ${name} addon at ${source}.`);
     }
     const target = join10(projectPath, "addons", name);
-    const replaced = existsSync9(target);
+    const replaced = existsSync10(target);
     rmSync5(target, { recursive: true, force: true });
-    mkdirSync4(dirname4(target), { recursive: true });
+    mkdirSync4(dirname5(target), { recursive: true });
     cpSync(source, target, { recursive: true });
     writeFileSync6(join10(target, VERSION_MARKER), `${SERVER_VERSION}
 `);
@@ -16384,23 +16523,23 @@ function installAddons(projectPath, from = shippedAddonsDirectory()) {
 }
 function installedAddonVersion(projectPath) {
   const marker = join10(projectPath, "addons", ADDONS[0], VERSION_MARKER);
-  if (!existsSync9(marker)) {
+  if (!existsSync10(marker)) {
     return null;
   }
-  const said = readFileSync8(marker, "utf8").trim();
+  const said = readFileSync9(marker, "utf8").trim();
   return said === "" ? null : said;
 }
 function removeAddons(projectPath) {
   const removed = [];
   for (const name of ADDONS) {
     const target = join10(projectPath, "addons", name);
-    if (existsSync9(target)) {
+    if (existsSync10(target)) {
       rmSync5(target, { recursive: true, force: true });
       removed.push(target);
     }
   }
   const addons = join10(projectPath, "addons");
-  if (removed.length > 0 && existsSync9(addons) && readdirSync4(addons).length === 0) {
+  if (removed.length > 0 && existsSync10(addons) && readdirSync4(addons).length === 0) {
     rmdirSync(addons);
     removed.push(addons);
   }
@@ -16424,7 +16563,7 @@ function autoloadIsOurs(named) {
   return named === null || named === `res://${RUNTIME_AUTOLOAD.path}`;
 }
 async function setRuntime(engine, projectPath, on) {
-  return on ? await runOperation(engine, "add_autoload", { name: RUNTIME_AUTOLOAD.name, path: `res://${RUNTIME_AUTOLOAD.path}`, enabled: true }, projectPath) : await runOperation(engine, "remove_autoload", { name: RUNTIME_AUTOLOAD.name }, projectPath);
+  return on ? await runOperation(engine, "add_autoload", { name: RUNTIME_AUTOLOAD.name, path: `res://${RUNTIME_AUTOLOAD.path}`, global: true }, projectPath) : await runOperation(engine, "remove_autoload", { name: RUNTIME_AUTOLOAD.name }, projectPath);
 }
 function loaderAmong(projectPath, named) {
   let byName = null;
@@ -16434,7 +16573,7 @@ function loaderAmong(projectPath, named) {
     }
     let source = null;
     try {
-      source = readFileSync8(join10(projectPath, path), "utf8");
+      source = readFileSync9(join10(projectPath, path), "utf8");
     } catch {}
     if (source?.includes(RUNTIME_AUTOLOAD.path)) {
       return { name: entry, path, exists: true };
@@ -16478,8 +16617,8 @@ function inspectProject(projectPath) {
   const addons = ADDONS.map((name) => {
     const directory = join10(projectPath, "addons", name);
     const marker = join10(directory, VERSION_MARKER);
-    const installed = existsSync9(directory);
-    const version = existsSync9(marker) ? readFileSync8(marker, "utf8").trim() : null;
+    const installed = existsSync10(directory);
+    const version = existsSync10(marker) ? readFileSync9(marker, "utf8").trim() : null;
     const current = version === SERVER_VERSION;
     if (!installed) {
       problems.push(`addons/${name} is not installed; run gdharness setup`);
@@ -16488,7 +16627,7 @@ function inspectProject(projectPath) {
     }
     return { name, installed, version, current };
   });
-  const settings = parseProjectGodot(readFileSync8(join10(projectPath, "project.godot"), "utf8"));
+  const settings = parseProjectGodot(readFileSync9(join10(projectPath, "project.godot"), "utf8"));
   const pluginsEnabled = enabledPlugins(settings);
   for (const name of EDITOR_PLUGINS) {
     if (!pluginsEnabled.includes(name)) {
@@ -16504,7 +16643,7 @@ function inspectProject(projectPath) {
   const tracked = trackedByGit(projectPath, [...named.values()]);
   const addonMissing = (path) => addons.some((addon) => !addon.installed && path.startsWith(`addons/${addon.name}/`));
   for (const [name, path] of named) {
-    if (!existsSync9(join10(projectPath, path))) {
+    if (!existsSync10(join10(projectPath, path))) {
       if (!addonMissing(path)) {
         problems.push(`the ${name} autoload names res://${path}, which is not in this project, so it boots with a missing script; restore that file, or point the autoload at one that is here`);
       }
@@ -16664,7 +16803,7 @@ var init_tool_definitions = __esm(() => {
   };
   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
   };
   XY = {
@@ -16819,11 +16958,18 @@ var init_tool_definitions = __esm(() => {
         },
         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,
@@ -16835,9 +16981,15 @@ var init_tool_definitions = __esm(() => {
         },
         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." }
       },
@@ -16856,7 +17008,7 @@ var init_tool_definitions = __esm(() => {
         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"] }
@@ -16895,7 +17047,11 @@ var init_tool_definitions = __esm(() => {
           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"]
     },
@@ -16940,7 +17096,10 @@ var init_tool_definitions = __esm(() => {
           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: []
@@ -17001,11 +17160,11 @@ var init_tool_definitions = __esm(() => {
     },
     {
       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"],
@@ -17029,7 +17188,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       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,
@@ -17047,7 +17206,10 @@ var init_tool_definitions = __esm(() => {
           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"],
@@ -17058,7 +17220,10 @@ var init_tool_definitions = __esm(() => {
         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"]
+        }
       }
     },
     {
@@ -17146,13 +17311,16 @@ var init_tool_definitions = __esm(() => {
     },
     {
       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"],
@@ -17243,13 +17411,13 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "editor_launch",
-      description: "Opens the Godot editor on a project, or restarts the one already connected. The editor is an ordinary visible one on the desktop in use, and on Windows it is shown without being activated, so opening or reopening it does not take the keyboard from whatever the user is typing in. hidden: true opens it headless instead and, on Windows, on a desktop of its own, where the games it plays go too; a hidden editor serves the bridge, the language server and the debug adapter as a visible one does. A game a visible editor plays opens as a window on the desktop in use. An editor goes on serving the addon it read at startup, so restart is what puts a gdharness upgrade into effect, and nothing else here restarts one; it saves open scenes on the way out and answers with the version that came back. An editor a server opened is started again by the server, visible unless hidden: true is passed again. One opened by hand restarts itself, which only one with a window can do, because the engine hands back none of the arguments it was started with. editor_status says which editor is connected and whether it is holding an old addon. Opening a project is a save and so is closing one, which is the part that is not obvious from outside: the editor imports the project on open and writes project.godot back, and Godot writes only what differs from its own defaults, so a key named deliberately at its default value is dropped either way. A restart says which under settingsDropped in its own answer because it waits for the editor to return. An open cannot, since it answers as soon as the process exists and the save happens during the import minutes later, so editor_status carries that reading once the editor has connected. Nothing else will say a key went until something depends on one. A restart of an editor this server opened is a quit and then a launch, and this server can be ended between them, usually by the reconnect the restart was being taken for: the editor is gone and nothing replaces it. That is written down before the quit, so the next server says so under restartInterrupted in editor_status rather than waiting for an editor that is not coming, and open finishes it, saying so under finishesRestart.",
+      description: "Opens the Godot editor on a project, or restarts the one already connected. The editor is an ordinary visible one on the desktop in use, and on Windows it is shown without being activated, so opening or reopening it does not take the keyboard from whatever the user is typing in. hidden: true opens it headless instead and, on Windows, on a desktop of its own, where the games it plays go too; a hidden editor serves the bridge, the language server and the debug adapter as a visible one does. A game a visible editor plays opens as a window on the desktop in use. An editor goes on serving the addon it read at startup, so restart is what puts a gdharness upgrade into effect, and nothing else here restarts one; it saves open scenes on the way out and answers with the version that came back. An editor a server opened is started again by the server, visible unless hidden: true is passed again, once the old one has gone: it waits 90 seconds for that, or GDHARNESS_EDITOR_RESTART_TIMEOUT_MS, and an old editor still running after it is not replaced, since the new one would find its ports held. One opened by hand restarts itself, which only one with a window can do, because the engine hands back none of the arguments it was started with. editor_status says which editor is connected and whether it is holding an old addon. Opening a project is a save and so is closing one, which is the part that is not obvious from outside: the editor imports the project on open and writes project.godot back, and Godot writes only what differs from its own defaults, so a key named deliberately at its default value is dropped either way. A restart says which under settingsDropped in its own answer because it waits for the editor to return. An open cannot, since it answers as soon as the process exists and the save happens during the import minutes later, so editor_status carries that reading once the editor has connected. Nothing else will say a key went until something depends on one. A restart of an editor this server opened is a quit and then a launch, and this server can be ended between them, usually by the reconnect the restart was being taken for: the editor is gone and nothing replaces it. That is written down before the quit, so the next server says so under restartInterrupted in editor_status rather than waiting for an editor that is not coming, and open finishes it, saying so under finishesRestart. An open is refused when the editor it would start could never reach this server: a project other than the one this server serves, whose editor dials that project's own server; a project without the gdharness editor addon installed and enabled; and a project whose editor a restart is already bringing back.",
       parameters: {
         projectPath: { ...PROJECT_PATH, ops: ["open"] },
         hidden: {
           type: "boolean",
           ops: ["open", "restart"],
-          description: "Open the editor headless and, on Windows, on a desktop of its own, so no window of it or of the games it plays appears. Default false: one visible editor, shown without taking the focus."
+          description: "Open the editor headless and, on Windows, on a desktop of its own, so no window of it or of the games it plays appears. Default false: one visible editor, shown without taking the focus. On restart only for an editor a server opened; one opened by hand comes back as it was, so hidden is refused there."
         }
       },
       requires: [],
@@ -17337,7 +17505,7 @@ var init_tool_definitions = __esm(() => {
           requires: ["projectPath"]
         },
         stop: {
-          summary: "end the run and answer with what it printed last, naming the process ended under endedPid: for a run the editor plays, the number its game announced under, read at the stop rather than remembered, and the operating system hands a freed number to the next process, so it can equal the game before it. A game that started processes of its own keeps them unless andChildren says to end those too. stopped is false, with the number under notSignalled, when that number no longer answers as the process the run was started as and nothing was signalled",
+          summary: "end the run and answer with what it printed last, naming the process ended under endedPid: for a run the editor plays, the number its game announced under, read at the stop rather than remembered, and the operating system hands a freed number to the next process, so it can equal the game before it. A game that started processes of its own keeps them unless andChildren says to end those too. stopped is false, with the number under notSignalled, when that number no longer answers as the process the run was started as and nothing was signalled, and false with the number under stillGoing when what was told to end was still running ten seconds later",
           requires: []
         },
         check: {
@@ -17350,7 +17518,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       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",
@@ -17398,7 +17566,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "editor_status",
-      description: "Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and whether a game with the runtime addon is reachable: runtimeConnected counts the games of the project this server serves, and runtimes lists every game on the machine with ofThisProject saying which is which, since a game of another project is reached only by naming its projectPath. playingInEditor is null when the editor was not asked or did not answer, which is not the same as a no: with no editor connected there is nobody to ask, and an editor that does not serve the question is given a moment and then left. A game can be playing while this is null, so read it as unanswered rather than as nothing playing, and use processActive and runtimes, which come from elsewhere and do not depend on the editor answering. editor.scan says whether the editor is scanning or importing and how many milliseconds ago its last scan finished (finishedMsAgo), or is null when it did not answer: the editor rewrites the class cache just after a scan, and editor_run waits that out before starting a game, saying so under waitedForEditorScanMs. Each game under runtimes is pinged with a short wait, so one held at a breakpoint is listed as unreachable rather than making this call wait out the runtime timeout; for the run this server is reporting on, heldAt says whether that is what it is, with the same three answers editor_output gives. A game the editor played announces the editor under editorPid, and so does whatever that game started for itself; a game some other server started announces none, which is how the two are told apart when both are running from one project. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means \"not reached yet\" as often as it means \"no editor\". True is worth waiting out; false is an editor that is not there. False beside restartInterrupted is one that an editor_launch restart on a previous server asked to quit, where the launch half never ran because that server was ended in between, usually by the reconnect the restart was taken for; editor_launch open finishes it. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. settingsDropped appears here once when the editor this server opened saved project.godot on its way in, which is the same reading editor_launch restart makes in its own answer. A game that has announced itself in a protocol this server does not speak is listed under unreadable rather than left out, with the protocol it speaks and whether the server or the addon is the older half. This happens during an upgrade that moves the runtime protocol, which most do not: installing replaces the addon on disk as soon as the pin moves, while a server that is already running stays on the version it started with, so the two speak different protocols until the server is reconnected. Those games are real and running, but no tool here can reach them until the halves match, so runtimes stays empty and runtimeConnected stays false. An upgrade that leaves the protocol alone opens no such window and this list stays empty through it. addonIsStale is decided by the code of the editor addons rather than their version, so an editor started before an upgrade that left that code alone reports the older addonVersion, is not stale, and addonNote says so: it needs no restart. port is the one the editor bridge is on; when that is not the one this server was configured with, portWanted names the configured one and portNote says why it moved and, when it was the server this one replaced, which pid kept it. A server replacing another of its project that holds the configured port waits for it to stand down and takes the port over, which takes a few seconds; bridgeHandover says so while it waits, and it moves only if that server has not let go within the wait.",
+      description: "Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and whether a game with the runtime addon is reachable: runtimeConnected counts the games of the project this server serves, and runtimes lists every game on the machine with ofThisProject saying which is which, since a game of another project is reached only by naming its projectPath. playingInEditor is null when the editor was not asked or did not answer, which is not the same as a no: with no editor connected there is nobody to ask, and an editor that does not serve the question is given a moment and then left. A game can be playing while this is null, so read it as unanswered rather than as nothing playing, and use processActive and runtimes, which come from elsewhere and do not depend on the editor answering. editor.scan says whether the editor is scanning or importing and how many milliseconds ago its last scan finished (finishedMsAgo), or is null when it did not answer: the editor rewrites the class cache just after a scan, and editor_run waits that out before starting a game, saying so under waitedForEditorScanMs. Each game under runtimes is pinged with a short wait, so one held at a breakpoint is listed as unreachable rather than making this call wait out the runtime timeout; for the run this server is reporting on, heldAt says whether that is what it is, with the same three answers editor_output gives. A game the editor played announces the editor under editorPid, and so does whatever that game started for itself; a game some other server started announces none, which is how the two are told apart when both are running from one project. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means \"not reached yet\" as often as it means \"no editor\". True is worth waiting out; false is an editor that is not there. False beside restartInterrupted is one that an editor_launch restart on a previous server asked to quit, where the launch half never ran because that server was ended in between, usually by the reconnect the restart was taken for; editor_launch open finishes it. True beside restartUnderway is a restart still in progress, its server alive and within the wait for the old editor to go: the editor is coming, and opening another would put two on one project. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. settingsDropped appears here once when the editor this server opened saved project.godot on its way in, which is the same reading editor_launch restart makes in its own answer. A game that has announced itself in a protocol this server does not speak is listed under unreadable rather than left out, with the protocol it speaks and whether the server or the addon is the older half. This happens during an upgrade that moves the runtime protocol, which most do not: installing replaces the addon on disk as soon as the pin moves, while a server that is already running stays on the version it started with, so the two speak different protocols until the server is reconnected. Those games are real and running, but no tool here can reach them until the halves match, so runtimes stays empty and runtimeConnected stays false. An upgrade that leaves the protocol alone opens no such window and this list stays empty through it. addonIsStale is decided by the code of the editor addons rather than their version, so an editor started before an upgrade that left that code alone reports the older addonVersion, is not stale, and addonNote says so: it needs no restart. port is the one the editor bridge is on; when that is not the one this server was configured with, portWanted names the configured one and portNote says why it moved and, when it was the server this one replaced, which pid kept it. A server replacing another of its project that holds the configured port waits for it to stand down and takes the port over, which takes a few seconds; bridgeHandover says so while it waits, and it moves only if that server has not let go within the wait. An editor that has connected and not yet greeted, which lasts a frame and longer while it imports, reports nothing about itself: greeting says so, addonIsStale is absent rather than guessed, and a restart asked then waits for the greeting to learn who opened it. startedByAnEditor is an editor another editor started, by Godot's own restart or the project manager, which has none of the arguments a server gave the one before it; startedByAnEditorNote says what that costs.",
       parameters: {},
       requires: []
     },
@@ -17414,7 +17582,7 @@ var init_tool_definitions = __esm(() => {
         },
         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"]
@@ -17437,6 +17605,7 @@ var init_tool_definitions = __esm(() => {
             "physics2d",
             "physics3d",
             "audio",
+            "visual",
             "animation",
             "ui"
           ],
@@ -17476,7 +17645,7 @@ var init_tool_definitions = __esm(() => {
         property: {
           type: "string",
           ops: ["property", "find"],
-          description: 'property: which one to read. find: read this one off every node matched, so a panel of labels is one call rather than one per label. Colons read through what a node holds, "_game:clock:speed", which is where a game keeps what is worth asking about. A number or a key steps into a list or a map, "_game:run:roster:0:traits", which is how the lists a game keeps its state in are walked: a roster, a board, an in-tray. A packed list, such as a PackedStringArray, steps the same way. A negative number counts from the end. A step written as a call, "get_viewport():gui_get_focus_owner()", calls a method that takes no arguments and walks into what it returned, which is how a question only a method answers is read in one call: which control holds the focus in the viewport this one is in. A list or a map answers the calls that read it and take no arguments, "_game:run:board:size()" or "_game:inbox:keys()", and not those that change it, such as clear() or sort(). A step that is not there is named, and says what was there instead.'
+          description: 'property: which one to read. find: read this one off every node matched, so a panel of labels is one call rather than one per label. Colons read through what a node holds, "_game:clock:speed", which is where a game keeps what is worth asking about. A number or a key steps into a list or a map, "_game:run:roster:0:traits", which is how the lists a game keeps its state in are walked: a roster, a board, an in-tray. A packed list, such as a PackedStringArray, steps the same way. A negative number counts from the end. A step written as a call, "get_viewport():gui_get_focus_owner()", calls a method that takes no arguments and only reads (an engine method the engine marks as reading, or a game method not declared -> void, so queue_free() is refused) and walks into what it returned, which is how a question only a method answers is read in one call: which control holds the focus in the viewport this one is in. A list or a map answers the calls that read it and take no arguments, "_game:run:board:size()" or "_game:inbox:keys()", and not those that change it, such as clear() or sort(). A step that is not there is named, and says what was there instead.'
         },
         depth: {
           type: "integer",
@@ -17515,13 +17684,14 @@ var init_tool_definitions = __esm(() => {
         limit: {
           type: "integer",
           minimum: 1,
+          maximum: 5000,
           ops: ["find", "text"],
-          description: "find: the most nodes to answer with, default 100. text: the most lines, default 500, with omitted saying how many lines that left behind. A screen whose dialog sits under a long list is a screen read with omitted greater than zero, so raise this or point root at the dialog rather than reading the answer as what is on screen."
+          description: "find: the most nodes to answer with, default 100. text: the most lines, default 500, with omitted saying how many lines that left behind. At most 5000 for either. A screen whose dialog sits under a long list is a screen read with omitted greater than zero, so raise this or point root at the dialog rather than reading the answer as what is on screen."
         },
         includeHidden: {
           type: "boolean",
           ops: ["text", "find"],
-          description: "text: read hidden nodes as well, for checking that something is not showing. Default false. find: default true, since a find means the node whether or not it is drawn; false answers with what the player can actually see, which is how a panel that keeps a label for every line and hides the ones that do not is read. A node counts as hidden when anything above it is, and how many matches were left out comes back under hidden."
+          description: "text: read hidden nodes as well, for checking that something is not showing. Default false. find: default true, since a find means the node whether or not it is drawn; false answers with what the player can actually see, which is how a panel that keeps a label for every line and hides the ones that do not is read. A node counts as hidden when the engine would not draw it: a hidden Control, Node2D or Node3D above it hides it, a plain Node in between breaks that chain as it does for the engine, and a hidden canvas layer or window hides everything in it. How many matches were left out comes back under hidden."
         },
         metrics: {
           type: "array",
@@ -17560,7 +17730,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       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,
@@ -17572,12 +17742,12 @@ var init_tool_definitions = __esm(() => {
         property: {
           type: "string",
           ops: ["set"],
-          description: 'set: which one to write. Colons write through what a node holds, "_game:run:day", and a number or a key steps into a list or a map on the way, "_game:run:roster:0:name", a negative number counting from the end, and a step written as a call, "get_viewport():gui_embed_subwindows", walks through what a method taking no arguments returned. 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",
@@ -17587,7 +17757,7 @@ var init_tool_definitions = __esm(() => {
         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",
@@ -17620,7 +17790,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "runtime_capture",
-      description: "A picture of the running game: the whole screen or one viewport, as an image. Needs the game running with a window. A capture asked for before the game's first frame is drawn waits for that frame, since the game announces itself before it and the viewport holds nothing it drew until then.",
+      description: "A picture of the running game: the whole screen or one viewport, as an image. The whole screen includes the game's own dialogs and popups where they sit, also when a project opens them as windows of their own (subwindows not embedded). Needs the game running with a window. A capture asked for before the game's first frame is drawn waits for that frame, since the game announces itself before it and the viewport holds nothing it drew until then.",
       parameters: {
         projectPath: RUNNING_PROJECT_PATH,
         pid: RUNNING_PID,
@@ -17665,7 +17835,7 @@ var init_tool_definitions = __esm(() => {
         says: {
           type: "string",
           ops: ["click"],
-          description: "click: the words on the control to click, matched the way runtime_inspect find matches says (a plain word is contained in the text, a pattern with * or ? is a glob over it, and | separates alternatives), among the controls on screen, and pressed in the same frame it was found in, so a panel rebuilding between a find and a click cannot free it first. Words on a label inside a button press the button. A control with something drawn over its centre that would take the pointer, such as a screen shown over it, 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",
@@ -17698,7 +17868,7 @@ var init_tool_definitions = __esm(() => {
         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",
@@ -17742,11 +17912,11 @@ var init_tool_definitions = __esm(() => {
       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"] },
@@ -17755,7 +17925,7 @@ var init_tool_definitions = __esm(() => {
           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: {
@@ -17794,7 +17964,7 @@ var init_tool_definitions = __esm(() => {
         },
         value: {
           ops: ["until"],
-          description: "until: the value to wait for, fitted to the property's type. On a property holding an object, whether declared to or untyped and holding one or null, the text null means null. One declared to hold an object refuses any value other than null, since it can never hold it."
+          description: "until: the value to wait for, fitted to the property's type and compared at the precision the property keeps, so -1.1 meets a 32-bit float holding -1.10000002. A value the property would have to cut is refused: a fraction on a whole number, a number other than 0 or 1 on a bool. On a property holding an object, whether declared to or untyped and holding one or null, the text null means null. One declared to hold an object refuses any value other than null, since it can never hold it."
         },
         says: {
           type: "string",
@@ -17843,7 +18013,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       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: {
@@ -17854,12 +18024,12 @@ var init_tool_definitions = __esm(() => {
     },
     {
       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: [],
@@ -32626,10 +32796,10 @@ var init_stdio2 = __esm(() => {
 });
 
 // src/runtime-client.ts
-import { existsSync as existsSync11, readdirSync as readdirSync6, readFileSync as readFileSync10, statSync as statSync5, unlinkSync } from "node:fs";
+import { existsSync as existsSync12, readdirSync as readdirSync6, readFileSync as readFileSync11, statSync as statSync5, unlinkSync } from "node:fs";
 import { createConnection } from "node:net";
 import { tmpdir as tmpdir3 } from "node:os";
-import { dirname as dirname7, join as join13, resolve as resolve3 } from "node:path";
+import { dirname as dirname8, join as join13, resolve as resolve3 } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 function runtimeDirectory(variables = process.env) {
   const explicit = envValue("GDHARNESS_RUNTIME_DIR", variables);
@@ -32650,7 +32820,7 @@ function runtimeDirectories(variables = process.env) {
 function errorReportOf(pid, directories = runtimeDirectories()) {
   for (const directory of directories) {
     const path = join13(directory, `runtime-${pid}.log`);
-    if (existsSync11(path)) {
+    if (existsSync12(path)) {
       return path;
     }
   }
@@ -32681,7 +32851,7 @@ function reportAlreadyInTranscript(transcript, report) {
 function parseAnnouncement(file, pid) {
   let fields;
   try {
-    fields = asParams(JSON.parse(readFileSync10(file, "utf8")));
+    fields = asParams(JSON.parse(readFileSync11(file, "utf8")));
   } catch {
     return { kind: "rubbish" };
   }
@@ -32718,6 +32888,12 @@ function parseAnnouncement(file, pid) {
     }
   };
 }
+function dialAddress(address) {
+  if (address === "*" || address === "0.0.0.0") {
+    return "127.0.0.1";
+  }
+  return address === "::" ? "::1" : address;
+}
 function runtimesAnnounced(directories = runtimeDirectories()) {
   const running = new Map;
   const unspoken = new Map;
@@ -32739,7 +32915,7 @@ function discoverRuntimes(directories = runtimeDirectories()) {
 function wentAway(file, pid) {
   let project = "";
   try {
-    const fields = asParams(JSON.parse(readFileSync10(file, "utf8")));
+    const fields = asParams(JSON.parse(readFileSync11(file, "utf8")));
     project = readString(readParams(fields, "project") ?? {}, "path") ?? "";
   } catch {
     return;
@@ -32782,7 +32958,7 @@ function strangersAmong(candidates, now, startTimes = startTimesOf) {
   }).map((one) => one.file));
 }
 function announcedIn(directory) {
-  if (!existsSync11(directory)) {
+  if (!existsSync12(directory)) {
     return [];
   }
   const found = [];
@@ -32828,14 +33004,14 @@ function announcedIn(directory) {
   const held = new Set(entries.map((one) => one.file));
   const here = join13(directory, ".");
   for (const file of verdicts.keys()) {
-    if (dirname7(file) === here && !held.has(file)) {
+    if (dirname8(file) === here && !held.has(file)) {
       verdicts.delete(file);
     }
   }
   return found;
 }
 async function announcementEnded(pid, directories = runtimeDirectories()) {
-  const files = directories.map((directory) => join13(directory, `runtime-${pid}.json`)).filter((file) => existsSync11(file));
+  const files = directories.map((directory) => join13(directory, `runtime-${pid}.json`)).filter((file) => existsSync12(file));
   const first = files[0];
   if (first === undefined) {
     return;
@@ -32870,13 +33046,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));
   }
@@ -33007,7 +33183,7 @@ function runtimeRequest(endpoint, command, params, timeoutMs, keepListening = fa
     let late = false;
     let buffered = "";
     let welcomed = false;
-    const socket = createConnection({ port: endpoint.port, host: endpoint.address });
+    const socket = createConnection({ port: endpoint.port, host: dialAddress(endpoint.address) });
     let lateTimer = null;
     const finish = (reply) => {
       if (late) {
@@ -33135,14 +33311,14 @@ var init_runtime_client = __esm(() => {
 });
 
 // src/boot-note.ts
-import { mkdirSync as mkdirSync6, readFileSync as readFileSync11, writeFileSync as writeFileSync8 } from "node:fs";
-import { dirname as dirname8, join as join14 } from "node:path";
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync12, writeFileSync as writeFileSync8 } from "node:fs";
+import { dirname as dirname9, join as join14 } from "node:path";
 function bootNotePath(projectPath) {
   return join14(projectPath, ".godot", "gdharness-boot.json");
 }
 function readBootNote(projectPath) {
   try {
-    const noted = readNumber(asParams(JSON.parse(readFileSync11(bootNotePath(projectPath), "utf8"))), "announcedAfterMs");
+    const noted = readNumber(asParams(JSON.parse(readFileSync12(bootNotePath(projectPath), "utf8"))), "announcedAfterMs");
     return noted !== undefined && Number.isFinite(noted) && noted > 0 ? noted : null;
   } catch {
     return null;
@@ -33151,7 +33327,7 @@ function readBootNote(projectPath) {
 function writeBootNote(projectPath, announcedAfterMs) {
   try {
     const path = bootNotePath(projectPath);
-    mkdirSync6(dirname8(path), { recursive: true });
+    mkdirSync6(dirname9(path), { recursive: true });
     writeFileSync8(path, JSON.stringify({ announcedAfterMs: Math.round(announcedAfterMs), at: new Date().toISOString() }, null, 2), "utf8");
   } catch {}
 }
@@ -33170,8 +33346,8 @@ var init_boot_note = __esm(() => {
 });
 
 // src/breakpoint-note.ts
-import { mkdirSync as mkdirSync7, readFileSync as readFileSync12, rmSync as rmSync7, writeFileSync as writeFileSync9 } from "node:fs";
-import { dirname as dirname9, isAbsolute as isAbsolute2, join as join15, relative as relative2 } from "node:path";
+import { mkdirSync as mkdirSync7, readFileSync as readFileSync13, rmSync as rmSync7, writeFileSync as writeFileSync9 } from "node:fs";
+import { dirname as dirname10, isAbsolute as isAbsolute2, join as join15, relative as relative2 } from "node:path";
 function breakpointNotePath(projectPath) {
   return join15(projectPath, ".godot", "gdharness-breakpoints.json");
 }
@@ -33190,7 +33366,7 @@ function writeBreakpointNote(projectPath, held) {
         lines: [...one.lines]
       }))
     };
-    mkdirSync7(dirname9(path), { recursive: true });
+    mkdirSync7(dirname10(path), { recursive: true });
     writeFileSync9(path, `${JSON.stringify(note, null, 2)}
 `, "utf8");
   } catch (error) {
@@ -33199,7 +33375,7 @@ function writeBreakpointNote(projectPath, held) {
 }
 function readBreakpointNote(projectPath) {
   try {
-    const parsed = JSON.parse(readFileSync12(breakpointNotePath(projectPath), "utf8"));
+    const parsed = JSON.parse(readFileSync13(breakpointNotePath(projectPath), "utf8"));
     if (typeof parsed !== "object" || parsed === null || !Array.isArray(parsed.breakpoints)) {
       return [];
     }
@@ -33232,14 +33408,14 @@ var init_breakpoint_note = __esm(() => {
 });
 
 // src/class-note.ts
-import { mkdirSync as mkdirSync8, readFileSync as readFileSync13, writeFileSync as writeFileSync10 } from "node:fs";
-import { dirname as dirname10, join as join16 } from "node:path";
+import { mkdirSync as mkdirSync8, readFileSync as readFileSync14, writeFileSync as writeFileSync10 } from "node:fs";
+import { dirname as dirname11, join as join16 } from "node:path";
 function classNotePath(projectPath) {
   return join16(projectPath, ".godot", "gdharness-classes.json");
 }
 function readClassNote(projectPath) {
   try {
-    const fields = asParams(JSON.parse(readFileSync13(classNotePath(projectPath), "utf8")));
+    const fields = asParams(JSON.parse(readFileSync14(classNotePath(projectPath), "utf8")));
     const rebuiltWith = readArray(fields, "rebuiltWith");
     if (rebuiltWith === undefined || !rebuiltWith.every((name) => typeof name === "string")) {
       return null;
@@ -33256,7 +33432,7 @@ function readClassNote(projectPath) {
 function writeClassNote(projectPath, note) {
   try {
     const path = classNotePath(projectPath);
-    mkdirSync8(dirname10(path), { recursive: true });
+    mkdirSync8(dirname11(path), { recursive: true });
     writeFileSync10(path, `${JSON.stringify(note, null, 2)}
 `, "utf8");
   } catch {}
@@ -33264,16 +33440,16 @@ function writeClassNote(projectPath, note) {
 var init_class_note = () => {};
 
 // src/config-pin.ts
-import { existsSync as existsSync12, readFileSync as readFileSync14 } from "node:fs";
+import { existsSync as existsSync13, readFileSync as readFileSync15 } from "node:fs";
 import { join as join17 } from "node:path";
 function versionsNamedInConfig(projectPath) {
   const config = join17(projectPath, ".mcp.json");
-  if (!existsSync12(config)) {
+  if (!existsSync13(config)) {
     return [];
   }
   let text;
   try {
-    text = readFileSync14(config, "utf8");
+    text = readFileSync15(config, "utf8");
     JSON.parse(text);
   } catch {
     return [];
@@ -33422,6 +33598,9 @@ var init_ports = __esm(() => {
 // src/dap_client.ts
 import { createConnection as createConnection2 } from "node:net";
 import { setTimeout as delay2 } from "node:timers/promises";
+function fileKey(path) {
+  return process.platform === "win32" ? path.replaceAll("\\", "/").toLowerCase() : path;
+}
 function said(body, field) {
   const value = body?.[field];
   return typeof value === "string" ? value : "";
@@ -33438,17 +33617,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() {
@@ -33609,6 +33796,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;
@@ -33625,6 +33813,7 @@ class GodotDAPClient {
         text: said(body, "text")
       };
       this.holdKnown = true;
+      this.stops += 1;
       return;
     }
     if (eventName === "continued") {
@@ -33641,20 +33830,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") {
@@ -33737,24 +33930,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);
     }
@@ -33764,14 +33977,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;
   }
@@ -33780,11 +33993,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;
@@ -33792,12 +34005,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)
@@ -33810,19 +34024,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);
       }
     }
   }
@@ -33833,15 +34049,16 @@ class GodotDAPClient {
     this.halt = null;
     this.holdKnown = true;
   }
-  async stepOver(threadId) {
-    await this.attach();
-    const resolvedThreadId = await this.resolveThreadId(threadId);
-    await this.sendRequest("next", { threadId: resolvedThreadId });
-  }
-  async stepInto(threadId) {
+  async step(command) {
     await this.attach();
-    const resolvedThreadId = await this.resolveThreadId(threadId);
-    await this.sendRequest("stepIn", { threadId: resolvedThreadId });
+    const resolvedThreadId = await this.resolveThreadId();
+    const before = this.stops;
+    await this.sendRequest(command, { threadId: resolvedThreadId });
+    const deadline = Date.now() + this.stepPatienceMs;
+    while (this.stops === before && this.connected && Date.now() < deadline) {
+      await delay2(50);
+    }
+    return this.stops !== before;
   }
   async getStackTrace(threadId) {
     await this.attach();
@@ -33867,16 +34084,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 {
@@ -33888,6 +34105,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"];
@@ -33951,9 +34171,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": {
@@ -33980,19 +34199,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();
@@ -34003,8 +34216,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:
@@ -34012,18 +34231,22 @@ 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}`}` }
+      ]
     };
   }
 }
-var DEFAULT_DAP_PORT = 6006, DAP_REQUEST_TIMEOUT_MS = 1e4, SCOPES_TIMEOUT_MS = 20000, VARIABLES_POLL_TIMEOUT_MS = 2000;
+var DEFAULT_DAP_PORT = 6006, DAP_REQUEST_TIMEOUT_MS = 1e4, SCOPES_TIMEOUT_MS = 20000, STEP_LANDS_WITHIN_MS = 1e4, VARIABLES_POLL_TIMEOUT_MS = 2000, ReadRefusal;
 var init_dap_client = __esm(() => {
   init_errors();
   init_framing();
   init_ports();
+  ReadRefusal = class ReadRefusal extends Refusal {
+  };
 });
 
 // src/desktop.ts
@@ -34033,16 +34256,16 @@ var init_desktop = () => {};
 // src/editor-log.ts
 import {
   closeSync,
-  existsSync as existsSync13,
+  existsSync as existsSync14,
   mkdirSync as mkdirSync9,
   openSync,
-  readFileSync as readFileSync15,
+  readFileSync as readFileSync16,
   readSync,
   rmSync as rmSync8,
   statSync as statSync6,
   writeFileSync as writeFileSync11
 } from "node:fs";
-import { dirname as dirname11, join as join18 } from "node:path";
+import { dirname as dirname12, join as join18 } from "node:path";
 function editorLogPath(projectPath) {
   return join18(projectPath, ".godot", "gdharness-editor.log");
 }
@@ -34051,7 +34274,7 @@ function editorLogNotePath(projectPath) {
 }
 function readEditorLogNote(projectPath) {
   try {
-    const fields = asParams(JSON.parse(readFileSync15(editorLogNotePath(projectPath), "utf8")));
+    const fields = asParams(JSON.parse(readFileSync16(editorLogNotePath(projectPath), "utf8")));
     const pid = readNumber(fields, "pid");
     const startedAt = readString(fields, "startedAt");
     return pid !== undefined && Number.isInteger(pid) && pid > 0 && startedAt !== undefined ? { pid, startedAt } : null;
@@ -34062,7 +34285,7 @@ function readEditorLogNote(projectPath) {
 function clearEditorLog(projectPath) {
   try {
     const path = editorLogPath(projectPath);
-    mkdirSync9(dirname11(path), { recursive: true });
+    mkdirSync9(dirname12(path), { recursive: true });
     rmSync8(path, { force: true });
     rmSync8(editorLogNotePath(projectPath), { force: true });
   } catch {}
@@ -34070,7 +34293,7 @@ function clearEditorLog(projectPath) {
 function writeEditorLogNote(projectPath, pid) {
   try {
     const path = editorLogNotePath(projectPath);
-    mkdirSync9(dirname11(path), { recursive: true });
+    mkdirSync9(dirname12(path), { recursive: true });
     writeFileSync11(path, JSON.stringify({ pid, startedAt: new Date().toISOString() }, null, 2), "utf8");
   } catch {}
 }
@@ -34092,7 +34315,7 @@ function editorConsole(projectPath, editorPid, openedByAServer) {
     return { kind: "older server", notedPid: noted?.pid ?? null };
   }
   const path = editorLogPath(projectPath);
-  if (!existsSync13(path)) {
+  if (!existsSync14(path)) {
     return { kind: "not written" };
   }
   const log = new GameLog;
@@ -34104,7 +34327,7 @@ function editorConsole(projectPath, editorPid, openedByAServer) {
 function theFirstOf(path) {
   const whole = statSync6(path).size;
   if (whole <= MOST_CONSOLE_BYTES) {
-    return { text: readFileSync15(path, "utf8") };
+    return { text: readFileSync16(path, "utf8") };
   }
   const handle = openSync(path, "r");
   try {
@@ -37173,7 +37396,10 @@ function mayYetConnect(listeningSince, now = Date.now()) {
   return listeningSince === undefined || now - listeningSince.getTime() < CONNECT_WINDOW_MS;
 }
 function theEditorHasComeBack(status, startedAt) {
-  return status.connected && (status.connectedAt?.getTime() ?? 0) > startedAt && status.addonVersion !== undefined;
+  return hasSaidWhoItIs(status) && (status.connectedAt?.getTime() ?? 0) > startedAt;
+}
+function hasSaidWhoItIs(status) {
+  return status.connected && status.addonVersion !== undefined;
 }
 function anEditorIsStillComing(listeningSince, launchedEditorIsAlive, now = Date.now()) {
   return mayYetConnect(listeningSince, now) || launchedEditorIsAlive;
@@ -37332,6 +37558,7 @@ var init_godot_bridge = __esm(() => {
         dapPort: this.connectionInfo?.dapPort,
         debugPort: this.connectionInfo?.debugPort,
         openedByAServer: this.connectionInfo?.openedByAServer,
+        startedByAnEditor: this.connectionInfo?.startedByAnEditor,
         syncsBreakpoints: this.connectionInfo?.syncsBreakpoints,
         pendingRequests: this.pendingRequests.size,
         queuedResources: this.resourceQueues.size,
@@ -37477,6 +37704,7 @@ var init_godot_bridge = __esm(() => {
             this.connectionInfo.dapPort = servedPort(message.dap_port);
             this.connectionInfo.debugPort = servedPort(message.debug_port);
             this.connectionInfo.openedByAServer = message.opened_by_a_server === true;
+            this.connectionInfo.startedByAnEditor = typeof message.started_by_an_editor === "boolean" ? message.started_by_an_editor : undefined;
             this.connectionInfo.syncsBreakpoints = typeof message.syncs_breakpoints === "boolean" ? message.syncs_breakpoints : undefined;
             this.log("info", `Godot ready: ${message.project_path}`);
             this.emitBridgeEvent("godot_connected", { projectPath: message.project_path });
@@ -37798,13 +38026,18 @@ function parseJUnit(xml) {
   const suiteElements = top.name === "testsuite" ? [top] : top.children.filter((child) => child.name === "testsuite");
   const suites = suiteElements.map((suite) => {
     const cases = suite.children.filter((child) => child.name === "testcase").map((element) => caseOf(suite, element));
+    const failures = cases.filter((entry) => entry.status === "failed").length;
+    const errors = cases.filter((entry) => entry.status === "error").length;
+    const written = (kind) => suite.children.filter((child) => child.name === "testcase").reduce((sum, element) => sum + element.children.filter((child) => child.name === kind).length, 0);
     return {
       name: suite.attributes["name"] ?? "",
       path: pathOf(suite),
       tests: cases.length,
       discovered: count(suite.attributes, "tests"),
-      failures: cases.filter((entry) => entry.status === "failed").length,
-      errors: cases.filter((entry) => entry.status === "error").length,
+      failures,
+      errors,
+      hookFailures: Math.max(0, count(suite.attributes, "failures") - written("failure")),
+      hookErrors: Math.max(0, count(suite.attributes, "errors") - written("error")),
       skipped: cases.filter((entry) => entry.status === "skipped").length,
       time: count(suite.attributes, "time"),
       cases
@@ -37815,11 +38048,19 @@ 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
   };
 }
+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] ?? "" }];
+  });
+}
 function whyNoReport(printed, asked) {
   const missing = printed.map((line) => NO_SUCH_PATH.exec(line)).find((found) => found !== null);
   if (missing !== undefined) {
@@ -37884,13 +38125,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}`;
@@ -37899,6 +38144,7 @@ function withActualsPrinted(failed, printed) {
  '${diff.actual}'${diff.suffix}
 	at ${diff.at}`);
         recovered = true;
+        used.add(index);
       }
     }
     const quoted = QUOTED_EQUALITY.exec(detail);
@@ -37950,7 +38196,7 @@ function orphansPrinted(printed) {
     suites
   };
 }
-var MalformedReportError, ENTITIES, ATTRIBUTE, NOTHING_RAN, NO_SUCH_PATH, DISCOVERY_FAILED = "Script errors were detected during test discovery!", ESCAPE, LOCATION = `'[^'\\n]*' in \\S+:\\d+`, IGNORING_CASE = " \\(ignoring case\\)", PRINTED_ACTUAL, QUOTED_EQUALITY, COLOUR2, SPELLED, BOTH_SIDES_ALIKE_NOTE = "[gdharness: the expected and the actual printed alike because gdUnit4 drops the marks that tell them apart when it writes its report, and the runner printed no copy of this one, so neither side above is the value the assertion found.]", VALUE_NOT_RECOVERED_NOTE = '[gdharness: the value after "but was" may not be the one the assertion found. gdUnit4 writes a failing string into its report as a character diff against the expected one with the marks dropped, which merges the two, and the runner printed no copy of this one to read the value back from.]', RENDERED_AWAY_NOTE = '[gdharness: the two sides print alike, so what tells them apart is something gdUnit4 does not print. The usual cause is BBCode in the expected string, which gdUnit4 renders as formatting instead of showing; the value after "but was" is the one the assertion found.]', MASKED_BRACKET = "[lb]", PRINTED_DICTIONARY, RUNNING_SUITE, ORPHANS, OVERALL = "Overall Summary";
+var MalformedReportError, ENTITIES, ATTRIBUTE, HOOK_FAILURE, NOTHING_RAN, NO_SUCH_PATH, DISCOVERY_FAILED = "Script errors were detected during test discovery!", ESCAPE, LOCATION = `'[^'\\n]*' in \\S+:\\d+`, IGNORING_CASE = " \\(ignoring case\\)", PRINTED_ACTUAL, QUOTED_EQUALITY, COLOUR2, SPELLED, BOTH_SIDES_ALIKE_NOTE = "[gdharness: the expected and the actual printed alike because gdUnit4 drops the marks that tell them apart when it writes its report, and the runner printed no copy of this one, so neither side above is the value the assertion found.]", VALUE_NOT_RECOVERED_NOTE = '[gdharness: the value after "but was" may not be the one the assertion found. gdUnit4 writes a failing string into its report as a character diff against the expected one with the marks dropped, which merges the two, and the runner printed no copy of this one to read the value back from.]', RENDERED_AWAY_NOTE = '[gdharness: the two sides print alike, so what tells them apart is something gdUnit4 does not print. The usual cause is BBCode in the expected string, which gdUnit4 renders as formatting instead of showing; the value after "but was" is the one the assertion found.]', MASKED_BRACKET = "[lb]", PRINTED_DICTIONARY, RUNNING_SUITE, ORPHANS, OVERALL = "Overall Summary";
 var init_junit = __esm(() => {
   MalformedReportError = class MalformedReportError extends Error {
     constructor(message) {
@@ -37960,8 +38206,9 @@ var init_junit = __esm(() => {
   };
   ENTITIES = { lt: "<", gt: ">", amp: "&", quot: '"', apos: "'" };
   ATTRIBUTE = /\s*([^\s=/>]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/y;
+  HOOK_FAILURE = /^\s*(.*?)\s*\tat '(before|after)' in (res:\/\/.+?):(\d+)\s*$/;
   NOTHING_RAN = /no test cases found/i;
-  NO_SUCH_PATH = /given directory or file does not exists:\s*(\S+)/i;
+  NO_SUCH_PATH = /given directory or file does not exists:\s*(.+?)\s*$/i;
   ESCAPE = String.fromCharCode(27);
   PRINTED_ACTUAL = new RegExp(` but was\\n '((?:(?!\\tat ${LOCATION})[\\s\\S])*?)'((?:${ESCAPE}\\[[0-9;]*m)*)(${IGNORING_CASE})?((?:${ESCAPE}\\[[0-9;]*m)*)\\tat (${LOCATION})`, "g");
   QUOTED_EQUALITY = new RegExp(`^Expecting(?: error message)?:\\n '([\\s\\S]*)'\\n but was\\n '([\\s\\S]*)'(?:${IGNORING_CASE})?\\n\\tat `);
@@ -37979,15 +38226,15 @@ var init_junit = __esm(() => {
     "<DEL>": ""
   };
   PRINTED_DICTIONARY = /^\{\n\t[\s\S]*\n {2}\}$/;
-  RUNNING_SUITE = /Run Test Suite:\s*(\S+)/;
+  RUNNING_SUITE = /Run Test Suite:\s*(res:\/\/.+?\.(?:gd|cs))(?=\s|$)/;
   ORPHANS = /(\d+)\s+orphans/;
 });
 
 // src/lsp_client.ts
-import { realpathSync as realpathSync2 } from "node:fs";
+import { existsSync as existsSync15, realpathSync as realpathSync4 } from "node:fs";
 import { readFile, realpath } from "node:fs/promises";
 import { createConnection as createConnection3 } from "node:net";
-import { dirname as dirname12, resolve as resolve4 } from "node:path";
+import { dirname as dirname13, join as join19, resolve as resolve4 } from "node:path";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
 function diagnosticsKey(uri) {
   let decoded;
@@ -38000,7 +38247,7 @@ function diagnosticsKey(uri) {
     return decoded;
   }
   try {
-    return realpathSync2.native(fileURLToPath3(decoded)).toLowerCase();
+    return realpathSync4.native(fileURLToPath3(decoded)).toLowerCase();
   } catch {
     return decoded.toLowerCase();
   }
@@ -38017,8 +38264,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;
@@ -38115,7 +38364,7 @@ class GodotLSPClient {
     if (this.initialized) {
       return;
     }
-    const rootPath = this.rootPath ?? dirname12(resolve4(filePath));
+    const rootPath = this.rootPath ?? dirname13(resolve4(filePath));
     await this.initialize(rootPath);
   }
   async sendRequest(method, params) {
@@ -38190,6 +38439,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;
@@ -38292,10 +38545,14 @@ class GodotLSPClient {
       this.sendNotification("textDocument/didClose", { textDocument: { uri } });
     } catch {}
   }
+  forgetServedWorkspace() {
+    this.servedWorkspace = null;
+  }
   async initialize(rootPath) {
     await this.ensureConnected();
     const resolvedRootPath = resolve4(rootPath);
     const rootUri = pathToFileURL(resolvedRootPath).href;
+    this.forgetServedWorkspace();
     const result = await this.sendRequest("initialize", {
       processId: process.pid,
       rootPath: resolvedRootPath,
@@ -38321,60 +38578,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
-      });
+    const before = this.documentTurns.get(key) ?? Promise.resolve();
+    let done = () => {};
+    const mine = new Promise((finished) => {
+      done = finished;
     });
-    let opened = null;
+    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;
     }
@@ -38389,28 +38668,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() {
@@ -38442,36 +38724,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 (!existsSync15(join19(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");
@@ -38485,7 +38770,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 });
@@ -38494,7 +38779,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 });
@@ -38508,20 +38793,31 @@ 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 } : {}
     });
   }
 }
-var DEFAULT_LSP_PORT = 6005, DIAGNOSTICS_TIMEOUT_MS = 5000;
+var DEFAULT_LSP_PORT = 6005, DIAGNOSTICS_TIMEOUT_MS = 5000, ArgumentRefusal, AnotherProjectsServer;
 var init_lsp_client = __esm(() => {
   init_errors();
   init_framing();
   init_paths();
   init_ports();
+  ArgumentRefusal = class ArgumentRefusal extends Refusal {
+  };
+  AnotherProjectsServer = 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;
+    }
+  };
 });
 
 // src/outside.ts
-import { spawn as spawn2 } from "node:child_process";
+import { spawn as spawn3 } from "node:child_process";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 function changesFrom(env, base) {
   const changes = {};
@@ -38554,7 +38850,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
     });
@@ -38589,8 +38885,8 @@ var init_outside = __esm(() => {
 });
 
 // src/process-time.ts
-import { execFile as execFile4 } from "node:child_process";
-import { promisify as promisify4 } from "node:util";
+import { execFile as execFile3 } from "node:child_process";
+import { promisify as promisify3 } from "node:util";
 async function cpuSecondsOf(pid) {
   try {
     return process.platform === "win32" ? await secondsOnWindows(pid) : await askPosix2(pid);
@@ -38604,7 +38900,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) {
@@ -38622,20 +38918,20 @@ function secondsFromClock(printed) {
   const extra = days === null ? 0 : Number(days) * 86400;
   return Number.isFinite(extra) ? seconds + extra : undefined;
 }
-var run4, ASK_TIMEOUT_MS2 = 6000;
+var run3, ASK_TIMEOUT_MS2 = 6000;
 var init_process_time = __esm(() => {
   init_windows_ask();
-  run4 = promisify4(execFile4);
+  run3 = promisify3(execFile3);
 });
 
 // src/project-scan.ts
-import { existsSync as existsSync14, readdirSync as readdirSync7, readFileSync as readFileSync16 } from "node:fs";
-import { join as join19 } from "node:path";
+import { existsSync as existsSync16, readdirSync as readdirSync7, readFileSync as readFileSync17 } from "node:fs";
+import { join as join20 } from "node:path";
 function skipped(name) {
   return name.startsWith(".") || SKIPPED.has(name);
 }
 function steppedOver(directory) {
-  return existsSync14(join19(directory, ".gdignore"));
+  return existsSync16(join20(directory, ".gdignore"));
 }
 function projectStructure(projectPath) {
   const structure = { scenes: 0, scripts: 0, assets: 0, other: 0 };
@@ -38648,10 +38944,10 @@ function projectStructure(projectPath) {
         continue;
       }
       if (entry.isDirectory()) {
-        visit(join19(directory, entry.name));
+        visit(join20(directory, entry.name));
       } else if (entry.isFile()) {
         const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
-        if (extension === "tscn") {
+        if (SCENE_EXTENSIONS.has(extension)) {
           structure.scenes += 1;
         } else if (extension === "gd" || extension === "cs") {
           structure.scripts += 1;
@@ -38678,14 +38974,14 @@ function scriptsWithoutUid(projectPath) {
       }
       const spelled = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
       if (entry.isDirectory()) {
-        visit(join19(directory, entry.name), spelled);
+        visit(join20(directory, entry.name), spelled);
         continue;
       }
       if (!entry.isFile()) {
         continue;
       }
       const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
-      if (CARRIES_A_UID.has(extension) && !existsSync14(join19(directory, `${entry.name}.uid`))) {
+      if (CARRIES_A_UID.has(extension) && !existsSync16(join20(directory, `${entry.name}.uid`))) {
         found.push(spelled);
       }
     }
@@ -38693,8 +38989,11 @@ function scriptsWithoutUid(projectPath) {
   visit(projectPath, "");
   return found.sort();
 }
+function isBinary(bytes) {
+  return bytes.subarray(0, 8000).includes(0);
+}
 function searchProject(projectPath, options) {
-  const extensions = new Set(options.fileTypes.map((ext) => ext.replace(/^\./, "").toLowerCase()).filter(Boolean));
+  const extensions = options.fileTypes === undefined ? null : new Set(options.fileTypes.map((ext) => ext.replace(/^\./, "").toLowerCase()).filter(Boolean));
   const result = {
     query: options.query,
     results: [],
@@ -38702,13 +39001,7 @@ function searchProject(projectPath, options) {
   };
   const regex = options.regex ? new RegExp(options.query, options.caseSensitive ? "" : "i") : null;
   const needle = options.caseSensitive ? options.query : options.query.toLowerCase();
-  const full = () => {
-    if (result.summary.total_matches >= options.maxResults) {
-      result.summary.truncated = true;
-      return true;
-    }
-    return false;
-  };
+  const full = () => result.summary.truncated;
   const visit = (directory) => {
     if (steppedOver(directory)) {
       return;
@@ -38720,27 +39013,32 @@ function searchProject(projectPath, options) {
       if (skipped(entry.name)) {
         continue;
       }
-      const entryPath = join19(directory, entry.name);
+      const entryPath = join20(directory, entry.name);
       if (entry.isDirectory()) {
         visit(entryPath);
         continue;
       }
       const extension = entry.name.includes(".") ? entry.name.split(".").pop()?.toLowerCase() ?? "" : "";
-      if (!entry.isFile() || !extensions.has(extension)) {
+      if (!entry.isFile() || extensions !== null && !extensions.has(extension)) {
+        continue;
+      }
+      const bytes = readFileSync17(entryPath);
+      if (extensions === null && isBinary(bytes)) {
         continue;
       }
       result.summary.files_searched += 1;
       const matches = [];
-      for (const [index, line] of readFileSync16(entryPath, "utf8").split(`
-`).entries()) {
-        if (full()) {
-          break;
+      for (const [index, line] of bytes.toString("utf8").split(/\r?\n/).entries()) {
+        const found = regex ? regex.exec(line) : (options.caseSensitive ? line : line.toLowerCase()).includes(needle) ? [options.query] : null;
+        if (found === null) {
+          continue;
         }
-        const match = regex ? regex.exec(line)?.[0] : (options.caseSensitive ? line : line.toLowerCase()).includes(needle) ? options.query : "";
-        if (match) {
-          matches.push({ line: index + 1, content: line.trim(), match });
-          result.summary.total_matches += 1;
+        if (result.summary.total_matches >= options.maxResults) {
+          result.summary.truncated = true;
+          break;
         }
+        matches.push({ line: index + 1, content: line.trim(), match: found[0] ?? "" });
+        result.summary.total_matches += 1;
       }
       if (matches.length > 0) {
         const relativePath = entryPath.slice(projectPath.length + 1).replace(/\\/g, "/");
@@ -38752,23 +39050,53 @@ function searchProject(projectPath, options) {
   visit(projectPath);
   return result;
 }
-var SKIPPED, ASSET_EXTENSIONS, CARRIES_A_UID;
+var SKIPPED, SCENE_EXTENSIONS, ASSET_EXTENSIONS, CARRIES_A_UID;
 var init_project_scan = __esm(() => {
   SKIPPED = new Set(["node_modules"]);
-  ASSET_EXTENSIONS = new Set(["png", "jpg", "jpeg", "webp", "svg", "ttf", "otf", "wav", "mp3", "ogg"]);
+  SCENE_EXTENSIONS = new Set(["tscn", "scn"]);
+  ASSET_EXTENSIONS = new Set([
+    "png",
+    "jpg",
+    "jpeg",
+    "webp",
+    "svg",
+    "bmp",
+    "tga",
+    "exr",
+    "hdr",
+    "ktx",
+    "dds",
+    "ttf",
+    "otf",
+    "woff",
+    "woff2",
+    "fnt",
+    "wav",
+    "mp3",
+    "ogg",
+    "glb",
+    "gltf",
+    "obj",
+    "fbx",
+    "blend",
+    "dae",
+    "ogv",
+    "gdshader",
+    "shader"
+  ]);
   CARRIES_A_UID = new Set(["gd", "shader", "gdshader"]);
 });
 
 // src/restart-note.ts
-import { mkdirSync as mkdirSync10, readFileSync as readFileSync17, rmSync as rmSync9, writeFileSync as writeFileSync12 } from "node:fs";
-import { dirname as dirname13, join as join20 } from "node:path";
+import { mkdirSync as mkdirSync10, readFileSync as readFileSync18, rmSync as rmSync9, writeFileSync as writeFileSync12 } from "node:fs";
+import { dirname as dirname14, join as join21 } from "node:path";
 function restartNotePath(projectPath) {
-  return join20(projectPath, ".godot", "gdharness-restart.json");
+  return join21(projectPath, ".godot", "gdharness-restart.json");
 }
 function noteRestartBegun(note) {
   const path = restartNotePath(note.projectPath);
   try {
-    mkdirSync10(dirname13(path), { recursive: true });
+    mkdirSync10(dirname14(path), { recursive: true });
     writeFileSync12(path, `${JSON.stringify(note, null, 2)}
 `, "utf8");
   } catch (error) {
@@ -38777,7 +39105,7 @@ function noteRestartBegun(note) {
 }
 function restartOwed(projectPath) {
   try {
-    const parsed = JSON.parse(readFileSync17(restartNotePath(projectPath), "utf8"));
+    const parsed = JSON.parse(readFileSync18(restartNotePath(projectPath), "utf8"));
     if (typeof parsed !== "object" || parsed === null) {
       return null;
     }
@@ -38802,31 +39130,31 @@ var init_restart_note = __esm(() => {
 });
 
 // src/run-record.ts
-import { execFile as execFile5 } from "node:child_process";
+import { execFile as execFile4 } from "node:child_process";
 import { createHash as createHash4 } from "node:crypto";
 import {
   mkdirSync as mkdirSync11,
   openSync as openSync2,
   readdirSync as readdirSync8,
-  readFileSync as readFileSync18,
-  realpathSync as realpathSync3,
+  readFileSync as readFileSync19,
+  realpathSync as realpathSync5,
   rmSync as rmSync10,
   statSync as statSync7,
   writeFileSync as writeFileSync13
 } from "node:fs";
-import { basename as basename4, dirname as dirname14, join as join21, resolve as resolve5 } from "node:path";
-import { promisify as promisify5 } from "node:util";
+import { basename as basename4, dirname as dirname15, join as join22, resolve as resolve5 } from "node:path";
+import { promisify as promisify4 } from "node:util";
 function runsDirectory() {
-  return join21(runtimeDirectory(), "runs");
+  return join22(runtimeDirectory(), "runs");
 }
 function realAsFarAsItExists(path) {
   const missing = [];
   let at = path;
   for (;; ) {
     try {
-      return join21(realpathSync3.native(at), ...missing);
+      return join22(realpathSync5.native(at), ...missing);
     } catch {
-      const parent = dirname14(at);
+      const parent = dirname15(at);
       if (parent === at) {
         return path;
       }
@@ -38841,15 +39169,18 @@ function projectKey(projectPath) {
   return createHash4("sha256").update(folded.replaceAll("\\", "/")).digest("hex").slice(0, 16);
 }
 function runRecordPath(projectPath, directory = runtimeDirectory()) {
-  return join21(directory, "runs", `note-${projectKey(projectPath)}.json`);
+  return join22(directory, "runs", `note-${projectKey(projectPath)}.json`);
 }
 function openTranscript(startedAt) {
   mkdirSync11(runsDirectory(), { recursive: true });
-  const path = join21(runsDirectory(), `run-${startedAt}.log`);
+  const path = join22(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 join21(directory, "runs", `editor-${projectKey(projectPath)}.json`);
+  return join22(directory, "runs", `editor-${projectKey(projectPath)}.json`);
 }
 function writeEditorRunNote(note) {
   mkdirSync11(runsDirectory(), { recursive: true });
@@ -38857,7 +39188,7 @@ function writeEditorRunNote(note) {
 }
 function readEditorRunNote(projectPath) {
   for (const directory of runtimeDirectories()) {
-    const note = editorNoteAt(editorNotePath(projectPath, directory)) ?? editorNoteAt(join21(directory, "runs", "editor-run.json"));
+    const note = editorNoteAt(editorNotePath(projectPath, directory)) ?? editorNoteAt(join22(directory, "runs", "editor-run.json"));
     if (note !== null && isSameDirectory(note.projectPath, projectPath)) {
       return note;
     }
@@ -38867,7 +39198,7 @@ function readEditorRunNote(projectPath) {
 function editorNoteAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync18(path, "utf8"));
+    parsed = JSON.parse(readFileSync19(path, "utf8"));
   } catch {
     return null;
   }
@@ -38881,7 +39212,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()) {
@@ -38889,7 +39222,7 @@ function readRunRecord(projectPath) {
     if (own !== null) {
       return own;
     }
-    const shared = recordAt(join21(directory, "runs", SHARED_NOTE));
+    const shared = recordAt(join22(directory, "runs", SHARED_NOTE));
     if (shared !== null && shared.projectPath !== "" && isSameDirectory(shared.projectPath, projectPath)) {
       return shared;
     }
@@ -38901,13 +39234,13 @@ function everyRunRecord() {
   for (const directory of runtimeDirectories()) {
     let entries;
     try {
-      entries = readdirSync8(join21(directory, "runs"));
+      entries = readdirSync8(join22(directory, "runs"));
     } catch {
       continue;
     }
     for (const entry of entries) {
       if (entry === SHARED_NOTE || entry.startsWith("note-") && entry.endsWith(".json")) {
-        const record = recordAt(join21(directory, "runs", entry));
+        const record = recordAt(join22(directory, "runs", entry));
         if (record !== null) {
           found.push(record);
         }
@@ -38919,7 +39252,7 @@ function everyRunRecord() {
 function recordAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync18(path, "utf8"));
+    parsed = JSON.parse(readFileSync19(path, "utf8"));
   } catch {
     return null;
   }
@@ -38938,7 +39271,9 @@ function recordAt(path) {
     pid,
     transcript,
     startedAt,
+    ...typeof fields["startedBy"] === "number" ? { startedBy: fields["startedBy"] } : {},
     projectPath: typeof fields["projectPath"] === "string" ? fields["projectPath"] : "",
+    ...typeof fields["servedBy"] === "string" && fields["servedBy"] !== "" ? { servedBy: fields["servedBy"] } : {},
     arguments: Array.isArray(args) ? args.filter((value) => typeof value === "string") : [],
     ...typeof fields["command"] === "string" ? { command: fields["command"] } : {},
     ...typeof fields["exitCode"] === "number" ? { exitCode: fields["exitCode"] } : {},
@@ -38947,7 +39282,8 @@ function recordAt(path) {
 }
 async function runningAs(pid) {
   if (process.platform === "win32") {
-    const answer = await windowsCommandLine(pid);
+    const read = await readWindowsCommandLine(pid);
+    const answer = "answer" in read ? read.answer : null;
     if (answer !== null) {
       const [, ...rest] = answer.split(`
 `);
@@ -38959,13 +39295,17 @@ async function runningAs(pid) {
       }
     }
     const image = await windowsImage(pid);
-    return image === null ? null : { kind: "image", text: image };
+    return image === null ? null : {
+      kind: "image",
+      text: image,
+      unread: "unread" in read ? read.unread : "Windows gave an empty command line"
+    };
   }
   try {
     const began = await startedAt(pid, null);
     const when = began === null ? {} : { startedAt: began };
     if (process.platform === "linux") {
-      const raw = readFileSync18(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
+      const raw = readFileSync19(`/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();
@@ -39010,13 +39350,18 @@ function listeningPidInNetstat(printed, port) {
   }
   return null;
 }
-async function windowsCommandLine(pid) {
-  try {
-    const answer = (await askWindows(`$p = Get-CimInstance Win32_Process -Filter "ProcessId=${pid}"; if ($p) { $p.CreationDate.ToUniversalTime().ToString("o"); $p.CommandLine }`, 15000)).trim();
-    return answer === "" ? null : answer;
-  } catch {
-    return null;
+async function readWindowsCommandLine(pid, ask = askWindows) {
+  const query = `$p = Get-CimInstance Win32_Process -Filter "ProcessId=${pid}"; if ($p) { $p.CreationDate.ToUniversalTime().ToString("o"); $p.CommandLine }`;
+  let unread = "";
+  for (const withinMs of [15000, 45000]) {
+    try {
+      const answer = (await ask(query, withinMs)).trim();
+      return answer === "" ? { unread: "Windows gave no command line for it" } : { answer };
+    } catch (error) {
+      unread = errorMessage(error);
+    }
   }
+  return { unread };
 }
 async function startedAt(pid, windowsAnswer) {
   if (process.platform === "win32") {
@@ -39044,36 +39389,43 @@ async function windowsImage(pid) {
     return null;
   }
 }
-async function stillTheRecordedRun(record) {
-  return judgeRun(record, await runningAs(record.pid), "confirmed");
+async function whyNotStillTheRecordedRun(record) {
+  return whyNotTheRun(record, await runningAs(record.pid), "confirmed");
 }
 async function couldStillBeTheRecordedRun(record) {
   return judgeRun(record, await runningAs(record.pid), "possible");
 }
 function judgeRun(record, running, needed) {
+  return whyNotTheRun(record, running, needed) === null;
+}
+function whyNotTheRun(record, running, needed) {
   if (running === null) {
-    return false;
+    return "the operating system would not describe that process";
   }
-  if (running.startedAt !== undefined && running.startedAt - record.startedAt > SAME_RUN_WINDOW_MS) {
-    return false;
+  const after = running.startedAt === undefined ? 0 : running.startedAt - (record.startedBy ?? record.startedAt);
+  if (after > SAME_RUN_WINDOW_MS) {
+    return `that process started ${Math.round(after / 1000)} seconds after the run had`;
   }
   const engine = record.command === undefined ? null : basename4(record.command);
   const said = process.platform === "win32" ? running.text.toLowerCase() : running.text;
   const wanted = engine === null || process.platform !== "win32" ? engine : engine.toLowerCase();
   if (wanted !== null && !said.includes(wanted)) {
-    return false;
+    return `that process is not ${engine ?? "the engine"}, which the run was started with`;
   }
   if (running.kind === "commandLine" && readCommandLine(running.text).editor) {
-    return false;
+    return "that process is an editor";
   }
   if (record.projectPath === "") {
-    return wanted !== null;
+    return wanted !== null ? null : "the record names neither the project nor the engine";
   }
   if (running.kind === "image") {
-    return needed === "possible" && wanted !== null;
+    if (wanted === null) {
+      return "the operating system named only its executable, and the record names no engine";
+    }
+    return needed === "possible" ? null : `the operating system named only its executable and not its command line (${running.unread ?? "no reason given"}), which is not enough to signal it on`;
   }
   const project = process.platform === "win32" ? record.projectPath.toLowerCase() : record.projectPath;
-  return said.includes(project);
+  return said.includes(project) ? null : `that process's command line does not name ${record.projectPath}`;
 }
 async function stillTheAnnouncedGame(pid, projectPath, announcedAt) {
   return judgeAnnouncedGame(await runningAs(pid), projectPath, announcedAt);
@@ -39093,7 +39445,7 @@ function judgeAnnouncedGame(running, projectPath, announcedAt) {
 }
 function clearRunRecord(projectPath) {
   for (const directory of runtimeDirectories()) {
-    const shared = join21(directory, "runs", SHARED_NOTE);
+    const shared = join22(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] : []]) {
@@ -39123,7 +39475,7 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
     if (!entry.startsWith("run-") || !entry.endsWith(".log")) {
       continue;
     }
-    const path = join21(directory, entry);
+    const path = join22(directory, entry);
     if (kept.has(path) || ageMs(path, now) < keepMs) {
       continue;
     }
@@ -39134,35 +39486,43 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
 }
 var execFileAsync, SHARED_NOTE = "run.json", SAME_RUN_WINDOW_MS = 1e4;
 var init_run_record = __esm(() => {
+  init_errors();
   init_paths();
   init_process_children();
   init_runtime_client();
   init_windows_ask();
-  execFileAsync = promisify5(execFile5);
+  execFileAsync = promisify4(execFile4);
 });
 
 // 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 existsSync15,
+  existsSync as existsSync17,
   fstatSync,
   mkdirSync as mkdirSync12,
   openSync as openSync3,
   readdirSync as readdirSync9,
-  readFileSync as readFileSync19,
+  readFileSync as readFileSync20,
   readSync as readSync2,
   rmdirSync as rmdirSync2,
   statSync as statSync8
 } from "node:fs";
-import { basename as basename5, dirname as dirname15, extname as extname2, isAbsolute as isAbsolute3, join as join22, normalize as normalize2, relative as relative3 } from "node:path";
+import { basename as basename5, dirname as dirname16, extname as extname2, isAbsolute as isAbsolute3, join as join23, normalize as normalize2, relative as relative3 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
-import { promisify as promisify6 } from "node:util";
+import { promisify as promisify5 } from "node:util";
+function editorRestartTimeoutMs() {
+  const override = Number.parseInt(envValue("GDHARNESS_EDITOR_RESTART_TIMEOUT_MS") ?? "", 10);
+  return Number.isInteger(override) && override > 0 ? override : 90000;
+}
+function restartUnderway(note, now = Date.now()) {
+  return alive(note.byPid) && now - Date.parse(note.quitAt) < editorRestartTimeoutMs() + 30000;
+}
 function captureDestinationRefusal(outputPath, projects) {
   if (/^(res|user):\/\//.test(outputPath)) {
     return `outputPath ${outputPath} is a Godot path; a capture is saved outside the project, at an absolute path on this machine.`;
@@ -39173,16 +39533,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(dirname15(outputPath));
-  if (!existsSync15(directory)) {
-    return `outputPath's directory ${dirname15(outputPath)} does not exist; a capture creates no directories.`;
+  const directory = realPathOr(dirname16(outputPath));
+  if (!existsSync17(directory)) {
+    return `outputPath's directory ${dirname16(outputPath)} does not exist; a capture creates no directories.`;
   }
-  const where = join22(directory, basename5(outputPath));
+  const where = join23(directory, basename5(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 (existsSync15(where)) {
+  if (existsSync17(where)) {
     return `outputPath ${outputPath} already exists; a capture is not written over a file. Name a new one.`;
   }
   return null;
@@ -39213,16 +39573,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;
@@ -39238,6 +39600,11 @@ function stillRunning(run) {
   }
   return true;
 }
+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);
@@ -39285,11 +39652,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,
@@ -39298,22 +39673,31 @@ function stopVerdict(stop) {
       withChildren: false
     };
   }
+  if (stop.ending === "lingering") {
+    const told = stop.throughEditor ? stop.endedPid === null ? "The editor was asked to stop the scene it is playing and was still playing it" : `The editor was asked to stop the scene it is playing, and its game, pid ${stop.endedPid}, was still running` : `pid ${stop.endedPid ?? "unknown"} was told to end and was still running`;
+    return {
+      stopped: false,
+      stillGoing: stop.endedPid,
+      note: `${told} ${STOP_WAIT_MS / 1000} seconds later, so it has not stopped. editor_status says when it has gone, and editor_run stop asks again.`,
+      withChildren: true
+    };
+  }
   return {
     stopped: true,
     endedPid: stop.endedPid,
-    clean: stop.errors === 0,
-    note: `${stop.throughEditor ? stop.endedPid === null ? "The editor was asked to stop the scene it is playing. Its game had not announced a runtime, so no process was named under endedPid, and its exit code stays with the editor." : "The editor was asked to stop the scene it is playing." : "The process named under endedPid was ended."}${stop.exitSignal === null ? "" : ` It was ended by ${stop.exitSignal} and so has no exit code.`}${stop.ending === "gone" ? "" : ` It had not exited ${STOP_WAIT_MS / 1000} seconds after being told to, so it may still be going: editor_status says whether it is.`}`,
+    clean: stop.clean,
+    note: `${stop.throughEditor ? stop.endedPid === null ? "The editor was asked to stop the scene it is playing. Its game had not announced a runtime, so no process was named under endedPid, and its exit code stays with the editor." : "The editor was asked to stop the scene it is playing." : "The process named under endedPid was ended."}${stop.exitSignal === null ? "" : ` It was ended by ${stop.exitSignal} and so has no exit code.`}`,
     withChildren: true
   };
 }
 function endedPreviousRun(ended) {
-  if (ended === null || ended.ending === "refused") {
+  if (ended?.ending !== "gone") {
     return;
   }
   return ended.pid ?? true;
 }
 function previousRunLeft(ended) {
-  return ended?.ending === "refused" && ended.pid !== null ? ended.pid : undefined;
+  return (ended?.ending === "refused" || ended?.ending === "lingering") && ended.pid !== null ? ended.pid : undefined;
 }
 function engineNamesOf(executable) {
   return CONSOLE_WRAPPER.test(executable) ? [executable, executable.replace(CONSOLE_WRAPPER, "$1")] : [executable];
@@ -39389,8 +39773,13 @@ function endedToStartThis(ended) {
   if (ended.ending === "refused") {
     return ` ${which} was not ended: that pid no longer answers as the process the run was started as, so nothing was signalled. If it is still the game, it is running beside this one and you have to end it yourself; if it is not, it belongs to something else.`;
   }
-  const after = ended.ending === "lingering" ? ` It had not exited ${STOP_WAIT_MS / 1000} seconds after being told to, so it may still be running beside this one: editor_status says whether it is.` : "";
-  return ` ${which} was ended to start this one; its output is no longer what editor_output answers about.${after}`;
+  if (ended.ending === "unreached") {
+    return ` ${which} was not ended here: the editor could not be asked to stop it. The editor stops a play before starting the next, so it is not running beside this one if this start reached the editor.`;
+  }
+  if (ended.ending === "lingering") {
+    return ` ${which} was told to end to start this one and was still running ${STOP_WAIT_MS / 1000} seconds later, so it is running beside this one: editor_status says when it has gone.`;
+  }
+  return ` ${which} was ended to start this one; its output is no longer what editor_output answers about.`;
 }
 function runtimeVerdict(endpoint, after) {
   if (endpoint !== null) {
@@ -39514,19 +39903,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."
   };
 }
 function changedSettings(before, after) {
@@ -39581,16 +40009,17 @@ function importStatuses(payload) {
     };
   });
 }
-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;
@@ -39611,7 +40040,7 @@ function aboveTheRunner(entry) {
 }
 function elsewhereIn(projectPath, asked) {
   const wanted = asked.replace(/^res:\/\//, "").replace(/\/+$/, "");
-  if (wanted === "" || existsSync15(join22(projectPath, wanted))) {
+  if (wanted === "" || existsSync17(join23(projectPath, wanted))) {
     return "";
   }
   const root = (wanted.split("/")[0] ?? "").toLowerCase();
@@ -39625,7 +40054,7 @@ function elsewhereIn(projectPath, asked) {
   return near.length === 0 ? "" : ` The project does have ${there}.`;
 }
 function hasMainScene(projectFile) {
-  const scene = parseProjectGodot(readFileSync19(projectFile, "utf8"))["application"]?.["run/main_scene"];
+  const scene = parseProjectGodot(readFileSync20(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "";
 }
 function runtimeAddonAnnouncesEditors(projectPath) {
@@ -39633,13 +40062,13 @@ function runtimeAddonAnnouncesEditors(projectPath) {
     return false;
   }
   try {
-    return readFileSync19(join22(projectPath, RUNTIME_AUTOLOAD.path), "utf8").includes('"editor_pid"');
+    return readFileSync20(join23(projectPath, RUNTIME_AUTOLOAD.path), "utf8").includes('"editor_pid"');
   } catch {
     return false;
   }
 }
 function editorPlaysHeadless(projectFile) {
-  const runArgs = parseProjectGodot(readFileSync19(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
+  const runArgs = parseProjectGodot(readFileSync20(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
   return typeof runArgs === "string" && /(?:^|\s)--headless(?:\s|$)/.test(runArgs);
 }
 function camelCased(params) {
@@ -39658,7 +40087,7 @@ function needsItsOwnProcess(asked) {
 class GodotServer {
   mcp;
   locator = new GodotLocator;
-  operationsScript = join22(__dirname2, "godot", "operations", "godot_operations.gd");
+  operationsScript = join23(__dirname2, "godot", "operations", "godot_operations.gd");
   godotBridge;
   tools = buildToolDefinitions();
   activeProcess = null;
@@ -39680,6 +40109,7 @@ class GodotServer {
   shutdownInitiated = false;
   launchedEditor = null;
   launchedFrom = null;
+  launchedDropped = null;
   ownProject;
   announcedAt = null;
   handingOverFrom = null;
@@ -39687,9 +40117,12 @@ class GodotServer {
   constructor() {
     this.ownProject = envValue("GDHARNESS_PROJECT") ?? null;
     this.godotBridge = getDefaultBridge(this.ownProject);
+    this.godotBridge.on("godot_connected", () => {
+      this.settleTheLaunchReading();
+    });
     this.mcp = new McpServer({ name: "gdharness", version: SERVER_VERSION }, { capabilities: { tools: {}, resources: {} } });
     this.setupToolHandlers();
-    setupResourceHandlers(this.mcp, () => this.lastProjectPath);
+    setupResourceHandlers(this.mcp, () => this.ourProject() ?? this.lastProjectPath);
     this.mcp.server.onerror = (error) => {
       console.error("[MCP Error]", error);
     };
@@ -39955,8 +40388,9 @@ class GodotServer {
       if (!checked.ok) {
         return checked.response;
       }
-      if (typeof args["projectPath"] === "string") {
-        this.lastProjectPath = args["projectPath"];
+      const named = args["projectPath"];
+      if (typeof named === "string" && existsSync17(join23(named, "project.godot"))) {
+        this.lastProjectPath = named;
       }
       this.updates.refresh();
       const answer = await withCallSignal(extra.signal, () => this.answered(spec.name, checked.op ?? "", args));
@@ -39996,6 +40430,17 @@ class GodotServer {
       return answer;
     }
     const moved = this.projectHasMovedOn();
+    if (moved !== null && !isNewer(moved, SERVER_VERSION)) {
+      this.noticedUpdate = true;
+      this.callsSinceNotice = 0;
+      return this.saying(answer, {
+        project_addons_behind_this_server: {
+          server_is: SERVER_VERSION,
+          project_is: moved,
+          what_to_do: `The project's gdharness addons are ${moved}, older than this ${SERVER_VERSION} server, so an ` + "editor restart loads the old code and reconnecting spawns this same server again. Tell the " + "user, and offer to run gdharness upgrade in the project, which replaces the addons with " + "this server's; ask first, since it changes files in their project. editor_launch restart " + "then loads them."
+        }
+      });
+    }
     if (moved !== null) {
       this.noticedUpdate = true;
       this.callsSinceNotice = 0;
@@ -40028,7 +40473,7 @@ class GodotServer {
     return this.saying(answer, {
       update_available: {
         ...notice,
-        what_to_do: "Tell the user a newer gdharness is out, with what changed, and offer to take it. " + "Only run the upgrade command if they say yes: it restarts their editor and the " + "MCP server has to be reconnected afterwards."
+        what_to_do: "Tell the user a newer gdharness is out, with what changed, and offer to take it. " + "Only run the upgrade command if they say yes: it replaces the addons in their project, " + "and afterwards the MCP server has to be reconnected and the editor restarted with " + "editor_launch restart."
       }
     });
   }
@@ -40045,6 +40490,11 @@ class GodotServer {
     const installed = installedAddonVersion(this.ownProject);
     return installed === null || installed === SERVER_VERSION ? null : installed;
   }
+  editorCodeOnDisk() {
+    const status = this.godotBridge.getStatus();
+    const project = (status.connected ? status.projectPath : undefined) ?? this.ownProject;
+    return project === null || project === "" ? undefined : installedEditorDigest(project);
+  }
   configDisagreement() {
     return this.ownProject === null ? null : configDisagrees(this.ownProject, SERVER_VERSION);
   }
@@ -40158,6 +40608,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);
       }
@@ -40328,7 +40781,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"] }
@@ -40400,8 +40853,8 @@ class GodotServer {
     if (path === undefined) {
       return { ok: false, response: this.createErrorResponse("projectPath is required.") };
     }
-    const file = join22(path, "project.godot");
-    if (!existsSync15(file)) {
+    const file = join23(path, "project.godot");
+    if (!existsSync17(file)) {
       return {
         ok: false,
         response: this.createErrorResponse(`Not a Godot project: ${path}`, [
@@ -40611,13 +41064,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`);
@@ -40665,6 +41135,7 @@ class GodotServer {
     return this.answer(withScanWait({
       ok: true,
       messages: imported.messages,
+      ...imported.messagesOmitted === undefined ? {} : { messagesOmitted: imported.messagesOmitted },
       payload: {
         uidsCreated: given,
         stillWithoutUid: after,
@@ -40715,16 +41186,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);
@@ -40762,7 +41242,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 });
   }
@@ -40780,7 +41272,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,
@@ -40819,9 +41318,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;
       }
@@ -40904,17 +41401,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") ?? [];
@@ -40930,7 +41425,7 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const application = parseProjectGodot(readFileSync19(project.value.file, "utf8"))["application"] ?? {};
+    const application = parseProjectGodot(readFileSync20(project.value.file, "utf8"))["application"] ?? {};
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
@@ -40947,10 +41442,14 @@ class GodotServer {
         continue;
       }
       const outcome = await this.operation(spec.operation, spec.params(args, detailed), project.value.path);
-      info[section] = outcome.ok ? outcome.messages.length > 0 ? { ...outcome.payload, engine_messages: outcome.messages } : outcome.payload : { error: outcome.message, engine_messages: outcome.messages };
+      info[section] = outcome.ok ? { ...outcome.payload, ...engineExtras(outcome) } : { error: outcome.message, ...engineExtras(outcome) };
     }
     return this.jsonTextResponse(info);
   }
+  fileTypes(args) {
+    const named = readStringArray(args, "fileTypes");
+    return named === undefined ? {} : { fileTypes: named };
+  }
   handleSearchProject(args) {
     const project = this.project(args);
     if (!project.ok) {
@@ -40959,16 +41458,7 @@ class GodotServer {
     try {
       return this.jsonTextResponse(searchProject(project.value.path, {
         query: readString(args, "query") ?? "",
-        fileTypes: readStringArray(args, "fileTypes") ?? [
-          "gd",
-          "tscn",
-          "tres",
-          "gdshader",
-          "cfg",
-          "md",
-          "txt",
-          "json"
-        ],
+        ...this.fileTypes(args),
         regex: readBoolean(args, "regex") ?? false,
         caseSensitive: readBoolean(args, "caseSensitive") ?? false,
         maxResults: readPositiveNumber(args, "maxResults") ?? 100
@@ -40991,18 +41481,18 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const folder = dirname15(output.absolutePath);
+    const folder = dirname16(output.absolutePath);
     try {
       mkdirSync12(folder, { recursive: true });
     } catch (error) {
-      return this.createErrorResponse(`Cannot create ${dirname15(output.relativePath)} to export into: ${errorMessage(error)}`);
+      return this.createErrorResponse(`Cannot create ${dirname16(output.relativePath)} to export into: ${errorMessage(error)}`);
     }
     const debug = readBoolean(args, "debug") ?? false;
     const exportLogs = scratchDirectory("export");
     const exportArgs = [
       "--headless",
       "--log-file",
-      join22(exportLogs, "engine.log"),
+      join23(exportLogs, "engine.log"),
       "--path",
       project.value.path,
       debug ? "--export-debug" : "--export-release",
@@ -41010,55 +41500,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 = () => existsSync17(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 && existsSync15(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);
@@ -41070,7 +41523,7 @@ class GodotServer {
       return contained.response;
     }
     const runner = "addons/gdUnit4/bin/GdUnitCmdTool.gd";
-    if (!existsSync15(join22(project.value.path, runner))) {
+    if (!existsSync17(join23(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"
       ]);
@@ -41136,21 +41589,22 @@ class GodotServer {
     if (timedOut && run.process.pid !== undefined) {
       await untilGone([run.process.pid]);
     }
-    const reportsDir = join22(project.value.path, ".godot", ...ours.split("/"));
+    await run.settled;
+    const reportsDir = join23(project.value.path, ".godot", ...ours.split("/"));
     let report = null;
     let reportProblem = null;
     try {
-      const written = existsSync15(reportsDir) ? readdirSync9(reportsDir).filter((name) => name.startsWith("report_")).sort((a, b) => Number(a.slice("report_".length)) - Number(b.slice("report_".length))) : [];
+      const written = existsSync17(reportsDir) ? readdirSync9(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(readFileSync19(join22(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync20(join23(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
     } finally {
       discard(reportsDir, userData);
       try {
-        rmdirSync2(dirname15(reportsDir));
+        rmdirSync2(dirname16(reportsDir));
       } catch {}
     }
     const engineEntries = run.log.select({ severity: "warning", sinceLastCall: false, limit: 200 }).entries.map(aboveTheRunner);
@@ -41163,7 +41617,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;
@@ -41179,7 +41637,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 },
@@ -41216,10 +41674,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,
@@ -41230,13 +41699,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,
@@ -41244,6 +41714,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
@@ -41257,7 +41728,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) {
@@ -41269,8 +41740,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"
       ]);
@@ -41288,7 +41769,7 @@ class GodotServer {
       warnings: diagnostics.length - errors,
       diagnostics,
       ...disagrees
-    }, this.godotBridge.getStatus().addonVersion, SERVER_VERSION, this.godotBridge.getStatus().addonDigest, shippedEditorDigest()));
+    }, this.godotBridge.getStatus().addonVersion, SERVER_VERSION, this.godotBridge.getStatus().addonDigest, shippedEditorDigest(), this.editorCodeOnDisk()));
   }
   whereTheFileDisagrees(diagnostics, args) {
     const messages = diagnostics.map((entry) => asParams(entry)["message"]).filter((message) => typeof message === "string");
@@ -41301,11 +41782,11 @@ class GodotServer {
     const cached = cachedClasses(projectPath);
     const contradicted = cached === null ? [] : contradictedDiagnostics(messages, cached, (resourcePath) => {
       const contained = resolveWithinProject(projectPath, resourcePath);
-      if (!contained.ok || !existsSync15(contained.absolutePath)) {
+      if (!contained.ok || !existsSync17(contained.absolutePath)) {
         return null;
       }
       try {
-        return readFileSync19(contained.absolutePath, "utf8");
+        return readFileSync20(contained.absolutePath, "utf8");
       } catch {
         return null;
       }
@@ -41361,11 +41842,11 @@ class GodotServer {
   }
   sourceOfClass(projectPath, resourcePath) {
     const contained = resolveWithinProject(projectPath, resourcePath);
-    if (!contained.ok || !existsSync15(contained.absolutePath)) {
+    if (!contained.ok || !existsSync17(contained.absolutePath)) {
       return null;
     }
     try {
-      return readFileSync19(contained.absolutePath, "utf8");
+      return readFileSync20(contained.absolutePath, "utf8");
     } catch {
       return null;
     }
@@ -41439,7 +41920,7 @@ class GodotServer {
   }
   breakpointsAtRisk() {
     const status = this.godotBridge.getStatus();
-    if (!status.connected || status.syncsBreakpoints === true) {
+    if (!hasSaidWhoItIs(status) || status.syncsBreakpoints === true) {
       return {};
     }
     return {
@@ -41494,26 +41975,34 @@ class GodotServer {
       restartSettled(this.ownProject);
       return null;
     }
-    return owed;
+    return { note: owed, underway: restartUnderway(owed) };
   }
   async getEditorStatusPayload() {
     const status = this.godotBridge.getStatus();
     const launchedIsUp = !status.connected && await this.launchedEditorIsUp();
     const isPortConflict = this.bridgeStartupError?.includes("EADDRINUSE") ?? false;
-    const stale = status.connected && editorIsStale(status.addonVersion, SERVER_VERSION, status.addonDigest, shippedEditorDigest());
+    const greeted = hasSaidWhoItIs(status);
+    const stale = greeted && editorIsStale(status.addonVersion, SERVER_VERSION, status.addonDigest, shippedEditorDigest());
     const unfinished = this.restartLeftUnfinished(status.connected);
     return {
       ...status,
       serverVersion: SERVER_VERSION,
-      addonIsStale: status.connected ? stale : undefined,
+      addonIsStale: greeted ? stale : undefined,
+      greeting: status.connected && !greeted ? "The editor has connected and has not yet said who it is: its project, pid, addon version and ports arrive with its greeting a moment after the socket opens, later while it imports. Ask again for them." : undefined,
       bridgeAvailable: this.bridgeStartupError === null,
-      mayYetConnect: status.connected ? undefined : unfinished !== null ? false : anEditorIsStillComing(status.listeningSince, launchedIsUp),
-      restartInterrupted: unfinished === null ? undefined : {
-        quitEditorPid: unfinished.editorPid,
-        quitAt: unfinished.quitAt,
-        byServerPid: unfinished.byPid,
+      mayYetConnect: status.connected ? undefined : unfinished !== null ? unfinished.underway : anEditorIsStillComing(status.listeningSince, launchedIsUp),
+      restartInterrupted: unfinished === null || unfinished.underway ? undefined : {
+        quitEditorPid: unfinished.note.editorPid,
+        quitAt: unfinished.note.quitAt,
+        byServerPid: unfinished.note.byPid,
         note: "A restart begun by a previous gdharness server asked this project's editor to quit, and that server was ended before it could start the editor again, so nothing is coming. editor_launch open starts one, and clears this."
       },
+      restartUnderway: unfinished === null || !unfinished.underway ? undefined : {
+        quitEditorPid: unfinished.note.editorPid,
+        quitAt: unfinished.note.quitAt,
+        byServerPid: unfinished.note.byPid,
+        note: `A restart of this project's editor is under way: gdharness server pid ${unfinished.note.byPid} asked it to quit at ${unfinished.note.quitAt} and is starting it again. Wait for it rather than opening another.`
+      },
       awaitingLaunchedEditor: status.connected || !launchedIsUp ? undefined : this.launchedEditor?.pid ?? undefined,
       ...status.connected ? this.whatTheLaunchedEditorDropped() : {},
       startupError: this.bridgeStartupError,
@@ -41523,8 +42012,9 @@ class GodotServer {
         port: this.godotBridge.configuredPort,
         note: `The gdharness server this one replaced, pid ${this.handingOverFrom}, still holds port ${this.godotBridge.configuredPort} and is standing down; this server takes the port when it lets go, and takes another after ${HANDOVER_MS / 1000} seconds if it does not.`
       },
-      staleNote: stale ? addonMismatch(status.addonVersion, SERVER_VERSION, status.addonDigest, shippedEditorDigest()) : undefined,
-      addonNote: status.connected ? sameCodeNote(status.addonVersion, SERVER_VERSION, status.addonDigest, shippedEditorDigest()) : undefined,
+      staleNote: stale ? addonMismatch(status.addonVersion, SERVER_VERSION, status.addonDigest, shippedEditorDigest(), this.editorCodeOnDisk()) : undefined,
+      addonNote: greeted ? sameCodeNote(status.addonVersion, SERVER_VERSION, status.addonDigest, shippedEditorDigest()) : undefined,
+      startedByAnEditorNote: status.startedByAnEditor === true ? "Another editor started this one: Godot's own restart, or the project manager opening a project. None of the arguments a server gave the editor before it reached this one, so it serves the ports its editor settings name (and none at all while another editor holds those, when the script and debug tools reach that editor instead), its console is not captured, and it restarts itself. Close it and use editor_launch open to have an editor this server started." : undefined,
       ...this.breakpointsAtRisk(),
       retryingBridge: this.bridgeRetry === null ? undefined : true,
       announcedAt: this.announcedAt ?? undefined,
@@ -41553,7 +42043,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;
@@ -41649,7 +42140,7 @@ class GodotServer {
       return null;
     }
     try {
-      return settingKeys(readFileSync19(join22(projectPath, "project.godot"), "utf8"));
+      return settingKeys(readFileSync20(join23(projectPath, "project.godot"), "utf8"));
     } catch {
       return null;
     }
@@ -41662,17 +42153,33 @@ class GodotServer {
         "editor_status says whether the bridge is up and what has reached it"
       ]);
     }
-    const settingsBefore = this.settingKeysOf(before.projectPath);
+    if (!hasSaidWhoItIs(before)) {
+      const settled = await this.waitForBridge(() => hasSaidWhoItIs(this.godotBridge.getStatus()) || !this.godotBridge.isConnected(), Date.now() + GREETING_WAIT_MS);
+      if (!settled) {
+        return this.createErrorResponse(`The editor has connected and has not said who it is within ${GREETING_WAIT_MS / 1000}s, so whether this server or the editor itself restarts it cannot be told.`, [
+          "editor_status says when it has, under greeting while it has not",
+          "Then ask for the restart again"
+        ]);
+      }
+      return this.handleRestartEditor(args);
+    }
     const mine = before.openedByAServer === true && before.projectPath !== undefined;
+    if (!mine && args["hidden"] === true) {
+      return this.createErrorResponse("This editor was opened by hand, and restarts itself as it was, so it cannot come back hidden.", [
+        "Close it, then editor_launch open with hidden: true starts a hidden one this server can restart",
+        "editor_launch restart without hidden restarts it as it is"
+      ]);
+    }
+    const settingsBefore = this.settingKeysOf(before.projectPath);
     const asked = mine ? await this.startItAgain(before.projectPath ?? "", before.editorPid, args["hidden"] === true) : await this.handleViaBridge("restart_editor", {});
     if (asked.isError === true) {
       return asked;
     }
     const startedAt = before.connectedAt?.getTime() ?? 0;
     const began = Date.now();
-    const back = await this.waitForBridge(() => theEditorHasComeBack(this.godotBridge.getStatus(), startedAt), began + EDITOR_RESTART_TIMEOUT_MS);
+    const back = await this.waitForBridge(() => theEditorHasComeBack(this.godotBridge.getStatus(), startedAt), began + editorRestartTimeoutMs());
     if (!back) {
-      return this.createErrorResponse(`The editor was asked to restart and has not come back within ${EDITOR_RESTART_TIMEOUT_MS / 1000}s.`, [
+      return this.createErrorResponse(`The editor was asked to restart and has not come back within ${editorRestartTimeoutMs() / 1000}s.`, [
         "It may be asking what to do about an unsaved scene: look at the editor window",
         "An addon that no longer parses stops the editor reaching this server",
         "editor_status says whether anything has reached the bridge since"
@@ -41686,18 +42193,27 @@ class GodotServer {
       addonVersion: now.addonVersion,
       serverVersion: SERVER_VERSION,
       addonIsStale: editorIsStale(now.addonVersion, SERVER_VERSION, now.addonDigest, shippedEditorDigest()),
-      staleNote: addonMismatch(now.addonVersion, SERVER_VERSION, now.addonDigest, shippedEditorDigest()),
+      staleNote: addonMismatch(now.addonVersion, SERVER_VERSION, now.addonDigest, shippedEditorDigest(), this.editorCodeOnDisk()),
       ...this.whatTheEditorDropped(settingsBefore, after),
       tookMs: Date.now() - began
     });
   }
-  whatTheLaunchedEditorDropped() {
+  settleTheLaunchReading() {
     const watched = this.launchedFrom;
-    if (watched === null) {
-      return {};
+    const status = this.godotBridge.getStatus();
+    if (watched === null || !hasSaidWhoItIs(status)) {
+      return;
     }
     this.launchedFrom = null;
-    return this.whatTheEditorDropped(watched.before, this.settingKeysOf(watched.projectPath));
+    if (status.editorPid === undefined || status.editorPid !== this.launchedEditor?.pid) {
+      return;
+    }
+    this.launchedDropped = this.whatTheEditorDropped(watched.before, this.settingKeysOf(watched.projectPath));
+  }
+  whatTheLaunchedEditorDropped() {
+    const dropped = this.launchedDropped ?? {};
+    this.launchedDropped = null;
+    return dropped;
   }
   whatTheEditorDropped(before, after) {
     return settingsDroppedReport(before, after);
@@ -41723,7 +42239,14 @@ class GodotServer {
       restartSettled(projectPath);
       return asked;
     }
-    await this.waitForBridge(() => !alive(editorPid), Date.now() + EDITOR_RESTART_TIMEOUT_MS);
+    const gone = await this.waitForBridge(() => !alive(editorPid), Date.now() + editorRestartTimeoutMs());
+    if (!gone) {
+      restartSettled(projectPath);
+      return this.createErrorResponse(`The editor was asked to go and pid ${editorPid ?? "unknown"} is still running after ${editorRestartTimeoutMs() / 1000}s, so no replacement was started: it would find the language server and debug adapter ports still held.`, [
+        "It may be asking what to do about unsaved changes, or a script may be holding up its exit",
+        `editor_launch open starts one on ${projectPath} once it has gone`
+      ]);
+    }
     const opened = await this.openAnEditor(engine.value, projectPath, ports, hidden);
     restartSettled(projectPath);
     if (opened.error !== null) {
@@ -41754,6 +42277,10 @@ class GodotServer {
         "Another project wants its own gdharness server, which is its own harness session"
       ]);
     }
+    const refused = this.anEditorThatCannotConnect(project.value.path);
+    if (refused !== null) {
+      return refused;
+    }
     const engine = await this.engine();
     if (!engine.ok) {
       return engine.response;
@@ -41778,6 +42305,27 @@ class GodotServer {
       settingsNote: before === null ? "project.godot could not be read before this editor was opened, so nothing here will be able to say what the import saved away. Opening a project rewrites the file and drops any key sitting at its own default." : before.size === 0 ? undefined : "Opening a project imports it and saves project.godot, and Godot drops any key sitting at its own default. editor_status names anything lost under settingsDropped once this editor has connected."
     });
   }
+  anEditorThatCannotConnect(projectPath) {
+    if (this.ownProject !== null && !isSameDirectory(this.ownProject, projectPath)) {
+      return this.createErrorResponse(`This server serves ${this.ownProject}, and an editor of ${projectPath} would dial that project's own server rather than this one.`, [
+        "Open it from that project's own gdharness session",
+        `editor_launch with projectPath ${this.ownProject} opens the editor this server serves`
+      ]);
+    }
+    const report = inspectProject(projectPath);
+    const installed = report.addons.some((addon) => addon.name === "gdharness_editor" && addon.installed);
+    if (!installed || !report.pluginsEnabled.includes("gdharness_editor")) {
+      return this.createErrorResponse(`The gdharness editor addon is not ${installed ? "enabled" : "installed"} in ${projectPath}, so an editor opened on it would never reach this server.`, installed ? [
+        "gdharness setup in the project enables it",
+        "Or enable it under Project Settings, Plugins, in an editor opened by hand"
+      ] : ["gdharness setup in the project installs and enables it"]);
+    }
+    const owed = restartOwed(projectPath);
+    if (owed !== null && restartUnderway(owed)) {
+      return this.createErrorResponse(`A restart of this project's editor is under way: gdharness server pid ${owed.byPid} asked it to quit at ${owed.quitAt} and is starting it again, so opening another would put two editors on one project.`, ["editor_status says when it has connected"]);
+    }
+    return null;
+  }
   async openAnEditor(engine, projectPath, ports, hidden) {
     clearEditorLog(projectPath);
     const launched = await launchOutsideTheTree({
@@ -41812,6 +42360,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) {
@@ -41906,7 +42461,7 @@ class GodotServer {
   }
   async runtimeUp(projectPath, before, budget, withArgs) {
     const budgetMs = budget.ms;
-    if (!existsSync15(join22(projectPath, RUNTIME_AUTOLOAD.path))) {
+    if (!existsSync17(join23(projectPath, RUNTIME_AUTOLOAD.path))) {
       return runtimeVerdict(null, { addon: false, budgetMs, heldAt: null, running: false, withArgs });
     }
     let asking = null;
@@ -41915,7 +42470,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: () => {
@@ -41939,11 +42494,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,
@@ -42027,7 +42590,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,
@@ -42142,7 +42711,7 @@ class GodotServer {
       return 0;
     }
     try {
-      return reportAlreadyInTranscript(readFileSync19(game.transcript), readFileSync19(report));
+      return reportAlreadyInTranscript(readFileSync20(game.transcript), readFileSync20(report));
     } catch (error) {
       this.logDebug(`Could not compare a picked-up run's report with its transcript: ${errorMessage(error)}`);
       return 0;
@@ -42156,6 +42725,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();
@@ -42174,8 +42755,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";
@@ -42184,23 +42773,30 @@ class GodotServer {
       pid: running.pid,
       transcript: running.transcript ?? "",
       startedAt: running.startedAt,
+      ...running.startedBy === undefined ? {} : { startedBy: running.startedBy },
       projectPath: running.projectPath ?? "",
       arguments: [],
       ...running.command === undefined ? {} : { command: running.command }
     };
-    if (!await stillTheRecordedRun(startedAs)) {
+    const why = await whyNotStillTheRecordedRun(startedAs);
+    if (why !== null) {
       clearTheRecord();
       running.endedHere = null;
-      running.log.record("warning", `This run was not ended here: pid ${running.pid} no longer answers as the process the run was started as, so nothing was signalled. If that process is still the game, end it yourself; if it is not, it belongs to something else.`);
+      running.log.record("warning", `This run was not ended here: pid ${running.pid} no longer answers as the process the run was started as (${why}), so nothing was signalled. If that process is still the game, end it yourself; if it is not, it belongs to something else.`);
       return "refused";
     }
     const signalled = await runningAs(running.pid);
     const described = signalled === null ? "nothing it would name" : `${signalled.kind}: ${signalled.text}`;
     let landed = true;
+    let declined = null;
     try {
       process.kill(running.pid);
-    } catch {
+    } catch (error) {
       landed = false;
+      const code = error.code;
+      if (code !== "ESRCH") {
+        declined = code ?? errorMessage(error);
+      }
     }
     const gone = await untilGone([running.pid]);
     if (gone) {
@@ -42211,11 +42807,11 @@ class GodotServer {
       running.exitSignal = "SIGTERM";
     }
     clearTheRecord();
-    running.log.record("info", landed ? `gdharness ended pid ${running.pid}, which the operating system described as ${described}.` : `gdharness signalled pid ${running.pid} and it was already gone; the operating system had described it as ${described}.`);
+    running.log.record(gone ? "info" : "warning", declined !== null ? `gdharness could not signal pid ${running.pid}: the operating system refused it (${declined}). It had described that process as ${described}.` : !gone ? `gdharness signalled pid ${running.pid}, which the operating system described as ${described}, and it was still running ${STOP_WAIT_MS / 1000} seconds later.` : landed ? `gdharness ended pid ${running.pid}, which the operating system described as ${described}.` : `gdharness signalled pid ${running.pid} and it was already gone; the operating system had described it as ${described}.`);
     return gone ? "gone" : "lingering";
   }
   spawnGame(godotPath, cmdArgs, env) {
-    const child = spawn3(godotPath, cmdArgs, { stdio: ["ignore", "pipe", "pipe"], ...env ? { env } : {} });
+    const child = spawn4(godotPath, cmdArgs, { stdio: ["ignore", "pipe", "pipe"], ...env ? { env } : {} });
     const cancelled = callSignal();
     if (cancelled !== undefined) {
       const end = () => {
@@ -42255,7 +42851,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;
     });
@@ -42265,7 +42860,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();
@@ -42275,12 +42891,13 @@ class GodotServer {
       command: godotPath,
       args: cmdArgs,
       ...env === undefined ? {} : { env },
-      run: { transcript: transcript.path, startedAt, projectPath },
+      run: { transcript: transcript.path, startedAt, projectPath, ...this.servedBy() },
       ...desktop === undefined ? {} : { desktop }
     });
     if ("error" in launched) {
       return launched;
     }
+    const startedBy = Date.now();
     sweepTranscripts();
     return {
       pid: launched.pid,
@@ -42289,6 +42906,7 @@ class GodotServer {
       readOffset: 0,
       projectPath,
       startedAt,
+      startedBy,
       command: godotPath,
       exitCode: null,
       exitSignal: null,
@@ -42347,7 +42965,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,
@@ -42404,6 +43023,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;
@@ -42482,8 +43126,9 @@ class GodotServer {
   }
   async adoptRecordedRun() {
     const project = this.ourProject();
-    const record = project === null ? null : readRunRecord(project);
-    if (record === null || !this.couldBeOurs(record.projectPath)) {
+    const found = project === null ? [] : [readRunRecord(project), this.startedForUs(project)];
+    const record = found.reduce((newest, one) => one !== null && (newest === null || one.startedAt > newest.startedAt) ? one : newest, null);
+    if (record === null || !(this.couldBeOurs(record.projectPath) || this.couldBeOurs(record.servedBy ?? ""))) {
       return null;
     }
     const adopted = {
@@ -42493,6 +43138,7 @@ class GodotServer {
       readOffset: 0,
       projectPath: record.projectPath === "" ? null : record.projectPath,
       startedAt: record.startedAt,
+      ...record.startedBy === undefined ? {} : { startedBy: record.startedBy },
       ...record.command === undefined ? {} : { command: record.command },
       exitCode: null,
       exitSignal: null,
@@ -42513,6 +43159,13 @@ class GodotServer {
     this.activeProcess = adopted;
     return adopted;
   }
+  servedBy() {
+    const mine = this.ourProject();
+    return mine === null ? {} : { servedBy: mine };
+  }
+  startedForUs(project) {
+    return everyRunRecord().find((one) => one.servedBy !== undefined && isSameDirectory(one.servedBy, project) && !(one.projectPath !== "" && isSameDirectory(one.projectPath, project))) ?? null;
+  }
   nothingOfOursIsRunning() {
     const status = this.godotBridge.getStatus();
     const noEditor = !status.connected ? " No editor is connected, so a game the editor is playing cannot be seen from here at all:" + " editor_status says whether one is on its way, and a run of yours that is still up is" + " reachable again once it is." : "";
@@ -42604,6 +43257,7 @@ class GodotServer {
         resolve(false);
       });
     });
+    await boot.settled;
     const errors = boot.log.count("error");
     const warnings = boot.log.count("warning");
     return this.jsonTextResponse({
@@ -42678,22 +43332,20 @@ class GodotServer {
   }
   async handleEditorConsole(args) {
     const status = this.godotBridge.getStatus();
-    const projectPath = status.projectPath ?? this.ownProject ?? undefined;
-    if (projectPath === undefined) {
-      return this.createErrorResponse("No editor is connected, so there is no console to read.", [
-        "editor_status says whether one is connected and whether it may yet be",
-        "editor_launch opens one, and an editor opened here has its console captured"
-      ]);
+    const greeted = hasSaidWhoItIs(status);
+    const launched = greeted ? null : this.launchedEditor?.pid ?? null;
+    if (!greeted && launched === null && status.connected) {
+      return this.createErrorResponse("The editor has connected and has not yet said who it is, so whose console to read cannot be told yet.", ["Ask again in a moment; editor_status shows greeting until it has"]);
     }
-    const launched = status.connected ? null : this.launchedEditor?.pid ?? null;
-    if (!status.connected && launched === null) {
+    const projectPath = status.projectPath ?? this.ownProject ?? undefined;
+    if (projectPath === undefined || !greeted && launched === null) {
       return this.createErrorResponse("No editor is connected, so there is no console to read.", [
         "editor_status says whether one is connected and whether it may yet be",
         "editor_launch opens one, and an editor opened here has its console captured"
       ]);
     }
-    const editorPid = status.connected ? status.editorPid ?? null : launched;
-    const console2 = editorConsole(projectPath, editorPid, status.connected ? status.openedByAServer === true : true);
+    const editorPid = greeted ? status.editorPid ?? null : launched;
+    const console2 = editorConsole(projectPath, editorPid, greeted ? status.openedByAServer === true : true);
     if ("kind" in console2) {
       return this.createErrorResponse(theConsoleWasNotCaptured(console2, projectPath), [
         "editor_launch restart replaces this editor with one whose console is captured",
@@ -42745,6 +43397,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);
@@ -42780,7 +43433,7 @@ class GodotServer {
       notes.push(endedWithoutACode({
         throughEditor: run.throughEditor,
         announced: announced !== undefined || run.announcedPid !== undefined,
-        couldAnnounce: run.projectPath !== null && existsSync15(join22(run.projectPath, RUNTIME_AUTOLOAD.path)),
+        couldAnnounce: run.projectPath !== null && existsSync17(join23(run.projectPath, RUNTIME_AUTOLOAD.path)),
         endedHere: typeof run.endedHere === "string",
         pickedUp: run.pickedUp === true
       }));
@@ -42788,6 +43441,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.`);
@@ -42803,8 +43459,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,
@@ -42839,6 +43496,7 @@ class GodotServer {
     if (elsewhere !== null) {
       return elsewhere;
     }
+    await this.tieThePlayedGame(stopped);
     this.drainEditorOutput(stopped);
     this.drainTranscript(stopped);
     const wasRunning = await this.runStillGoing(stopped);
@@ -42847,7 +43505,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])) {
@@ -42862,13 +43520,14 @@ class GodotServer {
       endedPid,
       throughEditor: stopped.throughEditor,
       exitSignal: stopped.exitSignal,
-      errors: stopped.log.count("error")
+      clean: cleanVerdict(stopped)
     });
     return this.jsonTextResponse({
       stopped: verdict.stopped,
       through: stopped.throughEditor ? "editor" : "gdharness",
       endedPid: verdict.endedPid,
       notSignalled: verdict.notSignalled,
+      stillGoing: verdict.stillGoing,
       ...childrenFields(ended),
       exitedBeforeStop: !wasRunning,
       exitCode: stopped.exitCode,
@@ -42876,6 +43535,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)
     });
@@ -42925,12 +43585,13 @@ class GodotServer {
       await announcementEnded(pid);
     }
     return this.jsonTextResponse({
-      stopped: true,
+      stopped: gone,
       through: "gdharness",
-      endedPid: pid,
+      endedPid: gone ? pid : undefined,
+      stillGoing: gone ? undefined : pid,
       ...childrenFields(ended),
       exitedBeforeStop: !landed,
-      note: `${landed ? `pid ${pid} was ended: a game of this project that no server here was holding,` : `pid ${pid} had already gone when it was signalled: a game of this project that no server here was holding,`} identified by its announcement and by its command line, ${read.executable} run with --path ${read.projectPath ?? ""}. Nothing here read what it printed or holds its exit code, so neither is in this answer.${gone ? "" : ` It had not exited ${STOP_WAIT_MS / 1000} seconds after being told to, so it may still be going: editor_status says whether it is.`} ${aboutTheChildren(ended, false)}`
+      note: `${!gone ? `pid ${pid} was told to end and was still running ${STOP_WAIT_MS / 1000} seconds later, so it has not stopped: a game of this project that no server here was holding,` : landed ? `pid ${pid} was ended: a game of this project that no server here was holding,` : `pid ${pid} had already gone when it was signalled: a game of this project that no server here was holding,`} identified by its announcement and by its command line, ${read.executable} run with --path ${read.projectPath ?? ""}. Nothing here read what it printed or holds its exit code, so neither is in this answer.${gone ? "" : " editor_status says when it has gone."} ${aboutTheChildren(ended, false)}`
     });
   }
   async whatTheRunStarted(run) {
@@ -43077,7 +43738,8 @@ class GodotServer {
       }
     }
     const after = projectPath === "" || busy ? null : cachedClasses(projectPath);
-    const lost = before === null || after === null ? [] : [...before.keys()].filter((name) => !after.has(name));
+    const declaredNow = before === null || after === null ? null : declaredClasses(projectPath);
+    const lost = before === null || after === null || declaredNow === null ? [] : [...before.keys()].filter((name) => !after.has(name) && declaredNow.has(name));
     if (lost.length > 0) {
       this.noteAShortListEditor(projectPath);
     }
@@ -43088,7 +43750,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");
@@ -43096,29 +43763,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)}` };
@@ -43126,7 +43800,7 @@ class GodotServer {
     }
     const checked = busy ? { unseen: [] } : await this.classesTheEditorCannotSee(args);
     const unseen = checked.unseen;
-    const broughtIn = blind.unseen.map((one) => one.className).filter((name) => !unseen.some((still) => still.className === name));
+    const broughtIn = busy ? [] : blind.unseen.map((one) => one.className).filter((name) => !unseen.some((still) => still.className === name));
     const dependents = busy || projectPath === "" || broughtIn.length === 0 ? null : await this.reloadDependents(projectPath, broughtIn);
     const stillGone = lost.filter((name) => !restored.includes(name));
     const notes = [];
@@ -43140,7 +43814,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.`);
@@ -43155,6 +43829,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,
@@ -43181,7 +43856,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;
       }
@@ -43189,9 +43865,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({
@@ -43263,6 +43940,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") {
@@ -43335,7 +44041,7 @@ class GodotServer {
       ]);
     }
     try {
-      return this.jsonTextResponse(markIfStale(await this.godotBridge.invokeTool(toolName, args), this.godotBridge.getStatus().addonVersion, SERVER_VERSION, this.godotBridge.getStatus().addonDigest, shippedEditorDigest()));
+      return this.jsonTextResponse(markIfStale(await this.godotBridge.invokeTool(toolName, args), this.godotBridge.getStatus().addonVersion, SERVER_VERSION, this.godotBridge.getStatus().addonDigest, shippedEditorDigest(), this.editorCodeOnDisk()));
     } catch (error) {
       return this.createErrorResponse(`The editor answered ${toolName} with an error: ${errorMessage(error)}`);
     }
@@ -43391,7 +44097,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) || !existsSync15(join22(project, RUNTIME_AUTOLOAD.path)) || !await this.runStillGoing(run)) {
+    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync17(join23(project, RUNTIME_AUTOLOAD.path)) || !await this.runStillGoing(run)) {
       return null;
     }
     const already = runtimesAnnounced().running;
@@ -43415,11 +44121,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()) {
@@ -43471,7 +44181,7 @@ class GodotServer {
       }
     }
     const screenshotDir = expectsScreenshot ? scratchDirectory("runtime-screenshot") : null;
-    const screenshotPath = screenshotDir ? join22(screenshotDir, "capture.png") : null;
+    const screenshotPath = screenshotDir ? join23(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) {
@@ -43512,7 +44222,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: readFileSync19(screenshotPath).toString("base64"), mimeType: "image/png" }
+          { type: "image", data: readFileSync20(screenshotPath).toString("base64"), mimeType: "image/png" }
         ]
       };
     } finally {
@@ -43609,10 +44319,11 @@ class GodotServer {
   }
 }
 async function runGodotServer() {
+  delete process.env[EDITOR_PID_VARIABLE];
   const server = new GodotServer;
   await server.run();
 }
-var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run5, __dirname2, EDITOR_RESTART_TIMEOUT_MS = 90000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, PLAY_STARTS_WITHIN_MS = 30000, STOP_WAIT_MS = 1e4, EXIT_REPORTED_WITHIN_MS = 2000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, MOST_GROUPS = 20, VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, CONSOLE_WATCH_MS = 250, BOUNDARY_WAIT_MS = 2000, HANDOVER_MS, HANDOVER_POLL_MS = 250, CACHE_WRITE_MS = 2000, SCAN_WAIT_MS = 30000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, SCAN_SETTLED_MS = 500, REIMPORT_TIMEOUT_MS = 300000, AUDIO_BUS_OPS, STALLED_AFTER_MS = 30000, DEPENDED_FAILED = "Failed to compile depended scripts", WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/";
+var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run4, __dirname2, GREETING_WAIT_MS = 1e4, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, PLAY_STARTS_WITHIN_MS = 30000, STOP_WAIT_MS = 1e4, EXIT_REPORTED_WITHIN_MS = 2000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, MOST_GROUPS = 20, VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, CONSOLE_WATCH_MS = 250, BOUNDARY_WAIT_MS = 2000, HANDOVER_MS, HANDOVER_POLL_MS = 250, CACHE_WRITE_MS = 2000, SCAN_WAIT_MS = 30000, STREAMS_GRACE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, SCAN_SETTLED_MS = 500, REIMPORT_TIMEOUT_MS = 300000, AUDIO_BUS_OPS, STALLED_AFTER_MS = 30000, DEPENDED_FAILED = "Failed to compile depended scripts", WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/";
 var init_server3 = __esm(() => {
   init_mcp();
   init_stdio2();
@@ -43628,6 +44339,7 @@ var init_server3 = __esm(() => {
   init_dap_client();
   init_desktop();
   init_editor_log();
+  init_engine_run();
   init_errors();
   init_game_log();
   init_godot_bridge();
@@ -43652,8 +44364,8 @@ var init_server3 = __esm(() => {
   init_setup();
   init_tool_definitions();
   init_update_check();
-  run5 = promisify6(execFile6);
-  __dirname2 = dirname15(fileURLToPath5(import.meta.url));
+  run4 = promisify5(execFile5);
+  __dirname2 = dirname16(fileURLToPath5(import.meta.url));
   CONSOLE_WRAPPER = /_console(\.exe)?$/i;
   LONGEST_BOOT_NOTED_MS = 5 * 60000;
   VALUE_NAMES = {
@@ -43702,8 +44414,8 @@ var init_server3 = __esm(() => {
 init_bridge_announce();
 init_errors();
 init_godot_path();
-import { existsSync as existsSync16 } from "node:fs";
-import { join as join23, resolve as resolve6 } from "node:path";
+import { existsSync as existsSync18 } from "node:fs";
+import { join as join24, resolve as resolve6 } from "node:path";
 
 // src/harnesses.ts
 import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
@@ -44413,27 +45125,37 @@ function registered(harness, projectPath) {
 }
 function recordedEnginePath(projectPath) {
   for (const harness of HARNESSES) {
-    if (harness.scope !== "project" || harness.toml || harness.yaml || harness.snippet) {
+    if (harness.scope !== "project") {
       continue;
     }
-    const path = configPath(harness, projectPath);
-    if (!existsSync4(path)) {
-      continue;
-    }
-    let parsed;
-    try {
-      parsed = JSON.parse(readFileSync2(path, "utf8"));
-    } catch {
-      continue;
-    }
-    const entry = reach(reach(parsed, harness.container), SERVER_KEY);
-    const named = reach(reach(entry, harness.shape === "opencode" ? "environment" : "env"), "GODOT_PATH");
+    const named = reach(entryEnvironment(harness, projectPath), "GODOT_PATH");
     if (typeof named === "string" && named !== "" && existsSync4(named)) {
       return named;
     }
   }
   return null;
 }
+function entryEnvironment(harness, projectPath) {
+  if (harness.toml || harness.yaml || harness.snippet) {
+    return;
+  }
+  const path = configPath(harness, projectPath);
+  if (!existsSync4(path)) {
+    return;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync2(path, "utf8"));
+  } catch {
+    return;
+  }
+  const entry = reach(reach(parsed, harness.container), SERVER_KEY);
+  return reach(entry, harness.shape === "opencode" ? "environment" : "env");
+}
+function servedProject(harness, projectPath) {
+  const named = reach(entryEnvironment(harness, projectPath), "GDHARNESS_PROJECT");
+  return typeof named === "string" && named !== "" ? named : null;
+}
 function reach(held, key) {
   return typeof held === "object" && held !== null && !Array.isArray(held) ? held[key] : undefined;
 }
@@ -44571,6 +45293,7 @@ function taken(harness, path, held, stripped) {
 // src/cli.ts
 init_headless();
 init_issues();
+init_paths();
 
 // src/prompt.ts
 import process8 from "node:process";
@@ -44602,8 +45325,8 @@ init_setup();
 // src/skill.ts
 init_setup();
 init_tool_definitions();
-import { existsSync as existsSync10, mkdirSync as mkdirSync5, readdirSync as readdirSync5, rmSync as rmSync6, writeFileSync as writeFileSync7 } from "node:fs";
-import { basename as basename3, dirname as dirname5, join as join11 } from "node:path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync5, readdirSync as readdirSync5, rmSync as rmSync6, writeFileSync as writeFileSync7 } from "node:fs";
+import { basename as basename3, dirname as dirname6, join as join11 } from "node:path";
 
 // src/tool-reference.ts
 init_headless_operations();
@@ -44736,9 +45459,10 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
 - Read \`editor_output\` after every run. It returns the engine's errors and warnings as entries
   with their backtraces, and a \`clean\` verdict, so a run that printed an error is one call away
   from being known. For a run the editor plays, the errors come from the game through the runtime
-  addon, so a played game without the addon is judged on its prints alone and \`clean\` there says
-  less. For a long run it also names a transcript file: read that for output and this
-  answer for state. Never decide a run has ended by watching the file stop growing, or a process
+  addon, so a played game without the addon answers \`errorsUnread\` and no \`clean\`, since
+  what it raised reached nothing the server reads. For a long run it also names a transcript file:
+  read that for output and this answer for state. Never decide a run has ended by watching the
+  file stop growing, or a process
   list, or a timeout; a bench between prints looks exactly like a bench that died to everything else.
   \`endedBy\` says whether gdharness ended it, and \`running\` is asked of the operating system
   whenever there is a process to ask about: every run started through \`editor_run\`, and every
@@ -44768,7 +45492,7 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
 | Where a control is, and whether it is visible | \`runtime_inspect\` \`find\`, \`rect\` |
 | What a property reads right now, on a node whose path you already hold | \`runtime_inspect\` \`property\`, \`runtime_invoke\` |
 | What a property on an object a node holds reads | the same two, with colons: \`_game:clock:speed\` |
-| Which control holds the focus, or anything only a method answers | the same path with a step written as a call, \`get_viewport():gui_get_focus_owner\`, which calls a method taking no arguments and walks into what it returned |
+| Which control holds the focus, or anything only a method answers | the same path with a step written as a call, \`get_viewport():gui_get_focus_owner\`, which calls a method taking no arguments that only reads and walks into what it returned |
 | Press a button | \`runtime_input click\` with \`says\` and the words on it, which finds it and presses it in the same frame and says what was under the pointer. A \`find\` and then a click by the path it answered is two calls over a generated path, and a panel that rebuilds between them frees the button first; \`nodePath\` narrows where \`says\` looks, and several matches are refused with an \`index\` for each |
 | Press the next thing after a click that changed screen | \`runtime_wait until\` with \`says\` and a word the new screen shows (no \`nodePath\` needed: without one the whole game is searched), then the click. A click sent straight after a screen change lands on a control the new screen is about to free, answers \`landed: true\`, and does nothing; a frame count is a number nobody can pick correctly across a cold start and a warm one, and waiting for the words answered in about 130ms where twenty frames had not been enough |
 | Fill in a field | \`runtime_input click\` on it, then \`runtime_input text\` with \`replace\`; a submitted field has to be clicked again |
@@ -44918,9 +45642,9 @@ function everySkillDirectory(projectPath, harnesses) {
 function removeSkill(directories, projectPath) {
   const removed = [];
   for (const directory of directories) {
-    if (existsSync10(directory)) {
+    if (existsSync11(directory)) {
       rmSync6(directory, { recursive: true, force: true });
-      pruneEmpty(dirname5(directory), projectPath);
+      pruneEmpty(dirname6(directory), projectPath);
       removed.push(directory);
     }
   }
@@ -44934,17 +45658,17 @@ function pruneEmpty(directory, projectPath) {
       return;
     }
     rmSync6(path, { recursive: true, force: true });
-    path = dirname5(path);
+    path = dirname6(path);
   }
 }
 function writeSkill(directories, version) {
   const files = skillFiles(version);
   return directories.map((directory) => {
-    const replaced = existsSync10(directory);
+    const replaced = existsSync11(directory);
     rmSync6(directory, { recursive: true, force: true });
     for (const [name, contents] of files) {
       const path = join11(directory, name);
-      mkdirSync5(dirname5(path), { recursive: true });
+      mkdirSync5(dirname6(path), { recursive: true });
       writeFileSync7(path, contents, "utf8");
     }
     return { path: directory, replaced };
@@ -44952,18 +45676,18 @@ function writeSkill(directories, version) {
 }
 
 // src/version.ts
-import { readFileSync as readFileSync9 } from "node:fs";
-import { dirname as dirname6, join as join12 } from "node:path";
+import { readFileSync as readFileSync10 } from "node:fs";
+import { dirname as dirname7, join as join12 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function getLocalVersion() {
-  const currentDirectory = dirname6(fileURLToPath2(import.meta.url));
+  const currentDirectory = dirname7(fileURLToPath2(import.meta.url));
   const packageCandidates = [
     join12(currentDirectory, "..", "package.json"),
     join12(currentDirectory, "..", "..", "package.json")
   ];
   for (const packagePath of packageCandidates) {
     try {
-      const value = JSON.parse(readFileSync9(packagePath, "utf-8"));
+      const value = JSON.parse(readFileSync10(packagePath, "utf-8"));
       if (typeof value === "object" && value !== null && "name" in value && value.name === "gdharness" && "version" in value && typeof value.version === "string") {
         return value.version;
       }
@@ -44981,7 +45705,7 @@ class UsageError extends Refusal {
 function projectArgument(at) {
   const named = args.slice(at).find((value) => !value.startsWith("--"));
   const projectPath = resolve6(named ?? ".");
-  if (!existsSync16(join23(projectPath, "project.godot"))) {
+  if (!existsSync18(join24(projectPath, "project.godot"))) {
     throw new UsageError(`Not a Godot project: ${projectPath} holds no project.godot.`);
   }
   return projectPath;
@@ -45020,7 +45744,7 @@ async function registerRuntime(godot, projectPath) {
     return;
   }
   console.log(`${RUNTIME_AUTOLOAD.name} autoload left at ${named}, which this project registers itself`);
-  if (!existsSync16(join23(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
+  if (!existsSync18(join24(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
     console.log(`  that file is not in this project, so it boots with a missing script: restore it, or point the entry at res://${RUNTIME_AUTOLOAD.path}`);
   }
 }
@@ -45152,7 +45876,7 @@ async function setup() {
       console.log("no harness configured; name one yourself, and gdharness harnesses lists them all");
     }
     if (!args.includes("--no-skill")) {
-      const directories = skillDirectories(chosen.harnesses, projectPath, existsSync16);
+      const directories = skillDirectories(chosen.harnesses, projectPath, existsSync18);
       for (const written of writeSkill(directories, getLocalVersion())) {
         console.log(`skill: ${written.replaced ? "replaced" : "written"} ${written.path}`);
       }
@@ -45169,12 +45893,14 @@ async function uninstall() {
   const named = namedHarnesses();
   const from = named.length > 0 ? named : HARNESSES;
   for (const harness of from) {
-    const removal = disconnect(harness, projectPath);
-    if (removal.action === "absent") {
+    if (harness.scope === "home" && named.length === 0) {
+      if (registered(harness, projectPath)) {
+        console.log(`${harness.name}: left alone. Its config is machine-wide and may serve another project; pass --${harness.id} to remove it.`);
+      }
       continue;
     }
-    if (harness.scope === "home" && named.length === 0) {
-      console.log(`${harness.name}: left alone. Its config is machine-wide and may serve another project; pass --${harness.id} to remove it.`);
+    const removal = disconnect(harness, projectPath);
+    if (removal.action === "absent") {
       continue;
     }
     if (removal.action === "manual") {
@@ -45194,15 +45920,19 @@ async function uninstall() {
     said2(outcome, `disabling ${name}`);
     console.log(`${name}: ${outcome.ok ? String(outcome.payload["action"]) : "failed"}`);
   }
-  if (before.runtimeAutoload) {
+  if (before.runtimeAutoloadPath !== null) {
     said2(await setRuntime(godot, projectPath, false), "removing the runtime autoload");
     console.log(`${RUNTIME_AUTOLOAD.name} autoload removed`);
   }
+  const loader = before.runtimeLoaderAutoload;
+  if (loader !== null && loader.name !== RUNTIME_AUTOLOAD.name) {
+    console.log(`${loader.name} names res://${loader.path}, which brings the runtime up its own way. That line is this project's, so it is left in place; the addon it brings up is gone now, so take the entry out unless that file does nothing without it.`);
+  }
   const addons = removeAddons(projectPath);
   for (const path of addons) {
     console.log(`removed ${path}`);
   }
-  const anything = addons.length > 0 || before.runtimeAutoload || enabled.length > 0;
+  const anything = addons.length > 0 || before.runtimeAutoloadPath !== null || enabled.length > 0;
   console.log(anything ? `
 Reconnect your harness so it stops spawning a server that is no longer installed.` : `
 Nothing of gdharness was in this project.`);
@@ -45211,13 +45941,13 @@ async function upgrade() {
   const projectPath = projectArgument(1);
   const version = getLocalVersion();
   const before = inspectProject(projectPath);
-  const installed = before.addons.find((addon) => addon.installed)?.version ?? null;
-  if (installed === null) {
+  const present = before.addons.find((addon) => addon.installed);
+  if (present === undefined) {
     const where = projectPath === process.cwd() ? "" : ` ${projectPath}`;
     throw new UsageError(`gdharness is not installed in ${projectPath}. Run  gdharness setup${where}  instead.`);
   }
   const godot = await engine(projectPath);
-  console.log(installed === version ? `already ${version}; reinstalling` : `${installed} -> ${version}`);
+  console.log(present.version === version ? `already ${version}; reinstalling` : `${present.version ?? "an unmarked copy"} -> ${version}`);
   const digestBefore = installedEditorDigest(projectPath);
   for (const addon of installAddons(projectPath)) {
     console.log(`${addon.replaced ? "replaced" : "installed"} ${addon.path}`);
@@ -45231,7 +45961,21 @@ async function upgrade() {
   }
   said2(await runOperation(godot, "refresh_class_cache", {}, projectPath), "rebuilding the class list");
   const launch = launchFor(version, godot.godotPath, projectPath);
-  const already = HARNESSES.filter((harness) => registered(harness, projectPath));
+  const named = namedHarnesses();
+  const already = HARNESSES.filter((harness) => {
+    if (!registered(harness, projectPath)) {
+      return false;
+    }
+    if (harness.scope !== "home" || named.includes(harness)) {
+      return true;
+    }
+    const serves = servedProject(harness, projectPath);
+    if (serves !== null && isSameDirectory(serves, projectPath)) {
+      return true;
+    }
+    console.log(`${harness.name}: left alone. Its config is machine-wide and ${serves === null ? "names no project" : `serves ${serves}`}; pass --${harness.id} to point it at this one.`);
+    return false;
+  });
   const moved = [];
   let written = 0;
   let byHand = 0;
@@ -45246,7 +45990,7 @@ async function upgrade() {
       moved.push(took.from);
     }
   }
-  for (const written of writeSkill(skillDirectories(already, projectPath, existsSync16), version)) {
+  for (const written of writeSkill(skillDirectories(already, projectPath, existsSync18), version)) {
     console.log(`skill: ${written.replaced ? "replaced" : "written"} ${written.path}`);
   }
   console.log(`