gdharness 1.1.6 → 1.1.8

package/build/cli.js

@@ -385,10 +385,10 @@ function runArguments(options) {
   }
   return args;
 }
-function editorArguments(projectPath, ports, logFile) {
+function editorArguments(projectPath, ports, logFile, hidden) {
   return [
     "-e",
-    "--headless",
+    ...hidden ? ["--headless"] : [],
     "--path",
     projectPath,
     "--lsp-port",
@@ -7836,6 +7836,30 @@ function cachedClasses(projectPath) {
   }
   return listed;
 }
+function withAddonClassesCounted(rebuilt, listed) {
+  const counted = { ...rebuilt };
+  for (const key of ["added", "changed"]) {
+    const names = rebuilt[key];
+    if (!Array.isArray(names)) {
+      continue;
+    }
+    const own = [];
+    const perAddon = {};
+    for (const name of names) {
+      const addon = /^res:\/\/addons\/([^/]+)\//.exec(listed.get(String(name)) ?? "")?.[1];
+      if (addon === undefined) {
+        own.push(name);
+      } else {
+        perAddon[addon] = (perAddon[addon] ?? 0) + 1;
+      }
+    }
+    if (Object.keys(perAddon).length > 0) {
+      counted[key] = own;
+      counted[`${key}InAddons`] = perAddon;
+    }
+  }
+  return counted;
+}
 function missingMemberIn(message) {
   const found = /The (method|property) "([^"(]+)(?:\(\))?" is not present on the inferred type "([^"]+)"/.exec(message);
   if (found === null) {
@@ -16044,7 +16068,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "project_test",
-      description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Suites where everything passed are counted rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines. The class list is rebuilt first, so a suite written a moment ago is found, and the rebuild's answer is under classes: a class it 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. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. On macOS the engine reads user:// off HOME and the run writes where the player keeps theirs, which the answer says under savesNote rather than leaving to be found in a save list. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. A run where nothing failed but nodes were left in the tree 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. Needs gdUnit4 under addons/gdUnit4.",
+      description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Suites where everything passed are counted rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines. The class list is rebuilt first, so a suite written a moment ago is found, and the rebuild's answer is under classes, with the classes each addon declares counted under addedInAddons and changedInAddons rather than named: a class it 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. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. On macOS the engine reads user:// off HOME and the run writes where the player keeps theirs, which the answer says under savesNote rather than leaving to be found in a save list. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. A run where nothing failed but nodes were left in the tree 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. Needs gdUnit4 under addons/gdUnit4.",
       parameters: {
         projectPath: PROJECT_PATH,
         path: {
@@ -16063,7 +16087,7 @@ var init_tool_definitions = __esm(() => {
         timeoutMs: {
           type: "integer",
           minimum: 1,
-          description: "How long the run may take before it is killed. Default 600000."
+          description: "How long the run may take before it is killed. Default 600000. A run killed at the limit answers timedOut and silentForMs, how long it had printed nothing; it is called hung only when that was half the limit, or thirty seconds of a longer one, and otherwise it was still running and wants a longer timeoutMs or a narrower path."
         }
       },
       requires: ["projectPath"]
@@ -16312,8 +16336,15 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "editor_launch",
-      description: "Opens the Godot editor on a project, or restarts the one already connected. An editor this opens is headless: it shows no window and takes no focus, and it serves the bridge, the language server, the debug adapter and the games it plays as a windowed one does. An editor goes on serving the addon it read at startup, so restart is what puts a gdharness upgrade into effect; it saves open scenes on the way out and answers with the version that came back. An editor a server opened is started again by the server, headless as before. One opened by hand restarts itself, which only one with a window can do, because the engine hands back none of the arguments it was started with. editor_status says which editor is connected and whether it is holding an old addon. Opening a project is a save and so is closing one, which is the part that is not obvious from outside: the editor imports the project on open and writes project.godot back, and Godot writes only what differs from its own defaults, so a key named deliberately at its default value is dropped either way. A restart says which under settingsDropped in its own answer because it waits for the editor to return. An open cannot, since it answers as soon as the process exists and the save happens during the import minutes later, so editor_status carries that reading once the editor has connected. Nothing else will say a key went until something depends on one. A restart of an editor this server opened is a quit and then a launch, and this server can be ended between them, usually by the reconnect the restart was being taken for: the editor is gone and nothing replaces it. That is written down before the quit, so the next server says so under restartInterrupted in editor_status rather than waiting for an editor that is not coming, and open finishes it, saying so under finishesRestart.",
-      parameters: { projectPath: { ...PROJECT_PATH, ops: ["open"] } },
+      description: "Opens the Godot editor on a project, or restarts the one already connected. The editor is an ordinary visible one on the desktop in use, and on Windows it is shown without being activated, so opening or reopening it does not take the keyboard from whatever the user is typing in. hidden: true opens it headless instead and, on Windows, on a desktop of its own, where the games it plays go too; a hidden editor serves the bridge, the language server and the debug adapter as a visible one does. A game a visible editor plays opens as a window on the desktop in use. An editor goes on serving the addon it read at startup, so restart is what puts a gdharness upgrade into effect, and nothing else here restarts one; it saves open scenes on the way out and answers with the version that came back. An editor a server opened is started again by the server, visible unless hidden: true is passed again. One opened by hand restarts itself, which only one with a window can do, because the engine hands back none of the arguments it was started with. editor_status says which editor is connected and whether it is holding an old addon. Opening a project is a save and so is closing one, which is the part that is not obvious from outside: the editor imports the project on open and writes project.godot back, and Godot writes only what differs from its own defaults, so a key named deliberately at its default value is dropped either way. A restart says which under settingsDropped in its own answer because it waits for the editor to return. An open cannot, since it answers as soon as the process exists and the save happens during the import minutes later, so editor_status carries that reading once the editor has connected. Nothing else will say a key went until something depends on one. A restart of an editor this server opened is a quit and then a launch, and this server can be ended between them, usually by the reconnect the restart was being taken for: the editor is gone and nothing replaces it. That is written down before the quit, so the next server says so under restartInterrupted in editor_status rather than waiting for an editor that is not coming, and open finishes it, saying so under finishesRestart.",
+      parameters: {
+        projectPath: { ...PROJECT_PATH, ops: ["open"] },
+        hidden: {
+          type: "boolean",
+          ops: ["open", "restart"],
+          description: "Open the editor headless and, on Windows, on a desktop of its own, so no window of it or of the games it plays appears. Default false: one visible editor, shown without taking the focus."
+        }
+      },
       requires: [],
       operations: {
         open: { summary: "open the editor on a project", requires: ["projectPath"] },
@@ -16341,7 +16372,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. A game the editor plays goes there too, since an editor this server opens is on that 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. 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."
         },
         savesIn: {
           type: "string",
@@ -37107,6 +37138,26 @@ function whyNoReport(printed, asked) {
   }
   return printed.some((line) => NOTHING_RAN.test(line)) ? `no test cases found at ${asked}` : null;
 }
+function scriptErrorsPrinted(printed) {
+  const start = printed.findIndex((line) => line.includes(DISCOVERY_FAILED));
+  if (start < 0) {
+    return [];
+  }
+  const found = [];
+  let message = null;
+  for (const line of printed.slice(start + 1)) {
+    const at = /^\s*at (res:\/\/.+):(\d+)\s*$/.exec(line);
+    if (at !== null && message !== null) {
+      found.push({ path: at[1] ?? "", line: Number(at[2]), message });
+      message = null;
+    } else if (at === null && message === null && /^ {2}\S/.test(line)) {
+      message = line.trim();
+    } else {
+      break;
+    }
+  }
+  return found.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : a.line - b.line);
+}
 function unspelled(text) {
   return text.replace(/<(?:LF|CR|TAB|BS|FF|VT|BEL|ESC|DEL|0x[0-9A-F]{2})>/g, (spelling) => spelling.startsWith("<0x") ? String.fromCharCode(Number.parseInt(spelling.slice(3, 5), 16)) : SPELLED[spelling] ?? spelling);
 }
@@ -37140,7 +37191,8 @@ function withActualsPrinted(failed, printed) {
   const diffs = [...printed.replaceAll(`\r
 `, `
 `).matchAll(PRINTED_ACTUAL)].map((match) => ({
-    at: match[3] ?? "",
+    suffix: match[3] ?? "",
+    at: match[5] ?? "",
     ...readDiff(match[1] ?? "")
   }));
   return failed.map((entry) => {
@@ -37148,24 +37200,37 @@ function withActualsPrinted(failed, printed) {
       return entry;
     }
     let detail = entry.detail;
+    let recovered = false;
     for (const diff of diffs) {
       const wrong = ` but was
- '${diff.merged.replaceAll("\r", "")}'
+ '${diff.merged.replaceAll("\r", "")}'${diff.suffix}
 	at ${diff.at}`;
       if (detail.includes(wrong)) {
         detail = detail.replace(wrong, () => ` but was
- '${diff.actual}'
+ '${diff.actual}'${diff.suffix}
 	at ${diff.at}`);
+        recovered = true;
       }
     }
-    const alike = /Expecting:\n '([\s\S]*)'\n but was\n '\1'\n\tat /.test(detail);
-    if (alike) {
-      detail = `${detail}
-${BOTH_SIDES_ALIKE_NOTE}`;
+    const quoted = QUOTED_EQUALITY.exec(detail);
+    if (quoted !== null) {
+      const alike = quoted[1] === quoted[2];
+      const note = recovered ? alike ? RENDERED_AWAY_NOTE : null : alike ? BOTH_SIDES_ALIKE_NOTE : VALUE_NOT_RECOVERED_NOTE;
+      detail = note === null ? detail : `${detail}
+${note}`;
+    }
+    if (quoted !== null && masked(quoted[1] ?? "", quoted[2] ?? "")) {
+      const end = quoted[0].length - `
+	at `.length;
+      detail = detail.slice(0, end).replaceAll(MASKED_BRACKET, "[") + detail.slice(end);
     }
     return detail === entry.detail ? entry : { ...entry, detail };
   });
 }
+function masked(expected, actual) {
+  const allSpelled = (value) => !PRINTED_DICTIONARY.test(value) && value.split("[").length === value.split(MASKED_BRACKET).length;
+  return `${expected}${actual}`.includes(MASKED_BRACKET) && allSpelled(expected) && allSpelled(actual);
+}
 function orphansPrinted(printed) {
   const suites = [];
   let total = null;
@@ -37196,7 +37261,7 @@ function orphansPrinted(printed) {
     suites
   };
 }
-var MalformedReportError, ENTITIES, ATTRIBUTE, NOTHING_RAN, NO_SUCH_PATH, ESCAPE, PRINTED_ACTUAL, COLOUR2, SPELLED, BOTH_SIDES_ALIKE_NOTE = "[gdharness: the expected and the actual printed alike because gdUnit4 drops the marks that tell them apart when it writes its report, and the runner printed no copy of this one, so neither side above is the value the assertion found.]", RUNNING_SUITE, ORPHANS, OVERALL = "Overall Summary";
+var MalformedReportError, ENTITIES, ATTRIBUTE, NOTHING_RAN, NO_SUCH_PATH, DISCOVERY_FAILED = "Script errors were detected during test discovery!", ESCAPE, LOCATION = `'[^'\\n]*' in \\S+:\\d+`, IGNORING_CASE = " \\(ignoring case\\)", PRINTED_ACTUAL, QUOTED_EQUALITY, COLOUR2, SPELLED, BOTH_SIDES_ALIKE_NOTE = "[gdharness: the expected and the actual printed alike because gdUnit4 drops the marks that tell them apart when it writes its report, and the runner printed no copy of this one, so neither side above is the value the assertion found.]", VALUE_NOT_RECOVERED_NOTE = '[gdharness: the value after "but was" may not be the one the assertion found. gdUnit4 writes a failing string into its report as a character diff against the expected one with the marks dropped, which merges the two, and the runner printed no copy of this one to read the value back from.]', RENDERED_AWAY_NOTE = '[gdharness: the two sides print alike, so what tells them apart is something gdUnit4 does not print. The usual cause is BBCode in the expected string, which gdUnit4 renders as formatting instead of showing; the value after "but was" is the one the assertion found.]', MASKED_BRACKET = "[lb]", PRINTED_DICTIONARY, RUNNING_SUITE, ORPHANS, OVERALL = "Overall Summary";
 var init_junit = __esm(() => {
   MalformedReportError = class MalformedReportError extends Error {
     constructor(message) {
@@ -37209,7 +37274,8 @@ var init_junit = __esm(() => {
   NOTHING_RAN = /no test cases found/i;
   NO_SUCH_PATH = /given directory or file does not exists:\s*(\S+)/i;
   ESCAPE = String.fromCharCode(27);
-  PRINTED_ACTUAL = new RegExp(` but was\\n '([\\s\\S]*?)'((?:${ESCAPE}\\[[0-9;]*m)*)\\tat ('[^'\\n]*' in \\S+:\\d+)`, "g");
+  PRINTED_ACTUAL = new RegExp(` but was\\n '((?:(?!\\tat ${LOCATION})[\\s\\S])*?)'((?:${ESCAPE}\\[[0-9;]*m)*)(${IGNORING_CASE})?((?:${ESCAPE}\\[[0-9;]*m)*)\\tat (${LOCATION})`, "g");
+  QUOTED_EQUALITY = new RegExp(`^Expecting(?: error message)?:\\n '([\\s\\S]*)'\\n but was\\n '([\\s\\S]*)'(?:${IGNORING_CASE})?\\n\\tat `);
   COLOUR2 = new RegExp(`${ESCAPE}\\[([0-9;]*)m`, "g");
   SPELLED = {
     "<LF>": `
@@ -37223,6 +37289,7 @@ var init_junit = __esm(() => {
     "<ESC>": ESCAPE,
     "<DEL>": ""
   };
+  PRINTED_DICTIONARY = /^\{\n\t[\s\S]*\n {2}\}$/;
   RUNNING_SUITE = /Run Test Suite:\s*(\S+)/;
   ORPHANS = /(\d+)\s+orphans/;
 });
@@ -37807,7 +37874,8 @@ async function launchOutsideTheTree(spec, runtime = process.execPath, keeper = K
       args: spec.args,
       envChanges: changesFrom(spec.env, process.env),
       ...spec.run === undefined ? {} : { run: spec.run },
-      ...spec.desktop === undefined ? {} : { desktop: spec.desktop }
+      ...spec.desktop === undefined ? {} : { desktop: spec.desktop },
+      ...spec.noActivate === true ? { noActivate: true } : {}
     });
     let printed = "";
     let complained = "";
@@ -38818,6 +38886,27 @@ function changedSettings(before, after) {
   const names = new Set([...before.keys(), ...after.keys()]);
   return [...names].filter((name) => JSON.stringify(before.get(name)) !== JSON.stringify(after.get(name))).sort();
 }
+function scriptErrorsNote(errors) {
+  const first = new Map;
+  for (const error of errors) {
+    if (!first.has(error.path)) {
+      first.set(error.path, error);
+    }
+  }
+  const scripts = [...first.values()].map((error) => `${error.path}:${error.line} ${error.message}${error.message.endsWith(".") ? "" : "."}`).join(" ");
+  const more = errors.length - first.size;
+  return `No tests ran: gdUnit4 could not load ${first.size === 1 ? "one script" : `${first.size} scripts`} while looking for suites, and it runs no suite at all when one fails to load. ${scripts}${more > 0 ? ` ${more === 1 ? "One more error" : `${more} more errors`} in ${first.size === 1 ? "that script" : "those scripts"} ${more === 1 ? "is" : "are"} under scriptErrors.` : ""}`;
+}
+function timedOutVerdict(timeoutMs, silentForMs) {
+  const quiet = Math.round(silentForMs);
+  return quiet >= Math.min(STALLED_AFTER_MS, timeoutMs / 2) ? {
+    verdict: `hung: killed after ${timeoutMs} ms, having printed nothing for the last ${quiet} ms`,
+    hung: true
+  } : {
+    verdict: `timed out after ${timeoutMs} ms while still running: it last printed ${quiet} ms before it was killed, so pass a longer timeoutMs or a narrower path`,
+    hung: false
+  };
+}
 function importStatuses(payload) {
   const listed = payload["resources"];
   if (!Array.isArray(listed)) {
@@ -39196,9 +39285,12 @@ class GodotServer {
     try {
       return await this.dispatch(tool, op, args);
     } catch (error) {
-      if (error instanceof McpError || error instanceof Refusal) {
+      if (error instanceof McpError) {
         throw error;
       }
+      if (error instanceof Refusal) {
+        return this.createErrorResponse(error.message);
+      }
       const where = op === "" ? tool : `${tool} op=${op}`;
       console.error(`[SERVER] Unmodelled failure in ${where}:`, error);
       const seenBefore = this.defectsSeen.before(where, errorMessage(error));
@@ -39478,7 +39570,7 @@ class GodotServer {
             return await bridge("set_theme_font_size", { themePath: args["resourcePath"] });
         }
       case "editor_launch":
-        return op === "restart" ? await this.handleRestartEditor() : await this.handleLaunchEditor(args);
+        return op === "restart" ? await this.handleRestartEditor(args) : await this.handleLaunchEditor(args);
       case "editor_run":
         if (op === "stop") {
           return await this.handleStopProject(args);
@@ -40329,11 +40421,18 @@ class GodotServer {
     const userData = mkdtempSync3(join24(tmpdir5(), "gdharness-tests-"));
     const run = this.spawnGame(engine.value, cmdArgs, userDataIn(userData));
     const console2 = [];
+    let lastSaid = Date.now();
     run.process.stdout?.on("data", (data) => {
       console2.push(data);
+      lastSaid = Date.now();
     });
-    const hung = await new Promise((resolve) => {
+    run.process.stderr?.on("data", () => {
+      lastSaid = Date.now();
+    });
+    let silentForMs = 0;
+    const timedOut = await new Promise((resolve) => {
       const timer = setTimeout(() => {
+        silentForMs = Date.now() - lastSaid;
         run.process.kill();
         resolve(true);
       }, timeoutMs);
@@ -40375,11 +40474,15 @@ class GodotServer {
     const exitCode = run.exitCode;
     const printed = run.log.select({ severity: "info", sinceLastCall: false, limit: 200 }).entries;
     const said = printed.map((entry) => entry.text);
-    const nothingRan = hung ? null : whyNoReport(said, asked);
-    const verdict = hung ? `hung: killed after ${timeoutMs} ms` : nothingRan ?? (exitCode === null ? undefined : verdicts[exitCode]) ?? (run.exitSignal === null ? `exit ${exitCode ?? "unknown"}` : howItExited(run));
+    const nothingRan = timedOut ? null : whyNoReport(said, asked);
+    const cutShort = timedOut ? timedOutVerdict(timeoutMs, silentForMs) : null;
+    const hung = cutShort?.hung ?? false;
+    const scriptErrors = timedOut || exitCode !== 105 ? [] : scriptErrorsPrinted(said);
+    const brokenScripts = new Set(scriptErrors.map((error) => error.path)).size;
+    const verdict = cutShort !== null ? cutShort.verdict : nothingRan ?? (brokenScripts > 0 ? `script errors in ${brokenScripts === 1 ? "one script" : `${brokenScripts} scripts`}, so no suite ran` : undefined) ?? (exitCode === null ? undefined : verdicts[exitCode]) ?? (run.exitSignal === null ? `exit ${exitCode ?? "unknown"}` : howItExited(run));
     const savesNote = savesStayPut() && nothingRan === null ? SAVES_NOT_MOVED_NOTE : undefined;
     if (report === null) {
-      const note = nothingRan === null ? `The test run wrote no report (${verdict}${reportProblem ? `; ${reportProblem}` : ""}).` : `No tests ran: ${verdict}.${elsewhereIn(project.value.path, asked)}`;
+      const note = nothingRan !== null ? `No tests ran: ${verdict}.${elsewhereIn(project.value.path, asked)}` : scriptErrors.length > 0 ? scriptErrorsNote(scriptErrors) : `The test run wrote no report (${verdict}${reportProblem ? `; ${reportProblem}` : ""}).`;
       return {
         content: [
           { type: "text", text: note },
@@ -40392,8 +40495,10 @@ class GodotServer {
               exitCode,
               exitSignal: run.exitSignal ?? undefined,
               hung,
+              ...timedOut ? { timedOut, silentForMs } : {},
+              ...scriptErrors.length > 0 ? { scriptErrors } : {},
               arguments: cmdArgs,
-              entries: forAnswer(printed.slice(0, 60)),
+              entries: forAnswer(printed.slice(0, 60).map(aboveTheRunner)),
               savesNote,
               ...scanned
             }, null, 2)
@@ -40416,8 +40521,9 @@ class GodotServer {
     const unclean = report.suites.filter((suite) => suite.failures > 0 || suite.errors > 0 || suite.skipped > 0 || orphansIn(suite.path) > 0);
     const notRun = report.suites.reduce((sum, suite) => sum + Math.max(0, suite.discovered - suite.tests), 0);
     return this.jsonTextResponse({
-      passed: !hung && exitCode === 0 && report.failures === 0 && report.errors === 0,
+      passed: !timedOut && exitCode === 0 && report.failures === 0 && report.errors === 0,
       verdict,
+      ...timedOut ? { timedOut, hung, silentForMs } : {},
       exitCode,
       exitSignal: run.exitSignal ?? undefined,
       tests: report.tests,
@@ -40447,7 +40553,7 @@ class GodotServer {
       engineErrors: run.log.count("error"),
       engineWarnings: run.log.count("warning"),
       engineEntries,
-      classes: classes.payload
+      classes: withAddonClassesCounted(classes.payload, cachedClasses(project.value.path) ?? new Map)
     });
   }
   async godotVersion(godotPath) {
@@ -40828,7 +40934,7 @@ class GodotServer {
       return null;
     }
   }
-  async handleRestartEditor() {
+  async handleRestartEditor(args) {
     const before = this.godotBridge.getStatus();
     if (!before.connected) {
       return this.createErrorResponse("No editor is connected, so there is nothing to restart.", [
@@ -40838,7 +40944,7 @@ class GodotServer {
     }
     const settingsBefore = this.settingKeysOf(before.projectPath);
     const mine = before.openedByAServer === true && before.projectPath !== undefined;
-    const asked = mine ? await this.startItAgain(before.projectPath ?? "", before.editorPid) : await this.handleViaBridge("restart_editor", {});
+    const asked = mine ? await this.startItAgain(before.projectPath ?? "", before.editorPid, args["hidden"] === true) : await this.handleViaBridge("restart_editor", {});
     if (asked.isError === true) {
       return asked;
     }
@@ -40876,7 +40982,7 @@ class GodotServer {
   whatTheEditorDropped(before, after) {
     return settingsDroppedReport(before, after);
   }
-  async startItAgain(projectPath, editorPid) {
+  async startItAgain(projectPath, editorPid, hidden) {
     const engine = await this.engine();
     if (!engine.ok) {
       return engine.response;
@@ -40898,7 +41004,7 @@ class GodotServer {
       return asked;
     }
     await this.waitForBridge(() => !alive(editorPid), Date.now() + EDITOR_RESTART_TIMEOUT_MS);
-    const opened = await this.openAnEditor(engine.value, projectPath, ports);
+    const opened = await this.openAnEditor(engine.value, projectPath, ports, hidden);
     restartSettled(projectPath);
     if (opened.error !== null) {
       return this.createErrorResponse(`The editor was asked to go and could not be started again: ${opened.error}`, [`editor_launch opens one on ${projectPath}`]);
@@ -40936,7 +41042,7 @@ class GodotServer {
     const ports = await this.portsForAnEditor();
     const before = this.settingKeysOf(project.value.path);
     const unfinished = restartOwed(project.value.path);
-    const opened = await this.openAnEditor(engine.value, project.value.path, ports);
+    const opened = await this.openAnEditor(engine.value, project.value.path, ports, args["hidden"] === true);
     if (opened.error !== null) {
       return this.createErrorResponse(`Could not start the editor: ${opened.error}`);
     }
@@ -40952,11 +41058,11 @@ class GodotServer {
       settingsNote: before === null ? "project.godot could not be read before this editor was opened, so nothing here will be able to say what the import saved away. Opening a project rewrites the file and drops any key sitting at its own default." : before.size === 0 ? undefined : "Opening a project imports it and saves project.godot, and Godot drops any key sitting at its own default. editor_status names anything lost under settingsDropped once this editor has connected."
     });
   }
-  async openAnEditor(engine, projectPath, ports) {
+  async openAnEditor(engine, projectPath, ports, hidden) {
     clearEditorLog(projectPath);
     const launched = await launchOutsideTheTree({
       command: engine,
-      args: editorArguments(projectPath, ports, editorLogPath(projectPath)),
+      args: editorArguments(projectPath, ports, editorLogPath(projectPath), hidden),
       env: {
         ...process.env,
         GDHARNESS_RUNTIME_DIR: runtimeDirectory(),
@@ -40964,7 +41070,7 @@ class GodotServer {
         GDHARNESS_DAP_PORT: String(ports.dap),
         [OPENED_BY_A_SERVER]: "1"
       },
-      desktop: HIDDEN_DESKTOP
+      ...hidden ? { desktop: HIDDEN_DESKTOP } : { noActivate: true }
     });
     if ("error" in launched) {
       return { pid: null, error: launched.error };
@@ -42624,7 +42730,7 @@ async function runGodotServer() {
   const server = new GodotServer;
   await server.run();
 }
-var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run7, __dirname2, EDITOR_RESTART_TIMEOUT_MS = 90000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, PLAY_STARTS_WITHIN_MS = 30000, STOP_WAIT_MS = 1e4, EXIT_REPORTED_WITHIN_MS = 2000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, MOST_GROUPS = 20, VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, HANDOVER_MS, HANDOVER_POLL_MS = 250, CACHE_WRITE_MS = 2000, SCAN_WAIT_MS = 30000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, SCAN_SETTLED_MS = 500, REIMPORT_TIMEOUT_MS = 300000, AUDIO_BUS_OPS, WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/";
+var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run7, __dirname2, EDITOR_RESTART_TIMEOUT_MS = 90000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, PLAY_STARTS_WITHIN_MS = 30000, STOP_WAIT_MS = 1e4, EXIT_REPORTED_WITHIN_MS = 2000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, MOST_GROUPS = 20, VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, HANDOVER_MS, HANDOVER_POLL_MS = 250, CACHE_WRITE_MS = 2000, SCAN_WAIT_MS = 30000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, SCAN_SETTLED_MS = 500, REIMPORT_TIMEOUT_MS = 300000, AUDIO_BUS_OPS, STALLED_AFTER_MS = 30000, WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/";
 var init_server3 = __esm(() => {
   init_mcp();
   init_stdio2();
@@ -44346,7 +44452,9 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
 | A picture, for a person who asked to see one | \`runtime_capture\` |
 
 These need the runtime autoload, which \`gdharness setup\` registers. \`runtime_capture\` needs a
-window and refuses headless rather than handing back the last frame anything drew.
+window and refuses headless rather than handing back the last frame anything drew. On Windows a
+windowed run this server starts is on a desktop of its own, where it draws and can be captured but
+never shows or takes the keyboard.
 
 The autoload reads these settings and no others. \`${BIND_ADDRESS_SETTING}\`
 is \`127.0.0.1\` and should stay there: the command set includes \`call_method\`, \`set_property\`
@@ -44398,7 +44506,7 @@ them. \`editor_rescan\` asks it to scan and names any class it still cannot reso
 \`unseenByEditor\`: its walk skips a file a headless engine has already imported, so the
 declaration and the cache can both be right while the editor stays blind to it. Rescan again on
 its own, which is the measured cure and needs no change to the declaring script; \`editor_launch
-restart\` also does it and costs a window.
+restart\` also does it and costs a restart of the editor.
 
 The scan writes \`.godot/global_script_class_cache.cfg\` from the list the editor is holding, so
 a class it cannot resolve would go out of that file with it. The answer names that loss under

package/build/index.js

@@ -24808,10 +24808,10 @@ function runArguments(options) {
   }
   return args;
 }
-function editorArguments(projectPath, ports, logFile) {
+function editorArguments(projectPath, ports, logFile, hidden) {
   return [
     "-e",
-    "--headless",
+    ...hidden ? ["--headless"] : [],
     "--path",
     projectPath,
     "--lsp-port",
@@ -25847,6 +25847,30 @@ function cachedClasses(projectPath) {
   }
   return listed;
 }
+function withAddonClassesCounted(rebuilt, listed) {
+  const counted = { ...rebuilt };
+  for (const key of ["added", "changed"]) {
+    const names = rebuilt[key];
+    if (!Array.isArray(names)) {
+      continue;
+    }
+    const own = [];
+    const perAddon = {};
+    for (const name of names) {
+      const addon = /^res:\/\/addons\/([^/]+)\//.exec(listed.get(String(name)) ?? "")?.[1];
+      if (addon === undefined) {
+        own.push(name);
+      } else {
+        perAddon[addon] = (perAddon[addon] ?? 0) + 1;
+      }
+    }
+    if (Object.keys(perAddon).length > 0) {
+      counted[key] = own;
+      counted[`${key}InAddons`] = perAddon;
+    }
+  }
+  return counted;
+}
 function missingMemberIn(message) {
   const found = /The (method|property) "([^"(]+)(?:\(\))?" is not present on the inferred type "([^"]+)"/.exec(message);
   if (found === null) {
@@ -28255,8 +28279,32 @@ function whyNoReport(printed, asked) {
   }
   return printed.some((line) => NOTHING_RAN.test(line)) ? `no test cases found at ${asked}` : null;
 }
+var DISCOVERY_FAILED = "Script errors were detected during test discovery!";
+function scriptErrorsPrinted(printed) {
+  const start = printed.findIndex((line) => line.includes(DISCOVERY_FAILED));
+  if (start < 0) {
+    return [];
+  }
+  const found = [];
+  let message = null;
+  for (const line of printed.slice(start + 1)) {
+    const at = /^\s*at (res:\/\/.+):(\d+)\s*$/.exec(line);
+    if (at !== null && message !== null) {
+      found.push({ path: at[1] ?? "", line: Number(at[2]), message });
+      message = null;
+    } else if (at === null && message === null && /^ {2}\S/.test(line)) {
+      message = line.trim();
+    } else {
+      break;
+    }
+  }
+  return found.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : a.line - b.line);
+}
 var ESCAPE = String.fromCharCode(27);
-var PRINTED_ACTUAL = new RegExp(` but was\\n '([\\s\\S]*?)'((?:${ESCAPE}\\[[0-9;]*m)*)\\tat ('[^'\\n]*' in \\S+:\\d+)`, "g");
+var LOCATION = `'[^'\\n]*' in \\S+:\\d+`;
+var IGNORING_CASE = " \\(ignoring case\\)";
+var PRINTED_ACTUAL = new RegExp(` but was\\n '((?:(?!\\tat ${LOCATION})[\\s\\S])*?)'((?:${ESCAPE}\\[[0-9;]*m)*)(${IGNORING_CASE})?((?:${ESCAPE}\\[[0-9;]*m)*)\\tat (${LOCATION})`, "g");
+var QUOTED_EQUALITY = new RegExp(`^Expecting(?: error message)?:\\n '([\\s\\S]*)'\\n but was\\n '([\\s\\S]*)'(?:${IGNORING_CASE})?\\n\\tat `);
 var COLOUR = new RegExp(`${ESCAPE}\\[([0-9;]*)m`, "g");
 var SPELLED = {
   "<LF>": `
@@ -28300,11 +28348,14 @@ function readDiff(printed) {
   return { merged, actual };
 }
 var BOTH_SIDES_ALIKE_NOTE = "[gdharness: the expected and the actual printed alike because gdUnit4 drops the marks that tell them apart when it writes its report, and the runner printed no copy of this one, so neither side above is the value the assertion found.]";
+var VALUE_NOT_RECOVERED_NOTE = '[gdharness: the value after "but was" may not be the one the assertion found. gdUnit4 writes a failing string into its report as a character diff against the expected one with the marks dropped, which merges the two, and the runner printed no copy of this one to read the value back from.]';
+var RENDERED_AWAY_NOTE = '[gdharness: the two sides print alike, so what tells them apart is something gdUnit4 does not print. The usual cause is BBCode in the expected string, which gdUnit4 renders as formatting instead of showing; the value after "but was" is the one the assertion found.]';
 function withActualsPrinted(failed, printed) {
   const diffs = [...printed.replaceAll(`\r
 `, `
 `).matchAll(PRINTED_ACTUAL)].map((match) => ({
-    at: match[3] ?? "",
+    suffix: match[3] ?? "",
+    at: match[5] ?? "",
     ...readDiff(match[1] ?? "")
   }));
   return failed.map((entry) => {
@@ -28312,24 +28363,39 @@ function withActualsPrinted(failed, printed) {
       return entry;
     }
     let detail = entry.detail;
+    let recovered = false;
     for (const diff of diffs) {
       const wrong = ` but was
- '${diff.merged.replaceAll("\r", "")}'
+ '${diff.merged.replaceAll("\r", "")}'${diff.suffix}
 	at ${diff.at}`;
       if (detail.includes(wrong)) {
         detail = detail.replace(wrong, () => ` but was
- '${diff.actual}'
+ '${diff.actual}'${diff.suffix}
 	at ${diff.at}`);
+        recovered = true;
       }
     }
-    const alike = /Expecting:\n '([\s\S]*)'\n but was\n '\1'\n\tat /.test(detail);
-    if (alike) {
-      detail = `${detail}
-${BOTH_SIDES_ALIKE_NOTE}`;
+    const quoted = QUOTED_EQUALITY.exec(detail);
+    if (quoted !== null) {
+      const alike = quoted[1] === quoted[2];
+      const note = recovered ? alike ? RENDERED_AWAY_NOTE : null : alike ? BOTH_SIDES_ALIKE_NOTE : VALUE_NOT_RECOVERED_NOTE;
+      detail = note === null ? detail : `${detail}
+${note}`;
+    }
+    if (quoted !== null && masked(quoted[1] ?? "", quoted[2] ?? "")) {
+      const end = quoted[0].length - `
+	at `.length;
+      detail = detail.slice(0, end).replaceAll(MASKED_BRACKET, "[") + detail.slice(end);
     }
     return detail === entry.detail ? entry : { ...entry, detail };
   });
 }
+var MASKED_BRACKET = "[lb]";
+function masked(expected, actual) {
+  const allSpelled = (value) => !PRINTED_DICTIONARY.test(value) && value.split("[").length === value.split(MASKED_BRACKET).length;
+  return `${expected}${actual}`.includes(MASKED_BRACKET) && allSpelled(expected) && allSpelled(actual);
+}
+var PRINTED_DICTIONARY = /^\{\n\t[\s\S]*\n {2}\}$/;
 var RUNNING_SUITE = /Run Test Suite:\s*(\S+)/;
 var ORPHANS = /(\d+)\s+orphans/;
 var OVERALL = "Overall Summary";
@@ -28940,7 +29006,8 @@ async function launchOutsideTheTree(spec, runtime = process.execPath, keeper = K
       args: spec.args,
       envChanges: changesFrom(spec.env, process.env),
       ...spec.run === undefined ? {} : { run: spec.run },
-      ...spec.desktop === undefined ? {} : { desktop: spec.desktop }
+      ...spec.desktop === undefined ? {} : { desktop: spec.desktop },
+      ...spec.noActivate === true ? { noActivate: true } : {}
     });
     let printed = "";
     let complained = "";
@@ -30194,7 +30261,7 @@ var TOOL_SPECS = [
   },
   {
     name: "project_test",
-    description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Suites where everything passed are counted rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines. The class list is rebuilt first, so a suite written a moment ago is found, and the rebuild's answer is under classes: a class it 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. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. On macOS the engine reads user:// off HOME and the run writes where the player keeps theirs, which the answer says under savesNote rather than leaving to be found in a save list. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. A run where nothing failed but nodes were left in the tree 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. Needs gdUnit4 under addons/gdUnit4.",
+    description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Suites where everything passed are counted rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines. The class list is rebuilt first, so a suite written a moment ago is found, and the rebuild's answer is under classes, with the classes each addon declares counted under addedInAddons and changedInAddons rather than named: a class it 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. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. On macOS the engine reads user:// off HOME and the run writes where the player keeps theirs, which the answer says under savesNote rather than leaving to be found in a save list. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. A run where nothing failed but nodes were left in the tree 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. Needs gdUnit4 under addons/gdUnit4.",
     parameters: {
       projectPath: PROJECT_PATH,
       path: {
@@ -30213,7 +30280,7 @@ var TOOL_SPECS = [
       timeoutMs: {
         type: "integer",
         minimum: 1,
-        description: "How long the run may take before it is killed. Default 600000."
+        description: "How long the run may take before it is killed. Default 600000. A run killed at the limit answers timedOut and silentForMs, how long it had printed nothing; it is called hung only when that was half the limit, or thirty seconds of a longer one, and otherwise it was still running and wants a longer timeoutMs or a narrower path."
       }
     },
     requires: ["projectPath"]
@@ -30462,8 +30529,15 @@ var TOOL_SPECS = [
   },
   {
     name: "editor_launch",
-    description: "Opens the Godot editor on a project, or restarts the one already connected. An editor this opens is headless: it shows no window and takes no focus, and it serves the bridge, the language server, the debug adapter and the games it plays as a windowed one does. An editor goes on serving the addon it read at startup, so restart is what puts a gdharness upgrade into effect; it saves open scenes on the way out and answers with the version that came back. An editor a server opened is started again by the server, headless as before. One opened by hand restarts itself, which only one with a window can do, because the engine hands back none of the arguments it was started with. editor_status says which editor is connected and whether it is holding an old addon. Opening a project is a save and so is closing one, which is the part that is not obvious from outside: the editor imports the project on open and writes project.godot back, and Godot writes only what differs from its own defaults, so a key named deliberately at its default value is dropped either way. A restart says which under settingsDropped in its own answer because it waits for the editor to return. An open cannot, since it answers as soon as the process exists and the save happens during the import minutes later, so editor_status carries that reading once the editor has connected. Nothing else will say a key went until something depends on one. A restart of an editor this server opened is a quit and then a launch, and this server can be ended between them, usually by the reconnect the restart was being taken for: the editor is gone and nothing replaces it. That is written down before the quit, so the next server says so under restartInterrupted in editor_status rather than waiting for an editor that is not coming, and open finishes it, saying so under finishesRestart.",
-    parameters: { projectPath: { ...PROJECT_PATH, ops: ["open"] } },
+    description: "Opens the Godot editor on a project, or restarts the one already connected. The editor is an ordinary visible one on the desktop in use, and on Windows it is shown without being activated, so opening or reopening it does not take the keyboard from whatever the user is typing in. hidden: true opens it headless instead and, on Windows, on a desktop of its own, where the games it plays go too; a hidden editor serves the bridge, the language server and the debug adapter as a visible one does. A game a visible editor plays opens as a window on the desktop in use. An editor goes on serving the addon it read at startup, so restart is what puts a gdharness upgrade into effect, and nothing else here restarts one; it saves open scenes on the way out and answers with the version that came back. An editor a server opened is started again by the server, visible unless hidden: true is passed again. One opened by hand restarts itself, which only one with a window can do, because the engine hands back none of the arguments it was started with. editor_status says which editor is connected and whether it is holding an old addon. Opening a project is a save and so is closing one, which is the part that is not obvious from outside: the editor imports the project on open and writes project.godot back, and Godot writes only what differs from its own defaults, so a key named deliberately at its default value is dropped either way. A restart says which under settingsDropped in its own answer because it waits for the editor to return. An open cannot, since it answers as soon as the process exists and the save happens during the import minutes later, so editor_status carries that reading once the editor has connected. Nothing else will say a key went until something depends on one. A restart of an editor this server opened is a quit and then a launch, and this server can be ended between them, usually by the reconnect the restart was being taken for: the editor is gone and nothing replaces it. That is written down before the quit, so the next server says so under restartInterrupted in editor_status rather than waiting for an editor that is not coming, and open finishes it, saying so under finishesRestart.",
+    parameters: {
+      projectPath: { ...PROJECT_PATH, ops: ["open"] },
+      hidden: {
+        type: "boolean",
+        ops: ["open", "restart"],
+        description: "Open the editor headless and, on Windows, on a desktop of its own, so no window of it or of the games it plays appears. Default false: one visible editor, shown without taking the focus."
+      }
+    },
     requires: [],
     operations: {
       open: { summary: "open the editor on a project", requires: ["projectPath"] },
@@ -30491,7 +30565,7 @@ var TOOL_SPECS = [
       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. A game the editor plays goes there too, since an editor this server opens is on that 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. 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."
       },
       savesIn: {
         type: "string",
@@ -31530,6 +31604,28 @@ function changedSettings(before, after) {
   const names = new Set([...before.keys(), ...after.keys()]);
   return [...names].filter((name) => JSON.stringify(before.get(name)) !== JSON.stringify(after.get(name))).sort();
 }
+var STALLED_AFTER_MS = 30000;
+function scriptErrorsNote(errors) {
+  const first = new Map;
+  for (const error of errors) {
+    if (!first.has(error.path)) {
+      first.set(error.path, error);
+    }
+  }
+  const scripts = [...first.values()].map((error) => `${error.path}:${error.line} ${error.message}${error.message.endsWith(".") ? "" : "."}`).join(" ");
+  const more = errors.length - first.size;
+  return `No tests ran: gdUnit4 could not load ${first.size === 1 ? "one script" : `${first.size} scripts`} while looking for suites, and it runs no suite at all when one fails to load. ${scripts}${more > 0 ? ` ${more === 1 ? "One more error" : `${more} more errors`} in ${first.size === 1 ? "that script" : "those scripts"} ${more === 1 ? "is" : "are"} under scriptErrors.` : ""}`;
+}
+function timedOutVerdict(timeoutMs, silentForMs) {
+  const quiet = Math.round(silentForMs);
+  return quiet >= Math.min(STALLED_AFTER_MS, timeoutMs / 2) ? {
+    verdict: `hung: killed after ${timeoutMs} ms, having printed nothing for the last ${quiet} ms`,
+    hung: true
+  } : {
+    verdict: `timed out after ${timeoutMs} ms while still running: it last printed ${quiet} ms before it was killed, so pass a longer timeoutMs or a narrower path`,
+    hung: false
+  };
+}
 function importStatuses(payload) {
   const listed = payload["resources"];
   if (!Array.isArray(listed)) {
@@ -31939,9 +32035,12 @@ class GodotServer {
     try {
       return await this.dispatch(tool, op, args);
     } catch (error) {
-      if (error instanceof McpError || error instanceof Refusal) {
+      if (error instanceof McpError) {
         throw error;
       }
+      if (error instanceof Refusal) {
+        return this.createErrorResponse(error.message);
+      }
       const where = op === "" ? tool : `${tool} op=${op}`;
       console.error(`[SERVER] Unmodelled failure in ${where}:`, error);
       const seenBefore = this.defectsSeen.before(where, errorMessage(error));
@@ -32221,7 +32320,7 @@ class GodotServer {
             return await bridge("set_theme_font_size", { themePath: args["resourcePath"] });
         }
       case "editor_launch":
-        return op === "restart" ? await this.handleRestartEditor() : await this.handleLaunchEditor(args);
+        return op === "restart" ? await this.handleRestartEditor(args) : await this.handleLaunchEditor(args);
       case "editor_run":
         if (op === "stop") {
           return await this.handleStopProject(args);
@@ -33072,11 +33171,18 @@ class GodotServer {
     const userData = mkdtempSync2(join17(tmpdir4(), "gdharness-tests-"));
     const run = this.spawnGame(engine.value, cmdArgs, userDataIn(userData));
     const console2 = [];
+    let lastSaid = Date.now();
     run.process.stdout?.on("data", (data) => {
       console2.push(data);
+      lastSaid = Date.now();
     });
-    const hung = await new Promise((resolve) => {
+    run.process.stderr?.on("data", () => {
+      lastSaid = Date.now();
+    });
+    let silentForMs = 0;
+    const timedOut = await new Promise((resolve) => {
       const timer = setTimeout(() => {
+        silentForMs = Date.now() - lastSaid;
         run.process.kill();
         resolve(true);
       }, timeoutMs);
@@ -33118,11 +33224,15 @@ class GodotServer {
     const exitCode = run.exitCode;
     const printed = run.log.select({ severity: "info", sinceLastCall: false, limit: 200 }).entries;
     const said = printed.map((entry) => entry.text);
-    const nothingRan = hung ? null : whyNoReport(said, asked);
-    const verdict = hung ? `hung: killed after ${timeoutMs} ms` : nothingRan ?? (exitCode === null ? undefined : verdicts[exitCode]) ?? (run.exitSignal === null ? `exit ${exitCode ?? "unknown"}` : howItExited(run));
+    const nothingRan = timedOut ? null : whyNoReport(said, asked);
+    const cutShort = timedOut ? timedOutVerdict(timeoutMs, silentForMs) : null;
+    const hung = cutShort?.hung ?? false;
+    const scriptErrors = timedOut || exitCode !== 105 ? [] : scriptErrorsPrinted(said);
+    const brokenScripts = new Set(scriptErrors.map((error) => error.path)).size;
+    const verdict = cutShort !== null ? cutShort.verdict : nothingRan ?? (brokenScripts > 0 ? `script errors in ${brokenScripts === 1 ? "one script" : `${brokenScripts} scripts`}, so no suite ran` : undefined) ?? (exitCode === null ? undefined : verdicts[exitCode]) ?? (run.exitSignal === null ? `exit ${exitCode ?? "unknown"}` : howItExited(run));
     const savesNote = savesStayPut() && nothingRan === null ? SAVES_NOT_MOVED_NOTE : undefined;
     if (report === null) {
-      const note = nothingRan === null ? `The test run wrote no report (${verdict}${reportProblem ? `; ${reportProblem}` : ""}).` : `No tests ran: ${verdict}.${elsewhereIn(project.value.path, asked)}`;
+      const note = nothingRan !== null ? `No tests ran: ${verdict}.${elsewhereIn(project.value.path, asked)}` : scriptErrors.length > 0 ? scriptErrorsNote(scriptErrors) : `The test run wrote no report (${verdict}${reportProblem ? `; ${reportProblem}` : ""}).`;
       return {
         content: [
           { type: "text", text: note },
@@ -33135,8 +33245,10 @@ class GodotServer {
               exitCode,
               exitSignal: run.exitSignal ?? undefined,
               hung,
+              ...timedOut ? { timedOut, silentForMs } : {},
+              ...scriptErrors.length > 0 ? { scriptErrors } : {},
               arguments: cmdArgs,
-              entries: forAnswer(printed.slice(0, 60)),
+              entries: forAnswer(printed.slice(0, 60).map(aboveTheRunner)),
               savesNote,
               ...scanned
             }, null, 2)
@@ -33159,8 +33271,9 @@ class GodotServer {
     const unclean = report.suites.filter((suite) => suite.failures > 0 || suite.errors > 0 || suite.skipped > 0 || orphansIn(suite.path) > 0);
     const notRun = report.suites.reduce((sum, suite) => sum + Math.max(0, suite.discovered - suite.tests), 0);
     return this.jsonTextResponse({
-      passed: !hung && exitCode === 0 && report.failures === 0 && report.errors === 0,
+      passed: !timedOut && exitCode === 0 && report.failures === 0 && report.errors === 0,
       verdict,
+      ...timedOut ? { timedOut, hung, silentForMs } : {},
       exitCode,
       exitSignal: run.exitSignal ?? undefined,
       tests: report.tests,
@@ -33190,7 +33303,7 @@ class GodotServer {
       engineErrors: run.log.count("error"),
       engineWarnings: run.log.count("warning"),
       engineEntries,
-      classes: classes.payload
+      classes: withAddonClassesCounted(classes.payload, cachedClasses(project.value.path) ?? new Map)
     });
   }
   async godotVersion(godotPath) {
@@ -33571,7 +33684,7 @@ class GodotServer {
       return null;
     }
   }
-  async handleRestartEditor() {
+  async handleRestartEditor(args) {
     const before = this.godotBridge.getStatus();
     if (!before.connected) {
       return this.createErrorResponse("No editor is connected, so there is nothing to restart.", [
@@ -33581,7 +33694,7 @@ class GodotServer {
     }
     const settingsBefore = this.settingKeysOf(before.projectPath);
     const mine = before.openedByAServer === true && before.projectPath !== undefined;
-    const asked = mine ? await this.startItAgain(before.projectPath ?? "", before.editorPid) : await this.handleViaBridge("restart_editor", {});
+    const asked = mine ? await this.startItAgain(before.projectPath ?? "", before.editorPid, args["hidden"] === true) : await this.handleViaBridge("restart_editor", {});
     if (asked.isError === true) {
       return asked;
     }
@@ -33619,7 +33732,7 @@ class GodotServer {
   whatTheEditorDropped(before, after) {
     return settingsDroppedReport(before, after);
   }
-  async startItAgain(projectPath, editorPid) {
+  async startItAgain(projectPath, editorPid, hidden) {
     const engine = await this.engine();
     if (!engine.ok) {
       return engine.response;
@@ -33641,7 +33754,7 @@ class GodotServer {
       return asked;
     }
     await this.waitForBridge(() => !alive(editorPid), Date.now() + EDITOR_RESTART_TIMEOUT_MS);
-    const opened = await this.openAnEditor(engine.value, projectPath, ports);
+    const opened = await this.openAnEditor(engine.value, projectPath, ports, hidden);
     restartSettled(projectPath);
     if (opened.error !== null) {
       return this.createErrorResponse(`The editor was asked to go and could not be started again: ${opened.error}`, [`editor_launch opens one on ${projectPath}`]);
@@ -33679,7 +33792,7 @@ class GodotServer {
     const ports = await this.portsForAnEditor();
     const before = this.settingKeysOf(project.value.path);
     const unfinished = restartOwed(project.value.path);
-    const opened = await this.openAnEditor(engine.value, project.value.path, ports);
+    const opened = await this.openAnEditor(engine.value, project.value.path, ports, args["hidden"] === true);
     if (opened.error !== null) {
       return this.createErrorResponse(`Could not start the editor: ${opened.error}`);
     }
@@ -33695,11 +33808,11 @@ class GodotServer {
       settingsNote: before === null ? "project.godot could not be read before this editor was opened, so nothing here will be able to say what the import saved away. Opening a project rewrites the file and drops any key sitting at its own default." : before.size === 0 ? undefined : "Opening a project imports it and saves project.godot, and Godot drops any key sitting at its own default. editor_status names anything lost under settingsDropped once this editor has connected."
     });
   }
-  async openAnEditor(engine, projectPath, ports) {
+  async openAnEditor(engine, projectPath, ports, hidden) {
     clearEditorLog(projectPath);
     const launched = await launchOutsideTheTree({
       command: engine,
-      args: editorArguments(projectPath, ports, editorLogPath(projectPath)),
+      args: editorArguments(projectPath, ports, editorLogPath(projectPath), hidden),
       env: {
         ...process.env,
         GDHARNESS_RUNTIME_DIR: runtimeDirectory(),
@@ -33707,7 +33820,7 @@ class GodotServer {
         GDHARNESS_DAP_PORT: String(ports.dap),
         [OPENED_BY_A_SERVER]: "1"
       },
-      desktop: HIDDEN_DESKTOP
+      ...hidden ? { desktop: HIDDEN_DESKTOP } : { noActivate: true }
     });
     if ("error" in launched) {
       return { pid: null, error: launched.error };

package/build/keeper.js

@@ -18,6 +18,8 @@ using System.Text;
 public static class GdharnessDesktop {
   const uint GenericAll = 0x10000000;
   const int UseStdHandles = 0x100;
+  const int UseShowWindow = 0x1;
+  const short ShowNoActivate = 4;
   // No console at all, rather than a hidden one: a console's host would sit on the desktop too.
   const uint DetachedProcess = 0x00000008;
   const uint Infinite = 0xFFFFFFFF;
@@ -50,26 +52,90 @@ public static class GdharnessDesktop {
   [DllImport("kernel32.dll")] static extern bool GetExitCodeProcess(IntPtr handle, out uint code);
   [DllImport("kernel32.dll")] static extern bool CloseHandle(IntPtr handle);
 
-  // Starts the command line on the named desktop, both of its streams on this process's output,
-  // writes its pid, and waits for it: the answer is its exit code. The desktop's handle is held until then, since a
-  // desktop goes when the last handle to it does.
-  public static int Run(string desktop, string commandLine, string pidFile) {
-    IntPtr held = CreateDesktopW(desktop, IntPtr.Zero, IntPtr.Zero, 0, GenericAll, IntPtr.Zero);
-    if (held == IntPtr.Zero) {
-      throw new Win32Exception(Marshal.GetLastWin32Error(), "CreateDesktopW " + desktop);
+  delegate bool EachWindow(IntPtr window, IntPtr unused);
+  [DllImport("user32.dll")] static extern bool EnumWindows(EachWindow each, IntPtr unused);
+  [DllImport("user32.dll")] static extern bool IsWindowVisible(IntPtr window);
+  [DllImport("user32.dll")] static extern uint GetWindowThreadProcessId(IntPtr window, out uint processId);
+  [DllImport("user32.dll")] static extern bool LockSetForegroundWindow(uint code);
+  const uint LockForeground = 1;
+  const uint UnlockForeground = 2;
+  const uint TimedOut = 0x102;
+
+  static bool ShowsAWindow(int processId) {
+    bool shown = false;
+    EnumWindows(delegate(IntPtr window, IntPtr unused) {
+      uint owner;
+      GetWindowThreadProcessId(window, out owner);
+      if (owner == (uint)processId && IsWindowVisible(window)) {
+        shown = true;
+        return false;
+      }
+      return true;
+    }, IntPtr.Zero);
+    return shown;
+  }
+
+  // Keeps the foreground where it is while the process starts: its own call to take it fails while
+  // the foreground is locked, and the user's own Alt+Tab or click still moves it. Released once its
+  // window has been showing for a while, since a program takes the foreground as it shows its window
+  // and not afterwards, or when it exits, or after two minutes whatever happens.
+  static void HoldTheForeground(Started started) {
+    DateTime until = DateTime.UtcNow.AddMinutes(2);
+    DateTime? shownAt = null;
+    while (DateTime.UtcNow < until) {
+      if (WaitForSingleObject(started.process, 100) != TimedOut) {
+        return;
+      }
+      if (shownAt == null && ShowsAWindow(started.processId)) {
+        shownAt = DateTime.UtcNow;
+      }
+      if (shownAt != null && DateTime.UtcNow - shownAt.Value > TimeSpan.FromSeconds(10)) {
+        return;
+      }
     }
+  }
+
+  // Starts the command line, both of its streams on this process's output, writes its pid, and
+  // waits for it: the answer is its exit code. On the named desktop when there is one, whose handle
+  // is held until then, since a desktop goes when the last handle to it does, and on this process's
+  // own otherwise. With noActivate its first window is shown without being activated, which is
+  // what a program's first ShowWindow does whatever it asks for when the start names a show state,
+  // and the foreground is held while it starts, since Godot also asks for it outright.
+  public static int Run(string desktop, string commandLine, string pidFile, bool noActivate) {
     StartupInfo startup = new StartupInfo();
     startup.cb = Marshal.SizeOf(typeof(StartupInfo));
-    startup.desktop = desktop;
+    if (desktop.Length > 0) {
+      IntPtr held = CreateDesktopW(desktop, IntPtr.Zero, IntPtr.Zero, 0, GenericAll, IntPtr.Zero);
+      if (held == IntPtr.Zero) {
+        throw new Win32Exception(Marshal.GetLastWin32Error(), "CreateDesktopW " + desktop);
+      }
+      startup.desktop = desktop;
+    }
     startup.flags = UseStdHandles;
+    if (noActivate) {
+      startup.flags |= UseShowWindow;
+      startup.show = ShowNoActivate;
+    }
     startup.input = GetStdHandle(-10);
     startup.output = GetStdHandle(-11);
     startup.error = startup.output;
     Started started;
+    if (noActivate) {
+      LockSetForegroundWindow(LockForeground);
+    }
+    try {
     if (!CreateProcessW(null, new StringBuilder(commandLine), IntPtr.Zero, IntPtr.Zero, true, DetachedProcess, IntPtr.Zero, null, ref startup, out started)) {
       throw new Win32Exception(Marshal.GetLastWin32Error(), "CreateProcessW " + commandLine);
     }
     File.WriteAllText(pidFile, started.processId.ToString());
+    if (noActivate) {
+      HoldTheForeground(started);
+    }
+    } finally {
+      if (noActivate) {
+        LockSetForegroundWindow(UnlockForeground);
+      }
+    }
     WaitForSingleObject(started.process, Infinite);
     uint code;
     GetExitCodeProcess(started.process, out code);
@@ -98,9 +164,10 @@ function quoted(argument) {
 function windowsCommandLine(command, args) {
   return [command, ...args].map(quoted).join(" ");
 }
-function onDesktop(desktop, command, args, pidFile, errorFile) {
+function throughHelper(how, command, args, pidFile, errorFile) {
   const spec = {
-    desktop,
+    desktop: how.desktop ?? "",
+    noActivate: how.noActivate === true,
     commandLine: windowsCommandLine(command, args),
     pidFile,
     errorFile,
@@ -119,7 +186,7 @@ function onDesktop(desktop, command, args, pidFile, errorFile) {
     "    try { Move-Item -LiteralPath $partial -Destination $assembly } catch { Remove-Item -LiteralPath $partial -ErrorAction SilentlyContinue }",
     "  }",
     "  Add-Type -LiteralPath $assembly",
-    "  $code = [GdharnessDesktop]::Run($spec.desktop, $spec.commandLine, $spec.pidFile)",
+    "  $code = [GdharnessDesktop]::Run($spec.desktop, $spec.commandLine, $spec.pidFile, [bool]$spec.noActivate)",
     "} catch {",
     "  [IO.File]::WriteAllText($spec.errorFile, $_.Exception.Message)",
     "  exit 1",
@@ -311,12 +378,13 @@ async function startDirectly(spec, output, hidden, detached = true, errors = out
     });
   });
 }
-async function startOnDesktop(spec, output) {
+async function startThroughHelper(spec, output) {
   const scratch = mkdtempSync(join3(tmpdir2(), "gdharness-desktop-"));
   const pidFile = join3(scratch, "pid");
   const errorFile = join3(scratch, "error");
+  const where = spec.desktop === undefined ? "without activation" : `on the ${spec.desktop} desktop`;
   try {
-    const wrapper = onDesktop(spec.desktop, spec.command, spec.args, pidFile, errorFile);
+    const wrapper = throughHelper(spec, spec.command, spec.args, pidFile, errorFile);
     const started = await startDirectly({ ...spec, command: wrapper.command, args: wrapper.args }, output, true, false, "ignore");
     if ("error" in started) {
       return started;
@@ -332,27 +400,26 @@ async function startOnDesktop(spec, output) {
       }
       if (exited.now) {
         const why = existsSync(errorFile) ? readFileSync2(errorFile, "utf8").trim() : "it exited saying nothing";
-        return { error: `it could not be started on the ${spec.desktop} desktop: ${why}` };
+        return { error: `it could not be started ${where}: ${why}` };
       }
       await delay(50);
     }
     started.child.kill();
-    return { error: `it was not started on the ${spec.desktop} desktop within ${DESKTOP_START_MS} ms` };
+    return { error: `it was not started ${where} within ${DESKTOP_START_MS} ms` };
   } finally {
     rmSync2(scratch, { recursive: true, force: true });
   }
 }
 var DESKTOP_START_MS = 60000;
 async function startDetached(spec, output, hidden) {
-  const desktop = spec.desktop;
-  return desktop !== undefined && process.platform === "win32" ? await startOnDesktop({ ...spec, desktop }, output) : await startDirectly(spec, output, hidden);
+  return process.platform === "win32" && (spec.desktop !== undefined || spec.noActivate === true) ? await startThroughHelper(spec, output) : await startDirectly(spec, output, hidden);
 }
-function onItsOwnDesktop(spec) {
-  return spec.desktop !== undefined && process.platform === "win32";
+function needsItsHelperKept(spec) {
+  return process.platform === "win32" && (spec.desktop !== undefined || spec.noActivate === true);
 }
 async function launch() {
   const spec = await receivedSpec();
-  if (spec.run === undefined && !onItsOwnDesktop(spec)) {
+  if (spec.run === undefined && !needsItsHelperKept(spec)) {
     const started = await startDetached(spec, "ignore", true);
     if ("error" in started) {
       process.stdout.write(`error ${started.error}
@@ -402,8 +469,8 @@ async function launch() {
 async function keep() {
   const spec = await receivedSpec();
   const run = spec.run;
-  if (run === undefined && !onItsOwnDesktop(spec)) {
-    process.stdout.write(`error a keeper was started without a run or a desktop
+  if (run === undefined && !needsItsHelperKept(spec)) {
+    process.stdout.write(`error a keeper was started without a run or a helper to keep
 `);
     process.exit(1);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdharness",
-  "version": "1.1.6",
+  "version": "1.1.8",
   "mcpName": "io.github.Aureliolo/gdharness",
   "description": "A harness for driving a Godot 4 project from an agent: editor addons, a runtime bridge into the running game, an MCP server in front of them, and a CLI that installs and diagnoses the Godot side.",
   "type": "module",