gdharness 1.2.27 → 1.2.28

package/build/cli.js

@@ -8198,24 +8198,106 @@ var init_engine_run = __esm(() => {
   init_game_log();
 });
 
+// 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 statSync3, 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, ""));
+  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 +8317,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 +8338,7 @@ function sweepAbandonedScratch(directory = tmpdir2()) {
       continue;
     }
     try {
-      remove(join6(directory, entry));
+      remove(join7(directory, entry));
     } catch {}
   }
 }
@@ -8294,7 +8376,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 +8423,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 +8479,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 +8504,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 +8512,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 +8536,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 +8556,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 +8632,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 +8649,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 +8679,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 +8848,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 +8919,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 +9704,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 statSync4 } from "node:fs";
+import { join as join10, posix } from "node:path";
 function isToolScript(source) {
   return TOOL.test(codeOf(source));
 }
@@ -9637,18 +9721,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 +9754,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,7 +10025,7 @@ 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;
   } catch {
@@ -9955,14 +10039,14 @@ function declaredSince(projectPath, paths, names, since) {
       return false;
     }
     try {
-      return statSync4(join9(projectPath, path.slice("res://".length))).mtimeMs > since;
+      return statSync4(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 +10071,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 +10080,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 +10091,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 +10120,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 +10141,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 +10171,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 +10185,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 +10201,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 +10215,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 +10238,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 +10254,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 +10341,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 +10537,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 +10546,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
@@ -10607,16 +10691,16 @@ 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,
   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 +10711,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()) {
         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 +10760,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 +10847,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 };
@@ -10805,10 +10889,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 +10901,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 +10917,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`);
       }
@@ -12241,12 +12325,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 path of the node that made the element; an element a node made as a part of itself has part_of instead, and part: announcement marks the text a window speaks announcements 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 no control focused, the engine reports the first node under the root, GdharnessRuntime, as 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: []
         }
       },
@@ -34422,10 +34506,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 statSync6, 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 +34517,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 +34561,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" };
   }
@@ -34543,7 +34627,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,23 +34670,23 @@ 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 });
@@ -34622,7 +34706,7 @@ function announcedIn(directory) {
       }
       wentAway(file, pid);
       try {
-        unlinkSync(file);
+        unlinkSync2(file);
       } catch {}
       verdicts.delete(file);
       continue;
@@ -34630,16 +34714,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 +34739,7 @@ async function announcementEnded(pid, directories = runtimeDirectories()) {
   wentAway(first, pid);
   for (const file of files) {
     try {
-      unlinkSync(file);
+      unlinkSync2(file);
     } catch {}
     verdicts.delete(file);
   }
@@ -34666,7 +34750,7 @@ function sweepErrorReport(path, pid, now = Date.now()) {
   }
   try {
     if (now - statSync6(path).mtimeMs >= ERROR_REPORT_KEEP_MS) {
-      unlinkSync(path);
+      unlinkSync2(path);
     }
   } catch {}
 }
@@ -34940,14 +35024,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 +35047,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 +35073,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 +35093,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 +35102,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 +35112,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,7 +35127,7 @@ 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();
@@ -35051,14 +35135,14 @@ var init_breakpoint_note = __esm(() => {
 });
 
 // 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, writeFileSync as writeFileSync10 } 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;
@@ -35075,7 +35159,7 @@ function readClassNote(projectPath) {
 function writeClassNote(projectPath, note) {
   try {
     const path = classNotePath(projectPath);
-    mkdirSync8(dirname11(path), { recursive: true });
+    mkdirSync8(dirname12(path), { recursive: true });
     writeFileSync10(path, `${JSON.stringify(note, null, 2)}
 `, "utf8");
   } catch {}
@@ -35083,16 +35167,16 @@ function writeClassNote(projectPath, note) {
 var init_class_note = () => {};
 
 // 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,26 +35197,26 @@ 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 rmSync8, 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"));
+    const run = JSON.parse(readFileSync18(path, "utf8"));
     rmSync8(path, { force: true });
     return typeof run.cutAt === "string" && Array.isArray(run.paths) && run.paths.every((path) => typeof path === "string") ? run : null;
   } catch {
@@ -35948,25 +36032,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,
   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,7 +36061,7 @@ function readEditorLogNote(projectPath) {
 function clearEditorLog(projectPath) {
   try {
     const path = editorLogPath(projectPath);
-    mkdirSync10(dirname13(path), { recursive: true });
+    mkdirSync10(dirname14(path), { recursive: true });
     rmSync9(path, { force: true });
     rmSync9(editorLogNotePath(projectPath), { force: true });
   } catch {}
@@ -35985,7 +36069,7 @@ function clearEditorLog(projectPath) {
 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 +36091,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;
@@ -36065,7 +36149,7 @@ function foldProgress(text) {
 function theFirstOf(path) {
   const whole = statSync7(path).size;
   if (whole <= MOST_CONSOLE_BYTES) {
-    return { text: readFileSync18(path, "utf8") };
+    return { text: readFileSync19(path, "utf8") };
   }
   const handle = openSync(path, "r");
   try {
@@ -40273,19 +40357,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 renameSync2, statSync as statSync8 } 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 });
+    mkdirSync11(dirname15(path), { recursive: true });
     if ((statSync8(path, { throwIfNoEntry: false })?.size ?? 0) > LIFECYCLE_LOG_LIMIT) {
       try {
-        renameSync(path, `${path}.1`);
+        renameSync2(path, `${path}.1`);
       } catch {}
     }
     const line = {
@@ -40320,10 +40404,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 +40569,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 +41070,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);
@@ -41426,8 +41510,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 renameSync3, unlinkSync as unlinkSync3, writeFileSync as writeFileSync13 } from "node:fs";
+import { dirname as dirname17, posix as posix2 } from "node:path";
 
 class Script {
   path;
@@ -42128,26 +42212,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);
+      renameSync3(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`)) {
+          renameSync3(`${rewrite.absolute}.uid`, `${rewrite.writeTo}.uid`);
           movedUid = true;
         }
       }
