gdharness 1.2.27 → 1.2.29

package/build/cli.js

@@ -68,8 +68,34 @@ var init_errors = __esm(() => {
   };
 });
 
+// src/spawn.ts
+import {
+  execFile,
+  execFileSync,
+  spawn,
+  spawnSync
+} from "node:child_process";
+function spawnHidden(command, args, options = {}) {
+  return spawn(command, [...args], { ...options, windowsHide: true });
+}
+function runHidden(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    execFile(command, [...args], { ...options, encoding: "utf8", windowsHide: true }, (error, stdout, stderr) => {
+      if (error !== null) {
+        Object.assign(error, { stdout, stderr });
+        reject(error);
+        return;
+      }
+      resolve({ stdout, stderr });
+    });
+  });
+}
+function spawnSyncHidden(command, args, options = {}) {
+  return spawnSync(command, [...args], { ...options, windowsHide: true });
+}
+var init_spawn = () => {};
+
 // src/windows-ask.ts
-import { spawn } from "node:child_process";
 import { tmpdir } from "node:os";
 import process2 from "node:process";
 function holding(child, wanted) {
@@ -88,14 +114,14 @@ function running() {
   if (helper?.exitCode === null && helper.signalCode === null) {
     return helper;
   }
-  const child = spawn("powershell.exe", [
+  const child = spawnHidden("powershell.exe", [
     "-NoProfile",
     "-NonInteractive",
     "-ExecutionPolicy",
     "Bypass",
     "-EncodedCommand",
     Buffer.from(SCRIPT, "utf16le").toString("base64")
-  ], { stdio: ["pipe", "pipe", "pipe"], windowsHide: true, cwd: tmpdir() });
+  ], { cwd: tmpdir() });
   buffered = "";
   child.stdout.setEncoding("utf8");
   child.stdout.on("data", (chunk) => {
@@ -188,6 +214,7 @@ function askWindows(script, withinMs) {
 }
 var SCRIPT, WindowsAskFailure, helper = null, buffered = "", next = 1, out = null, queued, held = false;
 var init_windows_ask = __esm(() => {
+  init_spawn();
   SCRIPT = [
     "[Console]::OutputEncoding = [Text.Encoding]::UTF8",
     "$in = [Console]::In",
@@ -215,9 +242,7 @@ var init_windows_ask = __esm(() => {
 });
 
 // src/process-children.ts
-import { execFile } from "node:child_process";
 import { basename } from "node:path";
-import { promisify } from "node:util";
 async function startTimesOf(pids) {
   const began = new Map;
   if (pids.length === 0) {
@@ -252,10 +277,9 @@ async function startTimesOf(pids) {
   return began;
 }
 function printedBy(command, args, env) {
-  return new Promise((resolve) => {
-    execFile(command, [...args], { encoding: "utf8", timeout: ASK_TIMEOUT_MS, env }, (_error, stdout) => {
-      resolve(stdout);
-    });
+  return runHidden(command, args, { timeout: ASK_TIMEOUT_MS, env }).then(({ stdout }) => stdout, (error) => {
+    const printed = error.stdout;
+    return typeof printed === "string" ? printed : "";
   });
 }
 async function processTree() {
@@ -321,10 +345,18 @@ function linked(tree, child, parent) {
   }
   return from.startedAt >= to.startedAt;
 }
+function isConsoleHost(listed) {
+  const executable = commandWords(listed.command)[0];
+  if (executable === undefined) {
+    return false;
+  }
+  const host = `${process.env["SystemRoot"] ?? "C:\\Windows"}\\System32\\conhost.exe`;
+  return executable.replace(/^\\\?\?\\/, "").replaceAll("/", "\\").toLowerCase() === host.toLowerCase();
+}
 function childrenIn(tree, pid) {
   const children = [];
-  for (const child of tree.keys()) {
-    if (linked(tree, child, pid)) {
+  for (const [child, listed] of tree) {
+    if (linked(tree, child, pid) && !isConsoleHost(listed)) {
       children.push(child);
     }
   }
@@ -426,16 +458,16 @@ function listWindows() {
   return askWindows('Get-CimInstance Win32_Process -Property ProcessId,ParentProcessId,CreationDate,CommandLine | ForEach-Object { $began = 0; if ($_.CreationDate) { $began = ([DateTimeOffset]$_.CreationDate).ToUnixTimeMilliseconds() }; "$($_.ProcessId) $($_.ParentProcessId) $began $($_.CommandLine)" }', ASK_TIMEOUT_MS);
 }
 async function askPosix() {
-  const { stdout } = await run("ps", ["-e", "-o", "pid=,ppid=,args="], {
+  const { stdout } = await runHidden("ps", ["-e", "-o", "pid=,ppid=,args="], {
     timeout: ASK_TIMEOUT_MS,
     maxBuffer: 16 * 1024 * 1024
   });
   return stdout;
 }
-var run, ASK_TIMEOUT_MS = 15000, lastListingFailure, ONE_SHOT_OPTIONS;
+var ASK_TIMEOUT_MS = 15000, lastListingFailure, ONE_SHOT_OPTIONS;
 var init_process_children = __esm(() => {
+  init_spawn();
   init_windows_ask();
-  run = promisify(execFile);
   ONE_SHOT_OPTIONS = [
     "--import",
     "--quit",
@@ -674,7 +706,10 @@ function engineFlagsAmongGameArgs(args) {
   return args.filter((one) => Object.hasOwn(ENGINE_FLAGS, one) || Object.hasOwn(SET_BY_ARGUMENT, one));
 }
 function runArguments(options) {
-  const args = options.headless ? ["--headless", "--path", options.projectPath] : ["--path", options.projectPath];
+  const args = [
+    ...options.headless ? ["--headless"] : [],
+    ...options.projectPath === null ? [] : ["--path", options.projectPath]
+  ];
   if (options.silent === true && !options.headless) {
     args.push("--audio-driver", "Dummy");
   }
@@ -778,10 +813,8 @@ var init_launch = __esm(() => {
 });
 
 // src/godot-path.ts
-import { execFile as execFile2 } from "node:child_process";
 import { existsSync as existsSync2 } from "node:fs";
 import { normalize } from "node:path";
-import { promisify as promisify2 } from "node:util";
 
 class GodotLocator {
   answered = new Map;
@@ -838,7 +871,7 @@ class GodotLocator {
       reason = "does not exist";
     } else {
       try {
-        await run2(path, ["--version"]);
+        await runHidden(path, ["--version"]);
         reason = null;
       } catch (error) {
         reason = `does not answer --version: ${errorMessage(error)}`;
@@ -848,12 +881,11 @@ class GodotLocator {
     return reason;
   }
 }
-var run2;
 var init_godot_path = __esm(() => {
   init_detection();
   init_errors();
   init_launch();
-  run2 = promisify2(execFile2);
+  init_spawn();
 });
 
 // node_modules/yaml/dist/nodes/identity.js
@@ -7799,7 +7831,7 @@ var require_public_api = __commonJS(function(exports) {
 });
 
 // src/paths.ts
-import { realpathSync } from "node:fs";
+import { realpathSync, statSync as statSync2 } from "node:fs";
 import { isAbsolute, relative, resolve, sep } from "node:path";
 function realPathOr(path) {
   try {
@@ -7860,6 +7892,31 @@ function resolveWithinProject(projectPath, candidatePath) {
   }
   return { ok: true, absolutePath, relativePath };
 }
+function exportedBuild(projectPath, candidatePath) {
+  const found = resolveWithinProject(projectPath, candidatePath);
+  if (!found.ok) {
+    return found;
+  }
+  let real;
+  try {
+    real = realpathSync.native(found.absolutePath);
+  } catch {
+    return {
+      ok: false,
+      reason: `There is no ${found.relativePath} in the project to start: export the build first, with project_export run.`
+    };
+  }
+  if (!isWithinRoot(realPathOr(projectPath), real)) {
+    return {
+      ok: false,
+      reason: `${found.relativePath} leads outside the project, to ${real}, so it is not started.`
+    };
+  }
+  if (!statSync2(real).isFile()) {
+    return { ok: false, reason: `${found.relativePath} is not a file, so there is nothing to start.` };
+  }
+  return { ok: true, absolutePath: real, relativePath: found.relativePath };
+}
 var RESOURCE_SCHEME = "res://", OTHER_SCHEME;
 var init_paths = __esm(() => {
   OTHER_SCHEME = /^[a-zA-Z][a-zA-Z\d+.-]+:\/\//;
@@ -8154,15 +8211,13 @@ var init_game_log = __esm(() => {
 });
 
 // src/engine-run.ts
-import { spawn as spawn2 } from "node:child_process";
 function runEngine(executable, args, options = {}) {
   return new Promise((resolve) => {
     const log = new GameLog;
     let failure = null;
     const signal = callSignal();
-    const child = spawn2(executable, [...args], {
+    const child = spawnHidden(executable, args, {
       stdio: ["ignore", "pipe", "pipe"],
-      windowsHide: true,
       ...signal === undefined ? {} : { signal }
     });
     child.stdout.on("data", (chunk) => {
@@ -8196,26 +8251,109 @@ function howItEnded(run) {
 var init_engine_run = __esm(() => {
   init_call_signal();
   init_game_log();
+  init_spawn();
 });
 
+// src/library-copies.ts
+import { existsSync as existsSync5, readdirSync as readdirSync3, readFileSync as readFileSync3, renameSync, unlinkSync } from "node:fs";
+import { basename as basename3, dirname as dirname4, isAbsolute as isAbsolute2, join as join5 } from "node:path";
+function freeLibraryCopies(projectPath, platform = process.platform) {
+  const setAside = [];
+  const swept = [];
+  if (platform !== "win32") {
+    return { setAside, swept };
+  }
+  for (const library of windowsLibraries(projectPath)) {
+    const folder = dirname4(library);
+    const copy = `~${basename3(library)}`;
+    if (existsSync5(join5(folder, copy))) {
+      const aside = join5(folder, `${copy}.aside-${process.pid}-${Date.now()}`);
+      try {
+        renameSync(join5(folder, copy), aside);
+        setAside.push(aside);
+      } catch {}
+    }
+    let names;
+    try {
+      names = readdirSync3(folder);
+    } catch {
+      continue;
+    }
+    for (const name of names) {
+      if (name.length > copy.length && name.toLowerCase().startsWith(copy.toLowerCase())) {
+        try {
+          unlinkSync(join5(folder, name));
+          swept.push(join5(folder, name));
+        } catch {}
+      }
+    }
+  }
+  return { setAside, swept };
+}
+function windowsLibraries(projectPath) {
+  const listed = readOrNull(join5(projectPath, ".godot", "extension_list.cfg"));
+  if (listed === null) {
+    return [];
+  }
+  const libraries = new Set;
+  for (const line of listed.split(/\r?\n/)) {
+    const manifest = resolveResource(projectPath, projectPath, line.trim());
+    const text = manifest === null ? null : readOrNull(manifest);
+    if (manifest === null || text === null) {
+      continue;
+    }
+    let inLibraries = false;
+    for (const row of text.split(/\r?\n/)) {
+      const section = /^\s*\[([^\]]+)\]/.exec(row)?.[1];
+      if (section !== undefined) {
+        inLibraries = section.trim() === "libraries";
+        continue;
+      }
+      const named = inLibraries ? /^\s*windows[\w.]*\s*=\s*"([^"]+)"/.exec(row)?.[1] : undefined;
+      const library = named === undefined ? null : resolveResource(projectPath, dirname4(manifest), named);
+      if (library !== null) {
+        libraries.add(library);
+      }
+    }
+  }
+  return [...libraries];
+}
+function resolveResource(projectPath, relativeTo, path) {
+  if (path === "") {
+    return null;
+  }
+  if (path.startsWith("res://")) {
+    return join5(projectPath, path.slice("res://".length));
+  }
+  return isAbsolute2(path) ? path : join5(relativeTo, path);
+}
+function readOrNull(path) {
+  try {
+    return readFileSync3(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+var init_library_copies = () => {};
+
 // src/reimport.ts
 import { createHash } from "node:crypto";
-import { existsSync as existsSync5, readFileSync as readFileSync3, rmSync as rmSync3, statSync as statSync3, utimesSync, writeFileSync as writeFileSync3 } from "node:fs";
-import { basename as basename3, join as join5 } from "node:path";
+import { existsSync as existsSync6, readFileSync as readFileSync4, rmSync as rmSync3, statSync as statSync4, utimesSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { basename as basename4, join as join6 } from "node:path";
 function forceNextImport(projectPath, resourcePath) {
   const relative = resourcePath.replace(/^res:\/\//, "");
-  const sidecar = join5(projectPath, `${relative}.import`);
-  if (!existsSync5(sidecar)) {
+  const sidecar = join6(projectPath, `${relative}.import`);
+  if (!existsSync6(sidecar)) {
     return;
   }
-  const { atime, mtimeMs } = statSync3(sidecar);
-  writeFileSync3(sidecar, readFileSync3(sidecar, "utf8").replace(/^valid=false\r?\n/m, ""));
+  const { atime, mtimeMs } = statSync4(sidecar);
+  writeFileSync3(sidecar, readFileSync4(sidecar, "utf8").replace(/^valid=false\r?\n/m, ""));
   utimesSync(sidecar, atime, new Date(mtimeMs + 2000));
   rmSync3(importRecord(projectPath, resourcePath), { force: true });
 }
 function importRecord(projectPath, resourcePath) {
   const digest = createHash("md5").update(resourcePath).digest("hex");
-  return join5(projectPath, ".godot", "imported", `${basename3(resourcePath)}-${digest}.md5`);
+  return join6(projectPath, ".godot", "imported", `${basename4(resourcePath)}-${digest}.md5`);
 }
 var init_reimport = () => {};
 
@@ -8235,17 +8373,17 @@ function alive(pid) {
 var init_alive = () => {};
 
 // src/scratch.ts
-import { existsSync as existsSync6, mkdtempSync, readdirSync as readdirSync3, rmSync as rmSync4 } from "node:fs";
+import { existsSync as existsSync7, mkdtempSync, readdirSync as readdirSync4, rmSync as rmSync4 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 import process6 from "node:process";
 function scratchDirectory(kind) {
-  return mkdtempSync(join6(tmpdir2(), `gdharness-${kind}-${process6.pid}-`));
+  return mkdtempSync(join7(tmpdir2(), `gdharness-${kind}-${process6.pid}-`));
 }
 function sweepAbandonedScratch(directory = tmpdir2()) {
   let entries;
   try {
-    entries = readdirSync3(directory);
+    entries = readdirSync4(directory);
   } catch {
     return;
   }
@@ -8256,7 +8394,7 @@ function sweepAbandonedScratch(directory = tmpdir2()) {
       continue;
     }
     try {
-      remove(join6(directory, entry));
+      remove(join7(directory, entry));
     } catch {}
   }
 }
@@ -8294,7 +8432,7 @@ function tryAgain(path, attempt) {
     lastTryOnExit();
   }
   const after = AGAIN_AFTER_MS[attempt];
-  if (after === undefined || !existsSync6(path)) {
+  if (after === undefined || !existsSync7(path)) {
     waiting.delete(path);
     if (after === undefined) {
       atExit.add(path);
@@ -8341,8 +8479,8 @@ var init_scratch = __esm(() => {
 });
 
 // src/headless.ts
-import { existsSync as existsSync7, readFileSync as readFileSync4, realpathSync as realpathSync2, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname4, join as join7 } from "node:path";
+import { existsSync as existsSync8, readFileSync as readFileSync5, realpathSync as realpathSync2, writeFileSync as writeFileSync4 } from "node:fs";
+import { dirname as dirname5, join as join8 } from "node:path";
 function snakeCased(params) {
   const result = emptyRecord();
   for (const [key, value] of Object.entries(params)) {
@@ -8397,7 +8535,7 @@ function refusalsIn(log) {
 }
 function scriptFault(problems, script) {
   const spelled = (path) => `(${path.replaceAll("\\", "/").toLowerCase()}/`;
-  const directories = [...new Set([spelled(dirname4(script)), spelled(resolvedOr(dirname4(script)))])];
+  const directories = [...new Set([spelled(dirname5(script)), spelled(resolvedOr(dirname5(script)))])];
   return problems.find((entry) => {
     const at = entry.detail.find((line) => line.startsWith("at: "))?.replaceAll("\\", "/").toLowerCase();
     return entry.severity === "error" && at !== undefined && directories.some((directory) => at.includes(directory));
@@ -8422,7 +8560,7 @@ function librariesNotCopied(messages) {
 }
 function extensionRetryNote(libraries, stillNotLoaded = []) {
   const second = stillNotLoaded.length === 0 ? "so the import was run again and loaded the extension, and the messages are from that second run." : `so the import was run again, and it still could not load ${stillNotLoaded.join(" and ")}: this answer is from an import without ${stillNotLoaded.length === 1 ? "it" : "them"}, and its messages say what the engine hit.`;
-  return `The first import could not load ${libraries.join(" and ")}: on Windows an engine running as the editor ` + "loads a GDExtension from a ~ copy beside the library, and the editor open on this project holds its own " + "copy there, so the first engine started beside it cannot make one. That failed attempt moves the " + `editor's copy aside, ${second} The editor's copy is left beside the library as a ~RF….TMP file, which ` + "can be deleted once the editor has exited.";
+  return `The first import could not load ${libraries.join(" and ")}: on Windows an engine running as the editor ` + "loads a GDExtension from a ~ copy beside the library, and the editor open on this project holds its own " + "copy there, so the first engine started beside it cannot make one. That failed attempt moves the " + `editor's copy aside, ${second} The editor's copy is left beside the library as a ~RF….TMP file, which ` + "the next import, export or editor this server starts on the project deletes once the editor has exited.";
 }
 async function runImport(godotPath, projectPath, options = {}) {
   const once = options.once ?? importOnce;
@@ -8430,6 +8568,7 @@ async function runImport(godotPath, projectPath, options = {}) {
     for (const target of options.forcing ?? []) {
       forceNextImport(projectPath, target);
     }
+    freeLibraryCopies(projectPath);
     return once(godotPath, projectPath);
   };
   const first = await pass();
@@ -8453,7 +8592,7 @@ async function importOnce(godotPath, projectPath) {
     ran = await runEngine(godotPath, [
       "--headless",
       "--log-file",
-      join7(logDir, "engine.log"),
+      join8(logDir, "engine.log"),
       "--path",
       projectPath,
       "--import"
@@ -8473,13 +8612,13 @@ async function importOnce(godotPath, projectPath) {
 }
 async function runOperation(engine, operation, params, projectPath) {
   const paramsDir = scratchDirectory("params");
-  const paramsFile = join7(paramsDir, `${operation}.json`);
-  const answerFile = join7(paramsDir, "answer.json");
+  const paramsFile = join8(paramsDir, `${operation}.json`);
+  const answerFile = join8(paramsDir, "answer.json");
   writeFileSync4(paramsFile, JSON.stringify(snakeCased(params)), "utf8");
   const args = [
     "--headless",
     "--log-file",
-    join7(paramsDir, "engine.log"),
+    join8(paramsDir, "engine.log"),
     "--path",
     projectPath,
     "--script",
@@ -8549,10 +8688,10 @@ async function runOperation(engine, operation, params, projectPath) {
   };
 }
 function answerIn(file) {
-  if (!existsSync7(file)) {
+  if (!existsSync8(file)) {
     return { kind: "none" };
   }
-  const text = readFileSync4(file, "utf8");
+  const text = readFileSync5(file, "utf8");
   try {
     const parsed = JSON.parse(text);
     return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? { kind: "answer", payload: parsed } : { kind: "unreadable", why: `it is JSON but not an object: ${text.slice(0, 200)}` };
@@ -8566,14 +8705,15 @@ function answerIn(file) {
 var AFTER_ANSWER_NOTE = "Printed after this operation had written its answer, while the engine ran the project's autoloads and shut down: Godot starts a project's autoloads in every script run and cannot be told not to. An error raised in a project script here is that autoload's own, and none of these changes the answer.", OWN_ERROR = "[ERROR] ", ANSWERED = "[gdharness] answered", MESSAGES_KEPT = 200, ERRORS_NAMED = 3;
 var init_headless = __esm(() => {
   init_engine_run();
+  init_library_copies();
   init_reimport();
   init_scratch();
 });
 
 // src/update-check.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "node:fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "node:fs";
 import { homedir as homedir3, tmpdir as tmpdir3 } from "node:os";
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 function packageUrl(root) {
   return `${root.replace(/\/+$/, "")}/gdharness/latest`;
 }
@@ -8595,28 +8735,28 @@ function cacheDirectory(environment) {
   };
   const home = set("HOME") ?? homedir3();
   if (process.platform === "win32") {
-    return join8(set("LOCALAPPDATA") ?? home, "gdharness");
+    return join9(set("LOCALAPPDATA") ?? home, "gdharness");
   }
   if (process.platform === "darwin") {
-    return join8(home, "Library", "Caches", "gdharness");
+    return join9(home, "Library", "Caches", "gdharness");
   }
-  return join8(set("XDG_CACHE_HOME") ?? join8(home, ".cache"), "gdharness");
+  return join9(set("XDG_CACHE_HOME") ?? join9(home, ".cache"), "gdharness");
 }
 function cacheFile(environment = process.env) {
   try {
     const directory = cacheDirectory(environment);
     mkdirSync3(directory, { recursive: true, mode: 448 });
-    return join8(directory, "update-check.json");
+    return join9(directory, "update-check.json");
   } catch {
-    return join8(tmpdir3(), "gdharness-update-check.json");
+    return join9(tmpdir3(), "gdharness-update-check.json");
   }
 }
 function readCache(path) {
   try {
-    if (!existsSync8(path)) {
+    if (!existsSync9(path)) {
       return null;
     }
-    const parsed = JSON.parse(readFileSync5(path, "utf8"));
+    const parsed = JSON.parse(readFileSync6(path, "utf8"));
     if (typeof parsed !== "object" || parsed === null) {
       return null;
     }
@@ -8764,7 +8904,7 @@ var init_update_check = __esm(() => {
 });
 
 // src/server-version.ts
-import { readFileSync as readFileSync6 } from "node:fs";
+import { readFileSync as readFileSync7 } from "node:fs";
 function editorIsStale(addonVersion, serverVersion, addonDigest, shippedDigest) {
   if (addonDigest !== undefined && addonDigest !== "" && shippedDigest !== undefined) {
     return addonDigest !== shippedDigest;
@@ -8835,7 +8975,7 @@ var init_server_version = __esm(() => {
   GODOT_DEBUG_MODE_DEFAULT = process.env["GODOT_DEBUG"] === "true" || DEBUG_MODE;
   SERVER_VERSION = (() => {
     try {
-      const pkg = JSON.parse(readFileSync6(new URL("../package.json", import.meta.url), "utf8"));
+      const pkg = JSON.parse(readFileSync7(new URL("../package.json", import.meta.url), "utf8"));
       return typeof pkg.version === "string" ? pkg.version : "0.0.0";
     } catch {
       return "0.0.0";
@@ -9620,8 +9760,8 @@ var init_gdscript_source = __esm(() => {
 });
 
 // src/class-cache.ts
-import { existsSync as existsSync9, readdirSync as readdirSync4, readFileSync as readFileSync7, statSync as statSync4 } from "node:fs";
-import { join as join9, posix } from "node:path";
+import { existsSync as existsSync10, readdirSync as readdirSync5, readFileSync as readFileSync8, statSync as statSync5 } from "node:fs";
+import { join as join10, posix } from "node:path";
 function isToolScript(source) {
   return TOOL.test(codeOf(source));
 }
@@ -9637,18 +9777,18 @@ function declaredClasses(projectPath) {
 }
 function eachScript(projectPath, each) {
   const visit = (directory, prefix) => {
-    if (existsSync9(join9(directory, ".gdignore"))) {
+    if (existsSync10(join10(directory, ".gdignore"))) {
       return;
     }
-    for (const entry of readdirSync4(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync5(directory, { withFileTypes: true })) {
       if (entry.name.startsWith(".")) {
         continue;
       }
-      const path = join9(directory, entry.name);
+      const path = join10(directory, entry.name);
       if (entry.isDirectory()) {
         visit(path, `${prefix}${entry.name}/`);
       } else if (entry.isFile() && entry.name.endsWith(".gd")) {
-        each(`res://${prefix}${entry.name}`, readFileSync7(path, "utf8"));
+        each(`res://${prefix}${entry.name}`, readFileSync8(path, "utf8"));
       }
     }
   };
@@ -9670,12 +9810,12 @@ function scriptsNaming(projectPath, classes) {
   return naming.sort((a, b) => a.script.localeCompare(b.script));
 }
 function cachedClasses(projectPath) {
-  const cache = join9(projectPath, ".godot", "global_script_class_cache.cfg");
-  if (!existsSync9(cache)) {
+  const cache = join10(projectPath, ".godot", "global_script_class_cache.cfg");
+  if (!existsSync10(cache)) {
     return null;
   }
   const listed = new Map;
-  const text = readFileSync7(cache, "utf8");
+  const text = readFileSync8(cache, "utf8");
   for (const entry of text.matchAll(/"class":\s*&"([^"]+)"[\s\S]*?"path":\s*"([^"]+)"/g)) {
     listed.set(entry[1] ?? "", entry[2] ?? "");
   }
@@ -9941,9 +10081,9 @@ function uncachedClassNote(types) {
   return `${types.join(", ")} ${one ? "is declared" : "are declared"} in this project and missing from ` + `.godot/global_script_class_cache.cfg, so a game launched now would not resolve ${one ? "it" : "them"} ` + "either. Try editor_rescan first: it asks the editor already running and starts nothing, and it " + "cleared this in 314ms in a second project with a 31-worker fan-out still importing. It is not " + "always enough, because a file another engine has already imported reads as settled and the " + "walk does not look inside it. project_import refresh_classes rewrites the cache from the " + "declarations on disk and does reach that case, at the cost of a short headless engine, which " + "is worth knowing when something else is already running against this project.";
 }
 function cacheWrittenAt(projectPath) {
-  const cache = join9(projectPath, ".godot", "global_script_class_cache.cfg");
+  const cache = join10(projectPath, ".godot", "global_script_class_cache.cfg");
   try {
-    return statSync4(cache).mtimeMs;
+    return statSync5(cache).mtimeMs;
   } catch {
     return null;
   }
@@ -9955,14 +10095,14 @@ function declaredSince(projectPath, paths, names, since) {
       return false;
     }
     try {
-      return statSync4(join9(projectPath, path.slice("res://".length))).mtimeMs > since;
+      return statSync5(join10(projectPath, path.slice("res://".length))).mtimeMs > since;
     } catch {
       return false;
     }
   });
 }
 function cachedAtMissingPaths(cached, projectPath) {
-  return [...cached].filter(([, path]) => path.startsWith("res://") && !existsSync9(join9(projectPath, path.slice("res://".length)))).map(([name]) => name).sort();
+  return [...cached].filter(([, path]) => path.startsWith("res://") && !existsSync10(join10(projectPath, path.slice("res://".length)))).map(([name]) => name).sort();
 }
 function staleAgainst(cached, projectPath) {
   return [...declaredClasses(projectPath)].filter(([name, path]) => cached.get(name) !== path).map(([name]) => name);
@@ -9987,8 +10127,8 @@ var init_class_cache = __esm(() => {
 });
 
 // src/project-scan.ts
-import { existsSync as existsSync10, readdirSync as readdirSync5, readFileSync as readFileSync8 } from "node:fs";
-import { extname, join as join10 } from "node:path";
+import { existsSync as existsSync11, readdirSync as readdirSync6, readFileSync as readFileSync9 } from "node:fs";
+import { extname, join as join11 } from "node:path";
 function skipped(name) {
   return name.startsWith(".") || SKIPPED.has(name);
 }
@@ -9996,10 +10136,10 @@ function steppedOver(directory) {
   return gdignored(directory) || installedByUs(directory);
 }
 function gdignored(directory) {
-  return existsSync10(join10(directory, ".gdignore"));
+  return existsSync11(join11(directory, ".gdignore"));
 }
 function installedByUs(directory) {
-  return existsSync10(join10(directory, VERSION_MARKER));
+  return existsSync11(join11(directory, VERSION_MARKER));
 }
 function projectStructure(projectPath) {
   const structure = { scenes: 0, scripts: 0, assets: 0, other: 0 };
@@ -10007,12 +10147,12 @@ function projectStructure(projectPath) {
     if (steppedOver(directory)) {
       return;
     }
-    for (const entry of readdirSync5(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync6(directory, { withFileTypes: true })) {
       if (skipped(entry.name)) {
         continue;
       }
       if (entry.isDirectory()) {
-        visit(join10(directory, entry.name));
+        visit(join11(directory, entry.name));
       } else if (entry.isFile()) {
         const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
         if (SCENE_EXTENSIONS.has(extension)) {
@@ -10036,13 +10176,13 @@ function projectFiles(projectPath, extensions) {
     if (steppedOver(directory)) {
       return;
     }
-    for (const entry of readdirSync5(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync6(directory, { withFileTypes: true })) {
       if (skipped(entry.name)) {
         continue;
       }
       const spelled = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
       if (entry.isDirectory()) {
-        visit(join10(directory, entry.name), spelled);
+        visit(join11(directory, entry.name), spelled);
       } else if (entry.isFile() && extensions.includes(extname(entry.name).toLowerCase())) {
         found.push(spelled);
       }
@@ -10057,20 +10197,20 @@ function scriptsWithoutUid(projectPath) {
     if (steppedOver(directory)) {
       return;
     }
-    for (const entry of readdirSync5(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync6(directory, { withFileTypes: true })) {
       if (skipped(entry.name)) {
         continue;
       }
       const spelled = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
       if (entry.isDirectory()) {
-        visit(join10(directory, entry.name), spelled);
+        visit(join11(directory, entry.name), spelled);
         continue;
       }
       if (!entry.isFile()) {
         continue;
       }
       const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
-      if (CARRIES_A_UID.has(extension) && !existsSync10(join10(directory, `${entry.name}.uid`))) {
+      if (CARRIES_A_UID.has(extension) && !existsSync11(join11(directory, `${entry.name}.uid`))) {
         found.push(spelled);
       }
     }
@@ -10087,11 +10227,11 @@ function projectTexts(projectPath) {
     if (steppedOver(directory)) {
       return;
     }
-    for (const entry of readdirSync5(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync6(directory, { withFileTypes: true })) {
       if (skipped(entry.name)) {
         continue;
       }
-      const absolute = join10(directory, entry.name);
+      const absolute = join11(directory, entry.name);
       const spelled = `${prefix}${entry.name}`;
       if (entry.isDirectory()) {
         visit(absolute, `${spelled}/`);
@@ -10101,7 +10241,7 @@ function projectTexts(projectPath) {
       if (!entry.isFile() || BINARY_EXTENSIONS.has(extension)) {
         continue;
       }
-      const bytes = readFileSync8(absolute);
+      const bytes = readFileSync9(absolute);
       if (!isBinary(bytes)) {
         found.push({ path: `res://${spelled}`, absolute, text: bytes.toString("utf8") });
       }
@@ -10117,11 +10257,11 @@ function ignoredTexts(projectPath) {
       return;
     }
     const under = ignored || gdignored(directory);
-    for (const entry of readdirSync5(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync6(directory, { withFileTypes: true })) {
       if (skipped(entry.name)) {
         continue;
       }
-      const absolute = join10(directory, entry.name);
+      const absolute = join11(directory, entry.name);
       const spelled = `${prefix}${entry.name}`;
       if (entry.isDirectory()) {
         visit(absolute, `${spelled}/`, under);
@@ -10131,7 +10271,7 @@ function ignoredTexts(projectPath) {
       if (!under || !entry.isFile() || BINARY_EXTENSIONS.has(extension) || entry.name === ".gdignore") {
         continue;
       }
-      const bytes = readFileSync8(absolute);
+      const bytes = readFileSync9(absolute);
       if (!isBinary(bytes)) {
         found.push({ path: `res://${spelled}`, absolute, text: bytes.toString("utf8") });
       }
@@ -10154,14 +10294,14 @@ function searchProject(projectPath, options) {
     if (steppedOver(directory)) {
       return;
     }
-    for (const entry of readdirSync5(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync6(directory, { withFileTypes: true })) {
       if (full()) {
         return;
       }
       if (skipped(entry.name)) {
         continue;
       }
-      const entryPath = join10(directory, entry.name);
+      const entryPath = join11(directory, entry.name);
       if (entry.isDirectory()) {
         visit(entryPath);
         continue;
@@ -10170,7 +10310,7 @@ function searchProject(projectPath, options) {
       if (!entry.isFile() || extensions !== null && !extensions.has(extension)) {
         continue;
       }
-      const bytes = readFileSync8(entryPath);
+      const bytes = readFileSync9(entryPath);
       if (extensions === null && isBinary(bytes)) {
         continue;
       }
@@ -10257,7 +10397,7 @@ var init_answer_json = __esm(() => {
 });
 
 // src/resources.ts
-import { readFileSync as readFileSync9, realpathSync as realpathSync3 } from "node:fs";
+import { readFileSync as readFileSync10, realpathSync as realpathSync3 } from "node:fs";
 import { extname as extname2, resolve as resolve3 } from "node:path";
 function ensureProjectPath(getProjectPath) {
   const projectPath = getProjectPath();
@@ -10453,7 +10593,7 @@ function readResourceText(uri, getProjectPath) {
   const parsedUri = parseGodotUri(uri);
   if (parsedUri.kind === "project-info") {
     const projectFilePath = resolveProjectFile(projectPath, "project.godot");
-    const rawProject = readFileSync9(projectFilePath, "utf-8");
+    const rawProject = readFileSync10(projectFilePath, "utf-8");
     const parsedProject = parseProjectGodot(rawProject);
     return {
       mimeType: "application/json",
@@ -10462,7 +10602,7 @@ function readResourceText(uri, getProjectPath) {
   }
   const filePath = resolveProjectFile(projectPath, parsedUri.resourcePath);
   ensureAllowedExtension(parsedUri.kind, filePath);
-  const text = readFileSync9(filePath, "utf-8");
+  const text = readFileSync10(filePath, "utf-8");
   return {
     mimeType: parsedUri.kind === "script" ? "text/x-gdscript" : "text/plain",
     text
@@ -10603,20 +10743,19 @@ function readParams(params, key) {
 }
 
 // src/setup.ts
-import { spawnSync } from "node:child_process";
 import { createHash as createHash3 } from "node:crypto";
 import {
   cpSync,
-  existsSync as existsSync11,
+  existsSync as existsSync12,
   mkdirSync as mkdirSync4,
-  readdirSync as readdirSync6,
-  readFileSync as readFileSync10,
+  readdirSync as readdirSync7,
+  readFileSync as readFileSync11,
   rmdirSync,
   rmSync as rmSync5,
-  statSync as statSync5,
+  statSync as statSync6,
   writeFileSync as writeFileSync6
 } from "node:fs";
-import { dirname as dirname5, join as join11 } from "node:path";
+import { dirname as dirname6, join as join12 } from "node:path";
 import { fileURLToPath } from "node:url";
 function editorAddonDigest(from = shippedAddonsDirectory()) {
   return addonsDigest(EDITOR_PLUGINS, from);
@@ -10627,25 +10766,25 @@ function runtimeAddonDigest(from = shippedAddonsDirectory()) {
 function addonsDigest(names, from) {
   const hash = createHash3("sha256");
   const walk = (directory, relative) => {
-    for (const name of readdirSync6(directory).sort()) {
+    for (const name of readdirSync7(directory).sort()) {
       if (name === VERSION_MARKER || name === DIGEST_MARKER) {
         continue;
       }
-      const path = join11(directory, name);
+      const path = join12(directory, name);
       const inside = `${relative}/${name}`;
-      if (statSync5(path).isDirectory()) {
+      if (statSync6(path).isDirectory()) {
         walk(path, inside);
       } else {
         hash.update(`${inside}
 `);
-        hash.update(readFileSync10(path));
+        hash.update(readFileSync11(path));
         hash.update(`
 `);
       }
     }
   };
   for (const name of names) {
-    walk(join11(from, name), name);
+    walk(join12(from, name), name);
   }
   return hash.digest("hex");
 }
@@ -10676,60 +10815,60 @@ function installedRuntimeDigest(projectPath) {
   return digestMarker(projectPath, RUNTIME_ADDON);
 }
 function digestMarker(projectPath, addon) {
-  const marker = join11(projectPath, "addons", addon, DIGEST_MARKER);
-  if (!existsSync11(marker)) {
+  const marker = join12(projectPath, "addons", addon, DIGEST_MARKER);
+  if (!existsSync12(marker)) {
     return null;
   }
-  const said = readFileSync10(marker, "utf8").trim();
+  const said = readFileSync11(marker, "utf8").trim();
   return said === "" ? null : said;
 }
 function shippedAddonsDirectory() {
-  return join11(dirname5(fileURLToPath(import.meta.url)), "godot", "addons");
+  return join12(dirname6(fileURLToPath(import.meta.url)), "godot", "addons");
 }
 function shippedOperationsScript() {
-  return join11(dirname5(fileURLToPath(import.meta.url)), "godot", "operations", "godot_operations.gd");
+  return join12(dirname6(fileURLToPath(import.meta.url)), "godot", "operations", "godot_operations.gd");
 }
 function installAddons(projectPath, from = shippedAddonsDirectory()) {
   const installed = [];
   for (const name of ADDONS) {
-    const source = join11(from, name);
-    if (!existsSync11(join11(source, name === RUNTIME_ADDON ? "runtime_autoload.gd" : "plugin.cfg"))) {
+    const source = join12(from, name);
+    if (!existsSync12(join12(source, name === RUNTIME_ADDON ? "runtime_autoload.gd" : "plugin.cfg"))) {
       throw new Error(`The package holds no ${name} addon at ${source}.`);
     }
-    const target = join11(projectPath, "addons", name);
-    const replaced = existsSync11(target);
+    const target = join12(projectPath, "addons", name);
+    const replaced = existsSync12(target);
     rmSync5(target, { recursive: true, force: true });
-    mkdirSync4(dirname5(target), { recursive: true });
+    mkdirSync4(dirname6(target), { recursive: true });
     cpSync(source, target, { recursive: true });
-    writeFileSync6(join11(target, VERSION_MARKER), `${SERVER_VERSION}
+    writeFileSync6(join12(target, VERSION_MARKER), `${SERVER_VERSION}
 `);
     installed.push({ name, path: target, replaced });
   }
-  writeFileSync6(join11(projectPath, "addons", ADDONS[0], DIGEST_MARKER), `${editorAddonDigest(from)}
+  writeFileSync6(join12(projectPath, "addons", ADDONS[0], DIGEST_MARKER), `${editorAddonDigest(from)}
 `);
-  writeFileSync6(join11(projectPath, "addons", RUNTIME_ADDON, DIGEST_MARKER), `${runtimeAddonDigest(from)}
+  writeFileSync6(join12(projectPath, "addons", RUNTIME_ADDON, DIGEST_MARKER), `${runtimeAddonDigest(from)}
 `);
   return installed;
 }
 function installedAddonVersion(projectPath) {
-  const marker = join11(projectPath, "addons", ADDONS[0], VERSION_MARKER);
-  if (!existsSync11(marker)) {
+  const marker = join12(projectPath, "addons", ADDONS[0], VERSION_MARKER);
+  if (!existsSync12(marker)) {
     return null;
   }
-  const said = readFileSync10(marker, "utf8").trim();
+  const said = readFileSync11(marker, "utf8").trim();
   return said === "" ? null : said;
 }
 function removeAddons(projectPath) {
   const removed = [];
   for (const name of ADDONS) {
-    const target = join11(projectPath, "addons", name);
-    if (existsSync11(target)) {
+    const target = join12(projectPath, "addons", name);
+    if (existsSync12(target)) {
       rmSync5(target, { recursive: true, force: true });
       removed.push(target);
     }
   }
-  const addons = join11(projectPath, "addons");
-  if (removed.length > 0 && existsSync11(addons) && readdirSync6(addons).length === 0) {
+  const addons = join12(projectPath, "addons");
+  if (removed.length > 0 && existsSync12(addons) && readdirSync7(addons).length === 0) {
     rmdirSync(addons);
     removed.push(addons);
   }
@@ -10763,7 +10902,7 @@ function loaderAmong(projectPath, named) {
     }
     let source = null;
     try {
-      source = readFileSync10(join11(projectPath, path), "utf8");
+      source = readFileSync11(join12(projectPath, path), "utf8");
     } catch {}
     if (source?.includes(RUNTIME_AUTOLOAD.path)) {
       return { name: entry, path, exists: true };
@@ -10786,7 +10925,7 @@ function trackedByGit(projectPath, wanted) {
   if (wanted.length === 0) {
     return new Set;
   }
-  const asked = spawnSync("git", ["ls-files", "-z", "--", ...wanted], {
+  const asked = spawnSyncHidden("git", ["ls-files", "-z", "--", ...wanted], {
     cwd: projectPath,
     encoding: "utf8"
   });
@@ -10805,10 +10944,10 @@ function enabledPlugins(settings) {
 function inspectProject(projectPath) {
   const problems = [];
   const addons = ADDONS.map((name) => {
-    const directory = join11(projectPath, "addons", name);
-    const marker = join11(directory, VERSION_MARKER);
-    const installed = existsSync11(directory);
-    const version = existsSync11(marker) ? readFileSync10(marker, "utf8").trim() : null;
+    const directory = join12(projectPath, "addons", name);
+    const marker = join12(directory, VERSION_MARKER);
+    const installed = existsSync12(directory);
+    const version = existsSync12(marker) ? readFileSync11(marker, "utf8").trim() : null;
     const current = version === SERVER_VERSION;
     if (!installed) {
       problems.push(`addons/${name} is not installed; run gdharness setup`);
@@ -10817,7 +10956,7 @@ function inspectProject(projectPath) {
     }
     return { name, installed, version, current };
   });
-  const settings = parseProjectGodot(readFileSync10(join11(projectPath, "project.godot"), "utf8"));
+  const settings = parseProjectGodot(readFileSync11(join12(projectPath, "project.godot"), "utf8"));
   const pluginsEnabled = enabledPlugins(settings);
   for (const name of EDITOR_PLUGINS) {
     if (!pluginsEnabled.includes(name)) {
@@ -10833,7 +10972,7 @@ function inspectProject(projectPath) {
   const tracked = trackedByGit(projectPath, [...named.values()]);
   const addonMissing = (path) => addons.some((addon) => !addon.installed && path.startsWith(`addons/${addon.name}/`));
   for (const [name, path] of named) {
-    if (!existsSync11(join11(projectPath, path))) {
+    if (!existsSync12(join12(projectPath, path))) {
       if (!addonMissing(path)) {
         problems.push(`the ${name} autoload names res://${path}, which is not in this project, so it boots with a missing script; restore that file, or point the autoload at one that is here`);
       }
@@ -10869,6 +11008,7 @@ var init_setup = __esm(() => {
   init_project_scan();
   init_resources();
   init_server_version();
+  init_spawn();
   ADDONS = ["gdharness_editor", "gdharness_runtime", "auto_reload"];
   EDITOR_PLUGINS = ["gdharness_editor", "auto_reload"];
   RUNTIME_AUTOLOAD = {
@@ -11917,6 +12057,11 @@ var init_tool_definitions = __esm(() => {
           ops: ["start"],
           description: "start: run the game with no sound out of the machine, by starting the engine with --audio-driver Dummy: every stream still plays and every playback position still advances, so what is playing can still be asked. The editor takes no engine flags for a game it plays, so a silent windowed run is started by this server, whose keeper is its debugger rather than the editor. A headless run, check's included, is silent already. Default false, or true when GDHARNESS_SILENT is set in the server's environment to anything but 0 or false; silent: false then plays through the editor as before."
         },
+        executable: {
+          type: "string",
+          ops: ["start"],
+          description: "start: an exported build to run instead of the project, as a path inside the project such as export/windows/game.exe, so what a player runs can be measured. It takes args, engineArgs, savesIn, env, headless and visible as the project does, goes on the hidden desktop the same way, and is ended by stop, but takes no scene (its pack holds the main scene) and no profile, and has no debugger: a release build quits when given one. Its runtime is not waited for."
+        },
         savesIn: {
           type: "string",
           ops: ["start", "check"],
@@ -12072,7 +12217,7 @@ var init_tool_definitions = __esm(() => {
       name: "editor_rescan",
       title: "Rescan the project",
       effect: "additive",
-      description: "Makes the running editor scan the project filesystem, so files written outside it are picked up. A scan or an import the editor is already running is waited out first rather than scanned over, which would start a second import over it, and the answer says how long under waitedForEditorScanMs. The scan is a change-detecting walk rather than an unconditional reparse, so a file another engine has already imported reads as settled and the walk does not look inside it: its class_name then stays out of the list the editor resolves against, however many times you scan. Any class in that state is named under unseenByEditor, which is what no check on disk can see, since the declaration and the cache are both correct there and only the editor disagrees. The cure is this call on its own, with no change to the declaring script: measured against a real editor on three platforms, with idle waits of the same length ruled out so the scan is credited rather than the time it takes, and reproduced in a second project against its own reproduction in 203ms. editor_launch restart also does it and costs a window, and project_import refresh_classes does not: it rewrites the cache and does not touch what the editor is holding. The walk also passes over a file whose .uid alone changed, so the editor keeps the old UID and every engine reading its cache warns of a duplicate; before scanning, each file whose .uid names a UID the editor does not hold for it is read again and named under uidsReread, and files on disk naming one UID between them are named under uidsDuplicatedOnDisk, which reading again cannot settle. A class the scan brings in is named under broughtIn, and every script naming it is reloaded in the editor and named under dependentsReloaded: what the editor compiled from them while it could not see the class stays compiled that way after the scan, and a script extending a new base class went on reporting \"Could not find base class\" until reloaded. One that would not reload is named under dependentsNotReloaded and the call is not ok, as it is not when the script named in reloadScript was not reloaded. A scan writes .godot/global_script_class_cache.cfg from the list the editor is holding, so a class the editor cannot resolve goes out of that file with it. That is not a reason to refuse the scan, because on a class the editor has merely not walked yet the scan is the cure; what the answer does instead is name the loss under cacheLost and rebuild the cache from the files, naming what came back under cacheRestored, so no fresh engine, CI run or clone inherits the short file. An editor that lost classes is still holding the short list, so the note says to restart it before scanning again. The other direction is guarded the same way: a class the editor still holds for a script that was renamed or deleted comes back into the cache at a path that is not there, and the next engine to read it fails on \"Could not parse global class\" in whichever correct script shares the bare name, so the cache is rebuilt without it and the answer names it under cacheDropped; the editor goes on holding it until it is restarted, and every scan until then ends in that rebuild. A script or shader written outside the editor has no .uid sidecar until something imports it, and the scan writes one beside it, which a project that commits sidecars needs before the commit. Needs the editor connected.",
+      description: "Makes the running editor scan the project filesystem, so files written outside it are picked up. A scan or an import the editor is already running is waited out first rather than scanned over, which would start a second import over it, and the answer says how long under waitedForEditorScanMs. The scan is a change-detecting walk rather than an unconditional reparse, so a file another engine has already imported reads as settled and the walk does not look inside it: its class_name then stays out of the list the editor resolves against, however many times you scan. Any class in that state is named under unseenByEditor, which is what no check on disk can see, since the declaration and the cache are both correct there and only the editor disagrees. The cure is this call on its own, with no change to the declaring script: measured against a real editor on three platforms, with idle waits of the same length ruled out so the scan is credited rather than the time it takes, and reproduced in a second project against its own reproduction in 203ms. editor_launch restart also does it and costs a window, and project_import refresh_classes does not: it rewrites the cache and does not touch what the editor is holding. The walk also passes over a file whose .uid alone changed, so the editor keeps the old UID and every engine reading its cache warns of a duplicate; before scanning, each file whose .uid names a UID the editor does not hold for it is read again and named under uidsReread, and files on disk naming one UID between them are named under uidsDuplicatedOnDisk, which reading again cannot settle. A class the scan brings in is named under broughtIn, and every script naming it is reloaded in the editor and named under dependentsReloaded: what the editor compiled from them while it could not see the class stays compiled that way after the scan, and a script extending a new base class went on reporting \"Could not find base class\" until reloaded. One that would not reload is named under dependentsNotReloaded and the call is not ok, as it is not when the script named in reloadScript was not reloaded. An editor importing answers nothing until the import is over, and a hidden one imports on the thread that answers, so a large addon install can leave the rescan itself unanswered: that is waited for as any busy editor is, within timeoutMs, and when the wait runs out first the answer is stillWorking. The classes the editor could not see before that scan are then noted in the project, and the next editor_rescan of the same editor, from any server, names them under broughtIn and reloads what names them, which it could not otherwise know to do, since by then the editor sees them. A scan writes .godot/global_script_class_cache.cfg from the list the editor is holding, so a class the editor cannot resolve goes out of that file with it. That is not a reason to refuse the scan, because on a class the editor has merely not walked yet the scan is the cure; what the answer does instead is name the loss under cacheLost and rebuild the cache from the files, naming what came back under cacheRestored, so no fresh engine, CI run or clone inherits the short file. An editor that lost classes is still holding the short list, so the note says to restart it before scanning again. The other direction is guarded the same way: a class the editor still holds for a script that was renamed or deleted comes back into the cache at a path that is not there, and the next engine to read it fails on \"Could not parse global class\" in whichever correct script shares the bare name, so the cache is rebuilt without it and the answer names it under cacheDropped; the editor goes on holding it until it is restarted, and every scan until then ends in that rebuild. A script or shader written outside the editor has no .uid sidecar until something imports it, and the scan writes one beside it, which a project that commits sidecars needs before the commit. Needs the editor connected.",
       parameters: {
         projectPath: PROJECT_PATH,
         timeoutMs: {
@@ -12150,13 +12295,13 @@ var init_tool_definitions = __esm(() => {
         pid: RUNNING_PID,
         nodePath: {
           type: "string",
-          ops: ["tree", "text", "find", "rect", "property"],
-          description: "tree, find, text: where to start, default /root. rect: the node to place. property: the node to read."
+          ops: ["tree", "text", "find", "rect", "property", "accessibility"],
+          description: 'tree, find, text: where to start, default /root. rect: the node to place. property: the node to read, or an engine singleton by name as runtime_invoke takes them, "Engine" with property "get_frames_drawn()". accessibility: only the elements that node and those below it made, whether as node or part_of, each window keeping the outermost of them with what they hold, and matched counting them. What a ScrollContainer holds out of its sight is not in the tree until it is scrolled to, so an element missing under one may be scrolled away rather than hidden.'
         },
         property: {
           type: "string",
           ops: ["property", "find"],
-          description: 'property: which one to read. find: read this one off every node matched, so a panel of labels is one call rather than one per label. Colons read through what a node holds, "_game:clock:speed", which is where a game keeps what is worth asking about. A number or a key steps into a list or a map, "_game:run:roster:0:traits", which is how the lists a game keeps its state in are walked: a roster, a board, an in-tray. A packed list, such as a PackedStringArray, steps the same way. A negative number counts from the end. A step written as a call, "get_viewport():gui_get_focus_owner()", calls a method that only reads (an engine method the engine marks as reading, or a game method not declared -> void, so queue_free() is refused) and walks into what it returned, which is how a question only a method answers is read in one call: which control holds the focus in the viewport this one is in. An engine method that reads takes literal arguments in its brackets, words in double quotes, numbers, true, false or null, so a control\'s theme is read where it is drawn: \'get_theme_stylebox("panel"):content_margin_top\' or \'get_theme_constant("separation")\'. A game method is given none in a path, since nothing marks one as only reading; runtime_invoke call takes those. A list or a map answers the calls that read it and take no arguments, "_game:run:board:size()" or "_game:inbox:keys()", and not those that change it, such as clear() or sort(). A step that is not there is named, and says what was there instead.'
+          description: 'property: which one to read. find: read this one off every node matched, so a panel of labels is one call rather than one per label. Colons read through what a node holds, "_game:clock:speed", which is where a game keeps what is worth asking about. A number or a key steps into a list or a map, "_game:run:roster:0:traits", which is how the lists a game keeps its state in are walked: a roster, a board, an in-tray. A packed list, such as a PackedStringArray, steps the same way. A negative number counts from the end. A vector, a colour, a rectangle or a transform is stepped into by its components as GDScript names them, so one axis is one number: "size:x", "global_position:y", "modulate:a", "global_transform:origin:z"; a name the value does not have is refused, naming the ones it has. A step written as a call, "get_viewport():gui_get_focus_owner()", calls a method that only reads (an engine method the engine marks as reading, or a game method not declared -> void, so queue_free() is refused) and walks into what it returned, which is how a question only a method answers is read in one call: which control holds the focus in the viewport this one is in. An engine method that reads takes literal arguments in its brackets, words in double quotes, numbers, true, false or null, so a control\'s theme is read where it is drawn: \'get_theme_stylebox("panel"):content_margin_top\' or \'get_theme_constant("separation")\'. A game method is given none in a path, since nothing marks one as only reading; runtime_invoke call takes those. A list or a map answers the calls that read it and take no arguments, "_game:run:board:size()" or "_game:inbox:keys()", and not those that change it, such as clear() or sort(). A step that is not there is named, and says what was there instead.'
         },
         depth: {
           type: "integer",
@@ -12172,8 +12317,8 @@ var init_tool_definitions = __esm(() => {
         properties: {
           type: "array",
           items: { type: "string" },
-          ops: ["tree"],
-          description: "tree: the properties to read off each node, by name, so the text of every label and button under a panel is one call: a node that has not got one leaves it out. Colons read through what a node holds, as property does for find."
+          ops: ["tree", "accessibility"],
+          description: 'tree: the properties to read off each node, by name, so the text of every label and button under a panel is one call: a node that has not got one leaves it out. Colons read through what a node holds, as property does for find. accessibility: the fields to keep on each element, such as ["role", "name", "node"], leaving out the rest (bounds, actions, tooltip); children are always kept.'
         },
         className: {
           type: "string",
@@ -12189,15 +12334,15 @@ var init_tool_definitions = __esm(() => {
         group: { type: "string", ops: ["find"], description: "find: a group the node is in." },
         says: {
           type: "string",
-          ops: ["find"],
-          description: 'find: part of what the node has written on it as drawn, the way the text op reads it, case-insensitively and with a typed space matching any space the game draws (a non-breaking one included), which is how a button is reached by the word on it rather than by a generated path. Its own text, so a row is found by the label in it, and hidden nodes match. A bare word is a contains; write a glob and it is one, matched against the whole of what the node says, the same as namePattern, and a glob that finds nothing says under note how many nodes it would find open at both ends. A label with a line break is matched with the break in the words, and a backslash followed by n counts as one. Alternatives separated by | match when any one of them does, each by these rules ("*won*|*lost*"); write \\| for a bar that is part of the words.'
+          ops: ["find", "accessibility"],
+          description: 'accessibility: only the elements whose name or value says these words, matched as find matches them, with what they hold. find: part of what the node has written on it as drawn, the way the text op reads it, case-insensitively and with a typed space matching any space the game draws (a non-breaking one included), which is how a button is reached by the word on it rather than by a generated path. Its own text, so a row is found by the label in it, and hidden nodes match. A bare word is a contains; write a glob and it is one, matched against the whole of what the node says, the same as namePattern, and a glob that finds nothing says under note how many nodes it would find open at both ends. A label with a line break is matched with the break in the words, and a backslash followed by n counts as one. Alternatives separated by | match when any one of them does, each by these rules ("*won*|*lost*"); write \\| for a bar that is part of the words.'
         },
         limit: {
           type: "integer",
           minimum: 1,
           maximum: 5000,
-          ops: ["find", "text"],
-          description: "find: the most nodes to answer with, default 100. text: the most lines, default 500, with omitted saying how many lines that left behind. At most 5000 for either. A screen whose dialog sits under a long list is a screen read with omitted greater than zero, so raise this or point root at the dialog rather than reading the answer as what is on screen."
+          ops: ["find", "text", "accessibility"],
+          description: "find: the most nodes to answer with, default 100. text: the most lines, default 500, with omitted saying how many lines that left behind. accessibility: the most elements below the windows, depth first, with omitted counting the rest; default all. At most 5000 for either. A screen whose dialog sits under a long list is a screen read with omitted greater than zero, so raise this or point root at the dialog rather than reading the answer as what is on screen."
         },
         includeHidden: {
           type: "boolean",
@@ -12241,12 +12386,12 @@ var init_tool_definitions = __esm(() => {
         },
         metrics: {
           effect: "read",
-          summary: "frame time, memory, draw calls and the rest. frame_time is the mean wall time of a frame over the last frames_timed frames (up to 120, timed by the game itself, physics and the wait for the display included), frame_time_max the slowest of them, both in seconds and null before a frame has passed; vsync says whether a frame waits for the display, and max_fps is the game's frame-rate cap, 0 for none. fps, process_time_max and physics_time are the engine's monitors, which it sets once a second: the frames counted in the last second, and the slowest process and physics step in it, so they trail a change by up to a second and the last two are a worst case rather than the frame. The memory, object and render counts are read as asked. memory_static is what the engine allocated on the CPU side, in bytes; render_video_mem_used, render_texture_mem_used and render_buffer_mem_used are what the renderer has on the GPU, in bytes, which memory_static does not count",
+          summary: "frame time, memory, draw calls and the rest. frame_time is the mean wall time of a frame over the last frames_timed frames (up to 120, timed by the game itself, physics and the wait for the display included), frame_time_max the slowest of them, both in seconds and null before a frame has passed; vsync says whether a frame waits for the display, and max_fps is the game's frame-rate cap, 0 for none. physics_steps_per_second is the physics steps taken a second over those frames, fewer than physics_ticks_per_second when a frame needs more than max_physics_steps_per_frame or the editor's Game view slows it. fps, process_time_max and physics_time are the engine's monitors, which it sets once a second: the frames counted in the last second, and the slowest process and physics step in it, so they trail a change by up to a second and the last two are a worst case rather than the frame. The memory, object and render counts are read as asked. memory_static is what the engine allocated on the CPU side, in bytes; render_video_mem_used, render_texture_mem_used and render_buffer_mem_used are what the renderer has on the GPU, in bytes, which memory_static does not count",
           requires: []
         },
         accessibility: {
           effect: "read",
-          summary: `what the game tells a screen reader, read through UI Automation as a Windows screen reader reads it, under windows: one tree per window, each element with its role as UI Automation names it (text for static text, button, check_box, group for a control holding others), its name, its value where it has one, its bounds in the window's pixels, the actions a screen reader is offered (click, focus, toggle, set_value, select, expand_collapse, scroll_into_view), and focused on the one holding the focus. The name is what is read aloud, so an empty one is read as nothing; static text takes it from DisplayServer.accessibility_update_set_value, not from a name set on it, and the answer says under _note how many text elements on screen have none. With no control focused, the engine reports the first node under the root as focused, which in a run with the runtime is GdharnessRuntime. Needs a windowed run on Windows started with engineArgs ["--accessibility", "always"] or with the project's accessibility/general/accessibility_support at Always Active, since the engine builds the tree only when asked; reading it takes a second or two, starting PowerShell inside the game so it reaches the game's own desktop`,
+          summary: "what the game tells a screen reader, read through UI Automation as a Windows screen reader reads it, under windows: one tree per window, each element with its role (text for static text, button, check_box, group for a control holding others), name, value, description, placeholder, bounds in the window's pixels, the actions a reader is offered (click, focus, toggle, set_value, select, expand_collapse, scroll_into_view), and focused on the one with the focus. node is the node that made the element; an element a node made as a part of itself has part_of, the node drawn around it that holds its words, or part_of_candidates where several are, and part: announcement marks the text a window announces through. An empty name is read as nothing: static text takes it from accessibility_update_set_value, and _note counts the text elements on screen with none. tooltip is the node's tooltip_text, which a Windows reader is not told. With nothing focused, the engine calls GdharnessRuntime focused. Needs a windowed run on Windows started with engineArgs [\"--accessibility\", \"always\"] or accessibility_support at Always Active, since the engine builds the tree only when asked; reading takes a second or two",
           requires: []
         }
       },
@@ -12255,19 +12400,19 @@ var init_tool_definitions = __esm(() => {
     {
       name: "runtime_invoke",
       title: "Set or call in the running game",
-      description: "Sets a property or calls a method on a node in the running game. Needs the game running with the runtime addon. The answer carries elapsed_usec, how long the call or the write took inside the game, measured around it there: the round trip to the game is a second or more, so timing from outside measures that instead. Errors and warnings the engine reported while a called method ran come back under errors, the first 20, with errors_not_shown counting the rest. A call that takes longer than timeoutMs is not cancelled: the answer is pending: true with a requestId, the call goes on and does everything it was asked, and op result with that requestId collects its reply once it comes.",
+      description: "Sets a property or calls a method on a node, or on one of the engine singletons nodePath names, in the running game. Needs the game running with the runtime addon. The answer carries elapsed_usec, how long the call or the write took inside the game, measured around it there: the round trip to the game is a second or more, so timing from outside measures that instead. Errors and warnings the engine reported while a called method ran come back under errors, the first 20, with errors_not_shown counting the rest. A call that takes longer than timeoutMs is not cancelled: the answer is pending: true with a requestId, the call goes on and does everything it was asked, and op result with that requestId collects its reply once it comes.",
       parameters: {
         projectPath: RUNNING_PROJECT_PATH,
         pid: RUNNING_PID,
         nodePath: {
           type: "string",
           ops: ["set", "call"],
-          description: 'Absolute node path, such as "/root/Main/Player".'
+          description: 'Absolute node path, such as "/root/Main/Player", or the name of an engine singleton: Engine, Performance, RenderingServer, AudioServer, PhysicsServer2D, PhysicsServer3D, NavigationServer2D, NavigationServer3D, Time or TranslationServer, so "RenderingServer" with method viewport_get_measured_render_time_cpu reads what the engine measures. The other singletons are refused: OS runs programs, DisplayServer switches the keyboard layout and Input moves the real pointer.'
         },
         property: {
           type: "string",
           ops: ["set"],
-          description: 'set: which one to write. Colons write through what a node holds, "_game:run:day", and a number or a key steps into a list or a map on the way, "_game:run:roster:0:name", a negative number counting from the end, and a step written as a call, "get_viewport():gui_embed_subwindows", walks through what a reading method returned, as runtime_inspect property describes. A map keyed by numbers is stepped into by the number, "_game:units:3". The answer reads back off the same holder, and a write that leaves the property as it was is refused and says what it still holds: the engine not taking it and a setter keeping the value look the same, so the refusal names neither. A write of the value the property already holds, at its own precision, as a float given in 64 bits to a property keeping 32, is not refused: it answers unchanged: true.'
+          description: 'set: which one to write. Colons write through what a node holds, "_game:run:day", and a number or a key steps into a list or a map on the way, "_game:run:roster:0:name", a negative number counting from the end, and a step written as a call, "get_viewport():gui_embed_subwindows", walks through what a reading method returned, as runtime_inspect property describes. A map keyed by numbers is stepped into by the number, "_game:units:3". A component of a vector, a colour or a transform, "position:x", writes that one alone: the value holding it is a copy, so it is put back where it was read from, setter and all, and a component of what a call returned is refused, since the game keeps that copy nowhere. The answer reads back off the same holder, and a write that leaves the property as it was is refused and says what it still holds: the engine not taking it and a setter keeping the value look the same, so the refusal names neither. A write of the value the property already holds, at its own precision, as a float given in 64 bits to a property keeping 32, is not refused: it answers unchanged: true.'
         },
         value: {
           ops: ["set"],
@@ -12400,6 +12545,13 @@ var init_tool_definitions = __esm(() => {
           ops: ["action", "key", "mouse_click", "joypad_button"],
           description: "action, key, mouse_click, joypad_button: leave it out and the press is a whole one, down and up a frame apart. true holds it down, false lets go of one being held. A wheel button held down is still a whole step, since a wheel is never held."
         },
+        holdFrames: {
+          type: "integer",
+          minimum: 1,
+          maximum: 600,
+          ops: ["action", "key", "mouse_click", "joypad_button"],
+          description: "action, key, mouse_click, joypad_button: hold a whole press down for this many process frames and then let go, both inside the game, so a pour, a charge or a long press runs to a set length. A press, a frames wait and a release sent as three calls hold it for the time between the calls as well. The answer says held_frames. Not with pressed, and not on a wheel step. Default 1."
+        },
         strength: {
           type: "number",
           minimum: 0,
@@ -12548,7 +12700,7 @@ var init_tool_definitions = __esm(() => {
         property: {
           type: "string",
           ops: ["until"],
-          description: 'until: the property name, or a colon path through what the node holds, "_game:run:day", read the way runtime_inspect property reads one, a step written as a call included. Walked again on every frame, so a holder the game replaces while the wait is on is followed.'
+          description: 'until: the property name, or a colon path through what the node holds, "_game:run:day", read the way runtime_inspect property reads one, a step written as a call included, and one axis of a vector as well: "global_position:x" with compare ">=" stops once a thing has travelled far enough. Walked again on every frame, so a holder the game replaces while the wait is on is followed.'
         },
         value: {
           ops: ["until"],
@@ -34422,10 +34574,10 @@ var init_stdio = __esm(() => {
 });
 
 // src/runtime-client.ts
-import { existsSync as existsSync13, readdirSync as readdirSync8, readFileSync as readFileSync12, statSync as statSync6, unlinkSync } from "node:fs";
+import { existsSync as existsSync14, readdirSync as readdirSync9, readFileSync as readFileSync13, statSync as statSync7, unlinkSync as unlinkSync2 } from "node:fs";
 import { createConnection } from "node:net";
 import { tmpdir as tmpdir4 } from "node:os";
-import { dirname as dirname8, join as join14, resolve as resolve4 } from "node:path";
+import { dirname as dirname9, join as join15, resolve as resolve4 } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 function runtimeDirectory(variables = process.env) {
   const explicit = envValue("GDHARNESS_RUNTIME_DIR", variables);
@@ -34433,20 +34585,20 @@ function runtimeDirectory(variables = process.env) {
     return explicit;
   }
   const perUser = envValue("XDG_RUNTIME_DIR", variables);
-  return join14(perUser ?? tmpdir4(), "gdharness");
+  return join15(perUser ?? tmpdir4(), "gdharness");
 }
 function runtimeDirectories(variables = process.env) {
   const candidates = [runtimeDirectory(variables)];
   const fallbacks = process.platform === "win32" ? [envValue("SystemRoot", variables) ?? envValue("windir", variables) ?? "C:\\Windows"] : ["/tmp", "/var/tmp"];
   for (const base of fallbacks) {
-    candidates.push(join14(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
+    candidates.push(join15(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
   }
   return [...new Set(candidates.map((path) => resolve4(path)))];
 }
 function errorReportOf(pid, directories = runtimeDirectories()) {
   for (const directory of directories) {
-    const path = join14(directory, `runtime-${pid}.log`);
-    if (existsSync13(path)) {
+    const path = join15(directory, `runtime-${pid}.log`);
+    if (existsSync14(path)) {
       return path;
     }
   }
@@ -34477,7 +34629,7 @@ function reportAlreadyInTranscript(transcript, report) {
 function parseAnnouncement(file, pid) {
   let fields;
   try {
-    fields = asParams(JSON.parse(readFileSync12(file, "utf8")));
+    fields = asParams(JSON.parse(readFileSync13(file, "utf8")));
   } catch {
     return { kind: "rubbish" };
   }
@@ -34494,7 +34646,7 @@ function parseAnnouncement(file, pid) {
   };
   let announcedAt;
   try {
-    announcedAt = statSync6(file).mtimeMs;
+    announcedAt = statSync7(file).mtimeMs;
   } catch {}
   const when = announcedAt === undefined ? {} : { announcedAt };
   if (protocol !== RUNTIME_PROTOCOL) {
@@ -34543,7 +34695,7 @@ function discoverRuntimes(directories = runtimeDirectories()) {
 function wentAway(file, pid) {
   let project = "";
   try {
-    const fields = asParams(JSON.parse(readFileSync12(file, "utf8")));
+    const fields = asParams(JSON.parse(readFileSync13(file, "utf8")));
     project = readString(readParams(fields, "project") ?? {}, "path") ?? "";
   } catch {
     return;
@@ -34586,29 +34738,29 @@ function strangersAmong(candidates, now, startTimes = startTimesOf) {
   }).map((one) => one.file));
 }
 function announcedIn(directory) {
-  if (!existsSync13(directory)) {
+  if (!existsSync14(directory)) {
     return [];
   }
   const found = [];
   const candidates = [];
   const entries = [];
-  for (const entry of readdirSync8(directory)) {
+  for (const entry of readdirSync9(directory)) {
     const report = ERROR_REPORT_PATTERN.exec(entry);
     if (report) {
-      sweepErrorReport(join14(directory, entry), Number.parseInt(report[1] ?? "", 10));
+      sweepErrorReport(join15(directory, entry), Number.parseInt(report[1] ?? "", 10));
       continue;
     }
     const match = ANNOUNCEMENT_PATTERN.exec(entry);
     if (!match) {
       continue;
     }
-    const file = join14(directory, entry);
+    const file = join15(directory, entry);
     const pid = Number.parseInt(match[1] ?? "", 10);
     const running = alive(pid);
     entries.push({ file, pid, running });
     if (running) {
       try {
-        candidates.push({ file, pid, writtenAt: statSync6(file).mtimeMs });
+        candidates.push({ file, pid, writtenAt: statSync7(file).mtimeMs });
       } catch {}
     }
   }
@@ -34622,7 +34774,7 @@ function announcedIn(directory) {
       }
       wentAway(file, pid);
       try {
-        unlinkSync(file);
+        unlinkSync2(file);
       } catch {}
       verdicts.delete(file);
       continue;
@@ -34630,16 +34782,16 @@ function announcedIn(directory) {
     found.push(announced);
   }
   const held = new Set(entries.map((one) => one.file));
-  const here = join14(directory, ".");
+  const here = join15(directory, ".");
   for (const file of verdicts.keys()) {
-    if (dirname8(file) === here && !held.has(file)) {
+    if (dirname9(file) === here && !held.has(file)) {
       verdicts.delete(file);
     }
   }
   return found;
 }
 async function announcementEnded(pid, directories = runtimeDirectories()) {
-  const files = directories.map((directory) => join14(directory, `runtime-${pid}.json`)).filter((file) => existsSync13(file));
+  const files = directories.map((directory) => join15(directory, `runtime-${pid}.json`)).filter((file) => existsSync14(file));
   const first = files[0];
   if (first === undefined) {
     return;
@@ -34655,7 +34807,7 @@ async function announcementEnded(pid, directories = runtimeDirectories()) {
   wentAway(first, pid);
   for (const file of files) {
     try {
-      unlinkSync(file);
+      unlinkSync2(file);
     } catch {}
     verdicts.delete(file);
   }
@@ -34665,8 +34817,8 @@ function sweepErrorReport(path, pid, now = Date.now()) {
     return;
   }
   try {
-    if (now - statSync6(path).mtimeMs >= ERROR_REPORT_KEEP_MS) {
-      unlinkSync(path);
+    if (now - statSync7(path).mtimeMs >= ERROR_REPORT_KEEP_MS) {
+      unlinkSync2(path);
     }
   } catch {}
 }
@@ -34940,14 +35092,14 @@ var init_runtime_client = __esm(() => {
 });
 
 // src/boot-note.ts
-import { mkdirSync as mkdirSync6, readFileSync as readFileSync13, writeFileSync as writeFileSync8 } from "node:fs";
-import { dirname as dirname9, join as join15 } from "node:path";
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync14, writeFileSync as writeFileSync8 } from "node:fs";
+import { dirname as dirname10, join as join16 } from "node:path";
 function bootNotePath(projectPath) {
-  return join15(projectPath, ".godot", "gdharness-boot.json");
+  return join16(projectPath, ".godot", "gdharness-boot.json");
 }
 function readScenes(projectPath) {
   try {
-    return asParams(asParams(JSON.parse(readFileSync13(bootNotePath(projectPath), "utf8")))["scenes"]);
+    return asParams(asParams(JSON.parse(readFileSync14(bootNotePath(projectPath), "utf8")))["scenes"]);
   } catch {
     return {};
   }
@@ -34963,7 +35115,7 @@ function readBootNote(projectPath, scene) {
 function writeBootNote(projectPath, scene, announcedAfterMs) {
   try {
     const path = bootNotePath(projectPath);
-    mkdirSync6(dirname9(path), { recursive: true });
+    mkdirSync6(dirname10(path), { recursive: true });
     const scenes = {
       ...readScenes(projectPath),
       [scene]: {
@@ -34989,10 +35141,10 @@ var init_boot_note = __esm(() => {
 });
 
 // src/breakpoint-note.ts
-import { mkdirSync as mkdirSync7, readFileSync as readFileSync14, rmSync as rmSync7, writeFileSync as writeFileSync9 } from "node:fs";
-import { dirname as dirname10, isAbsolute as isAbsolute2, join as join16, relative as relative3 } from "node:path";
+import { mkdirSync as mkdirSync7, readFileSync as readFileSync15, rmSync as rmSync7, writeFileSync as writeFileSync9 } from "node:fs";
+import { dirname as dirname11, isAbsolute as isAbsolute3, join as join17, relative as relative3 } from "node:path";
 function breakpointNotePath(projectPath) {
-  return join16(projectPath, ".godot", "gdharness-breakpoints.json");
+  return join17(projectPath, ".godot", "gdharness-breakpoints.json");
 }
 function writeBreakpointNote(projectPath, held) {
   const path = breakpointNotePath(projectPath);
@@ -35009,7 +35161,7 @@ function writeBreakpointNote(projectPath, held) {
         lines: [...one.lines]
       }))
     };
-    mkdirSync7(dirname10(path), { recursive: true });
+    mkdirSync7(dirname11(path), { recursive: true });
     writeFileSync9(path, `${JSON.stringify(note, null, 2)}
 `, "utf8");
   } catch (error) {
@@ -35018,7 +35170,7 @@ function writeBreakpointNote(projectPath, held) {
 }
 function readBreakpointNote(projectPath) {
   try {
-    const parsed = JSON.parse(readFileSync14(breakpointNotePath(projectPath), "utf8"));
+    const parsed = JSON.parse(readFileSync15(breakpointNotePath(projectPath), "utf8"));
     if (typeof parsed !== "object" || parsed === null || !Array.isArray(parsed.breakpoints)) {
       return [];
     }
@@ -35028,12 +35180,12 @@ function readBreakpointNote(projectPath) {
         continue;
       }
       const { script, lines: listed } = entry;
-      if (typeof script !== "string" || isAbsolute2(script) || script.split("/").includes("..")) {
+      if (typeof script !== "string" || isAbsolute3(script) || script.split("/").includes("..")) {
         continue;
       }
       const lines = Array.isArray(listed) ? listed.filter((line) => Number.isInteger(line) && line > 0) : [];
       if (lines.length > 0) {
-        held.push({ scriptPath: realPathOr(join16(projectPath, script)), lines });
+        held.push({ scriptPath: realPathOr(join17(projectPath, script)), lines });
       }
     }
     return held;
@@ -35043,56 +35195,104 @@ function readBreakpointNote(projectPath) {
 }
 function withinProject(projectPath, scriptPath) {
   const rel = relative3(projectPath, scriptPath);
-  return rel !== "" && !rel.startsWith("..") && !isAbsolute2(rel);
+  return rel !== "" && !rel.startsWith("..") && !isAbsolute3(rel);
 }
 var init_breakpoint_note = __esm(() => {
   init_errors();
   init_paths();
 });
 
+// src/whole-file.ts
+import { renameSync as renameSync2, rmSync as rmSync8, writeFileSync as writeFileSync10 } from "node:fs";
+function writeWhole(path, text) {
+  const partial = `${path}.${process.pid}.partial`;
+  try {
+    writeFileSync10(partial, text, "utf8");
+  } catch {
+    return false;
+  }
+  const until = Date.now() + HELD_FILE_MS;
+  for (;; ) {
+    try {
+      renameSync2(partial, path);
+      return true;
+    } catch (error) {
+      const code = error.code ?? "";
+      if (!HELD_BY_A_READER.has(code) || Date.now() >= until) {
+        try {
+          rmSync8(partial, { force: true });
+        } catch {}
+        return false;
+      }
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, HELD_FILE_RETRY_MS);
+    }
+  }
+}
+var HELD_FILE_MS = 1000, HELD_FILE_RETRY_MS = 10, HELD_BY_A_READER;
+var init_whole_file = __esm(() => {
+  HELD_BY_A_READER = new Set(["EPERM", "EACCES", "EBUSY"]);
+});
+
 // src/class-note.ts
-import { mkdirSync as mkdirSync8, readFileSync as readFileSync15, writeFileSync as writeFileSync10 } from "node:fs";
-import { dirname as dirname11, join as join17 } from "node:path";
+import { mkdirSync as mkdirSync8, readFileSync as readFileSync16 } from "node:fs";
+import { dirname as dirname12, join as join18 } from "node:path";
 function classNotePath(projectPath) {
-  return join17(projectPath, ".godot", "gdharness-classes.json");
+  return join18(projectPath, ".godot", "gdharness-classes.json");
 }
 function readClassNote(projectPath) {
   try {
-    const fields = asParams(JSON.parse(readFileSync15(classNotePath(projectPath), "utf8")));
+    const fields = asParams(JSON.parse(readFileSync16(classNotePath(projectPath), "utf8")));
     const rebuiltWith = readArray(fields, "rebuiltWith");
     if (rebuiltWith === undefined || !rebuiltWith.every((name) => typeof name === "string")) {
       return null;
     }
     const pid = readNumber(fields, "shortListEditorPid");
+    const unfinished = unfinishedScanIn(fields["unseenBeforeAnUnfinishedScan"]);
     return {
       rebuiltWith: rebuiltWith.map(String),
-      ...Object.hasOwn(fields, "shortListEditorPid") ? { shortListEditorPid: pid ?? null } : {}
+      ...Object.hasOwn(fields, "shortListEditorPid") ? { shortListEditorPid: pid ?? null } : {},
+      ...unfinished === null ? {} : { unseenBeforeAnUnfinishedScan: unfinished }
     };
   } catch {
     return null;
   }
 }
+function unfinishedScanIn(value) {
+  if (typeof value !== "object" || value === null) {
+    return null;
+  }
+  const fields = asParams(value);
+  const classes = readArray(fields, "classes");
+  if (classes === undefined || !classes.every((name) => typeof name === "string")) {
+    return null;
+  }
+  return { editorPid: readNumber(fields, "editorPid") ?? null, classes: classes.map(String) };
+}
 function writeClassNote(projectPath, note) {
+  const path = classNotePath(projectPath);
   try {
-    const path = classNotePath(projectPath);
-    mkdirSync8(dirname11(path), { recursive: true });
-    writeFileSync10(path, `${JSON.stringify(note, null, 2)}
-`, "utf8");
-  } catch {}
+    mkdirSync8(dirname12(path), { recursive: true });
+  } catch {
+    return;
+  }
+  writeWhole(path, `${JSON.stringify(note, null, 2)}
+`);
 }
-var init_class_note = () => {};
+var init_class_note = __esm(() => {
+  init_whole_file();
+});
 
 // src/config-pin.ts
-import { existsSync as existsSync14, readFileSync as readFileSync16 } from "node:fs";
-import { join as join18 } from "node:path";
+import { existsSync as existsSync15, readFileSync as readFileSync17 } from "node:fs";
+import { join as join19 } from "node:path";
 function versionsNamedInConfig(projectPath) {
-  const config = join18(projectPath, ".mcp.json");
-  if (!existsSync14(config)) {
+  const config = join19(projectPath, ".mcp.json");
+  if (!existsSync15(config)) {
     return [];
   }
   let text;
   try {
-    text = readFileSync16(config, "utf8");
+    text = readFileSync17(config, "utf8");
     JSON.parse(text);
   } catch {
     return [];
@@ -35113,30 +35313,30 @@ var init_config_pin = __esm(() => {
 });
 
 // src/cut-test-run.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync9, readFileSync as readFileSync17, rmSync as rmSync8, writeFileSync as writeFileSync11 } from "node:fs";
-import { dirname as dirname12, join as join19 } from "node:path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync9, readFileSync as readFileSync18, rmSync as rmSync9, writeFileSync as writeFileSync11 } from "node:fs";
+import { dirname as dirname13, join as join20 } from "node:path";
 function keptAt(projectPath) {
-  return join19(projectPath, ".godot", "gdharness-reports", "cut-run.json");
+  return join20(projectPath, ".godot", "gdharness-reports", "cut-run.json");
 }
 function keepCutTestRun(projectPath, run) {
   const path = keptAt(projectPath);
   try {
-    mkdirSync9(dirname12(path), { recursive: true });
+    mkdirSync9(dirname13(path), { recursive: true });
     writeFileSync11(path, `${JSON.stringify(run, null, 2)}
 `, "utf8");
   } catch {}
 }
 function takeCutTestRun(projectPath) {
   const path = keptAt(projectPath);
-  if (!existsSync15(path)) {
+  if (!existsSync16(path)) {
     return null;
   }
   try {
-    const run = JSON.parse(readFileSync17(path, "utf8"));
-    rmSync8(path, { force: true });
+    const run = JSON.parse(readFileSync18(path, "utf8"));
+    rmSync9(path, { force: true });
     return typeof run.cutAt === "string" && Array.isArray(run.paths) && run.paths.every((path) => typeof path === "string") ? run : null;
   } catch {
-    rmSync8(path, { force: true });
+    rmSync9(path, { force: true });
     return null;
   }
 }
@@ -35948,25 +36148,25 @@ var init_desktop = () => {};
 // src/editor-log.ts
 import {
   closeSync,
-  existsSync as existsSync16,
+  existsSync as existsSync17,
   mkdirSync as mkdirSync10,
   openSync,
-  readFileSync as readFileSync18,
+  readFileSync as readFileSync19,
   readSync,
-  rmSync as rmSync9,
-  statSync as statSync7,
+  rmSync as rmSync10,
+  statSync as statSync8,
   writeFileSync as writeFileSync12
 } from "node:fs";
-import { dirname as dirname13, join as join20 } from "node:path";
+import { dirname as dirname14, join as join21 } from "node:path";
 function editorLogPath(projectPath) {
-  return join20(projectPath, ".godot", "gdharness-editor.log");
+  return join21(projectPath, ".godot", "gdharness-editor.log");
 }
 function editorLogNotePath(projectPath) {
-  return join20(projectPath, ".godot", "gdharness-editor.json");
+  return join21(projectPath, ".godot", "gdharness-editor.json");
 }
 function readEditorLogNote(projectPath) {
   try {
-    const fields = asParams(JSON.parse(readFileSync18(editorLogNotePath(projectPath), "utf8")));
+    const fields = asParams(JSON.parse(readFileSync19(editorLogNotePath(projectPath), "utf8")));
     const pid = readNumber(fields, "pid");
     const startedAt = readString(fields, "startedAt");
     return pid !== undefined && Number.isInteger(pid) && pid > 0 && startedAt !== undefined ? { pid, startedAt } : null;
@@ -35977,15 +36177,15 @@ function readEditorLogNote(projectPath) {
 function clearEditorLog(projectPath) {
   try {
     const path = editorLogPath(projectPath);
-    mkdirSync10(dirname13(path), { recursive: true });
-    rmSync9(path, { force: true });
-    rmSync9(editorLogNotePath(projectPath), { force: true });
+    mkdirSync10(dirname14(path), { recursive: true });
+    rmSync10(path, { force: true });
+    rmSync10(editorLogNotePath(projectPath), { force: true });
   } catch {}
 }
 function writeEditorLogNote(projectPath, pid) {
   try {
     const path = editorLogNotePath(projectPath);
-    mkdirSync10(dirname13(path), { recursive: true });
+    mkdirSync10(dirname14(path), { recursive: true });
     writeFileSync12(path, JSON.stringify({ pid, startedAt: new Date().toISOString() }, null, 2), "utf8");
   } catch {}
 }
@@ -36007,7 +36207,7 @@ function editorConsole(projectPath, editorPid, openedByAServer) {
     return { kind: "older server", notedPid: noted?.pid ?? null };
   }
   const path = editorLogPath(projectPath);
-  if (!existsSync16(path)) {
+  if (!existsSync17(path)) {
     return { kind: "not written" };
   }
   const log = new GameLog;
@@ -36063,9 +36263,9 @@ function foldProgress(text) {
 `);
 }
 function theFirstOf(path) {
-  const whole = statSync7(path).size;
+  const whole = statSync8(path).size;
   if (whole <= MOST_CONSOLE_BYTES) {
-    return { text: readFileSync18(path, "utf8") };
+    return { text: readFileSync19(path, "utf8") };
   }
   const handle = openSync(path, "r");
   try {
@@ -39202,12 +39402,21 @@ function getDefaultBridge(ownProject = null) {
   defaultBridge ??= new GodotBridge(resolveDefaultBridgePort(), resolveDefaultBridgeHost(), DEFAULT_TIMEOUT_MS, ownProject);
   return defaultBridge;
 }
-var DEFAULT_PORT = 6505, DEFAULT_HOST = "127.0.0.1", DEFAULT_TIMEOUT_MS = 30000, KEEPALIVE_INTERVAL_MS = 1e4, SECOND_CONNECTION_CLOSE_CODE = 4000, MOST_CLOSE_REASON_BYTES = 123, OTHER_PROJECT_CLOSE_CODE = 4001, ONE_SHOT_CLOSE_CODE = 4002, CONNECT_WINDOW_MS = 35000, GodotBridge, defaultBridge = null;
+var DEFAULT_PORT = 6505, DEFAULT_HOST = "127.0.0.1", DEFAULT_TIMEOUT_MS = 30000, KEEPALIVE_INTERVAL_MS = 1e4, SECOND_CONNECTION_CLOSE_CODE = 4000, MOST_CLOSE_REASON_BYTES = 123, OTHER_PROJECT_CLOSE_CODE = 4001, ONE_SHOT_CLOSE_CODE = 4002, CONNECT_WINDOW_MS = 35000, BridgeTimeout, GodotBridge, defaultBridge = null;
 var init_godot_bridge = __esm(() => {
   init_wrapper();
   init_errors();
   init_paths();
   init_ports();
+  BridgeTimeout = class BridgeTimeout extends Error {
+    toolName;
+    waitedMs;
+    constructor(toolName, waitedMs) {
+      super(`Tool ${toolName} timed out after ${waitedMs}ms`);
+      this.toolName = toolName;
+      this.waitedMs = waitedMs;
+    }
+  };
   GodotBridge = class GodotBridge extends EventEmitter {
     listeningSince = null;
     httpServer = null;
@@ -39545,7 +39754,7 @@ var init_godot_bridge = __esm(() => {
       return new Promise((resolve, reject) => {
         const timeout = setTimeout(() => {
           this.pendingRequests.delete(requestId);
-          reject(new Error(`Tool ${toolName} timed out after ${this.timeoutMs}ms`));
+          reject(new BridgeTimeout(toolName, this.timeoutMs));
         }, this.timeoutMs);
         this.pendingRequests.set(requestId, {
           toolName,
@@ -40273,19 +40482,19 @@ var DEBUG_PREFIX = "debug ";
 var init_keeper_channel = () => {};
 
 // src/lifecycle-log.ts
-import { appendFileSync, mkdirSync as mkdirSync11, renameSync, statSync as statSync8 } from "node:fs";
-import { dirname as dirname14, join as join21 } from "node:path";
+import { appendFileSync, mkdirSync as mkdirSync11, renameSync as renameSync3, statSync as statSync9 } from "node:fs";
+import { dirname as dirname15, join as join22 } from "node:path";
 import process10 from "node:process";
 function lifecycleLogPath() {
-  return join21(runtimeDirectory(), "servers.log");
+  return join22(runtimeDirectory(), "servers.log");
 }
 function writeLifecycle(event, fields = {}) {
   const path = lifecycleLogPath();
   try {
-    mkdirSync11(dirname14(path), { recursive: true });
-    if ((statSync8(path, { throwIfNoEntry: false })?.size ?? 0) > LIFECYCLE_LOG_LIMIT) {
+    mkdirSync11(dirname15(path), { recursive: true });
+    if ((statSync9(path, { throwIfNoEntry: false })?.size ?? 0) > LIFECYCLE_LOG_LIMIT) {
       try {
-        renameSync(path, `${path}.1`);
+        renameSync3(path, `${path}.1`);
       } catch {}
     }
     const line = {
@@ -40320,10 +40529,10 @@ var init_lifecycle_log = __esm(() => {
 });
 
 // src/lsp_client.ts
-import { existsSync as existsSync17, realpathSync as realpathSync4 } from "node:fs";
+import { existsSync as existsSync18, realpathSync as realpathSync4 } from "node:fs";
 import { readFile, realpath } from "node:fs/promises";
 import { createConnection as createConnection3 } from "node:net";
-import { dirname as dirname15, join as join22, resolve as resolve5 } from "node:path";
+import { dirname as dirname16, join as join23, resolve as resolve5 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
 function initializeTimeoutMs() {
@@ -40485,7 +40694,7 @@ class GodotLSPClient {
     if (this.initialized) {
       return;
     }
-    const rootPath = this.rootPath ?? dirname15(resolve5(filePath));
+    const rootPath = this.rootPath ?? dirname16(resolve5(filePath));
     await this.initialize(rootPath);
   }
   async sendRequest(method, params, timeoutMs = this.timeouts.requestMs) {
@@ -40986,7 +41195,7 @@ async function resolveLSPPaths(projectPathValue, scriptPathValue) {
   } catch {
     throw new ArgumentRefusal(`Project path does not exist: ${requestedProjectPath}`);
   }
-  if (!existsSync17(join22(projectPath, "project.godot"))) {
+  if (!existsSync18(join23(projectPath, "project.godot"))) {
     throw new ArgumentRefusal(`Not a Godot project: ${projectPath}. Point projectPath at the directory holding project.godot.`);
   }
   const contained = resolveWithinProject(projectPath, scriptPathValue);
@@ -41146,7 +41355,6 @@ var init_lsp_client = __esm(() => {
 });
 
 // src/outside.ts
-import { spawn as spawn3 } from "node:child_process";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 function changesFrom(env, base) {
   const changes = {};
@@ -41179,9 +41387,8 @@ function readLaunched(printed) {
 }
 async function launchOutsideTheTree(spec, runtime = process.execPath, keeper = KEEPER_SCRIPT) {
   return await new Promise((resolve) => {
-    const launcher = spawn3(runtime, [keeper, "launch"], {
-      stdio: ["pipe", "pipe", "pipe"],
-      windowsHide: true
+    const launcher = spawnHidden(runtime, [keeper, "launch"], {
+      stdio: ["pipe", "pipe", "pipe"]
     });
     sendSpec(launcher, {
       command: spec.command,
@@ -41210,6 +41417,7 @@ async function launchOutsideTheTree(spec, runtime = process.execPath, keeper = K
 }
 var KEEPER_SCRIPT;
 var init_outside = __esm(() => {
+  init_spawn();
   KEEPER_SCRIPT = fileURLToPath4(new URL("./keeper.js", import.meta.url));
 });
 
@@ -41250,8 +41458,6 @@ var STARTING_MS = 20000;
 var init_port_probe = () => {};
 
 // src/process-time.ts
-import { execFile as execFile3 } from "node:child_process";
-import { promisify as promisify3 } from "node:util";
 async function cpuSecondsOf(pid) {
   try {
     return process.platform === "win32" ? await secondsOnWindows(pid) : await askPosix2(pid);
@@ -41265,7 +41471,7 @@ async function secondsOnWindows(pid) {
   return Number.isFinite(seconds) ? seconds : undefined;
 }
 async function askPosix2(pid) {
-  const { stdout } = await run3("ps", ["-o", "time=", "-p", String(pid)], { timeout: ASK_TIMEOUT_MS2 });
+  const { stdout } = await runHidden("ps", ["-o", "time=", "-p", String(pid)], { timeout: ASK_TIMEOUT_MS2 });
   return secondsFromClock(stdout.trim());
 }
 function secondsFromClock(printed) {
@@ -41283,10 +41489,10 @@ function secondsFromClock(printed) {
   const extra = days === null ? 0 : Number(days) * 86400;
   return Number.isFinite(extra) ? seconds + extra : undefined;
 }
-var run3, ASK_TIMEOUT_MS2 = 6000;
+var ASK_TIMEOUT_MS2 = 6000;
 var init_process_time = __esm(() => {
+  init_spawn();
   init_windows_ask();
-  run3 = promisify3(execFile3);
 });
 
 // src/prompts.ts
@@ -41426,8 +41632,8 @@ var init_prompts = __esm(() => {
 });
 
 // src/rename.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync12, readFileSync as readFileSync19, renameSync as renameSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync13 } from "node:fs";
-import { dirname as dirname16, posix as posix2 } from "node:path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync12, readFileSync as readFileSync20, renameSync as renameSync4, unlinkSync as unlinkSync3, writeFileSync as writeFileSync13 } from "node:fs";
+import { dirname as dirname17, posix as posix2 } from "node:path";
 
 class Script {
   path;
@@ -42128,26 +42334,26 @@ function rewritesOf(plan, texts, move) {
 }
 function applyRewrites(rewrites) {
   for (const rewrite of rewrites) {
-    const now = readFileSync19(rewrite.absolute, "utf8");
+    const now = readFileSync20(rewrite.absolute, "utf8");
     if (now !== rewrite.before) {
       throw new Error(`${rewrite.path} changed on disk while the rename was being worked out; nothing was written`);
     }
-    if (rewrite.writeTo !== rewrite.absolute && existsSync18(rewrite.writeTo)) {
+    if (rewrite.writeTo !== rewrite.absolute && existsSync19(rewrite.writeTo)) {
       throw new Error(`${rewrite.writeTo} already exists; nothing was written`);
     }
   }
   const done = [];
   try {
     for (const rewrite of rewrites) {
-      mkdirSync12(dirname16(rewrite.writeTo), { recursive: true });
+      mkdirSync12(dirname17(rewrite.writeTo), { recursive: true });
       const staging = `${rewrite.writeTo}.gdharness-rename`;
       writeFileSync13(staging, rewrite.after, "utf8");
-      renameSync2(staging, rewrite.writeTo);
+      renameSync4(staging, rewrite.writeTo);
       let movedUid = false;
       if (rewrite.writeTo !== rewrite.absolute) {
-        unlinkSync2(rewrite.absolute);
-        if (existsSync18(`${rewrite.absolute}.uid`)) {
-          renameSync2(`${rewrite.absolute}.uid`, `${rewrite.writeTo}.uid`);
+        unlinkSync3(rewrite.absolute);
+        if (existsSync19(`${rewrite.absolute}.uid`)) {
+          renameSync4(`${rewrite.absolute}.uid`, `${rewrite.writeTo}.uid`);
           movedUid = true;
         }
       }
@@ -42158,9 +42364,9 @@ function applyRewrites(rewrites) {
       try {
         writeFileSync13(rewrite.absolute, rewrite.before, "utf8");
         if (rewrite.writeTo !== rewrite.absolute) {
-          unlinkSync2(rewrite.writeTo);
+          unlinkSync3(rewrite.writeTo);
           if (movedUid) {
-            renameSync2(`${rewrite.writeTo}.uid`, `${rewrite.absolute}.uid`);
+            renameSync4(`${rewrite.writeTo}.uid`, `${rewrite.absolute}.uid`);
           }
         }
       } catch {}
@@ -42192,8 +42398,8 @@ var init_rename = __esm(() => {
 });
 
 // src/rename-symbol.ts
-import { existsSync as existsSync19, mkdirSync as mkdirSync13, readdirSync as readdirSync9, realpathSync as realpathSync5, rmSync as rmSync10, writeFileSync as writeFileSync14 } from "node:fs";
-import { basename as basename5, dirname as dirname17, join as join23, relative as relative4, resolve as resolve6 } from "node:path";
+import { existsSync as existsSync20, mkdirSync as mkdirSync13, readdirSync as readdirSync10, realpathSync as realpathSync5, rmSync as rmSync11, writeFileSync as writeFileSync14 } from "node:fs";
+import { basename as basename6, dirname as dirname18, join as join24, relative as relative4, resolve as resolve6 } from "node:path";
 function resourcePathOf(projectPath, absolute) {
   const inside = relative4(onDiskSpelling(projectPath), onDiskSpelling(absolute));
   if (inside === "" || inside.startsWith("..") || /^[A-Za-z]:/.test(inside)) {
@@ -42206,13 +42412,13 @@ function onDiskSpelling(path) {
   let at = resolve6(path);
   for (;; ) {
     try {
-      return join23(realpathSync5.native(at), ...missing.reverse());
+      return join24(realpathSync5.native(at), ...missing.reverse());
     } catch {
-      const parent = dirname17(at);
+      const parent = dirname18(at);
       if (parent === at) {
         return resolve6(path);
       }
-      missing.push(basename5(at));
+      missing.push(basename6(at));
       at = parent;
     }
   }
@@ -42259,7 +42465,7 @@ async function renameSymbol(request, services) {
         reason: `newScriptPath must be a .gd path inside the project, and ${request.newScriptPath} is not.`
       };
     }
-    if (existsSync19(request.newScriptPath)) {
+    if (existsSync20(request.newScriptPath)) {
       return { ok: false, reason: `${moveTo} already exists, so the script cannot be moved there.` };
     }
   }
@@ -42435,7 +42641,7 @@ async function renameSymbol(request, services) {
       scripts,
       from: declaringPath,
       to: moveTo,
-      exists: (path) => existsSync19(`${projectPath}/${path.slice("res://".length)}`)
+      exists: (path) => existsSync20(`${projectPath}/${path.slice("res://".length)}`)
     }, plan);
   }
   plan = mentionIgnored(plan, ignoredTexts(projectPath), symbol, moveTo === null ? null : declaringPath);
@@ -42634,15 +42840,15 @@ ${mention.kind}`;
   };
 }
 function writeLeftAloneDetail(projectPath, symbol, detail) {
-  const directory = join23(projectPath, ".godot", "gdharness-renames");
+  const directory = join24(projectPath, ".godot", "gdharness-renames");
   mkdirSync13(directory, { recursive: true });
   detailWrites += 1;
-  const path = join23(directory, `${String(Date.now())}-${String(detailWrites).padStart(6, "0")}-${String(process.pid)}-${symbol}.json`);
+  const path = join24(directory, `${String(Date.now())}-${String(detailWrites).padStart(6, "0")}-${String(process.pid)}-${symbol}.json`);
   writeFileSync14(path, `${JSON.stringify(detail, null, 2)}
 `, "utf8");
-  const kept = readdirSync9(directory).filter((name) => name.endsWith(".json")).sort().reverse();
+  const kept = readdirSync10(directory).filter((name) => name.endsWith(".json")).sort().reverse();
   for (const old of kept.slice(10)) {
-    rmSync10(join23(directory, old), { force: true });
+    rmSync11(join24(directory, old), { force: true });
   }
   return path;
 }
@@ -42682,15 +42888,15 @@ var init_rename_symbol = __esm(() => {
 });
 
 // src/restart-note.ts
-import { mkdirSync as mkdirSync14, readFileSync as readFileSync20, rmSync as rmSync11, writeFileSync as writeFileSync15 } from "node:fs";
-import { dirname as dirname18, join as join24 } from "node:path";
+import { mkdirSync as mkdirSync14, readFileSync as readFileSync21, rmSync as rmSync12, writeFileSync as writeFileSync15 } from "node:fs";
+import { dirname as dirname19, join as join25 } from "node:path";
 function restartNotePath(projectPath) {
-  return join24(projectPath, ".godot", "gdharness-restart.json");
+  return join25(projectPath, ".godot", "gdharness-restart.json");
 }
 function noteRestartBegun(note) {
   const path = restartNotePath(note.projectPath);
   try {
-    mkdirSync14(dirname18(path), { recursive: true });
+    mkdirSync14(dirname19(path), { recursive: true });
     writeFileSync15(path, `${JSON.stringify(note, null, 2)}
 `, "utf8");
   } catch (error) {
@@ -42699,7 +42905,7 @@ function noteRestartBegun(note) {
 }
 function restartOwed(projectPath) {
   try {
-    const parsed = JSON.parse(readFileSync20(restartNotePath(projectPath), "utf8"));
+    const parsed = JSON.parse(readFileSync21(restartNotePath(projectPath), "utf8"));
     if (typeof parsed !== "object" || parsed === null) {
       return null;
     }
@@ -42714,7 +42920,7 @@ function restartOwed(projectPath) {
 }
 function restartSettled(projectPath) {
   try {
-    rmSync11(restartNotePath(projectPath), { force: true });
+    rmSync12(restartNotePath(projectPath), { force: true });
   } catch (error) {
     console.error(`[SERVER] Could not clear the restart note: ${errorMessage(error)}`);
   }
@@ -42723,58 +42929,25 @@ var init_restart_note = __esm(() => {
   init_errors();
 });
 
-// src/whole-file.ts
-import { renameSync as renameSync3, rmSync as rmSync12, writeFileSync as writeFileSync16 } from "node:fs";
-function writeWhole(path, text) {
-  const partial = `${path}.${process.pid}.partial`;
-  try {
-    writeFileSync16(partial, text, "utf8");
-  } catch {
-    return false;
-  }
-  const until = Date.now() + HELD_FILE_MS;
-  for (;; ) {
-    try {
-      renameSync3(partial, path);
-      return true;
-    } catch (error) {
-      const code = error.code ?? "";
-      if (!HELD_BY_A_READER.has(code) || Date.now() >= until) {
-        try {
-          rmSync12(partial, { force: true });
-        } catch {}
-        return false;
-      }
-      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, HELD_FILE_RETRY_MS);
-    }
-  }
-}
-var HELD_FILE_MS = 1000, HELD_FILE_RETRY_MS = 10, HELD_BY_A_READER;
-var init_whole_file = __esm(() => {
-  HELD_BY_A_READER = new Set(["EPERM", "EACCES", "EBUSY"]);
-});
-
 // src/run-record.ts
-import { execFile as execFile4 } from "node:child_process";
 import { createHash as createHash4 } from "node:crypto";
-import { mkdirSync as mkdirSync15, openSync as openSync2, readdirSync as readdirSync10, readFileSync as readFileSync21, realpathSync as realpathSync6, rmSync as rmSync13, statSync as statSync9 } from "node:fs";
-import { basename as basename6, dirname as dirname19, join as join25, resolve as resolve7 } from "node:path";
-import { promisify as promisify4 } from "node:util";
+import { mkdirSync as mkdirSync15, openSync as openSync2, readdirSync as readdirSync11, readFileSync as readFileSync22, realpathSync as realpathSync6, rmSync as rmSync13, statSync as statSync10 } from "node:fs";
+import { basename as basename7, dirname as dirname20, join as join26, resolve as resolve7 } from "node:path";
 function runsDirectory() {
-  return join25(runtimeDirectory(), "runs");
+  return join26(runtimeDirectory(), "runs");
 }
 function realAsFarAsItExists(path) {
   const missing = [];
   let at = path;
   for (;; ) {
     try {
-      return join25(realpathSync6.native(at), ...missing);
+      return join26(realpathSync6.native(at), ...missing);
     } catch {
-      const parent = dirname19(at);
+      const parent = dirname20(at);
       if (parent === at) {
         return path;
       }
-      missing.unshift(basename6(at));
+      missing.unshift(basename7(at));
       at = parent;
     }
   }
@@ -42785,10 +42958,10 @@ function projectKey(projectPath) {
   return createHash4("sha256").update(folded.replaceAll("\\", "/")).digest("hex").slice(0, 16);
 }
 function runRecordPath(projectPath, directory = runtimeDirectory()) {
-  return join25(directory, "runs", `note-${projectKey(projectPath)}.json`);
+  return join26(directory, "runs", `note-${projectKey(projectPath)}.json`);
 }
 function latestRunPath(servedBy, directory = runtimeDirectory()) {
-  return join25(directory, "runs", `latest-${projectKey(servedBy)}.json`);
+  return join26(directory, "runs", `latest-${projectKey(servedBy)}.json`);
 }
 function writeLatestRun(servedBy, latest) {
   try {
@@ -42798,7 +42971,7 @@ function writeLatestRun(servedBy, latest) {
 }
 function readLatestRun(servedBy, directory = runtimeDirectory()) {
   try {
-    const fields = JSON.parse(readFileSync21(latestRunPath(servedBy, directory), "utf8"));
+    const fields = JSON.parse(readFileSync22(latestRunPath(servedBy, directory), "utf8"));
     if (typeof fields !== "object" || fields === null) {
       return null;
     }
@@ -42813,17 +42986,17 @@ function readLatestRun(servedBy, directory = runtimeDirectory()) {
 }
 function openTranscript(startedAt) {
   mkdirSync15(runsDirectory(), { recursive: true });
-  const path = join25(runsDirectory(), `run-${startedAt}.log`);
+  const path = join26(runsDirectory(), `run-${startedAt}.log`);
   return { path, fd: openSync2(path, "a") };
 }
 function profilePath(startedAt) {
-  return join25(runsDirectory(), `run-${startedAt}.profile.json`);
+  return join26(runsDirectory(), `run-${startedAt}.profile.json`);
 }
 function noteIsAbout(note, playing) {
   return note.play !== undefined && playing !== null && note.play.play === playing.play && note.play.editorPid === playing.editorPid;
 }
 function editorNotePath(projectPath, directory = runtimeDirectory()) {
-  return join25(directory, "runs", `editor-${projectKey(projectPath)}.json`);
+  return join26(directory, "runs", `editor-${projectKey(projectPath)}.json`);
 }
 function writeEditorRunNote(note) {
   mkdirSync15(runsDirectory(), { recursive: true });
@@ -42834,7 +43007,7 @@ function writeEditorRunNote(note) {
 }
 function readEditorRunNote(projectPath) {
   for (const directory of runtimeDirectories()) {
-    const note = editorNoteAt(editorNotePath(projectPath, directory)) ?? editorNoteAt(join25(directory, "runs", "editor-run.json"));
+    const note = editorNoteAt(editorNotePath(projectPath, directory)) ?? editorNoteAt(join26(directory, "runs", "editor-run.json"));
     if (note !== null && isSameDirectory(note.projectPath, projectPath)) {
       return note;
     }
@@ -42844,7 +43017,7 @@ function readEditorRunNote(projectPath) {
 function editorNoteAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync21(path, "utf8"));
+    parsed = JSON.parse(readFileSync22(path, "utf8"));
   } catch {
     return null;
   }
@@ -42868,7 +43041,7 @@ function readRunRecord(projectPath) {
     if (own !== null) {
       return own;
     }
-    const shared = recordAt(join25(directory, "runs", SHARED_NOTE));
+    const shared = recordAt(join26(directory, "runs", SHARED_NOTE));
     if (shared !== null && shared.projectPath !== "" && isSameDirectory(shared.projectPath, projectPath)) {
       return shared;
     }
@@ -42880,13 +43053,13 @@ function everyRunRecord() {
   for (const directory of runtimeDirectories()) {
     let entries;
     try {
-      entries = readdirSync10(join25(directory, "runs"));
+      entries = readdirSync11(join26(directory, "runs"));
     } catch {
       continue;
     }
     for (const entry of entries) {
       if (entry === SHARED_NOTE || entry.startsWith("note-") && entry.endsWith(".json")) {
-        const record = recordAt(join25(directory, "runs", entry));
+        const record = recordAt(join26(directory, "runs", entry));
         if (record !== null) {
           found.push(record);
         }
@@ -42898,7 +43071,7 @@ function everyRunRecord() {
 function recordAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync21(path, "utf8"));
+    parsed = JSON.parse(readFileSync22(path, "utf8"));
   } catch {
     return null;
   }
@@ -42951,10 +43124,10 @@ async function runningAs(pid) {
     const began = await startedAt(pid, null);
     const when = began === null ? {} : { startedAt: began };
     if (process.platform === "linux") {
-      const raw = readFileSync21(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
+      const raw = readFileSync22(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
       return raw === "" ? null : { kind: "commandLine", text: raw, ...when };
     }
-    const args = (await execFileAsync("ps", ["-p", String(pid), "-o", "args="], { encoding: "utf8", timeout: 15000 })).stdout.trim();
+    const args = (await runHidden("ps", ["-p", String(pid), "-o", "args="], { timeout: 15000 })).stdout.trim();
     return args === "" ? null : { kind: "commandLine", text: args, ...when };
   } catch {
     return null;
@@ -42963,7 +43136,7 @@ async function runningAs(pid) {
 async function listeningPid(port) {
   try {
     if (process.platform === "win32") {
-      const { stdout } = await execFileAsync("netstat", ["-ano"], { encoding: "utf8", timeout: 15000 });
+      const { stdout } = await runHidden("netstat", ["-ano"], { timeout: 15000 });
       return listeningPidInNetstat(stdout, port);
     }
     for (const [command, args, pattern] of [
@@ -42971,7 +43144,7 @@ async function listeningPid(port) {
       ["ss", ["-ltnpH", `sport = :${port}`], /pid=(\d+)/]
     ]) {
       try {
-        const said = (await execFileAsync(command, [...args], { encoding: "utf8", timeout: 15000 })).stdout.trim();
+        const said = (await runHidden(command, [...args], { timeout: 15000 })).stdout.trim();
         const found = pattern.exec(said);
         if (found?.[1] !== undefined) {
           return Number(found[1]);
@@ -43016,7 +43189,7 @@ async function startedAt(pid, windowsAnswer) {
     return Number.isNaN(when) ? null : when;
   }
   try {
-    const said = (await execFileAsync("ps", ["-p", String(pid), "-o", "lstart="], { encoding: "utf8", timeout: 15000 })).stdout.trim();
+    const said = (await runHidden("ps", ["-p", String(pid), "-o", "lstart="], { timeout: 15000 })).stdout.trim();
     const when = Date.parse(said);
     return said === "" || Number.isNaN(when) ? null : when;
   } catch {
@@ -43025,10 +43198,8 @@ async function startedAt(pid, windowsAnswer) {
 }
 async function windowsImage(pid) {
   try {
-    const { stdout: csv } = await execFileAsync("tasklist", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], {
-      encoding: "utf8",
-      timeout: 15000,
-      windowsHide: true
+    const { stdout: csv } = await runHidden("tasklist", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], {
+      timeout: 15000
     });
     const image = /^"([^"]+)"/.exec(csv.trim())?.[1];
     return image === undefined ? { why: "named no process under that number" } : { image };
@@ -43057,7 +43228,7 @@ function whyNotTheRun(record, running, needed) {
   if (after > SAME_RUN_WINDOW_MS) {
     return `that process started ${Math.round(after / 1000)} seconds after the run had`;
   }
-  const engine = record.command === undefined ? null : basename6(record.command);
+  const engine = record.command === undefined ? null : basename7(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)) {
@@ -43096,7 +43267,7 @@ function judgeAnnouncedGame(running, projectPath, announcedAt) {
 }
 function clearRunRecord(projectPath) {
   for (const directory of runtimeDirectories()) {
-    const shared = join25(directory, "runs", SHARED_NOTE);
+    const shared = join26(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] : []]) {
@@ -43108,7 +43279,7 @@ function clearRunRecord(projectPath) {
 }
 function ageMs(path, now) {
   try {
-    return now - statSync9(path).mtimeMs;
+    return now - statSync10(path).mtimeMs;
   } catch {
     return 0;
   }
@@ -43121,7 +43292,7 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
   ]));
   let entries;
   try {
-    entries = readdirSync10(directory);
+    entries = readdirSync11(directory);
   } catch {
     return;
   }
@@ -43130,7 +43301,7 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
     if (!transcript && !entry.endsWith(".partial")) {
       continue;
     }
-    const path = join25(directory, entry);
+    const path = join26(directory, entry);
     if (kept.has(path) || ageMs(path, now) < keepMs) {
       continue;
     }
@@ -43139,19 +43310,19 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
     } catch {}
   }
 }
-var execFileAsync, SHARED_NOTE = "run.json", SAME_RUN_WINDOW_MS = 1e4;
+var SHARED_NOTE = "run.json", SAME_RUN_WINDOW_MS = 1e4;
 var init_run_record = __esm(() => {
   init_errors();
   init_paths();
   init_process_children();
   init_runtime_client();
+  init_spawn();
   init_whole_file();
   init_windows_ask();
-  execFileAsync = promisify4(execFile4);
 });
 
 // src/script-origins.ts
-import { join as join26 } from "node:path";
+import { join as join27 } from "node:path";
 function unresolvedClassIn(message) {
   return UNRESOLVED.exec(message)?.[1] ?? null;
 }
@@ -43204,7 +43375,7 @@ function checkWithEngine(godotPath, projectPath) {
       const ran = await runEngine(godotPath, [
         "--headless",
         "--log-file",
-        join26(logDir, "engine.log"),
+        join27(logDir, "engine.log"),
         "--path",
         projectPath,
         "--check-only",
@@ -43249,10 +43420,10 @@ var init_script_origins = __esm(() => {
 });
 
 // src/script-profile.ts
-import { readFileSync as readFileSync22 } from "node:fs";
+import { readFileSync as readFileSync23 } from "node:fs";
 function readProfileFile(path) {
   try {
-    const parsed = JSON.parse(readFileSync22(path, "utf8"));
+    const parsed = JSON.parse(readFileSync23(path, "utf8"));
     return typeof parsed === "object" && typeof parsed.connected === "boolean" ? parsed : null;
   } catch {
     return null;
@@ -43423,27 +43594,25 @@ var init_server_instructions = __esm(() => {
 });
 
 // src/server.ts
-import { execFile as execFile5, spawn as spawn4 } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import {
   appendFileSync as appendFileSync2,
   closeSync as closeSync2,
   constants,
   copyFileSync,
-  existsSync as existsSync20,
+  existsSync as existsSync21,
   fstatSync,
   mkdirSync as mkdirSync16,
   openSync as openSync3,
-  readdirSync as readdirSync11,
-  readFileSync as readFileSync23,
+  readdirSync as readdirSync12,
+  readFileSync as readFileSync24,
   readSync as readSync2,
   rmdirSync as rmdirSync2,
-  statSync as statSync10
+  statSync as statSync11
 } from "node:fs";
-import { basename as basename7, dirname as dirname20, extname as extname3, isAbsolute as isAbsolute3, join as join27, normalize as normalize2, relative as relative5 } from "node:path";
+import { basename as basename8, dirname as dirname21, extname as extname3, isAbsolute as isAbsolute4, join as join28, normalize as normalize2, relative as relative5 } from "node:path";
 import { setTimeout as delay4 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
-import { promisify as promisify5 } from "node:util";
 function editorRestartTimeoutMs() {
   return waitFromEnv("GDHARNESS_EDITOR_RESTART_TIMEOUT_MS", 90000);
 }
@@ -43471,22 +43640,22 @@ function writtenFileRefusal(path, rule) {
   if (/^(res|user):\/\//.test(path)) {
     return `${named} ${path} is a Godot path; ${what} is saved outside the project, at an absolute path on this machine.`;
   }
-  if (!isAbsolute3(path)) {
+  if (!isAbsolute4(path)) {
     return `${named} ${path} is not absolute; name the whole path, so where it is written does not depend on this server's directory.`;
   }
   if (!rule.extensions.includes(extname3(path).toLowerCase())) {
     return `${named} ${path} does not end in ${rule.extensions.join(" or ")}, which is what ${what} is.`;
   }
-  const directory = realPathOr(dirname20(path));
-  if (!existsSync20(directory)) {
-    return `${named}'s directory ${dirname20(path)} does not exist; ${what} creates no directories.`;
+  const directory = realPathOr(dirname21(path));
+  if (!existsSync21(directory)) {
+    return `${named}'s directory ${dirname21(path)} does not exist; ${what} creates no directories.`;
   }
-  const where = join27(directory, basename7(path));
+  const where = join28(directory, basename8(path));
   const inside = rule.projects.find((project) => project !== "" && isWithinRoot(realPathOr(project), where));
   if (inside !== undefined) {
     return `${named} ${path} is inside the project at ${inside}; ${what} is saved outside it, so it never becomes part of the game.`;
   }
-  const taken = rule.writes(where).find((file) => existsSync20(file));
+  const taken = rule.writes(where).find((file) => existsSync21(file));
   if (taken !== undefined) {
     return taken === where ? `${named} ${path} already exists; ${what} is not written over a file. Name a new one.` : `${named} ${path} would write ${taken}, which already exists; ${what} is not written over a file. Name a new one.`;
   }
@@ -43536,6 +43705,9 @@ function captureDetail(payload) {
 function patienceForFrames(frames, atLeast) {
   return Math.max(atLeast, frames / SLOWEST_FRAME_RATE * 1000 + atLeast);
 }
+function withDefined(fields) {
+  return Object.fromEntries(Object.entries(fields).filter(([, value]) => value !== undefined));
+}
 function longerWaitNote(tool, op, waitedMs) {
   const spec = TOOL_SPECS.find((one) => one.name === tool);
   if (spec !== undefined && argumentsOf(spec, op).includes("timeoutMs")) {
@@ -43979,9 +44151,35 @@ function notRunNote(notRun, failFast) {
   const cases = `${notRun} case${notRun === 1 ? "" : "s"}`;
   return failFast ? `This run stopped at the first failure in each suite it failed in, so ${cases} never ran and count as neither passed nor failed. Leave failFast out to run every case.` : `${cases} counted in ${notRun === 1 ? "its suite" : "their suites"} never ran and count as neither passed nor failed. failFast was not set, so it was not that: the suites below with notRun are the ones to read.`;
 }
+function exportPresetRefusal(projectPath, preset) {
+  let text;
+  try {
+    text = readFileSync24(join28(projectPath, "export_presets.cfg"), "utf8");
+  } catch {
+    return `This project has no export_presets.cfg, so it has no preset '${preset}' to export with. The editor writes the file when a preset is added in Project > Export.`;
+  }
+  const names = [];
+  let inPreset = false;
+  for (const line of text.split(/\r?\n/)) {
+    const section = /^\s*\[([^\]]+)\]/.exec(line)?.[1];
+    if (section !== undefined) {
+      inPreset = /^preset\.\d+$/.test(section.trim());
+      continue;
+    }
+    const named = inPreset ? /^\s*name\s*=\s*"((?:[^"\\]|\\.)*)"/.exec(line)?.[1] : undefined;
+    if (named !== undefined) {
+      names.push(named.replace(/\\(.)/g, "$1"));
+    }
+  }
+  if (names.includes(preset)) {
+    return null;
+  }
+  return names.length === 0 ? `export_presets.cfg names no preset, so there is no '${preset}' to export with. The editor adds one in Project > Export.` : `This project has no export preset named '${preset}'. Its presets are ${names.map((name) => `'${name}'`).join(", ")}.`;
+}
 function exportAnswer(ending, asked, before, after) {
   const { log } = ending;
   const written = after !== null && after !== before;
+  const notCopied = librariesNotCopied(log.all);
   const verdict = {
     exported: ending.exitCode === 0 && ending.failure === null && log.count("error") === 0 && written,
     ...asked,
@@ -43990,6 +44188,10 @@ function exportAnswer(ending, asked, before, after) {
     failure: ending.failure ?? undefined,
     errors: log.count("error"),
     warnings: log.count("warning"),
+    ...notCopied.length === 0 ? {} : {
+      librariesNotLoaded: notCopied,
+      extensionNote: `The export could not load ${notCopied.join(" and ")}: on Windows an engine running as the editor, which an export is, loads a GDExtension from a ~ copy beside the library, and another engine on this project held that copy: it could not be moved aside before the export, or another engine made a new one in between. Export again once that engine has loaded or exited.`
+    },
     ...foldedEntriesAnswer(log)
   };
   if (verdict.exported) {
@@ -44027,7 +44229,7 @@ function engineFlagsNote(args) {
   return `${named} ${among.length === 1 ? "is a flag" : "are flags"} the engine reads, and args goes to the game after --, where the engine does not read ${among.length === 1 ? "it" : "them"}. engineArgs hands the engine its own flags; ${among.length === 1 ? "leave it" : "leave them"} in args only for a game that reads ${among.length === 1 ? "that flag" : "those flags"} itself.`;
 }
 function editorAddonMissing(projectPath) {
-  if (!existsSync20(join27(projectPath, "project.godot"))) {
+  if (!existsSync21(join28(projectPath, "project.godot"))) {
     return null;
   }
   const report = inspectProject(projectPath);
@@ -44263,7 +44465,7 @@ function profileFrameFunctions(projectPath) {
   let projectGodot = null;
   if (projectPath !== null) {
     try {
-      projectGodot = readFileSync23(join27(projectPath, "project.godot"), "utf8");
+      projectGodot = readFileSync24(join28(projectPath, "project.godot"), "utf8");
     } catch {}
   }
   return frameFunctionsFor(queuedMessagesOf(projectGodot));
@@ -44287,7 +44489,7 @@ function projectSourceOf(projectPath) {
       let source = null;
       if (inside.ok) {
         try {
-          source = readFileSync23(inside.absolutePath, "utf8");
+          source = readFileSync24(inside.absolutePath, "utf8");
         } catch {}
       }
       read.set(script, source);
@@ -44437,7 +44639,7 @@ function foldedEntriesAnswer(log, floor = "warning") {
 }
 function gdUnitFailsOnScriptErrors(projectPath) {
   try {
-    return settingKeys(readFileSync23(join27(projectPath, "project.godot"), "utf8")).get("gdunit4/report/godot/script_error") !== false;
+    return settingKeys(readFileSync24(join28(projectPath, "project.godot"), "utf8")).get("gdunit4/report/godot/script_error") !== false;
   } catch {
     return true;
   }
@@ -44452,13 +44654,13 @@ function uncaughtNote(uncaught) {
 }
 function elsewhereIn(projectPath, asked) {
   const wanted = asked.replace(/^res:\/\//, "").replace(/\/+$/, "");
-  if (wanted === "" || existsSync20(join27(projectPath, wanted))) {
+  if (wanted === "" || existsSync21(join28(projectPath, wanted))) {
     return "";
   }
   const root = (wanted.split("/")[0] ?? "").toLowerCase();
   let near = [];
   try {
-    near = readdirSync11(projectPath, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.toLowerCase() !== root).map((entry) => entry.name).filter((name) => name.toLowerCase().startsWith("test") || root.startsWith(name.toLowerCase()));
+    near = readdirSync12(projectPath, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.toLowerCase() !== root).map((entry) => entry.name).filter((name) => name.toLowerCase().startsWith("test") || root.startsWith(name.toLowerCase()));
   } catch {
     return "";
   }
@@ -44542,23 +44744,23 @@ function scriptsToDiagnose(projectPath, given) {
 }
 function isDirectory(path) {
   try {
-    return statSync10(path).isDirectory();
+    return statSync11(path).isDirectory();
   } catch {
     return false;
   }
 }
 function scriptsUnder(directory, prefix) {
-  if (existsSync20(join27(directory, ".gdignore"))) {
+  if (existsSync21(join28(directory, ".gdignore"))) {
     return [];
   }
   const found = [];
-  for (const entry of readdirSync11(directory, { withFileTypes: true }).sort((a, b) => a.name < b.name ? -1 : 1)) {
+  for (const entry of readdirSync12(directory, { withFileTypes: true }).sort((a, b) => a.name < b.name ? -1 : 1)) {
     if (entry.name.startsWith(".")) {
       continue;
     }
     const path = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
     if (entry.isDirectory()) {
-      found.push(...scriptsUnder(join27(directory, entry.name), path));
+      found.push(...scriptsUnder(join28(directory, entry.name), path));
     } else if (entry.isFile() && entry.name.endsWith(".gd")) {
       found.push(path);
     }
@@ -44566,7 +44768,7 @@ function scriptsUnder(directory, prefix) {
   return found;
 }
 function hasMainScene(projectFile) {
-  const scene = parseProjectGodot(readFileSync23(projectFile, "utf8"))["application"]?.["run/main_scene"];
+  const scene = parseProjectGodot(readFileSync24(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "";
 }
 function runtimeAddonAnnouncesEditors(projectPath) {
@@ -44574,13 +44776,13 @@ function runtimeAddonAnnouncesEditors(projectPath) {
     return false;
   }
   try {
-    return readFileSync23(join27(projectPath, RUNTIME_AUTOLOAD.path), "utf8").includes('"editor_pid"');
+    return readFileSync24(join28(projectPath, RUNTIME_AUTOLOAD.path), "utf8").includes('"editor_pid"');
   } catch {
     return false;
   }
 }
 function editorPlaysHeadless(projectFile) {
-  const runArgs = parseProjectGodot(readFileSync23(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
+  const runArgs = parseProjectGodot(readFileSync24(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
   return typeof runArgs === "string" && /(?:^|\s)--headless(?:\s|$)/.test(runArgs);
 }
 function camelCased(params) {
@@ -44599,7 +44801,7 @@ function needsItsOwnProcess(asked) {
 class GodotServer {
   stdio = null;
   locator = new GodotLocator;
-  operationsScript = join27(__dirname2, "godot", "operations", "godot_operations.gd");
+  operationsScript = join28(__dirname2, "godot", "operations", "godot_operations.gd");
   godotBridge;
   tools = buildToolDefinitions();
   activeProcess = null;
@@ -44624,6 +44826,7 @@ class GodotServer {
   launchedDropped = null;
   closedHere = null;
   inFlight = new Map;
+  callsOnGames = new Set;
   callsTaken = 0;
   clientNoted = null;
   parentCommand = null;
@@ -44855,14 +45058,14 @@ class GodotServer {
   }
   noteTheStart() {
     const cwd = process.cwd();
-    const mcpJson = join27(cwd, ".mcp.json");
+    const mcpJson = join28(cwd, ".mcp.json");
     const announced = this.ownProject === null ? null : readAnnouncement(announcementPath(this.ownProject));
     const predecessor = announced !== null && announced.pid !== process.pid && alive(announced.pid) ? announced.pid : null;
     writeLifecycle("started", {
       argv: process.argv.slice(1),
       cwd,
       project: this.ownProject,
-      mcpJson: existsSync20(mcpJson) ? mcpJson : null
+      mcpJson: existsSync21(mcpJson) ? mcpJson : null
     });
     if (predecessor !== null) {
       writeLifecycle("replaced", { project: this.ownProject, predecessor });
@@ -45003,7 +45206,7 @@ class GodotServer {
         return checked.response;
       }
       const named = args["projectPath"];
-      if (typeof named === "string" && existsSync20(join27(named, "project.godot"))) {
+      if (typeof named === "string" && existsSync21(join28(named, "project.godot"))) {
         this.lastProjectPath = named;
       }
       this.updates.refresh();
@@ -45410,7 +45613,15 @@ class GodotServer {
               property: readNonEmptyString(args, "property") ?? ""
             }, { tool: "runtime_inspect", op, patience });
           case "accessibility":
-            return await this.handleRuntimeCommand("get_accessibility", whichGame(args), {
+            return await this.handleRuntimeCommand("get_accessibility", {
+              ...whichGame(args),
+              ...withDefined({
+                node_path: readNonEmptyString(args, "nodePath"),
+                says: readNonEmptyString(args, "says"),
+                properties: readStringArray(args, "properties"),
+                limit: readPositiveNumber(args, "limit")
+              })
+            }, {
               tool: "runtime_inspect",
               op,
               patience: readPositiveNumber(args, "timeoutMs") ?? Math.max(30000, this.runtimeTimeoutMs())
@@ -45461,7 +45672,14 @@ class GodotServer {
             ...args["index"] === undefined ? {} : { index: args["index"] }
           }, { tool: "runtime_input", op });
         }
-        return await this.handleRuntimeCommand(`inject_${op}`, args, { tool: "runtime_input", op });
+        {
+          const holding = readPositiveNumber(args, "holdFrames");
+          return await this.handleRuntimeCommand(`inject_${op}`, args, {
+            tool: "runtime_input",
+            op,
+            ...holding === undefined ? {} : { patience: patienceForFrames(holding, this.runtimeTimeoutMs()) }
+          });
+        }
       case "runtime_wait":
         return await this.handleRuntimeWait(op, args);
       case "debug_breakpoint": {
@@ -45561,8 +45779,8 @@ class GodotServer {
     if (path === undefined) {
       return { ok: false, response: this.createErrorResponse("projectPath is required.") };
     }
-    const file = join27(path, "project.godot");
-    if (!existsSync20(file)) {
+    const file = join28(path, "project.godot");
+    if (!existsSync21(file)) {
       return {
         ok: false,
         response: this.createErrorResponse(`Not a Godot project: ${path}`, [
@@ -45608,7 +45826,7 @@ class GodotServer {
   }
   runEnvironment(args) {
     const savesIn = readNonEmptyString(args, "savesIn");
-    if (savesIn !== undefined && !isAbsolute3(savesIn)) {
+    if (savesIn !== undefined && !isAbsolute4(savesIn)) {
       return {
         ok: false,
         response: this.createErrorResponse(`savesIn must be an absolute path, not "${savesIn}".`, [
@@ -46192,11 +46410,11 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const application = parseProjectGodot(readFileSync23(project.value.file, "utf8"))["application"] ?? {};
+    const application = parseProjectGodot(readFileSync24(project.value.file, "utf8"))["application"] ?? {};
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
-      name: typeof name === "string" && name !== "" ? name : basename7(project.value.path),
+      name: typeof name === "string" && name !== "" ? name : basename8(project.value.path),
       path: project.value.path,
       mainScene: typeof mainScene === "string" && mainScene !== "" ? mainScene : null,
       godotVersion: await this.godotVersion(engine.value),
@@ -46244,22 +46462,26 @@ class GodotServer {
     if (!output.ok) {
       return this.createErrorResponse(output.reason, PATH_SOLUTIONS);
     }
+    const noPreset = exportPresetRefusal(project.value.path, preset);
+    if (noPreset !== null) {
+      return this.createErrorResponse(noPreset, ["project_export list reads the presets the project has"]);
+    }
     const engine = await this.engine();
     if (!engine.ok) {
       return engine.response;
     }
-    const folder = dirname20(output.absolutePath);
+    const folder = dirname21(output.absolutePath);
     try {
       mkdirSync16(folder, { recursive: true });
     } catch (error) {
-      return this.createErrorResponse(`Cannot create ${dirname20(output.relativePath)} to export into: ${errorMessage(error)}`);
+      return this.createErrorResponse(`Cannot create ${dirname21(output.relativePath)} to export into: ${errorMessage(error)}`);
     }
     const debug = readBoolean(args, "debug") ?? false;
     const exportLogs = scratchDirectory("export");
     const exportArgs = [
       "--headless",
       "--log-file",
-      join27(exportLogs, "engine.log"),
+      join28(exportLogs, "engine.log"),
       "--path",
       project.value.path,
       debug ? "--export-debug" : "--export-release",
@@ -46267,8 +46489,12 @@ class GodotServer {
       output.absolutePath
     ];
     this.logDebug(`Exporting: ${engine.value} ${exportArgs.join(" ")}`);
-    const writtenAt = () => existsSync20(output.absolutePath) ? statSync10(output.absolutePath).mtimeMs : null;
+    const writtenAt = () => existsSync21(output.absolutePath) ? statSync11(output.absolutePath).mtimeMs : null;
     const before = writtenAt();
+    const freed = freeLibraryCopies(project.value.path);
+    if (freed.setAside.length > 0 || freed.swept.length > 0) {
+      this.logDebug(`Before the export: set aside ${freed.setAside.join(", ")}; swept ${freed.swept.join(", ")}`);
+    }
     let ending;
     try {
       ending = await runEngine(engine.value, exportArgs, { timeout: { ms: 300000, said: "five minutes" } });
@@ -46331,10 +46557,10 @@ class GodotServer {
     if (movie !== null) {
       return this.createErrorResponse(movie);
     }
-    const missing = paths.value.filter((path) => !existsSync20(join27(project.value.path, path.slice("res://".length))));
+    const missing = paths.value.filter((path) => !existsSync21(join28(project.value.path, path.slice("res://".length))));
     const asked = paths.value.filter((path) => !missing.includes(path));
     const runner = "addons/gdUnit4/bin/GdUnitCmdTool.gd";
-    const noRunner = !existsSync20(join27(project.value.path, runner));
+    const noRunner = !existsSync21(join28(project.value.path, runner));
     if (asked.length === 0) {
       const verdict = `nothing at ${missing.join(" and ")}`;
       const andNoRunner = noRunner ? `, and gdUnit4 is not installed in this project: no ${runner}` : "";
@@ -46425,21 +46651,21 @@ class GodotServer {
       await untilGone([run.process.pid]);
     }
     await run.settled;
-    const reportsDir = join27(project.value.path, ".godot", ...ours.split("/"));
+    const reportsDir = join28(project.value.path, ".godot", ...ours.split("/"));
     let report = null;
     let reportProblem = null;
     try {
-      const written = existsSync20(reportsDir) ? readdirSync11(reportsDir).filter((name) => name.startsWith("report_")).sort((a, b) => Number(a.slice("report_".length)) - Number(b.slice("report_".length))) : [];
+      const written = existsSync21(reportsDir) ? readdirSync12(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(readFileSync23(join27(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync24(join28(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
     } finally {
       discard(reportsDir, userData);
       try {
-        rmdirSync2(dirname20(reportsDir));
+        rmdirSync2(dirname21(reportsDir));
       } catch {}
     }
     const engineEntries = foldedRepeats(run.log.select({
@@ -46608,7 +46834,7 @@ class GodotServer {
   }
   async godotVersion(godotPath) {
     try {
-      const { stdout } = await run4(godotPath, ["--version"], { timeout: 1e4 });
+      const { stdout } = await runHidden(godotPath, ["--version"], { timeout: 1e4 });
       this.lastGodotVersion = stdout.trim();
       return this.lastGodotVersion;
     } catch (error) {
@@ -46669,6 +46895,10 @@ class GodotServer {
     return markIfStale(answer, this.godotBridge.getStatus().addonVersion, SERVER_VERSION, this.godotBridge.getStatus().addonDigest, shippedEditorDigest(), this.editorCodeOnDisk());
   }
   async diagnosticsOf(args) {
+    const waited = await this.waitForTheEditorOpenedHere(args, []);
+    if (waited !== null) {
+      return { refusal: waited, perScript: false };
+    }
     const answer = await this.handleLSP("lsp_get_diagnostics", args);
     const payload = asParams(JSON.parse(answer.content[0]?.text ?? "{}"));
     const refused = this.languageServerRefusal(payload, "Diagnostics");
@@ -46699,11 +46929,11 @@ class GodotServer {
     const cached = cachedClasses(projectPath);
     const sourceOf = (resourcePath) => {
       const contained = resolveWithinProject(projectPath, resourcePath);
-      if (!contained.ok || !existsSync20(contained.absolutePath)) {
+      if (!contained.ok || !existsSync21(contained.absolutePath)) {
         return null;
       }
       try {
-        return readFileSync23(contained.absolutePath, "utf8");
+        return readFileSync24(contained.absolutePath, "utf8");
       } catch {
         return null;
       }
@@ -46753,9 +46983,34 @@ class GodotServer {
     const recorded = readClassNote(projectPath)?.shortListEditorPid;
     return recorded !== undefined && recorded === (this.godotBridge.getStatus().editorPid ?? null);
   }
+  unseenBeforeAnUnfinishedScan(projectPath) {
+    const noted = readClassNote(projectPath)?.unseenBeforeAnUnfinishedScan;
+    if (noted === undefined || noted.editorPid !== (this.godotBridge.getStatus().editorPid ?? null)) {
+      return [];
+    }
+    return [...noted.classes];
+  }
+  noteUnseenBeforeAnUnfinishedScan(projectPath, classes) {
+    const note = readClassNote(projectPath);
+    const held = note?.unseenBeforeAnUnfinishedScan;
+    if (classes.length === 0 && held === undefined) {
+      return;
+    }
+    const { unseenBeforeAnUnfinishedScan: _replaced, ...rest } = note ?? { rebuiltWith: [] };
+    writeClassNote(projectPath, {
+      ...rest,
+      ...classes.length === 0 ? {} : {
+        unseenBeforeAnUnfinishedScan: {
+          editorPid: this.godotBridge.getStatus().editorPid ?? null,
+          classes: [...classes].sort()
+        }
+      }
+    });
+  }
   noteAShortListEditor(projectPath) {
     const note = readClassNote(projectPath);
     writeClassNote(projectPath, {
+      ...note,
       rebuiltWith: note?.rebuiltWith ?? [],
       shortListEditorPid: this.godotBridge.getStatus().editorPid ?? null
     });
@@ -46768,11 +47023,11 @@ class GodotServer {
   }
   sourceOfClass(projectPath, resourcePath) {
     const contained = resolveWithinProject(projectPath, resourcePath);
-    if (!contained.ok || !existsSync20(contained.absolutePath)) {
+    if (!contained.ok || !existsSync21(contained.absolutePath)) {
       return null;
     }
     try {
-      return readFileSync23(contained.absolutePath, "utf8");
+      return readFileSync24(contained.absolutePath, "utf8");
     } catch {
       return null;
     }
@@ -46780,7 +47035,17 @@ class GodotServer {
   async handleLSP(toolName, args) {
     return handleLSPTool(await this.lsp(), toolName, args);
   }
+  async waitForTheEditorOpenedHere(args, instead) {
+    if (this.godotBridge.isConnected() || this.launchedEditor === null || !await this.launchedEditorIsUp()) {
+      return null;
+    }
+    return await this.noEditorYet(args, instead);
+  }
   async askScriptInfo(toolName, asked, args) {
+    const waited = await this.waitForTheEditorOpenedHere(args, []);
+    if (waited !== null) {
+      return waited;
+    }
     const answer = await this.handleLSP(toolName, args);
     const refused = this.languageServerRefusal(asParams(JSON.parse(answer.content[0]?.text ?? "{}")), asked);
     return refused === null ? answer : refused.refusal;
@@ -46920,7 +47185,7 @@ class GodotServer {
       ...Array.isArray(stack) ? {
         stack: stack.map((frame) => ({
           ...frame,
-          ...projectPath !== "" && typeof frame["script"] === "string" && frame["script"].startsWith("res://") ? { path: join27(projectPath, frame["script"].slice("res://".length)) } : {}
+          ...projectPath !== "" && typeof frame["script"] === "string" && frame["script"].startsWith("res://") ? { path: join28(projectPath, frame["script"].slice("res://".length)) } : {}
         }))
       } : {}
     });
@@ -47190,7 +47455,7 @@ class GodotServer {
       return null;
     }
     try {
-      return settingKeys(readFileSync23(join27(projectPath, "project.godot"), "utf8"));
+      return settingKeys(readFileSync24(join28(projectPath, "project.godot"), "utf8"));
     } catch {
       return null;
     }
@@ -47455,6 +47720,7 @@ class GodotServer {
   }
   async openAnEditor(engine, projectPath, ports, hidden) {
     clearEditorLog(projectPath);
+    freeLibraryCopies(projectPath);
     const launched = await launchOutsideTheTree({
       command: engine,
       args: editorArguments(projectPath, ports, editorLogPath(projectPath), hidden),
@@ -47505,6 +47771,17 @@ class GodotServer {
     if (sceneToRun && !sceneToRun.ok) {
       return this.createErrorResponse(sceneToRun.reason, PATH_SOLUTIONS);
     }
+    const build = readNonEmptyString(args, "executable");
+    const exported = build === undefined ? null : exportedBuild(project.value.path, build);
+    if (exported !== null && !exported.ok) {
+      return this.createErrorResponse(exported.reason, PATH_SOLUTIONS);
+    }
+    if (exported !== null && scene !== undefined) {
+      return this.createErrorResponse("An exported build runs the main scene its pack holds, and takes no scene: leave scene out, or run the project without executable.");
+    }
+    if (exported !== null && readBoolean(args, "profile") === true) {
+      return this.createErrorResponse("A profile is read through the debugger, and an exported build is started without one, since a release build quits when given --remote-debug. Profile the project without executable.");
+    }
     const given = this.gameArguments(args);
     if (!given.ok) {
       return given.response;
@@ -47521,13 +47798,13 @@ class GodotServer {
     if (!asked.ok) {
       return asked.response;
     }
-    if (!sceneToRun && !hasMainScene(project.value.file)) {
+    if (exported === null && !sceneToRun && !hasMainScene(project.value.file)) {
       return this.createErrorResponse("The project sets no main scene, so there is nothing to run.", [
         "Pass scene to run one scene",
         "Choose the main scene with project_settings set_main_scene"
       ]);
     }
-    const engine = await this.engine();
+    const engine = exported?.ok === true ? { ok: true, value: exported.absolutePath } : await this.engine();
     if (!engine.ok) {
       return engine.response;
     }
@@ -47565,11 +47842,11 @@ class GodotServer {
     const editorWouldPlay = !headless || editorPlaysHeadless(project.value.file);
     const silent = resolveSilent(args["silent"], process.env) && !headless;
     const profiled = readBoolean(args, "profile") === true;
-    if (this.godotBridge.isConnected() && editorWouldPlay && given.value.length === 0 && flags.value.length === 0 && !needsItsOwnProcess(asked.value) && !silent) {
+    if (exported === null && this.godotBridge.isConnected() && editorWouldPlay && given.value.length === 0 && flags.value.length === 0 && !needsItsOwnProcess(asked.value) && !silent) {
       return await this.playThroughEditor(sceneArgument, refreshed.value, scanned, project.value.path, alreadyPlaying, runtimeWaitMs, ended, profiled);
     }
     const cmdArgs = runArguments({
-      projectPath: project.value.path,
+      projectPath: exported === null ? project.value.path : null,
       headless,
       scene: sceneArgument,
       userArgs: given.value,
@@ -47577,7 +47854,7 @@ class GodotServer {
       silent
     });
     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, headless || args["visible"] === true ? undefined : HIDDEN_DESKTOP, profiled);
+    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, profiled, exported === null);
     if ("error" in started) {
       return this.createErrorResponse(`The game could not be started: ${started.error}`, [
         "editor_status says which Godot this server runs and whether it answers"
@@ -47586,7 +47863,7 @@ class GodotServer {
     started.announcedBefore = alreadyPlaying;
     started.bootScene = runtimeWaitMs.scene;
     this.activeProcess = started;
-    const spawnedInstead = this.godotBridge.isConnected() && editorWouldPlay && (given.value.length > 0 || flags.value.length > 0) ? ` The editor cannot be handed arguments for a game it plays, so this one was started here.${OWN_DEBUGGER}` : this.godotBridge.isConnected() && editorWouldPlay && needsItsOwnProcess(asked.value) ? ` The editor plays a game with its own environment, so a run given one was started here.${OWN_DEBUGGER}` : this.godotBridge.isConnected() && editorWouldPlay && silent ? " The editor cannot play a game silent, which takes an engine flag, so this one was " + `started here${args["silent"] === true ? "" : ", silent because GDHARNESS_SILENT says so"}, and silent: false plays it through the editor.${OWN_DEBUGGER}` : "";
+    const spawnedInstead = exported !== null ? " An exported build is started without a debugger, since a release build quits when given one, so breakpoints and debug_state do not reach it." : this.godotBridge.isConnected() && editorWouldPlay && (given.value.length > 0 || flags.value.length > 0) ? ` The editor cannot be handed arguments for a game it plays, so this one was started here.${OWN_DEBUGGER}` : this.godotBridge.isConnected() && editorWouldPlay && needsItsOwnProcess(asked.value) ? ` The editor plays a game with its own environment, so a run given one was started here.${OWN_DEBUGGER}` : this.godotBridge.isConnected() && editorWouldPlay && silent ? " The editor cannot play a game silent, which takes an engine flag, so this one was " + `started here${args["silent"] === true ? "" : ", silent because GDHARNESS_SILENT says so"}, and silent: false plays it through the editor.${OWN_DEBUGGER}` : "";
     const endedForThis = endedToStartThis(ended);
     const stranded = wereHereFirst.filter((one) => one.pid !== ended?.pid && alive(one.pid));
     const handed = this.dapHoldingBreakpointsOf(project.value.path).breakpointsHeld();
@@ -47596,6 +47873,7 @@ class GodotServer {
       through: "gdharness",
       alsoRunning: stranded.length === 0 ? undefined : stranded.map((one) => one.pid),
       pid: started.pid,
+      executable: exported?.ok === true ? exported.relativePath : undefined,
       arguments: cmdArgs,
       argsNote: engineFlagsNote(given.value),
       transcript: started.transcript,
@@ -47607,13 +47885,13 @@ class GodotServer {
       endedPreviousRun: endedPreviousRun(ended),
       previousRunLeft: previousRunLeft(ended),
       ...previousRunHow(ended),
-      runtime: await this.runtimeUp(project.value.path, alreadyPlaying, runtimeWaitMs, given.value.length > 0),
+      runtime: exported !== null ? undefined : await this.runtimeUp(project.value.path, alreadyPlaying, runtimeWaitMs, given.value.length > 0),
       message: `Use editor_output for what it prints and editor_run stop to end it.${started.keeper !== undefined && handed.length > 0 ? " It stops at the lines under breakpoints, and debug_state stack reads where it is held." : ""}${spawnedInstead}${endedForThis}${alsoRunning}`
     });
   }
   async runtimeUp(projectPath, before, budget, withArgs) {
     const budgetMs = budget.ms;
-    if (!existsSync20(join27(projectPath, RUNTIME_AUTOLOAD.path))) {
+    if (!existsSync21(join28(projectPath, RUNTIME_AUTOLOAD.path))) {
       return runtimeVerdict(null, {
         addon: false,
         budgetMs,
@@ -47698,7 +47976,7 @@ class GodotServer {
     }
     let announcedAt;
     try {
-      announcedAt = statSync10(endpoint.file).mtimeMs;
+      announcedAt = statSync11(endpoint.file).mtimeMs;
     } catch {
       return;
     }
@@ -47892,7 +48170,7 @@ class GodotServer {
       return 0;
     }
     try {
-      return reportAlreadyInTranscript(readFileSync23(game.transcript), readFileSync23(report));
+      return reportAlreadyInTranscript(readFileSync24(game.transcript), readFileSync24(report));
     } catch (error) {
       this.logDebug(`Could not compare a picked-up run's report with its transcript: ${errorMessage(error)}`);
       return 0;
@@ -48047,7 +48325,10 @@ class GodotServer {
     return gone ? "gone" : "lingering";
   }
   spawnGame(godotPath, cmdArgs, env) {
-    const child = spawn4(godotPath, cmdArgs, { stdio: ["ignore", "pipe", "pipe"], ...env ? { env } : {} });
+    const child = spawnHidden(godotPath, cmdArgs, {
+      stdio: ["ignore", "pipe", "pipe"],
+      ...env ? { env } : {}
+    });
     const cancelled = callSignal();
     if (cancelled !== undefined) {
       const end = () => {
@@ -48120,7 +48401,7 @@ class GodotServer {
     });
     return Object.assign(started, { settled });
   }
-  async launchKeptGame(godotPath, cmdArgs, projectPath, env, desktop, profiled = false) {
+  async launchKeptGame(godotPath, cmdArgs, projectPath, env, desktop, profiled = false, debugged = true) {
     const startedAt = Date.now();
     const transcript = openTranscript(startedAt);
     closeSync2(transcript.fd);
@@ -48136,7 +48417,7 @@ class GodotServer {
         projectPath,
         ...this.servedBy(),
         ...profile === undefined ? {} : { profile },
-        breakpoints: this.breakpointsForAGame(projectPath)
+        ...debugged ? { breakpoints: this.breakpointsForAGame(projectPath) } : { debugged: false }
       },
       ...desktop === undefined ? {} : { desktop }
     });
@@ -48572,7 +48853,7 @@ class GodotServer {
     }
     const going = await this.runStillGoing(run);
     const projectPath = run.projectPath;
-    const projectGone = projectPath !== null && !existsSync20(join27(projectPath, "project.godot"));
+    const projectGone = projectPath !== null && !existsSync21(join28(projectPath, "project.godot"));
     if (projectGone && callersName !== undefined) {
       return this.createErrorResponse(`callersOf reads the project's scripts, and the run's project at ${projectPath} has no project.godot any more.`, ["editor_run profile without callersOf answers with the profile itself"]);
     }
@@ -48860,7 +49141,7 @@ class GodotServer {
       notes.push(endedWithoutACode({
         throughEditor: run.throughEditor,
         announced: announced !== undefined || run.announcedPid !== undefined,
-        couldAnnounce: run.projectPath !== null && existsSync20(join27(run.projectPath, RUNTIME_AUTOLOAD.path)),
+        couldAnnounce: run.projectPath !== null && existsSync21(join28(run.projectPath, RUNTIME_AUTOLOAD.path)),
         endedHere: typeof run.endedHere === "string",
         pickedUp: run.pickedUp === true
       }));
@@ -49100,8 +49381,8 @@ class GodotServer {
     try {
       const status = asParams(await this.godotBridge.invokeTool("scan_status", {}));
       return status["scanning"] === true || status["importing"] === true;
-    } catch {
-      return false;
+    } catch (error) {
+      return error instanceof BridgeTimeout;
     }
   }
   async handleRescanFilesystem(args) {
@@ -49112,7 +49393,7 @@ class GodotServer {
     let writtenBefore = null;
     let blind = { unseen: [] };
     let waitedForEditorMs = 0;
-    let first;
+    let startUnanswered = false;
     let completedBefore;
     let uidsReread = [];
     let uidsDuplicatedOnDisk = [];
@@ -49129,7 +49410,11 @@ class GodotServer {
       before = projectPath === "" ? null : cachedClasses(projectPath);
       writtenBefore = projectPath === "" ? null : cacheWrittenAt(projectPath);
       blind = await this.classesTheEditorCannotSee(args);
-      first = await this.handleViaBridge("rescan_filesystem", args);
+      const first = await this.askViaBridge("rescan_filesystem", args);
+      if (first instanceof BridgeTimeout) {
+        startUnanswered = true;
+        break;
+      }
       if (first.isError) {
         return first;
       }
@@ -49152,7 +49437,17 @@ class GodotServer {
     let idleSince = null;
     while (Date.now() - started < timeoutMs) {
       await new Promise((settle) => setTimeout(settle, 100));
-      const status = asParams(await this.godotBridge.invokeTool("rescan_filesystem", { ...args, statusOnly: true }));
+      let status;
+      try {
+        status = asParams(await this.godotBridge.invokeTool("rescan_filesystem", { ...args, statusOnly: true }));
+      } catch (error) {
+        if (!(error instanceof BridgeTimeout)) {
+          throw error;
+        }
+        busy = true;
+        idleSince = null;
+        continue;
+      }
       const pending = Boolean(status["pending"]) && Date.now() - started < SCAN_START_MS;
       const completed = readNumber(status, "scansCompleted");
       const notYetOver = completedBefore !== undefined && completed !== undefined && completed <= completedBefore;
@@ -49235,12 +49530,20 @@ class GodotServer {
     }
     const checked = busy ? { unseen: [] } : await this.classesTheEditorCannotSee(args);
     const unseen = checked.unseen;
-    const broughtIn = busy ? [] : blind.unseen.map((one) => one.className).filter((name) => !unseen.some((still) => still.className === name));
+    const carried = projectPath === "" ? [] : this.unseenBeforeAnUnfinishedScan(projectPath);
+    const unseenBefore = [...new Set([...blind.unseen.map((one) => one.className), ...carried])];
+    const broughtIn = busy ? [] : unseenBefore.filter((name) => !unseen.some((still) => still.className === name));
+    if (projectPath !== "") {
+      this.noteUnseenBeforeAnUnfinishedScan(projectPath, busy ? unseenBefore : []);
+    }
     const dependents = busy || projectPath === "" || broughtIn.length === 0 ? null : await this.reloadDependents(projectPath, broughtIn);
     const stillGone = lost.filter((name) => !restored.includes(name));
     const notes = [];
     if (busy) {
-      notes.push("The editor was still scanning or importing when the wait ran out, so new files may not be visible yet.");
+      notes.push(startUnanswered ? "The editor took the rescan in and did not answer it before the wait ran out, which is an editor importing: a hidden editor imports on the thread that answers, and answers nothing until it is done. It carries the scan out once it is free, so new files may not be visible yet." : "The editor was still scanning or importing when the wait ran out, so new files may not be visible yet.");
+      if (unseenBefore.length > 0) {
+        notes.push(`Scripts naming ${unseenBefore.join(", ")}, which the editor could not see before this scan, were compiled without them and stay that way until reloaded. editor_rescan again once the editor is idle reloads them, for any server on this project, until this editor is restarted.`);
+      }
     } else if (stillGone.length > 0) {
       notes.push("The scan wrote the class cache from the list this editor is holding, that list is shorter than the file was, and rebuilding the cache from the files did not bring these back. Every engine that reads the cache next, including a test run, will report them as unknown identifiers. Restart the editor with editor_launch restart before scanning again.");
     } else if (lost.length > 0) {
@@ -49358,8 +49661,9 @@ class GodotServer {
     const droppedByTheEditor = lost.filter((name) => !cameBack.includes(name));
     const seenLosing = droppedByTheEditor.length > 0 && this.godotBridge.isConnected();
     writeClassNote(projectPath, {
+      ...noted,
       rebuiltWith: [...after.keys()].sort(),
-      ...seenLosing ? { shortListEditorPid: this.godotBridge.getStatus().editorPid ?? null } : noted?.shortListEditorPid === undefined ? {} : { shortListEditorPid: noted.shortListEditorPid }
+      ...seenLosing ? { shortListEditorPid: this.godotBridge.getStatus().editorPid ?? null } : {}
     });
     const notes = [];
     if (seenLosing) {
@@ -49425,7 +49729,7 @@ class GodotServer {
     if (!scriptPath.ok) {
       return this.createErrorResponse(scriptPath.reason);
     }
-    if (!existsSync20(scriptPath.absolutePath)) {
+    if (!existsSync21(scriptPath.absolutePath)) {
       return this.createErrorResponse(`Script file does not exist: ${scriptPath.absolutePath}`);
     }
     const asked = readNonEmptyString(args, "newScriptPath");
@@ -49433,6 +49737,10 @@ class GodotServer {
     if (moveTo !== null && !moveTo.ok) {
       return this.createErrorResponse(moveTo.reason);
     }
+    const waited = await this.waitForTheEditorOpenedHere(args, []);
+    if (waited !== null) {
+      return waited;
+    }
     const languageServer = {
       problem: null,
       initialized: false
@@ -49675,6 +49983,16 @@ class GodotServer {
     ]);
   }
   async handleViaBridge(toolName, args, askedAs) {
+    const answered = await this.askViaBridge(toolName, args, askedAs);
+    if (!(answered instanceof BridgeTimeout)) {
+      return answered;
+    }
+    return this.createErrorResponse(`The editor took ${toolName} in and did not answer within ${String(answered.waitedMs / 1000)}s. An editor importing files answers nothing until the import is over, and a hidden one imports on the thread that answers.`, [
+      "editor_status says whether it is scanning or importing",
+      "The editor still carries the request out once it is free, so read what it changed before asking again"
+    ]);
+  }
+  async askViaBridge(toolName, args, askedAs) {
     if (!this.godotBridge.isConnected()) {
       const alternative = askedAs !== undefined && Object.hasOwn(EDITOR_FREE_INSTEAD, askedAs) ? EDITOR_FREE_INSTEAD[askedAs] : undefined;
       const refused = await this.noEditorYet(args, alternative === undefined ? [] : [alternative]);
@@ -49693,6 +50011,9 @@ class GodotServer {
     try {
       return this.jsonTextResponse(markIfStale(await this.godotBridge.invokeTool(toolName, args), this.godotBridge.getStatus().addonVersion, SERVER_VERSION, this.godotBridge.getStatus().addonDigest, shippedEditorDigest(), this.editorCodeOnDisk()));
     } catch (error) {
+      if (error instanceof BridgeTimeout) {
+        return error;
+      }
       const message = errorMessage(error);
       if (message.includes(`Unknown tool: ${toolName}`)) {
         const status = this.godotBridge.getStatus();
@@ -49753,7 +50074,7 @@ class GodotServer {
   async ownRunOnItsWay(projectPath, budgetMs) {
     const run = await this.currentRun();
     const project = projectPath ?? run?.projectPath ?? null;
-    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync20(join27(project, RUNTIME_AUTOLOAD.path)) || !await this.runStillGoing(run)) {
+    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync21(join28(project, RUNTIME_AUTOLOAD.path)) || !await this.runStillGoing(run)) {
       return null;
     }
     const already = runtimesAnnounced().running;
@@ -49762,7 +50083,7 @@ class GodotServer {
         return !run.announcedBefore.has(one.pid);
       }
       try {
-        return statSync10(one.file).mtimeMs >= run.startedAt;
+        return statSync11(one.file).mtimeMs >= run.startedAt;
       } catch {
         return false;
       }
@@ -49838,12 +50159,25 @@ class GodotServer {
       }
     }
     const screenshotDir = expectsScreenshot ? scratchDirectory("runtime-screenshot") : null;
-    const screenshotPath = screenshotDir ? join27(screenshotDir, "capture.png") : null;
+    const screenshotPath = screenshotDir ? join28(screenshotDir, "capture.png") : null;
     const staleNote = this.runtimeStaleNote(choice.endpoint);
     const stale = staleNote === undefined ? {} : { addonIsStale: true, staleNote };
     const refused = (message) => this.createErrorResponse(staleNote === undefined ? message : `${message}
 
 ${staleNote}`);
+    const onGame = {
+      pid: choice.endpoint.pid,
+      what: `${asked.tool} ${asked.op}`,
+      alongside: new Set
+    };
+    for (const other of this.callsOnGames) {
+      if (other.pid === onGame.pid) {
+        other.alongside.add(onGame.what);
+        onGame.alongside.add(other.what);
+      }
+    }
+    this.callsOnGames.add(onGame);
+    const alongside = () => onGame.alongside.size === 0 ? {} : { ranAlongside: [...onGame.alongside], alongsideNote: ALONGSIDE_NOTE };
     try {
       const reply = await runtimeRequest(choice.endpoint, command, screenshotPath ? { ...params, output_path: screenshotPath } : params, timeoutMs, !expectsScreenshot);
       if (!reply.ok && reply.requestId !== undefined) {
@@ -49854,7 +50188,8 @@ ${staleNote}`);
           waitedMs: timeoutMs,
           note: `${reply.message} ${longerWaitNote(asked.tool, asked.op, timeoutMs)}`,
           ...answeredBy,
-          ...stale
+          ...stale,
+          ...alongside()
         });
       }
       if (!reply.ok) {
@@ -49862,7 +50197,7 @@ ${staleNote}`);
       }
       const { id: _id, ...payload } = reply.payload;
       if (!expectsScreenshot) {
-        return this.jsonTextResponse({ ...payload, ...answeredBy, ...stale });
+        return this.jsonTextResponse({ ...payload, ...answeredBy, ...stale, ...alongside() });
       }
       const returnedPath = readString(payload, "path");
       if (readString(payload, "type") !== "screenshot_file" || !returnedPath || !screenshotPath) {
@@ -49879,18 +50214,22 @@ ${staleNote}`);
           return this.createErrorResponse(`The capture was taken and could not be saved at ${saveTo}: ${errorMessage(error)}`);
         }
       }
+      const ranWith = [...onGame.alongside];
       return {
         content: [
           {
             type: "text",
-            text: `Screenshot captured: ${dimensions}${chosenAmongSeveral ? ` from pid ${own}, the game this server holds` : ""}${captureDetail(payload)}${saveTo === null ? "" : `. Saved to ${saveTo}`}${staleNote === undefined ? "" : `
+            text: `Screenshot captured: ${dimensions}${chosenAmongSeveral ? ` from pid ${own}, the game this server holds` : ""}${captureDetail(payload)}${saveTo === null ? "" : `. Saved to ${saveTo}`}${ranWith.length === 0 ? "" : `
+
+Ran alongside ${ranWith.join(", ")}. ${ALONGSIDE_NOTE}`}${staleNote === undefined ? "" : `
 
 ${staleNote}`}`
           },
-          { type: "image", data: readFileSync23(screenshotPath).toString("base64"), mimeType: "image/png" }
+          { type: "image", data: readFileSync24(screenshotPath).toString("base64"), mimeType: "image/png" }
         ]
       };
     } finally {
+      this.callsOnGames.delete(onGame);
       discard(screenshotDir);
     }
   }
@@ -49989,7 +50328,7 @@ async function runGodotServer() {
   const server = new GodotServer;
   await server.run();
 }
-var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run4, __dirname2, PARENT_ASKED_AFTER_MS = 5000, EDITOR_SERVERS_START_MS = 20000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, OWN_DEBUGGER = " Its debugger is the keeper holding it rather than the editor, so the debug_* tools answer for it all the same: breakpoints stop it, and debug_control pause breaks into it wherever it is, which the editor offers no way to do.", PLAY_STARTS_WITHIN_MS = 30000, KEEPER_ANSWER_MS = 15000, KEEPER_DEBUG_MS, EXIT_REPORTED_WITHIN_MS = 2000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, PROFILE_SEND_MS = 5000, MOST_GROUPS = 20, RUNTIME_LISTENING_LINE = "[gdharness] runtime listening on ", VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, CONSOLE_WATCH_MS = 250, BOUNDARY_WAIT_MS = 2000, HANDOVER_MS, HANDOVER_POLL_MS = 250, CACHE_WRITE_MS = 2000, STREAMS_GRACE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, SCAN_SETTLED_MS = 500, REIMPORT_TIMEOUT_MS = 300000, EDITOR_FREE_INSTEAD, OPS_ELSEWHERE, AUDIO_BUS_OPS, STALLED_AFTER_MS = 30000, TEST_HEARTBEAT_MS = 20000, DEPENDED_FAILED = "Failed to compile depended scripts", WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/", PROFILE_FUNCTIONS = 30, PROFILER_ON_MS = 3000, PROPERTY_PLACES = "It is a property, so each place says whether it writes it (access write), which runs its set block, or reads it (access read), which runs its get block: withinCalls on a read says nothing of the set block, nor on a write of the get block unless the write is a compound one such as +=. Inside the property's own blocks its name is the value stored, which the engine reads and writes without running them, so those lines are not listed.", CALLERS_FOUND_BY_NAME = "Found by name in the project's scripts, since the engine's profiler counts calls and time per function and records nothing about who made them: a method of the same name on another class is listed too, unless one class was asked about and it is called through another class by name or through a variable declared as one. Each place carries the profile's numbers for the function it is written in.", MOST_ENGINE_ENTRIES = 200, ERROR_ASSERT = "GdUnitGodotErrorAssertImpl.gd", EXTERNAL_MEMBER = 'Could not resolve external class member "', STATIC_LIST_HINT;
+var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, __dirname2, PARENT_ASKED_AFTER_MS = 5000, EDITOR_SERVERS_START_MS = 20000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, ALONGSIDE_NOTE = "Another call on this game was running while this one was: calls sent together run together and are answered as each finishes, so this answer is not from after the other. Send a call meant to come after another once that one has answered.", OWN_DEBUGGER = " Its debugger is the keeper holding it rather than the editor, so the debug_* tools answer for it all the same: breakpoints stop it, and debug_control pause breaks into it wherever it is, which the editor offers no way to do.", PLAY_STARTS_WITHIN_MS = 30000, KEEPER_ANSWER_MS = 15000, KEEPER_DEBUG_MS, EXIT_REPORTED_WITHIN_MS = 2000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, PROFILE_SEND_MS = 5000, MOST_GROUPS = 20, RUNTIME_LISTENING_LINE = "[gdharness] runtime listening on ", VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, CONSOLE_WATCH_MS = 250, BOUNDARY_WAIT_MS = 2000, HANDOVER_MS, HANDOVER_POLL_MS = 250, CACHE_WRITE_MS = 2000, STREAMS_GRACE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, SCAN_SETTLED_MS = 500, REIMPORT_TIMEOUT_MS = 300000, EDITOR_FREE_INSTEAD, OPS_ELSEWHERE, AUDIO_BUS_OPS, STALLED_AFTER_MS = 30000, TEST_HEARTBEAT_MS = 20000, DEPENDED_FAILED = "Failed to compile depended scripts", WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/", PROFILE_FUNCTIONS = 30, PROFILER_ON_MS = 3000, PROPERTY_PLACES = "It is a property, so each place says whether it writes it (access write), which runs its set block, or reads it (access read), which runs its get block: withinCalls on a read says nothing of the set block, nor on a write of the get block unless the write is a compound one such as +=. Inside the property's own blocks its name is the value stored, which the engine reads and writes without running them, so those lines are not listed.", CALLERS_FOUND_BY_NAME = "Found by name in the project's scripts, since the engine's profiler counts calls and time per function and records nothing about who made them: a method of the same name on another class is listed too, unless one class was asked about and it is called through another class by name or through a variable declared as one. Each place carries the profile's numbers for the function it is written in.", MOST_ENGINE_ENTRIES = 200, ERROR_ASSERT = "GdUnitGodotErrorAssertImpl.gd", EXTERNAL_MEMBER = 'Could not resolve external class member "', STATIC_LIST_HINT;
 var init_server = __esm(() => {
   init_dist();
   init_stdio();
@@ -50019,6 +50358,7 @@ var init_server = __esm(() => {
   init_junit();
   init_keeper_channel();
   init_launch();
+  init_library_copies();
   init_lifecycle_log();
   init_lsp_client();
   init_outside();
@@ -50041,11 +50381,11 @@ var init_server = __esm(() => {
   init_server_instructions();
   init_server_version();
   init_setup();
+  init_spawn();
   init_tool_definitions();
   init_tool_reference();
   init_update_check();
-  run4 = promisify5(execFile5);
-  __dirname2 = dirname20(fileURLToPath5(import.meta.url));
+  __dirname2 = dirname21(fileURLToPath5(import.meta.url));
   KEEPER_DEBUG_MS = PAUSE_MS + STEP_MS + 2 * READ_MS;
   CONSOLE_WRAPPER = /_console(\.exe)?$/i;
   LONGEST_BOOT_NOTED_MS = 5 * 60000;
@@ -50104,11 +50444,11 @@ var init_server = __esm(() => {
 init_bridge_announce();
 init_errors();
 init_godot_path();
-import { existsSync as existsSync21 } from "node:fs";
-import { join as join28, resolve as resolve8 } from "node:path";
+import { existsSync as existsSync22 } from "node:fs";
+import { join as join29, resolve as resolve8 } from "node:path";
 
 // src/harnesses.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, rmSync as rmSync2, statSync as statSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, rmSync as rmSync2, statSync as statSync3, writeFileSync as writeFileSync2 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
 import { basename as basename2, dirname as dirname3, join as join4, relative as relative2, resolve as resolve2 } from "node:path";
 import process4 from "node:process";
@@ -50836,7 +51176,7 @@ function mainCheckoutOf(projectPath) {
     top = up;
   }
   const marker = join4(top, ".git");
-  if (!statSync2(marker).isFile()) {
+  if (!statSync3(marker).isFile()) {
     return null;
   }
   const pointer = /^gitdir:\s*(.+)$/m.exec(readFileSync2(marker, "utf8"))?.[1]?.trim();
@@ -50865,7 +51205,7 @@ function worktreeCheckoutsOf(projectPath) {
     top = up;
   }
   const listed = join4(top, ".git", "worktrees");
-  if (!statSync2(join4(top, ".git")).isDirectory() || !existsSync4(listed)) {
+  if (!statSync3(join4(top, ".git")).isDirectory() || !existsSync4(listed)) {
     return [];
   }
   const below = relative2(top, resolve2(projectPath));
@@ -51070,10 +51410,10 @@ init_setup();
 init_setup();
 init_tool_definitions();
 init_tool_reference();
-import { existsSync as existsSync12, mkdirSync as mkdirSync5, readdirSync as readdirSync7, rmSync as rmSync6, writeFileSync as writeFileSync7 } from "node:fs";
-import { basename as basename4, dirname as dirname6, join as join12 } from "node:path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync5, readdirSync as readdirSync8, rmSync as rmSync6, writeFileSync as writeFileSync7 } from "node:fs";
+import { basename as basename5, dirname as dirname7, join as join13 } from "node:path";
 var SKILL_NAME = "gdharness";
-var SHARED_SKILLS = join12(".agents", "skills");
+var SHARED_SKILLS = join13(".agents", "skills");
 function skillMarkdown(version) {
   return `---
 name: ${SKILL_NAME}
@@ -51279,27 +51619,27 @@ comes back separately, under \`engine_messages_after_answer\`: none of it change
 function skillFiles(version) {
   return new Map([
     ["SKILL.md", skillMarkdown(version)],
-    [join12("references", "tools.md"), renderToolsMarkdown()]
+    [join13("references", "tools.md"), renderToolsMarkdown()]
   ]);
 }
 function skillDirectories(harnesses, projectPath, exists) {
-  const directories = [join12(projectPath, SHARED_SKILLS, SKILL_NAME)];
+  const directories = [join13(projectPath, SHARED_SKILLS, SKILL_NAME)];
   for (const harness of harnesses) {
     if (harness.skills === undefined) {
       continue;
     }
-    const own = join12(projectPath, harness.skills.dir);
-    if ((!harness.skills.shared || exists(own)) && !directories.includes(join12(own, SKILL_NAME))) {
-      directories.push(join12(own, SKILL_NAME));
+    const own = join13(projectPath, harness.skills.dir);
+    if ((!harness.skills.shared || exists(own)) && !directories.includes(join13(own, SKILL_NAME))) {
+      directories.push(join13(own, SKILL_NAME));
     }
   }
   return directories;
 }
 function everySkillDirectory(projectPath, harnesses) {
-  const directories = new Set([join12(projectPath, SHARED_SKILLS, SKILL_NAME)]);
+  const directories = new Set([join13(projectPath, SHARED_SKILLS, SKILL_NAME)]);
   for (const harness of harnesses) {
     if (harness.skills !== undefined) {
-      directories.add(join12(projectPath, harness.skills.dir, SKILL_NAME));
+      directories.add(join13(projectPath, harness.skills.dir, SKILL_NAME));
     }
   }
   return [...directories];
@@ -51307,33 +51647,33 @@ function everySkillDirectory(projectPath, harnesses) {
 function removeSkill(directories, projectPath) {
   const removed = [];
   for (const directory of directories) {
-    if (existsSync12(directory)) {
+    if (existsSync13(directory)) {
       rmSync6(directory, { recursive: true, force: true });
-      pruneEmpty(dirname6(directory), projectPath);
+      pruneEmpty(dirname7(directory), projectPath);
       removed.push(directory);
     }
   }
   return removed;
 }
 function pruneEmpty(directory, projectPath) {
-  const shared = join12(projectPath, ".agents");
+  const shared = join13(projectPath, ".agents");
   let path = directory;
-  while (path !== projectPath && (basename4(path) === "skills" || path === shared)) {
-    if (readdirSync7(path).length > 0) {
+  while (path !== projectPath && (basename5(path) === "skills" || path === shared)) {
+    if (readdirSync8(path).length > 0) {
       return;
     }
     rmSync6(path, { recursive: true, force: true });
-    path = dirname6(path);
+    path = dirname7(path);
   }
 }
 function writeSkill(directories, version) {
   const files = skillFiles(version);
   return directories.map((directory) => {
-    const replaced = existsSync12(directory);
+    const replaced = existsSync13(directory);
     rmSync6(directory, { recursive: true, force: true });
     for (const [name, contents] of files) {
-      const path = join12(directory, name);
-      mkdirSync5(dirname6(path), { recursive: true });
+      const path = join13(directory, name);
+      mkdirSync5(dirname7(path), { recursive: true });
       writeFileSync7(path, contents, "utf8");
     }
     return { path: directory, replaced };
@@ -51341,18 +51681,18 @@ function writeSkill(directories, version) {
 }
 
 // src/version.ts
-import { readFileSync as readFileSync11 } from "node:fs";
-import { dirname as dirname7, join as join13 } from "node:path";
+import { readFileSync as readFileSync12 } from "node:fs";
+import { dirname as dirname8, join as join14 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function getLocalVersion() {
-  const currentDirectory = dirname7(fileURLToPath2(import.meta.url));
+  const currentDirectory = dirname8(fileURLToPath2(import.meta.url));
   const packageCandidates = [
-    join13(currentDirectory, "..", "package.json"),
-    join13(currentDirectory, "..", "..", "package.json")
+    join14(currentDirectory, "..", "package.json"),
+    join14(currentDirectory, "..", "..", "package.json")
   ];
   for (const packagePath of packageCandidates) {
     try {
-      const value = JSON.parse(readFileSync11(packagePath, "utf-8"));
+      const value = JSON.parse(readFileSync12(packagePath, "utf-8"));
       if (typeof value === "object" && value !== null && "name" in value && value.name === "gdharness" && "version" in value && typeof value.version === "string") {
         return value.version;
       }
@@ -51370,7 +51710,7 @@ class UsageError extends Refusal {
 function projectArgument(at) {
   const named = args.slice(at).find((value) => !value.startsWith("--"));
   const projectPath = resolve8(named ?? ".");
-  if (!existsSync21(join28(projectPath, "project.godot"))) {
+  if (!existsSync22(join29(projectPath, "project.godot"))) {
     throw new UsageError(`Not a Godot project: ${projectPath} holds no project.godot.`);
   }
   return projectPath;
@@ -51415,7 +51755,7 @@ async function registerRuntime(godot, projectPath) {
     return;
   }
   console.log(`${RUNTIME_AUTOLOAD.name} autoload left at ${named}, which this project registers itself`);
-  if (!existsSync21(join28(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
+  if (!existsSync22(join29(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
     console.log(`  that file is not in this project, so it boots with a missing script: restore it, or point the entry at res://${RUNTIME_AUTOLOAD.path}`);
   }
 }
@@ -51547,7 +51887,7 @@ async function setup() {
       console.log("no harness configured; name one yourself, and gdharness harnesses lists them all");
     }
     if (!args.includes("--no-skill")) {
-      const directories = skillDirectories(chosen.harnesses, projectPath, existsSync21);
+      const directories = skillDirectories(chosen.harnesses, projectPath, existsSync22);
       for (const written of writeSkill(directories, getLocalVersion())) {
         console.log(`skill: ${written.replaced ? "replaced" : "written"} ${written.path}`);
       }
@@ -51661,7 +52001,7 @@ async function upgrade() {
       moved.push(took.from);
     }
   }
-  for (const written of writeSkill(skillDirectories(already, projectPath, existsSync21), version)) {
+  for (const written of writeSkill(skillDirectories(already, projectPath, existsSync22), version)) {
     console.log(`skill: ${written.replaced ? "replaced" : "written"} ${written.path}`);
   }
   console.log(`