gdharness 1.3.43 → 1.3.44

package/build/cli.js

@@ -9723,8 +9723,71 @@ var init_gdscript_source = __esm(() => {
   ]);
 });
 
+// src/whole-file.ts
+import { readFileSync as readFileSync5, renameSync, rmSync as rmSync4, writeFileSync as writeFileSync4 } from "node:fs";
+function readWhole(path) {
+  const until = Date.now() + HELD_FILE_MS;
+  for (;; ) {
+    try {
+      return readFileSync5(path, "utf8");
+    } catch (error) {
+      const code = error.code ?? "";
+      if (code === "ENOENT") {
+        return null;
+      }
+      if (!HELD_BY_A_READER.has(code) || Date.now() >= until) {
+        throw error;
+      }
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, HELD_FILE_RETRY_MS);
+    }
+  }
+}
+function writeWhole(path, text) {
+  const partial = `${path}.${process.pid}.partial`;
+  try {
+    writeFileSync4(partial, text, "utf8");
+  } catch {
+    return false;
+  }
+  const until = Date.now() + HELD_FILE_MS;
+  for (;; ) {
+    try {
+      renameSync(partial, path);
+      return true;
+    } catch (error) {
+      const code = error.code ?? "";
+      if (!HELD_BY_A_READER.has(code) || Date.now() >= until) {
+        try {
+          rmSync4(partial, { force: true });
+        } catch {}
+        return false;
+      }
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, HELD_FILE_RETRY_MS);
+    }
+  }
+}
+function removeWhole(path) {
+  const until = Date.now() + HELD_FILE_MS;
+  for (;; ) {
+    try {
+      rmSync4(path, { force: true });
+      return true;
+    } catch (error) {
+      const code = error.code ?? "";
+      if (!HELD_BY_A_READER.has(code) || Date.now() >= until) {
+        return false;
+      }
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, HELD_FILE_RETRY_MS);
+    }
+  }
+}
+var HELD_FILE_MS = 1000, HELD_FILE_RETRY_MS = 10, HELD_BY_A_READER;
+var init_whole_file = __esm(() => {
+  HELD_BY_A_READER = new Set(["EPERM", "EACCES", "EBUSY"]);
+});
+
 // src/class-cache.ts
-import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync5, statSync as statSync4 } from "node:fs";
+import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync6, statSync as statSync4 } from "node:fs";
 import { join as join6, posix } from "node:path";
 function isToolScript(source) {
   return TOOL.test(codeOf(source));
@@ -9799,7 +9862,7 @@ function eachScript(projectPath, each) {
       if (entry.isDirectory()) {
         visit(path, `${prefix}${entry.name}/`);
       } else if (entry.isFile() && entry.name.endsWith(".gd")) {
-        each(`res://${prefix}${entry.name}`, readFileSync5(path, "utf8"));
+        each(`res://${prefix}${entry.name}`, readFileSync6(path, "utf8"));
       }
     }
   };