@@ -42158,9 +42242,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`);
+            renameSync3(`${rewrite.writeTo}.uid`, `${rewrite.absolute}.uid`);
           }
         }
       } catch {}
@@ -42192,8 +42276,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 rmSync10, 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 +42290,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 +42343,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 +42519,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 +42718,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 });
+    rmSync10(join24(directory, old), { force: true });
   }
   return path;
 }
@@ -42682,15 +42766,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 rmSync11, 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 +42783,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;
     }
@@ -42724,7 +42808,7 @@ var init_restart_note = __esm(() => {
 });
 
 // src/whole-file.ts
-import { renameSync as renameSync3, rmSync as rmSync12, writeFileSync as writeFileSync16 } from "node:fs";
+import { renameSync as renameSync4, rmSync as rmSync12, writeFileSync as writeFileSync16 } from "node:fs";
 function writeWhole(path, text) {
   const partial = `${path}.${process.pid}.partial`;
   try {
@@ -42735,7 +42819,7 @@ function writeWhole(path, text) {
   const until = Date.now() + HELD_FILE_MS;
   for (;; ) {
     try {
-      renameSync3(partial, path);
+      renameSync4(partial, path);
       return true;
     } catch (error) {
       const code = error.code ?? "";
@@ -42757,24 +42841,24 @@ var init_whole_file = __esm(() => {
 // 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 { mkdirSync as mkdirSync15, openSync as openSync2, readdirSync as readdirSync11, readFileSync as readFileSync22, realpathSync as realpathSync6, rmSync as rmSync13, statSync as statSync9 } from "node:fs";
+import { basename as basename7, dirname as dirname20, join as join26, resolve as resolve7 } from "node:path";
 import { promisify as promisify4 } from "node:util";
 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 +42869,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 +42882,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 +42897,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 +42918,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 +42928,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 +42952,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 +42964,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 +42982,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,7 +43035,7 @@ 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();
@@ -43057,7 +43141,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 +43180,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] : []]) {
@@ -43121,7 +43205,7 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
   ]));
   let entries;
   try {
-    entries = readdirSync10(directory);
+    entries = readdirSync11(directory);
   } catch {
     return;
   }
@@ -43130,7 +43214,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;
     }
@@ -43151,7 +43235,7 @@ var init_run_record = __esm(() => {
 });
 
 // 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 +43288,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 +43333,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;
@@ -43430,17 +43514,17 @@ import {
   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
 } 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";
@@ -43471,22 +43555,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.`;
   }
@@ -43982,6 +44066,7 @@ function notRunNote(notRun, failFast) {
 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 +44075,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 +44116,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 +44352,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 +44376,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 +44526,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 +44541,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 "";
   }
@@ -44548,17 +44637,17 @@ function isDirectory(path) {
   }
 }
 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 +44655,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 +44663,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 +44688,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 +44713,7 @@ class GodotServer {
   launchedDropped = null;
   closedHere = null;
   inFlight = new Map;
+  callsOnGames = new Set;
   callsTaken = 0;
   clientNoted = null;
   parentCommand = null;
@@ -44855,14 +44945,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 +45093,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();
@@ -45561,8 +45651,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 +45698,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 +46282,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),
@@ -46248,18 +46338,18 @@ class GodotServer {
     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 +46357,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) ? statSync10(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 +46425,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 +46519,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({
@@ -46699,11 +46793,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;
       }
@@ -46768,11 +46862,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;
     }
@@ -46920,7 +47014,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 +47284,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 +47549,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),
@@ -47613,7 +47708,7 @@ class GodotServer {
   }
   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,
@@ -47892,7 +47987,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;
@@ -48572,7 +48667,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 +48955,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
       }));
@@ -49425,7 +49520,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");
@@ -49753,7 +49848,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;
@@ -49838,12 +49933,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 +49962,8 @@ ${staleNote}`);
           waitedMs: timeoutMs,
           note: `${reply.message} ${longerWaitNote(asked.tool, asked.op, timeoutMs)}`,
           ...answeredBy,
-          ...stale
+          ...stale,
+          ...alongside()
         });
       }
       if (!reply.ok) {
@@ -49862,7 +49971,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 +49988,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 +50102,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, run4, __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 +50132,7 @@ var init_server = __esm(() => {
   init_junit();
   init_keeper_channel();
   init_launch();
+  init_library_copies();
   init_lifecycle_log();
   init_lsp_client();
   init_outside();
@@ -50045,7 +50159,7 @@ var init_server = __esm(() => {
   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,8 +50218,8 @@ 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";
@@ -51070,10 +51184,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 +51393,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 +51421,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 +51455,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 +51484,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 +51529,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 +51661,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 +51775,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(`