gdharness 1.3.47 → 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,13 +12179,14 @@ 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);
           continue;
         }
-        await changes.next(SLOT_LOOK_MS, SLOT_SETTLE_MS, signal);
+        const sayAt = waiting !== undefined ? said + WAIT_SAID_MS : this.say !== undefined && this.held.size === 0 ? Math.max(began + COMMAND_WAIT_SAID_MS, this.saidAt + WAIT_SAID_MS) : Number.POSITIVE_INFINITY;
+        await changes.next(Math.max(0, Math.min(SLOT_LOOK_MS, sayAt - Date.now())), SLOT_SETTLE_MS, signal);
       }
     } finally {
       changes?.close();
@@ -12122,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);
@@ -12146,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) {
@@ -12169,11 +12268,17 @@ class EngineSlots {
   }
   release(lock) {
     this.held.delete(lock);
-    try {
-      if (holderOf(readFileSync8(lock, "utf8"))?.pid === this.holder.pid) {
-        removeWhole(lock);
-      }
-    } catch {}
+    giveBackSlot(lock, this.holder.pid);
+  }
+  forget(lock) {
+    this.held.delete(lock);
+  }
+  hand(lock, to) {
+    const handed = handSlot(lock, this.holder.pid, to);
+    if (handed) {
+      this.held.delete(lock);
+    }
+    return handed;
   }
   made(path) {
     let made;
@@ -12240,6 +12345,22 @@ class EngineSlots {
     this.starts.set(pid, { started, readAt: Date.now() });
   }
 }
+function handSlot(lock, from, to) {
+  let content;
+  try {
+    content = readWhole(lock);
+  } catch {
+    return false;
+  }
+  return content !== null && holderOf(content)?.pid === from && writeWhole(lock, JSON.stringify(to));
+}
+function giveBackSlot(lock, pid) {
+  try {
+    if (holderOf(readFileSync8(lock, "utf8"))?.pid === pid) {
+      removeWhole(lock);
+    }
+  } catch {}
+}
 function sayWaitsTo(say) {
   saidTo = say;
 }
@@ -12256,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;
@@ -12297,19 +12432,28 @@ 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,
+    from: slots.holder.pid,
     release: () => {
       slots.release(lock);
+    },
+    handTo: (holder) => slots.hand(lock, holder),
+    leave: () => {
+      slots.forget(lock);
     }
   };
 }
@@ -12321,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();
@@ -12332,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() {
@@ -12348,7 +12492,7 @@ function scanDirectoryForGodotBinaries(directory, platform) {
   }
   let entries;
   try {
-    entries = readdirSync4(directory);
+    entries = readdirSync5(directory);
   } catch {
     return [];
   }
@@ -12431,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;
 }
@@ -12475,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);
   }
@@ -12552,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",
@@ -12848,7 +12999,7 @@ class GameLog {
       return;
     }
     const owner = this.lastHeadline[source];
-    if (owner !== null && /^\s/.test(line)) {
+    if (owner !== null && /^\s/.test(line) && !GDUNIT_CASE.test(line)) {
       owner.detail.push(line.trim());
       owner.continues = false;
       return;
@@ -12925,10 +13076,11 @@ function answersTo(entry, severity, contains) {
   const needle = contains.toLowerCase();
   return [entry.text, ...entry.detail].some((line) => line.toLowerCase().includes(needle));
 }
-var HEADLINE, CRASH, CRASH_FILLER, COLOUR_CODE, STREAMS, ADMITTED, LOCATION2, FRAME, LONGEST_CYCLE = 64;
+var HEADLINE, CRASH, GDUNIT_CASE, CRASH_FILLER, COLOUR_CODE, STREAMS, ADMITTED, LOCATION2, FRAME, LONGEST_CYCLE = 64;
 var init_game_log = __esm(() => {
   HEADLINE = /^(USER )?(SCRIPT ERROR|SHADER ERROR|ERROR|WARNING):\s?(.*)$/;
   CRASH = /^(?:CrashHandlerException|handle_crash): Program crashed with signal \d+/;
+  GDUNIT_CASE = /^\s+res:\/\/.+?\.(?:gd|cs) > .+? (?:STARTED|PASSED|FAILED|ERROR|SKIPPED|FLAKY)(?:\s|$)/;
   CRASH_FILLER = /^(?:=+|-- END OF .* BACKTRACE --|\[\d+\] .* - no debug info in .*)$/;
   COLOUR_CODE = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
   STREAMS = ["stdout", "stderr", "transcript"];
@@ -13021,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";
@@ -13047,7 +13199,7 @@ function docCachesWritten(directory) {
   const written = new Map;
   let names;
   try {
-    names = readdirSync5(directory);
+    names = readdirSync6(directory);
   } catch {
     return written;
   }
@@ -13077,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);
@@ -13097,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;
       }
@@ -13144,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;
       }
@@ -13165,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;
       }
@@ -13189,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;
       }
