gdharness 1.1.5 → 1.1.7

package/build/index.js

@@ -10190,19 +10190,19 @@ import {
   closeSync as closeSync2,
   constants,
   copyFileSync,
-  existsSync as existsSync10,
+  existsSync as existsSync11,
   fstatSync,
   mkdirSync as mkdirSync10,
   mkdtempSync as mkdtempSync2,
   openSync as openSync3,
   readdirSync as readdirSync7,
-  readFileSync as readFileSync16,
+  readFileSync as readFileSync17,
   readSync as readSync2,
   rmdirSync,
-  statSync as statSync7
+  statSync as statSync8
 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
-import { basename as basename3, dirname as dirname11, extname as extname2, isAbsolute as isAbsolute3, join as join16, normalize as normalize2, relative as relative3 } from "node:path";
+import { basename as basename4, dirname as dirname11, extname as extname2, isAbsolute as isAbsolute3, join as join17, normalize as normalize2, relative as relative3 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 import { promisify as promisify5 } from "node:util";
@@ -24808,9 +24808,10 @@ function runArguments(options) {
   }
   return args;
 }
-function editorArguments(projectPath, ports, logFile) {
+function editorArguments(projectPath, ports, logFile, hidden) {
   return [
     "-e",
+    ...hidden ? ["--headless"] : [],
     "--path",
     projectPath,
     "--lsp-port",
@@ -26748,6 +26749,9 @@ async function handleDAPTool(client, toolName, args) {
   }
 }
 
+// src/desktop.ts
+var HIDDEN_DESKTOP = "gdharness";
+
 // src/dictionary.ts
 function emptyRecord() {
   return Object.create(null);
@@ -27921,7 +27925,6 @@ var HEADLESS_OPERATIONS = dictionary({
     status: "get_import_status",
     options: "get_import_options",
     set_options: "set_import_options",
-    reimport: "reimport_resource",
     uid: "get_uid",
     refresh_classes: "refresh_class_cache"
   }),
@@ -27935,7 +27938,7 @@ var HEADLESS_OPERATIONS = dictionary({
   })
 });
 var ENGINE_PASSES = dictionary({
-  project_import: dictionary({ refresh_uids: "import" })
+  project_import: dictionary({ refresh_uids: "import", reimport: "import" })
 });
 var EDITOR_READS = dictionary({
   project_settings: dictionary({ get: "get_project_setting" })
@@ -28253,7 +28256,8 @@ function whyNoReport(printed, asked) {
   return printed.some((line) => NOTHING_RAN.test(line)) ? `no test cases found at ${asked}` : null;
 }
 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 PRINTED_ACTUAL = new RegExp(` but was\\n '((?:(?!\\tat ${LOCATION})[\\s\\S])*?)'((?:${ESCAPE}\\[[0-9;]*m)*)\\tat (${LOCATION})`, "g");
 var COLOUR = new RegExp(`${ESCAPE}\\[([0-9;]*)m`, "g");
 var SPELLED = {
   "<LF>": `
@@ -28297,6 +28301,7 @@ 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.]';
 function withActualsPrinted(failed, printed) {
   const diffs = [...printed.replaceAll(`\r
 `, `
@@ -28309,6 +28314,7 @@ 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", "")}'
@@ -28317,12 +28323,13 @@ function withActualsPrinted(failed, printed) {
         detail = detail.replace(wrong, () => ` but was
  '${diff.actual}'
 	at ${diff.at}`);
+        recovered = true;
       }
     }
-    const alike = /Expecting:\n '([\s\S]*)'\n but was\n '\1'\n\tat /.test(detail);
-    if (alike) {
+    if (!recovered && /Expecting:\n '[\s\S]*'\n but was\n '[\s\S]*'\n\tat /.test(detail)) {
+      const alike = /Expecting:\n '([\s\S]*)'\n but was\n '\1'\n\tat /.test(detail);
       detail = `${detail}
-${BOTH_SIDES_ALIKE_NOTE}`;
+${alike ? BOTH_SIDES_ALIKE_NOTE : VALUE_NOT_RECOVERED_NOTE}`;
     }
     return detail === entry.detail ? entry : { ...entry, detail };
   });
@@ -28936,7 +28943,9 @@ async function launchOutsideTheTree(spec, runtime = process.execPath, keeper = K
       command: spec.command,
       args: spec.args,
       envChanges: changesFrom(spec.env, process.env),
-      ...spec.run === undefined ? {} : { run: spec.run }
+      ...spec.run === undefined ? {} : { run: spec.run },
+      ...spec.desktop === undefined ? {} : { desktop: spec.desktop },
+      ...spec.noActivate === true ? { noActivate: true } : {}
     });
     let printed = "";
     let complained = "";
@@ -29121,8 +29130,28 @@ function searchProject(projectPath, options) {
   return result;
 }
 
+// src/reimport.ts
+import { createHash as createHash3 } from "node:crypto";
+import { existsSync as existsSync9, readFileSync as readFileSync12, rmSync as rmSync5, statSync as statSync5, utimesSync, writeFileSync as writeFileSync8 } from "node:fs";
+import { basename as basename2, join as join13 } from "node:path";
+function forceNextImport(projectPath, resourcePath) {
+  const relative = resourcePath.replace(/^res:\/\//, "");
+  const sidecar = join13(projectPath, `${relative}.import`);
+  if (!existsSync9(sidecar)) {
+    return;
+  }
+  const { atime, mtimeMs } = statSync5(sidecar);
+  writeFileSync8(sidecar, readFileSync12(sidecar, "utf8").replace(/^valid=false\r?\n/m, ""));
+  utimesSync(sidecar, atime, new Date(mtimeMs + 2000));
+  rmSync5(importRecord(projectPath, resourcePath), { force: true });
+}
+function importRecord(projectPath, resourcePath) {
+  const digest = createHash3("md5").update(resourcePath).digest("hex");
+  return join13(projectPath, ".godot", "imported", `${basename2(resourcePath)}-${digest}.md5`);
+}
+
 // src/resources.ts
-import { readFileSync as readFileSync12 } from "node:fs";
+import { readFileSync as readFileSync13 } from "node:fs";
 import { extname, resolve as resolve4 } from "node:path";
 var STATIC_RESOURCES = [
   {
@@ -29317,7 +29346,7 @@ function readResourceText(uri, getProjectPath) {
   const parsedUri = parseGodotUri(uri);
   if (parsedUri.kind === "project-info") {
     const projectFilePath = resolveProjectFile(projectPath, "project.godot");
-    const rawProject = readFileSync12(projectFilePath, "utf-8");
+    const rawProject = readFileSync13(projectFilePath, "utf-8");
     const parsedProject = parseProjectGodot(rawProject);
     return {
       mimeType: "application/json",
@@ -29326,7 +29355,7 @@ function readResourceText(uri, getProjectPath) {
   }
   const filePath = resolveProjectFile(projectPath, parsedUri.resourcePath);
   ensureAllowedExtension(parsedUri.kind, filePath);
-  const text = readFileSync12(filePath, "utf-8");
+  const text = readFileSync13(filePath, "utf-8");
   return {
     mimeType: parsedUri.kind === "script" ? "text/x-gdscript" : "text/plain",
     text
@@ -29363,16 +29392,16 @@ function setupResourceHandlers(mcp, getProjectPath) {
 }
 
 // src/restart-note.ts
-import { mkdirSync as mkdirSync7, readFileSync as readFileSync13, rmSync as rmSync5, writeFileSync as writeFileSync8 } from "node:fs";
-import { dirname as dirname8, join as join13 } from "node:path";
+import { mkdirSync as mkdirSync7, readFileSync as readFileSync14, rmSync as rmSync6, writeFileSync as writeFileSync9 } from "node:fs";
+import { dirname as dirname8, join as join14 } from "node:path";
 function restartNotePath(projectPath) {
-  return join13(projectPath, ".godot", "gdharness-restart.json");
+  return join14(projectPath, ".godot", "gdharness-restart.json");
 }
 function noteRestartBegun(note) {
   const path = restartNotePath(note.projectPath);
   try {
     mkdirSync7(dirname8(path), { recursive: true });
-    writeFileSync8(path, `${JSON.stringify(note, null, 2)}
+    writeFileSync9(path, `${JSON.stringify(note, null, 2)}
 `, "utf8");
   } catch (error) {
     console.error(`[SERVER] Could not record the restart at ${path}: ${errorMessage(error)}`);
@@ -29380,7 +29409,7 @@ function noteRestartBegun(note) {
 }
 function restartOwed(projectPath) {
   try {
-    const parsed = JSON.parse(readFileSync13(restartNotePath(projectPath), "utf8"));
+    const parsed = JSON.parse(readFileSync14(restartNotePath(projectPath), "utf8"));
     if (typeof parsed !== "object" || parsed === null) {
       return null;
     }
@@ -29395,7 +29424,7 @@ function restartOwed(projectPath) {
 }
 function restartSettled(projectPath) {
   try {
-    rmSync5(restartNotePath(projectPath), { force: true });
+    rmSync6(restartNotePath(projectPath), { force: true });
   } catch (error) {
     console.error(`[SERVER] Could not clear the restart note: ${errorMessage(error)}`);
   }
@@ -29403,33 +29432,33 @@ function restartSettled(projectPath) {
 
 // src/run-record.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 import {
   mkdirSync as mkdirSync8,
   openSync as openSync2,
   readdirSync as readdirSync5,
-  readFileSync as readFileSync14,
+  readFileSync as readFileSync15,
   realpathSync as realpathSync3,
-  rmSync as rmSync6,
-  statSync as statSync5,
-  writeFileSync as writeFileSync9
+  rmSync as rmSync7,
+  statSync as statSync6,
+  writeFileSync as writeFileSync10
 } from "node:fs";
-import { basename as basename2, dirname as dirname9, join as join14, resolve as resolve5 } from "node:path";
+import { basename as basename3, dirname as dirname9, join as join15, resolve as resolve5 } from "node:path";
 function runsDirectory() {
-  return join14(runtimeDirectory(), "runs");
+  return join15(runtimeDirectory(), "runs");
 }
 function realAsFarAsItExists(path) {
   const missing = [];
   let at = path;
   for (;; ) {
     try {
-      return join14(realpathSync3.native(at), ...missing);
+      return join15(realpathSync3.native(at), ...missing);
     } catch {
       const parent = dirname9(at);
       if (parent === at) {
         return path;
       }
-      missing.unshift(basename2(at));
+      missing.unshift(basename3(at));
       at = parent;
     }
   }
@@ -29437,27 +29466,27 @@ function realAsFarAsItExists(path) {
 function projectKey(projectPath) {
   const real = realAsFarAsItExists(resolve5(projectPath)).replace(/[\\/]+$/, "");
   const folded = process.platform === "win32" || process.platform === "darwin" ? real.toLowerCase() : real;
-  return createHash3("sha256").update(folded.replaceAll("\\", "/")).digest("hex").slice(0, 16);
+  return createHash4("sha256").update(folded.replaceAll("\\", "/")).digest("hex").slice(0, 16);
 }
 function runRecordPath(projectPath, directory = runtimeDirectory()) {
-  return join14(directory, "runs", `note-${projectKey(projectPath)}.json`);
+  return join15(directory, "runs", `note-${projectKey(projectPath)}.json`);
 }
 var SHARED_NOTE = "run.json";
 function openTranscript(startedAt) {
   mkdirSync8(runsDirectory(), { recursive: true });
-  const path = join14(runsDirectory(), `run-${startedAt}.log`);
+  const path = join15(runsDirectory(), `run-${startedAt}.log`);
   return { path, fd: openSync2(path, "a") };
 }
 function editorNotePath(projectPath, directory = runtimeDirectory()) {
-  return join14(directory, "runs", `editor-${projectKey(projectPath)}.json`);
+  return join15(directory, "runs", `editor-${projectKey(projectPath)}.json`);
 }
 function writeEditorRunNote(note) {
   mkdirSync8(runsDirectory(), { recursive: true });
-  writeFileSync9(editorNotePath(note.projectPath), JSON.stringify(note, null, 2), "utf8");
+  writeFileSync10(editorNotePath(note.projectPath), JSON.stringify(note, null, 2), "utf8");
 }
 function readEditorRunNote(projectPath) {
   for (const directory of runtimeDirectories()) {
-    const note = editorNoteAt(editorNotePath(projectPath, directory)) ?? editorNoteAt(join14(directory, "runs", "editor-run.json"));
+    const note = editorNoteAt(editorNotePath(projectPath, directory)) ?? editorNoteAt(join15(directory, "runs", "editor-run.json"));
     if (note !== null && isSameDirectory(note.projectPath, projectPath)) {
       return note;
     }
@@ -29467,7 +29496,7 @@ function readEditorRunNote(projectPath) {
 function editorNoteAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync14(path, "utf8"));
+    parsed = JSON.parse(readFileSync15(path, "utf8"));
   } catch {
     return null;
   }
@@ -29489,7 +29518,7 @@ function readRunRecord(projectPath) {
     if (own !== null) {
       return own;
     }
-    const shared = recordAt(join14(directory, "runs", SHARED_NOTE));
+    const shared = recordAt(join15(directory, "runs", SHARED_NOTE));
     if (shared !== null && shared.projectPath !== "" && isSameDirectory(shared.projectPath, projectPath)) {
       return shared;
     }
@@ -29501,13 +29530,13 @@ function everyRunRecord() {
   for (const directory of runtimeDirectories()) {
     let entries;
     try {
-      entries = readdirSync5(join14(directory, "runs"));
+      entries = readdirSync5(join15(directory, "runs"));
     } catch {
       continue;
     }
     for (const entry of entries) {
       if (entry === SHARED_NOTE || entry.startsWith("note-") && entry.endsWith(".json")) {
-        const record = recordAt(join14(directory, "runs", entry));
+        const record = recordAt(join15(directory, "runs", entry));
         if (record !== null) {
           found.push(record);
         }
@@ -29519,7 +29548,7 @@ function everyRunRecord() {
 function recordAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync14(path, "utf8"));
+    parsed = JSON.parse(readFileSync15(path, "utf8"));
   } catch {
     return null;
   }
@@ -29565,7 +29594,7 @@ function runningAs(pid) {
     const began = startedAt(pid, null);
     const when = began === null ? {} : { startedAt: began };
     if (process.platform === "linux") {
-      const raw = readFileSync14(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
+      const raw = readFileSync15(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
       return raw === "" ? null : { kind: "commandLine", text: raw, ...when };
     }
     const args = execFileSync2("ps", ["-p", String(pid), "-o", "args="], {
@@ -29668,7 +29697,7 @@ function judgeRun(record, running, needed) {
   if (running.startedAt !== undefined && running.startedAt - record.startedAt > SAME_RUN_WINDOW_MS) {
     return false;
   }
-  const engine = record.command === undefined ? null : basename2(record.command);
+  const engine = record.command === undefined ? null : basename3(record.command);
   const said = process.platform === "win32" ? running.text.toLowerCase() : running.text;
   const wanted = engine === null || process.platform !== "win32" ? engine : engine.toLowerCase();
   if (wanted !== null && !said.includes(wanted)) {
@@ -29704,19 +29733,19 @@ function judgeAnnouncedGame(running, projectPath, announcedAt) {
 }
 function clearRunRecord(projectPath) {
   for (const directory of runtimeDirectories()) {
-    const shared = join14(directory, "runs", SHARED_NOTE);
+    const shared = join15(directory, "runs", SHARED_NOTE);
     const sharedRecord = recordAt(shared);
     const ours = sharedRecord !== null && sharedRecord.projectPath !== "" && isSameDirectory(sharedRecord.projectPath, projectPath);
     for (const path of [runRecordPath(projectPath, directory), ...ours ? [shared] : []]) {
       try {
-        rmSync6(path, { force: true });
+        rmSync7(path, { force: true });
       } catch {}
     }
   }
 }
 function ageMs(path, now) {
   try {
-    return now - statSync5(path).mtimeMs;
+    return now - statSync6(path).mtimeMs;
   } catch {
     return 0;
   }
@@ -29734,29 +29763,29 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
     if (!entry.startsWith("run-") || !entry.endsWith(".log")) {
       continue;
     }
-    const path = join14(directory, entry);
+    const path = join15(directory, entry);
     if (kept.has(path) || ageMs(path, now) < keepMs) {
       continue;
     }
     try {
-      rmSync6(path);
+      rmSync7(path);
     } catch {}
   }
 }
 
 // src/setup.ts
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 import {
   cpSync,
-  existsSync as existsSync9,
+  existsSync as existsSync10,
   mkdirSync as mkdirSync9,
   readdirSync as readdirSync6,
-  readFileSync as readFileSync15,
-  rmSync as rmSync7,
-  statSync as statSync6,
-  writeFileSync as writeFileSync10
+  readFileSync as readFileSync16,
+  rmSync as rmSync8,
+  statSync as statSync7,
+  writeFileSync as writeFileSync11
 } from "node:fs";
-import { dirname as dirname10, join as join15 } from "node:path";
+import { dirname as dirname10, join as join16 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 var ADDONS = ["gdharness_editor", "gdharness_runtime", "auto_reload"];
 var EDITOR_PLUGINS = ["gdharness_editor", "auto_reload"];
@@ -29767,27 +29796,27 @@ var RUNTIME_AUTOLOAD = {
 var VERSION_MARKER = ".gdharness-version";
 var DIGEST_MARKER = ".gdharness-digest";
 function editorAddonDigest(from = shippedAddonsDirectory()) {
-  const hash = createHash4("sha256");
+  const hash = createHash5("sha256");
   const walk = (directory, relative) => {
     for (const name of readdirSync6(directory).sort()) {
       if (name === VERSION_MARKER || name === DIGEST_MARKER) {
         continue;
       }
-      const path = join15(directory, name);
+      const path = join16(directory, name);
       const inside = `${relative}/${name}`;
-      if (statSync6(path).isDirectory()) {
+      if (statSync7(path).isDirectory()) {
         walk(path, inside);
       } else {
         hash.update(`${inside}
 `);
-        hash.update(readFileSync15(path));
+        hash.update(readFileSync16(path));
         hash.update(`
 `);
       }
     }
   };
   for (const name of EDITOR_PLUGINS) {
-    walk(join15(from, name), name);
+    walk(join16(from, name), name);
   }
   return hash.digest("hex");
 }
@@ -29803,14 +29832,14 @@ function shippedEditorDigest() {
   return shippedDigest ?? undefined;
 }
 function shippedAddonsDirectory() {
-  return join15(dirname10(fileURLToPath3(import.meta.url)), "godot", "addons");
+  return join16(dirname10(fileURLToPath3(import.meta.url)), "godot", "addons");
 }
 function installedAddonVersion(projectPath) {
-  const marker = join15(projectPath, "addons", ADDONS[0], VERSION_MARKER);
-  if (!existsSync9(marker)) {
+  const marker = join16(projectPath, "addons", ADDONS[0], VERSION_MARKER);
+  if (!existsSync10(marker)) {
     return null;
   }
-  const said = readFileSync15(marker, "utf8").trim();
+  const said = readFileSync16(marker, "utf8").trim();
   return said === "" ? null : said;
 }
 
@@ -30001,7 +30030,7 @@ var TOOL_SPECS = [
   },
   {
     name: "project_settings",
-    description: "Reads or writes project.godot: settings, autoloads, the main scene, input actions, plugins and audio buses.",
+    description: "Reads or writes project.godot: settings, autoloads, the main scene, input actions, plugins and audio buses. A write with an editor open on the project is handed to the editor, which takes the settings the write changed from the file (named under editorAdopted), or reloads the bus layout, so it answers the new values and does not save the old ones back over them. editorNote is an editor that could not take the write, one on an addon from before this, which still holds the old values until editor_launch restart. An enabled plugin's code still loads on the editor's next start.",
     parameters: {
       projectPath: PROJECT_PATH,
       setting: { type: "string", description: 'Setting path, such as "display/window/size/viewport_width".' },
@@ -30113,19 +30142,30 @@ var TOOL_SPECS = [
         description: 'set_options: import options keyed as the .import file spells them, {"compress/mode": 1}.',
         additionalProperties: true
       },
-      reimport: { type: "boolean", description: "set_options: reimport afterwards. Default true." },
-      force: { type: "boolean", description: "reimport: reimport even what is current. Default false." }
+      reimport: {
+        type: "boolean",
+        description: "set_options: reimport afterwards, answered under reimport as project_import reimport answers. Default true."
+      },
+      force: { type: "boolean", description: "reimport: reimport even what is current. Default false." },
+      timeoutMs: {
+        type: "integer",
+        minimum: 1,
+        description: "reimport, set_options: how long to wait for the editor to finish reimporting. Default 300000."
+      }
     },
     requires: ["projectPath"],
     operations: {
       status: {
-        summary: "which resources are outdated or failed, or one resource with resourcePath, judged by content as the editor judges it: a source whose hash differs from the one its import recorded, an import whose output under .godot/imported is gone (missing_outputs), and a glTF scene whose import does not depend on an image it names, because it was built before that image was imported (imported_without), each with its reason",
+        summary: "which resources are outdated or failed, or one resource with resourcePath, each with its reason. Judged by content with the checks the editor makes before it reimports: a sidecar changed since its import, as setting an option without a reimport leaves it; a sidecar with no uid or written for another file; an output under .godot/imported that is gone (missing_outputs) or changed; a source whose hash differs from the one its import recorded, or with no record. Beyond the editor, a glTF scene whose import does not depend on an image it names, because it was built before that image was imported (imported_without; a scene whose import runs an import script is not judged on images). failed is an import that failed, which the editor never tries again on its own. Without resourcePath, a sidecar whose source is gone is listed as missing_source",
         requires: []
       },
       options: { summary: "the import options of one resource", requires: ["resourcePath"] },
-      set_options: { summary: "change import options", requires: ["resourcePath", "options"] },
+      set_options: {
+        summary: "change import options in the sidecar, then apply them with a reimport of that resource",
+        requires: ["resourcePath", "options"]
+      },
       reimport: {
-        summary: "reimport one resource, or everything modified without resourcePath",
+        summary: "reimport what status says is outdated or failed, one resource with resourcePath, or what is current as well with force. Through the open editor when one serves the project, so it reloads what it holds, waiting for it to finish; otherwise through the engine's own import pass. Answered from a second status read: reimported lists what is current now, notReimported what is not, with its status and reason, and via says which of the two did the work. stillImporting is an editor that had not finished within timeoutMs",
         requires: []
       },
       uid: { summary: "the UID of one file", requires: ["resourcePath"] },
@@ -30427,8 +30467,15 @@ var TOOL_SPECS = [
   },
   {
     name: "editor_launch",
-    description: "Opens the Godot editor on a project, in a window on this machine, or restarts the one already connected. 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. Only an editor with a window can be restarted, 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"] },
@@ -30453,6 +30500,11 @@ var TOOL_SPECS = [
         description: `The game's own arguments, what OS.get_cmdline_user_args() answers, such as ["--level=2"]. The separator is added here. A run with any is started by this server rather than by the editor, which fixes the game's command line when it opens the project, so the debug_* tools do not answer for it.`
       },
       headless: { type: "boolean", ops: ["start"], description: "start: force a window or no window." },
+      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 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",
         ops: ["start", "check"],
@@ -30783,7 +30835,7 @@ var TOOL_SPECS = [
   },
   {
     name: "runtime_capture",
-    description: "A picture of the running game: the whole screen or one viewport, as an image. Needs the game running with a window.",
+    description: "A picture of the running game: the whole screen or one viewport, as an image. Needs the game running with a window. A capture asked for before the game's first frame is drawn waits for that frame, since the game announces itself before it and the viewport holds nothing it drew until then.",
     parameters: {
       projectPath: RUNNING_PROJECT_PATH,
       pid: RUNNING_PID,
@@ -31091,15 +31143,15 @@ function captureDestinationRefusal(outputPath, projects) {
     return `outputPath ${outputPath} does not end in .png, which is what a capture is.`;
   }
   const directory = realPathOr(dirname11(outputPath));
-  if (!existsSync10(directory)) {
+  if (!existsSync11(directory)) {
     return `outputPath's directory ${dirname11(outputPath)} does not exist; a capture creates no directories.`;
   }
-  const where = join16(directory, basename3(outputPath));
+  const where = join17(directory, basename4(outputPath));
   const inside = projects.find((project) => project !== "" && isWithinRoot(realPathOr(project), where));
   if (inside !== undefined) {
     return `outputPath ${outputPath} is inside the project at ${inside}; a capture is saved outside it, so it never becomes part of the game.`;
   }
-  if (existsSync10(where)) {
+  if (existsSync11(where)) {
     return `outputPath ${outputPath} already exists; a capture is not written over a file. Name a new one.`;
   }
   return null;
@@ -31477,6 +31529,45 @@ function scanWaitAnswer(scanned) {
 var PLAYING_STATUS_MS = 1000;
 var SCAN_START_MS = 2000;
 var SCAN_SETTLED_MS = 500;
+var REIMPORT_TIMEOUT_MS = 300000;
+var AUDIO_BUS_OPS = new Set([
+  "add_audio_bus",
+  "set_audio_bus_effect",
+  "set_audio_bus_volume"
+]);
+function changedSettings(before, after) {
+  if (before === null || after === null) {
+    return null;
+  }
+  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 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)) {
+    return [];
+  }
+  return listed.map((entry) => {
+    const one = asParams(entry);
+    const reason = readString(one, "reason");
+    return {
+      path: readString(one, "path") ?? "",
+      status: readString(one, "status") ?? "unknown",
+      ...reason === undefined ? {} : { reason }
+    };
+  });
+}
 var WAIT_FOR_RUN_MS = 600000;
 var RUN_POLL_MS = 250;
 var PATH_SOLUTIONS = [
@@ -31538,7 +31629,7 @@ function aboveTheRunner(entry) {
 }
 function elsewhereIn(projectPath, asked) {
   const wanted = asked.replace(/^res:\/\//, "").replace(/\/+$/, "");
-  if (wanted === "" || existsSync10(join16(projectPath, wanted))) {
+  if (wanted === "" || existsSync11(join17(projectPath, wanted))) {
     return "";
   }
   const root = (wanted.split("/")[0] ?? "").toLowerCase();
@@ -31552,7 +31643,7 @@ function elsewhereIn(projectPath, asked) {
   return near.length === 0 ? "" : ` The project does have ${there}.`;
 }
 function hasMainScene(projectFile) {
-  const scene = parseProjectGodot(readFileSync16(projectFile, "utf8"))["application"]?.["run/main_scene"];
+  const scene = parseProjectGodot(readFileSync17(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "";
 }
 function runtimeAddonAnnouncesEditors(projectPath) {
@@ -31560,13 +31651,13 @@ function runtimeAddonAnnouncesEditors(projectPath) {
     return false;
   }
   try {
-    return readFileSync16(join16(projectPath, RUNTIME_AUTOLOAD.path), "utf8").includes('"editor_pid"');
+    return readFileSync17(join17(projectPath, RUNTIME_AUTOLOAD.path), "utf8").includes('"editor_pid"');
   } catch {
     return false;
   }
 }
 function editorPlaysHeadless(projectFile) {
-  const runArgs = parseProjectGodot(readFileSync16(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
+  const runArgs = parseProjectGodot(readFileSync17(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
   return typeof runArgs === "string" && /(?:^|\s)--headless(?:\s|$)/.test(runArgs);
 }
 function camelCased(params) {
@@ -31585,7 +31676,7 @@ function needsItsOwnProcess(asked) {
 class GodotServer {
   mcp;
   locator = new GodotLocator;
-  operationsScript = join16(__dirname2, "godot", "operations", "godot_operations.gd");
+  operationsScript = join17(__dirname2, "godot", "operations", "godot_operations.gd");
   godotBridge;
   tools = buildToolDefinitions();
   activeProcess = null;
@@ -31871,9 +31962,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));
@@ -32030,7 +32124,14 @@ class GodotServer {
   }
   async dispatch(tool, op, args) {
     if (ENGINE_PASSES[tool]?.[op] !== undefined) {
-      return await this.handleRefreshUids(args);
+      return op === "reimport" ? await this.handleReimport(args) : await this.handleRefreshUids(args);
+    }
+    const settingsWrite = tool === "project_settings" && op !== "get" ? HEADLESS_OPERATIONS[tool]?.[op] : undefined;
+    if (settingsWrite !== undefined) {
+      return await this.handleProjectSettingsWrite(op, settingsWrite, args);
+    }
+    if (tool === "project_import" && op === "set_options") {
+      return await this.handleSetImportOptions(args);
     }
     const headless = HEADLESS_OPERATIONS[tool]?.[op];
     if (headless !== undefined) {
@@ -32146,7 +32247,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);
@@ -32289,8 +32390,8 @@ class GodotServer {
     if (path === undefined) {
       return { ok: false, response: this.createErrorResponse("projectPath is required.") };
     }
-    const file = join16(path, "project.godot");
-    if (!existsSync10(file)) {
+    const file = join17(path, "project.godot");
+    if (!existsSync11(file)) {
       return {
         ok: false,
         response: this.createErrorResponse(`Not a Godot project: ${path}`, [
@@ -32561,6 +32662,222 @@ class GodotServer {
       }
     }, scanned));
   }
+  async handleReimport(args) {
+    const project = this.project(args);
+    if (!project.ok) {
+      return project.response;
+    }
+    const contained = this.containProjectFiles(args);
+    if (!contained.ok) {
+      return contained.response;
+    }
+    const outcome = await this.reimport(project.value.path, readNonEmptyString(contained.value, "resourcePath"), args["force"] === true, readPositiveNumber(args, "timeoutMs") ?? REIMPORT_TIMEOUT_MS);
+    return outcome.ok ? this.jsonTextResponse(outcome.payload) : outcome.response;
+  }
+  editorHasOpen(projectPath) {
+    const open = this.godotBridge.getStatus().projectPath;
+    return this.godotBridge.isConnected() && open !== undefined && open !== "" && isSameDirectory(open, projectPath);
+  }
+  async handleProjectSettingsWrite(op, operation, args) {
+    const project = this.project(args);
+    if (!project.ok) {
+      return project.response;
+    }
+    const projectPath = project.value.path;
+    const served = this.editorHasOpen(projectPath);
+    const before = served ? this.settingKeysOf(projectPath) : null;
+    const written = await this.headless(operation, args);
+    if (!served || written.isError === true) {
+      return written;
+    }
+    const answer = asParams(JSON.parse(written.content[0]?.text ?? "{}"));
+    if (AUDIO_BUS_OPS.has(op)) {
+      return this.jsonTextResponse({ ...answer, ...await this.editorTakes("adopt_audio_bus_layout", {}) });
+    }
+    const changed = changedSettings(before, this.settingKeysOf(projectPath));
+    if (changed === null) {
+      return this.jsonTextResponse({
+        ...answer,
+        editorNote: "project.godot could not be read on both sides of the write, so what it changed is unknown and the open editor was not told: it may still hold the old values and write them back the next time it saves. editor_launch restart loads the file."
+      });
+    }
+    if (changed.length === 0) {
+      return written;
+    }
+    const taken = await this.editorTakes("adopt_project_settings", { settings: changed });
+    return this.jsonTextResponse({
+      ...answer,
+      ...taken,
+      ...taken["editorNote"] === undefined ? { editorAdopted: changed } : {}
+    });
+  }
+  async editorTakes(command, args) {
+    try {
+      await this.godotBridge.invokeTool(command, args);
+      return {};
+    } catch (error) {
+      const message = errorMessage(error);
+      const why = message.includes("Unknown tool") ? "runs an addon from before writes were handed to it" : `could not take the change (${message})`;
+      return {
+        editorNote: `The open editor ${why}, so it still holds the old values, answers them when asked, and writes them back over the file the next time it saves. editor_launch restart loads the file and the addon this server ships.`
+      };
+    }
+  }
+  async handleSetImportOptions(args) {
+    const project = this.project(args);
+    if (!project.ok) {
+      return project.response;
+    }
+    const contained = this.containProjectFiles(args);
+    if (!contained.ok) {
+      return contained.response;
+    }
+    const {
+      op: _op,
+      projectPath: _projectPath,
+      reimport: _reimport,
+      timeoutMs: _timeoutMs,
+      ...params
+    } = contained.value;
+    const written = await this.operation("set_import_options", params, project.value.path);
+    if (!written.ok || args["reimport"] === false) {
+      return this.answer(written.ok ? {
+        ...written,
+        payload: {
+          ...written.payload,
+          note: "Not reimported: the editor imports it with these options on its next scan, or project_import reimport does now."
+        }
+      } : written);
+    }
+    const applied = await this.reimport(project.value.path, readNonEmptyString(contained.value, "resourcePath"), true, readPositiveNumber(args, "timeoutMs") ?? REIMPORT_TIMEOUT_MS);
+    if (!applied.ok) {
+      return applied.response;
+    }
+    return this.jsonTextResponse({ ...written.payload, reimport: applied.payload });
+  }
+  async reimport(projectPath, resourcePath, force, timeoutMs) {
+    const ask = resourcePath === undefined ? { includeUpToDate: force } : { resourcePath };
+    const before = await this.operation("get_import_status", ask, projectPath);
+    if (!before.ok) {
+      return { ok: false, response: this.answer(before) };
+    }
+    const listed = importStatuses(before.payload);
+    const missingSource = listed.filter((one) => one.status === "missing_source").map((one) => one.path);
+    if (resourcePath !== undefined && missingSource.length > 0) {
+      return {
+        ok: false,
+        response: this.createErrorResponse(`${missingSource[0]} is not on disk, so there is nothing to import.`)
+      };
+    }
+    const targets = listed.filter((one) => one.status !== "missing_source" && (force || one.status !== "up_to_date")).map((one) => one.path);
+    if (targets.length === 0) {
+      return {
+        ok: true,
+        payload: {
+          reimported: [],
+          notReimported: [],
+          note: resourcePath === undefined ? "Nothing needed reimporting. Pass force to reimport what is current." : `${listed[0]?.path ?? resourcePath} is current. Pass force to reimport it anyway.`
+        }
+      };
+    }
+    const viaEditor = this.editorHasOpen(projectPath);
+    const extra = {};
+    if (viaEditor) {
+      const inEditor = await this.reimportInTheEditor(targets, timeoutMs);
+      if (!inEditor.ok) {
+        return inEditor;
+      }
+      if (!inEditor.finished) {
+        return {
+          ok: true,
+          payload: {
+            via: "editor",
+            stillImporting: true,
+            asked: targets,
+            note: `The editor had not finished after ${timeoutMs} ms. project_import status says what it has done so far; pass a longer timeoutMs to wait it out.`
+          }
+        };
+      }
+    } else {
+      const engine = await this.engine();
+      if (!engine.ok) {
+        return { ok: false, response: engine.response };
+      }
+      for (const target of targets) {
+        forceNextImport(projectPath, target);
+      }
+      const scanned = await this.untilTheEditorsScanIsWritten(projectPath);
+      const imported = await runImport(engine.value, projectPath);
+      if (!imported.ok) {
+        return { ok: false, response: this.answer(withScanWait(imported, scanned)) };
+      }
+      if (imported.messages.length > 0) {
+        extra["engine_messages"] = imported.messages;
+      }
+    }
+    const after = await this.operation("get_import_status", resourcePath === undefined ? { includeUpToDate: true } : { resourcePath }, projectPath);
+    if (!after.ok) {
+      return { ok: false, response: this.answer(after) };
+    }
+    const now = new Map(importStatuses(after.payload).map((one) => [one.path, one]));
+    const reimported = targets.filter((path) => now.get(path)?.status === "up_to_date");
+    const notReimported = targets.filter((path) => now.get(path)?.status !== "up_to_date").map((path) => ({
+      path,
+      status: now.get(path)?.status ?? "unknown",
+      ...now.get(path)?.reason === undefined ? {} : { reason: now.get(path)?.reason }
+    }));
+    return {
+      ok: true,
+      payload: {
+        via: viaEditor ? "editor" : "engine",
+        reimported,
+        notReimported,
+        ...missingSource.length > 0 ? { missingSource } : {},
+        ...extra
+      }
+    };
+  }
+  async reimportInTheEditor(paths, timeoutMs) {
+    const started = Date.now();
+    let completedBefore;
+    for (;; ) {
+      while (Date.now() - started < timeoutMs && await this.editorIsScanningOrImporting()) {
+        await new Promise((settle) => setTimeout(settle, 100));
+      }
+      let answer;
+      try {
+        answer = asParams(await this.godotBridge.invokeTool("reimport_files", { paths: [...paths] }));
+      } catch (error) {
+        const message = errorMessage(error);
+        return {
+          ok: false,
+          response: message.includes("Unknown tool") ? this.createErrorResponse("The editor is running an addon from before reimport_files, so it cannot be asked to reimport.", [
+            "editor_launch restart loads the addon this server ships",
+            "Or close the editor, and project_import reimport runs the engine import instead"
+          ]) : this.createErrorResponse(`The editor answered reimport_files with an error: ${message}`)
+        };
+      }
+      if (answer["started"] !== false) {
+        completedBefore = readNumber(answer, "reimportsCompletedBefore");
+        break;
+      }
+      if (Date.now() - started >= timeoutMs) {
+        return { ok: true, finished: false };
+      }
+      await new Promise((settle) => setTimeout(settle, 100));
+    }
+    while (Date.now() - started < timeoutMs) {
+      await new Promise((settle) => setTimeout(settle, 250));
+      try {
+        const status = asParams(await this.godotBridge.invokeTool("scan_status", {}));
+        const completed = readNumber(status, "reimportsCompleted");
+        if (completedBefore !== undefined && completed !== undefined && completed > completedBefore) {
+          return { ok: true, finished: true };
+        }
+      } catch {}
+    }
+    return { ok: true, finished: false };
+  }
   async operation(operation, params, projectPath) {
     const engine = await this.engine();
     if (!engine.ok) {
@@ -32602,11 +32919,11 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const application = parseProjectGodot(readFileSync16(project.value.file, "utf8"))["application"] ?? {};
+    const application = parseProjectGodot(readFileSync17(project.value.file, "utf8"))["application"] ?? {};
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
-      name: typeof name === "string" && name !== "" ? name : basename3(project.value.path),
+      name: typeof name === "string" && name !== "" ? name : basename4(project.value.path),
       path: project.value.path,
       mainScene: typeof mainScene === "string" && mainScene !== "" ? mainScene : null,
       godotVersion: await this.godotVersion(engine.value),
@@ -32670,11 +32987,11 @@ class GodotServer {
       return this.createErrorResponse(`Cannot create ${dirname11(output.relativePath)} to export into: ${errorMessage(error)}`);
     }
     const debug = readBoolean(args, "debug") ?? false;
-    const exportLogs = mkdtempSync2(join16(tmpdir4(), "gdharness-export-"));
+    const exportLogs = mkdtempSync2(join17(tmpdir4(), "gdharness-export-"));
     const exportArgs = [
       "--headless",
       "--log-file",
-      join16(exportLogs, "engine.log"),
+      join17(exportLogs, "engine.log"),
       "--path",
       project.value.path,
       debug ? "--export-debug" : "--export-release",
@@ -32706,7 +33023,7 @@ class GodotServer {
     log.finish();
     const problems = log.select({ severity: "warning", sinceLastCall: false, limit: 200 });
     const verdict = {
-      exported: ending.exitCode === 0 && log.count("error") === 0 && existsSync10(output.absolutePath),
+      exported: ending.exitCode === 0 && log.count("error") === 0 && existsSync11(output.absolutePath),
       preset,
       outputPath: output.relativePath,
       debug,
@@ -32742,7 +33059,7 @@ class GodotServer {
       return contained.response;
     }
     const runner = "addons/gdUnit4/bin/GdUnitCmdTool.gd";
-    if (!existsSync10(join16(project.value.path, runner))) {
+    if (!existsSync11(join17(project.value.path, runner))) {
       return this.createErrorResponse(`gdUnit4 is not installed in this project: no ${runner}.`, [
         "Install gdUnit4 under addons/gdUnit4, from https://github.com/godot-gdunit-labs/gdUnit4"
       ]);
@@ -32778,14 +33095,21 @@ class GodotServer {
     ];
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 600000;
     this.logDebug(`Running tests: ${engine.value} ${cmdArgs.join(" ")}`);
-    const userData = mkdtempSync2(join16(tmpdir4(), "gdharness-tests-"));
+    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);
@@ -32798,14 +33122,14 @@ class GodotServer {
         resolve(false);
       });
     });
-    const reportsDir = join16(project.value.path, ".godot", ...ours.split("/"));
+    const reportsDir = join17(project.value.path, ".godot", ...ours.split("/"));
     let report = null;
     let reportProblem = null;
     try {
-      const written = existsSync10(reportsDir) ? readdirSync7(reportsDir).filter((name) => name.startsWith("report_")).sort((a, b) => Number(a.slice("report_".length)) - Number(b.slice("report_".length))) : [];
+      const written = existsSync11(reportsDir) ? readdirSync7(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(readFileSync16(join16(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync17(join17(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
@@ -32827,8 +33151,10 @@ 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 verdict = cutShort !== null ? cutShort.verdict : nothingRan ?? (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)}`;
@@ -32844,6 +33170,7 @@ class GodotServer {
               exitCode,
               exitSignal: run.exitSignal ?? undefined,
               hung,
+              ...timedOut ? { timedOut, silentForMs } : {},
               arguments: cmdArgs,
               entries: forAnswer(printed.slice(0, 60)),
               savesNote,
@@ -32868,8 +33195,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,
@@ -32948,11 +33276,11 @@ class GodotServer {
     const cached = cachedClasses(projectPath);
     const contradicted = cached === null ? [] : contradictedDiagnostics(messages, cached, (resourcePath) => {
       const contained = resolveWithinProject(projectPath, resourcePath);
-      if (!contained.ok || !existsSync10(contained.absolutePath)) {
+      if (!contained.ok || !existsSync11(contained.absolutePath)) {
         return null;
       }
       try {
-        return readFileSync16(contained.absolutePath, "utf8");
+        return readFileSync17(contained.absolutePath, "utf8");
       } catch {
         return null;
       }
@@ -33002,11 +33330,11 @@ class GodotServer {
   }
   sourceOfClass(projectPath, resourcePath) {
     const contained = resolveWithinProject(projectPath, resourcePath);
-    if (!contained.ok || !existsSync10(contained.absolutePath)) {
+    if (!contained.ok || !existsSync11(contained.absolutePath)) {
       return null;
     }
     try {
-      return readFileSync16(contained.absolutePath, "utf8");
+      return readFileSync17(contained.absolutePath, "utf8");
     } catch {
       return null;
     }
@@ -33275,12 +33603,12 @@ class GodotServer {
       return null;
     }
     try {
-      return settingKeys(readFileSync16(join16(projectPath, "project.godot"), "utf8"));
+      return settingKeys(readFileSync17(join17(projectPath, "project.godot"), "utf8"));
     } catch {
       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.", [
@@ -33290,7 +33618,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;
     }
@@ -33328,7 +33656,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;
@@ -33350,7 +33678,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}`]);
@@ -33388,7 +33716,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}`);
     }
@@ -33404,18 +33732,19 @@ 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(),
         GDHARNESS_LSP_PORT: String(ports.lsp),
         GDHARNESS_DAP_PORT: String(ports.dap),
         [OPENED_BY_A_SERVER]: "1"
-      }
+      },
+      ...hidden ? { desktop: HIDDEN_DESKTOP } : { noActivate: true }
     });
     if ("error" in launched) {
       return { pid: null, error: launched.error };
@@ -33497,7 +33826,7 @@ class GodotServer {
       userArgs: given.value
     });
     this.logDebug(`Running Godot project: ${engine.value} ${cmdArgs.join(" ")}`);
-    const started = await this.launchKeptGame(engine.value, cmdArgs, project.value.path, needsItsOwnProcess(asked.value) ? environmentFor({ ...asked.value, runtimeDirectory: runtimeDirectory() }) : undefined);
+    const started = await this.launchKeptGame(engine.value, cmdArgs, project.value.path, needsItsOwnProcess(asked.value) ? environmentFor({ ...asked.value, runtimeDirectory: runtimeDirectory() }) : undefined, headless || args["visible"] === true ? undefined : HIDDEN_DESKTOP);
     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"
@@ -33527,7 +33856,7 @@ class GodotServer {
   }
   async runtimeUp(projectPath, before, budget, withArgs) {
     const budgetMs = budget.ms;
-    if (!existsSync10(join16(projectPath, RUNTIME_AUTOLOAD.path))) {
+    if (!existsSync11(join17(projectPath, RUNTIME_AUTOLOAD.path))) {
       return runtimeVerdict(null, { addon: false, budgetMs, heldAt: null, running: false, withArgs });
     }
     let asking = null;
@@ -33590,7 +33919,7 @@ class GodotServer {
     }
     let announcedAt;
     try {
-      announcedAt = statSync7(endpoint.file).mtimeMs;
+      announcedAt = statSync8(endpoint.file).mtimeMs;
     } catch {
       return;
     }
@@ -33837,7 +34166,7 @@ class GodotServer {
     });
     return started;
   }
-  async launchKeptGame(godotPath, cmdArgs, projectPath, env) {
+  async launchKeptGame(godotPath, cmdArgs, projectPath, env, desktop) {
     const startedAt = Date.now();
     const transcript = openTranscript(startedAt);
     closeSync2(transcript.fd);
@@ -33845,7 +34174,8 @@ class GodotServer {
       command: godotPath,
       args: cmdArgs,
       ...env === undefined ? {} : { env },
-      run: { transcript: transcript.path, startedAt, projectPath }
+      run: { transcript: transcript.path, startedAt, projectPath },
+      ...desktop === undefined ? {} : { desktop }
     });
     if ("error" in launched) {
       return launched;
@@ -34340,7 +34670,7 @@ class GodotServer {
       notes.push(endedWithoutACode({
         throughEditor: run.throughEditor,
         announced: announced !== undefined || run.announcedPid !== undefined,
-        couldAnnounce: run.projectPath !== null && existsSync10(join16(run.projectPath, RUNTIME_AUTOLOAD.path)),
+        couldAnnounce: run.projectPath !== null && existsSync11(join17(run.projectPath, RUNTIME_AUTOLOAD.path)),
         endedHere: typeof run.endedHere === "string",
         pickedUp: run.pickedUp === true
       }));
@@ -34853,7 +35183,7 @@ class GodotServer {
   async ownRunOnItsWay(projectPath, budgetMs) {
     const run = this.currentRun();
     const project = projectPath ?? run?.projectPath ?? null;
-    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync10(join16(project, RUNTIME_AUTOLOAD.path)) || !await this.runStillGoing(run)) {
+    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync11(join17(project, RUNTIME_AUTOLOAD.path)) || !await this.runStillGoing(run)) {
       return null;
     }
     const already = runtimesAnnounced().running;
@@ -34862,7 +35192,7 @@ class GodotServer {
         return !run.announcedBefore.has(one.pid);
       }
       try {
-        return statSync7(one.file).mtimeMs >= run.startedAt;
+        return statSync8(one.file).mtimeMs >= run.startedAt;
       } catch {
         return false;
       }
@@ -34932,8 +35262,8 @@ class GodotServer {
         return this.createErrorResponse(refusal);
       }
     }
-    const screenshotDir = expectsScreenshot ? mkdtempSync2(join16(tmpdir4(), "gdharness-runtime-screenshot-")) : null;
-    const screenshotPath = screenshotDir ? join16(screenshotDir, "capture.png") : null;
+    const screenshotDir = expectsScreenshot ? mkdtempSync2(join17(tmpdir4(), "gdharness-runtime-screenshot-")) : null;
+    const screenshotPath = screenshotDir ? join17(screenshotDir, "capture.png") : null;
     try {
       const reply = await runtimeRequest(choice.endpoint, command, screenshotPath ? { ...params, output_path: screenshotPath } : params, timeoutMs, !expectsScreenshot);
       if (!reply.ok && reply.requestId !== undefined) {
@@ -34974,7 +35304,7 @@ class GodotServer {
             type: "text",
             text: `Screenshot captured: ${dimensions}${chosenAmongSeveral ? ` from pid ${own}, the game this server holds` : ""}${saveTo === null ? "" : `. Saved to ${saveTo}`}`
           },
-          { type: "image", data: readFileSync16(screenshotPath).toString("base64"), mimeType: "image/png" }
+          { type: "image", data: readFileSync17(screenshotPath).toString("base64"), mimeType: "image/png" }
         ]
       };
     } finally {