@@ -9832,12 +9895,11 @@ function scriptsDeclaring(projectPath, classes) {
   return declaring.sort((a, b) => a.script.localeCompare(b.script));
 }
 function cachedClasses(projectPath) {
-  const cache = join6(projectPath, ".godot", "global_script_class_cache.cfg");
-  if (!existsSync4(cache)) {
+  const text = readWhole(join6(projectPath, ".godot", "global_script_class_cache.cfg"));
+  if (text === null) {
     return null;
   }
   const listed = new Map;
-  const text = readFileSync5(cache, "utf8");
   for (const entry of text.matchAll(/"class":\s*&"([^"]+)"[\s\S]*?"path":\s*"([^"]+)"/g)) {
     listed.set(entry[1] ?? "", entry[2] ?? "");
   }
@@ -10126,7 +10188,8 @@ function failedReloadNote(failed) {
   } 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.builtOn !== undefined ? ` ${failed.builtOn}` : 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.`;
+  const advice = 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.`;
+  const order = failed.builtOn === undefined ? advice : ` ${failed.builtOn}${failed.builtOnUnchecked === true ? advice : ""}`;
   return `${failed.script} did not compile: Godot answered ${answered}. ${copy} ` + `script_diagnostics on it gives the errors.${order}`;
 }
 function uncachedClassNote(types) {
@@ -10188,6 +10251,7 @@ function unseenByEditor(projectPath, editorHolds) {
 var DECLARATION, TOOL, ABSTRACT_HEADER, UNKNOWN_CLASS;
 var init_class_cache = __esm(() => {
   init_gdscript_source();
+  init_whole_file();
   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;
   ABSTRACT_HEADER = /^((?:@[\p{L}_][\p{L}\p{N}_]*(?:\([^)]*\))?\s+)*)(?:class_name|extends)\s/mu;
@@ -10894,7 +10958,7 @@ var init_junit = __esm(() => {
 });
 
 // src/suite-judge.ts
-import { readFileSync as readFileSync6 } from "node:fs";
+import { readFileSync as readFileSync7 } from "node:fs";
 import { stripVTControlCharacters } from "node:util";
 function secondsOf(time) {
   let ms = 0;
@@ -11095,7 +11159,7 @@ function versionFault(said, wanted) {
 function readExpected(file) {
   const declared = (value) => typeof value === "object" && value !== null ? value : {};
   try {
-    const parsed = JSON.parse(readFileSync6(file, "utf8"));
+    const parsed = JSON.parse(readFileSync7(file, "utf8"));
     const read = typeof parsed === "object" && parsed !== null ? parsed : {};
     return { errors: declared(read["errors"]), warnings: declared(read["warnings"]) };
   } catch {
@@ -11417,9 +11481,9 @@ import {
   openSync as openSync2,
   readdirSync as readdirSync3,
   readSync,
-  rmSync as rmSync4,
+  rmSync as rmSync5,
   statSync as statSync5,
-  writeFileSync as writeFileSync4,
+  writeFileSync as writeFileSync5,
   writeSync as writeSync2
 } from "node:fs";
 import { availableParallelism, freemem, totalmem } from "node:os";
@@ -11495,14 +11559,14 @@ function sweepRunDirectories(runs, kept = KEPT_RUN_DIRECTORIES) {
     const named = /^(\d+)-(\d+)$/.exec(entry);
     const pid = Number(named?.[2]);
     if (!Number.isInteger(pid)) {
-      rmSync4(join7(runs, entry), { recursive: true, force: true });
+      rmSync5(join7(runs, entry), { recursive: true, force: true });
     } else if (!alive(pid)) {
       ended.push({ entry, started: Number(named?.[1]) });
     }
   }
   ended.sort((a, b) => b.started - a.started);
   for (const { entry } of ended.slice(kept)) {
-    rmSync4(join7(runs, entry), { recursive: true, force: true });
+    rmSync5(join7(runs, entry), { recursive: true, force: true });
   }
 }
 function roomFor(most, processors, available, said = "of memory free", processorsSaid = `the machine has ${plural(processors, "processor")}`) {
@@ -11607,7 +11671,7 @@ async function watchedEngine(launch, args, directory, log, silenceSeconds, silen
       piped = [helped.stdout, helped.stderr];
       child = helped;
       stop = () => {
-        writeFileSync4(stopFile, "");
+        writeFileSync5(stopFile, "");
       };
     } else {
       const held = heldToCores(launch.cores, launch.godotPath, args);
@@ -11761,9 +11825,9 @@ function stillGoingSaid(tool, op, elapsedMs) {
   const took = seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
   return `${op === null || op === "" ? tool : `${tool} ${op}`} is still going; ${took} in.`;
 }
-async function withCallSignal(signal, answer, progress, still) {
+async function withCallSignal(signal, answer, progress, still, slotWaits) {
   if (progress === undefined) {
-    return signal === undefined ? answer() : current.run({ signal, progress: undefined }, answer);
+    return signal === undefined && slotWaits === undefined ? answer() : current.run({ signal, progress: undefined, slotWaits }, answer);
   }
   const began = Date.now();
   const rising = risingOnly(progress);
@@ -11787,7 +11851,7 @@ async function withCallSignal(signal, answer, progress, still) {
   };
   rearm();
   try {
-    return await current.run({ signal, progress: told }, answer);
+    return await current.run({ signal, progress: told, slotWaits }, answer);
   } finally {
     going = undefined;
     clearTimeout(quiet);
@@ -11806,63 +11870,20 @@ function callSignal() {
 function callProgress() {
   return current.getStore()?.progress;
 }
+function callSlotWaits() {
+  return current.getStore()?.slotWaits;
+}
 var current, CALL_HEARTBEAT_MS = 20000;
 var init_call_signal = __esm(() => {
   current = new AsyncLocalStorage;
 });
 
-// src/whole-file.ts
-import { renameSync, rmSync as rmSync5, writeFileSync as writeFileSync5 } from "node:fs";
-function writeWhole(path, text) {
-  const partial = `${path}.${process.pid}.partial`;
-  try {
-    writeFileSync5(partial, text, "utf8");
-  } catch {
-    return false;
-  }
-  const until = Date.now() + HELD_FILE_MS;
-  for (;; ) {
-    try {
-      renameSync(partial, path);
-      return true;
-    } catch (error) {
-      const code = error.code ?? "";
-      if (!HELD_BY_A_READER.has(code) || Date.now() >= until) {
-        try {
-          rmSync5(partial, { force: true });
-        } catch {}
-        return false;
-      }
-      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, HELD_FILE_RETRY_MS);
-    }
-  }
-}
-function removeWhole(path) {
-  const until = Date.now() + HELD_FILE_MS;
-  for (;; ) {
-    try {
-      rmSync5(path, { force: true });
-      return true;
-    } catch (error) {
-      const code = error.code ?? "";
-      if (!HELD_BY_A_READER.has(code) || Date.now() >= until) {
-        return false;
-      }
-      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, HELD_FILE_RETRY_MS);
-    }
-  }
-}
-var HELD_FILE_MS = 1000, HELD_FILE_RETRY_MS = 10, HELD_BY_A_READER;
-var init_whole_file = __esm(() => {
-  HELD_BY_A_READER = new Set(["EPERM", "EACCES", "EBUSY"]);
-});
-
 // src/engine-slots.ts
 import {
   closeSync as closeSync3,
   mkdirSync as mkdirSync3,
   openSync as openSync3,
-  readFileSync as readFileSync7,
+  readFileSync as readFileSync8,
   rmSync as rmSync6,
   statSync as statSync6,
   watch,
@@ -11992,7 +12013,7 @@ class EngineSlots {
     this.holder = holder;
     this.say = say;
   }
-  async take(signal, waiting) {
+  async take(signal, waiting, blocked) {
     mkdirSync3(this.directory, { recursive: true });
     const began = Date.now();
     let said = Number.NEGATIVE_INFINITY;
@@ -12005,7 +12026,10 @@ class EngineSlots {
         if (lock !== null) {
           return lock;
         }
-        mark ??= this.waitMarked();
+        if (mark === undefined) {
+          mark = this.waitMarked();
+          blocked?.();
+        }
         const now = Date.now();
         if (waiting !== undefined) {
           if (now - said >= WAIT_SAID_MS) {
@@ -12059,7 +12083,7 @@ class EngineSlots {
     const found = [];
     for (let slot = 0;slot < this.count; slot += 1) {
       try {
-        const holder = holderOf(readFileSync7(join8(this.directory, `${String(slot)}.lock`), "utf8"));
+        const holder = holderOf(readFileSync8(join8(this.directory, `${String(slot)}.lock`), "utf8"));
         if (holder !== null) {
           found.push(holder);
         }
@@ -12079,7 +12103,7 @@ class EngineSlots {
   release(lock) {
     this.held.delete(lock);
     try {
-      if (holderOf(readFileSync7(lock, "utf8"))?.pid === this.holder.pid) {
+      if (holderOf(readFileSync8(lock, "utf8"))?.pid === this.holder.pid) {
         removeWhole(lock);
       }
     } catch {}
@@ -12129,7 +12153,7 @@ class EngineSlots {
     let content;
     let writtenAt;
     try {
-      content = readFileSync7(lock, "utf8");
+      content = readFileSync8(lock, "utf8");
       writtenAt = statSync6(lock).mtimeMs;
     } catch {
       return false;
@@ -12167,31 +12191,55 @@ function nameSlotTaker(by) {
 }
 function slotWaitSaid(waitedMs, count, directory, holders = []) {
   const slots = count === 1 ? `the one engine slot on this machine (${directory}) is in use` : `all ${String(count)} engine slots on this machine (${directory}) are in use`;
+  const named = holdersNamed(count, holders);
+  const waiting = `Waiting${waitedMs >= 1000 ? ` ${String(Math.round(waitedMs / 1000))} s so far` : ""} for an engine: ${slots}`;
+  if (named.length === 0) {
+    return `${waiting}, by a gate or another tool, and the engine starts when one is given back.`;
+  }
+  if (count === 1) {
+    return `${waiting}, by ${named.join(", ")}, and the engine starts when it is given back.`;
+  }
+  return `${waiting}: ${listed(named)}. The engine starts when one is given back.`;
+}
+function slotWaitedSaid(waitedMs, count, directory, holders) {
+  const waited = `This call waited ${String(Math.round(waitedMs / 1000))} s for an engine slot in all.`;
+  const slots = count === 1 ? `the one engine slot on this machine (${directory}) was in use` : `all ${String(count)} engine slots on this machine (${directory}) were in use`;
+  const named = holdersNamed(count, holders);
+  if (named.length === 0) {
+    return `${waited} When it first waited, ${slots}, by a gate or another tool.`;
+  }
+  return count === 1 ? `${waited} When it first waited, ${slots}, by ${named.join(", ")}.` : `${waited} When it first waited, ${slots}: ${listed(named)}.`;
+}
+function holdersNamed(count, holders) {
   const held = new Map;
   for (const holder of holders) {
     const known = held.get(holder.pid);
     held.set(holder.pid, { by: known?.by ?? holder.by, slots: (known?.slots ?? 0) + 1 });
   }
-  const named = [...held].map(([pid, { by, slots: taken }]) => {
+  return [...held].map(([pid, { by, slots: taken }]) => {
     const who = pid === process7.pid ? `this process (pid ${String(pid)})` : by === undefined ? `pid ${String(pid)}` : `${by} (pid ${String(pid)})`;
     return count === 1 ? who : `${String(taken)} by ${who}`;
   });
-  const waiting = `Waiting${waitedMs >= 1000 ? ` ${String(Math.round(waitedMs / 1000))} s so far` : ""} for an engine: ${slots}`;
-  if (named.length === 0) {
-    return `${waiting}, by a gate or another tool, and the engine starts when one is given back.`;
-  }
-  if (count === 1) {
-    return `${waiting}, by ${named.join(", ")}, and the engine starts when it is given back.`;
-  }
-  const list = named.length === 1 ? named.join("") : `${named.slice(0, -1).join(", ")} and ${named.at(-1) ?? ""}`;
-  return `${waiting}: ${list}. The engine starts when one is given back.`;
+}
+function listed(named) {
+  return named.length === 1 ? named.join("") : `${named.slice(0, -1).join(", ")} and ${named.at(-1) ?? ""}`;
 }
 async function slotForCall() {
   const slots = await processSlots();
   const progress = callProgress();
+  const waits = callSlotWaits();
+  const began = Date.now();
+  let blockedBy;
   const lock = await slots.take(callSignal(), progress === undefined ? undefined : (waitedMs) => {
     progress(waitedMs / 1000, slotWaitSaid(waitedMs, slots.count, slots.directory, slots.holders()));
+  }, () => {
+    blockedBy = slots.holders();
   });
+  if (waits !== undefined && blockedBy !== undefined) {
+    waits.ms += Date.now() - began;
+    const heldBy = blockedBy;
+    waits.said ??= (waitedMs) => slotWaitedSaid(waitedMs, slots.count, slots.directory, heldBy);
+  }
   return {
     release: () => {
       slots.release(lock);
@@ -12961,7 +13009,7 @@ var init_doc_cache = __esm(() => {
 });
 
 // src/project-scan.ts
-import { existsSync as existsSync9, readdirSync as readdirSync6, readFileSync as readFileSync8, statSync as statSync9 } from "node:fs";
+import { existsSync as existsSync9, readdirSync as readdirSync6, readFileSync as readFileSync9, statSync as statSync9 } from "node:fs";
 import { basename as basename5, extname, join as join11, relative as relative4, sep as sep3 } from "node:path";
 function skipped(name) {
   return name.startsWith(".") || SKIPPED.has(name);
@@ -13097,7 +13145,7 @@ function scriptsWithoutUid(projectPath) {
 function pathsInUidCache(projectPath) {
   let data;
   try {
-    data = readFileSync8(join11(projectPath, ".godot", "uid_cache.bin"));
+    data = readFileSync9(join11(projectPath, ".godot", "uid_cache.bin"));
   } catch {
     return null;
   }
@@ -13159,7 +13207,7 @@ function projectTexts(projectPath) {
       if (!entry.isFile() || BINARY_EXTENSIONS.has(extension)) {
         continue;
       }
-      const bytes = readFileSync8(absolute);
+      const bytes = readFileSync9(absolute);
       if (!isBinary(bytes)) {
         found.push({ path: `res://${spelled}`, absolute, text: bytes.toString("utf8") });
       }
@@ -13189,7 +13237,7 @@ function ignoredTexts(projectPath) {
       if (!under || !entry.isFile() || BINARY_EXTENSIONS.has(extension) || entry.name === ".gdignore") {
         continue;
       }
-      const bytes = readFileSync8(absolute);
+      const bytes = readFileSync9(absolute);
       if (!isBinary(bytes)) {
         found.push({ path: `res://${spelled}`, absolute, text: bytes.toString("utf8") });
       }
@@ -13226,7 +13274,7 @@ function searchProject(projectPath, options) {
   };
   const regex = options.regex ? compiledQuery(options.query, options.caseSensitive) : null;
   const needle = options.caseSensitive ? options.query : options.query.toLowerCase();
-  const full = () => result.summary.truncated;
+  let shown = 0;
   const notSearched = [];
   const met = new Set;
   const searchFile = (entryPath, name) => {
@@ -13237,28 +13285,33 @@ function searchProject(projectPath, options) {
     if (extensions !== null && !extensions.has(extension)) {
       return;
     }
-    const bytes = readFileSync8(entryPath);
+    const bytes = readFileSync9(entryPath);
     if (extensions === null && isBinary(bytes)) {
       return;
     }
     result.summary.files_searched += 1;
     const matches = [];
+    let matched = false;
     for (const [index, line] of bytes.toString("utf8").split(/\r?\n/).entries()) {
       const found = regex ? regex.exec(line) : plainMatch(line, needle, options.caseSensitive);
       if (found === null) {
         continue;
       }
-      if (result.summary.total_matches >= options.maxResults) {
+      matched = true;
+      result.summary.total_matches += 1;
+      if (shown >= options.maxResults) {
         result.summary.truncated = true;
-        break;
+        continue;
       }
+      shown += 1;
       matches.push({ line: index + 1, content: line.trim(), match: found[0] });
-      result.summary.total_matches += 1;
+    }
+    if (matched) {
+      result.summary.files_with_matches += 1;
     }
     if (matches.length > 0) {
       const relativePath = entryPath.slice(projectPath.length + 1).replace(/\\/g, "/");
       result.results.push({ file: `res://${relativePath}`, matches });
-      result.summary.files_with_matches += 1;
     }
   };
   const visit = (directory, named = false) => {
@@ -13269,9 +13322,6 @@ function searchProject(projectPath, options) {
       return;
     }
     for (const entry of readdirSync6(directory, { withFileTypes: true })) {
-      if (full()) {
-        return;
-      }
       if (skipped(entry.name)) {
         continue;
       }
@@ -13351,7 +13401,7 @@ var init_project_scan = __esm(() => {
 
 // src/import-freshness.ts
 import { createHash as createHash2 } from "node:crypto";
-import { existsSync as existsSync10, readdirSync as readdirSync7, readFileSync as readFileSync9, statSync as statSync10 } from "node:fs";
+import { existsSync as existsSync10, readdirSync as readdirSync7, readFileSync as readFileSync10, statSync as statSync10 } from "node:fs";
 import { join as join12 } from "node:path";
 function md5Of(file) {
   let stats;
@@ -13366,7 +13416,7 @@ function md5Of(file) {
   }
   let md5;
   try {
-    md5 = createHash2("md5").update(readFileSync9(file)).digest("hex");
+    md5 = createHash2("md5").update(readFileSync10(file)).digest("hex");
   } catch {
     return null;
   }
@@ -13392,7 +13442,7 @@ function sectionOf(text, section) {
 function unquoted(value) {
   return value === undefined ? "" : value.replace(/^"(.*)"$/, "$1");
 }
-function listed(value) {
+function listed2(value) {
   return [...(value ?? "").matchAll(/"((?:[^"\\]|\\.)*)"/g)].map((match) => match[1] ?? "");
 }
 function importedIntoTheProject(projectPath, resPaths) {
@@ -13400,11 +13450,11 @@ function importedIntoTheProject(projectPath, resPaths) {
   for (const resPath of resPaths) {
     let sidecar;
     try {
-      sidecar = readFileSync9(`${onDisk(projectPath, resPath)}.import`, "utf8");
+      sidecar = readFileSync10(`${onDisk(projectPath, resPath)}.import`, "utf8");
     } catch {
       continue;
     }
-    const outputs = listed(sectionOf(sidecar, "deps").get("dest_files")).filter((output) => output.startsWith("res://") && !output.startsWith("res://.godot/"));
+    const outputs = listed2(sectionOf(sidecar, "deps").get("dest_files")).filter((output) => output.startsWith("res://") && !output.startsWith("res://.godot/"));
     if (outputs.length > 0) {
       wrote[resPath] = outputs;
     }
@@ -13420,7 +13470,7 @@ function behind(projectPath, resPath, sidecar) {
   if (importer === "keep" || importer === "skip") {
     return null;
   }
-  const outputs = listed(sectionOf(sidecar, "deps").get("dest_files"));
+  const outputs = listed2(sectionOf(sidecar, "deps").get("dest_files"));
   if (outputs.some((output) => !existsSync10(onDisk(projectPath, output)))) {
     return "its imported output is not on disk";
   }
@@ -13428,7 +13478,7 @@ function behind(projectPath, resPath, sidecar) {
   const record = join12(projectPath, ".godot", "imported", `${name}-${createHash2("md5").update(resPath, "utf8").digest("hex")}.md5`);
   let recorded = "";
   try {
-    recorded = /^source_md5="([0-9a-f]*)"/m.exec(readFileSync9(record, "utf8"))?.[1] ?? "";
+    recorded = /^source_md5="([0-9a-f]*)"/m.exec(readFileSync10(record, "utf8"))?.[1] ?? "";
   } catch {
     recorded = "";
   }
@@ -13470,7 +13520,7 @@ function staleImports(projectPath) {
         }
         let sidecar;
         try {
-          sidecar = readFileSync9(join12(directory, entry.name), "utf8");
+          sidecar = readFileSync10(join12(directory, entry.name), "utf8");
         } catch {
           continue;
         }
@@ -13534,7 +13584,7 @@ import {
   existsSync as existsSync11,
   mkdirSync as mkdirSync4,
   readdirSync as readdirSync8,
-  readFileSync as readFileSync10,
+  readFileSync as readFileSync11,
   renameSync as renameSync2,
   unlinkSync,
   writeFileSync as writeFileSync6
@@ -13650,7 +13700,7 @@ function resolveResource(projectPath, relativeTo, path) {
 }
 function readOrNull(path) {
   try {
-    return readFileSync10(path, "utf8");
+    return readFileSync11(path, "utf8");
   } catch {
     return null;
   }
@@ -13659,7 +13709,7 @@ var init_library_copies = () => {};
 
 // src/reimport.ts
 import { createHash as createHash3 } from "node:crypto";
-import { existsSync as existsSync12, readFileSync as readFileSync11, rmSync as rmSync7, statSync as statSync11, utimesSync, writeFileSync as writeFileSync7 } from "node:fs";
+import { existsSync as existsSync12, readFileSync as readFileSync12, rmSync as rmSync7, statSync as statSync11, utimesSync, writeFileSync as writeFileSync7 } from "node:fs";
 import { basename as basename7, join as join14 } from "node:path";
 function forceNextImport(projectPath, resourcePath) {
   const relative = resourcePath.replace(/^res:\/\//, "");
@@ -13668,7 +13718,7 @@ function forceNextImport(projectPath, resourcePath) {
     return;
   }
   const { atime, mtimeMs } = statSync11(sidecar);
-  writeFileSync7(sidecar, readFileSync11(sidecar, "utf8").replace(/^valid=false\r?\n/m, ""));
+  writeFileSync7(sidecar, readFileSync12(sidecar, "utf8").replace(/^valid=false\r?\n/m, ""));
   utimesSync(sidecar, atime, new Date(mtimeMs + 2000));
   rmSync7(importRecord(projectPath, resourcePath), { force: true });
 }
@@ -13894,7 +13944,7 @@ var init_script_origins = __esm(() => {
 });
 
 // src/headless.ts
-import { existsSync as existsSync14, readFileSync as readFileSync12, writeFileSync as writeFileSync8 } from "node:fs";
+import { existsSync as existsSync14, readFileSync as readFileSync13, writeFileSync as writeFileSync8 } from "node:fs";
 import { dirname as dirname7, join as join17 } from "node:path";
 function snakeCased(params) {
   const result = emptyRecord();
@@ -14185,7 +14235,7 @@ function answerIn(file) {
   if (!existsSync14(file)) {
     return { kind: "none" };
   }
-  const text = readFileSync12(file, "utf8");
+  const text = readFileSync13(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)}` };
@@ -14210,7 +14260,7 @@ var init_headless = __esm(() => {
 });
 
 // src/update-check.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync5, readFileSync as readFileSync13, writeFileSync as writeFileSync9 } from "node:fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync5, readFileSync as readFileSync14, writeFileSync as writeFileSync9 } from "node:fs";
 import { homedir as homedir5, tmpdir as tmpdir4 } from "node:os";
 import { join as join18 } from "node:path";
 function packageUrl(root) {
@@ -14255,7 +14305,7 @@ function readCache(path) {
     if (!existsSync15(path)) {
       return null;
     }
-    const parsed = JSON.parse(readFileSync13(path, "utf8"));
+    const parsed = JSON.parse(readFileSync14(path, "utf8"));
     if (typeof parsed !== "object" || parsed === null) {
       return null;
     }
@@ -14403,7 +14453,7 @@ var init_update_check = __esm(() => {
 });
 
 // src/server-version.ts
-import { readFileSync as readFileSync14 } from "node:fs";
+import { readFileSync as readFileSync15 } from "node:fs";
 function staleAddon(addonDigest, shippedDigest) {
   return addonDigest !== shippedDigest;
 }
@@ -14462,7 +14512,7 @@ var init_server_version = __esm(() => {
   DEBUG_MODE = process.env["GDHARNESS_DEBUG"] === "1";
   SERVER_VERSION = (() => {
     try {
-      const pkg = JSON.parse(readFileSync14(new URL("../package.json", import.meta.url), "utf8"));
+      const pkg = JSON.parse(readFileSync15(new URL("../package.json", import.meta.url), "utf8"));
       return typeof pkg.version === "string" ? pkg.version : "0.0.0";
     } catch {
       return "0.0.0";
@@ -15573,7 +15623,7 @@ var init_lsp_client = __esm(() => {
 });
 
 // src/resources.ts
-import { readFileSync as readFileSync16, realpathSync as realpathSync3 } from "node:fs";
+import { readFileSync as readFileSync17, realpathSync as realpathSync3 } from "node:fs";
 import { extname as extname2, resolve as resolve8 } from "node:path";
 function ensureProjectPath(getProjectPath) {
   const projectPath = getProjectPath();
@@ -15769,7 +15819,7 @@ function readResourceText(uri, getProjectPath) {
   const parsedUri = parseGodotUri(uri);
   if (parsedUri.kind === "project-info") {
     const projectFilePath = resolveProjectFile(projectPath, "project.godot");
-    const rawProject = readFileSync16(projectFilePath, "utf-8");
+    const rawProject = readFileSync17(projectFilePath, "utf-8");
     const parsedProject = parseProjectGodot(rawProject);
     return {
       mimeType: "application/json",
@@ -15778,7 +15828,7 @@ function readResourceText(uri, getProjectPath) {
   }
   const filePath = resolveProjectFile(projectPath, parsedUri.resourcePath);
   ensureAllowedExtension(parsedUri.kind, filePath);
-  const text = readFileSync16(filePath, "utf-8");
+  const text = readFileSync17(filePath, "utf-8");
   return {
     mimeType: parsedUri.kind === "script" ? "text/x-gdscript" : "text/plain",
     text
@@ -15925,7 +15975,7 @@ import {
   existsSync as existsSync18,
   mkdirSync as mkdirSync6,
   readdirSync as readdirSync11,
-  readFileSync as readFileSync17,
+  readFileSync as readFileSync18,
   rmdirSync,
   rmSync as rmSync9,
   statSync as statSync12,
@@ -15959,7 +16009,7 @@ function addonsDigest(names, from) {
       } else {
         hash.update(`${inside}
 `);
-        hash.update(readFileSync17(path));
+        hash.update(readFileSync18(path));
         hash.update(`
 `);
       }
@@ -15989,7 +16039,7 @@ function digestMarker(projectPath, addon) {
   if (!existsSync18(marker)) {
     return null;
   }
-  const said = readFileSync17(marker, "utf8").trim();
+  const said = readFileSync18(marker, "utf8").trim();
   return said === "" ? null : said;
 }
 function shippedAddonsDirectory() {
@@ -16006,7 +16056,7 @@ function loaderState(projectPath) {
   if (!existsSync18(copy)) {
     return "missing";
   }
-  const lines = (path) => readFileSync17(path, "utf8").replaceAll(`\r
+  const lines = (path) => readFileSync18(path, "utf8").replaceAll(`\r
 `, `
 `);
   return lines(copy) === lines(shippedLoader()) ? "current" : "differs";
@@ -16017,7 +16067,7 @@ function writeLoader(projectPath) {
   }
   const copy = join21(projectPath, ...RUNTIME_AUTOLOAD.path.split("/"));
   mkdirSync6(dirname9(copy), { recursive: true });
-  writeFileSync10(copy, readFileSync17(shippedLoader()));
+  writeFileSync10(copy, readFileSync18(shippedLoader()));
   return true;
 }
 function removeLoader(projectPath) {
@@ -16076,7 +16126,7 @@ function installedAddonVersion(projectPath) {
   if (!existsSync18(marker)) {
     return null;
   }
-  const said = readFileSync17(marker, "utf8").trim();
+  const said = readFileSync18(marker, "utf8").trim();
   return said === "" ? null : said;
 }
 function removeAddons(projectPath) {
@@ -16131,7 +16181,7 @@ function loaderAmong(projectPath, named) {
     }
     let source = null;
     try {
-      source = readFileSync17(join21(projectPath, path), "utf8");
+      source = readFileSync18(join21(projectPath, path), "utf8");
     } catch {}
     if (source?.includes(RUNTIME_SCRIPT)) {
       return { name: entry, path, exists: true };
@@ -16190,7 +16240,7 @@ function inspectProject(projectPath) {
     const directory = join21(projectPath, "addons", name);
     const marker = join21(directory, VERSION_MARKER);
     const installed = existsSync18(directory);
-    const version = existsSync18(marker) ? readFileSync17(marker, "utf8").trim() : null;
+    const version = existsSync18(marker) ? readFileSync18(marker, "utf8").trim() : null;
     const current = version === SERVER_VERSION;
     if (!installed) {
       problems.push(`addons/${name} is not installed; run gdharness setup`);
@@ -16199,7 +16249,7 @@ function inspectProject(projectPath) {
     }
     return { name, installed, version, current };
   });
-  const settings = parseProjectGodot(readFileSync17(join21(projectPath, "project.godot"), "utf8"));
+  const settings = parseProjectGodot(readFileSync18(join21(projectPath, "project.godot"), "utf8"));
   const pluginsEnabled = enabledPlugins(settings);
   for (const name of EDITOR_PLUGINS) {
     if (!pluginsEnabled.includes(name)) {
@@ -16630,7 +16680,11 @@ var init_tool_definitions = __esm(() => {
           ops: ["set"],
           description: 'The value to write, fitted to the type the setting is registered as, the way scene_node set fits a property. Engine types may be written as their fields, {"x": 1, "y": 2}, or tagged, {"_type": "Vector2", "x": 1, "y": 2}, and infinity as {"_type": "float", "value": "inf"}, the form a read answers with; one carrying a field its type has not is refused naming it, and a colour may also be its html code, "#ff8000". "" writes an empty string. A setting the engine does not declare is written as given, a whole number as an int and a plain list as an Array, so a packed array is tagged with its type, {"_type": "PackedStringArray", "value": ["res://a/"]}; a tag that cannot be read as its type is refused rather than written as a dictionary. When a setting in its section is named like an undeclared one, note names the nearest, as it may be a misspelt one. Every line of project.godot for another setting stays as it was, one holding a default value included.'
         },
-        name: { type: "string", ops: ["add_autoload", "remove_autoload"], description: "Autoload name." },
+        name: {
+          type: "string",
+          ops: ["add_autoload", "remove_autoload"],
+          description: "Autoload name. add_autoload on a name already registered replaces its entry, as the editor's Add does, and answers action updated with old_path, the path it held, which no longer loads."
+        },
         path: {
           type: "string",
           ops: ["add_autoload"],
@@ -16784,7 +16838,7 @@ var init_tool_definitions = __esm(() => {
         maxResults: {
           type: "integer",
           minimum: 1,
-          description: "How many matching lines to answer. Default 100."
+          description: "How many matching lines to answer. Default 100. Past it truncated is true, and the summary still counts the whole search."
         }
       },
       requires: ["projectPath", "query"]
@@ -16823,7 +16877,7 @@ var init_tool_definitions = __esm(() => {
       name: "project_import",
       title: "Asset imports",
       description: "The import pipeline: what needs importing, how a resource is imported, reimports, UIDs, and the global class list the editor and the engine read.",
-      answer: "reimport is answered from a second status read: reimported lists what is current now, notReimported what is not, one entry per status and reason with the paths sharing them, and via says which of the two did the work. importedByTheScan names what the editor's scan imported first, and alsoImported, on a reimport of one resourcePath, the others it imported. wroteInProject names, by source, what an import wrote into the project itself rather than under .godot, such as the .translation a CSV gives each language, which version control sees and internationalization/locale/translations names. The import gives every script without a .uid sidecar one, as the editor's scan does, and uidsWritten names those scripts, counted per addon under uidsWrittenInAddons for the ones inside an addon. When nothing needed reimporting, the two lists are empty, a note says so, and there is no via. A whole-project reimport also answers missingSource, the .import files whose source is not beside them, empty when there are none, even when nothing needed reimporting; one resourcePath leaves it out. stillImporting is an editor that had not finished within timeoutMs.",
+      answer: "options answers remap, deps and params as the .import file holds them, so an enum option such as compress/mode is its number: the engine gives scripts no list of a built-in importer's options or of what the numbers mean, so Godot's documentation of that importer is where a number is looked up. reimport is answered from a second status read: reimported lists what is current now, notReimported what is not, one entry per status and reason with the paths sharing them, and via says which of the two did the work. importedByTheScan names what the editor's scan imported first, and alsoImported, on a reimport of one resourcePath, the others it imported. wroteInProject names, by source, what an import wrote into the project itself rather than under .godot, such as the .translation a CSV gives each language, which version control sees and internationalization/locale/translations names. The import gives every script without a .uid sidecar one, as the editor's scan does, and uidsWritten names those scripts, counted per addon under uidsWrittenInAddons for the ones inside an addon. When nothing needed reimporting, the two lists are empty, a note says so, and there is no via. A whole-project reimport also answers missingSource, the .import files whose source is not beside them, empty when there are none, even when nothing needed reimporting; one resourcePath leaves it out. stillImporting is an editor that had not finished within timeoutMs.",
       parameters: {
         projectPath: PROJECT_PATH,
         resourcePath: { ...RESOURCE_PATH, ops: ["status", "options", "set_options", "uid", "reimport"] },
@@ -16885,7 +16939,7 @@ var init_tool_definitions = __esm(() => {
         },
         refresh_classes: {
           effect: "destructive",
-          summary: 'rewrite .godot/global_script_class_cache.cfg from the class_name declarations on disk. That misses the list a running editor loaded, so "added: []" means the file was already right, not that nothing is wrong: unseenByEditor names a class the editor open on this project cannot resolve, and heldBehindInEditor one it holds compiled from an older text of its file. lostSinceLastRebuild names a class the cache held after the last rebuild and lost before this one: the editor wrote the file without it, on a save or a scan, and will again until restarted. staleInThisEngine names a class the rebuild added, unknown to the autoloads its own engine compiles afterwards, and autoloadsOnTheRebuiltList what a second engine on that list reports of them',
+          summary: 'rewrite .godot/global_script_class_cache.cfg from the class_name declarations on disk. That misses the list a running editor loaded, so "added: []" means the file was already right, not that nothing is wrong: unseenByEditor names a class the editor open on this project cannot resolve, and heldBehindInEditor one it holds compiled from an older text of its file, with heldBehindUnchecked saying why when the editor did not say. lostSinceLastRebuild names a class the cache held after the last rebuild and lost before this one: the editor wrote the file without it, on a save or a scan, and will again until restarted. staleInThisEngine names a class the rebuild added, unknown to the autoloads its own engine compiles afterwards, and autoloadsOnTheRebuiltList what a second engine on that list reports of them',
           requires: []
         }
       }
@@ -16893,7 +16947,7 @@ var init_tool_definitions = __esm(() => {
     {
       name: "project_export",
       title: "Export",
-      description: "Export presets and exports. add_preset writes a preset to export_presets.cfg with the keys the editor's Project > Export writes for a new one and every option a new preset of its platform shows, each at its default, and makes it the platform's runnable preset when the platform has none. set_preset changes a preset's export path, its resource filter and the files it lists, its include and exclude filters, its custom features and its platform's options, and answers under changed what each held before and holds now, and under unchanged what already held the value given; nothing is written when any of it is refused. The option names are the exporter's own, as the Export dialog's Options tab shows them by their paths, such as binary_format/embed_pck, and a name the platform does not have is refused with the nearest it has, or all of them when none is near. An option the dialog shows only while another is on, such as codesign/identity behind codesign/enable, is taken when the preset has that one on or the same call turns it on, and otherwise refused naming what shows it. A secret option, such as a signing password, is written to .godot/export_credentials.cfg, where the editor keeps secrets out of the committed file, and its value is never answered. A file an option names that is not there is written and listed under missing_files, or for a secret its option under secretsNamingNoFile. remove_preset takes a preset out, and when it was its platform's runnable preset the next of that platform becomes it, under runnableNow, which is null when the platform has no other; a secret it held is taken out with it. It answers where this engine's export templates belong and whether the preset's platform has them, since an export needs them; list says the same for every preset. An editor open on the project does not see a preset added this way until it restarts. run names, as alsoWritten, what else the export wrote beside its output, such as the .pck a Windows or Linux build cannot start without. Its entries are the errors and warnings the export printed, the newest two hundred distinct ones, one printed more than once carrying times, and errors and warnings count them; exported is true only when this run wrote the output and printed no error.",
+      description: "Export presets and exports. add_preset writes a preset to export_presets.cfg with the keys the editor's Project > Export writes for a new one and every option a new preset of its platform shows, each at its default, and makes it the platform's runnable preset when the platform has none. set_preset changes a preset's export path, its resource filter and the files it lists, its include and exclude filters, its custom features and its platform's options, and answers under changed what each held before and holds now, and under unchanged what already held the value given, with saved false when that is all of it, since the file is then not written; nothing is written when any of it is refused. The option names are the exporter's own, as the Export dialog's Options tab shows them by their paths, such as binary_format/embed_pck, and a name the platform does not have is refused with the nearest it has, or all of them when none is near. An option the dialog shows only while another is on, such as codesign/identity behind codesign/enable, is taken when the preset has that one on or the same call turns it on, and otherwise refused naming what shows it. A secret option, such as a signing password, is written to .godot/export_credentials.cfg, where the editor keeps secrets out of the committed file, and its value is never answered. A file an option names that is not there is written and listed under missing_files, or for a secret its option under secretsNamingNoFile. remove_preset takes a preset out, and when it was its platform's runnable preset the next of that platform becomes it, under runnableNow, which is null when the platform has no other; a secret it held is taken out with it. It answers where this engine's export templates belong and whether the preset's platform has them, since an export needs them; list says the same for every preset. An editor open on the project does not see a preset added this way until it restarts. run names, as alsoWritten, what else the export wrote beside its output, such as the .pck a Windows or Linux build cannot start without. Its entries are the errors and warnings the export printed, the newest two hundred distinct ones, one printed more than once carrying times, and errors and warnings count them; exported is true only when this run wrote the output and printed no error.",
       parameters: {
         projectPath: PROJECT_PATH,
         preset: {
@@ -16977,7 +17031,7 @@ var init_tool_definitions = __esm(() => {
       title: "Run tests",
       effect: "additive",
       description: "Runs the project's gdUnit4 tests and answers with every case that did not pass: where it is, and what the assertion said. Each entry under failed carries its first report as message and detail, and, when it has more than one, its reports under reports in the order the case met them: gdUnit4 goes on past a failed assertion, and a case can fail several and then stop on a runtime error, which makes its status error. Identical reports fold into one with times, at most twenty different ones are kept (reportsLeftOut counts the rest), and past about a megabyte the largest cases keep only their first message (failedWithoutDetail). failures counts the cases that failed an assertion and errors the cases that hit an error, so such a case counts in both. Suites where everything passed are counted, not listed, and an engine message keeps the frames above gdUnit4, not the twenty inside it; identical engine messages come back once under engineEntries, with times saying how often they were printed, and with script, line and function for the project script one points at, as editor_output's entries have. The class list is rebuilt first, so a suite written a moment ago is found, and the rebuild's answer is under classes. What changed on disk since it was imported is then imported before any suite runs, and named under importedFirst. A suite it ran with no .uid beside it is named under uidsMissing, with uidsNote. On Windows and Linux the run gets a user:// of its own, away from a player's saves; on macOS the engine reads user:// off HOME, so it writes where the player keeps theirs, and savesNote says so. The run is headless unless a suite in it needs a window as gdharness test reads it, and then has one, on a desktop of its own on Windows. A run that found nothing to run is never called a pass, and names the path it looked in. A script that does not load stops gdUnit4 before any suite runs: its errors come back in full under scriptErrors, and the scripts that failed only because one they depend on did are listed by path under failedThroughDependency. When they failed on a class whose own script has a parser error, which gdUnit4 never names, that script is checked by the engine and its error comes first under scriptErrors, with the class it declares under declares, and the errors a script has only because that class did not resolve, which the engine reads as Variant, are kept apart under followFromUnresolved. An autoload that does not compile stops the run at once, its errors listed the same way. A client sending a progress token is told as each suite finishes, and at least every twenty seconds. A run that ends without a report, at its timeout or otherwise, names the suites it finished under suitesFinished, the failing ones with their failed cases under suitesFailing, and the one it was in under suiteRunning. When a client cuts a run off, that is kept in the project and the next project_test there carries it under previousRunCut. A run where nothing failed but orphan nodes were left comes back under warnings, with the count per suite: gdUnit4 decides its verdict on those and keeps them out of its report, so they are read off what it printed. A run whose every case passed is still not called passed when it printed a script error that no case failed on: gdUnit4 fails a case on the script errors its logger sees, and it cannot see a stack overflow, so the cases pass on whatever the faulted calls returned. Those errors come back under uncaughtScriptErrors, and under engineEntries by index with detailUnder rather than with their backtrace a second time; a backtrace that repeats, as a recursion's does, has each repeated frame or cycle of frames written once with the frames it covers and how many times. One raised inside assert_error(...).is_runtime_error is the test's own and is not listed there, and none are when the project turns off gdUnit4's report/godot/script_error setting; a suite declares them all the same. Needs gdUnit4 under addons/gdUnit4.",
-      answer: "passed is the verdict to read. exitCode is the engine's own exit, gdUnit4's code for what it saw (100 a case failed, 101 only warnings, 105 script errors it detected), and is 0 beside passed false when the run is failed for something gdUnit4 does not judge, such as an engine error no suite declared. time is gdUnit4's own sum of the seconds its cases took, from its report. tookMs is the whole call in milliseconds, from the class rebuild to the engine's exit, which is what a caller waits for, and tookMsBy splits it into the class rebuild (classes), the import after it (import) and the engine running the suites (engine), each with any wait for an engine slot or the editor's scan in it. The run is judged as gdharness test judges it: undeclaredErrors names each engine error that no suite declared in its GDHARNESS_EXPECTED_ERRORS constant, and each engine warning a suite printed and did not declare in its GDHARNESS_EXPECTED_WARNINGS, marked warning true, with the suite and the case that printed it, and declaredNotPrinted each declared error or warning its case did not print. gdUnit4 does not fail a case on push_error or push_warning, so a case that printed one undeclared is in neither failed nor errors: it is named here, and the run is failed for it. A declared text must be the whole line after ERROR: or WARNING: and its space, so a longer one its case printed holding the text is named under printedInstead. Either fails the run, and each suite holding one is listed with its count. leakedAtExit holds the engine's lines saying it exited still holding objects, resources, memory pages or a server's RIDs, which fail the run too, and the note names any script of the project Godot itself never frees and, on a run with engineArgs [\"--verbose\"], what the engine held. engineErrors counts every engine error the run printed but those a suite declared. orphans totals the orphan nodes gdUnit4 counted, and each suite that left some has its count, and a warning saying how to free them, under warnings, with left naming each case that left some (before or after for one of the suite's hooks, or the one value \"before or after\" where no case began and the two cannot be told apart) and the nodes, by class, name and script. suites lists only the suites with something to say (a case that failed, erred or was skipped, a hook that failed, orphans, or an error undeclared or declared and not printed), and suitesPassed counts the rest. A before() or after() that failed comes back under hookFailures with its suite, line and whole message; failures and errors count cases and leave it out, so the verdict names it as failed hooks, and the cases after a failed before() still run and are counted. Under classes, the classes each addon declares are counted under addedInAddons and changedInAddons rather than named, and a class the rebuild puts back that the cache had after the last rebuild is named under classes.lostSinceLastRebuild, which is the editor writing its shorter list over the file on every save until restarted. A suite needs a window when it declares const GDHARNESS_NEEDS_WINDOW: bool = true, or calls scene_runner and declares nothing; a run holding one has a window, at the size project.godot gives its viewport and with no sound, and windowed is true and windowNote names those suites and any saying it runs headless that shared the window. On a machine with no display such a run is headless, windowed is false, and windowNote says so. " + IMPORTED_FIRST,
+      answer: "passed is the verdict to read. exitCode is the engine's own exit, gdUnit4's code for what it saw (100 a case failed, 101 only warnings, 105 script errors it detected), and is 0 beside passed false when the run is failed for something gdUnit4 does not judge, such as an engine error no suite declared. time is gdUnit4's own sum of the seconds its cases took, from its report. tookMs is the whole call in milliseconds, from the class rebuild to the engine's exit, which is what a caller waits for, and tookMsBy splits it into the class rebuild (classes), the import after it (import) and the engine running the suites (engine), each with any wait for an engine slot or the editor's scan in it; a call that waited a second or more for slots in all is answered with an engine_slot_wait block giving waitedMs and who held them. The run is judged as gdharness test judges it: undeclaredErrors names each engine error that no suite declared in its GDHARNESS_EXPECTED_ERRORS constant, and each engine warning a suite printed and did not declare in its GDHARNESS_EXPECTED_WARNINGS, marked warning true, with the suite and the case that printed it, and declaredNotPrinted each declared error or warning its case did not print. gdUnit4 does not fail a case on push_error or push_warning, so a case that printed one undeclared is in neither failed nor errors: it is named here, and the run is failed for it. A declared text must be the whole line after ERROR: or WARNING: and its space, so a longer one its case printed holding the text is named under printedInstead. Either fails the run, and each suite holding one is listed with its count. leakedAtExit holds the engine's lines saying it exited still holding objects, resources, memory pages or a server's RIDs, which fail the run too, and the note names any script of the project Godot itself never frees and, on a run with engineArgs [\"--verbose\"], what the engine held. engineErrors counts every engine error the run printed but those a suite declared. orphans totals the orphan nodes gdUnit4 counted, and each suite that left some has its count, and a warning saying how to free them, under warnings, with left naming each case that left some (before or after for one of the suite's hooks, or the one value \"before or after\" where no case began and the two cannot be told apart) and the nodes, by class, name and script. suites lists only the suites with something to say (a case that failed, erred or was skipped, a hook that failed, orphans, or an error undeclared or declared and not printed), and suitesPassed counts the rest. A before() or after() that failed comes back under hookFailures with its suite, line and whole message; failures and errors count cases and leave it out, so the verdict names it as failed hooks, and the cases after a failed before() still run and are counted. Under classes, the classes each addon declares are counted under addedInAddons and changedInAddons rather than named, and a class the rebuild puts back that the cache had after the last rebuild is named under classes.lostSinceLastRebuild, which is the editor writing its shorter list over the file on every save until restarted. A suite needs a window when it declares const GDHARNESS_NEEDS_WINDOW: bool = true, or calls scene_runner and declares nothing; a run holding one has a window, at the size project.godot gives its viewport and with no sound, and windowed is true and windowNote names those suites and any saying it runs headless that shared the window. On a machine with no display such a run is headless, windowed is false, and windowNote says so. " + IMPORTED_FIRST,
       parameters: {
         projectPath: PROJECT_PATH,
         path: {
@@ -17512,7 +17566,7 @@ var init_tool_definitions = __esm(() => {
       name: "script_diagnostics",
       title: "Script diagnostics",
       effect: "read",
-      description: "Errors and warnings for a script, or for several, from the editor's language server, and whether each is clean. With no editor of this project open, so no language server of it to ask, a short headless engine compiles the scripts instead and the answer says checkedBy: engine rather than language server: every error that stops a script compiling, up to its first syntax error, with its line and no column (a call to a method another class lacks is not one, since GDScript checks those only on self: the object may be a subclass that has it, so it fails at run time instead), dependenciesWithErrors naming the other scripts that failed while it loaded, typesMissingFromTheClassCache naming a class the project declares that the engine could not resolve because the class cache lacks it, with staleAnalysis saying what rewrites the cache, and the warnings at the levels the project sets, which a second engine reports by raising each warning set to warn as an error for that run only, each at its line with no column, warnings being null when that engine could not answer. Of several scripts, a language server that stops answering partway leaves the rest to the engine, and checkedBy then says language server, then engine, with checkedByLanguageServer counting the scripts it answered. Each diagnostic carries its severity (error or warning), its message, and where it is as the editor shows it: line and column counted from 1, and endLine and endColumn just past its end. Diagnostics are checked against the project's own files, and the two that the files disprove are named rather than passed on: a member the class cache's file declares, or a project class it extends does, a method, property, constant, static function or enum member, comes back under contradictedByTheFile with the script declaring it, and so does one a diagnostic names alone as an external class member, read against the class it is looked up on in the line it is on; and a class this project declares that the diagnostic could not resolve comes back under typesTheEditorHasNotLoaded, with inTheClassCache saying whether a launched game would resolve it. staleAnalysis then says what to do, and for both states it is editor_rescan first: it asks the editor already running, starts nothing, and has cleared each in every reproduction measured. Two exceptions are named when they apply. For an enum member, constant or static function of a global class the reload comes first: in the one project that has reproduced a stale enum member, editor_rescan with reloadScript on the declaring script cleared it and a plain rescan did not. And an editor whose last scan wrote the class cache shorter than the file holds a list behind the files and writes it on every scan, so on that editor the rescan loads nothing and staleAnalysis says editor_launch restart instead. What follows differs: for a stale analysed type, editor_rescan with reloadScript recompiles the held copy and editor_launch restart is the last resort that costs a window; for a class missing from the cache, project_import refresh_classes rewrites the cache from disk at the cost of a short headless engine, which matters beside a running bench.",
+      description: "Errors and warnings for a script, or for several, from the editor's language server, and whether each is clean. With no editor of this project open, so no language server of it to ask, a short headless engine compiles the scripts instead and the answer says checkedBy: engine rather than language server: every error that stops a script compiling, up to its first syntax error, with its line and no column (a method or property another class lacks is not one, since GDScript checks a method only on self and a property only named bare: the object may be a subclass that has it, so it fails at run time instead), dependenciesWithErrors naming the other scripts that failed while it loaded, typesMissingFromTheClassCache naming a class the project declares that the engine could not resolve because the class cache lacks it, with staleAnalysis saying what rewrites the cache, and the warnings at the levels the project sets, which a second engine reports by raising each warning set to warn as an error for that run only, each at its line with no column, warnings being null when that engine could not answer; a script with a syntax error is checked for no warnings until it parses. Of several scripts, a language server that stops answering partway leaves the rest to the engine, and checkedBy then says language server, then engine, with checkedByLanguageServer counting the scripts it answered. Each diagnostic carries its severity (error or warning), its message, and where it is as the editor shows it: line and column counted from 1, and endLine and endColumn just past its end. Diagnostics are checked against the project's own files, and the two that the files disprove are named rather than passed on: a member the class cache's file declares, or a project class it extends does, a method, property, constant, static function or enum member, comes back under contradictedByTheFile with the script declaring it, and so does one a diagnostic names alone as an external class member, read against the class it is looked up on in the line it is on; and a class this project declares that the diagnostic could not resolve comes back under typesTheEditorHasNotLoaded, with inTheClassCache saying whether a launched game would resolve it. staleAnalysis then says what to do, and for both states it is editor_rescan first: it asks the editor already running, starts nothing, and has cleared each in every reproduction measured. Two exceptions are named when they apply. For an enum member, constant or static function of a global class the reload comes first: in the one project that has reproduced a stale enum member, editor_rescan with reloadScript on the declaring script cleared it and a plain rescan did not. And an editor whose last scan wrote the class cache shorter than the file holds a list behind the files and writes it on every scan, so on that editor the rescan loads nothing and staleAnalysis says editor_launch restart instead. What follows differs: for a stale analysed type, editor_rescan with reloadScript recompiles the held copy and editor_launch restart is the last resort that costs a window; for a class missing from the cache, project_import refresh_classes rewrites the cache from disk at the cost of a short headless engine, which matters beside a running bench.",
       parameters: {
         projectPath: PROJECT_PATH,
         scriptPath: {
@@ -17899,7 +17953,8 @@ var init_tool_definitions = __esm(() => {
       name: "editor_rescan",
       title: "Rescan the project",
       effect: "additive",
-      description: "Makes the running editor scan the project filesystem, so files written outside it are picked up. A scan or an import the editor is already running is waited out first rather than scanned over, which would start a second import over it. waitedMs is the whole call, and waitedForEditorScanMs, given only when a scan or an import was already running, the part spent waiting it out. The scan is a change-detecting walk rather than an unconditional reparse, so a file another engine has already imported reads as settled and the walk does not look inside it: its class_name then stays out of the list the editor resolves against, however many times you scan. Any class in that state is named under unseenByEditor, which is what no check on disk can see, since the declaration and the cache are both correct there and only the editor disagrees. The cure is this call on its own, with no change to the declaring script, measured against a real editor on three platforms. editor_launch restart also does it and costs a window, and project_import refresh_classes does not: it rewrites the cache and does not touch what the editor is holding. The walk also passes over a file whose .uid alone changed, so the editor keeps the old UID and every engine reading its cache warns of a duplicate; before scanning, each file whose .uid names a UID the editor does not hold for it is read again and named under uidsReread, and files on disk naming one UID between them are named under uidsDuplicatedOnDisk, which reading again cannot settle. A class the scan brings in is named under broughtIn, and every script naming it is reloaded in the editor and named under dependentsReloaded: what the editor compiled from them while it could not see the class stays compiled that way after the scan, and a script extending a new base class went on reporting \"Could not find base class\" until reloaded. One that would not reload is named under dependentsNotReloaded and the call is not ok, as it is not when the script named in reloadScript was not reloaded. A script that fails to compile is tried again once the scripts it is compiled against that the editor holds behind their files are reloaded, which are named under reloadedFirst. An editor importing answers nothing until the import is over, and a hidden one imports on the thread that answers, so a large addon install can leave the rescan itself unanswered: that is waited for as any busy editor is, within timeoutMs, and when the wait runs out first the answer is stillWorking. The classes the editor could not see before that scan are then noted in the project, and the next editor_rescan of the same editor, from any server, names them under broughtIn and reloads what names them, which it could not otherwise know to do, since by then the editor sees them. A scan writes .godot/global_script_class_cache.cfg from the list the editor is holding, so a class the editor cannot resolve goes out of that file with it. That is not a reason to refuse the scan, because on a class the editor has merely not walked yet the scan is the cure; what the answer does instead is name the loss under cacheLost and rebuild the cache from the files, naming what came back under cacheRestored, so no fresh engine, CI run or clone inherits the short file. An editor that lost classes is still holding the short list, so the note says to restart it before scanning again. The other direction is guarded the same way: a class the editor still holds for a script that was renamed or deleted comes back into the cache at a path that is not there, and the next engine to read it fails on \"Could not parse global class\" in whichever correct script shares the bare name, so the cache is rebuilt without it and the answer names it under cacheDropped; the editor goes on holding it until it is restarted, and every scan until then ends in that rebuild. A script or shader written outside the editor has no .uid sidecar until something imports it, and the scan writes one beside it, which a project that commits sidecars needs before the commit. Needs the editor connected.",
+      description: "Makes the running editor scan the project filesystem, so files written outside it are picked up. A scan or an import the editor is already running is waited out first rather than scanned over, which would start a second import over it. The scan is a change-detecting walk rather than an unconditional reparse, so a file another engine has already imported reads as settled and the walk does not look inside it: its class_name then stays out of the list the editor resolves against, however many times you scan. Any class in that state is named under unseenByEditor, which is what no check on disk can see, since the declaration and the cache are both correct there and only the editor disagrees. The cure is this call on its own, with no change to the declaring script, measured against a real editor on three platforms. editor_launch restart also does it and costs a window, and project_import refresh_classes does not: it rewrites the cache and does not touch what the editor is holding. The walk also passes over a file whose .uid alone changed, so the editor keeps the old UID and every engine reading its cache warns of a duplicate; before scanning, each file whose .uid names a UID the editor does not hold for it is read again and named under uidsReread, and files on disk naming one UID between them are named under uidsDuplicatedOnDisk, which reading again cannot settle. A class the scan brings in is named under broughtIn, and every script naming it is reloaded in the editor and named under dependentsReloaded: what the editor compiled from them while it could not see the class stays compiled that way after the scan, and a script extending a new base class went on reporting \"Could not find base class\" until reloaded. One that would not reload is named under dependentsNotReloaded and the call is not ok, as it is not when the script named in reloadScript was not reloaded. A script that fails to compile is tried again once the scripts it is compiled against that the editor holds behind their files are reloaded, which are named under reloadedFirst. An editor importing answers nothing until the import is over, and a hidden one imports on the thread that answers, so a large addon install can leave the rescan itself unanswered: that is waited for as any busy editor is, within timeoutMs, and when the wait runs out first the answer is stillWorking. The classes the editor could not see before that scan are then noted in the project, and the next editor_rescan of the same editor, from any server, names them under broughtIn and reloads what names them, which it could not otherwise know to do, since by then the editor sees them. A scan writes .godot/global_script_class_cache.cfg from the list the editor is holding, so a class the editor cannot resolve goes out of that file with it. That is not a reason to refuse the scan, because on a class the editor has merely not walked yet the scan is the cure; what the answer does instead is name the loss under cacheLost and rebuild the cache from the files, naming what came back under cacheRestored, so no fresh engine, CI run or clone inherits the short file. An editor that lost classes is still holding the short list, so the note says to restart it before scanning again. The other direction is guarded the same way: a class the editor still holds for a script that was renamed or deleted comes back into the cache at a path that is not there, and the next engine to read it fails on \"Could not parse global class\" in whichever correct script shares the bare name, so the cache is rebuilt without it and the answer names it under cacheDropped; the editor goes on holding it until it is restarted, and every scan until then ends in that rebuild. A script or shader written outside the editor has no .uid sidecar until something imports it, and the scan writes one beside it, which a project that commits sidecars needs before the commit. Needs the editor connected.",
+      answer: "waitedMs is the whole call, and waitedForEditorScanMs, given only when a scan or an import was already running, the part spent waiting it out. waitedForEditorAnswerMs, given when an idle editor took a second or more to say so, is how long that took: such an editor is busy on the thread that answers with an earlier request rather than scanning, so the time is added to timeoutMs rather than taken from it, and the note says so. stillWorking is true when a scan was still running at the end of the wait; the scan the call started is looked at once even when the wait has run out, so stillWorking is never said of a scan nothing looked at.",
       parameters: {
         projectPath: PROJECT_PATH,
         timeoutMs: {
@@ -18557,7 +18612,7 @@ var init_tool_definitions = __esm(() => {
     {
       name: "debug_state",
       title: "Debugger state",
-      description: "Where the debugged game is stopped: the stack trace, what is in scope at a frame with the values, or the debugger's console output so far, its last thousand lines, with any earlier ones counted under notShown. For a game this server started the output is what the game printed; the errors and warnings it reported, with where each happened, are in editor_output. For a game this server started, its keeper's debugger answers: each frame names its script as the project spells it under script and on this machine under path, and held says which thread stopped and why. For a game the editor plays, the editor's debug adapter answers. 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. A function that awaited is resumed with no caller below it, since the call that started it returned at the await, so its frame is the only one. The variables give an object as its class and instance id only, and evaluate reads into it: an expression worked out by the game at a frame, with the frame's locals, the globals and every global class in scope and the frame's instance as self, such as wave.spawned or wave.spawned.size(). The game runs what the expression calls, so a call that changes something changes the game. A frame with no instance, a static function's called on its class, is refused, since the engine lets the game go on rather than evaluate there; the frame below it has one. The compiler's own locals, named with @ such as a for loop's @counter_pos, are left out.",
+      description: "Where the debugged game is stopped: the stack trace, what is in scope at a frame with the values, or the debugger's console output so far, its last thousand lines, with any earlier ones counted under notShown. For a game this server started the output is what the game printed; the errors and warnings it reported, with where each happened, are in editor_output, which also has what it printed once it has ended, as its debugger ends with it. For a game this server started, its keeper's debugger answers: each frame names its script as the project spells it under script and on this machine under path, and held says which thread stopped and why. For a game the editor plays, the editor's debug adapter answers. 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. A function that awaited is resumed with no caller below it, since the call that started it returned at the await, so its frame is the only one. The variables give an object as its class and instance id only, and evaluate reads into it: an expression worked out by the game at a frame, with the frame's locals, the globals and every global class in scope and the frame's instance as self, such as wave.spawned or wave.spawned.size(). The game runs what the expression calls, so a call that changes something changes the game. A frame with no instance, a static function's called on its class, is refused, since the engine lets the game go on rather than evaluate there; the frame below it has one. The compiler's own locals, named with @ such as a for loop's @counter_pos, are left out.",
       parameters: {
         frameId: {
           type: "number",
@@ -18698,9 +18753,9 @@ function whatItCanChange(tool) {
   if (destroying.length === 0) {
     return "Adds or starts things, and overwrites and removes nothing itself.";
   }
-  return `Can overwrite, remove or end what is there, through ${listed2(destroying)}.`;
+  return `Can overwrite, remove or end what is there, through ${listed3(destroying)}.`;
 }
-function listed2(items) {
+function listed3(items) {
   const last = items.at(-1) ?? "";
   return items.length === 1 ? last : `${items.slice(0, -1).join(", ")} and ${last}`;
 }
@@ -18758,7 +18813,7 @@ var init_tool_reference = __esm(() => {
 });
 
 // src/suite-plan.ts
-import { existsSync as existsSync22, mkdirSync as mkdirSync9, readFileSync as readFileSync20 } from "node:fs";
+import { existsSync as existsSync22, mkdirSync as mkdirSync9, readFileSync as readFileSync21 } from "node:fs";
 import { dirname as dirname11, join as join25, posix as posix3 } from "node:path";
 function within(path, folder) {
   return path === folder || path.startsWith(`${folder}/`);
@@ -18775,7 +18830,7 @@ class ProjectScripts {
     this.projectPath = projectPath;
     let settings = {};
     try {
-      settings = parseProjectGodot(readFileSync20(join25(projectPath, "project.godot"), "utf8"))["gdharness"] ?? {};
+      settings = parseProjectGodot(readFileSync21(join25(projectPath, "project.godot"), "utf8"))["gdharness"] ?? {};
     } catch {}
     const [section, key] = [NOT_SEARCHED_SETTING, GUESS_WINDOW_SETTING].map((setting) => setting.slice("gdharness/".length));
     const listed = settings[section ?? ""];
@@ -18890,7 +18945,7 @@ class ProjectScripts {
 }
 function readTimes(file) {
   try {
-    const parsed = JSON.parse(readFileSync20(file, "utf8"));
+    const parsed = JSON.parse(readFileSync21(file, "utf8"));
     return typeof parsed === "object" && parsed !== null ? parsed : {};
   } catch {
     return {};
@@ -19173,7 +19228,7 @@ function viewportOf(projectPath) {
   if (!existsSync22(file)) {
     return null;
   }
-  const text = readFileSync20(file, "utf8");
+  const text = readFileSync21(file, "utf8");
   const width = /^window\/size\/viewport_width\s*=\s*(\d+)/m.exec(text)?.[1];
   const height = /^window\/size\/viewport_height\s*=\s*(\d+)/m.exec(text)?.[1];
   return width === undefined || height === undefined ? null : { width: Number(width), height: Number(height) };
@@ -40792,13 +40847,13 @@ var init_stdio = __esm(() => {
 });
 
 // src/autoload-failure.ts
-import { existsSync as existsSync24, readFileSync as readFileSync23 } from "node:fs";
+import { existsSync as existsSync24, readFileSync as readFileSync24 } from "node:fs";
 import { join as join28 } from "node:path";
 function scriptsAutoloaded(projectPath) {
   const scripts = new Map;
   let settings;
   try {
-    settings = parseProjectGodot(readFileSync23(join28(projectPath, "project.godot"), "utf8"));
+    settings = parseProjectGodot(readFileSync24(join28(projectPath, "project.godot"), "utf8"));
   } catch {
     return scripts;
   }
@@ -40812,7 +40867,7 @@ function scriptsAutoloaded(projectPath) {
       continue;
     }
     try {
-      for (const named of readFileSync23(scene, "utf8").matchAll(/^\[ext_resource\b[^\]]*\btype="Script"[^\]]*\bpath="(res:\/\/[^"]+)"/gm)) {
+      for (const named of readFileSync24(scene, "utf8").matchAll(/^\[ext_resource\b[^\]]*\btype="Script"[^\]]*\bpath="(res:\/\/[^"]+)"/gm)) {
         scripts.set(named[1] ?? "", name);
       }
     } catch {}
@@ -40831,7 +40886,7 @@ var init_autoload_failure = __esm(() => {
 });
 
 // src/runtime-client.ts
-import { existsSync as existsSync25, readdirSync as readdirSync15, readFileSync as readFileSync24, statSync as statSync15, unlinkSync as unlinkSync3 } from "node:fs";
+import { existsSync as existsSync25, readdirSync as readdirSync15, readFileSync as readFileSync25, statSync as statSync15, unlinkSync as unlinkSync3 } from "node:fs";
 import { createConnection as createConnection2 } from "node:net";
 import { tmpdir as tmpdir5 } from "node:os";
 import { dirname as dirname14, join as join29, resolve as resolve11 } from "node:path";
@@ -40886,7 +40941,7 @@ function reportAlreadyInTranscript(transcript, report) {
 function parseAnnouncement(file, pid) {
   let fields;
   try {
-    fields = asParams(JSON.parse(readFileSync24(file, "utf8")));
+    fields = asParams(JSON.parse(readFileSync25(file, "utf8")));
   } catch {
     return { kind: "rubbish" };
   }
@@ -40958,7 +41013,7 @@ function discoverRuntimes(directories = runtimeDirectories()) {
 function wentAway(file, pid) {
   let project = "";
   try {
-    const fields = asParams(JSON.parse(readFileSync24(file, "utf8")));
+    const fields = asParams(JSON.parse(readFileSync25(file, "utf8")));
     project = readString(readParams(fields, "project") ?? {}, "path") ?? "";
   } catch {
     return;
@@ -41473,14 +41528,14 @@ var init_runtime_client = __esm(() => {
 });
 
 // src/boot-note.ts
-import { mkdirSync as mkdirSync11, readFileSync as readFileSync25, writeFileSync as writeFileSync13 } from "node:fs";
+import { mkdirSync as mkdirSync11, readFileSync as readFileSync26, writeFileSync as writeFileSync13 } from "node:fs";
 import { dirname as dirname15, join as join30 } from "node:path";
 function bootNotePath(projectPath) {
   return join30(projectPath, ".godot", "gdharness-boot.json");
 }
 function readScenes(projectPath) {
   try {
-    return asParams(asParams(JSON.parse(readFileSync25(bootNotePath(projectPath), "utf8")))["scenes"]);
+    return asParams(asParams(JSON.parse(readFileSync26(bootNotePath(projectPath), "utf8")))["scenes"]);
   } catch {
     return {};
   }
@@ -41522,7 +41577,7 @@ var init_boot_note = __esm(() => {
 });
 
 // src/breakpoint-note.ts
-import { mkdirSync as mkdirSync12, readFileSync as readFileSync26, rmSync as rmSync13, writeFileSync as writeFileSync14 } from "node:fs";
+import { mkdirSync as mkdirSync12, readFileSync as readFileSync27, rmSync as rmSync13, writeFileSync as writeFileSync14 } from "node:fs";
 import { dirname as dirname16, isAbsolute as isAbsolute7, join as join31, relative as relative6 } from "node:path";
 function breakpointNotePath(projectPath) {
   return join31(projectPath, ".godot", "gdharness-breakpoints.json");
@@ -41551,7 +41606,7 @@ function writeBreakpointNote(projectPath, held) {
 }
 function readBreakpointNote(projectPath) {
   try {
-    const parsed = JSON.parse(readFileSync26(breakpointNotePath(projectPath), "utf8"));
+    const parsed = JSON.parse(readFileSync27(breakpointNotePath(projectPath), "utf8"));
     if (typeof parsed !== "object" || parsed === null || !Array.isArray(parsed.breakpoints)) {
       return [];
     }
@@ -41584,14 +41639,14 @@ var init_breakpoint_note = __esm(() => {
 });
 
 // src/class-note.ts
-import { mkdirSync as mkdirSync13, readFileSync as readFileSync27 } from "node:fs";
+import { mkdirSync as mkdirSync13, readFileSync as readFileSync28 } from "node:fs";
 import { dirname as dirname17, join as join32 } from "node:path";
 function classNotePath(projectPath) {
   return join32(projectPath, ".godot", "gdharness-classes.json");
 }
 function readClassNote(projectPath) {
   try {
-    const fields = asParams(JSON.parse(readFileSync27(classNotePath(projectPath), "utf8")));
+    const fields = asParams(JSON.parse(readFileSync28(classNotePath(projectPath), "utf8")));
     const rebuiltWith = readArray(fields, "rebuiltWith");
     if (rebuiltWith === undefined || !rebuiltWith.every((name) => typeof name === "string")) {
       return null;
@@ -41633,7 +41688,7 @@ var init_class_note = __esm(() => {
 });
 
 // src/config-pin.ts
-import { existsSync as existsSync26, readFileSync as readFileSync28 } from "node:fs";
+import { existsSync as existsSync26, readFileSync as readFileSync29 } from "node:fs";
 import { join as join33 } from "node:path";
 function versionsNamedInConfig(projectPath) {
   const config = join33(projectPath, ".mcp.json");
@@ -41642,7 +41697,7 @@ function versionsNamedInConfig(projectPath) {
   }
   let text;
   try {
-    text = readFileSync28(config, "utf8");
+    text = readFileSync29(config, "utf8");
     JSON.parse(text);
   } catch {
     return [];
@@ -41663,7 +41718,7 @@ var init_config_pin = __esm(() => {
 });
 
 // src/cut-test-run.ts
-import { existsSync as existsSync27, mkdirSync as mkdirSync14, readFileSync as readFileSync29, rmSync as rmSync14, writeFileSync as writeFileSync15 } from "node:fs";
+import { existsSync as existsSync27, mkdirSync as mkdirSync14, readFileSync as readFileSync30, rmSync as rmSync14, writeFileSync as writeFileSync15 } from "node:fs";
 import { dirname as dirname18, join as join34 } from "node:path";
 function keptAt(projectPath) {
   return join34(projectPath, ".godot", "gdharness-reports", "cut-run.json");
@@ -41682,7 +41737,7 @@ function takeCutTestRun(projectPath) {
     return null;
   }
   try {
-    const run = JSON.parse(readFileSync29(path, "utf8"));
+    const run = JSON.parse(readFileSync30(path, "utf8"));
     rmSync14(path, { force: true });
     return typeof run.cutAt === "string" && Array.isArray(run.paths) && run.paths.every((path) => typeof path === "string") ? run : null;
   } catch {
@@ -42418,7 +42473,7 @@ import {
   existsSync as existsSync28,
   mkdirSync as mkdirSync15,
   openSync as openSync4,
-  readFileSync as readFileSync30,
+  readFileSync as readFileSync31,
   readSync as readSync2,
   rmSync as rmSync15,
   statSync as statSync16,
@@ -42433,7 +42488,7 @@ function editorLogNotePath(projectPath) {
 }
 function readEditorLogNote(projectPath) {
   try {
-    const fields = asParams(JSON.parse(readFileSync30(editorLogNotePath(projectPath), "utf8")));
+    const fields = asParams(JSON.parse(readFileSync31(editorLogNotePath(projectPath), "utf8")));
     const pid = readNumber(fields, "pid");
     const startedAt = readString(fields, "startedAt");
     const processStartedAt = readNumber(fields, "processStartedAt");
@@ -42537,7 +42592,7 @@ function foldProgress(text) {
 function theFirstOf(path) {
   const whole = statSync16(path).size;
   if (whole <= MOST_CONSOLE_BYTES) {
-    return { text: readFileSync30(path, "utf8") };
+    return { text: readFileSync31(path, "utf8") };
   }
   const handle = openSync4(path, "r");
   try {
@@ -42698,7 +42753,7 @@ var init_editor_log = __esm(() => {
 });
 
 // src/rename.ts
-import { existsSync as existsSync29, mkdirSync as mkdirSync16, readFileSync as readFileSync31, renameSync as renameSync3, unlinkSync as unlinkSync4, writeFileSync as writeFileSync17 } from "node:fs";
+import { existsSync as existsSync29, mkdirSync as mkdirSync16, readFileSync as readFileSync32, renameSync as renameSync3, unlinkSync as unlinkSync4, writeFileSync as writeFileSync17 } from "node:fs";
 import { dirname as dirname20, posix as posix4 } from "node:path";
 
 class Script {
@@ -43403,7 +43458,7 @@ function rewritesOf(plan, texts, move) {
 }
 function applyRewrites(rewrites) {
   for (const rewrite of rewrites) {
-    const now = readFileSync31(rewrite.absolute, "utf8");
+    const now = readFileSync32(rewrite.absolute, "utf8");
     if (now !== rewrite.before) {
       throw new Error(`${rewrite.path} changed on disk while the rename was being worked out; nothing was written`);
     }
@@ -43493,18 +43548,18 @@ function onDiskSpelling(path) {
   }
 }
 function usedAsIdentifier(scripts, name, most) {
-  const found = [];
+  const found = new Set;
   for (const script of scripts.values()) {
     for (const occurrence of script.occurrences(name)) {
       if (occurrence.kind === "code" && !occurrence.afterDot) {
-        found.push(`${script.path}:${script.lines.positionOf(occurrence.offset).line + 1}`);
-        if (found.length >= most) {
-          return found;
+        found.add(`${script.path}:${script.lines.positionOf(occurrence.offset).line + 1}`);
+        if (found.size >= most) {
+          return [...found];
         }
       }
     }
   }
-  return found;
+  return [...found];
 }
 function autoloadNames(texts) {
   const settings = texts.find((file) => file.path === "res://project.godot");
@@ -43568,7 +43623,7 @@ async function renameSymbol(request, services) {
       conflicts.push(`${newName} is already an autoload in project.godot`);
     }
     for (const place of usedAsIdentifier(scripts, newName, 10)) {
-      conflicts.push(`${newName} is already an identifier at ${place}`);
+      conflicts.push(`${newName} is already used in code at ${place}`);
     }
     const taken = (await services.namesTaken([newName], null))[newName];
     if (taken !== undefined && taken.as.length > 0) {
@@ -43971,7 +44026,7 @@ import {
   existsSync as existsSync31,
   mkdirSync as mkdirSync18,
   readdirSync as readdirSync17,
-  readFileSync as readFileSync32,
+  readFileSync as readFileSync33,
   renameSync as renameSync4,
   statSync as statSync17,
   writeFileSync as writeFileSync19
@@ -44131,7 +44186,7 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
   plan = mentionIgnored(plan, ignoredTexts(projectPath), null, [from]);
   const binaries = [];
   for (const path of binaryResources(projectPath)) {
-    const bytes = readFileSync32(join37(projectPath, path.slice("res://".length)));
+    const bytes = readFileSync33(join37(projectPath, path.slice("res://".length)));
     const names = [...moves.keys()].find((moving) => bytes.includes(moving));
     if (names !== undefined) {
       binaries.push({
@@ -44192,7 +44247,7 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
 }
 function applyFileMove(outcome) {
   for (const rewrite of outcome.inPlace) {
-    if (readFileSync32(rewrite.absolute, "utf8") !== rewrite.before) {
+    if (readFileSync33(rewrite.absolute, "utf8") !== rewrite.before) {
       throw new Error(`${rewrite.path} changed on disk while the move was being worked out; nothing was written`);
     }
   }
@@ -44200,7 +44255,7 @@ function applyFileMove(outcome) {
     if (!existsSync31(file.absoluteFrom)) {
       throw new Error(`${file.from} is gone from disk; nothing was written`);
     }
-    if (file.text !== null && readFileSync32(file.absoluteFrom, "utf8") !== file.text.before) {
+    if (file.text !== null && readFileSync33(file.absoluteFrom, "utf8") !== file.text.before) {
       throw new Error(`${file.from} changed on disk while the move was being worked out; nothing was written`);
     }
     if (existsSync31(file.absoluteTo) && !sameFile(file.absoluteFrom, file.absoluteTo)) {
@@ -48314,7 +48369,7 @@ var init_prompts = __esm(() => {
 });
 
 // src/restart-note.ts
-import { mkdirSync as mkdirSync20, readFileSync as readFileSync33, rmSync as rmSync17, writeFileSync as writeFileSync20 } from "node:fs";
+import { mkdirSync as mkdirSync20, readFileSync as readFileSync34, rmSync as rmSync17, writeFileSync as writeFileSync20 } from "node:fs";
 import { dirname as dirname24, join as join39 } from "node:path";
 function restartNotePath(projectPath) {
   return join39(projectPath, ".godot", "gdharness-restart.json");
@@ -48331,7 +48386,7 @@ function noteRestartBegun(note) {
 }
 function restartOwed(projectPath) {
   try {
-    const parsed = JSON.parse(readFileSync33(restartNotePath(projectPath), "utf8"));
+    const parsed = JSON.parse(readFileSync34(restartNotePath(projectPath), "utf8"));
     if (typeof parsed !== "object" || parsed === null) {
       return null;
     }
@@ -48357,7 +48412,7 @@ var init_restart_note = __esm(() => {
 
 // src/run-record.ts
 import { createHash as createHash7 } from "node:crypto";
-import { mkdirSync as mkdirSync21, openSync as openSync5, readdirSync as readdirSync18, readFileSync as readFileSync34, rmSync as rmSync18, statSync as statSync19 } from "node:fs";
+import { mkdirSync as mkdirSync21, openSync as openSync5, readdirSync as readdirSync18, readFileSync as readFileSync35, rmSync as rmSync18, statSync as statSync19 } from "node:fs";
 import { basename as basename11, join as join40, resolve as resolve13 } from "node:path";
 function runsDirectory() {
   return join40(runtimeDirectory(), "runs");
@@ -48381,7 +48436,7 @@ function writeLatestRun(servedBy, latest) {
 }
 function readLatestRun(servedBy, directory = runtimeDirectory()) {
   try {
-    const fields = JSON.parse(readFileSync34(latestRunPath(servedBy, directory), "utf8"));
+    const fields = JSON.parse(readFileSync35(latestRunPath(servedBy, directory), "utf8"));
     if (typeof fields !== "object" || fields === null) {
       return null;
     }
@@ -48430,7 +48485,7 @@ function readEditorRunNote(projectPath) {
 function editorNoteAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync34(path, "utf8"));
+    parsed = JSON.parse(readFileSync35(path, "utf8"));
   } catch {
     return null;
   }
@@ -48480,7 +48535,7 @@ function everyRunRecord() {
 function recordAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync34(path, "utf8"));
+    parsed = JSON.parse(readFileSync35(path, "utf8"));
   } catch {
     return null;
   }
@@ -48561,7 +48616,7 @@ async function runningAs(pid) {
     const began = await startedAt(pid, null);
     const when = began === null ? {} : { startedAt: began };
     if (process.platform === "linux") {
-      const raw = readFileSync34(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
+      const raw = readFileSync35(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
       return raw === "" ? null : { kind: "commandLine", text: raw, ...when };
     }
     const args = (await runHidden("ps", ["-p", String(pid), "-o", "args="], { timeout: 15000 })).stdout.trim();
@@ -48757,10 +48812,10 @@ var init_run_record = __esm(() => {
 });
 
 // src/script-profile.ts
-import { readFileSync as readFileSync35 } from "node:fs";
+import { readFileSync as readFileSync36 } from "node:fs";
 function readProfileFile(path) {
   try {
-    const parsed = JSON.parse(readFileSync35(path, "utf8"));
+    const parsed = JSON.parse(readFileSync36(path, "utf8"));
     return typeof parsed === "object" && typeof parsed.connected === "boolean" ? parsed : null;
   } catch {
     return null;
@@ -48818,7 +48873,7 @@ function writeProfileMark(path, mark) {
 }
 function readProfileMark(path) {
   try {
-    const parsed = JSON.parse(readFileSync35(path, "utf8"));
+    const parsed = JSON.parse(readFileSync36(path, "utf8"));
     return typeof parsed === "object" && typeof parsed.totals === "object" ? parsed : null;
   } catch {
     return null;
@@ -49150,7 +49205,7 @@ import {
   mkdirSync as mkdirSync23,
   openSync as openSync6,
   readdirSync as readdirSync19,
-  readFileSync as readFileSync36,
+  readFileSync as readFileSync37,
   readSync as readSync3,
   realpathSync as realpathSync5,
   rmdirSync as rmdirSync2,
@@ -49171,9 +49226,9 @@ function greetingWaitMs() {
   return waitFromEnv("GDHARNESS_GREETING_WAIT_MS", 1e4);
 }
 function pictureToSend(pngPath, jpegPath) {
-  const png = readFileSync36(pngPath);
+  const png = readFileSync37(pngPath);
   const beside = pngPath.replace(/\.png$/, ".jpg");
-  const jpeg = jpegPath !== undefined && normalize2(jpegPath) === normalize2(beside) && existsSync34(beside) ? readFileSync36(beside) : null;
+  const jpeg = jpegPath !== undefined && normalize2(jpegPath) === normalize2(beside) && existsSync34(beside) ? readFileSync37(beside) : null;
   const sent = jpeg !== null && jpeg.length < png.length ? jpeg : png;
   return {
     data: sent.toString("base64"),
@@ -49652,7 +49707,7 @@ function endedToStartThis(ended) {
   return ` ${which} was ended to start this one; its output is no longer what editor_output answers about.`;
 }
 function lineNothingStopsOn(absolutePath, relativePath, line) {
-  const text = readFileSync36(absolutePath, "utf8");
+  const text = readFileSync37(absolutePath, "utf8");
   const lines = text === "" ? 0 : text.split(`
 `).length - (text.endsWith(`
 `) ? 1 : 0);
@@ -49863,7 +49918,7 @@ function notRunNote(notRun, failFast) {
 function presetsIn(projectPath) {
   let text;
   try {
-    text = readFileSync36(join43(projectPath, "export_presets.cfg"), "utf8");
+    text = readFileSync37(join43(projectPath, "export_presets.cfg"), "utf8");
   } catch {
     return null;
   }
@@ -50013,7 +50068,7 @@ function rewriteBusNamed(projectPath, from, to) {
   const rewritten = [];
   for (const file of projectFiles(projectPath, [".tscn", ".tres"])) {
     const absolute = join43(projectPath, file);
-    const lines = readFileSync36(absolute, "utf8").split(`
+    const lines = readFileSync37(absolute, "utf8").split(`
 `);
     const at = [];
     const after = lines.map((line, index) => {
@@ -50032,7 +50087,7 @@ function rewriteBusNamed(projectPath, from, to) {
   }
   const namedInScripts = [];
   for (const file of projectFiles(projectPath, [".gd"])) {
-    readFileSync36(join43(projectPath, file), "utf8").split(`
+    readFileSync37(join43(projectPath, file), "utf8").split(`
 `).forEach((line, index) => {
       if (line.includes(`"${from}"`)) {
         namedInScripts.push({ file: `res://${file}`, line: index + 1, text: line.trim() });
@@ -50317,7 +50372,7 @@ function profileFrameFunctions(projectPath) {
   let projectGodot = null;
   if (projectPath !== null) {
     try {
-      projectGodot = readFileSync36(join43(projectPath, "project.godot"), "utf8");
+      projectGodot = readFileSync37(join43(projectPath, "project.godot"), "utf8");
     } catch {}
   }
   return frameFunctionsFor(queuedMessagesOf(projectGodot));
@@ -50341,7 +50396,7 @@ function projectSourceOf(projectPath) {
       let source = null;
       if (inside.ok) {
         try {
-          source = readFileSync36(inside.absolutePath, "utf8");
+          source = readFileSync37(inside.absolutePath, "utf8");
         } catch {}
       }
       read.set(script, source);
@@ -50513,7 +50568,7 @@ function foldedEntriesAnswer(log, floor = "warning") {
 }
 function gdUnitFailsOnScriptErrors(projectPath) {
   try {
-    return settingKeys(readFileSync36(join43(projectPath, "project.godot"), "utf8")).get("gdunit4/report/godot/script_error") !== false;
+    return settingKeys(readFileSync37(join43(projectPath, "project.godot"), "utf8")).get("gdunit4/report/godot/script_error") !== false;
   } catch {
     return true;
   }
@@ -50645,7 +50700,7 @@ function engineChecked(why) {
   return {
     checkedBy: "engine",
     languageServer: why,
-    note: "No editor of this project is open to ask, so a headless engine compiled the scripts the way loading them does. It reports every error that stops a script compiling, at its line and without a column, but stops reading a script at its first syntax error, so an error after one shows once it is fixed. A second engine reports the warnings, at the levels the project sets, by raising each warning set to warn as an error for that run only, since the engine tells a warning as one only to an editor; each comes at its line without a column, and warnings is null when that engine could not answer. editor_launch with hidden: true opens this project's editor without a window, and its language server reports both with their columns."
+    note: "No editor of this project is open to ask, so a headless engine compiled the scripts the way loading them does. It reports every error that stops a script compiling, at its line and without a column, but stops reading a script at its first syntax error, so an error after one shows once it is fixed, and so do its warnings, since a script that does not parse is not checked for any. A second engine reports the warnings, at the levels the project sets, by raising each warning set to warn as an error for that run only, since the engine tells a warning as one only to an editor; each comes at its line without a column, and warnings is null when that engine could not answer. editor_launch with hidden: true opens this project's editor without a window, and its language server reports both with their columns."
   };
 }
 function asWarning(raised) {
@@ -50660,11 +50715,11 @@ function isDirectory(path) {
   }
 }
 function mainSceneOf(projectFile) {
-  const scene = parseProjectGodot(readFileSync36(projectFile, "utf8"))["application"]?.["run/main_scene"];
+  const scene = parseProjectGodot(readFileSync37(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "" ? scene : null;
 }
 function editorPlaysHeadless(projectFile) {
-  const runArgs = parseProjectGodot(readFileSync36(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
+  const runArgs = parseProjectGodot(readFileSync37(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
   return typeof runArgs === "string" && /(?:^|\s)--headless(?:\s|$)/.test(runArgs);
 }
 function ownArguments(params) {
@@ -51117,12 +51172,16 @@ class GodotServer {
       };
       const call = this.callsTaken++;
       this.inFlight.set(call, { tool: spec.name, op: checked.op ?? "", startedAt: Date.now() });
+      const slotWaits = { ms: 0, said: undefined };
       try {
         const answer = await withCallSignal(ctx.mcpReq.signal, () => this.answered(spec.name, checked.op ?? "", args), progress, {
           everyMs: CALL_HEARTBEAT_MS,
           said: (elapsedMs) => stillGoingSaid(spec.name, checked.op, elapsedMs)
+        }, slotWaits);
+        const waited = slotWaits.said === undefined || slotWaits.ms < 1000 ? answer : this.saying(answer, {
+          engine_slot_wait: { waitedMs: slotWaits.ms, note: slotWaits.said(slotWaits.ms) }
         });
-        return this.withinTheClientsLimit(spec.name, this.withFeedbackNotice(this.withUpdateNotice(answer)));
+        return this.withinTheClientsLimit(spec.name, this.withFeedbackNotice(this.withUpdateNotice(waited)));
       } finally {
         this.inFlight.delete(call);
       }
@@ -51801,6 +51860,10 @@ class GodotServer {
         if (kept !== null) {
           return await this.askTheKeptGame(kept.keeper, keptGameRequest(tool, op, args), kept.projectPath ?? "");
         }
+        const last = this.activeProcess;
+        if (tool === "debug_state" && op === "output" && last !== null && !last.throughEditor && last.keeper !== undefined) {
+          return this.createErrorResponse("The game this server started has ended, and its debugger, which held its console output, ended with it.", ["editor_output reads what the game printed, with the errors and warnings it reported"]);
+        }
         if (tool === "debug_state" && op === "output") {
           return await this.handleDAP("dap_get_output", args);
         }
@@ -52579,7 +52642,7 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const application = parseProjectGodot(readFileSync36(project.value.file, "utf8"))["application"] ?? {};
+    const application = parseProjectGodot(readFileSync37(project.value.file, "utf8"))["application"] ?? {};
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
@@ -53130,13 +53193,13 @@ ${platform}`;
     const reportsDir = join43(project.value.path, ".godot", ...ours.split("/"));
     let report = null;
     let reportProblem = null;
-    const casePrinted = withNestedErrors(readRun(existsSync34(engineLog) ? readFileSync36(engineLog, "utf8") : ""), run.log.all);
+    const casePrinted = withNestedErrors(readRun(existsSync34(engineLog) ? readFileSync37(engineLog, "utf8") : ""), run.log.all);
     const declaredErrors = readExpected(expectedFile);
     try {
       const written = existsSync34(reportsDir) && notCompiled === null ? readdirSync19(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(readFileSync36(join43(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync37(join43(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
@@ -53674,7 +53737,7 @@ ${error.text}`;
         return null;
       }
       try {
-        return readFileSync36(contained.absolutePath, "utf8");
+        return readFileSync37(contained.absolutePath, "utf8");
       } catch {
         return null;
       }
@@ -53768,7 +53831,7 @@ ${error.text}`;
       return null;
     }
     try {
-      return readFileSync36(contained.absolutePath, "utf8");
+      return readFileSync37(contained.absolutePath, "utf8");
     } catch {
       return null;
     }
@@ -54287,7 +54350,7 @@ ${error.text}`;
       return null;
     }
     try {
-      return settingKeys(readFileSync36(join43(projectPath, "project.godot"), "utf8"));
+      return settingKeys(readFileSync37(join43(projectPath, "project.godot"), "utf8"));
     } catch {
       return null;
     }
@@ -55112,7 +55175,7 @@ ${error.text}`;
       return 0;
     }
     try {
-      return reportAlreadyInTranscript(readFileSync36(game.transcript), readFileSync36(report));
+      return reportAlreadyInTranscript(readFileSync37(game.transcript), readFileSync37(report));
     } catch (error) {
       this.logDebug(`Could not compare a picked-up run's report with its transcript: ${errorMessage(error)}`);
       return 0;
@@ -56496,6 +56559,8 @@ ${error.text}`;
     let writtenBefore = null;
     let blind = { unseen: [] };
     let waitedForEditorMs = 0;
+    let answerStalledMs = 0;
+    const deadline = () => started + timeoutMs + answerStalledMs;
     let startUnanswered = false;
     let completedBefore;
     let uidsReread = [];
@@ -56503,7 +56568,15 @@ ${error.text}`;
     for (;; ) {
       const busySince = Date.now();
       let wasBusy = false;
-      while (Date.now() - started < timeoutMs && await this.editorIsScanningOrImporting()) {
+      while (Date.now() < deadline()) {
+        const asked = Date.now();
+        if (!await this.editorIsScanningOrImporting()) {
+          const took = Date.now() - asked;
+          if (took >= SLOW_ANSWER_MS) {
+            answerStalledMs += took;
+          }
+          break;
+        }
         wasBusy = true;
         await new Promise((settle) => setTimeout(settle, 100));
       }
@@ -56528,7 +56601,7 @@ ${error.text}`;
       if (duplicated !== undefined) {
         uidsDuplicatedOnDisk = duplicated.map((group) => Array.isArray(group) ? group.map(String) : []);
       }
-      if (firstAnswer["started"] !== false || Date.now() - started >= timeoutMs) {
+      if (firstAnswer["started"] !== false || Date.now() >= deadline()) {
         break;
       }
       await new Promise((settle) => setTimeout(settle, 100));
@@ -56538,7 +56611,9 @@ ${error.text}`;
     const ghosts = blind.stillHeld ?? [];
     let busy = true;
     let idleSince = null;
-    while (Date.now() - started < timeoutMs) {
+    let looked = false;
+    while (!looked || Date.now() < deadline()) {
+      looked = true;
       await new Promise((settle) => setTimeout(settle, 100));
       let status;
       try {
@@ -56584,6 +56659,7 @@ ${error.text}`;
     let reloaded = {};
     const reloadedFirst = [];
     let builtOn;
+    let builtOnUnchecked = false;
     const reloadingSource = reloading === undefined || projectPath === "" ? null : this.sourceOfClass(projectPath, reloading);
     if (reloading !== undefined && reloadingSource !== null && isToolScript(reloadingSource)) {
       reloaded = {
@@ -56601,6 +56677,7 @@ ${error.text}`;
             answer = await reloadAsked();
           }
           builtOn = first.said;
+          builtOnUnchecked = first.unchecked === true;
         }
         const methods = readArray(answer, "methods");
         const listed = (field) => {
@@ -56627,7 +56704,8 @@ ${error.text}`;
               names: projectPath === "" ? [] : this.classesAScriptNames(projectPath, script),
               restored: answer["restored"] === true,
               restoredAs: readString(answer, "restoredAs") ?? "",
-              ...builtOn === undefined ? {} : { builtOn }
+              ...builtOn === undefined ? {} : { builtOn },
+              ...builtOnUnchecked ? { builtOnUnchecked } : {}
             })
           };
         } else {
@@ -56655,6 +56733,9 @@ ${error.text}`;
     const dependents = busy || projectPath === "" || broughtIn.length === 0 ? null : await this.reloadDependents(projectPath, broughtIn);
     const stillGone = lost.filter((name) => !restored.includes(name));
     const notes = [];
+    if (answerStalledMs > 0) {
+      notes.push(`The editor took ${(answerStalledMs / 1000).toFixed(1)} seconds to say it was idle, busy on the thread that answers with an earlier request, and that time was added to the wait rather than taken from it.`);
+    }
     if (busy) {
       notes.push(startUnanswered ? "The editor took the rescan in and did not answer it before the wait ran out, which is an editor importing: a hidden editor imports on the thread that answers, and answers nothing until it is done. It carries the scan out once it is free, so new files may not be visible yet." : "The editor was still scanning or importing when the wait ran out, so new files may not be visible yet.");
       if (unseenBefore.length > 0) {
@@ -56683,6 +56764,7 @@ ${error.text}`;
       stillWorking: busy,
       waitedMs: Date.now() - started,
       waitedForEditorScanMs: waitedForEditorMs > 0 ? waitedForEditorMs : undefined,
+      waitedForEditorAnswerMs: answerStalledMs > 0 ? answerStalledMs : undefined,
       reloadedAs: reloaded.as,
       ...reloadDifference(reloaded),
       ...args["listMembers"] === true ? {
@@ -56800,17 +56882,20 @@ ${error.text}`;
     try {
       const answer = asParams(await this.godotBridge.invokeTool("scripts_behind", { scriptPaths }));
       const behind = readArray(answer, "behind");
-      return behind === undefined ? null : { behind: behind.map(String), unsaved: (readArray(answer, "unsavedInEditor") ?? []).map(String) };
+      return behind === undefined ? { unchecked: "the editor answered without a list of them" } : { behind: behind.map(String), unsaved: (readArray(answer, "unsavedInEditor") ?? []).map(String) };
     } catch (error) {
-      this.logDebug(`The editor would not say which scripts it holds behind their files: ${errorMessage(error)}`);
-      return null;
+      return { unchecked: `the editor would not say: ${errorMessage(error)}` };
     }
   }
   async reloadWhatItIsBuiltOn(projectPath, scriptPath) {
     const against = this.scriptsCompiledAgainst(projectPath, scriptPath);
     const held = await this.scriptsHeldBehind(against);
-    if (held === null) {
-      return { reloaded: [] };
+    if ("unchecked" in held) {
+      return {
+        reloaded: [],
+        said: `Whether the editor holds the scripts it is compiled against behind their files could not be checked: ${held.unchecked}.`,
+        unchecked: true
+      };
     }
     const reloadedFor = scriptPath.startsWith("res://") ? scriptPath : `res://${scriptPath.replace(/^\/+/, "")}`;
     const reloaded = [];
@@ -57460,10 +57545,11 @@ ${error.text}`;
     const checked = await this.classesTheEditorCannotSee(args);
     const stillHeld = checked.stillHeld ?? [];
     const projectPath = typeof args["projectPath"] === "string" ? args["projectPath"] : "";
-    const listed = projectPath === "" ? null : cachedClasses(projectPath);
+    const listed = projectPath === "" || checked.unchecked !== undefined ? null : cachedClasses(projectPath);
     const held = listed === null ? null : await this.scriptsHeldBehind([...new Set(listed.values())]);
-    const behind = listed === null || held === null ? [] : [...listed].filter(([, path]) => held.behind.includes(path)).map(([className, scriptPath]) => ({ className, scriptPath }));
-    if (checked.unseen.length === 0 && stillHeld.length === 0 && checked.unchecked === undefined && behind.length === 0) {
+    const behindUnchecked = held !== null && "unchecked" in held ? held.unchecked : undefined;
+    const behind = listed === null || held === null || "unchecked" in held ? [] : [...listed].filter(([, path]) => held.behind.includes(path)).map(([className, scriptPath]) => ({ className, scriptPath }));
+    if (checked.unseen.length === 0 && stillHeld.length === 0 && checked.unchecked === undefined && behindUnchecked === undefined && behind.length === 0) {
       return answered;
     }
     const payload = asParams(JSON.parse(first.text));
@@ -57486,6 +57572,7 @@ ${error.text}`;
       stillHeldByEditor: stillHeld.length > 0 ? stillHeld : undefined,
       heldBehindInEditor: behind.length > 0 ? behind : undefined,
       classesUnchecked: checked.unchecked,
+      heldBehindUnchecked: behindUnchecked,
       note: notes.length > 0 ? notes.join(" ") : undefined
     });
   }
@@ -57495,7 +57582,7 @@ ${error.text}`;
     }
     const escaped = symbol.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const declared = new RegExp(`^\\s*(?:@\\w+(?:\\([^)]*\\))?\\s+)*class_name\\s+${escaped}\\b`, "m");
-    if (declared.test(readFileSync36(scriptPath, "utf8"))) {
+    if (declared.test(readFileSync37(scriptPath, "utf8"))) {
       return null;
     }
     const checked = await this.classesTheEditorCannotSee(args);
@@ -58006,7 +58093,7 @@ async function runGodotServer() {
   const server = new GodotServer;
   await server.run();
 }
-var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, FAILED_BUDGET = 1e6, ANSWER_BUDGET = 4000000, __dirname2, PARENT_ASKED_AFTER_MS = 5000, EDITOR_SERVERS_START_MS = 20000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, ALONGSIDE_NOTE = "Another call on this game was running while this one was: calls sent together run together and are answered as each finishes, so this answer is not from after the other. Send a call meant to come after another once that one has answered.", OWN_DEBUGGER = " Its debugger is the keeper holding it rather than the editor, so the debug_* tools answer for it all the same: breakpoints stop it, and debug_control pause breaks into it wherever it is, which the editor offers no way to do.", PLAY_STARTS_WITHIN_MS = 30000, KEEPER_ANSWER_MS = 15000, KEEPER_DEBUG_MS, EXIT_REPORTED_WITHIN_MS = 2000, SUCCESSOR_SOUGHT_WITHIN_MS = 20000, CLOSE_ASK_MS = 3000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, PROFILE_SEND_MS = 5000, MOST_GROUPS = 20, RUNTIME_LISTENING_LINE = "[gdharness] runtime listening on ", 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, STREAMS_GRACE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_SETTLED_MS = 500, REIMPORT_TIMEOUT_MS = 300000, OPS_ELSEWHERE, AUDIO_BUS_OPS, STALLED_AFTER_MS = 30000, TEST_TIMEOUT_MS = 600000, TEST_HEARTBEAT_MS = 20000, DEPENDED_FAILED = "Failed to compile depended scripts", LOOPING_AFTER = 100, WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, DESTINATION_ARGUMENTS, OUTPUT_PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/", PROFILE_FUNCTIONS = 30, PROFILER_ON_MS = 3000, PROPERTY_PLACES = "It is a property, so each place says whether it writes it (access write), which runs its set block, or reads it (access read), which runs its get block: withinCalls on a read says nothing of the set block, nor on a write of the get block unless the write is a compound one such as +=. Inside the property's own blocks its name is the value stored, which the engine reads and writes without running them, so those lines are not listed.", CALLERS_FOUND_BY_NAME = "Found by name in the project's scripts, since the engine's profiler counts calls and time per function and records nothing about who made them: a method of the same name on another class is listed too, unless one class was asked about and it is called through another class by name or through a variable declared as one. Each place carries the profile's numbers for the function it is written in.", MOST_ENGINE_ENTRIES = 200, MOST_PRINTED_LINES = 50, MOST_UNDECLARED_ERRORS = 20, ERROR_ASSERT = "GdUnitGodotErrorAssertImpl.gd", RAISED_WARNING = " (Warning treated as error.)", PARSE_ERROR2 = "Parse Error: ", EXTERNAL_MEMBER = 'Could not resolve external class member "', STATIC_LIST_HINT;
+var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, FAILED_BUDGET = 1e6, ANSWER_BUDGET = 4000000, __dirname2, PARENT_ASKED_AFTER_MS = 5000, EDITOR_SERVERS_START_MS = 20000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, ALONGSIDE_NOTE = "Another call on this game was running while this one was: calls sent together run together and are answered as each finishes, so this answer is not from after the other. Send a call meant to come after another once that one has answered.", OWN_DEBUGGER = " Its debugger is the keeper holding it rather than the editor, so the debug_* tools answer for it all the same: breakpoints stop it, and debug_control pause breaks into it wherever it is, which the editor offers no way to do.", PLAY_STARTS_WITHIN_MS = 30000, KEEPER_ANSWER_MS = 15000, KEEPER_DEBUG_MS, EXIT_REPORTED_WITHIN_MS = 2000, SUCCESSOR_SOUGHT_WITHIN_MS = 20000, CLOSE_ASK_MS = 3000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, PROFILE_SEND_MS = 5000, MOST_GROUPS = 20, RUNTIME_LISTENING_LINE = "[gdharness] runtime listening on ", 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, STREAMS_GRACE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_SETTLED_MS = 500, SLOW_ANSWER_MS = 1000, REIMPORT_TIMEOUT_MS = 300000, OPS_ELSEWHERE, AUDIO_BUS_OPS, STALLED_AFTER_MS = 30000, TEST_TIMEOUT_MS = 600000, TEST_HEARTBEAT_MS = 20000, DEPENDED_FAILED = "Failed to compile depended scripts", LOOPING_AFTER = 100, WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, DESTINATION_ARGUMENTS, OUTPUT_PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/", PROFILE_FUNCTIONS = 30, PROFILER_ON_MS = 3000, PROPERTY_PLACES = "It is a property, so each place says whether it writes it (access write), which runs its set block, or reads it (access read), which runs its get block: withinCalls on a read says nothing of the set block, nor on a write of the get block unless the write is a compound one such as +=. Inside the property's own blocks its name is the value stored, which the engine reads and writes without running them, so those lines are not listed.", CALLERS_FOUND_BY_NAME = "Found by name in the project's scripts, since the engine's profiler counts calls and time per function and records nothing about who made them: a method of the same name on another class is listed too, unless one class was asked about and it is called through another class by name or through a variable declared as one. Each place carries the profile's numbers for the function it is written in.", MOST_ENGINE_ENTRIES = 200, MOST_PRINTED_LINES = 50, MOST_UNDECLARED_ERRORS = 20, ERROR_ASSERT = "GdUnitGodotErrorAssertImpl.gd", RAISED_WARNING = " (Warning treated as error.)", PARSE_ERROR2 = "Parse Error: ", EXTERNAL_MEMBER = 'Could not resolve external class member "', STATIC_LIST_HINT;
 var init_server = __esm(() => {
   init_dist2();
   init_stdio();
@@ -58179,7 +58266,7 @@ init_alive();
 init_engine_launch();
 init_lsp_client();
 init_process_children();
-import { existsSync as existsSync17, readdirSync as readdirSync10, readFileSync as readFileSync15, unlinkSync as unlinkSync2 } from "node:fs";
+import { existsSync as existsSync17, readdirSync as readdirSync10, readFileSync as readFileSync16, unlinkSync as unlinkSync2 } from "node:fs";
 import { connect as connect2 } from "node:net";
 import { join as join20, resolve as resolve7 } from "node:path";
 var EDITOR_RECORD_PROTOCOL = 1;
@@ -58198,7 +58285,7 @@ function editorRecordsIn(projectPath) {
   for (const name of names) {
     const file = join20(directory, name);
     try {
-      const said = JSON.parse(readFileSync15(file, "utf8"));
+      const said = JSON.parse(readFileSync16(file, "utf8"));
       const { protocol, pid, lsp_port: lspPort, written_at_ms: writtenAtMs } = said;
       if (protocol === EDITOR_RECORD_PROTOCOL && typeof pid === "number" && typeof lspPort === "number" && lspPort > 0 && typeof writtenAtMs === "number") {
         records.push({ file, pid, lspPort, writtenAtMs });
@@ -58707,7 +58794,7 @@ init_engine_launch();
 init_engine_slots();
 init_setup();
 init_suite_judge();
-import { existsSync as existsSync20, mkdirSync as mkdirSync8, readFileSync as readFileSync18, rmSync as rmSync11 } from "node:fs";
+import { existsSync as existsSync20, mkdirSync as mkdirSync8, readFileSync as readFileSync19, rmSync as rmSync11 } from "node:fs";
 import { availableParallelism as availableParallelism3 } from "node:os";
 import { join as join23, resolve as resolve9 } from "node:path";
 import process13 from "node:process";
@@ -58895,17 +58982,17 @@ async function runSpreadCommand(options, godotPath) {
     const faults = left.flatMap((worker) => engineFaults(worker, options.godotVersion));
     const arms = left.map((_, index) => {
       const file = join23(shareDirectory, `worker-${String(index)}.arms`);
-      return existsSync20(file) ? armsPlayed(readFileSync18(file, "utf8")) : [];
+      return existsSync20(file) ? armsPlayed(readFileSync19(file, "utf8")) : [];
     });
     faults.push(...shareFaults(arms));
     if (faults.length > 0) {
       return failed(faults, left, runDirectory, "so nothing was gathered");
     }
     const gather = await engine("gather", `${GATHER}${String(workers)}`);
-    console.log(readFileSync18(gather.log, "utf8").replace(CONTROL_SEQUENCE, "").trimEnd());
+    console.log(readFileSync19(gather.log, "utf8").replace(CONTROL_SEQUENCE, "").trimEnd());
     const gatherFaults = engineFaults(gather, options.godotVersion);
     const gatheredFile = join23(shareDirectory, "gathered.arms");
-    const gathered = new Set((existsSync20(gatheredFile) ? armsPlayed(readFileSync18(gatheredFile, "utf8")) ?? [] : []).map((arm) => arm.arm));
+    const gathered = new Set((existsSync20(gatheredFile) ? armsPlayed(readFileSync19(gatheredFile, "utf8")) ?? [] : []).map((arm) => arm.arm));
     const ungathered = (arms[0] ?? []).filter((arm) => !gathered.has(arm.arm)).map((arm) => arm.arm);
     if (ungathered.length > 0) {
       gatherFaults.push(`the gathering run never asked for ${ungathered.join(", ")}, which the workers played: it went another way through the arms than they did`);
@@ -58959,7 +59046,7 @@ function engineFaults(engine, godotVersion) {
   if (!existsSync20(engine.log)) {
     return faults;
   }
-  const printed = readRun(readFileSync18(engine.log, "utf8"));
+  const printed = readRun(readFileSync19(engine.log, "utf8"));
   const wrongEngine = godotVersion === null ? null : versionFault(printed.engineVersion, godotVersion);
   if (wrongEngine !== null) {
     faults.push(`${engine.name}: ${wrongEngine}`);
@@ -58972,7 +59059,7 @@ function engineFaults(engine, godotVersion) {
 }
 function progressOf(logs) {
   const each = logs.map((log, index) => {
-    const text = existsSync20(log) ? readFileSync18(log, "utf8") : "";
+    const text = existsSync20(log) ? readFileSync19(log, "utf8") : "";
     const last = [...text.matchAll(PROGRESS)].at(-1);
     return last === undefined ? `worker ${String(index)} has played no arm yet` : `worker ${String(index)} at ${last[1] ?? ""} ${last[2] ?? ""} of ${last[3] ?? ""}`;
   });
@@ -59004,7 +59091,7 @@ import {
   existsSync as existsSync23,
   mkdirSync as mkdirSync10,
   readdirSync as readdirSync14,
-  readFileSync as readFileSync22,
+  readFileSync as readFileSync23,
   rmSync as rmSync12,
   statSync as statSync14,
   writeFileSync as writeFileSync12
@@ -59016,7 +59103,7 @@ import process14 from "node:process";
 // src/suite-fingerprint.ts
 init_class_cache();
 import { createHash as createHash6 } from "node:crypto";
-import { existsSync as existsSync21, readdirSync as readdirSync13, readFileSync as readFileSync19, statSync as statSync13 } from "node:fs";
+import { existsSync as existsSync21, readdirSync as readdirSync13, readFileSync as readFileSync20, statSync as statSync13 } from "node:fs";
 import { join as join24, posix as posix2 } from "node:path";
 var RES_LITERAL = /res:\/\/[^"'\s)\]<>]*/g;
 var RELATIVE_LOAD = /\b(?:pre)?load\(\s*["']((?!res:\/\/|uid:\/\/)[^"']+)["']/g;
@@ -59081,7 +59168,7 @@ ${this.read(path).digest}
           walk(file, `${under}${entry.name}/`);
         } else if (entry.isFile()) {
           hash.update(`${under}${entry.name}
-`).update(readFileSync19(file));
+`).update(readFileSync20(file));
         }
       }
     };
@@ -59107,7 +59194,7 @@ ${this.read(path).digest}
     if (BINARY_RESOURCE.test(path)) {
       return { digest: "", reaches: [], unreadable: `${path} is a binary resource` };
     }
-    const bytes = readFileSync19(file);
+    const bytes = readFileSync20(file);
     const digest = createHash6("sha256").update(bytes).digest("hex");
     const text = bytes.toString("latin1");
     const reaches = new Set;
@@ -59145,7 +59232,7 @@ ${this.read(path).digest}
 }
 function extensionsOf(projectPath) {
   const list = join24(projectPath, ".godot", "extension_list.cfg");
-  return existsSync21(list) ? readFileSync19(list, "utf8").split(`
+  return existsSync21(list) ? readFileSync20(list, "utf8").split(`
 `).map((line) => line.trim()).filter((line) => line.startsWith("res://")) : [];
 }
 
@@ -59154,7 +59241,7 @@ init_suite_judge();
 init_suite_plan();
 
 // src/version.ts
-import { readFileSync as readFileSync21 } from "node:fs";
+import { readFileSync as readFileSync22 } from "node:fs";
 import { dirname as dirname12, join as join26 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function getLocalVersion() {
@@ -59165,7 +59252,7 @@ function getLocalVersion() {
   ];
   for (const packagePath of packageCandidates) {
     try {
-      const value = JSON.parse(readFileSync21(packagePath, "utf-8"));
+      const value = JSON.parse(readFileSync22(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;
       }
@@ -59426,9 +59513,9 @@ async function runTestCommand(options, godotPath) {
     }
     const fingerprints = new SuiteFingerprints(scripts, [
       getLocalVersion(),
-      readFileSync22(shippedListedRunner(), "utf8"),
+      readFileSync23(shippedListedRunner(), "utf8"),
       ...options.reachAlso.map((path) => `${path}
-${existsSync23(path) ? readFileSync22(path, "latin1") : "missing"}`)
+${existsSync23(path) ? readFileSync23(path, "latin1") : "missing"}`)
     ]);
     const printsOf = new Map(suites.map((suite) => [suite.path, fingerprints.of(suite)]));
     if (options.changedOnly) {
@@ -59544,7 +59631,7 @@ function roomSaid(engines, lanes, unheld, held, asked) {
 }
 function readRecord(file) {
   try {
-    const parsed = JSON.parse(readFileSync22(file, "utf8"));
+    const parsed = JSON.parse(readFileSync23(file, "utf8"));
     return typeof parsed === "object" && parsed !== null ? parsed : {};
   } catch {
     return {};
@@ -59603,7 +59690,7 @@ async function importProject(launch) {
     if (ended.ended !== null || ended.code !== 0) {
       return `${ended.ended ?? `the engine exited ${exitNamed(ended.code ?? 0)}`}; everything it printed is in ${launch.logs.named(log)}`;
     }
-    const printed = readRun(readFileSync22(log, "utf8"));
+    const printed = readRun(readFileSync23(log, "utf8"));
     const wrongEngine = launch.godotVersion === null ? null : versionFault(printed.engineVersion, launch.godotVersion);
     if (wrongEngine !== null) {
       return `${wrongEngine}; everything it printed is in ${launch.logs.named(log)}`;
@@ -59719,7 +59806,7 @@ async function runEngine2(launch, plan, index, times, again = "", slot = null) {
       launch.slots.release(lock);
     }
   }
-  const printed = readRun(readFileSync22(log, "utf8"));
+  const printed = readRun(readFileSync23(log, "utf8"));
   const assignment = {
     suites: plan.suites,
     expected: readExpected(expectedFile),
@@ -59754,7 +59841,7 @@ function report(ran, across, uncollected, startedAt, logs, printOutput, targets)
     for (const engine of ran) {
       console.log("");
       console.log(`--- what engine ${String(engine.index)} printed, running ${named(engine.plan.suites.map((suite) => suite.path))}:`);
-      console.log(existsSync23(engine.log) ? readFileSync22(engine.log, "utf8").replace(CONTROL_SEQUENCE, "").trimEnd() : "(no log was written)");
+      console.log(existsSync23(engine.log) ? readFileSync23(engine.log, "utf8").replace(CONTROL_SEQUENCE, "").trimEnd() : "(no log was written)");
     }
   }
   const failed = ran.filter((engine) => !engine.verdict.passed);
@@ -59773,7 +59860,7 @@ function report(ran, across, uncollected, startedAt, logs, printOutput, targets)
       writeFileSync12(engine.log, `${verdict.join(`
 `)}
 ---
-${readFileSync22(engine.log, "utf8")}`);
+${readFileSync23(engine.log, "utf8")}`);
     }
     if (engine.verdict.shown.length > 0) {
       console.log("");