@@ -13261,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;
       }
@@ -13291,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;
       }
@@ -13389,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;
       }
@@ -13469,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;
@@ -13564,7 +13716,7 @@ function staleImports(projectPath) {
     }
     let entries;
     try {
-      entries = readdirSync7(directory, { withFileTypes: true });
+      entries = readdirSync8(directory, { withFileTypes: true });
     } catch {
       return;
     }
@@ -13651,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,
@@ -13676,7 +13828,7 @@ function freeLibraryCopies(projectPath, platform = process.platform) {
     }
     let names;
     try {
-      names = readdirSync8(folder);
+      names = readdirSync9(folder);
     } catch {
       continue;
     }
@@ -13703,7 +13855,7 @@ function seedExtensionList(projectPath) {
     }
     let entries;
     try {
-      entries = readdirSync8(directory, { withFileTypes: true });
+      entries = readdirSync9(directory, { withFileTypes: true });
     } catch {
       return;
     }
@@ -13797,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";
@@ -13807,7 +13959,7 @@ function scratchDirectory(kind) {
 function sweepAbandonedScratch(directory = tmpdir3()) {
   let entries;
   try {
-    entries = readdirSync9(directory);
+    entries = readdirSync10(directory);
   } catch {
     return;
   }
@@ -14225,7 +14377,7 @@ async function operationOutcome(engine, operation, params, projectPath) {
   let ran;
   let answer;
   try {
-    ran = await runEngine(engine.godotPath, args);
+    ran = await runEngine(engine.godotPath, args, { timeout: engine.ceiling ?? OPERATION_CEILING });
     answer = answerIn(answerFile);
   } finally {
     discard(paramsDir);
@@ -14315,7 +14467,7 @@ function answerIn(file) {
     };
   }
 }
-var AFTER_ANSWER_NOTE = "Printed after this operation had written its answer, while the engine ran the project's autoloads and shut down: Godot starts a project's autoloads in every script run and cannot be told not to. An error raised in a project script here is that autoload's own, and none of these changes the answer.", BEFORE_OPERATION_NOTE = "Printed while the engine started the project's autoloads, before this operation ran: an operation that compiles the project's scripts waits for them, because the engine knows an autoload's name only once it is in the tree. An error raised in a project script here is that autoload's own.", OWN_ERROR = "[ERROR] ", ANSWERED = "[gdharness] answered", WAITING = "[gdharness] waiting for the autoloads", BEGUN = "[gdharness] begun", ASIDE = "[gdharness] aside", RESUMED = "[gdharness] resumed", MESSAGES_KEPT = 200, ERRORS_NAMED = 3, NO_BLENDER = "Blender path is invalid or not set", BLENDER_STOPPED = "the import pass stopped at a .blend file and imported nothing: the engine imports .blend files through Blender, which the editor setting filesystem/import/blender/blender_path names, and here it names none. Set it in an editor, or set the project setting filesystem/import/blender/enabled to false with project_settings set, which has the engine leave .blend files unimported.";
+var AFTER_ANSWER_NOTE = "Printed after this operation had written its answer, while the engine ran the project's autoloads and shut down: Godot starts a project's autoloads in every script run and cannot be told not to. An error raised in a project script here is that autoload's own, and none of these changes the answer.", BEFORE_OPERATION_NOTE = "Printed while the engine started the project's autoloads, before this operation ran: an operation that compiles the project's scripts waits for them, because the engine knows an autoload's name only once it is in the tree. An error raised in a project script here is that autoload's own.", OWN_ERROR = "[ERROR] ", ANSWERED = "[gdharness] answered", WAITING = "[gdharness] waiting for the autoloads", BEGUN = "[gdharness] begun", ASIDE = "[gdharness] aside", RESUMED = "[gdharness] resumed", MESSAGES_KEPT = 200, OPERATION_CEILING, ERRORS_NAMED = 3, NO_BLENDER = "Blender path is invalid or not set", BLENDER_STOPPED = "the import pass stopped at a .blend file and imported nothing: the engine imports .blend files through Blender, which the editor setting filesystem/import/blender/blender_path names, and here it names none. Set it in an editor, or set the project setting filesystem/import/blender/enabled to false with project_settings set, which has the engine leave .blend files unimported.";
 var init_headless = __esm(() => {
   init_doc_cache();
   init_engine_leaks();
@@ -14326,6 +14478,7 @@ var init_headless = __esm(() => {
   init_reimport();
   init_scratch();
   init_script_origins();
+  OPERATION_CEILING = { ms: 600000, said: "ten minutes" };
 });
 
 // src/update-check.ts
@@ -16048,7 +16201,7 @@ import {
   cpSync,
   existsSync as existsSync18,
   mkdirSync as mkdirSync6,
-  readdirSync as readdirSync11,
+  readdirSync as readdirSync12,
   readFileSync as readFileSync18,
   rmdirSync,
   rmSync as rmSync9,
@@ -16072,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;
       }
@@ -16171,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;
@@ -16232,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);
   }
@@ -16565,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 = {
@@ -16593,13 +16746,25 @@ var init_tool_definitions = __esm(() => {
         ],
         description: "add_track makes property and method tracks; remove_track takes any type read answers."
       },
-      nodePath: { type: "string", description: "Target node, relative to the AnimationPlayer root." },
+      nodePath: {
+        type: "string",
+        description: "Target node, relative to the AnimationPlayer's root_node, which is the player's parent unless the scene sets it."
+      },
       property: { type: "string", description: "For property tracks: the property to animate." },
       update: {
         type: "string",
         enum: ["continuous", "discrete", "capture"],
         description: "For property tracks: how the value moves between keys. continuous blends toward the next key, so a bool or an int changes halfway to it; discrete holds each key's value until the next; capture blends from the value the property holds when playing starts. Without it a new track is made as the editor makes one: as the RESET animation's track for the same property, otherwise continuous for a float, vector, colour or transform and discrete for anything else. The answer gives the track's update."
       },
+      interpolation: {
+        type: "string",
+        enum: ["nearest", "linear", "cubic", "linear_angle", "cubic_angle"],
+        description: "For property tracks: how a continuous track blends between keys. Without it a new track is made linear, or as the RESET track for the same property is, and an existing track keeps its own."
+      },
+      loopWrap: {
+        type: "boolean",
+        description: "For property tracks: whether a looping animation blends its last key into its first. Without it a new track wraps, or as the RESET track for the same property does, and an existing track keeps its own."
+      },
       method: {
         type: "string",
         description: "For method tracks: the method to call. A method track holds every method key for its node, so a key calling another method joins the node's track, with existingTrack true. The answer's methodFound says whether the target node has it; a method it lacks is still added, while a nodePath that reaches no node is refused, since it may be written next, and until it exists each call the track makes fails. A key whose args the method cannot take (too few or too many, or an object where it takes a value or the reverse) is written too, and answers argumentsFit false with misfit saying why. remove_track: only the keys calling this method."
@@ -16923,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." },
@@ -16957,7 +17122,7 @@ var init_tool_definitions = __esm(() => {
         direction: {
           type: "string",
           enum: ["forward", "reverse"],
-          description: "forward: what this resource loads, with each reference closing a cycle marked circular and the cycle under circular_references, a script's dependencies including every script whose class_name it uses, marked by_class with the name, and the script of every autoload it names, marked by_autoload with the autoload's name. An ext_resource whose uid names another file than its path is followed to that file, as the engine loads it, with the path written under stale_path; one whose uid names no file the project has is followed by its path, as the engine does after warning, with the uid under unknown_uid; and a load or preload of a uid the project does not know is listed under that uid as missing. A shader's #include is followed as the preprocessor reads it, relative to the shader. A file the depth stops at carries beyond_depth, how many files it names that were not walked. A file's dependencies are listed at its first entry, and again further down only where the depth cut that list short and more is left; every other entry for a file naming any carries dependencies_listed_above. summary.total_resources is the file asked about, so 1; total_dependencies counts each file reached, directly or through another, once however many places load it; total_references counts the entries in the tree, and missing names every file referenced that does not exist, with the files referring to it. reverse: every file that refers to it and how, for a file that is gone as well while anything still refers to it, answered with exists: false (a missing file nothing refers to is refused, naming the nearest files), a scene instancing it, a script extending, preloading or loading it, and for a script with a class_name every use of that name, and for an autoload's script every use of the autoload's name, with autoload naming it. Each reference carries a kind: ext_resource, extends, preload, load, include or path for a reference by path, with stale_path when an ext_resource reaches it by its uid under another path, and unknown_uid when one names it by path beside a uid naming no file; setting, plugin, export_preset and import for one in project.godot, a plugin.cfg, export_presets.cfg or an import sidecar; class_name for a use of the declared name, the declaration itself being the script asked about; autoload for code naming the autoload. Three kinds are not uses: doc is a name inside a ## documentation comment, which renaming would break in the generated docs; comment is one in ordinary prose, which it would only make stale; and stale_path is an ext_resource naming it by a path the engine does not load, since its uid leads to the file under loads. summary.in_code is the count with those left out, which is the number to read when the question is whether anything still uses this. Default forward."
+          description: "forward: what this resource loads or names. Each file named by its path carries kind, as reverse words it: ext_resource, extends, preload, load, include, or path for a path only written in a string, which the file itself may never load. Each reference closing a cycle is marked circular, with the cycle under circular_references. A script's dependencies include every script whose class_name it uses, marked by_class with the name, and the script of every autoload it names, marked by_autoload with the autoload's name. An ext_resource whose uid names another file than its path is followed to that file, as the engine loads it, with the path written under stale_path; one whose uid names no file the project has is followed by its path, as the engine does after warning, with the uid under unknown_uid; and a load or preload of a uid the project does not know is listed under that uid as missing. A shader's #include is followed as the preprocessor reads it, relative to the shader. A file the depth stops at carries beyond_depth, how many files it names that were not walked. A file's dependencies are listed at its first entry, and again further down only where the depth cut that list short and more is left; every other entry for a file naming any carries dependencies_listed_above. summary.total_resources is the file asked about, so 1; total_dependencies counts each file reached, directly or through another, once however many places load it; total_references counts the entries in the tree, and missing names every file referenced that does not exist, with the files referring to it. reverse: every file that refers to it and how, for a file that is gone as well while anything still refers to it, answered with exists: false (a missing file nothing refers to is refused, naming the nearest files), a scene instancing it, a script extending, preloading or loading it, and for a script with a class_name every use of that name, and for an autoload's script every use of the autoload's name, with autoload naming it. Each reference carries a kind: ext_resource, extends, preload, load, include or path for a reference by path, with stale_path when an ext_resource reaches it by its uid under another path, and unknown_uid when one names it by path beside a uid naming no file; setting, plugin, export_preset and import for one in project.godot, a plugin.cfg, export_presets.cfg or an import sidecar; class_name for a use of the declared name, the declaration itself being the script asked about; autoload for code naming the autoload. Three kinds are not uses: doc is a name inside a ## documentation comment, which renaming would break in the generated docs; comment is one in ordinary prose, which it would only make stale; and stale_path is an ext_resource naming it by a path the engine does not load, since its uid leads to the file under loads. summary.in_code is the count with those left out, which is the number to read when the question is whether anything still uses this. Default forward."
         },
         depth: {
           type: "integer",
@@ -16992,7 +17157,7 @@ var init_tool_definitions = __esm(() => {
         options: {
           type: "object",
           ops: ["set_options"],
-          description: `set_options: import options keyed as the .import file spells them, {"compress/mode": 1}. A dictionary option whose keys are numbers, a font's opentype_features or any option already holding number keys, takes them written as strings of digits, and opentype_features also takes an OpenType tag by its four-letter name: {"opentype_features": {"liga": 0}} turns ligatures off. Both are written as the numbers the engine reads. One already holding the value given is answered under unchanged_options rather than updated_options, and when none changed nothing is written or reimported. changed gives each option written as {was, now}, was null for one the import file did not hold.`,
+          description: `set_options: import options keyed as the .import file spells them, {"compress/mode": 1}. A dictionary option whose keys are numbers, a font's opentype_features or any option already holding number keys, takes them written as strings of digits, and opentype_features also takes an OpenType tag by its four-letter name: {"opentype_features": {"liga": 0}} turns ligatures off. Both are written as the numbers the engine reads. One already holding the value given is answered under unchanged_options rather than updated_options, and when none changed nothing is written or reimported. changed gives each option written as {was, now}.`,
           additionalProperties: true
         },
         reimport: {
@@ -17032,7 +17197,7 @@ var init_tool_definitions = __esm(() => {
         },
         uid: {
           effect: "read",
-          summary: "the UID of one file and where it was read: a script's or shader's .uid file, an imported file's .import, or a scene's or resource's own header",
+          summary: "the UID of one file and where it was read: a script's or shader's .uid file, an imported file's .import, or a scene's or resource's own header. A file with none is answered with uid null and what would give it one",
           requires: ["resourcePath"]
         },
         refresh_uids: {
@@ -17050,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: {
@@ -17079,7 +17244,7 @@ var init_tool_definitions = __esm(() => {
           type: "string",
           ops: ["set_preset"],
           enum: ["all_resources", "scenes", "resources", "exclude"],
-          description: "set_preset: what the preset exports: every resource, the scenes listed in files and what they use, the resources listed, or every resource but those listed."
+          description: "set_preset: what the preset exports: every resource, the scenes listed in files and what they use, the resources listed, or every resource but those listed. What a scene or a resource uses is what the engine counts as its dependencies, so a file named only in a string, such as a scene path held in an exported property, or a script reached only by its class_name, is left out of the export, though project_dependencies lists both."
         },
         files: {
           type: "array",
@@ -17134,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: {
@@ -17183,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",
@@ -17214,7 +17379,7 @@ var init_tool_definitions = __esm(() => {
       name: "scene_tree",
       title: "Scene tree",
       effect: "read",
-      description: "The nodes of a scene file: names, classes and hierarchy, with properties when asked. A node that instances another scene names that file under instanceOf, and the nodes listed under it come from that file rather than this one; its editableChildren says whether this scene, or a scene it inherits, keeps values of its own for them (scene_node set editableChildren). The root of a scene inheriting another names the scene it inherits under inherits, and every node that scene or one further down makes names its file under inheritedFrom; this file holds only the values it changes on them. A node in any group answers groups, sorted, from this file and every scene it comes from. Needs no editor: one serving the project answers and says whether it holds unsaved changes to the scene, and with none a headless engine reads the file without making its nodes, so no script of theirs runs (autoloads still start once it has answered, as in every headless call). For the nodes of a game that is running, runtime_inspect tree.",
+      description: "The nodes of a scene file: names, classes and hierarchy, with properties when asked. type is the engine class, and a node whose script declares a class_name names it under scriptClass, as scene_node get does. A node that instances another scene names that file under instanceOf, and the nodes listed under it come from that file rather than this one; its editableChildren says whether this scene, or a scene it inherits, keeps values of its own for them (scene_node set editableChildren). The root of a scene inheriting another names the scene it inherits under inherits, and every node that scene or one further down makes names its file under inheritedFrom; this file holds only the values it changes on them. A node in any group answers groups, sorted, from this file and every scene it comes from. Needs no editor: one serving the project answers and says whether it holds unsaved changes to the scene, and with none a headless engine reads the file without making its nodes, so no script of theirs runs (autoloads still start once it has answered, as in every headless call). For the nodes of a game that is running, runtime_inspect tree.",
       parameters: {
         projectPath: PROJECT_PATH,
         scenePath: SCENE_PATH,
@@ -17254,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",
@@ -17657,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: {
@@ -17697,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: {
@@ -17876,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",
@@ -18070,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",
@@ -18225,7 +18391,11 @@ var init_tool_definitions = __esm(() => {
       },
       requires: [],
       operations: {
-        tree: { effect: "read", summary: "the live scene tree", requires: [] },
+        tree: {
+          effect: "read",
+          summary: "the live scene tree, with current_scene giving the path of the scene the game is showing and the file it was loaded from, or null when it shows none",
+          requires: []
+        },
         text: {
           effect: "read",
           summary: "every line of text under nodePath, the values in its fields included, in reading order, leaving out what is hidden and everything under it, and a control drawn wholly outside the viewport or scrolled out of a ScrollContainer, which the player cannot read. Every line reads as drawn: rich text without tags, text only as far as it is typed out, a translation rather than its key, an upper-case label in capitals and a secret field as its mask. Tab titles, menu bar titles, list items, a tree's column titles and rows, and an open menu's items and the titles of its separators read a line each. A line drawn as a copy under a node saying the same words, as an outline or a glow is, reads once, counted under copies",
@@ -18238,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: {
@@ -18279,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",
@@ -18289,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"],
@@ -18635,7 +18805,7 @@ var init_tool_definitions = __esm(() => {
         includeHidden: {
           type: "boolean",
           ops: ["until"],
-          description: "until, with says: count words on a hidden node too, and on one drawn outside the viewport or scrolled out of a ScrollContainer. Default false, since a wait for words is a wait for them to be shown, and a wait that runs out while such a node holds them says so under unseen_note: a button that exists hidden through a whole animation carries its words the whole time and satisfied the wait at once, and every wait on that screen fell back to counting frames."
+          description: "until, with says: count words on a hidden node too, and on one drawn outside the viewport or scrolled out of a ScrollContainer. Default false, since a wait for words is a wait for them to be shown, and a wait that runs out while such a node holds them says so under unseen_note: a button that exists hidden through a whole animation carries its words the whole time and satisfied the wait at once, and every wait on that screen fell back to counting frames. What is drawn over a node is not looked at, so words under a dialog or a panel count either way."
         },
         timeoutMs: {
           type: "integer",
@@ -18711,7 +18881,7 @@ var init_tool_definitions = __esm(() => {
         },
         step_out: {
           effect: "additive",
-          summary: "run to the end of the current function and stop at the next line run at its caller's depth: in its caller, or, when the call was the last thing its caller did, wherever script runs next, such as the caller's next call; a game this server started only",
+          summary: "run to the end of the current function and stop at the next line run at its caller's depth: in its caller, or, when the call was the last thing its caller did, wherever script runs next, such as the caller's next call; only for a game this server started",
           requires: []
         }
       }
@@ -18729,7 +18899,7 @@ var init_tool_definitions = __esm(() => {
         expression: {
           type: "string",
           ops: ["evaluate"],
-          description: "evaluate: a GDScript expression, as Godot's Expression class parses it: members of self by name, locals, autoloads and global classes, operators, indexing and calls, such as wave.spawned[0] or Ledger.entries.size(). An expression that does not parse, or fails as it runs, comes to null, and the game prints why as an error, which editor_output reads for a game this server started. The game reports what an expression raises while it is held inside a runtime_invoke call as raised by that call, and the call's answer says so under errorsNote."
+          description: "evaluate: a GDScript expression, as Godot's Expression class parses it: members of self by name, locals, autoloads and global classes, operators, indexing and calls, such as wave.spawned[0] or Ledger.entries.size(). An expression that does not parse, or fails as it runs, comes to null with failed saying why, as the engine words it, and a null with no failed is the value; for a game the editor plays, the reason reaches only the editor's Debugger panel, so a null there carries a note saying it may be either. The game reports what an expression raises while it is held inside a runtime_invoke call as raised by that call, and the call's answer says so under errorsNote."
         }
       },
       requires: [],
@@ -19330,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)) {
@@ -40993,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";
@@ -41169,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));
@@ -42562,6 +42747,7 @@ async function handleDAPTool(client, toolName, args) {
         const frameId = typeof safeArgs.frameId === "number" ? safeArgs.frameId : undefined;
         const expression = typeof safeArgs.expression === "string" ? safeArgs.expression : "";
         const evaluated = await client.evaluate(expression, frameId);
+        const nil = evaluated.type === "Nil" || evaluated.value === "null" || evaluated.value === "<null>";
         return {
           content: [
             {
@@ -42570,7 +42756,10 @@ async function handleDAPTool(client, toolName, args) {
                 frame: evaluated.frame,
                 expression,
                 value: evaluated.value,
-                ...evaluated.type === undefined ? {} : { type: evaluated.type }
+                ...evaluated.type === undefined ? {} : { type: evaluated.type },
+                ...nil ? {
+                  note: "null is also what an expression comes to when it does not parse or fails as it runs. For a game the editor plays, why reaches only the editor's Debugger panel, so this cannot say which it was."
+                } : {}
               })
             }
           ]
@@ -43507,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
+            });
+          }
         }
       }
     }
@@ -43656,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));
@@ -43906,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);
@@ -43990,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(`
@@ -44007,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,
@@ -44014,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);
+        })()
       }))
     };
   });
@@ -44027,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;
@@ -44057,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;
     }
   }
@@ -44114,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 = {};
@@ -44136,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();
@@ -44159,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,
@@ -44167,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];
   });
@@ -44210,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;
       }
@@ -44338,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]) => {
@@ -48522,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");
@@ -48627,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;
     }
@@ -48892,7 +49116,7 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
   ]));
   let entries;
   try {
-    entries = readdirSync18(directory);
+    entries = readdirSync19(directory);
   } catch {
     return;
   }
@@ -49314,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,
@@ -49518,6 +49742,13 @@ function restartsOf(run) {
     endedAt: new Date(one.endedAt).toISOString()
   }));
 }
+async function handToTheGame(slot, pid, projectPath) {
+  const started = (await startTimesOf([pid])).get(pid);
+  const by = `a game${projectPath === null ? "" : ` of ${projectPath}`} the editor played for editor_run`;
+  if (started === undefined || !slot.handTo({ pid, started, by })) {
+    slot.release();
+  }
+}
 function followTheRestart(run) {
   if (run.throughEditor || run.pid === null || run.projectPath === null) {
     return false;
@@ -50044,6 +50275,13 @@ function presetsIn(projectPath) {
 function presetPlatform(projectPath, preset) {
   return presetsIn(projectPath)?.find((held) => held.name === preset)?.platform ?? null;
 }
+function engineEndSaid(ending) {
+  if (ending.failure === null && ending.exitSignal === null) {
+    return `the engine ended with ${exitCodeText(ending.exitCode)}`;
+  }
+  const how = howItEnded(ending);
+  return how.startsWith("ended by") ? `the engine was ${how}` : how;
+}
 function exportPresetRefusal(projectPath, preset) {
   const presets = presetsIn(projectPath);
   if (presets === null) {
@@ -50055,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);
@@ -50067,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,
@@ -50078,7 +50317,24 @@ function exportAnswer(ending, asked, before, after, beside = [], docCacheNote =
   if (verdict.exported) {
     return { content: [{ type: "text", text: answerJson(verdict) }] };
   }
-  const stale = !written && after !== null ? ` The ${asked.outputPath} there is from before this export, which did not write it.` : "";
+  if (written) {
+    const errors = log.count("error");
+    const because = [
+      ...ending.exitCode === 0 && ending.failure === null && ending.exitSignal === null ? [] : [engineEndSaid(ending)],
+      ...errors === 0 ? [] : [`it printed ${String(errors)} ${errors === 1 ? "error" : "errors"}, under entries`]
+    ];
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Export with preset '${asked.preset}' wrote ${asked.outputPath}, but it is not counted as exported, as ${because.join(" and ")}.`
+        },
+        { type: "text", text: answerJson(verdict) }
+      ],
+      isError: true
+    };
+  }
+  const stale = after === null ? "" : ` The ${asked.outputPath} there is from before this export, which did not write it.`;
   const why = ending.exitSignal === null ? stale : ` The engine was ${howItEnded(ending)}, so it has no exit code.${stale}`;
   return {
     content: [
@@ -50097,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);
       }
@@ -50689,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 "";
   }
@@ -50833,6 +51089,20 @@ 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 "";
+  }
+  const unheld = Object.entries(changed).filter(([, change]) => isPlainObject3(change) && change["was"] === null).map(([name]) => name);
+  if (unheld.length === 0) {
+    return "";
+  }
+  const one = unheld.length === 1;
+  return ` ${unheld.join(", ")} ${one ? "was" : "were"} not in the import file before, so only that reimport can tell whether the importer has ${one ? "it" : "them"}: one it lacks is dropped from the file then, and the reimport through set_options says which.`;
+}
 
 class GodotServer {
   stdio = null;
@@ -52464,7 +52734,7 @@ class GodotServer {
         ...written,
         payload: {
           ...written.payload,
-          note: "Not reimported: the editor imports it with these options on its next scan, or project_import reimport does now."
+          note: `Not reimported: the editor imports it with these options on its next scan, or project_import reimport does now.${unheldNote(written.payload["changed"])}`
         }
       } : written);
     }
@@ -52825,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))) {
@@ -53044,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();
@@ -53316,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"));
@@ -53589,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}`,
@@ -53732,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) {
@@ -54945,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"
@@ -55131,17 +55404,20 @@ ${error.text}`;
     const sendingFrom = Date.now();
     const breakpoints = await this.dapHoldingBreakpointsOf(projectPath).reapplyBreakpoints();
     this.logDebug(`Breakpoints were sent again after ${Date.now() - sendingFrom}ms`);
+    const slot = await slotForCall();
     if (profiled) {
       const armed = await this.handleViaBridge("profile_start", {
         arm: true,
         frameFunctions: profileFrameFunctions(projectPath)
       });
       if (armed.isError === true) {
+        slot.release();
         return armed;
       }
     }
     const answer = await this.handleViaBridge("play_scene", scene === null ? {} : { scenePath: `res://${scene}` });
     if (answer.isError === true) {
+      slot.release();
       return answer;
     }
     const startedAt = Date.now();
@@ -55171,7 +55447,8 @@ ${error.text}`;
       announcedBefore: alreadyPlaying,
       seenPlaying: readBoolean(playAnswer, "playing") === true,
       ...which === null ? {} : { play: which },
-      bootScene: runtimeWaitMs.scene
+      bootScene: runtimeWaitMs.scene,
+      slot
     };
     this.activeProcess = played;
     this.noteTheLatestRun({ projectPath, pid: null, startedAt });
@@ -55187,6 +55464,11 @@ ${error.text}`;
     sweepTranscripts();
     step("sweep");
     this.logDebug(`After the play: ${steps.join(", ")}`);
+    const runtime = await this.runtimeUp(projectPath, alreadyPlaying, runtimeWaitMs, false);
+    if (played.slot !== undefined) {
+      played.slot.release();
+      delete played.slot;
+    }
     return this.jsonTextResponse({
       started: true,
       through: "editor",
@@ -55203,7 +55485,7 @@ ${error.text}`;
         scriptPath: projectSpelling(projectPath, one.scriptPath),
         reason: one.reason
       })),
-      runtime: await this.runtimeUp(projectPath, alreadyPlaying, runtimeWaitMs, false),
+      runtime,
       message: "The editor is playing it, so its debugger holds it: the debug_* tools can reach it, " + "editor_output reads its console through the debug adapter and the runtime's report of it, and editor_run stop ends it." + endedToStartThis(ended)
     });
   }
@@ -55359,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";
@@ -55584,20 +55872,33 @@ ${error.text}`;
     closeSync5(transcript.fd);
     const gameEnv = profiled ? { ...env ?? process.env, [PROFILE_FROM_START]: "1" } : env;
     const profile = profiled ? profilePath(startedAt) : undefined;
-    const launched = await launchOutsideTheTree({
-      command: godotPath,
-      args: cmdArgs,
-      ...gameEnv === undefined ? {} : { env: gameEnv },
-      run: {
-        transcript: transcript.path,
-        startedAt,
-        projectPath,
-        ...this.servedBy(),
-        ...profile === undefined ? {} : { profile },
-        ...debugged ? { breakpoints: this.breakpointsForAGame(projectPath) } : { debugged: false }
-      },
-      ...desktop === undefined ? {} : { desktop }
-    });
+    const slot = await slotForCall();
+    let launched;
+    try {
+      launched = await launchOutsideTheTree({
+        command: godotPath,
+        args: cmdArgs,
+        ...gameEnv === undefined ? {} : { env: gameEnv },
+        run: {
+          transcript: transcript.path,
+          startedAt,
+          projectPath,
+          ...this.servedBy(),
+          ...profile === undefined ? {} : { profile },
+          ...debugged ? { breakpoints: this.breakpointsForAGame(projectPath) } : { debugged: false },
+          slot: { lock: slot.lock, from: slot.from, by: `a game of ${projectPath} editor_run started` }
+        },
+        ...desktop === undefined ? {} : { desktop }
+      });
+    } catch (error) {
+      slot.release();
+      throw error;
+    }
+    if ("error" in launched) {
+      slot.release();
+    } else {
+      slot.leave();
+    }
     if ("error" in launched) {
       return launched;
     }
@@ -55819,6 +56120,11 @@ ${error.text}`;
   tie(run, endpoint) {
     run.announcedPid = endpoint.pid;
     this.noteBootOf(run, endpoint);
+    const slot = run.slot;
+    if (slot !== undefined) {
+      delete run.slot;
+      handToTheGame(slot, endpoint.pid, run.projectPath);
+    }
   }
   playedByOurEditor(endpoint) {
     const editor = this.godotBridge.getStatus().editorPid;
@@ -56782,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);
@@ -56887,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,
@@ -56906,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,
@@ -56920,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) {
@@ -57251,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({
@@ -57434,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) {
@@ -57451,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" },
@@ -57692,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,
@@ -58221,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();
@@ -58288,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;
@@ -58393,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;
@@ -58404,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 [];
   }
@@ -58612,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");
@@ -58896,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 });
@@ -59212,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,
@@ -59231,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;
@@ -59290,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}/`);
@@ -59315,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 };
     }
@@ -59567,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));
@@ -59627,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();
@@ -59894,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",
@@ -59939,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"));
@@ -59956,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;
   }