gdharness 1.3.48 → 1.3.49

package/build/cli.js

@@ -10095,6 +10095,12 @@ function uncachedFor(projectPath, messagesPer) {
   const cached = cachedClasses(projectPath);
   return messagesPer.map((messages) => unloadedTypes(messages, declared, cached).filter((type) => !type.inTheClassCache));
 }
+function declaredButUncached(projectPath, name) {
+  if (name === "" || cachedClasses(projectPath)?.has(name) === true) {
+    return null;
+  }
+  return declaredClasses(projectPath).get(name) ?? null;
+}
 function classesNamedIn(source, known) {
   const named = new Set;
   for (const [word] of source.matchAll(/\b[A-Z][A-Za-z0-9_]*\b/g)) {
@@ -10178,16 +10184,15 @@ function instanceRemedy(entries, dependsOn, besideOthers) {
   }
   const declaring = declaringScripts(entries);
   const lever = dependsOn.length === 0 ? ", and the named types depend on no other global class, so that lever is not available here. " + "That is the common case rather than the awkward one: an edit near a type that depends on " + "something refreshes it before the fault is noticed, which is why a type with no " + "dependencies is where this turns up" : `, so changing ${[...dependsOn].sort().join(" or ")} and then rescanning is worth a try`;
-  return `${besideOthers ? `For ${entries.map(written).join(", ")}, run` : "Run"} editor_rescan first: ` + "it costs about half a second, and it has cleared this in every reproduction measured since the " + "scan timing was fixed: both in one project, the scan returning in 243ms and 275ms, and one in " + "another where the same call also rebuilt the copy. " + "The fault behind it is that a script the editor has loaded keeps the copy it built, and nothing " + `rebuilds that copy when the file changes; ${declaring.length === 1 ? `editor_rescan with reloadScript set to ${declaring[0]} recompiles that copy` : `reloadScript takes one script, so a call each for ${declaring.join(" and ")} recompiles those copies`} from the file into the same ` + "object and answers with what that added under methodsAdded and constantsAdded. Read that and the " + "next diagnostics as two readings, because they are of two things: measured in one window on " + "one editor, the analyser resolved a call to a newly added method while the built copy of that " + "same script did not have it. So the reload is worth doing and is not what clears these; the " + "scan is. The other lever measured is that a held type is refreshed when something it " + `depends on changes rather than when it changes itself${lever}. editor_launch restart has always ` + "worked and costs a window. project_import refresh_classes does not, and answers added: [] while " + "this is happening.";
+  return `${besideOthers ? `For ${entries.map(written).join(", ")}, run` : "Run"} editor_rescan first: ` + "it costs about half a second, and it has cleared this in every reproduction measured since the " + "scan timing was fixed: both in one project, the scan returning in 243ms and 275ms, and one in " + "another where the same call also rebuilt the copy. " + "The fault behind it is that a script the editor has loaded keeps the copy it built, and nothing " + `rebuilds that copy when the file changes; ${declaring.length === 1 ? `editor_rescan with reloadScript set to ${declaring[0]} recompiles that copy` : `editor_rescan with reloadScript set to ${JSON.stringify(declaring)} recompiles those copies`} from the file into the same ` + "object and answers with what that added under methodsAdded and constantsAdded. Read that and the " + "next diagnostics as two readings, because they are of two things: measured in one window on " + "one editor, the analyser resolved a call to a newly added method while the built copy of that " + "same script did not have it. So the reload is worth doing and is not what clears these; the " + "scan is. The other lever measured is that a held type is refreshed when something it " + `depends on changes rather than when it changes itself${lever}. editor_launch restart has always ` + "worked and costs a window. project_import refresh_classes does not, and answers added: [] while " + "this is happening.";
 }
 function classRemedy(entries) {
   if (entries.length === 0) {
     return "";
   }
   const declaring = declaringScripts(entries);
-  const reload = declaring.length === 1 ? `editor_rescan with reloadScript set to ${declaring[0]}` : `editor_rescan with reloadScript, a call each for ${declaring.join(" and ")} since it takes one script,`;
-  const oneAtATime = declaring.length === 1 ? "" : " Take them one at a time: a rescan that brings in a class also reloads every script naming it and lists them under dependentsReloaded, so a script listed there needs no call of its own.";
-  return `For ${entries.map(written).join(", ")}, run ${reload} first.${oneAtATime} In the one project ` + "that has reproduced a stale enum member, three times, the reload cleared it at once each time, " + "and the one plain editor_rescan tried left the diagnostic standing.";
+  const reload = declaring.length === 1 ? `editor_rescan with reloadScript set to ${declaring[0]}` : `editor_rescan with reloadScript set to ${JSON.stringify(declaring)}`;
+  return `For ${entries.map(written).join(", ")}, run ${reload} first. In the one project ` + "that has reproduced a stale enum member, three times, the reload cleared it at once each time, " + "and the one plain editor_rescan tried left the diagnostic standing.";
 }
 function notReloadedNote(broughtIn, notReloaded) {
   const tried = notReloaded.filter((one) => one.tool !== true).map((one) => one.scriptPath);
@@ -11170,12 +11175,13 @@ function readRun(printed) {
     }
     const text = found[1] ?? "";
     const warning = error === null;
+    const script = /^\s*SCRIPT /.test(line);
     if (open === null) {
-      errors.push({ text, at, suite: null, during: null, warning });
+      errors.push({ text, at, suite: null, during: null, warning, script });
     } else if (during === null) {
-      afterCase.push({ text, at, warning });
+      afterCase.push({ text, at, warning, script });
     } else {
-      errors.push({ text, at, suite: open.path, during, warning });
+      errors.push({ text, at, suite: open.path, during, warning, script });
     }
   }
   const last = open;
@@ -11289,6 +11295,25 @@ function rowsAcross(engines) {
   }
   return faults;
 }
