gdharness 1.1.20 → 1.1.22

package/build/cli.js

@@ -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,72 @@ 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";
+import { basename as basename2, join as join5 } from "node:path";
+function forceNextImport(projectPath, resourcePath) {
+  const relative = resourcePath.replace(/^res:\/\//, "");
+  const sidecar = join5(projectPath, `${relative}.import`);
+  if (!existsSync5(sidecar)) {
+    return;
+  }
+  const { atime, mtimeMs } = statSync2(sidecar);
+  writeFileSync3(sidecar, readFileSync3(sidecar, "utf8").replace(/^valid=false\r?\n/m, ""));
+  utimesSync(sidecar, atime, new Date(mtimeMs + 2000));
+  rmSync3(importRecord(projectPath, resourcePath), { force: true });
+}
+function importRecord(projectPath, resourcePath) {
+  const digest = createHash("md5").update(resourcePath).digest("hex");
+  return join5(projectPath, ".godot", "imported", `${basename2(resourcePath)}-${digest}.md5`);
+}
+var init_reimport = () => {};
+
 // src/alive.ts
 import process5 from "node:process";
 function alive(pid) {
@@ -7866,12 +7932,12 @@ function alive(pid) {
 var init_alive = () => {};
 
 // src/scratch.ts
-import { existsSync as existsSync5, mkdtempSync, readdirSync as readdirSync2, rmSync as rmSync3 } from "node:fs";
+import { existsSync as existsSync6, mkdtempSync, readdirSync as readdirSync2, rmSync as rmSync4 } from "node:fs";
 import { tmpdir } from "node:os";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 import process6 from "node:process";
 function scratchDirectory(kind) {
-  return mkdtempSync(join5(tmpdir(), `gdharness-${kind}-${process6.pid}-`));
+  return mkdtempSync(join6(tmpdir(), `gdharness-${kind}-${process6.pid}-`));
 }
 function sweepAbandonedScratch(directory = tmpdir()) {
   let entries;
@@ -7887,7 +7953,7 @@ function sweepAbandonedScratch(directory = tmpdir()) {
       continue;
     }
     try {
-      remove(join5(directory, entry));
+      remove(join6(directory, entry));
     } catch {}
   }
 }
@@ -7913,7 +7979,7 @@ function discard(...paths) {
   return left;
 }
 function remove(path) {
-  rmSync3(path, SWEPT);
+  rmSync4(path, SWEPT);
 }
 function tryAgain(path, attempt) {
   if (attempt === 0) {
@@ -7925,7 +7991,7 @@ function tryAgain(path, attempt) {
     lastTryOnExit();
   }
   const after = AGAIN_AFTER_MS[attempt];
-  if (after === undefined || !existsSync5(path)) {
+  if (after === undefined || !existsSync6(path)) {
     waiting.delete(path);
     if (after === undefined) {
       atExit.add(path);
@@ -7972,10 +8038,8 @@ var init_scratch = __esm(() => {
 });
 
 // src/headless.ts
-import { execFile as execFile3 } from "node:child_process";
-import { writeFileSync as writeFileSync3 } from "node:fs";
-import { join as join6 } 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)) {
@@ -7984,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;
@@ -8023,99 +8108,141 @@ function librariesNotCopied(messages) {
   }
   return [...found];
 }
-function extensionRetryNote(libraries) {
-  return `The first import could not load ${libraries.join(" and ")}: on Windows an engine running as the editor ` + "loads a GDExtension from a ~ copy beside the library, and the editor open on this project holds its own " + "copy there, so the first engine started beside it cannot make one. That failed attempt moves the " + "editor's copy aside, so the import was run again and loaded the extension, and the messages are from " + "that second run. The editor's copy is left beside the library as a ~RF….TMP file, which can be deleted " + "once the editor has exited.";
+function extensionRetryNote(libraries, stillNotLoaded = []) {
+  const second = stillNotLoaded.length === 0 ? "so the import was run again and loaded the extension, and the messages are from that second run." : `so the import was run again, and it still could not load ${stillNotLoaded.join(" and ")}: this answer is from an import without ${stillNotLoaded.length === 1 ? "it" : "them"}, and its messages say what the engine hit.`;
+  return `The first import could not load ${libraries.join(" and ")}: on Windows an engine running as the editor ` + "loads a GDExtension from a ~ copy beside the library, and the editor open on this project holds its own " + "copy there, so the first engine started beside it cannot make one. That failed attempt moves the " + `editor's copy aside, ${second} The editor's copy is left beside the library as a ~RF….TMP file, which ` + "can be deleted once the editor has exited.";
 }
-async function runImport(godotPath, projectPath, once = importOnce) {
-  const first = await once(godotPath, projectPath);
+async function runImport(godotPath, projectPath, options = {}) {
+  const once = options.once ?? importOnce;
+  const pass = () => {
+    for (const target of options.forcing ?? []) {
+      forceNextImport(projectPath, target);
+    }
+    return once(godotPath, projectPath);
+  };
+  const first = await pass();
   const collided = librariesNotCopied(first.messages);
   if (collided.length === 0) {
     return first;
   }
-  return { ...await once(godotPath, projectPath), librariesRetried: collided };
+  const second = await pass();
+  const still = librariesNotCopied(second.messages);
+  return {
+    ...second,
+    librariesRetried: collided,
+    ...still.length === 0 ? {} : { librariesNotLoaded: still },
+    extensionNote: extensionRetryNote(collided, still)
+  };
 }
 async function importOnce(godotPath, projectPath) {
   const logDir = scratchDirectory("import");
+  let ran;
   try {
-    const { stderr } = await run3(godotPath, ["--headless", "--log-file", join6(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 = join6(paramsDir, `${operation}.json`);
-  writeFileSync3(paramsFile, JSON.stringify(snakeCased(params)), "utf8");
+  const paramsFile = join7(paramsDir, `${operation}.json`);
+  const answerFile = join7(paramsDir, "answer.json");
+  writeFileSync4(paramsFile, JSON.stringify(snakeCased(params)), "utf8");
   const args = [
     "--headless",
     "--log-file",
-    join6(paramsDir, "engine.log"),
+    join7(paramsDir, "engine.log"),
     "--path",
     projectPath,
     "--script",
     engine.script,
     operation,
     `@file:${paramsFile}`,
+    answerFile,
     ...engine.debug ? ["--debug-godot"] : []
   ];
-  let stdout;
-  let stderr;
+  let ran;
+  let answer;
   try {
-    ({ stdout, stderr } = await run3(engine.godotPath, args, { signal: callSignal() }));
-  } catch (error) {
-    if (error instanceof Error && "stdout" in error && "stderr" in error) {
-      const failed = error;
-      return {
-        ok: false,
-        message: `${operation} failed (exit ${failed.code ?? "unknown"}): ${reason(failed.stdout, failed.stderr)}`,
-        messages: problems(failed.stderr)
-      };
-    }
+    ran = await runEngine(engine.godotPath, args);
+    answer = answerIn(answerFile);
+  } finally {
+    discard(paramsDir);
+  }
+  const problems = problemsIn(ran.log);
+  if (answer.kind === "unreadable") {
     return {
       ok: false,
-      message: `${operation} could not be run: ${error instanceof Error ? error.message : String(error)}`,
-      messages: []
+      message: `${operation} wrote an answer that could not be read (${answer.why})`,
+      ...reported(problems)
     };
-  } finally {
-    discard(paramsDir);
   }
-  const payload = lastJsonObject(stdout);
-  if (payload === null) {
+  if (answer.kind === "none") {
+    const ending = ran.exitCode === 0 && ran.failure === null ? "produced no result" : `failed (${howItEnded(ran)})`;
     return {
       ok: false,
-      message: `${operation} produced no result: ${reason(stdout, stderr)}`,
-      messages: problems(stderr)
+      message: `${operation} ${ending}: ${reason(ran.log, problems)}`,
+      ...reported(problems)
     };
   }
-  return { ok: true, payload, messages: problems(stderr) };
+  const fault = scriptFault(problems, engine.script);
+  if (fault !== undefined) {
+    return {
+      ok: false,
+      message: `${operation} hit an error in the operations script, so its answer is left out: part of it was ` + `never computed. ${fault.text} (${fault.detail[0]?.slice("at: ".length) ?? "no location given"})`,
+      ...reported(problems)
+    };
+  }
+  const afterAnswer = ran.exitCode === 0 && ran.failure === null ? undefined : `The operation finished and wrote this answer, and then the engine did not exit cleanly (${howItEnded(ran)}). Anything it reported on the way out is under engine_messages.`;
+  return {
+    ok: true,
+    payload: answer.payload,
+    ...reported(problems),
+    ...afterAnswer === undefined ? {} : { afterAnswer }
+  };
 }
-var run3;
+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)}`
+    };
+  }
+}
+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 existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync4 } 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 join7 } from "node:path";
+import { join as join8 } from "node:path";
 function packageUrl(root) {
   return `${root.replace(/\/+$/, "")}/gdharness/latest`;
 }
@@ -8137,28 +8264,28 @@ function cacheDirectory(environment) {
   };
   const home = set("HOME") ?? homedir3();
   if (process.platform === "win32") {
-    return join7(set("LOCALAPPDATA") ?? home, "gdharness");
+    return join8(set("LOCALAPPDATA") ?? home, "gdharness");
   }
   if (process.platform === "darwin") {
-    return join7(home, "Library", "Caches", "gdharness");
+    return join8(home, "Library", "Caches", "gdharness");
   }
-  return join7(set("XDG_CACHE_HOME") ?? join7(home, ".cache"), "gdharness");
+  return join8(set("XDG_CACHE_HOME") ?? join8(home, ".cache"), "gdharness");
 }
 function cacheFile(environment = process.env) {
   try {
     const directory = cacheDirectory(environment);
     mkdirSync3(directory, { recursive: true, mode: 448 });
-    return join7(directory, "update-check.json");
+    return join8(directory, "update-check.json");
   } catch {
-    return join7(tmpdir2(), "gdharness-update-check.json");
+    return join8(tmpdir2(), "gdharness-update-check.json");
   }
 }
 function readCache(path) {
   try {
-    if (!existsSync6(path)) {
+    if (!existsSync8(path)) {
       return null;
     }
-    const parsed = JSON.parse(readFileSync3(path, "utf8"));
+    const parsed = JSON.parse(readFileSync5(path, "utf8"));
     if (typeof parsed !== "object" || parsed === null) {
       return null;
     }
@@ -8175,7 +8302,7 @@ function readCache(path) {
 }
 function writeCache(path, entry) {
   try {
-    writeFileSync4(path, JSON.stringify(entry), { encoding: "utf8", mode: 384 });
+    writeFileSync5(path, JSON.stringify(entry), { encoding: "utf8", mode: 384 });
   } catch {}
 }
 function parts(version) {
@@ -8306,7 +8433,7 @@ var init_update_check = __esm(() => {
 });
 
 // src/server-version.ts
-import { readFileSync as readFileSync4 } 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;
@@ -8348,7 +8475,7 @@ var init_server_version = __esm(() => {
   GODOT_DEBUG_MODE_DEFAULT = process.env["GODOT_DEBUG"] === "true" || DEBUG_MODE;
   SERVER_VERSION = (() => {
     try {
-      const pkg = JSON.parse(readFileSync4(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";
@@ -8357,7 +8484,7 @@ var init_server_version = __esm(() => {
 });
 
 // src/issues.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 import process7 from "node:process";
 function feedbackNotice(every) {
   return JSON.stringify({
@@ -8376,7 +8503,7 @@ function runtime() {
 function defectSignature(where, message) {
   const normalised = `${where}
 ${message}`.toLowerCase().replaceAll("\\", "/").replaceAll(/(?:[a-z]:)?(?:\/+[\w.-]+){2,}/gu, "<path>").replaceAll(/\d+/gu, "0");
-  return createHash("sha256").update(normalised).digest("hex").slice(0, 8);
+  return createHash2("sha256").update(normalised).digest("hex").slice(0, 8);
 }
 function facts(where, message, godotVersion) {
   return [
@@ -8482,8 +8609,11 @@ var init_issues = __esm(() => {
 });
 
 // src/class-cache.ts
-import { existsSync as existsSync7, readdirSync as readdirSync3, readFileSync as readFileSync5, statSync as statSync2 } from "node:fs";
-import { join as join8 } from "node:path";
+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) => {
@@ -8496,18 +8626,18 @@ function declaredClasses(projectPath) {
 }
 function eachScript(projectPath, each) {
   const visit = (directory, prefix) => {
-    if (existsSync7(join8(directory, ".gdignore"))) {
+    if (existsSync9(join9(directory, ".gdignore"))) {
       return;
     }
     for (const entry of readdirSync3(directory, { withFileTypes: true })) {
       if (entry.name.startsWith(".")) {
         continue;
       }
-      const path = join8(directory, entry.name);
+      const path = join9(directory, entry.name);
       if (entry.isDirectory()) {
         visit(path, `${prefix}${entry.name}/`);
       } else if (entry.isFile() && entry.name.endsWith(".gd")) {
-        each(`res://${prefix}${entry.name}`, readFileSync5(path, "utf8"));
+        each(`res://${prefix}${entry.name}`, readFileSync7(path, "utf8"));
       }
     }
   };
@@ -8523,7 +8653,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));
@@ -8556,12 +8686,12 @@ function codeOf(source) {
   return code;
 }
 function cachedClasses(projectPath) {
-  const cache = join8(projectPath, ".godot", "global_script_class_cache.cfg");
-  if (!existsSync7(cache)) {
+  const cache = join9(projectPath, ".godot", "global_script_class_cache.cfg");
+  if (!existsSync9(cache)) {
     return null;
   }
   const listed = new Map;
-  const text = readFileSync5(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] ?? "");
   }
@@ -8604,32 +8734,33 @@ function missingMemberIn(message) {
   if (called !== null) {
     return { kind: "static method", member: called[1] ?? "", type: called[2] ?? "" };
   }
-  const inBase = /Cannot find member "([A-Za-z_]\w*)" in base "([A-Za-z_]\w*)((?:\.[A-Za-z_]\w*)*)"/.exec(message);
+  const inBase = /Cannot find member "([A-Za-z_]\w*)" in base "([A-Za-z_]\w*)(?:\.([A-Za-z_]\w*))?"/.exec(message);
   if (inBase === null) {
     return null;
   }
   const member = inBase[1] ?? "";
   const type = inBase[2] ?? "";
-  const within = (inBase[3] ?? "").split(".").filter((part) => part !== "");
-  const enumName = within.at(-1);
+  const enumName = inBase[3];
   return enumName === undefined ? { kind: "member", member, type } : { kind: "enum member", member, type, enum: enumName };
 }
 function declaresMember(source, missing) {
   const name = missing.member.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const top = String.raw`^(?:@\w+(?:\([^)]*\))?\s+)*`;
+  const declared = (kinds) => new RegExp(String.raw`${top}(?:${kinds})\s+${name}\b`, "m").test(source);
   if (missing.kind === "method") {
-    return new RegExp(String.raw`^\s*(?:static\s+)?func\s+${name}\s*\(`, "m").test(source);
+    return new RegExp(String.raw`${top}(?:static\s+)?func\s+${name}\s*\(`, "m").test(source);
   }
   if (missing.kind === "static method") {
-    return new RegExp(String.raw`^\s*static\s+func\s+${name}\s*\(`, "m").test(source);
+    return new RegExp(String.raw`${top}static\s+func\s+${name}\s*\(`, "m").test(source);
   }
   if (missing.kind === "enum member") {
     return enumValues(source, missing.enum ?? "").includes(missing.member);
   }
-  const kinds = missing.kind === "property" ? "var|const|enum|class|signal|func" : "var|const|enum|class|signal";
-  return new RegExp(String.raw`^\s*(?:static\s+)?(?:@\w+(?:\([^)]*\))?\s+)*(?:${kinds})\s+${name}\b`, "m").test(source) || enumValues(source, null).includes(missing.member);
+  const kinds = missing.kind === "property" ? String.raw`(?:static\s+)?(?:var|func)|const|enum|class|signal` : String.raw`static\s+(?:var|func)|const|enum|class`;
+  return declared(kinds) || enumValues(source, null).includes(missing.member);
 }
 function enumValues(source, named) {
-  const opening = named === null ? /^\s*enum\s*\{([^}]*)\}/gm : new RegExp(String.raw`^\s*enum\s+${named.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\s*\{([^}]*)\}`, "gm");
+  const opening = named === null ? /^enum\s*\{([^}]*)\}/gm : new RegExp(String.raw`^enum\s+${named.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\s*\{([^}]*)\}`, "gm");
   const values = [];
   for (const [, body] of source.matchAll(opening)) {
     const uncommented = (body ?? "").split(`
@@ -8672,21 +8803,22 @@ function classesNamedIn(source, known) {
   return [...named].sort();
 }
 function contradictedDiagnostics(messages, classes, sourceOf) {
+  const keyOf = (missing) => [missing.type, missing.enum ?? "", missing.member].join(".");
+  const denials = messages.map((message) => missingMemberIn(message)).filter((missing) => missing !== null);
+  const calledOnTheClass = new Set(denials.filter((missing) => missing.kind === "static method").map((missing) => keyOf(missing)));
   const read = new Map;
   const found = new Map;
-  for (const message of messages) {
-    const missing = missingMemberIn(message);
-    const declaredIn = missing === null ? undefined : classes.get(missing.type);
-    if (missing === null || declaredIn === undefined) {
+  for (const missing of denials) {
+    const declaredIn = classes.get(missing.type);
+    const key = keyOf(missing);
+    if (declaredIn === undefined || missing.kind === "method" && calledOnTheClass.has(key)) {
       continue;
     }
     if (!read.has(declaredIn)) {
       read.set(declaredIn, sourceOf(declaredIn));
     }
     const source = read.get(declaredIn) ?? null;
-    const key = [missing.type, missing.enum ?? "", missing.member].join(".");
-    const already = found.get(key);
-    if (source !== null && declaresMember(source, missing) && already?.kind !== "static method") {
+    if (source !== null && declaresMember(source, missing)) {
       found.set(key, { ...missing, declaredIn });
     }
   }
@@ -8728,6 +8860,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 = [
@@ -8736,9 +8881,19 @@ 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 ? "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, so nothing was reloaded: Godot answered ${answered}. ${copy} ` + `script_diagnostics on it gives the errors.${order}`;
+  return `${failed.script} did not compile: Godot answered ${answered}. ${copy} ` + `script_diagnostics on it gives the errors.${order}`;
 }
 function uncachedClassNote(types) {
   if (types.length === 0) {
@@ -8748,9 +8903,9 @@ function uncachedClassNote(types) {
   return `${types.join(", ")} ${one ? "is declared" : "are declared"} in this project and missing from ` + `.godot/global_script_class_cache.cfg, so a game launched now would not resolve ${one ? "it" : "them"} ` + "either. Try editor_rescan first: it asks the editor already running and starts nothing, and it " + "cleared this in 314ms in a second project with a 31-worker fan-out still importing. It is not " + "always enough, because a file another engine has already imported reads as settled and the " + "walk does not look inside it. project_import refresh_classes rewrites the cache from the " + "declarations on disk and does reach that case, at the cost of a short headless engine, which " + "is worth knowing when something else is already running against this project.";
 }
 function cacheWrittenAt(projectPath) {
-  const cache = join8(projectPath, ".godot", "global_script_class_cache.cfg");
+  const cache = join9(projectPath, ".godot", "global_script_class_cache.cfg");
   try {
-    return statSync2(cache).mtimeMs;
+    return statSync3(cache).mtimeMs;
   } catch {
     return null;
   }
@@ -8762,14 +8917,14 @@ function declaredSince(projectPath, paths, names, since) {
       return false;
     }
     try {
-      return statSync2(join8(projectPath, path.slice("res://".length))).mtimeMs > since;
+      return statSync3(join9(projectPath, path.slice("res://".length))).mtimeMs > since;
     } catch {
       return false;
     }
   });
 }
 function cachedAtMissingPaths(cached, projectPath) {
-  return [...cached].filter(([, path]) => path.startsWith("res://") && !existsSync7(join8(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);
@@ -8786,9 +8941,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
@@ -15895,11 +16051,11 @@ var init_types = __esm(() => {
 });
 
 // src/paths.ts
-import { realpathSync } from "node:fs";
+import { realpathSync as realpathSync2 } from "node:fs";
 import { isAbsolute, relative, resolve, sep } from "node:path";
 function realPathOr(path) {
   try {
-    return realpathSync.native(path);
+    return realpathSync2.native(path);
   } catch {
     return path;
   }
@@ -15920,6 +16076,12 @@ function resolveWithinProject(projectPath, candidatePath) {
     return { ok: false, reason: "Path contains a null byte." };
   }
   const withoutScheme = trimmed.startsWith(RESOURCE_SCHEME) ? trimmed.slice(RESOURCE_SCHEME.length) : trimmed;
+  if (withoutScheme.startsWith("uid://")) {
+    return {
+      ok: false,
+      reason: `Path '${trimmed}' is a UID, and a file is judged here by where it is on disk, which a UID does not say. Give the file's res:// path.`
+    };
+  }
   const scheme = OTHER_SCHEME.exec(withoutScheme);
   if (scheme) {
     return {
@@ -15956,7 +16118,7 @@ var init_paths = __esm(() => {
 });
 
 // src/resources.ts
-import { readFileSync as readFileSync6 } from "node:fs";
+import { readFileSync as readFileSync8 } from "node:fs";
 import { extname, resolve as resolve2 } from "node:path";
 function ensureProjectPath(getProjectPath) {
   const projectPath = getProjectPath();
@@ -16122,7 +16284,7 @@ function readResourceText(uri, getProjectPath) {
   const parsedUri = parseGodotUri(uri);
   if (parsedUri.kind === "project-info") {
     const projectFilePath = resolveProjectFile(projectPath, "project.godot");
-    const rawProject = readFileSync6(projectFilePath, "utf-8");
+    const rawProject = readFileSync8(projectFilePath, "utf-8");
     const parsedProject = parseProjectGodot(rawProject);
     return {
       mimeType: "application/json",
@@ -16131,7 +16293,7 @@ function readResourceText(uri, getProjectPath) {
   }
   const filePath = resolveProjectFile(projectPath, parsedUri.resourcePath);
   ensureAllowedExtension(parsedUri.kind, filePath);
-  const text = readFileSync6(filePath, "utf-8");
+  const text = readFileSync8(filePath, "utf-8");
   return {
     mimeType: parsedUri.kind === "script" ? "text/x-gdscript" : "text/plain",
     text
@@ -16260,42 +16422,42 @@ function readParams(params, key) {
 
 // src/setup.ts
 import { spawnSync } from "node:child_process";
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 import {
   cpSync,
-  existsSync as existsSync8,
+  existsSync as existsSync10,
   mkdirSync as mkdirSync4,
   readdirSync as readdirSync4,
-  readFileSync as readFileSync7,
+  readFileSync as readFileSync9,
   rmdirSync,
-  rmSync as rmSync4,
-  statSync as statSync3,
-  writeFileSync as writeFileSync5
+  rmSync as rmSync5,
+  statSync as statSync4,
+  writeFileSync as writeFileSync6
 } from "node:fs";
-import { dirname as dirname4, join as join9 } from "node:path";
+import { dirname as dirname5, join as join10 } from "node:path";
 import { fileURLToPath } from "node:url";
 function editorAddonDigest(from = shippedAddonsDirectory()) {
-  const hash = createHash2("sha256");
+  const hash = createHash3("sha256");
   const walk = (directory, relative) => {
     for (const name of readdirSync4(directory).sort()) {
       if (name === VERSION_MARKER || name === DIGEST_MARKER) {
         continue;
       }
-      const path = join9(directory, name);
+      const path = join10(directory, name);
       const inside = `${relative}/${name}`;
-      if (statSync3(path).isDirectory()) {
+      if (statSync4(path).isDirectory()) {
         walk(path, inside);
       } else {
         hash.update(`${inside}
 `);
-        hash.update(readFileSync7(path));
+        hash.update(readFileSync9(path));
         hash.update(`
 `);
       }
     }
   };
   for (const name of EDITOR_PLUGINS) {
-    walk(join9(from, name), name);
+    walk(join10(from, name), name);
   }
   return hash.digest("hex");
 }
@@ -16310,58 +16472,58 @@ function shippedEditorDigest() {
   return shippedDigest ?? undefined;
 }
 function installedEditorDigest(projectPath) {
-  const marker = join9(projectPath, "addons", ADDONS[0], DIGEST_MARKER);
-  if (!existsSync8(marker)) {
+  const marker = join10(projectPath, "addons", ADDONS[0], DIGEST_MARKER);
+  if (!existsSync10(marker)) {
     return null;
   }
-  const said = readFileSync7(marker, "utf8").trim();
+  const said = readFileSync9(marker, "utf8").trim();
   return said === "" ? null : said;
 }
 function shippedAddonsDirectory() {
-  return join9(dirname4(fileURLToPath(import.meta.url)), "godot", "addons");
+  return join10(dirname5(fileURLToPath(import.meta.url)), "godot", "addons");
 }
 function shippedOperationsScript() {
-  return join9(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 = join9(from, name);
-    if (!existsSync8(join9(source, name === "gdharness_runtime" ? "runtime_autoload.gd" : "plugin.cfg"))) {
+    const source = join10(from, name);
+    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 = join9(projectPath, "addons", name);
-    const replaced = existsSync8(target);
-    rmSync4(target, { recursive: true, force: true });
-    mkdirSync4(dirname4(target), { recursive: true });
+    const target = join10(projectPath, "addons", name);
+    const replaced = existsSync10(target);
+    rmSync5(target, { recursive: true, force: true });
+    mkdirSync4(dirname5(target), { recursive: true });
     cpSync(source, target, { recursive: true });
-    writeFileSync5(join9(target, VERSION_MARKER), `${SERVER_VERSION}
+    writeFileSync6(join10(target, VERSION_MARKER), `${SERVER_VERSION}
 `);
     installed.push({ name, path: target, replaced });
   }
-  writeFileSync5(join9(projectPath, "addons", ADDONS[0], DIGEST_MARKER), `${editorAddonDigest(from)}
+  writeFileSync6(join10(projectPath, "addons", ADDONS[0], DIGEST_MARKER), `${editorAddonDigest(from)}
 `);
   return installed;
 }
 function installedAddonVersion(projectPath) {
-  const marker = join9(projectPath, "addons", ADDONS[0], VERSION_MARKER);
-  if (!existsSync8(marker)) {
+  const marker = join10(projectPath, "addons", ADDONS[0], VERSION_MARKER);
+  if (!existsSync10(marker)) {
     return null;
   }
-  const said = readFileSync7(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 = join9(projectPath, "addons", name);
-    if (existsSync8(target)) {
-      rmSync4(target, { recursive: true, force: true });
+    const target = join10(projectPath, "addons", name);
+    if (existsSync10(target)) {
+      rmSync5(target, { recursive: true, force: true });
       removed.push(target);
     }
   }
-  const addons = join9(projectPath, "addons");
-  if (removed.length > 0 && existsSync8(addons) && readdirSync4(addons).length === 0) {
+  const addons = join10(projectPath, "addons");
+  if (removed.length > 0 && existsSync10(addons) && readdirSync4(addons).length === 0) {
     rmdirSync(addons);
     removed.push(addons);
   }
@@ -16385,7 +16547,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;
@@ -16395,7 +16557,7 @@ function loaderAmong(projectPath, named) {
     }
     let source = null;
     try {
-      source = readFileSync7(join9(projectPath, path), "utf8");
+      source = readFileSync9(join10(projectPath, path), "utf8");
     } catch {}
     if (source?.includes(RUNTIME_AUTOLOAD.path)) {
       return { name: entry, path, exists: true };
@@ -16437,10 +16599,10 @@ function enabledPlugins(settings) {
 function inspectProject(projectPath) {
   const problems = [];
   const addons = ADDONS.map((name) => {
-    const directory = join9(projectPath, "addons", name);
-    const marker = join9(directory, VERSION_MARKER);
-    const installed = existsSync8(directory);
-    const version = existsSync8(marker) ? readFileSync7(marker, "utf8").trim() : null;
+    const directory = join10(projectPath, "addons", name);
+    const marker = join10(directory, VERSION_MARKER);
+    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`);
@@ -16449,7 +16611,7 @@ function inspectProject(projectPath) {
     }
     return { name, installed, version, current };
   });
-  const settings = parseProjectGodot(readFileSync7(join9(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)) {
@@ -16465,7 +16627,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 (!existsSync8(join9(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`);
       }
@@ -16625,7 +16787,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 = {
@@ -16780,11 +16942,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,
@@ -16796,9 +16965,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." }
       },
@@ -16817,7 +16992,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"] }
@@ -16856,7 +17031,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"]
     },
@@ -16901,7 +17080,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: []
@@ -16962,11 +17144,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"],
@@ -16990,7 +17172,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,
@@ -17008,7 +17190,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"],
@@ -17019,7 +17204,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"]
+        }
       }
     },
     {
@@ -17107,13 +17295,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"],
@@ -17311,7 +17502,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",
@@ -17375,7 +17566,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"]
@@ -17521,7 +17712,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,
@@ -17533,12 +17724,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",
@@ -17548,7 +17739,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",
@@ -17626,7 +17817,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",
@@ -17659,7 +17850,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",
@@ -17703,11 +17894,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"] },
@@ -17716,7 +17907,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: {
@@ -17755,7 +17946,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 declared to hold an object, null, which the text null also means; any other value is refused, since the property can never hold it."
+          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."
         },
         says: {
           type: "string",
@@ -17804,7 +17995,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: {
@@ -17815,12 +18006,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: [],
@@ -32587,10 +32778,10 @@ var init_stdio2 = __esm(() => {
 });
 
 // src/runtime-client.ts
-import { existsSync as existsSync10, readdirSync as readdirSync6, readFileSync as readFileSync9, statSync as statSync4, 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 join12, 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);
@@ -32598,20 +32789,20 @@ function runtimeDirectory(variables = process.env) {
     return explicit;
   }
   const perUser = envValue("XDG_RUNTIME_DIR", variables);
-  return join12(perUser ?? tmpdir3(), "gdharness");
+  return join13(perUser ?? tmpdir3(), "gdharness");
 }
 function runtimeDirectories(variables = process.env) {
   const candidates = [runtimeDirectory(variables)];
   const fallbacks = process.platform === "win32" ? [envValue("SystemRoot", variables) ?? envValue("windir", variables) ?? "C:\\Windows"] : ["/tmp", "/var/tmp"];
   for (const base of fallbacks) {
-    candidates.push(join12(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
+    candidates.push(join13(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
   }
   return [...new Set(candidates.map((path) => resolve3(path)))];
 }
 function errorReportOf(pid, directories = runtimeDirectories()) {
   for (const directory of directories) {
-    const path = join12(directory, `runtime-${pid}.log`);
-    if (existsSync10(path)) {
+    const path = join13(directory, `runtime-${pid}.log`);
+    if (existsSync12(path)) {
       return path;
     }
   }
@@ -32642,7 +32833,7 @@ function reportAlreadyInTranscript(transcript, report) {
 function parseAnnouncement(file, pid) {
   let fields;
   try {
-    fields = asParams(JSON.parse(readFileSync9(file, "utf8")));
+    fields = asParams(JSON.parse(readFileSync11(file, "utf8")));
   } catch {
     return { kind: "rubbish" };
   }
@@ -32659,7 +32850,7 @@ function parseAnnouncement(file, pid) {
   };
   let announcedAt;
   try {
-    announcedAt = statSync4(file).mtimeMs;
+    announcedAt = statSync5(file).mtimeMs;
   } catch {}
   const when = announcedAt === undefined ? {} : { announcedAt };
   if (protocol !== RUNTIME_PROTOCOL) {
@@ -32700,7 +32891,7 @@ function discoverRuntimes(directories = runtimeDirectories()) {
 function wentAway(file, pid) {
   let project = "";
   try {
-    const fields = asParams(JSON.parse(readFileSync9(file, "utf8")));
+    const fields = asParams(JSON.parse(readFileSync11(file, "utf8")));
     project = readString(readParams(fields, "project") ?? {}, "path") ?? "";
   } catch {
     return;
@@ -32743,7 +32934,7 @@ function strangersAmong(candidates, now, startTimes = startTimesOf) {
   }).map((one) => one.file));
 }
 function announcedIn(directory) {
-  if (!existsSync10(directory)) {
+  if (!existsSync12(directory)) {
     return [];
   }
   const found = [];
@@ -32752,20 +32943,20 @@ function announcedIn(directory) {
   for (const entry of readdirSync6(directory)) {
     const report = ERROR_REPORT_PATTERN.exec(entry);
     if (report) {
-      sweepErrorReport(join12(directory, entry), Number.parseInt(report[1] ?? "", 10));
+      sweepErrorReport(join13(directory, entry), Number.parseInt(report[1] ?? "", 10));
       continue;
     }
     const match = ANNOUNCEMENT_PATTERN.exec(entry);
     if (!match) {
       continue;
     }
-    const file = join12(directory, entry);
+    const file = join13(directory, entry);
     const pid = Number.parseInt(match[1] ?? "", 10);
     const running = alive(pid);
     entries.push({ file, pid, running });
     if (running) {
       try {
-        candidates.push({ file, pid, writtenAt: statSync4(file).mtimeMs });
+        candidates.push({ file, pid, writtenAt: statSync5(file).mtimeMs });
       } catch {}
     }
   }
@@ -32787,16 +32978,16 @@ function announcedIn(directory) {
     found.push(announced);
   }
   const held = new Set(entries.map((one) => one.file));
-  const here = join12(directory, ".");
+  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) => join12(directory, `runtime-${pid}.json`)).filter((file) => existsSync10(file));
+  const files = directories.map((directory) => join13(directory, `runtime-${pid}.json`)).filter((file) => existsSync12(file));
   const first = files[0];
   if (first === undefined) {
     return;
@@ -32822,7 +33013,7 @@ function sweepErrorReport(path, pid, now = Date.now()) {
     return;
   }
   try {
-    if (now - statSync4(path).mtimeMs >= ERROR_REPORT_KEEP_MS) {
+    if (now - statSync5(path).mtimeMs >= ERROR_REPORT_KEEP_MS) {
       unlinkSync(path);
     }
   } catch {}
@@ -32831,13 +33022,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));
   }
@@ -33096,14 +33287,14 @@ var init_runtime_client = __esm(() => {
 });
 
 // src/boot-note.ts
-import { mkdirSync as mkdirSync6, readFileSync as readFileSync10, writeFileSync as writeFileSync7 } from "node:fs";
-import { dirname as dirname8, join as join13 } 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 join13(projectPath, ".godot", "gdharness-boot.json");
+  return join14(projectPath, ".godot", "gdharness-boot.json");
 }
 function readBootNote(projectPath) {
   try {
-    const noted = readNumber(asParams(JSON.parse(readFileSync10(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;
@@ -33112,8 +33303,8 @@ function readBootNote(projectPath) {
 function writeBootNote(projectPath, announcedAfterMs) {
   try {
     const path = bootNotePath(projectPath);
-    mkdirSync6(dirname8(path), { recursive: true });
-    writeFileSync7(path, JSON.stringify({ announcedAfterMs: Math.round(announcedAfterMs), at: new Date().toISOString() }, null, 2), "utf8");
+    mkdirSync6(dirname9(path), { recursive: true });
+    writeFileSync8(path, JSON.stringify({ announcedAfterMs: Math.round(announcedAfterMs), at: new Date().toISOString() }, null, 2), "utf8");
   } catch {}
 }
 function halfAsLongAgain(lastBootMs) {
@@ -33131,10 +33322,10 @@ var init_boot_note = __esm(() => {
 });
 
 // src/breakpoint-note.ts
-import { mkdirSync as mkdirSync7, readFileSync as readFileSync11, rmSync as rmSync6, writeFileSync as writeFileSync8 } from "node:fs";
-import { dirname as dirname9, isAbsolute as isAbsolute2, join as join14, 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 join14(projectPath, ".godot", "gdharness-breakpoints.json");
+  return join15(projectPath, ".godot", "gdharness-breakpoints.json");
 }
 function writeBreakpointNote(projectPath, held) {
   const path = breakpointNotePath(projectPath);
@@ -33142,7 +33333,7 @@ function writeBreakpointNote(projectPath, held) {
   const inside = held.map((one) => ({ scriptPath: realPathOr(one.scriptPath), lines: one.lines })).filter((one) => one.lines.length > 0 && withinProject(root, one.scriptPath));
   try {
     if (inside.length === 0) {
-      rmSync6(path, { force: true });
+      rmSync7(path, { force: true });
       return;
     }
     const note = {
@@ -33151,8 +33342,8 @@ function writeBreakpointNote(projectPath, held) {
         lines: [...one.lines]
       }))
     };
-    mkdirSync7(dirname9(path), { recursive: true });
-    writeFileSync8(path, `${JSON.stringify(note, null, 2)}
+    mkdirSync7(dirname10(path), { recursive: true });
+    writeFileSync9(path, `${JSON.stringify(note, null, 2)}
 `, "utf8");
   } catch (error) {
     console.error(`[SERVER] Could not record the breakpoints at ${path}: ${errorMessage(error)}`);
@@ -33160,7 +33351,7 @@ function writeBreakpointNote(projectPath, held) {
 }
 function readBreakpointNote(projectPath) {
   try {
-    const parsed = JSON.parse(readFileSync11(breakpointNotePath(projectPath), "utf8"));
+    const parsed = JSON.parse(readFileSync13(breakpointNotePath(projectPath), "utf8"));
     if (typeof parsed !== "object" || parsed === null || !Array.isArray(parsed.breakpoints)) {
       return [];
     }
@@ -33175,7 +33366,7 @@ function readBreakpointNote(projectPath) {
       }
       const lines = Array.isArray(listed) ? listed.filter((line) => Number.isInteger(line) && line > 0) : [];
       if (lines.length > 0) {
-        held.push({ scriptPath: realPathOr(join14(projectPath, script)), lines });
+        held.push({ scriptPath: realPathOr(join15(projectPath, script)), lines });
       }
     }
     return held;
@@ -33193,14 +33384,14 @@ var init_breakpoint_note = __esm(() => {
 });
 
 // src/class-note.ts
-import { mkdirSync as mkdirSync8, readFileSync as readFileSync12, writeFileSync as writeFileSync9 } from "node:fs";
-import { dirname as dirname10, join as join15 } 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 join15(projectPath, ".godot", "gdharness-classes.json");
+  return join16(projectPath, ".godot", "gdharness-classes.json");
 }
 function readClassNote(projectPath) {
   try {
-    const fields = asParams(JSON.parse(readFileSync12(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;
@@ -33217,24 +33408,24 @@ function readClassNote(projectPath) {
 function writeClassNote(projectPath, note) {
   try {
     const path = classNotePath(projectPath);
-    mkdirSync8(dirname10(path), { recursive: true });
-    writeFileSync9(path, `${JSON.stringify(note, null, 2)}
+    mkdirSync8(dirname11(path), { recursive: true });
+    writeFileSync10(path, `${JSON.stringify(note, null, 2)}
 `, "utf8");
   } catch {}
 }
 var init_class_note = () => {};
 
 // src/config-pin.ts
-import { existsSync as existsSync11, readFileSync as readFileSync13 } from "node:fs";
-import { join as join16 } from "node:path";
+import { existsSync as existsSync13, readFileSync as readFileSync15 } from "node:fs";
+import { join as join17 } from "node:path";
 function versionsNamedInConfig(projectPath) {
-  const config = join16(projectPath, ".mcp.json");
-  if (!existsSync11(config)) {
+  const config = join17(projectPath, ".mcp.json");
+  if (!existsSync13(config)) {
     return [];
   }
   let text;
   try {
-    text = readFileSync13(config, "utf8");
+    text = readFileSync15(config, "utf8");
     JSON.parse(text);
   } catch {
     return [];
@@ -33383,6 +33574,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 : "";
@@ -33399,17 +33593,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() {
@@ -33570,6 +33772,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;
@@ -33586,6 +33789,7 @@ class GodotDAPClient {
         text: said(body, "text")
       };
       this.holdKnown = true;
+      this.stops += 1;
       return;
     }
     if (eventName === "continued") {
@@ -33602,20 +33806,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") {
@@ -33698,24 +33906,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);
     }
@@ -33725,14 +33953,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;
   }
@@ -33741,11 +33969,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;
@@ -33753,12 +33981,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)
@@ -33771,19 +34000,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);
       }
     }
   }
@@ -33794,15 +34025,16 @@ class GodotDAPClient {
     this.halt = null;
     this.holdKnown = true;
   }
-  async stepOver(threadId) {
+  async step(command) {
     await this.attach();
-    const resolvedThreadId = await this.resolveThreadId(threadId);
-    await this.sendRequest("next", { threadId: resolvedThreadId });
-  }
-  async stepInto(threadId) {
-    await this.attach();
-    const resolvedThreadId = await this.resolveThreadId(threadId);
-    await this.sendRequest("stepIn", { threadId: resolvedThreadId });
+    const resolvedThreadId = await this.resolveThreadId();
+    const before = this.stops;
+    await this.sendRequest(command, { threadId: resolvedThreadId });
+    const deadline = Date.now() + this.stepPatienceMs;
+    while (this.stops === before && this.connected && Date.now() < deadline) {
+      await delay2(50);
+    }
+    return this.stops !== before;
   }
   async getStackTrace(threadId) {
     await this.attach();
@@ -33828,16 +34060,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 {
@@ -33849,6 +34081,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"];
@@ -33912,9 +34147,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": {
@@ -33941,19 +34175,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();
@@ -33964,8 +34192,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:
@@ -33973,18 +34207,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
@@ -33994,25 +34232,25 @@ var init_desktop = () => {};
 // src/editor-log.ts
 import {
   closeSync,
-  existsSync as existsSync12,
+  existsSync as existsSync14,
   mkdirSync as mkdirSync9,
   openSync,
-  readFileSync as readFileSync14,
+  readFileSync as readFileSync16,
   readSync,
-  rmSync as rmSync7,
-  statSync as statSync5,
-  writeFileSync as writeFileSync10
+  rmSync as rmSync8,
+  statSync as statSync6,
+  writeFileSync as writeFileSync11
 } from "node:fs";
-import { dirname as dirname11, join as join17 } from "node:path";
+import { dirname as dirname12, join as join18 } from "node:path";
 function editorLogPath(projectPath) {
-  return join17(projectPath, ".godot", "gdharness-editor.log");
+  return join18(projectPath, ".godot", "gdharness-editor.log");
 }
 function editorLogNotePath(projectPath) {
-  return join17(projectPath, ".godot", "gdharness-editor.json");
+  return join18(projectPath, ".godot", "gdharness-editor.json");
 }
 function readEditorLogNote(projectPath) {
   try {
-    const fields = asParams(JSON.parse(readFileSync14(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;
@@ -34023,16 +34261,16 @@ function readEditorLogNote(projectPath) {
 function clearEditorLog(projectPath) {
   try {
     const path = editorLogPath(projectPath);
-    mkdirSync9(dirname11(path), { recursive: true });
-    rmSync7(path, { force: true });
-    rmSync7(editorLogNotePath(projectPath), { force: true });
+    mkdirSync9(dirname12(path), { recursive: true });
+    rmSync8(path, { force: true });
+    rmSync8(editorLogNotePath(projectPath), { force: true });
   } catch {}
 }
 function writeEditorLogNote(projectPath, pid) {
   try {
     const path = editorLogNotePath(projectPath);
-    mkdirSync9(dirname11(path), { recursive: true });
-    writeFileSync10(path, JSON.stringify({ pid, startedAt: new Date().toISOString() }, null, 2), "utf8");
+    mkdirSync9(dirname12(path), { recursive: true });
+    writeFileSync11(path, JSON.stringify({ pid, startedAt: new Date().toISOString() }, null, 2), "utf8");
   } catch {}
 }
 function theConsoleWasNotCaptured(why, projectPath) {
@@ -34053,7 +34291,7 @@ function editorConsole(projectPath, editorPid, openedByAServer) {
     return { kind: "older server", notedPid: noted?.pid ?? null };
   }
   const path = editorLogPath(projectPath);
-  if (!existsSync12(path)) {
+  if (!existsSync14(path)) {
     return { kind: "not written" };
   }
   const log = new GameLog;
@@ -34063,9 +34301,9 @@ function editorConsole(projectPath, editorPid, openedByAServer) {
   return { log, path, ...of === undefined ? {} : { readBytes: text.length, of } };
 }
 function theFirstOf(path) {
-  const whole = statSync5(path).size;
+  const whole = statSync6(path).size;
   if (whole <= MOST_CONSOLE_BYTES) {
-    return { text: readFileSync14(path, "utf8") };
+    return { text: readFileSync16(path, "utf8") };
   }
   const handle = openSync(path, "r");
   try {
@@ -37759,13 +37997,17 @@ function parseJUnit(xml) {
   const suiteElements = top.name === "testsuite" ? [top] : top.children.filter((child) => child.name === "testsuite");
   const suites = suiteElements.map((suite) => {
     const cases = suite.children.filter((child) => child.name === "testcase").map((element) => caseOf(suite, element));
+    const failures = cases.filter((entry) => entry.status === "failed").length;
+    const errors = cases.filter((entry) => entry.status === "error").length;
     return {
       name: suite.attributes["name"] ?? "",
       path: pathOf(suite),
       tests: cases.length,
       discovered: count(suite.attributes, "tests"),
-      failures: cases.filter((entry) => entry.status === "failed").length,
-      errors: cases.filter((entry) => entry.status === "error").length,
+      failures,
+      errors,
+      hookFailures: Math.max(0, count(suite.attributes, "failures") - failures),
+      hookErrors: Math.max(0, count(suite.attributes, "errors") - errors),
       skipped: cases.filter((entry) => entry.status === "skipped").length,
       time: count(suite.attributes, "time"),
       cases
@@ -37776,11 +38018,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) {
@@ -37845,13 +38095,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}`;
@@ -37860,6 +38114,7 @@ function withActualsPrinted(failed, printed) {
  '${diff.actual}'${diff.suffix}
 	at ${diff.at}`);
         recovered = true;
+        used.add(index);
       }
     }
     const quoted = QUOTED_EQUALITY.exec(detail);
@@ -37911,7 +38166,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) {
@@ -37921,8 +38176,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 `);
@@ -37940,15 +38196,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 realpathSync3 } 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;
@@ -37961,7 +38217,7 @@ function diagnosticsKey(uri) {
     return decoded;
   }
   try {
-    return realpathSync2.native(fileURLToPath3(decoded)).toLowerCase();
+    return realpathSync3.native(fileURLToPath3(decoded)).toLowerCase();
   } catch {
     return decoded.toLowerCase();
   }
@@ -37978,8 +38234,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;
@@ -38076,7 +38334,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) {
@@ -38151,6 +38409,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;
@@ -38253,10 +38515,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,
@@ -38282,60 +38548,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;
     }
@@ -38350,28 +38638,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() {
@@ -38403,36 +38694,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");
@@ -38446,7 +38740,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 });
@@ -38455,7 +38749,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 });
@@ -38469,20 +38763,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 = {};
@@ -38515,7 +38820,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
     });
@@ -38550,8 +38855,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);
@@ -38565,7 +38870,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) {
@@ -38583,20 +38888,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 existsSync13, readdirSync as readdirSync7, readFileSync as readFileSync15 } from "node:fs";
-import { join as join18 } 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 existsSync13(join18(directory, ".gdignore"));
+  return existsSync16(join20(directory, ".gdignore"));
 }
 function projectStructure(projectPath) {
   const structure = { scenes: 0, scripts: 0, assets: 0, other: 0 };
@@ -38609,7 +38914,7 @@ function projectStructure(projectPath) {
         continue;
       }
       if (entry.isDirectory()) {
-        visit(join18(directory, entry.name));
+        visit(join20(directory, entry.name));
       } else if (entry.isFile()) {
         const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
         if (extension === "tscn") {
@@ -38639,14 +38944,14 @@ function scriptsWithoutUid(projectPath) {
       }
       const spelled = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
       if (entry.isDirectory()) {
-        visit(join18(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) && !existsSync13(join18(directory, `${entry.name}.uid`))) {
+      if (CARRIES_A_UID.has(extension) && !existsSync16(join20(directory, `${entry.name}.uid`))) {
         found.push(spelled);
       }
     }
@@ -38681,7 +38986,7 @@ function searchProject(projectPath, options) {
       if (skipped(entry.name)) {
         continue;
       }
-      const entryPath = join18(directory, entry.name);
+      const entryPath = join20(directory, entry.name);
       if (entry.isDirectory()) {
         visit(entryPath);
         continue;
@@ -38692,7 +38997,7 @@ function searchProject(projectPath, options) {
       }
       result.summary.files_searched += 1;
       const matches = [];
-      for (const [index, line] of readFileSync15(entryPath, "utf8").split(`
+      for (const [index, line] of readFileSync17(entryPath, "utf8").split(`
 `).entries()) {
         if (full()) {
           break;
@@ -38720,37 +39025,16 @@ var init_project_scan = __esm(() => {
   CARRIES_A_UID = new Set(["gd", "shader", "gdshader"]);
 });
 
-// src/reimport.ts
-import { createHash as createHash3 } from "node:crypto";
-import { existsSync as existsSync14, readFileSync as readFileSync16, rmSync as rmSync8, statSync as statSync6, utimesSync, writeFileSync as writeFileSync11 } from "node:fs";
-import { basename as basename3, join as join19 } from "node:path";
-function forceNextImport(projectPath, resourcePath) {
-  const relative = resourcePath.replace(/^res:\/\//, "");
-  const sidecar = join19(projectPath, `${relative}.import`);
-  if (!existsSync14(sidecar)) {
-    return;
-  }
-  const { atime, mtimeMs } = statSync6(sidecar);
-  writeFileSync11(sidecar, readFileSync16(sidecar, "utf8").replace(/^valid=false\r?\n/m, ""));
-  utimesSync(sidecar, atime, new Date(mtimeMs + 2000));
-  rmSync8(importRecord(projectPath, resourcePath), { force: true });
-}
-function importRecord(projectPath, resourcePath) {
-  const digest = createHash3("md5").update(resourcePath).digest("hex");
-  return join19(projectPath, ".godot", "imported", `${basename3(resourcePath)}-${digest}.md5`);
-}
-var init_reimport = () => {};
-
 // 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) {
@@ -38759,7 +39043,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;
     }
@@ -38784,31 +39068,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 realpathSync4,
   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(realpathSync4.native(at), ...missing);
     } catch {
-      const parent = dirname14(at);
+      const parent = dirname15(at);
       if (parent === at) {
         return path;
       }
@@ -38823,15 +39107,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 });
@@ -38839,7 +39126,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;
     }
@@ -38849,7 +39136,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;
   }
@@ -38863,7 +39150,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()) {
@@ -38871,7 +39160,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;
     }
@@ -38883,13 +39172,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);
         }
@@ -38901,7 +39190,7 @@ function everyRunRecord() {
 function recordAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync18(path, "utf8"));
+    parsed = JSON.parse(readFileSync19(path, "utf8"));
   } catch {
     return null;
   }
@@ -38947,7 +39236,7 @@ async function runningAs(pid) {
     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();
@@ -39075,7 +39364,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] : []]) {
@@ -39105,7 +39394,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;
     }
@@ -39120,31 +39409,31 @@ var init_run_record = __esm(() => {
   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 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.`;
@@ -39155,16 +39444,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;
@@ -39195,16 +39484,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;
@@ -39220,6 +39511,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);
@@ -39267,11 +39563,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,
@@ -39283,13 +39587,13 @@ function stopVerdict(stop) {
   return {
     stopped: true,
     endedPid: stop.endedPid,
-    clean: stop.errors === 0,
+    clean: stop.clean,
     note: `${stop.throughEditor ? stop.endedPid === null ? "The editor was asked to stop the scene it is playing. Its game had not announced a runtime, so no process was named under endedPid, and its exit code stays with the editor." : "The editor was asked to stop the scene it is playing." : "The process named under endedPid was ended."}${stop.exitSignal === null ? "" : ` It was ended by ${stop.exitSignal} and so has no exit code.`}${stop.ending === "gone" ? "" : ` It had not exited ${STOP_WAIT_MS / 1000} seconds after being told to, so it may still be going: editor_status says whether it is.`}`,
     withChildren: true
   };
 }
 function endedPreviousRun(ended) {
-  if (ended === null || ended.ending === "refused") {
+  if (ended === null || ended.ending === "refused" || ended.ending === "unreached") {
     return;
   }
   return ended.pid ?? true;
@@ -39371,6 +39675,9 @@ function endedToStartThis(ended) {
   if (ended.ending === "refused") {
     return ` ${which} was not ended: that pid no longer answers as the process the run was started as, so nothing was signalled. If it is still the game, it is running beside this one and you have to end it yourself; if it is not, it belongs to something else.`;
   }
+  if (ended.ending === "unreached") {
+    return ` ${which} was not ended here: the editor could not be asked to stop it. The editor stops a play before starting the next, so it is not running beside this one if this start reached the editor.`;
+  }
   const after = ended.ending === "lingering" ? ` It had not exited ${STOP_WAIT_MS / 1000} seconds after being told to, so it may still be running beside this one: editor_status says whether it is.` : "";
   return ` ${which} was ended to start this one; its output is no longer what editor_output answers about.${after}`;
 }
@@ -39496,19 +39803,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) {
@@ -39563,16 +39909,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;
@@ -39593,7 +39940,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();
@@ -39607,7 +39954,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) {
@@ -39615,13 +39962,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) {
@@ -39640,7 +39987,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;
@@ -40140,6 +40487,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);
       }
@@ -40310,7 +40660,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"] }
@@ -40382,8 +40732,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}`, [
@@ -40593,13 +40943,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`);
@@ -40647,11 +41014,12 @@ class GodotServer {
     return this.answer(withScanWait({
       ok: true,
       messages: imported.messages,
+      ...imported.messagesOmitted === undefined ? {} : { messagesOmitted: imported.messagesOmitted },
       payload: {
         uidsCreated: given,
         stillWithoutUid: after,
         note: uidsLeftNote(after.length),
-        ...imported.librariesRetried === undefined ? {} : { extensionNote: extensionRetryNote(imported.librariesRetried) }
+        ...imported.extensionNote === undefined ? {} : { extensionNote: imported.extensionNote }
       }
     }, scanned));
   }
@@ -40697,16 +41065,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);
@@ -40744,7 +41121,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 });
   }
@@ -40762,7 +41151,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,
@@ -40796,19 +41192,14 @@ class GodotServer {
       if (!engine.ok) {
         return { ok: false, response: engine.response };
       }
-      for (const target of targets) {
-        forceNextImport(projectPath, target);
-      }
       const scanned = await this.untilTheEditorsScanIsWritten(projectPath);
-      const imported = await runImport(engine.value, projectPath);
+      const imported = await runImport(engine.value, projectPath, { forcing: targets });
       if (!imported.ok) {
         return { ok: false, response: this.answer(withScanWait(imported, scanned)) };
       }
-      if (imported.messages.length > 0) {
-        extra["engine_messages"] = imported.messages;
-      }
-      if (imported.librariesRetried !== undefined) {
-        extra["extensionNote"] = extensionRetryNote(imported.librariesRetried);
+      Object.assign(extra, engineExtras(imported));
+      if (imported.extensionNote !== undefined) {
+        extra["extensionNote"] = imported.extensionNote;
       }
     }
     const after = await this.operation("get_import_status", resourcePath === undefined ? { includeUpToDate: true } : { resourcePath }, projectPath);
@@ -40889,17 +41280,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") ?? [];
@@ -40915,7 +41304,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 = {
@@ -40932,7 +41321,7 @@ class GodotServer {
         continue;
       }
       const outcome = await this.operation(spec.operation, spec.params(args, detailed), project.value.path);
-      info[section] = outcome.ok ? outcome.messages.length > 0 ? { ...outcome.payload, engine_messages: outcome.messages } : outcome.payload : { error: outcome.message, engine_messages: outcome.messages };
+      info[section] = outcome.ok ? { ...outcome.payload, ...engineExtras(outcome) } : { error: outcome.message, ...engineExtras(outcome) };
     }
     return this.jsonTextResponse(info);
   }
@@ -40976,18 +41365,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",
@@ -40995,55 +41384,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);
@@ -41055,7 +41407,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"
       ]);
@@ -41121,21 +41473,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);
@@ -41148,7 +41501,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;
@@ -41164,7 +41521,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 },
@@ -41201,10 +41558,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,
@@ -41215,13 +41583,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,
@@ -41229,6 +41598,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
@@ -41242,7 +41612,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) {
@@ -41254,8 +41624,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"
       ]);
@@ -41286,11 +41666,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;
       }
@@ -41299,7 +41679,7 @@ class GodotServer {
     const notes = [];
     if (contradicted.length > 0) {
       const dependsOn = new Set;
-      for (const one of contradicted) {
+      for (const one of contradicted.filter((entry) => entry.kind === "method" || entry.kind === "property")) {
         const source = cached === null ? null : this.sourceOfClass(projectPath, one.declaredIn);
         if (source === null || cached === null) {
           continue;
@@ -41339,17 +41719,18 @@ class GodotServer {
     });
   }
   classesAScriptNames(projectPath, scriptPath) {
-    const source = this.sourceOfClass(projectPath, scriptPath);
+    const resourcePath = scriptPath.startsWith("res://") ? scriptPath : `res://${scriptPath.replace(/^\/+/, "")}`;
+    const source = this.sourceOfClass(projectPath, resourcePath);
     const known = cachedClasses(projectPath) ?? declaredClasses(projectPath);
-    return source === null ? [] : classesNamedIn(source, known).filter((name) => known.get(name) !== scriptPath);
+    return source === null ? [] : classesNamedIn(source, known).filter((name) => known.get(name) !== resourcePath);
   }
   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;
     }
@@ -41537,7 +41918,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;
@@ -41633,7 +42015,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;
     }
@@ -41796,6 +42178,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) {
@@ -41890,7 +42279,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;
@@ -41899,7 +42288,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: () => {
@@ -41923,11 +42312,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,
@@ -42011,7 +42408,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,
@@ -42126,7 +42529,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;
@@ -42140,6 +42543,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();
@@ -42158,8 +42573,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";
@@ -42199,7 +42622,7 @@ class GodotServer {
     return gone ? "gone" : "lingering";
   }
   spawnGame(godotPath, cmdArgs, env) {
-    const child = spawn3(godotPath, cmdArgs, { stdio: ["ignore", "pipe", "pipe"], ...env ? { env } : {} });
+    const child = spawn4(godotPath, cmdArgs, { stdio: ["ignore", "pipe", "pipe"], ...env ? { env } : {} });
     const cancelled = callSignal();
     if (cancelled !== undefined) {
       const end = () => {
@@ -42239,7 +42662,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;
     });
@@ -42249,7 +42671,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();
@@ -42331,7 +42774,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,
@@ -42388,6 +42832,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;
@@ -42588,6 +43057,7 @@ class GodotServer {
         resolve(false);
       });
     });
+    await boot.settled;
     const errors = boot.log.count("error");
     const warnings = boot.log.count("warning");
     return this.jsonTextResponse({
@@ -42729,6 +43199,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);
@@ -42764,7 +43235,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
       }));
@@ -42772,6 +43243,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.`);
@@ -42787,8 +43261,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,
@@ -42823,6 +43298,7 @@ class GodotServer {
     if (elsewhere !== null) {
       return elsewhere;
     }
+    await this.tieThePlayedGame(stopped);
     this.drainEditorOutput(stopped);
     this.drainTranscript(stopped);
     const wasRunning = await this.runStillGoing(stopped);
@@ -42831,7 +43307,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])) {
@@ -42846,7 +43322,7 @@ class GodotServer {
       endedPid,
       throughEditor: stopped.throughEditor,
       exitSignal: stopped.exitSignal,
-      errors: stopped.log.count("error")
+      clean: cleanVerdict(stopped)
     });
     return this.jsonTextResponse({
       stopped: verdict.stopped,
@@ -42860,6 +43336,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)
     });
@@ -43072,7 +43549,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");
@@ -43080,29 +43562,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)}` };
@@ -43124,7 +43613,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.`);
@@ -43139,6 +43628,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,
@@ -43165,7 +43655,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;
       }
@@ -43173,9 +43664,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({
@@ -43247,6 +43739,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") {
@@ -43375,7 +43896,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;
@@ -43399,11 +43920,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()) {
@@ -43455,7 +43980,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) {
@@ -43496,7 +44021,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 {
@@ -43596,7 +44121,7 @@ async function runGodotServer() {
   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, 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, 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();
@@ -43612,6 +44137,7 @@ var init_server3 = __esm(() => {
   init_dap_client();
   init_desktop();
   init_editor_log();
+  init_engine_run();
   init_errors();
   init_game_log();
   init_godot_bridge();
@@ -43627,7 +44153,6 @@ var init_server3 = __esm(() => {
   init_process_children();
   init_process_time();
   init_project_scan();
-  init_reimport();
   init_resources();
   init_restart_note();
   init_run_record();
@@ -43637,8 +44162,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 = {
@@ -43687,8 +44212,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";
@@ -44587,8 +45112,8 @@ init_setup();
 // src/skill.ts
 init_setup();
 init_tool_definitions();
-import { existsSync as existsSync9, mkdirSync as mkdirSync5, readdirSync as readdirSync5, rmSync as rmSync5, writeFileSync as writeFileSync6 } from "node:fs";
-import { basename as basename2, dirname as dirname5, join as join10 } 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();
@@ -44684,7 +45209,7 @@ function renderToolsMarkdown() {
 
 // src/skill.ts
 var SKILL_NAME = "gdharness";
-var SHARED_SKILLS = join10(".agents", "skills");
+var SHARED_SKILLS = join11(".agents", "skills");
 function skillMarkdown(version) {
   return `---
 name: ${SKILL_NAME}
@@ -44721,9 +45246,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
@@ -44875,27 +45401,27 @@ whatever the engine said on stderr comes back under \`engine_messages\`.
 function skillFiles(version) {
   return new Map([
     ["SKILL.md", skillMarkdown(version)],
-    [join10("references", "tools.md"), renderToolsMarkdown()]
+    [join11("references", "tools.md"), renderToolsMarkdown()]
   ]);
 }
 function skillDirectories(harnesses, projectPath, exists) {
-  const directories = [join10(projectPath, SHARED_SKILLS, SKILL_NAME)];
+  const directories = [join11(projectPath, SHARED_SKILLS, SKILL_NAME)];
   for (const harness of harnesses) {
     if (harness.skills === undefined) {
       continue;
     }
-    const own = join10(projectPath, harness.skills.dir);
-    if ((!harness.skills.shared || exists(own)) && !directories.includes(join10(own, SKILL_NAME))) {
-      directories.push(join10(own, SKILL_NAME));
+    const own = join11(projectPath, harness.skills.dir);
+    if ((!harness.skills.shared || exists(own)) && !directories.includes(join11(own, SKILL_NAME))) {
+      directories.push(join11(own, SKILL_NAME));
     }
   }
   return directories;
 }
 function everySkillDirectory(projectPath, harnesses) {
-  const directories = new Set([join10(projectPath, SHARED_SKILLS, SKILL_NAME)]);
+  const directories = new Set([join11(projectPath, SHARED_SKILLS, SKILL_NAME)]);
   for (const harness of harnesses) {
     if (harness.skills !== undefined) {
-      directories.add(join10(projectPath, harness.skills.dir, SKILL_NAME));
+      directories.add(join11(projectPath, harness.skills.dir, SKILL_NAME));
     }
   }
   return [...directories];
@@ -44903,52 +45429,52 @@ function everySkillDirectory(projectPath, harnesses) {
 function removeSkill(directories, projectPath) {
   const removed = [];
   for (const directory of directories) {
-    if (existsSync9(directory)) {
-      rmSync5(directory, { recursive: true, force: true });
-      pruneEmpty(dirname5(directory), projectPath);
+    if (existsSync11(directory)) {
+      rmSync6(directory, { recursive: true, force: true });
+      pruneEmpty(dirname6(directory), projectPath);
       removed.push(directory);
     }
   }
   return removed;
 }
 function pruneEmpty(directory, projectPath) {
-  const shared = join10(projectPath, ".agents");
+  const shared = join11(projectPath, ".agents");
   let path = directory;
-  while (path !== projectPath && (basename2(path) === "skills" || path === shared)) {
+  while (path !== projectPath && (basename3(path) === "skills" || path === shared)) {
     if (readdirSync5(path).length > 0) {
       return;
     }
-    rmSync5(path, { recursive: true, force: true });
-    path = dirname5(path);
+    rmSync6(path, { recursive: true, force: true });
+    path = dirname6(path);
   }
 }
 function writeSkill(directories, version) {
   const files = skillFiles(version);
   return directories.map((directory) => {
-    const replaced = existsSync9(directory);
-    rmSync5(directory, { recursive: true, force: true });
+    const replaced = existsSync11(directory);
+    rmSync6(directory, { recursive: true, force: true });
     for (const [name, contents] of files) {
-      const path = join10(directory, name);
-      mkdirSync5(dirname5(path), { recursive: true });
-      writeFileSync6(path, contents, "utf8");
+      const path = join11(directory, name);
+      mkdirSync5(dirname6(path), { recursive: true });
+      writeFileSync7(path, contents, "utf8");
     }
     return { path: directory, replaced };
   });
 }
 
 // src/version.ts
-import { readFileSync as readFileSync8 } from "node:fs";
-import { dirname as dirname6, join as join11 } 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 = [
-    join11(currentDirectory, "..", "package.json"),
-    join11(currentDirectory, "..", "..", "package.json")
+    join12(currentDirectory, "..", "package.json"),
+    join12(currentDirectory, "..", "..", "package.json")
   ];
   for (const packagePath of packageCandidates) {
     try {
-      const value = JSON.parse(readFileSync8(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;
       }
@@ -44966,7 +45492,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;
@@ -45005,7 +45531,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}`);
   }
 }
@@ -45137,7 +45663,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}`);
       }
@@ -45231,7 +45757,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(`