+function crashIn(lines) {
+  const trimmed = lines.map((line) => line.trim());
+  const at = trimmed.findIndex((line) => CRASH_HEADER.test(line));
+  const said = trimmed.some((line) => line.includes(QUEUE_OVERFLOW_LINE));
+  if (at === -1) {
+    return said ? { signal: "", overflowed: true } : null;
+  }
+  const report = trimmed.slice(at);
+  const build = report.map((line) => CRASH_BUILD.exec(line)?.[1]).find((commit) => commit !== undefined);
+  const frames = build === undefined ? undefined : QUEUE_OVERFLOW_FRAMES.get(build);
+  const framed = frames?.every((frame) => report.some((line) => line.includes(`(${frame})`))) === true;
+  return { signal: CRASH_HEADER.exec(trimmed[at] ?? "")?.[1] ?? "", overflowed: said || framed };
+}
+function whileRunning(running) {
+  if (running === null) {
+    return "";
+  }
+  return running.during === null ? ` in ${running.suite}` : ` while ${running.suite} > ${running.during} ran`;
+}
 function named(items) {
   const shown = items.slice(0, MOST_NAMED).join(", ");
   return items.length > MOST_NAMED ? `${shown} and ${String(items.length - MOST_NAMED)} more` : shown;
@@ -11304,11 +11329,15 @@ function judgeEngine(printed, handed, end) {
   const failing = new Set;
   const shownAt = new Set;
   const explained = end.code === GDUNIT_FAILED && [...printed.suites.values()].some((suite) => suite.cases.some((ran) => ran.verdict === "FAILED")) || end.code === GDUNIT_ORPHANS && printed.orphansLeft.length > 0;
+  const crashed = crashIn(printed.lines);
   if (end.ended !== null) {
     faults.push(end.ended);
   } else if (end.code !== 0 && !explained) {
     const free = end.freeBytes === undefined ? "" : `, with ${(end.freeBytes / 1024 ** 3).toFixed(1)} GB of memory free as it ended`;
-    faults.push(end.code === null ? `the engine was ended by ${end.signal ?? "a signal"}${free}` : `the engine exited ${exitNamed(end.code)}${free}`);
+    faults.push(crashed !== null && crashed.signal !== "" ? `the engine crashed${whileRunning(printed.running)}, its crash handler reporting signal ${crashed.signal}${free}` : end.code === null ? `the engine was ended by ${end.signal ?? "a signal"}${free}` : `the engine exited ${exitNamed(end.code)}${free}`);
+  }
+  if (crashed?.overflowed === true) {
+    faults.push(`the engine's call queue overflowed${whileRunning(printed.running)}: something queued deferred calls without end within one frame, most often a layout that changes the size it is laid out from in a deferred handler, so the frame never ends${crashed.signal === "" ? "" : ", and the engine crashed reporting the overflow"}`);
   }
   if (printed.lines.every((line) => line.trim() === "")) {
     faults.push("the engine printed nothing at all");
@@ -11391,6 +11420,10 @@ function judgeEngine(printed, handed, end) {
   }
   const selfTyped = selfTypedSentence(handed.selfTyped ?? []);
   const notes = [];
+  const pushErrorsFailed = handed.failsOnPushErrors === true ? pushErrorsFailedSentence(failedOnPushErrors(printed)) : undefined;
+  if (pushErrorsFailed !== undefined) {
+    notes.push(pushErrorsFailed);
+  }
   if (printed.leaks.length > 0 && walkStoppedPartWay(printed.lines)) {
     notes.push(`${WALK_STOPPED_SENTENCE} It said: ${printed.leaks.join(" ")}`);
   } else {
@@ -11447,6 +11480,25 @@ function linesShown(lines, picked, cutShort) {
 function declaringAdvice(during, warning = false) {
   return `if the suite prints it on purpose, list its text under "${funcOf(during)}" in the suite's ${warning ? "GDHARNESS_EXPECTED_WARNINGS" : "GDHARNESS_EXPECTED_ERRORS"}`;
 }
+function failedOnPushErrors(printed) {
+  const failed = new Set;
+  for (const suite of printed.suites.values()) {
+    for (const ran of suite.cases) {
+      if (ran.verdict === "FAILED") {
+        failed.add(`${suite.path} > ${ran.name}`);
+      }
+    }
+  }
+  return [
+    ...new Set(printed.errors.filter((error) => error.script !== true && error.suite !== null && error.during !== null).map((error) => `${error.suite ?? ""} > ${error.during ?? ""}`).filter((ran) => failed.has(ran)))
+  ];
+}
+function pushErrorsFailedSentence(cases) {
+  if (cases.length === 0) {
+    return;
+  }
+  return "The project turns on gdUnit4's report/godot/push_error, so gdUnit4 fails a case on every error " + `and warning the engine prints while it runs, declared or not, which failed ` + `${cases.length === 1 ? "this case" : "these cases"}: ${named(cases)}. A case that prints one on purpose ` + "does it inside assert_error(...).is_push_error(...) or is_push_warning(...), which gdUnit4 passes, " + "and declares it for gdharness all the same.";
+}
 function unexpectedErrors(printed, expected, paths) {
   const owed = new Map;
   for (const path of paths) {
@@ -11490,7 +11542,7 @@ ${String(error.warning)}`);
   const neverPrinted = [...owed.values()].flatMap((debt) => debt.texts.map((text) => ({ suite: debt.suite, during: debt.during, text, warning: debt.warning })));
   return { printed: unexpected, neverPrinted };
 }
-var SUITE_OPENED, TIME, CASE_LINE, STATISTICS, ERROR_LINE, WARNING_LINE, EXECUTED, MISMATCHED_ROW, UNRUNNABLE_CASE, BANNER, LEFT_OUT, DRIVER_FALLBACK, MACHINE_WARNED, ORPHANS_REPORTED, STARVED, NESTED_ERROR = "While attempting to print an error, another error was printed:", WINDOWS_EXITS, MEMORY_EXITS, GDUNIT_FAILED = 100, GDUNIT_ORPHANS = 101, GDUNIT_EXITS, GODOT_EXITS, TAIL = 60, MOST_NAMED = 8;
+var SUITE_OPENED, TIME, CASE_LINE, STATISTICS, ERROR_LINE, WARNING_LINE, EXECUTED, MISMATCHED_ROW, UNRUNNABLE_CASE, BANNER, LEFT_OUT, DRIVER_FALLBACK, MACHINE_WARNED, ORPHANS_REPORTED, STARVED, NESTED_ERROR = "While attempting to print an error, another error was printed:", WINDOWS_EXITS, MEMORY_EXITS, GDUNIT_FAILED = 100, GDUNIT_ORPHANS = 101, GDUNIT_EXITS, GODOT_EXITS, CRASH_HEADER, CRASH_BUILD, QUEUE_OVERFLOW_LINE = "Object was deleted while awaiting a callback.", QUEUE_OVERFLOW_FRAMES, TAIL = 60, MOST_NAMED = 8;
 var init_suite_judge = __esm(() => {
   init_engine_leaks();
   init_junit();
@@ -11530,6 +11582,11 @@ var init_suite_judge = __esm(() => {
     [105, "gdUnit4's code for scripts that did not compile"]
   ]);
   GODOT_EXITS = new Set([1, 255]);
+  CRASH_HEADER = /^(?:CrashHandlerException|handle_crash): Program crashed with signal (\d+)/;
+  CRASH_BUILD = /^Engine version: .*\(([0-9a-f]{40})\)$/;
+  QUEUE_OVERFLOW_FRAMES = new Map([
+    ["ed1daf0bf001b61586d9930840f2f1394092c079", ["main+3e1082a", "main+3e0f4aa"]]
+  ]);
 });
 
 // src/engine-launch.ts
@@ -11952,6 +12009,7 @@ import {
   closeSync as closeSync3,
   mkdirSync as mkdirSync3,
   openSync as openSync3,
+  readdirSync as readdirSync4,
   readFileSync as readFileSync8,
   rmSync as rmSync6,
   statSync as statSync6,
@@ -11989,6 +12047,18 @@ function machineSlots(asked = {
 function nonEmpty(value) {
   return value === undefined || value === "" ? undefined : value;
 }
+function slotsDrawnOn(count, inAGate, gateQueued) {
+  const gated = Math.max(1, count - KEPT_SLOTS);
+  if (inAGate) {
+    return { numbers: Array.from({ length: gated }, (_, slot) => slot), limit: "gate" };
+  }
+  const every = Array.from({ length: count }, (_, slot) => count - 1 - slot);
+  const kept = every.slice(0, count - gated);
+  return gateQueued && kept.length > 0 ? { numbers: kept, limit: "kept" } : { numbers: every };
+}
+function inAGate(env = process7.env) {
+  return nonEmpty(env[SHARE_VARIABLE]) !== undefined && nonEmpty(env[SHARE_COUNT_VARIABLE]) !== undefined;
+}
 
 class FolderChanges {
   changed = false;
@@ -12069,16 +12139,20 @@ class EngineSlots {
   starts = new Map;
   held = new Set;
   marks = new Set;
+  drawn = { numbers: [] };
   saidAt = Number.NEGATIVE_INFINITY;
   directory;
   count;
   holder;
+  inAGate;
   say;
-  constructor(directory, count, holder, say) {
+  constructor(directory, count, holder, say, gated = inAGate()) {
     this.directory = directory;
     this.count = count;
     this.holder = holder;
     this.say = say;
+    this.inAGate = gated;
+    this.drawn = slotsDrawnOn(count, gated, false);
   }
   async take(signal, waiting, blocked) {
     mkdirSync3(this.directory, { recursive: true });
@@ -12105,7 +12179,7 @@ class EngineSlots {
           }
         } else if (this.say !== undefined && this.held.size === 0 && now - began >= COMMAND_WAIT_SAID_MS && now - this.saidAt >= WAIT_SAID_MS) {
           this.saidAt = now;
-          this.say(slotWaitSaid(now - began, this.count, this.directory, this.holders()));
+          this.say(slotWaitSaid(now - began, this.count, this.directory, this.holders(), this.drawn));
         }
         if (changes === undefined) {
           changes = new FolderChanges(this.directory);
@@ -12123,7 +12197,8 @@ class EngineSlots {
   }
   async takeFree() {
     mkdirSync3(this.directory, { recursive: true });
-    for (let slot = 0;slot < this.count; slot += 1) {
+    this.drawn = slotsDrawnOn(this.count, this.inAGate, !this.inAGate && await this.aGateIsQueued());
+    for (const slot of this.drawn.numbers) {
       const lock = join9(this.directory, `${String(slot)}.lock`);
       if (this.made(lock) || await this.takenOver(lock)) {
         this.held.add(lock);
@@ -12147,9 +12222,32 @@ class EngineSlots {
     this.marks.add(mark);
     return mark;
   }
+  async aGateIsQueued() {
+    const marks = join9(this.directory, QUEUED_FOLDER);
+    let names;
+    try {
+      names = readdirSync4(marks).filter((name) => name.endsWith(".json"));
+    } catch {
+      return false;
+    }
+    let live = false;
+    for (const name of names) {
+      const mark = join9(marks, name);
+      const content = readWhole(mark);
+      if (content === null || holderOf(content) === null) {
+        continue;
+      }
+      if (await this.free(mark)) {
+        removeWhole(mark);
+      } else {
+        live = true;
+      }
+    }
+    return live;
+  }
   holders() {
     const found = [];
-    for (let slot = 0;slot < this.count; slot += 1) {
+    for (const slot of this.drawn.numbers) {
       try {
         const holder = holderOf(readFileSync8(join9(this.directory, `${String(slot)}.lock`), "utf8"));
         if (holder !== null) {
@@ -12279,26 +12377,40 @@ function processSlots() {
 function nameSlotTaker(by) {
   takenBy = 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);
+function slotWaitSaid(waitedMs, count, directory, holders = [], drawn = { numbers: [] }) {
+  const taking = drawn.limit === undefined ? count : drawn.numbers.length;
+  const slots = `${slotsSaid(taking, count, directory, drawn.limit)} ${taking === 1 ? "is" : "are"} in use`;
+  const named = holdersNamed(taking, holders);
   const waiting = `Waiting${waitedMs >= 1000 ? ` ${String(Math.round(waitedMs / 1000))} s so far` : ""} for an engine: ${slots}`;
+  const back = `the engine starts when ${taking === 1 ? "it" : "one"} is given back`;
+  const starts = drawn.limit === "kept" ? `${back} or no gate is queued` : back;
   if (named.length === 0) {
-    return `${waiting}, by a gate or another tool, and the engine starts when one is given back.`;
+    return `${waiting}, by a gate or another tool, and ${starts}.`;
   }
-  if (count === 1) {
-    return `${waiting}, by ${named.join(", ")}, and the engine starts when it is given back.`;
+  if (taking === 1) {
+    return `${waiting}, by ${named.join(", ")}, and ${starts}.`;
   }
-  return `${waiting}: ${listed(named)}. The engine starts when one is given back.`;
+  return `${waiting}: ${listed(named)}. ${starts.charAt(0).toUpperCase()}${starts.slice(1)}.`;
 }
-function slotWaitedSaid(waitedMs, count, directory, holders) {
+function slotsSaid(taking, count, directory, limit) {
+  const where = `on this machine (${directory})`;
+  if (limit === "kept") {
+    return `${taking === 1 ? "the one engine slot" : `the ${String(taking)} engine slots`} of the ${String(count)} ${where} kept for engines outside a gate while a gate is queued`;
+  }
+  if (limit === "gate") {
+    return `${taking === 1 ? "the one engine slot" : `the ${String(taking)} engine slots`} of the ${String(count)} ${where} a gate's engines draw on`;
+  }
+  return count === 1 ? `the one engine slot ${where}` : `all ${String(count)} engine slots ${where}`;
+}
+function slotWaitedSaid(waitedMs, count, directory, holders, drawn = { numbers: [] }) {
   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);
+  const taking = drawn.limit === undefined ? count : drawn.numbers.length;
+  const slots = `${slotsSaid(taking, count, directory, drawn.limit)} ${taking === 1 ? "was" : "were"} in use`;
+  const named = holdersNamed(taking, 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)}.`;
+  return taking === 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;
@@ -12320,15 +12432,18 @@ async function slotForCall() {
   const waits = callSlotWaits();
   const began = Date.now();
   let blockedBy;
+  let blockedOn;
   const lock = await slots.take(callSignal(), progress === undefined ? undefined : (waitedMs) => {
-    progress(waitedMs / 1000, slotWaitSaid(waitedMs, slots.count, slots.directory, slots.holders()));
+    progress(waitedMs / 1000, slotWaitSaid(waitedMs, slots.count, slots.directory, slots.holders(), slots.drawn));
   }, () => {
     blockedBy = slots.holders();
+    blockedOn = slots.drawn;
   });
   if (waits !== undefined && blockedBy !== undefined) {
     waits.ms += Date.now() - began;
     const heldBy = blockedBy;
-    waits.said ??= (waitedMs) => slotWaitedSaid(waitedMs, slots.count, slots.directory, heldBy);
+    const heldOn = blockedOn;
+    waits.said ??= (waitedMs) => slotWaitedSaid(waitedMs, slots.count, slots.directory, heldBy, heldOn);
   }
   return {
     lock,
@@ -12350,7 +12465,7 @@ async function inASlot(body) {
     held.release();
   }
 }
-var SLOTS_VARIABLE = "GODOT_ENGINE_SLOTS", SLOT_COUNT_VARIABLE = "GODOT_ENGINE_SLOT_COUNT", PROCESSORS_A_SLOT = 2, START_TOLERANCE_MS = 2000, UNWRITTEN_MS = 1e4, SLOT_LOOK_MS = 1000, SLOT_SETTLE_MS = 50, WAIT_SAID_MS = 20000, COMMAND_WAIT_SAID_MS = 2000, START_READ_MS = 1e4, WAITING_FOLDER = "waiting", waitsMarked = 0, ours, saidTo, takenBy;
+var SLOTS_VARIABLE = "GODOT_ENGINE_SLOTS", SLOT_COUNT_VARIABLE = "GODOT_ENGINE_SLOT_COUNT", PROCESSORS_A_SLOT = 2, START_TOLERANCE_MS = 2000, UNWRITTEN_MS = 1e4, SLOT_LOOK_MS = 1000, SLOT_SETTLE_MS = 50, WAIT_SAID_MS = 20000, COMMAND_WAIT_SAID_MS = 2000, START_READ_MS = 1e4, WAITING_FOLDER = "waiting", QUEUED_FOLDER = "queued", SHARE_VARIABLE = "GODOT_ENGINE_SHARE", SHARE_COUNT_VARIABLE = "GODOT_ENGINE_SHARE_COUNT", KEPT_SLOTS = 2, waitsMarked = 0, ours, saidTo, takenBy;
 var init_engine_slots = __esm(() => {
   init_alive();
   init_cache_home();
@@ -12361,7 +12476,7 @@ var init_engine_slots = __esm(() => {
 });
 
 // src/detection.ts
-import { existsSync as existsSync6, readdirSync as readdirSync4, statSync as statSync7 } from "node:fs";
+import { existsSync as existsSync6, readdirSync as readdirSync5, statSync as statSync7 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
 import { join as join10 } from "node:path";
 function resolveHomeDirectory() {
@@ -12377,7 +12492,7 @@ function scanDirectoryForGodotBinaries(directory, platform) {
   }
   let entries;
   try {
-    entries = readdirSync4(directory);
+    entries = readdirSync5(directory);
   } catch {
     return [];
   }
@@ -12460,6 +12575,10 @@ function resolveHeadless(requested, host) {
   }
   return envValue("DISPLAY", host.variables) === undefined && envValue("WAYLAND_DISPLAY", host.variables) === undefined;
 }
+function hiddenWindowFlags(engineArgs, projectCapsFrames) {
+  const capped = projectCapsFrames || engineArgs.includes("--max-fps");
+  return ["--disable-vsync", ...capped ? [] : ["--max-fps", String(HIDDEN_WINDOW_FPS)]];
+}
 function resolveSilent(requested) {
   return requested !== false;
 }
@@ -12504,6 +12623,9 @@ function runArguments(options) {
   if (options.quitAfter !== undefined && options.quitAfter !== null) {
     args.push("--quit-after", String(options.quitAfter));
   }
+  if (options.hiddenWindow !== undefined && !options.headless) {
+    args.push(...hiddenWindowFlags(options.engineArgs ?? [], options.hiddenWindow.projectCapsFrames));
+  }
   if (options.engineArgs !== undefined) {
     args.push(...options.engineArgs);
   }
@@ -12581,7 +12703,7 @@ function environmentFor2(options, variables = process.env) {
   const base = options.savesIn === undefined ? { ...variables } : userDataIn(options.savesIn, variables);
   return { ...base, ...options.env, GDHARNESS_RUNTIME_DIR: options.runtimeDirectory };
 }
-var ENGINE_FLAGS, VALUE_KIND, SET_BY_ARGUMENT, OPENED_BY_A_SERVER = "GDHARNESS_OPENED_BY_A_SERVER", EDITOR_PID_VARIABLE = "GDHARNESS_EDITOR_PID", RESERVED_VARIABLE_PREFIX = "GDHARNESS_", SAVES_NOT_MOVED_NOTE = "On macOS the engine reads user:// off HOME and ignores the variables that move it elsewhere, measured on Godot 4.7.2, so this run wrote its saves where the player keeps theirs. A suite that saves a game has written into the same folder as the copy being played, and one that tidies up after itself may have removed real saves.";
+var HIDDEN_WINDOW_FPS = 60, ENGINE_FLAGS, VALUE_KIND, SET_BY_ARGUMENT, OPENED_BY_A_SERVER = "GDHARNESS_OPENED_BY_A_SERVER", EDITOR_PID_VARIABLE = "GDHARNESS_EDITOR_PID", RESERVED_VARIABLE_PREFIX = "GDHARNESS_", SAVES_NOT_MOVED_NOTE = "On macOS the engine reads user:// off HOME and ignores the variables that move it elsewhere, measured on Godot 4.7.2, so this run wrote its saves where the player keeps theirs. A suite that saves a game has written into the same folder as the copy being played, and one that tidies up after itself may have removed real saves.";
 var init_launch = __esm(() => {
   ENGINE_FLAGS = Object.freeze({
     "--verbose": "none",
@@ -13051,7 +13173,7 @@ var init_engine_run = __esm(() => {
 });
 
 // src/doc-cache.ts
-import { existsSync as existsSync8, readdirSync as readdirSync5, statSync as statSync8 } from "node:fs";
+import { existsSync as existsSync8, readdirSync as readdirSync6, statSync as statSync8 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
 import { basename as basename4, dirname as dirname5, isAbsolute as isAbsolute5, join as join11 } from "node:path";
 import process9 from "node:process";
@@ -13077,7 +13199,7 @@ function docCachesWritten(directory) {
   const written = new Map;
   let names;
   try {
-    names = readdirSync5(directory);
+    names = readdirSync6(directory);
   } catch {
     return written;
   }
@@ -13107,7 +13229,7 @@ var init_doc_cache = __esm(() => {
 });
 
 // src/project-scan.ts
-import { existsSync as existsSync9, readdirSync as readdirSync6, readFileSync as readFileSync9, statSync as statSync9 } from "node:fs";
+import { existsSync as existsSync9, readdirSync as readdirSync7, readFileSync as readFileSync9, statSync as statSync9 } from "node:fs";
 import { basename as basename5, extname, join as join12, relative as relative4, sep as sep3 } from "node:path";
 function skipped(name) {
   return name.startsWith(".") || SKIPPED.has(name);
@@ -13127,7 +13249,7 @@ function projectStructure(projectPath) {
     if (steppedOver(directory)) {
       return;
     }
-    for (const entry of readdirSync6(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync7(directory, { withFileTypes: true })) {
       if (skipped(entry.name)) {
         continue;
       }
@@ -13174,7 +13296,7 @@ function steppedOverIn(directory) {
   }
   const found = [];
   const visit = (at, prefix) => {
-    for (const entry of readdirSync6(at, { withFileTypes: true })) {
+    for (const entry of readdirSync7(at, { withFileTypes: true })) {
       if (!entry.isDirectory() || skipped(entry.name)) {
         continue;
       }
@@ -13195,7 +13317,7 @@ function steppedOverIn(directory) {
 function filesBelow(root, extensions) {
   const found = [];
   const visit = (directory, prefix) => {
-    for (const entry of readdirSync6(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync7(directory, { withFileTypes: true })) {
       if (skipped(entry.name)) {
         continue;
       }
@@ -13219,7 +13341,7 @@ function scriptsWithoutUid(projectPath) {
     if (steppedOver(directory)) {
       return;
     }
-    for (const entry of readdirSync6(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync7(directory, { withFileTypes: true })) {
       if (skipped(entry.name)) {
         continue;
       }
@@ -13291,7 +13413,7 @@ function projectTexts(projectPath) {
     if (steppedOver(directory)) {
       return;
     }
-    for (const entry of readdirSync6(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync7(directory, { withFileTypes: true })) {
       if (skipped(entry.name)) {
         continue;
       }
@@ -13321,7 +13443,7 @@ function ignoredTexts(projectPath) {
       return;
     }
     const under = ignored || gdignored(directory);
-    for (const entry of readdirSync6(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync7(directory, { withFileTypes: true })) {
       if (skipped(entry.name)) {
         continue;
       }
@@ -13419,7 +13541,7 @@ function searchProject(projectPath, options) {
       }
       return;
     }
-    for (const entry of readdirSync6(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync7(directory, { withFileTypes: true })) {
       if (skipped(entry.name)) {
         continue;
       }
@@ -13499,7 +13621,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 readFileSync10, statSync as statSync10 } from "node:fs";
+import { existsSync as existsSync10, readdirSync as readdirSync8, readFileSync as readFileSync10, statSync as statSync10 } from "node:fs";
 import { join as join13 } from "node:path";
 function md5Of(file) {
   let stats;
@@ -13594,7 +13716,7 @@ function staleImports(projectPath) {
     }
     let entries;
     try {
-      entries = readdirSync7(directory, { withFileTypes: true });
+      entries = readdirSync8(directory, { withFileTypes: true });
     } catch {
       return;
     }
@@ -13681,7 +13803,7 @@ var init_import_freshness = __esm(() => {
 import {
   existsSync as existsSync11,
   mkdirSync as mkdirSync4,
-  readdirSync as readdirSync8,
+  readdirSync as readdirSync9,
   readFileSync as readFileSync11,
   renameSync as renameSync2,
   unlinkSync,
@@ -13706,7 +13828,7 @@ function freeLibraryCopies(projectPath, platform = process.platform) {
     }
     let names;
     try {
-      names = readdirSync8(folder);
+      names = readdirSync9(folder);
     } catch {
       continue;
     }
@@ -13733,7 +13855,7 @@ function seedExtensionList(projectPath) {
     }
     let entries;
     try {
-      entries = readdirSync8(directory, { withFileTypes: true });
+      entries = readdirSync9(directory, { withFileTypes: true });
     } catch {
       return;
     }
@@ -13827,7 +13949,7 @@ function importRecord(projectPath, resourcePath) {
 var init_reimport = () => {};
 
 // src/scratch.ts
-import { existsSync as existsSync13, mkdtempSync as mkdtempSync2, readdirSync as readdirSync9, rmSync as rmSync8 } from "node:fs";
+import { existsSync as existsSync13, mkdtempSync as mkdtempSync2, readdirSync as readdirSync10, rmSync as rmSync8 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
 import { join as join16 } from "node:path";
 import process10 from "node:process";
@@ -13837,7 +13959,7 @@ function scratchDirectory(kind) {
 function sweepAbandonedScratch(directory = tmpdir3()) {
   let entries;
   try {
-    entries = readdirSync9(directory);
+    entries = readdirSync10(directory);
   } catch {
     return;
   }
@@ -16079,7 +16201,7 @@ import {
   cpSync,
   existsSync as existsSync18,
   mkdirSync as mkdirSync6,
-  readdirSync as readdirSync11,
+  readdirSync as readdirSync12,
   readFileSync as readFileSync18,
   rmdirSync,
   rmSync as rmSync9,
@@ -16103,7 +16225,7 @@ function runtimeAddonDigest(from = shippedAddonsDirectory()) {
 function addonsDigest(names, from) {
   const hash = createHash5("sha256");
   const walk = (directory, relative) => {
-    for (const name of readdirSync11(directory).sort()) {
+    for (const name of readdirSync12(directory).sort()) {
       if (name === VERSION_MARKER || name === DIGEST_MARKER) {
         continue;
       }
@@ -16202,7 +16324,7 @@ function removeLoader(projectPath) {
   rmSync9(copy);
   rmSync9(`${copy}.uid`, { force: true });
   const folder = dirname9(copy);
-  if (readdirSync11(folder).length === 0) {
+  if (readdirSync12(folder).length === 0) {
     rmdirSync(folder);
   }
   return true;
@@ -16263,7 +16385,7 @@ function removeAddons(projectPath) {
     }
   }
   const addons = join22(projectPath, "addons");
-  if (removed.length > 0 && existsSync18(addons) && readdirSync11(addons).length === 0) {
+  if (removed.length > 0 && existsSync18(addons) && readdirSync12(addons).length === 0) {
     rmdirSync(addons);
     removed.push(addons);
   }
@@ -16596,7 +16718,7 @@ var init_tool_definitions = __esm(() => {
   };
   PROPERTIES = {
     type: "object",
-    description: `Properties to set, keyed by Godot property name. Vectors, colours and the like may be written as {"x": 1, "y": 2} or tagged {"_type": "Vector2", "x": 1, "y": 2}, which is the form a read answers with, so a value read off one node can be written straight to another. One carrying a field its type has not, such as a z for a Vector2, is refused naming it. A colour may also be given as its html code, "#ff8000" or "#ff800080". A key may also be a colon path into one of the components of a vector, a colour, a rectangle or a transform, as GDScript names them, so one axis is written alone: "position:x", "modulate:a", "region_rect:size:y"; a component the value does not have is refused, naming the ones it has. A property holding a node takes the path to it from the node being set, such as "../Player". A property holding a Resource takes the res:// path of a file, which a read answers with its class and, when its script declares one, scriptClass, or a resource built into the scene as {"_type": "CircleShape2D", "radius": 8}, its class (an engine class or a script's class_name) beside its properties. A typed list or map of resources or nodes, such as Array[Item], takes each in the same forms, a node by its path; a read answers a resource built into the scene in that form, with what it holds away from the defaults, so it too can be written to another node. script takes the res:// path of a script to attach, one with no class_name included, and is attached before the rest are set, so the properties it declares can be given beside it. Each value is read back once set, and one the engine changed or refused is refused with what it holds. An enum property takes its number or the name of a value: as the script spells it, as the inspector shows it, or for an engine enum as the class's constant, so Add or BLEND_MODE_ADD; a value past an export range, or a number no value of an enum has, is written as given and named under outsideDeclared. A key may reach into a resource built into this one: the property holding it, a slash, then one of its own, so a TileSet's first atlas source takes "sources/0/0:0/0/probability". A list of such resources is stepped into by an element's index, so "lines/1/text" is the text of the second resource in lines and the others are left as they were. A resource kept in a file of its own, or built into the scene an instance comes from, is written in that file, or replaced here by one of this file's own. The next element of a list is made by writing to it, as the inspector's Add Element makes it: physics_layer_0/collision_layer on a TileSet with no physics layer makes its first, and "sources/0/0:0/0/physics_layer_0/polygon_0/points" a tile's first collision polygon on that layer. ${WHOLE_NUMBERS}`,
+    description: `Properties to set, keyed by Godot property name. Vectors, colours and the like may be written as {"x": 1, "y": 2} or tagged {"_type": "Vector2", "x": 1, "y": 2}, which is the form a read answers with, so a value read off one node can be written straight to another. One carrying a field its type has not, such as a z for a Vector2, is refused naming it. A colour may also be given as its html code, "#ff8000" or "#ff800080". A key may also be a colon path into one of the components of a vector, a colour, a rectangle or a transform, as GDScript names them, so one axis is written alone: "position:x", "modulate:a", "region_rect:size:y"; a component the value does not have is refused, naming the ones it has. A property holding a node takes the path to it from the node being set, such as "../Player". A property holding a Resource takes the res:// path of a file, which a read answers with its class and, when its script declares one, scriptClass, or a resource built into the scene as {"_type": "CircleShape2D", "radius": 8}, its class (an engine class or a script's class_name) beside its properties. A typed list or map of resources or nodes, such as Array[Item], takes each in the same forms, a node by its path; a read answers a resource built into the scene in that form, with what it holds away from the defaults, so it too can be written to another node. script takes the res:// path of a script to attach, one with no class_name included, and is attached before the rest are set, so the properties it declares can be given beside it. Each value is read back once set, and one the engine changed or refused is refused with what it holds. An enum property takes its number or the name of a value: as the script spells it, as the inspector shows it, or for an engine enum as its constant, so Add or BLEND_MODE_ADD, and Bottom or VERTICAL_ALIGNMENT_BOTTOM for a global one; a value past an export range, or a number no value of an enum has, is written as given and named under outsideDeclared. A key may reach into a resource built into this one: the property holding it, a slash, then one of its own, so a TileSet's first atlas source takes "sources/0/0:0/0/probability". A list of such resources is stepped into by an element's index, so "lines/1/text" is the text of the second resource in lines and the others are left as they were. A resource kept in a file of its own, or built into the scene an instance comes from, is written in that file, or replaced here by one of this file's own. The next element of a list is made by writing to it, as the inspector's Add Element makes it: physics_layer_0/collision_layer on a TileSet with no physics layer makes its first, and "sources/0/0:0/0/physics_layer_0/polygon_0/points" a tile's first collision polygon on that layer. ${WHOLE_NUMBERS}`,
     additionalProperties: true
   };
   XY = {
@@ -16966,7 +17088,7 @@ var init_tool_definitions = __esm(() => {
       name: "project_search",
       title: "Search the project",
       effect: "read",
-      description: "Searches text or a regular expression across project files and returns file paths with line numbers, one entry per line that holds the query, however often it holds it; total_matches counts those lines. What the engine steps over is not searched: directories spelled with a dot, node_modules, and any directory holding a .gdignore, which not_searched names when the search passed one. A vendored engine or an export directory is therefore absent from the results rather than matching the code you are looking for in a copy nobody runs. The addons gdharness installed are not searched either, since nobody on the project wrote them. A path naming one of those folders, or a place inside one, is searched as asked, and note says the whole-project search steps over it. Each line is searched on its own, so a query holding a line break is refused.",
+      description: "Searches text or a regular expression across project files and returns file paths with line numbers, one entry per line that holds the query, however often it holds it; total_matches counts those lines. What the engine steps over is not searched: files and directories spelled with a dot, node_modules, and any directory holding a .gdignore, which not_searched names when the search passed one. A vendored engine or an export directory is therefore absent from the results rather than matching the code you are looking for in a copy nobody runs. The addons gdharness installed are not searched either, since nobody on the project wrote them. A path naming one of those folders, or a place inside one, is searched as asked, and note says the whole-project search steps over it. Each line is searched on its own, so a query holding a line break is refused.",
       parameters: {
         projectPath: PROJECT_PATH,
         query: { type: "string", description: "The text or pattern to find." },
@@ -17093,7 +17215,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, 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.",
+      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 answers bytes, the size of the output it wrote, and 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: {
@@ -17177,7 +17299,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; 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,
+      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, push_warning or an engine error unless the project turns on its report/godot/push_error setting, so a case that printed one undeclared is otherwise in neither failed nor errors: it is named here, and the run is failed for it. With that setting on, gdUnit4 fails the case on each one, declared or not, and the note names those cases; one printed inside assert_error(...).is_push_error(...) or is_push_warning(...) passes there, and is declared all the same. 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: {
@@ -17226,7 +17348,7 @@ var init_tool_definitions = __esm(() => {
         rootNodeType: {
           type: "string",
           ops: ["create"],
-          description: "create: the root node class, an engine class or a class_name a project script declares, which the root is made as with that script attached. Default Node. The answer names the root as scene_node get does: rootNodeType its engine class, with scriptClass for a class_name."
+          description: "create: the root node class, an engine class or a class_name a project script declares, which the root is made as with that script attached. Default Node. The answer names the root as scene_node get does: rootNodeType its engine class, with scriptClass for a class_name. With no editor open, a class_name the class cache does not list yet is put in it first, and classCacheRebuilt says so."
         },
         rootNodeName: {
           type: "string",
@@ -17297,7 +17419,7 @@ var init_tool_definitions = __esm(() => {
         nodeType: {
           type: "string",
           ops: ["add"],
-          description: `add: the node class, such as "CharacterBody2D", or a class_name a project script declares, which the node is made as with that script attached. Give this or instancePath. The answer names the node made as get does: nodeType its engine class, for an instance the class of its scene's root, with scriptClass when its script declares a class_name.`
+          description: `add: the node class, such as "CharacterBody2D", or a class_name a project script declares, which the node is made as with that script attached. Give this or instancePath. The answer names the node made as get does: nodeType its engine class, for an instance the class of its scene's root, with scriptClass when its script declares a class_name. With no editor open, a class_name the class cache does not list yet is put in it first, and classCacheRebuilt says so.`
         },
         instancePath: {
           type: "string",
@@ -17700,7 +17822,7 @@ var init_tool_definitions = __esm(() => {
         },
         symbols: {
           effect: "read",
-          summary: "document symbols from the language server, each with its kind, the line and column of its name, and the lastLine of its declaration",
+          summary: `document symbols from the language server, each with its kind, the line and column of its name, and the lastLine of its declaration. detail is the language server's own text, which writes a default through the engine (Callable() as "null::null", a Color as a quoted tuple) and leaves out a signal's argument types; structure gives each declaration as the file writes it`,
           requires: []
         },
         completion: {
@@ -17740,7 +17862,7 @@ var init_tool_definitions = __esm(() => {
         resourceType: {
           type: "string",
           ops: ["create"],
-          description: 'create: the resource class, such as "PhysicsMaterial" or "StandardMaterial3D", or a class_name a project script declares, which the resource is made as with that script attached.'
+          description: 'create: the resource class, such as "PhysicsMaterial" or "StandardMaterial3D", or a class_name a project script declares, which the resource is made as with that script attached. With no editor open, a class_name the class cache does not list yet is put in it first, and classCacheRebuilt says so.'
         },
         properties: { ...PROPERTIES, ops: ["create", "modify"] },
         script: {
@@ -17919,7 +18041,7 @@ var init_tool_definitions = __esm(() => {
         visible: {
           type: "boolean",
           ops: ["start"],
-          description: "start: on Windows, show the window on the desktop in use. By default a windowed run this server starts goes on a desktop of its own, where it renders and runtime_capture works but the window never shows and never takes the keyboard or the pointer. A game a visible editor plays opens on the desktop in use, and one a hidden editor (editor_launch hidden: true) plays goes on its desktop. Elsewhere than Windows the window shows either way. Default false."
+          description: `start: on Windows, show the window on the desktop in use. By default a windowed run this server starts goes on a desktop of its own, where it renders and runtime_capture works but the window never shows and never takes the keyboard or the pointer. That desktop has no display, so there is no refresh for vsync to wait on: a Vulkan game waiting on one drew two frames a second, and kept to that after turning vsync off as it ran. A game there, whether this server starts it or a hidden editor plays it, is given --disable-vsync, and --max-fps ${String(HIDDEN_WINDOW_FPS)} unless engineArgs, the project's editor/run/main_run_args or its application/run/max_fps cap its frames, so it reads its vsync mode as disabled; a game that turns vsync on as it runs slows to two frames a second again. A game a visible editor plays opens on the desktop in use, and one a hidden editor (editor_launch hidden: true) plays goes on its desktop. Elsewhere than Windows the window shows either way. Default false.`
         },
         silent: {
           type: "boolean",
@@ -18113,8 +18235,9 @@ var init_tool_definitions = __esm(() => {
           description: "How long to wait for the scan. Default 30000."
         },
         reloadScript: {
-          type: "string",
-          description: "A script to recompile in the editor after the scan, for the half a scan does not reach: a script the editor has loaded keeps the copy it built, that copy is refreshed when one of its dependencies changes rather than when it changes itself, and a scan leaves it alone. Measured here, a built copy comes back without a method added to it while script_diagnostics on the same script reads clean in the same window, so the copy the editor built and whatever the analyser resolves types against are not known to be one thing: reload for the copy, and read the diagnostics as a separate answer rather than as this one confirmed. This recompiles into the same object, so the holders that kept the stale copy alive see the new one. What the reload changed comes back under methodsAdded, methodsRemoved, constantsAdded and constantsRemoved, with each enum value as Kind.SHORT among the constants, since an enum member is held as a constant and never shows among the methods; methodsHeld and constantsHeld count what the copy holds afterwards, because a reload that compiled nothing and answered OK is the failure worth catching. listMembers adds the whole lists. A script that does not compile is not reloaded: reloadProblem gives Godot's error, says whether the copy the editor holds survived, and names the classes the file uses, whose held copies being behind is what failed one before. A @tool script is not reloaded either, since it runs inside the editor and reloading one from inside a call can take the editor down: reloadProblem says so, and editor_launch restart recompiles it. A path spelled in another case than the file is reloaded under the spelling on disk, which is the one the editor holds its copy under, and that spelling comes back under reloadedAs. A script open in a script tab with unsaved edits is reloaded from the file all the same, and unsavedInEditorNote says that saving the tab writes its text back over the file; open tabs with no unsaved edits reread what changed, as they do when the editor's window takes the focus."
+          type: ["string", "array"],
+          items: { type: "string" },
+          description: "A script to recompile in the editor after the scan, or a list of them recompiled in that order, for the half a scan does not reach: a script the editor has loaded keeps the copy it built, that copy is refreshed when one of its dependencies changes rather than when it changes itself, and a scan leaves it alone. Measured here, a built copy comes back without a method added to it while script_diagnostics on the same script reads clean in the same window, so the copy the editor built and whatever the analyser resolves types against are not known to be one thing: reload for the copy, and read the diagnostics as a separate answer rather than as this one confirmed. This recompiles into the same object, so the holders that kept the stale copy alive see the new one. What the reload changed comes back under methodsAdded, methodsRemoved, constantsAdded and constantsRemoved, with each enum value as Kind.SHORT among the constants, since an enum member is held as a constant and never shows among the methods; methodsHeld and constantsHeld count what the copy holds afterwards, because a reload that compiled nothing and answered OK is the failure worth catching. listMembers adds the whole lists. A script that does not compile is not reloaded: reloadProblem gives Godot's error, says whether the copy the editor holds survived, and names the classes the file uses, whose held copies being behind is what failed one before. A @tool script is not reloaded either, since it runs inside the editor and reloading one from inside a call can take the editor down: reloadProblem says so, and editor_launch restart recompiles it. A path spelled in another case than the file is reloaded under the spelling on disk, which is the one the editor holds its copy under, and that spelling comes back under reloadedAs. A script open in a script tab with unsaved edits is reloaded from the file all the same, and unsavedInEditorNote says that saving the tab writes its text back over the file; open tabs with no unsaved edits reread what changed, as they do when the editor's window takes the focus. A list is answered under reloads, one entry for each script with its scriptPath and ok and these fields, in place of them beside the scan."
         },
         listMembers: {
           type: "boolean",
@@ -18285,7 +18408,7 @@ var init_tool_definitions = __esm(() => {
         },
         rect: {
           effect: "read",
-          summary: "one node's rectangle or position, in canvas and in window pixels, and for a Control whether it is in view. Canvas is the node's own viewport; window is where it is drawn in the game's window, through any embedded dialog or SubViewport it sits in, which is what runtime_input mouse_click and mouse_motion take. A 2D node answers where it stands, and a sprite, collision shape, polygon or line also the rectangle it covers under covers. A 3D node answers with the point to aim at, which is the middle of what it draws rather than the origin it stands on, the rectangle it covers under covers, the camera that drew it, and behind_camera when it is not in front of one",
+          summary: "one node's rectangle or position, in canvas and in window pixels, and for a Control whether it is in view, with drawn_over naming what a pointer at its centre would reach instead, such as a dialog over the screen. Canvas is the node's own viewport; window is where it is drawn in the game's window, through any embedded dialog or SubViewport it sits in, which is what runtime_input mouse_click and mouse_motion take. A 2D node answers where it stands, and a sprite, collision shape, polygon or line also the rectangle it covers under covers. A 3D node answers with the point to aim at, which is the middle of what it draws rather than the origin it stands on, the rectangle it covers under covers, the camera that drew it, and behind_camera when it is not in front of one",
           requires: ["nodePath"]
         },
         property: {
@@ -18326,7 +18449,7 @@ var init_tool_definitions = __esm(() => {
         value: {
           ops: ["set"],
           blank: true,
-          description: `set: the value, fitted to the property's type. ${WHOLE_NUMBERS} A number the property would have to cut is refused rather than truncated: a fraction into an int, a number other than 0 or 1 into a bool. A vector, colour or the like may be written as its fields, {"x": 140, "y": 300}, or tagged, {"_type": "Vector2", "x": 140, "y": 300}, which is the form a read answers with, and one carrying a field its type has not, such as a z for a Vector2, is refused naming it. A colour may also be given as its html code, "#ff8000" or "#ff800080". Text is written as sent: the JSON string "" writes an empty string, and quote marks inside the string are written into the text. An enum property takes the name of a value as well as its number, as the script or the inspector spells it, and a name none of its values has is refused listing them. A number past the range a property is exported with, or one none of its enum values has, is written, as the engine writes it, and the answer says so under outside_declared. A property typed as or holding an object takes a path naming one the game holds, the way call's args do, and holds that instance, or null, which the text null also means, to empty it. One declared as Variant or untyped takes anything, as the engine does: a value of the kind it holds is fitted to it, an int staying an int, and any other is stored as sent, a fraction into one holding an int included. A typed list or map, such as Array[int] or Dictionary[String, int], takes a JSON list or object with each element fitted to its element type, and an element that cannot become one is refused by its index or key, as is an object of another script than the one the list holds, whether or not that script has a class_name.`
+          description: `set: the value, fitted to the property's type. ${WHOLE_NUMBERS} A number the property would have to cut is refused rather than truncated: a fraction into an int, a number other than 0 or 1 into a bool. A vector, colour or the like may be written as its fields, {"x": 140, "y": 300}, or tagged, {"_type": "Vector2", "x": 140, "y": 300}, which is the form a read answers with, and one carrying a field its type has not, such as a z for a Vector2, is refused naming it. A colour may also be given as its html code, "#ff8000" or "#ff800080". Text is written as sent: the JSON string "" writes an empty string, and quote marks inside the string are written into the text. An enum property takes the name of a value as well as its number, as the script or the inspector spells it, and a name none of its values has is refused listing them. A number past the range a property is exported with, or one none of its enum values has, is written, as the engine writes it, and the answer says so under outside_declared. A property typed as or holding an object takes a path naming one the game holds, the way call's args do, and holds that instance, or null, which the text null also means, to empty it. A resource is named by the res:// or uid:// path of its file, "res://art/hero.png", and loaded as the game loads one, so a resource it already holds is that same instance; the record a read answers a node or a filed resource with names it too. One declared as Variant or untyped takes anything, as the engine does: a value of the kind it holds is fitted to it, an int staying an int, and any other is stored as sent, a fraction into one holding an int included. A typed list or map, such as Array[int] or Dictionary[String, int], takes a JSON list or object with each element fitted to its element type, and an element that cannot become one is refused by its index or key, as is an object of another script than the one the list holds, whether or not that script has a class_name.`
         },
         method: {
           type: "string",
@@ -18336,7 +18459,7 @@ var init_tool_definitions = __esm(() => {
         args: {
           type: "array",
           ops: ["call"],
-          description: `call: the arguments, fitted to the method's parameter types. An RID is passed as the {"_type": "RID", "id": ...} a read answers it with, such as a viewport's for RenderingServer's render timing. ${WHOLE_NUMBERS} A number a parameter would have to cut is refused rather than truncated: a fraction for an int, a number other than 0 or 1 for a bool. A vector, colour or the like may be written as its fields, {"x": 140, "y": 300}, or tagged, {"_type": "Vector2", "x": 140, "y": 300}. A parameter typed as an object takes a path naming one the game holds and is handed that instance: a colon path read from nodePath, "_game:run:wares:3", or one starting at a node, "/root/Main/Hud" or "/root/Main:_game:run". A path that reaches no object, or an object of another class than the parameter declares, is refused, and so are too few or too many arguments. The engine names a parameter typed as a script class without class_name by the class the script extends, so an object of that class with another script passes that check and the engine refuses the call: the answer says the method did not run, with the engine's reason. A parameter typed as a list or map, such as Array[int] or Array[Gear], or as a packed array, such as PackedVector2Array, is built from a JSON list or object element by element, points as their fields and objects named by their paths, and an element that cannot become what it holds is refused naming it, as a fraction where whole numbers go is. A parameter typed as an enum takes a name of its values as well as a number, Mood's ANGRY or Node's PROCESS_MODE_DISABLED, and a number none of its values has is passed on and named under outside_declared. The method itself takes its arguments here only: brackets on it holding arguments are refused.`
+          description: `call: the arguments, fitted to the method's parameter types. An RID is passed as the {"_type": "RID", "id": ...} a read answers it with, such as a viewport's for RenderingServer's render timing. ${WHOLE_NUMBERS} A number a parameter would have to cut is refused rather than truncated: a fraction for an int, a number other than 0 or 1 for a bool. A vector, colour or the like may be written as its fields, {"x": 140, "y": 300}, or tagged, {"_type": "Vector2", "x": 140, "y": 300}. A parameter typed as an object takes a path naming one the game holds and is handed that instance: a colon path read from nodePath, "_game:run:wares:3", or one starting at a node, "/root/Main/Hud" or "/root/Main:_game:run". A resource is named by the res:// or uid:// path of its file, as set takes one. A path that reaches no object, or an object of another class than the parameter declares, is refused, and so are too few or too many arguments. The engine names a parameter typed as a script class without class_name by the class the script extends, so an object of that class with another script passes that check and the engine refuses the call: the answer says the method did not run, with the engine's reason. A parameter typed as a list or map, such as Array[int] or Array[Gear], or as a packed array, such as PackedVector2Array, is built from a JSON list or object element by element, points as their fields and objects named by their paths, and an element that cannot become what it holds is refused naming it, as a fraction where whole numbers go is. A parameter typed as an enum takes a name of its values as well as a number, Mood's ANGRY or Node's PROCESS_MODE_DISABLED, and a number none of its values has is passed on and named under outside_declared. The method itself takes its arguments here only: brackets on it holding arguments are refused.`
         },
         properties: {
           type: ["boolean", "array"],
@@ -19377,6 +19500,21 @@ function windowNeedsOf(scripts, paths) {
     headless: sorted.filter((suite) => suite.headless).map((suite) => suite.path)
   };
 }
+function capsFrames(projectPath) {
+  const file = `${projectPath}/project.godot`;
+  if (!existsSync22(file)) {
+    return false;
+  }
+  const cap = parseProjectGodot(readFileSync21(file, "utf8"))["application"]?.["run/max_fps"];
+  return typeof cap === "number" && cap > 0;
+}
+function gdUnitFailsOnPushErrors(projectPath) {
+  const file = `${projectPath}/project.godot`;
+  if (!existsSync22(file)) {
+    return false;
+  }
+  return parseProjectGodot(readFileSync21(file, "utf8"))["gdunit4"]?.["report/godot/push_error"] === true;
+}
 function viewportOf(projectPath) {
   const file = `${projectPath}/project.godot`;
   if (!existsSync22(file)) {
@@ -41040,7 +41178,7 @@ var init_autoload_failure = __esm(() => {
 });
 
 // src/runtime-client.ts
-import { existsSync as existsSync25, readdirSync as readdirSync15, readFileSync as readFileSync25, statSync as statSync15, unlinkSync as unlinkSync3 } from "node:fs";
+import { existsSync as existsSync25, readdirSync as readdirSync16, 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 join30, resolve as resolve11 } from "node:path";
@@ -41216,7 +41354,7 @@ function announcedIn(directory) {
   const found = [];
   const candidates = [];
   const entries = [];
-  for (const entry of readdirSync15(directory)) {
+  for (const entry of readdirSync16(directory)) {
     const report = ERROR_REPORT_PATTERN.exec(entry);
     if (report) {
       sweepErrorReport(join30(directory, entry), Number.parseInt(report[1] ?? "", 10));
@@ -43558,19 +43696,35 @@ function planMove(args, plan) {
     }
     const lines = script?.lines ?? new Lines(file.text);
     for (const path of named) {
-      const spelled = new RegExp(`${path.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&")}(?![\\w-]|\\.\\w)`, "g");
-      for (const match of file.text.matchAll(spelled)) {
-        const offset = match.index;
-        const covered = edits.some((one) => one.file === file.path && one.offset <= offset && offset < one.offset + one.length);
-        if (!covered) {
-          const region = script?.regions.find((one) => one.start <= offset && offset < one.end);
-          mentions.push({
-            file: file.path,
-            line: lines.positionOf(offset).line + 1,
-            kind: region !== undefined ? region.kind : /\.(tscn|tres)$/.test(file.path) ? "scene" : "text",
-            text: lines.lineAt(offset).trim(),
-            why: `names ${path} outside a string the engine reads as a path`
-          });
+      const after = String.raw`(?![\w-]|\.\w)`;
+      const escaped = (text) => text.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&");
+      const fromRoot = path.startsWith("res://") ? path.slice("res://".length) : "";
+      const spellings = [
+        {
+          pattern: new RegExp(`${escaped(path)}${after}`, "g"),
+          why: `names ${path} outside a string the engine reads as a path`
+        },
+        ...fromRoot === "" ? [] : [
+          {
+            pattern: new RegExp(`(?<![\\w./-])${escaped(fromRoot)}${after}`, "g"),
+            why: `names ${path} as ${fromRoot}, a path from the project's root without res://, which the engine does not read as one`
+          }
+        ]
+      ];
+      for (const { pattern, why } of spellings) {
+        for (const match of file.text.matchAll(pattern)) {
+          const offset = match.index;
+          const covered = edits.some((one) => one.file === file.path && one.offset <= offset && offset < one.offset + one.length);
+          if (!covered) {
+            const region = script?.regions.find((one) => one.start <= offset && offset < one.end);
+            mentions.push({
+              file: file.path,
+              line: lines.positionOf(offset).line + 1,
+              kind: region !== undefined ? region.kind : /\.(tscn|tres)$/.test(file.path) ? "scene" : "text",
+              text: lines.lineAt(offset).trim(),
+              why
+            });
+          }
         }
       }
     }
@@ -43707,7 +43861,7 @@ var init_rename = __esm(() => {
 });
 
 // src/rename-symbol.ts
-import { existsSync as existsSync30, mkdirSync as mkdirSync17, readdirSync as readdirSync16, realpathSync as realpathSync4, rmSync as rmSync16, writeFileSync as writeFileSync18 } from "node:fs";
+import { existsSync as existsSync30, mkdirSync as mkdirSync17, readdirSync as readdirSync17, realpathSync as realpathSync4, rmSync as rmSync16, writeFileSync as writeFileSync18 } from "node:fs";
 import { basename as basename9, dirname as dirname21, join as join37, relative as relative7, resolve as resolve12 } from "node:path";
 function resourcePathOf(projectPath, absolute) {
   const inside = relative7(onDiskSpelling(projectPath), onDiskSpelling(absolute));
@@ -43957,7 +44111,7 @@ async function renameSymbol(request, services) {
   }
   plan = mentionIgnored(plan, ignoredTexts(projectPath), symbol, moveTo === null ? [] : [declaringPath]);
   const rewrites = rewritesOf(plan, texts, moveTo === null || request.newScriptPath === null ? null : { from: declaringPath, to: moveTo, absoluteTo: request.newScriptPath });
-  const left = leftAloneReport(asWritten(plan.mentions, rewrites));
+  const left = leftAloneReport(asWritten(plan.mentions, rewrites), [symbol]);
   const graph = new ClassGraph(scripts, declared);
   const rank = (path) => (declaringFiles.includes(path) ? 0 : 1000) + graph.ancestors(`${path}#`).length;
   const scriptsInOrder = rewrites.map((rewrite) => rewrite.path).filter((path) => path.endsWith(".gd")).sort((a, b) => rank(a) - rank(b) || a.localeCompare(b)).map((path) => path === declaringPath && moveTo !== null ? moveTo : path);
@@ -44041,6 +44195,7 @@ function changedReport(edits, rewrites) {
     const lines = rewrite.after.split(`
 `);
     const byLine = new Map;
+    const firstAt = new Map;
     const starts = [0];
     for (let at = rewrite.before.indexOf(`
 `);at !== -1; at = rewrite.before.indexOf(`
@@ -44058,6 +44213,8 @@ function changedReport(edits, rewrites) {
         line += 1;
       }
       byLine.set(line, (byLine.get(line) ?? new Set).add(edit.kind));
+      const column = edit.offset - (starts[line] ?? 0);
+      firstAt.set(line, Math.min(firstAt.get(line) ?? column, column));
     }
     return {
       file: rewrite.path,
@@ -44065,7 +44222,11 @@ function changedReport(edits, rewrites) {
       lines: [...byLine.entries()].sort(([a], [b]) => a - b).map(([line, kinds]) => ({
         line: line + 1,
         kinds: [...kinds],
-        text: (lines[line] ?? "").replace(/\r$/, "").trim()
+        text: (() => {
+          const whole = (lines[line] ?? "").replace(/\r$/, "");
+          const indent = whole.length - whole.trimStart().length;
+          return quoted2(whole.trim(), (firstAt.get(line) ?? 0) - indent);
+        })()
       }))
     };
   });
@@ -44078,7 +44239,7 @@ function asWritten(mentions, rewrites) {
     return line === undefined ? mention : { ...mention, text: line.replace(/\r$/, "").trim() };
   });
 }
-function leftAloneReport(mentions) {
+function leftAloneReport(mentions, terms) {
   const full = [];
   const prose = new Map;
   const others = new Map;
@@ -44108,7 +44269,7 @@ ${mention.kind}`;
       others.set(mention.why, files);
       counts.otherSymbols += 1;
     } else {
-      full.push(mention);
+      full.push({ ...mention, text: quotedAround(mention.text, terms) });
       counts.quoted += 1;
     }
   }
@@ -44165,12 +44326,24 @@ function writeLeftAloneDetail(projectPath, symbol, detail) {
   const path = join37(directory, `${String(Date.now())}-${String(detailWrites).padStart(6, "0")}-${String(process.pid)}-${symbol}.json`);
   writeFileSync18(path, `${JSON.stringify(detail, null, 2)}
 `, "utf8");
-  const kept = readdirSync16(directory).filter((name) => name.endsWith(".json")).sort().reverse();
+  const kept = readdirSync17(directory).filter((name) => name.endsWith(".json")).sort().reverse();
   for (const old of kept.slice(10)) {
     rmSync16(join37(directory, old), { force: true });
   }
   return path;
 }
+function quoted2(line, at) {
+  if (line.length <= QUOTED_CHARS) {
+    return line;
+  }
+  const start = Math.max(0, Math.min(at - Math.floor(QUOTED_CHARS / 3), line.length - QUOTED_CHARS));
+  const end = start + QUOTED_CHARS;
+  return `${start > 0 ? "..." : ""}${line.slice(start, end)}${end < line.length ? "..." : ""}`;
+}
+function quotedAround(text, terms) {
+  const at = terms.map((term) => text.indexOf(term)).filter((found) => found >= 0);
+  return quoted2(text, at.length > 0 ? Math.min(...at) : 0);
+}
 function summaryOf(edits, mentions, rewrites, left) {
   const count = (values) => {
     const counted = {};
@@ -44187,7 +44360,7 @@ function summaryOf(edits, mentions, rewrites, left) {
     leftAloneByKind: count(mentions.map((mention) => mention.kind))
   };
 }
-var WHAT, LEFT_ALONE_ANSWER_LINES = 300, detailWrites = 0, PROSE_KINDS;
+var WHAT, LEFT_ALONE_ANSWER_LINES = 300, detailWrites = 0, PROSE_KINDS, QUOTED_CHARS = 240;
 var init_rename_symbol = __esm(() => {
   init_gdscript_source();
   init_lsp_client();
@@ -44210,7 +44383,7 @@ var init_rename_symbol = __esm(() => {
 import {
   existsSync as existsSync31,
   mkdirSync as mkdirSync18,
-  readdirSync as readdirSync17,
+  readdirSync as readdirSync18,
   readFileSync as readFileSync33,
   renameSync as renameSync4,
   statSync as statSync17,
@@ -44218,7 +44391,7 @@ import {
 } from "node:fs";
 import { basename as basename10, dirname as dirname22, extname as extname4, join as join38, relative as relative8 } from "node:path";
 function filesUnder(directory) {
-  return readdirSync17(directory, { withFileTypes: true }).flatMap((entry) => {
+  return readdirSync18(directory, { withFileTypes: true }).flatMap((entry) => {
     const path = join38(directory, entry.name);
     return entry.isDirectory() ? filesUnder(path) : [path];
   });
@@ -44261,7 +44434,7 @@ function binaryResources(projectPath) {
     if (existsSync31(join38(directory, ".gdignore"))) {
       return;
     }
-    for (const entry of readdirSync17(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync18(directory, { withFileTypes: true })) {
       if (entry.name.startsWith(".")) {
         continue;
       }
@@ -44389,7 +44562,7 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
     ...mention,
     file: afterwards(mention.file)
   }));
-  const left = leftAloneReport(mentions);
+  const left = leftAloneReport(mentions, [from, ...moves.keys()].flatMap((path) => [path, path.replace(/^res:\/\//, "")]));
   const absoluteOf = (path) => join38(projectPath, path.slice("res://".length));
   const rewritten = new Map(rewrites.map((rewrite) => [rewrite.path, rewrite]));
   const moved = [...moves].map(([source, target]) => {
@@ -48573,7 +48746,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 readFileSync35, rmSync as rmSync18, statSync as statSync19 } from "node:fs";
+import { mkdirSync as mkdirSync21, openSync as openSync5, readdirSync as readdirSync19, readFileSync as readFileSync35, rmSync as rmSync18, statSync as statSync19 } from "node:fs";
 import { basename as basename11, join as join41, resolve as resolve13 } from "node:path";
 function runsDirectory() {
   return join41(runtimeDirectory(), "runs");
@@ -48678,7 +48851,7 @@ function everyRunRecord() {
   for (const directory of runtimeDirectories()) {
     let entries;
     try {
-      entries = readdirSync18(join41(directory, "runs"));
+      entries = readdirSync19(join41(directory, "runs"));
     } catch {
       continue;
     }
@@ -48943,7 +49116,7 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
   ]));
   let entries;
   try {
-    entries = readdirSync18(directory);
+    entries = readdirSync19(directory);
   } catch {
     return;
   }
@@ -49365,7 +49538,7 @@ import {
   fstatSync as fstatSync2,
   mkdirSync as mkdirSync23,
   openSync as openSync6,
-  readdirSync as readdirSync19,
+  readdirSync as readdirSync20,
   readFileSync as readFileSync37,
   readSync as readSync3,
   realpathSync as realpathSync5,
@@ -50120,7 +50293,7 @@ function exportPresetRefusal(projectPath, preset) {
   }
   return names.length === 0 ? `export_presets.cfg names no preset, so there is no '${preset}' to export with. project_export add_preset adds one.` : `This project has no export preset named '${preset}'. Its presets are ${names.map((name) => `'${name}'`).join(", ")}.`;
 }
-function exportAnswer(ending, asked, before, after, beside = [], docCacheNote = null) {
+function exportAnswer(ending, asked, before, after, beside = [], docCacheNote = null, bytes = null) {
   const { log } = ending;
   const written = after !== null && after !== before;
   const notCopied = librariesNotCopied(log.all);
@@ -50132,6 +50305,7 @@ function exportAnswer(ending, asked, before, after, beside = [], docCacheNote =
     failure: ending.failure ?? undefined,
     errors: log.count("error"),
     warnings: log.count("warning"),
+    ...written && bytes !== null ? { bytes } : {},
     ...beside.length === 0 ? {} : { alsoWritten: beside },
     ...notCopied.length === 0 ? {} : {
       librariesNotLoaded: notCopied,
@@ -50179,7 +50353,7 @@ function writtenBeside(before, after, output, within) {
 function filesIn(folder) {
   const found = new Map;
   try {
-    for (const entry of readdirSync19(folder, { withFileTypes: true })) {
+    for (const entry of readdirSync20(folder, { withFileTypes: true })) {
       if (entry.isFile()) {
         found.set(entry.name, statSync20(join44(folder, entry.name)).mtimeMs);
       }
@@ -50771,7 +50945,7 @@ function elsewhereIn(projectPath, asked) {
   const root = (wanted.split("/")[0] ?? "").toLowerCase();
   let near = [];
   try {
-    near = readdirSync19(projectPath, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.toLowerCase() !== root).map((entry) => entry.name).filter((name) => name.toLowerCase().startsWith("test") || root.startsWith(name.toLowerCase()));
+    near = readdirSync20(projectPath, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.toLowerCase() !== root).map((entry) => entry.name).filter((name) => name.toLowerCase().startsWith("test") || root.startsWith(name.toLowerCase()));
   } catch {
     return "";
   }
@@ -50915,6 +51089,9 @@ function ownArguments(params) {
 function needsItsOwnProcess(asked) {
   return asked.savesIn !== undefined || asked.env !== undefined;
 }
+function staleCopyNote(problem) {
+  return `The editor serving the project still holds the copy of the script it compiled before, since reloading it failed: ${problem.replace(/\.$/, "")}.`;
+}
 function unheldNote(changed) {
   if (!isPlainObject3(changed)) {
     return "";
@@ -52918,7 +53095,7 @@ class GodotServer {
       return this.createErrorResponse(place.reason);
     }
     if (place !== null && !existsSync34(place.absolutePath)) {
-      const folders = readdirSync19(project.value.path, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => entry.name).sort();
+      const folders = readdirSync20(project.value.path, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => entry.name).sort();
       return this.createErrorResponse(`There is nothing at res://${place.relativePath} to search.${folders.length === 0 ? "" : ` The project's folders are ${folders.join(", ")}.`}`);
     }
     if (place !== null && !isWithinRoot(realpathSync5.native(project.value.path), realpathSync5.native(place.absolutePath))) {
@@ -53137,7 +53314,7 @@ ${platform}`;
       return this.createErrorResponse(`Export could not be run: ${ending.failure ?? "the engine gave no exit status"}`);
     }
     const beside = writtenBeside(listedBefore, filesIn(folder), basename13(output.absolutePath), dirname25(output.relativePath).replaceAll("\\", "/"));
-    return exportAnswer(ending, { preset, outputPath: output.relativePath, debug, ...pack ? { pack } : {} }, before, writtenAt(), beside, docCacheNote);
+    return exportAnswer(ending, { preset, outputPath: output.relativePath, debug, ...pack ? { pack } : {} }, before, writtenAt(), beside, docCacheNote, existsSync34(output.absolutePath) ? statSync20(output.absolutePath).size : null);
   }
   reportTestProgress(log) {
     const progress = callProgress();
@@ -53409,7 +53586,7 @@ ${platform}`;
     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 written = existsSync34(reportsDir) && notCompiled === null ? readdirSync20(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(readFileSync37(join44(reportsDir, newest, "results.xml"), "utf8"));
@@ -53682,6 +53859,7 @@ ${error.text}`;
         uncaughtNote(uncaught),
         undeclaredErrors.length > 0 ? `An engine error or warning a suite does not declare fails the run, as gdharness test judges it; ${declaringAdvice(undeclaredErrors[0]?.case ?? "test_name", undeclaredErrors[0]?.warning === true)}, once for each time it prints it${undeclaredErrors.some((error) => error.warning !== undeclaredErrors[0]?.warning) ? undeclaredErrors[0]?.warning === true ? ", and an error in its GDHARNESS_EXPECTED_ERRORS" : ", and a warning in its GDHARNESS_EXPECTED_WARNINGS" : ""}.${declaredAs}` : undefined,
         declaredNotPrinted.length > 0 ? "A declared error or warning the case did not print fails the run too, since the case no longer reaches what it was written to test." : undefined,
+        gdUnitFailsOnPushErrors(project.value.path) ? pushErrorsFailedSentence(failedOnPushErrors(casePrinted)) : undefined,
         walkStopped ? WALK_STOPPED_SENTENCE : undefined,
         countedLeaks.length > 0 ? [
           heldNamed === undefined ? 'What the engine still held as it exited fails the run, as gdharness test judges it; engineArgs ["--verbose"] has the engine name what it held.' : `What the engine still held as it exited fails the run, as gdharness test judges it. ${heldNamed}`,
@@ -53825,7 +54003,7 @@ ${error.text}`;
     const wanted = `res://${relativePath}`;
     const folder = dirname25(relativePath.replaceAll("\\", "/"));
     const inFolder = join44(projectPath, folder);
-    const beside = existsSync34(inFolder) ? readdirSync19(inFolder, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => `res://${folder === "." ? "" : `${folder}/`}${entry.name}`) : [];
+    const beside = existsSync34(inFolder) ? readdirSync20(inFolder, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => `res://${folder === "." ? "" : `${folder}/`}${entry.name}`) : [];
     return this.createErrorResponse(withNearestFiles(`Script file does not exist: ${wanted}`, wanted, scripts, beside));
   }
   async compileScripts(projectPath, paths) {
@@ -55038,16 +55216,18 @@ ${error.text}`;
     if (exported === null && this.godotBridge.isConnected() && editorWouldPlay && given.length === 0 && flags.value.length === 0 && !needsItsOwnProcess(asked.value) && !silentOnlyHere) {
       return await this.playThroughEditor(sceneArgument, refreshed.value, scanned, project.value.path, alreadyPlaying, runtimeWaitMs, ended, profiled);
     }
+    const onTheHiddenDesktop = !headless && args["visible"] !== true;
     const cmdArgs = runArguments({
       projectPath: exported === null ? project.value.path : null,
       headless,
       scene: sceneArgument,
       userArgs: given,
       engineArgs: flags.value,
-      silent
+      silent,
+      ...onTheHiddenDesktop && process.platform === "win32" ? { hiddenWindow: { projectCapsFrames: exported === null && capsFrames(project.value.path) } } : {}
     });
     this.logDebug(`Running Godot project: ${engine.value} ${cmdArgs.join(" ")}`);
-    const started = await this.launchKeptGame(engine.value, cmdArgs, project.value.path, needsItsOwnProcess(asked.value) ? environmentFor2({ ...asked.value, runtimeDirectory: runtimeDirectory() }) : undefined, headless || args["visible"] === true ? undefined : HIDDEN_DESKTOP, profiled, exported === null);
+    const started = await this.launchKeptGame(engine.value, cmdArgs, project.value.path, needsItsOwnProcess(asked.value) ? environmentFor2({ ...asked.value, runtimeDirectory: runtimeDirectory() }) : undefined, onTheHiddenDesktop ? HIDDEN_DESKTOP : undefined, profiled, exported === null);
     if ("error" in started) {
       return this.createErrorResponse(`The game could not be started: ${started.error}`, [
         "editor_status says which Godot this server runs and whether it answers"
@@ -55461,6 +55641,12 @@ ${error.text}`;
         if (spawned) {
           clearTheRecord();
         }
+        if (running.throughEditor) {
+          const told = await this.handleViaBridge("stop_playing", {});
+          if (told.isError === true) {
+            this.logDebug(`The editor was not told its closed game is over: ${told.content[0]?.text ?? ""}`);
+          }
+        }
         running.endedAt ??= Date.now();
         running.log.record("info", `gdharness asked pid ${announced ?? "unknown"} to close, as a player's close asks it, and it exited.`);
         return "gone";
@@ -56902,73 +57088,15 @@ ${error.text}`;
     const rebuilt = atMissingPaths.length > 0 ? cachedClasses(projectPath) : null;
     const dropped = rebuilt === null ? [] : atMissingPaths.filter((name) => !cachedAtMissingPaths(rebuilt, projectPath).includes(name));
     const stillAtMissingPaths = atMissingPaths.filter((name) => !dropped.includes(name));
-    const reloading = readNonEmptyString(args, "reloadScript");
-    let reloaded = {};
+    const asked = args["reloadScript"];
+    const reloads = [];
     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 = {
-        problem: `${reloading} is a @tool script, which runs inside the editor, so it is not reloaded from inside a call: editor_launch restart recompiles it.`
-      };
-    } else if (reloading !== undefined) {
-      try {
-        const reloadAsked = async () => asParams(await this.godotBridge.invokeTool("reload_script", { ...args, scriptPath: reloading }));
-        let answer = await reloadAsked();
-        const failedFirst = answer["failed"];
-        if (typeof failedFirst === "number" && failedFirst !== 0 && projectPath !== "") {
-          const first = await this.reloadWhatItIsBuiltOn(projectPath, readString(answer, "script") ?? reloading);
-          reloadedFirst.push(...first.reloaded);
-          if (first.reloaded.length > 0) {
-            answer = await reloadAsked();
-          }
-          builtOn = first.said;
-          builtOnUnchecked = first.unchecked === true;
-        }
-        const methods = readArray(answer, "methods");
-        const listed = (field) => {
-          const found = readArray(answer, field);
-          return found ? { [field]: found.map(String) } : {};
-        };
-        const asResource = (path) => path.startsWith("res://") ? path : `res://${path.replace(/^\/+/, "")}`;
-        const script = asResource(readString(answer, "script") ?? reloading);
-        const spelling = script === asResource(reloading) ? {} : { as: script };
-        const failed = answer["failed"];
-        if (typeof failed === "number" && failed !== 0) {
-          reloaded = {
-            ...spelling,
-            ...listed("heldBefore"),
-            ...listed("heldConstantsBefore"),
-            problem: failedReloadNote({
-              script,
-              code: failed,
-              codeName: readString(answer, "failedAs") ?? "",
-              heldBefore: listed("heldBefore")["heldBefore"] ?? [],
-              heldAfter: methods?.map(String) ?? [],
-              constantsBefore: listed("heldConstantsBefore")["heldConstantsBefore"] ?? [],
-              constantsAfter: listed("constants")["constants"] ?? [],
-              names: projectPath === "" ? [] : this.classesAScriptNames(projectPath, script),
-              restored: answer["restored"] === true,
-              restoredAs: readString(answer, "restoredAs") ?? "",
-              ...builtOn === undefined ? {} : { builtOn },
-              ...builtOnUnchecked ? { builtOnUnchecked } : {}
-            })
-          };
-        } else {
-          reloaded = methods ? {
-            ...spelling,
-            methods: methods.map(String),
-            ...listed("heldBefore"),
-            ...listed("constants"),
-            ...listed("heldConstantsBefore"),
-            ...answer["unsavedInEditor"] === true ? { unsaved: unsavedInEditorNote([script]) } : {}
-          } : { problem: `the editor would not say what ${script} has after reloading it` };
-        }
-      } catch (error) {
-        reloaded = { problem: `${reloading} could not be reloaded: ${errorMessage(error)}` };
-      }
+    for (const scriptPath of Array.isArray(asked) ? asked.map(String) : typeof asked === "string" ? [asked] : []) {
+      const one = await this.reloadAsked(projectPath, args, scriptPath);
+      reloads.push({ scriptPath, reloaded: one.reloaded });
+      reloadedFirst.push(...one.reloadedFirst);
     }
+    const reloaded = Array.isArray(asked) ? {} : reloads[0]?.reloaded ?? {};
     const checked = busy ? { unseen: [] } : await this.classesTheEditorCannotSee(args);
     const unseen = checked.unseen;
     const carried = projectPath === "" ? [] : this.unseenBeforeAnUnfinishedScan(projectPath);
@@ -57007,7 +57135,7 @@ ${error.text}`;
       notes.push(`The scan wrote the class cache from the list this editor is holding, and that list still has ${dropped.join(", ")} for a script that is gone, so the cache was rebuilt from the files without it. The editor goes on holding it and writes it back on every scan until it is restarted with editor_launch restart; until then a scan is followed by this same rebuild.`);
     }
     return this.jsonTextResponse({
-      ok: !busy && unseen.length === 0 && stillGone.length === 0 && stillAtMissingPaths.length === 0 && (dependents === null || dependents.notReloaded.length === 0) && reloaded.problem === undefined && checked.unchecked === undefined,
+      ok: !busy && unseen.length === 0 && stillGone.length === 0 && stillAtMissingPaths.length === 0 && (dependents === null || dependents.notReloaded.length === 0) && reloads.every((one) => one.reloaded.problem === undefined) && checked.unchecked === undefined,
       stillWorking: busy,
       waitedMs: Date.now() - started,
       waitedForEditorScanMs: waitedForEditorMs > 0 ? waitedForEditorMs : undefined,
@@ -57026,6 +57154,20 @@ ${error.text}`;
         return all.length > 0 ? all : undefined;
       })(),
       unsavedInEditorNote: reloaded.unsaved,
+      reloads: Array.isArray(asked) ? reloads.map(({ scriptPath, reloaded: one }) => ({
+        scriptPath,
+        ok: one.problem === undefined,
+        reloadedAs: one.as,
+        ...reloadDifference(one),
+        ...args["listMembers"] === true ? {
+          heldBeforeReload: one.heldBefore,
+          reloadedMethods: one.methods,
+          heldConstantsBeforeReload: one.heldConstantsBefore,
+          reloadedConstants: one.constants
+        } : {},
+        reloadProblem: one.problem,
+        unsavedInEditorNote: one.unsaved
+      })) : undefined,
       unseenByEditor: unseen.length > 0 ? unseen : undefined,
       broughtIn: broughtIn.length > 0 ? broughtIn : undefined,
       dependentsReloaded: dependents !== null && dependents.reloaded.length > 0 ? dependents.reloaded : undefined,
@@ -57040,6 +57182,75 @@ ${error.text}`;
       note: notes.length > 0 ? notes.join(" ") : undefined
     });
   }
+  async reloadAsked(projectPath, args, reloading) {
+    let reloaded = {};
+    const reloadedFirst = [];
+    let builtOn;
+    let builtOnUnchecked = false;
+    const reloadingSource = projectPath === "" ? null : this.sourceOfClass(projectPath, reloading);
+    if (reloadingSource !== null && isToolScript(reloadingSource)) {
+      reloaded = {
+        problem: `${reloading} is a @tool script, which runs inside the editor, so it is not reloaded from inside a call: editor_launch restart recompiles it.`
+      };
+    } else {
+      try {
+        const reloadAsked = async () => asParams(await this.godotBridge.invokeTool("reload_script", { ...args, scriptPath: reloading }));
+        let answer = await reloadAsked();
+        const failedFirst = answer["failed"];
+        if (typeof failedFirst === "number" && failedFirst !== 0 && projectPath !== "") {
+          const first = await this.reloadWhatItIsBuiltOn(projectPath, readString(answer, "script") ?? reloading);
+          reloadedFirst.push(...first.reloaded);
+          if (first.reloaded.length > 0) {
+            answer = await reloadAsked();
+          }
+          builtOn = first.said;
+          builtOnUnchecked = first.unchecked === true;
+        }
+        const methods = readArray(answer, "methods");
+        const listed = (field) => {
+          const found = readArray(answer, field);
+          return found ? { [field]: found.map(String) } : {};
+        };
+        const asResource = (path) => path.startsWith("res://") ? path : `res://${path.replace(/^\/+/, "")}`;
+        const script = asResource(readString(answer, "script") ?? reloading);
+        const spelling = script === asResource(reloading) ? {} : { as: script };
+        const failed = answer["failed"];
+        if (typeof failed === "number" && failed !== 0) {
+          reloaded = {
+            ...spelling,
+            ...listed("heldBefore"),
+            ...listed("heldConstantsBefore"),
+            problem: failedReloadNote({
+              script,
+              code: failed,
+              codeName: readString(answer, "failedAs") ?? "",
+              heldBefore: listed("heldBefore")["heldBefore"] ?? [],
+              heldAfter: methods?.map(String) ?? [],
+              constantsBefore: listed("heldConstantsBefore")["heldConstantsBefore"] ?? [],
+              constantsAfter: listed("constants")["constants"] ?? [],
+              names: projectPath === "" ? [] : this.classesAScriptNames(projectPath, script),
+              restored: answer["restored"] === true,
+              restoredAs: readString(answer, "restoredAs") ?? "",
+              ...builtOn === undefined ? {} : { builtOn },
+              ...builtOnUnchecked ? { builtOnUnchecked } : {}
+            })
+          };
+        } else {
+          reloaded = methods ? {
+            ...spelling,
+            methods: methods.map(String),
+            ...listed("heldBefore"),
+            ...listed("constants"),
+            ...listed("heldConstantsBefore"),
+            ...answer["unsavedInEditor"] === true ? { unsaved: unsavedInEditorNote([script]) } : {}
+          } : { problem: `the editor would not say what ${script} has after reloading it` };
+        }
+      } catch (error) {
+        reloaded = { problem: `${reloading} could not be reloaded: ${errorMessage(error)}` };
+      }
+    }
+    return { reloaded, reloadedFirst };
+  }
   async reloadDependents(projectPath, classes) {
     for (const { script, tool } of scriptsDeclaring(projectPath, classes)) {
       if (!tool) {
@@ -57371,9 +57582,7 @@ ${error.text}`;
     const done = await this.reloadInEditor([{ script: scriptPath, tool: source !== null && isToolScript(source) }], project.value.path);
     const problem = done.notReloaded[0]?.problem;
     const notes = [
-      ...problem === undefined ? [] : [
-        `The editor serving the project was not given the script as written, so it answers from the copy it compiled before: ${problem}.`
-      ],
+      ...problem === undefined ? [] : [staleCopyNote(problem)],
       ...done.unsavedInEditor.length > 0 ? [unsavedInEditorNote(done.unsavedInEditor)] : []
     ];
     return this.jsonTextResponse({
@@ -57554,9 +57763,15 @@ ${error.text}`;
       return project.response;
     }
     const projectPath = project.value.path;
+    const typeArgument = TYPE_ARGUMENTS[command];
+    const named = typeArgument === undefined ? "" : readString(contained.value, typeArgument) ?? "";
     const waited = await this.waitForTheEditorOpenedHere(contained.value, []);
     if (this.editorHasOpen(projectPath)) {
-      return await this.handleViaBridge(command, contained.value, askedAs);
+      const answered = await this.handleViaBridge(command, contained.value, askedAs);
+      if (answered.isError === true && declaredButUncached(projectPath, named) !== null) {
+        answered.content.push({ type: "text", text: uncachedClassNote([named]) });
+      }
+      return answered;
     }
     if (effect === "writes") {
       if (waited !== null) {
@@ -57571,12 +57786,22 @@ ${error.text}`;
         ]);
       }
     }
+    const declaring = declaredButUncached(projectPath, named);
+    if (declaring !== null) {
+      const rebuilt = await this.rebuildClassCache(projectPath);
+      if (!rebuilt.ok) {
+        return this.answer(rebuilt);
+      }
+    }
     const outcome = await this.operation("run_editor_tool", { command, arguments: contained.value }, projectPath);
     if (!outcome.ok) {
       return this.answer(outcome);
     }
     return this.jsonTextResponse({
       ...outcome.payload,
+      ...declaring === null ? {} : {
+        classCacheRebuilt: `${named} is declared in ${declaring} and .godot/global_script_class_cache.cfg did not list it, which is where an engine resolves a class name from, so the cache was rebuilt from the declarations on disk before the write.`
+      },
       ...effect === "reads" ? {
         readBy: "a headless engine, since no editor serves this project; unsaved changes in an editor are not seen"
       } : { writtenBy: "a headless engine, since no editor serves this project" },
@@ -57812,7 +58037,7 @@ ${error.text}`;
     if (behind.length > 0) {
       const one = behind.length === 1;
       const scripts = behind.map((entry) => entry.scriptPath);
-      notes.push(`The editor holds ${behind.map((entry) => entry.className).join(", ")} compiled from ${one ? "a text its file no longer has" : "texts their files no longer have"}, so a script it compiles against ${one ? "that class" : "them"} fails on whatever the file has gained, as a member not found or an identifier not declared, while the files are right and a new engine compiles them. editor_rescan with reloadScript on ${scripts.join(", ")} reloads ${one ? "it" : "each"}, and a rescan reloads such a class before a dependent compiled against it.`);
+      notes.push(`The editor holds ${behind.map((entry) => entry.className).join(", ")} compiled from ${one ? "a text its file no longer has" : "texts their files no longer have"}, so a script it compiles against ${one ? "that class" : "them"} fails on whatever the file has gained, as a member not found or an identifier not declared, while the files are right and a new engine compiles them. editor_rescan with reloadScript set to ${one ? scripts[0] : JSON.stringify(scripts)} reloads ${one ? "it" : "each"}, and a rescan reloads such a class before a dependent compiled against it.`);
     }
     return this.jsonTextResponse({
       ...payload,
@@ -58341,7 +58566,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, 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 TYPE_ARGUMENTS, 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, 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();
@@ -58408,6 +58633,11 @@ var init_server = __esm(() => {
   init_tool_definitions();
   init_tool_reference();
   init_update_check();
+  TYPE_ARGUMENTS = {
+    add_node: "nodeType",
+    create_resource: "resourceType",
+    create_scene: "rootNodeType"
+  };
   __dirname2 = dirname25(fileURLToPath5(import.meta.url));
   KEEPER_DEBUG_MS = PAUSE_MS + STEP_MS + 2 * READ_MS;
   LONGEST_BOOT_NOTED_MS = 5 * 60000;
@@ -58513,7 +58743,7 @@ init_alive();
 init_engine_launch();
 init_lsp_client();
 init_process_children();
-import { existsSync as existsSync17, readdirSync as readdirSync10, readFileSync as readFileSync16, unlinkSync as unlinkSync2 } from "node:fs";
+import { existsSync as existsSync17, readdirSync as readdirSync11, readFileSync as readFileSync16, unlinkSync as unlinkSync2 } from "node:fs";
 import { connect as connect2 } from "node:net";
 import { join as join21, resolve as resolve7 } from "node:path";
 var EDITOR_RECORD_PROTOCOL = 1;
@@ -58524,7 +58754,7 @@ function editorRecordsIn(projectPath) {
   const directory = join21(projectPath, ".godot", "gdharness-editors");
   let names;
   try {
-    names = readdirSync10(directory).filter((name) => /^\d+\.json$/.test(name));
+    names = readdirSync11(directory).filter((name) => /^\d+\.json$/.test(name));
   } catch {
     return [];
   }
@@ -58732,7 +58962,7 @@ init_setup();
 init_setup();
 init_tool_definitions();
 init_tool_reference();
-import { existsSync as existsSync19, mkdirSync as mkdirSync7, readdirSync as readdirSync12, rmSync as rmSync10, writeFileSync as writeFileSync11 } from "node:fs";
+import { existsSync as existsSync19, mkdirSync as mkdirSync7, readdirSync as readdirSync13, rmSync as rmSync10, writeFileSync as writeFileSync11 } from "node:fs";
 import { basename as basename8, dirname as dirname10, join as join23 } from "node:path";
 var SKILL_NAME = "gdharness";
 var SHARED_SKILLS = join23(".agents", "skills");
@@ -59016,7 +59246,7 @@ function pruneEmpty(directory, projectPath) {
   const shared = join23(projectPath, ".agents");
   let path = directory;
   while (path !== projectPath && (basename8(path) === "skills" || path === shared)) {
-    if (readdirSync12(path).length > 0) {
+    if (readdirSync13(path).length > 0) {
       return;
     }
     rmSync10(path, { recursive: true, force: true });
@@ -59332,13 +59562,14 @@ init_engine_launch();
 init_engine_leaks();
 init_engine_slots();
 init_import_freshness();
+init_launch();
 init_library_copies();
 init_setup();
 import {
   copyFileSync,
   existsSync as existsSync23,
   mkdirSync as mkdirSync10,
-  readdirSync as readdirSync14,
+  readdirSync as readdirSync15,
   readFileSync as readFileSync23,
   rmSync as rmSync12,
   statSync as statSync14,
@@ -59351,7 +59582,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 readFileSync20, statSync as statSync13 } from "node:fs";
+import { existsSync as existsSync21, readdirSync as readdirSync14, readFileSync as readFileSync20, statSync as statSync13 } from "node:fs";
 import { join as join25, posix as posix2 } from "node:path";
 var RES_LITERAL = /res:\/\/[^"'\s)\]<>]*/g;
 var RELATIVE_LOAD = /\b(?:pre)?load\(\s*["']((?!res:\/\/|uid:\/\/)[^"']+)["']/g;
@@ -59410,7 +59641,7 @@ ${this.read(path).digest}
   addon(root) {
     const hash = createHash6("sha256");
     const walk = (directory, under) => {
-      for (const entry of readdirSync13(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+      for (const entry of readdirSync14(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
         const file = join25(directory, entry.name);
         if (entry.isDirectory()) {
           walk(file, `${under}${entry.name}/`);
@@ -59435,7 +59666,7 @@ ${this.read(path).digest}
       return { digest: "missing", reaches: [], unreadable: null };
     }
     if (statSync13(file).isDirectory()) {
-      const inside = readdirSync13(file, { withFileTypes: true }).filter((entry) => !entry.name.startsWith(".")).map((entry) => `${path.endsWith("/") ? path : `${path}/`}${entry.name}`).sort();
+      const inside = readdirSync14(file, { withFileTypes: true }).filter((entry) => !entry.name.startsWith(".")).map((entry) => `${path.endsWith("/") ? path : `${path}/`}${entry.name}`).sort();
       return { digest: inside.join(`
 `), reaches: inside, unreadable: null };
     }
@@ -59687,7 +59918,7 @@ class RunLogs {
     if (this.kept === null) {
       return;
     }
-    for (const file of readdirSync14(this.directory, { recursive: true, encoding: "utf8" })) {
+    for (const file of readdirSync15(this.directory, { recursive: true, encoding: "utf8" })) {
       if (file.endsWith(".log") && file.split(sep4).length === 2) {
         mkdirSync10(dirname13(join28(this.kept, file)), { recursive: true });
         copyFileSync(join28(this.directory, file), join28(this.kept, file));
@@ -59747,10 +59978,15 @@ async function runTestCommand(options, godotPath) {
     selfTyped: selfTypedExports(scripts.sources),
     godotVersion: options.godotVersion,
     cores: options.cores,
-    verbose: options.verbose
+    verbose: options.verbose,
+    failsOnPushErrors: gdUnitFailsOnPushErrors(options.projectPath)
   };
   try {
-    if (options.importFirst) {
+    const neverImported = cachedClasses(options.projectPath) === null;
+    if (neverImported && !options.importFirst) {
+      console.log("The project has never been imported, so it is imported first.");
+    }
+    if (options.importFirst || neverImported) {
       const imported = await importProject(launch);
       if (imported !== null) {
         logs.keep();
@@ -60014,7 +60250,10 @@ async function runEngine2(launch, plan, index, times, again = "", slot = null) {
 `)}
 `);
   const viewport = viewportOf(launch.projectPath);
-  const display = plan.windowed ? viewport === null ? [] : ["--resolution", `${String(viewport.width)}x${String(viewport.height)}`] : ["--headless"];
+  const display = plan.windowed ? [
+    ...viewport === null ? [] : ["--resolution", `${String(viewport.width)}x${String(viewport.height)}`],
+    ...process14.platform === "win32" ? hiddenWindowFlags([], capsFrames(launch.projectPath)) : []
+  ] : ["--headless"];
   const args = [
     ...display,
     "--audio-driver",
@@ -60059,7 +60298,8 @@ async function runEngine2(launch, plan, index, times, again = "", slot = null) {
     suites: plan.suites,
     expected: readExpected(expectedFile),
     selfTyped: launch.selfTyped,
-    godotVersion: launch.godotVersion
+    godotVersion: launch.godotVersion,
+    failsOnPushErrors: launch.failsOnPushErrors
   };
   const judged = judgeEngine(printed, assignment, end);
   const written = reportsFault(join28(directory, "reports"));
@@ -60076,7 +60316,7 @@ async function runEngine2(launch, plan, index, times, again = "", slot = null) {
 }
 var REPORT_FILES_NAMED = 3;
 function reportsFault(reports) {
-  const files = existsSync23(reports) ? readdirSync14(reports, { recursive: true, encoding: "utf8" }).filter((file) => statSync14(join28(reports, file)).isFile()).sort() : [];
+  const files = existsSync23(reports) ? readdirSync15(reports, { recursive: true, encoding: "utf8" }).filter((file) => statSync14(join28(reports, file)).isFile()).sort() : [];
   if (files.length === 0) {
     return null;
   }