gdharness 1.2.27 → 1.2.28

package/build/index.js

@@ -3363,17 +3363,17 @@ import {
   closeSync as closeSync2,
   constants,
   copyFileSync,
-  existsSync as existsSync17,
+  existsSync as existsSync18,
   fstatSync,
   mkdirSync as mkdirSync14,
   openSync as openSync3,
-  readdirSync as readdirSync9,
-  readFileSync as readFileSync21,
+  readdirSync as readdirSync10,
+  readFileSync as readFileSync22,
   readSync as readSync2,
   rmdirSync as rmdirSync2,
   statSync as statSync9
 } from "node:fs";
-import { basename as basename5, dirname as dirname16, extname as extname3, isAbsolute as isAbsolute3, join as join23, normalize as normalize2, relative as relative4 } from "node:path";
+import { basename as basename6, dirname as dirname17, extname as extname3, isAbsolute as isAbsolute4, join as join24, normalize as normalize2, relative as relative4 } from "node:path";
 import { setTimeout as delay4 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 import { promisify as promisify5 } from "node:util";
@@ -29517,33 +29517,114 @@ class GodotLocator {
 }
 
 // src/headless.ts
-import { existsSync as existsSync11, readFileSync as readFileSync13, realpathSync as realpathSync2, writeFileSync as writeFileSync9 } from "node:fs";
-import { dirname as dirname8, join as join14 } from "node:path";
+import { existsSync as existsSync12, readFileSync as readFileSync14, realpathSync as realpathSync2, writeFileSync as writeFileSync9 } from "node:fs";
+import { dirname as dirname9, join as join15 } from "node:path";
+
+// src/library-copies.ts
+import { existsSync as existsSync9, readdirSync as readdirSync4, readFileSync as readFileSync12, renameSync, unlinkSync as unlinkSync2 } from "node:fs";
+import { basename as basename2, dirname as dirname8, isAbsolute as isAbsolute3, join as join12 } 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 = dirname8(library);
+    const copy = `~${basename2(library)}`;
+    if (existsSync9(join12(folder, copy))) {
+      const aside = join12(folder, `${copy}.aside-${process.pid}-${Date.now()}`);
+      try {
+        renameSync(join12(folder, copy), aside);
+        setAside.push(aside);
+      } catch {}
+    }
+    let names;
+    try {
+      names = readdirSync4(folder);
+    } catch {
+      continue;
+    }
+    for (const name of names) {
+      if (name.length > copy.length && name.toLowerCase().startsWith(copy.toLowerCase())) {
+        try {
+          unlinkSync2(join12(folder, name));
+          swept.push(join12(folder, name));
+        } catch {}
+      }
+    }
+  }
+  return { setAside, swept };
+}
+function windowsLibraries(projectPath) {
+  const listed = readOrNull(join12(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, dirname8(manifest), named);
+      if (library !== null) {
+        libraries.add(library);
+      }
+    }
+  }
+  return [...libraries];
+}
+function resolveResource(projectPath, relativeTo, path) {
+  if (path === "") {
+    return null;
+  }
+  if (path.startsWith("res://")) {
+    return join12(projectPath, path.slice("res://".length));
+  }
+  return isAbsolute3(path) ? path : join12(relativeTo, path);
+}
+function readOrNull(path) {
+  try {
+    return readFileSync12(path, "utf8");
+  } catch {
+    return null;
+  }
+}
 
 // src/reimport.ts
 import { createHash as createHash2 } from "node:crypto";
-import { existsSync as existsSync9, readFileSync as readFileSync12, rmSync as rmSync5, statSync as statSync5, utimesSync, writeFileSync as writeFileSync8 } from "node:fs";
-import { basename as basename2, join as join12 } from "node:path";
+import { existsSync as existsSync10, readFileSync as readFileSync13, rmSync as rmSync5, statSync as statSync5, utimesSync, writeFileSync as writeFileSync8 } from "node:fs";
+import { basename as basename3, join as join13 } from "node:path";
 function forceNextImport(projectPath, resourcePath) {
   const relative = resourcePath.replace(/^res:\/\//, "");
-  const sidecar = join12(projectPath, `${relative}.import`);
-  if (!existsSync9(sidecar)) {
+  const sidecar = join13(projectPath, `${relative}.import`);
+  if (!existsSync10(sidecar)) {
     return;
   }
   const { atime, mtimeMs } = statSync5(sidecar);
-  writeFileSync8(sidecar, readFileSync12(sidecar, "utf8").replace(/^valid=false\r?\n/m, ""));
+  writeFileSync8(sidecar, readFileSync13(sidecar, "utf8").replace(/^valid=false\r?\n/m, ""));
   utimesSync(sidecar, atime, new Date(mtimeMs + 2000));
   rmSync5(importRecord(projectPath, resourcePath), { force: true });
 }
 function importRecord(projectPath, resourcePath) {
   const digest = createHash2("md5").update(resourcePath).digest("hex");
-  return join12(projectPath, ".godot", "imported", `${basename2(resourcePath)}-${digest}.md5`);
+  return join13(projectPath, ".godot", "imported", `${basename3(resourcePath)}-${digest}.md5`);
 }
 
 // src/scratch.ts
-import { existsSync as existsSync10, mkdtempSync, readdirSync as readdirSync4, rmSync as rmSync6 } from "node:fs";
+import { existsSync as existsSync11, mkdtempSync, readdirSync as readdirSync5, rmSync as rmSync6 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 import process7 from "node:process";
 var SWEPT = { recursive: true, force: true };
 var AGAIN_AFTER_MS = [250, 500, 1000, 2000, 4000, 8000, 16000];
@@ -29558,12 +29639,12 @@ var KINDS = [
   "tests"
 ];
 function scratchDirectory(kind) {
-  return mkdtempSync(join13(tmpdir4(), `gdharness-${kind}-${process7.pid}-`));
+  return mkdtempSync(join14(tmpdir4(), `gdharness-${kind}-${process7.pid}-`));
 }
 function sweepAbandonedScratch(directory = tmpdir4()) {
   let entries;
   try {
-    entries = readdirSync4(directory);
+    entries = readdirSync5(directory);
   } catch {
     return;
   }
@@ -29574,7 +29655,7 @@ function sweepAbandonedScratch(directory = tmpdir4()) {
       continue;
     }
     try {
-      remove(join13(directory, entry));
+      remove(join14(directory, entry));
     } catch {}
   }
 }
@@ -29612,7 +29693,7 @@ function tryAgain(path, attempt) {
     lastTryOnExit();
   }
   const after = AGAIN_AFTER_MS[attempt];
-  if (after === undefined || !existsSync10(path)) {
+  if (after === undefined || !existsSync11(path)) {
     waiting.delete(path);
     if (after === undefined) {
       atExit.add(path);
@@ -29703,7 +29784,7 @@ function refusalsIn(log) {
 }
 function scriptFault(problems, script) {
   const spelled = (path) => `(${path.replaceAll("\\", "/").toLowerCase()}/`;
-  const directories = [...new Set([spelled(dirname8(script)), spelled(resolvedOr(dirname8(script)))])];
+  const directories = [...new Set([spelled(dirname9(script)), spelled(resolvedOr(dirname9(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));
@@ -29728,7 +29809,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;
@@ -29736,6 +29817,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();
@@ -29759,7 +29841,7 @@ async function importOnce(godotPath, projectPath) {
     ran = await runEngine(godotPath, [
       "--headless",
       "--log-file",
-      join14(logDir, "engine.log"),
+      join15(logDir, "engine.log"),
       "--path",
       projectPath,
       "--import"
@@ -29779,13 +29861,13 @@ async function importOnce(godotPath, projectPath) {
 }
 async function runOperation(engine, operation, params, projectPath) {
   const paramsDir = scratchDirectory("params");
-  const paramsFile = join14(paramsDir, `${operation}.json`);
-  const answerFile = join14(paramsDir, "answer.json");
+  const paramsFile = join15(paramsDir, `${operation}.json`);
+  const answerFile = join15(paramsDir, "answer.json");
   writeFileSync9(paramsFile, JSON.stringify(snakeCased(params)), "utf8");
   const args = [
     "--headless",
     "--log-file",
-    join14(paramsDir, "engine.log"),
+    join15(paramsDir, "engine.log"),
     "--path",
     projectPath,
     "--script",
@@ -29855,10 +29937,10 @@ async function runOperation(engine, operation, params, projectPath) {
   };
 }
 function answerIn(file) {
-  if (!existsSync11(file)) {
+  if (!existsSync12(file)) {
     return { kind: "none" };
   }
-  const text = readFileSync13(file, "utf8");
+  const text = readFileSync14(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)}` };
@@ -30431,20 +30513,20 @@ function askTheKeeper(address, line, withinMs) {
 }
 
 // src/lifecycle-log.ts
-import { appendFileSync, mkdirSync as mkdirSync8, renameSync, statSync as statSync6 } from "node:fs";
-import { dirname as dirname9, join as join15 } from "node:path";
+import { appendFileSync, mkdirSync as mkdirSync8, renameSync as renameSync2, statSync as statSync6 } from "node:fs";
+import { dirname as dirname10, join as join16 } from "node:path";
 import process8 from "node:process";
 function lifecycleLogPath() {
-  return join15(runtimeDirectory(), "servers.log");
+  return join16(runtimeDirectory(), "servers.log");
 }
 var LIFECYCLE_LOG_LIMIT = 1e6;
 function writeLifecycle(event, fields = {}) {
   const path = lifecycleLogPath();
   try {
-    mkdirSync8(dirname9(path), { recursive: true });
+    mkdirSync8(dirname10(path), { recursive: true });
     if ((statSync6(path, { throwIfNoEntry: false })?.size ?? 0) > LIFECYCLE_LOG_LIMIT) {
       try {
-        renameSync(path, `${path}.1`);
+        renameSync2(path, `${path}.1`);
       } catch {}
     }
     const line = {
@@ -30474,10 +30556,10 @@ function callsInFlight(calls, now = Date.now()) {
 }
 
 // src/lsp_client.ts
-import { existsSync as existsSync12, realpathSync as realpathSync3 } from "node:fs";
+import { existsSync as existsSync13, realpathSync as realpathSync3 } from "node:fs";
 import { readFile, realpath } from "node:fs/promises";
 import { createConnection as createConnection3 } from "node:net";
-import { dirname as dirname10, join as join16, resolve as resolve3 } from "node:path";
+import { dirname as dirname11, join as join17, resolve as resolve3 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
 var DEFAULT_LSP_PORT = 6005;
@@ -30675,7 +30757,7 @@ class GodotLSPClient {
     if (this.initialized) {
       return;
     }
-    const rootPath = this.rootPath ?? dirname10(resolve3(filePath));
+    const rootPath = this.rootPath ?? dirname11(resolve3(filePath));
     await this.initialize(rootPath);
   }
   async sendRequest(method, params, timeoutMs = this.timeouts.requestMs) {
@@ -31233,7 +31315,7 @@ async function resolveLSPPaths(projectPathValue, scriptPathValue) {
   } catch {
     throw new ArgumentRefusal(`Project path does not exist: ${requestedProjectPath}`);
   }
-  if (!existsSync12(join16(projectPath, "project.godot"))) {
+  if (!existsSync13(join17(projectPath, "project.godot"))) {
     throw new ArgumentRefusal(`Not a Godot project: ${projectPath}. Point projectPath at the directory holding project.godot.`);
   }
   const contained = resolveWithinProject(projectPath, scriptPathValue);
@@ -31440,8 +31522,8 @@ function secondsFromClock(printed) {
 }
 
 // src/project-scan.ts
-import { existsSync as existsSync13, readdirSync as readdirSync5, readFileSync as readFileSync14 } from "node:fs";
-import { extname, join as join17 } from "node:path";
+import { existsSync as existsSync14, readdirSync as readdirSync6, readFileSync as readFileSync15 } from "node:fs";
+import { extname, join as join18 } from "node:path";
 var SKIPPED = new Set(["node_modules"]);
 function skipped(name) {
   return name.startsWith(".") || SKIPPED.has(name);
@@ -31451,10 +31533,10 @@ function steppedOver(directory) {
   return gdignored(directory) || installedByUs(directory);
 }
 function gdignored(directory) {
-  return existsSync13(join17(directory, ".gdignore"));
+  return existsSync14(join18(directory, ".gdignore"));
 }
 function installedByUs(directory) {
-  return existsSync13(join17(directory, VERSION_MARKER));
+  return existsSync14(join18(directory, VERSION_MARKER));
 }
 var SCENE_EXTENSIONS = new Set(["tscn", "scn"]);
 var ASSET_EXTENSIONS = new Set([
@@ -31493,12 +31575,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(join17(directory, entry.name));
+        visit(join18(directory, entry.name));
       } else if (entry.isFile()) {
         const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
         if (SCENE_EXTENSIONS.has(extension)) {
@@ -31522,13 +31604,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(join17(directory, entry.name), spelled);
+        visit(join18(directory, entry.name), spelled);
       } else if (entry.isFile() && extensions.includes(extname(entry.name).toLowerCase())) {
         found.push(spelled);
       }
@@ -31544,20 +31626,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(join17(directory, entry.name), spelled);
+        visit(join18(directory, entry.name), spelled);
         continue;
       }
       if (!entry.isFile()) {
         continue;
       }
       const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
-      if (CARRIES_A_UID.has(extension) && !existsSync13(join17(directory, `${entry.name}.uid`))) {
+      if (CARRIES_A_UID.has(extension) && !existsSync14(join18(directory, `${entry.name}.uid`))) {
         found.push(spelled);
       }
     }
@@ -31585,11 +31667,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 = join17(directory, entry.name);
+      const absolute = join18(directory, entry.name);
       const spelled = `${prefix}${entry.name}`;
       if (entry.isDirectory()) {
         visit(absolute, `${spelled}/`);
@@ -31599,7 +31681,7 @@ function projectTexts(projectPath) {
       if (!entry.isFile() || BINARY_EXTENSIONS.has(extension)) {
         continue;
       }
-      const bytes = readFileSync14(absolute);
+      const bytes = readFileSync15(absolute);
       if (!isBinary(bytes)) {
         found.push({ path: `res://${spelled}`, absolute, text: bytes.toString("utf8") });
       }
@@ -31615,11 +31697,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 = join17(directory, entry.name);
+      const absolute = join18(directory, entry.name);
       const spelled = `${prefix}${entry.name}`;
       if (entry.isDirectory()) {
         visit(absolute, `${spelled}/`, under);
@@ -31629,7 +31711,7 @@ function ignoredTexts(projectPath) {
       if (!under || !entry.isFile() || BINARY_EXTENSIONS.has(extension) || entry.name === ".gdignore") {
         continue;
       }
-      const bytes = readFileSync14(absolute);
+      const bytes = readFileSync15(absolute);
       if (!isBinary(bytes)) {
         found.push({ path: `res://${spelled}`, absolute, text: bytes.toString("utf8") });
       }
@@ -31652,14 +31734,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 = join17(directory, entry.name);
+      const entryPath = join18(directory, entry.name);
       if (entry.isDirectory()) {
         visit(entryPath);
         continue;
@@ -31668,7 +31750,7 @@ function searchProject(projectPath, options) {
       if (!entry.isFile() || extensions !== null && !extensions.has(extension)) {
         continue;
       }
-      const bytes = readFileSync14(entryPath);
+      const bytes = readFileSync15(entryPath);
       if (extensions === null && isBinary(bytes)) {
         continue;
       }
@@ -31830,8 +31912,8 @@ function setupPromptHandlers(server) {
 }
 
 // src/rename.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync9, readFileSync as readFileSync15, renameSync as renameSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync10 } from "node:fs";
-import { dirname as dirname11, posix as posix2 } from "node:path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync9, readFileSync as readFileSync16, renameSync as renameSync3, unlinkSync as unlinkSync3, writeFileSync as writeFileSync10 } from "node:fs";
+import { dirname as dirname12, posix as posix2 } from "node:path";
 class Script {
   path;
   text;
@@ -32553,26 +32635,26 @@ function rewritesOf(plan, texts, move) {
 }
 function applyRewrites(rewrites) {
   for (const rewrite of rewrites) {
-    const now = readFileSync15(rewrite.absolute, "utf8");
+    const now = readFileSync16(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 && existsSync14(rewrite.writeTo)) {
+    if (rewrite.writeTo !== rewrite.absolute && existsSync15(rewrite.writeTo)) {
       throw new Error(`${rewrite.writeTo} already exists; nothing was written`);
     }
   }
   const done = [];
   try {
     for (const rewrite of rewrites) {
-      mkdirSync9(dirname11(rewrite.writeTo), { recursive: true });
+      mkdirSync9(dirname12(rewrite.writeTo), { recursive: true });
       const staging = `${rewrite.writeTo}.gdharness-rename`;
       writeFileSync10(staging, rewrite.after, "utf8");
-      renameSync2(staging, rewrite.writeTo);
+      renameSync3(staging, rewrite.writeTo);
       let movedUid = false;
       if (rewrite.writeTo !== rewrite.absolute) {
-        unlinkSync2(rewrite.absolute);
-        if (existsSync14(`${rewrite.absolute}.uid`)) {
-          renameSync2(`${rewrite.absolute}.uid`, `${rewrite.writeTo}.uid`);
+        unlinkSync3(rewrite.absolute);
+        if (existsSync15(`${rewrite.absolute}.uid`)) {
+          renameSync3(`${rewrite.absolute}.uid`, `${rewrite.writeTo}.uid`);
           movedUid = true;
         }
       }
@@ -32583,9 +32665,9 @@ function applyRewrites(rewrites) {
       try {
         writeFileSync10(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 {}
@@ -32595,11 +32677,11 @@ function applyRewrites(rewrites) {
 }
 
 // src/rename-symbol.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync10, readdirSync as readdirSync6, realpathSync as realpathSync5, rmSync as rmSync7, writeFileSync as writeFileSync11 } from "node:fs";
-import { basename as basename3, dirname as dirname12, join as join18, relative as relative3, resolve as resolve5 } from "node:path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync10, readdirSync as readdirSync7, realpathSync as realpathSync5, rmSync as rmSync7, writeFileSync as writeFileSync11 } from "node:fs";
+import { basename as basename4, dirname as dirname13, join as join19, relative as relative3, resolve as resolve5 } from "node:path";
 
 // src/resources.ts
-import { readFileSync as readFileSync16, realpathSync as realpathSync4 } from "node:fs";
+import { readFileSync as readFileSync17, realpathSync as realpathSync4 } from "node:fs";
 import { extname as extname2, resolve as resolve4 } from "node:path";
 var STATIC_RESOURCES = [
   {
@@ -32830,7 +32912,7 @@ function readResourceText(uri, getProjectPath) {
   const parsedUri = parseGodotUri(uri);
   if (parsedUri.kind === "project-info") {
     const projectFilePath = resolveProjectFile(projectPath, "project.godot");
-    const rawProject = readFileSync16(projectFilePath, "utf-8");
+    const rawProject = readFileSync17(projectFilePath, "utf-8");
     const parsedProject = parseProjectGodot(rawProject);
     return {
       mimeType: "application/json",
@@ -32839,7 +32921,7 @@ function readResourceText(uri, getProjectPath) {
   }
   const filePath = resolveProjectFile(projectPath, parsedUri.resourcePath);
   ensureAllowedExtension(parsedUri.kind, filePath);
-  const text = readFileSync16(filePath, "utf-8");
+  const text = readFileSync17(filePath, "utf-8");
   return {
     mimeType: parsedUri.kind === "script" ? "text/x-gdscript" : "text/plain",
     text
@@ -32904,13 +32986,13 @@ function onDiskSpelling(path) {
   let at = resolve5(path);
   for (;; ) {
     try {
-      return join18(realpathSync5.native(at), ...missing.reverse());
+      return join19(realpathSync5.native(at), ...missing.reverse());
     } catch {
-      const parent = dirname12(at);
+      const parent = dirname13(at);
       if (parent === at) {
         return resolve5(path);
       }
-      missing.push(basename3(at));
+      missing.push(basename4(at));
       at = parent;
     }
   }
@@ -32957,7 +33039,7 @@ async function renameSymbol(request, services) {
         reason: `newScriptPath must be a .gd path inside the project, and ${request.newScriptPath} is not.`
       };
     }
-    if (existsSync15(request.newScriptPath)) {
+    if (existsSync16(request.newScriptPath)) {
       return { ok: false, reason: `${moveTo} already exists, so the script cannot be moved there.` };
     }
   }
@@ -33133,7 +33215,7 @@ async function renameSymbol(request, services) {
       scripts,
       from: declaringPath,
       to: moveTo,
-      exists: (path) => existsSync15(`${projectPath}/${path.slice("res://".length)}`)
+      exists: (path) => existsSync16(`${projectPath}/${path.slice("res://".length)}`)
     }, plan);
   }
   plan = mentionIgnored(plan, ignoredTexts(projectPath), symbol, moveTo === null ? null : declaringPath);
@@ -33334,15 +33416,15 @@ ${mention.kind}`;
 var LEFT_ALONE_ANSWER_LINES = 300;
 var detailWrites = 0;
 function writeLeftAloneDetail(projectPath, symbol, detail) {
-  const directory = join18(projectPath, ".godot", "gdharness-renames");
+  const directory = join19(projectPath, ".godot", "gdharness-renames");
   mkdirSync10(directory, { recursive: true });
   detailWrites += 1;
-  const path = join18(directory, `${String(Date.now())}-${String(detailWrites).padStart(6, "0")}-${String(process.pid)}-${symbol}.json`);
+  const path = join19(directory, `${String(Date.now())}-${String(detailWrites).padStart(6, "0")}-${String(process.pid)}-${symbol}.json`);
   writeFileSync11(path, `${JSON.stringify(detail, null, 2)}
 `, "utf8");
-  const kept = readdirSync6(directory).filter((name) => name.endsWith(".json")).sort().reverse();
+  const kept = readdirSync7(directory).filter((name) => name.endsWith(".json")).sort().reverse();
   for (const old of kept.slice(10)) {
-    rmSync7(join18(directory, old), { force: true });
+    rmSync7(join19(directory, old), { force: true });
   }
   return path;
 }
@@ -33365,15 +33447,15 @@ function summaryOf(edits, mentions, rewrites, left) {
 }
 
 // src/restart-note.ts
-import { mkdirSync as mkdirSync11, readFileSync as readFileSync17, rmSync as rmSync8, writeFileSync as writeFileSync12 } from "node:fs";
-import { dirname as dirname13, join as join19 } from "node:path";
+import { mkdirSync as mkdirSync11, readFileSync as readFileSync18, rmSync as rmSync8, writeFileSync as writeFileSync12 } from "node:fs";
+import { dirname as dirname14, join as join20 } from "node:path";
 function restartNotePath(projectPath) {
-  return join19(projectPath, ".godot", "gdharness-restart.json");
+  return join20(projectPath, ".godot", "gdharness-restart.json");
 }
 function noteRestartBegun(note) {
   const path = restartNotePath(note.projectPath);
   try {
-    mkdirSync11(dirname13(path), { recursive: true });
+    mkdirSync11(dirname14(path), { recursive: true });
     writeFileSync12(path, `${JSON.stringify(note, null, 2)}
 `, "utf8");
   } catch (error) {
@@ -33382,7 +33464,7 @@ function noteRestartBegun(note) {
 }
 function restartOwed(projectPath) {
   try {
-    const parsed = JSON.parse(readFileSync17(restartNotePath(projectPath), "utf8"));
+    const parsed = JSON.parse(readFileSync18(restartNotePath(projectPath), "utf8"));
     if (typeof parsed !== "object" || parsed === null) {
       return null;
     }
@@ -33406,12 +33488,12 @@ function restartSettled(projectPath) {
 // src/run-record.ts
 import { execFile as execFile4 } from "node:child_process";
 import { createHash as createHash3 } from "node:crypto";
-import { mkdirSync as mkdirSync12, openSync as openSync2, readdirSync as readdirSync7, readFileSync as readFileSync18, realpathSync as realpathSync6, rmSync as rmSync10, statSync as statSync7 } from "node:fs";
-import { basename as basename4, dirname as dirname14, join as join20, resolve as resolve6 } from "node:path";
+import { mkdirSync as mkdirSync12, openSync as openSync2, readdirSync as readdirSync8, readFileSync as readFileSync19, realpathSync as realpathSync6, rmSync as rmSync10, statSync as statSync7 } from "node:fs";
+import { basename as basename5, dirname as dirname15, join as join21, resolve as resolve6 } from "node:path";
 import { promisify as promisify4 } from "node:util";
 
 // src/whole-file.ts
-import { renameSync as renameSync3, rmSync as rmSync9, writeFileSync as writeFileSync13 } from "node:fs";
+import { renameSync as renameSync4, rmSync as rmSync9, writeFileSync as writeFileSync13 } from "node:fs";
 var HELD_FILE_MS = 1000;
 var HELD_FILE_RETRY_MS = 10;
 var HELD_BY_A_READER = new Set(["EPERM", "EACCES", "EBUSY"]);
@@ -33425,7 +33507,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 ?? "";
@@ -33443,20 +33525,20 @@ function writeWhole(path, text) {
 // src/run-record.ts
 var execFileAsync = promisify4(execFile4);
 function runsDirectory() {
-  return join20(runtimeDirectory(), "runs");
+  return join21(runtimeDirectory(), "runs");
 }
 function realAsFarAsItExists(path) {
   const missing = [];
   let at = path;
   for (;; ) {
     try {
-      return join20(realpathSync6.native(at), ...missing);
+      return join21(realpathSync6.native(at), ...missing);
     } catch {
-      const parent = dirname14(at);
+      const parent = dirname15(at);
       if (parent === at) {
         return path;
       }
-      missing.unshift(basename4(at));
+      missing.unshift(basename5(at));
       at = parent;
     }
   }
@@ -33467,10 +33549,10 @@ function projectKey(projectPath) {
   return createHash3("sha256").update(folded.replaceAll("\\", "/")).digest("hex").slice(0, 16);
 }
 function runRecordPath(projectPath, directory = runtimeDirectory()) {
-  return join20(directory, "runs", `note-${projectKey(projectPath)}.json`);
+  return join21(directory, "runs", `note-${projectKey(projectPath)}.json`);
 }
 function latestRunPath(servedBy, directory = runtimeDirectory()) {
-  return join20(directory, "runs", `latest-${projectKey(servedBy)}.json`);
+  return join21(directory, "runs", `latest-${projectKey(servedBy)}.json`);
 }
 function writeLatestRun(servedBy, latest) {
   try {
@@ -33480,7 +33562,7 @@ function writeLatestRun(servedBy, latest) {
 }
 function readLatestRun(servedBy, directory = runtimeDirectory()) {
   try {
-    const fields = JSON.parse(readFileSync18(latestRunPath(servedBy, directory), "utf8"));
+    const fields = JSON.parse(readFileSync19(latestRunPath(servedBy, directory), "utf8"));
     if (typeof fields !== "object" || fields === null) {
       return null;
     }
@@ -33496,17 +33578,17 @@ function readLatestRun(servedBy, directory = runtimeDirectory()) {
 var SHARED_NOTE = "run.json";
 function openTranscript(startedAt) {
   mkdirSync12(runsDirectory(), { recursive: true });
-  const path = join20(runsDirectory(), `run-${startedAt}.log`);
+  const path = join21(runsDirectory(), `run-${startedAt}.log`);
   return { path, fd: openSync2(path, "a") };
 }
 function profilePath(startedAt) {
-  return join20(runsDirectory(), `run-${startedAt}.profile.json`);
+  return join21(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 join20(directory, "runs", `editor-${projectKey(projectPath)}.json`);
+  return join21(directory, "runs", `editor-${projectKey(projectPath)}.json`);
 }
 function writeEditorRunNote(note) {
   mkdirSync12(runsDirectory(), { recursive: true });
@@ -33517,7 +33599,7 @@ function writeEditorRunNote(note) {
 }
 function readEditorRunNote(projectPath) {
   for (const directory of runtimeDirectories()) {
-    const note = editorNoteAt(editorNotePath(projectPath, directory)) ?? editorNoteAt(join20(directory, "runs", "editor-run.json"));
+    const note = editorNoteAt(editorNotePath(projectPath, directory)) ?? editorNoteAt(join21(directory, "runs", "editor-run.json"));
     if (note !== null && isSameDirectory(note.projectPath, projectPath)) {
       return note;
     }
@@ -33527,7 +33609,7 @@ function readEditorRunNote(projectPath) {
 function editorNoteAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync18(path, "utf8"));
+    parsed = JSON.parse(readFileSync19(path, "utf8"));
   } catch {
     return null;
   }
@@ -33551,7 +33633,7 @@ function readRunRecord(projectPath) {
     if (own !== null) {
       return own;
     }
-    const shared = recordAt(join20(directory, "runs", SHARED_NOTE));
+    const shared = recordAt(join21(directory, "runs", SHARED_NOTE));
     if (shared !== null && shared.projectPath !== "" && isSameDirectory(shared.projectPath, projectPath)) {
       return shared;
     }
@@ -33563,13 +33645,13 @@ function everyRunRecord() {
   for (const directory of runtimeDirectories()) {
     let entries;
     try {
-      entries = readdirSync7(join20(directory, "runs"));
+      entries = readdirSync8(join21(directory, "runs"));
     } catch {
       continue;
     }
     for (const entry of entries) {
       if (entry === SHARED_NOTE || entry.startsWith("note-") && entry.endsWith(".json")) {
-        const record = recordAt(join20(directory, "runs", entry));
+        const record = recordAt(join21(directory, "runs", entry));
         if (record !== null) {
           found.push(record);
         }
@@ -33581,7 +33663,7 @@ function everyRunRecord() {
 function recordAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync18(path, "utf8"));
+    parsed = JSON.parse(readFileSync19(path, "utf8"));
   } catch {
     return null;
   }
@@ -33634,7 +33716,7 @@ async function runningAs(pid) {
     const began = await startedAt(pid, null);
     const when = began === null ? {} : { startedAt: began };
     if (process.platform === "linux") {
-      const raw = readFileSync18(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
+      const raw = readFileSync19(`/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();
@@ -33741,7 +33823,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 : basename4(record.command);
+  const engine = record.command === undefined ? null : basename5(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)) {
@@ -33780,7 +33862,7 @@ function judgeAnnouncedGame(running, projectPath, announcedAt) {
 }
 function clearRunRecord(projectPath) {
   for (const directory of runtimeDirectories()) {
-    const shared = join20(directory, "runs", SHARED_NOTE);
+    const shared = join21(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] : []]) {
@@ -33805,7 +33887,7 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
   ]));
   let entries;
   try {
-    entries = readdirSync7(directory);
+    entries = readdirSync8(directory);
   } catch {
     return;
   }
@@ -33814,7 +33896,7 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
     if (!transcript && !entry.endsWith(".partial")) {
       continue;
     }
-    const path = join20(directory, entry);
+    const path = join21(directory, entry);
     if (kept.has(path) || ageMs(path, now) < keepMs) {
       continue;
     }
@@ -33825,7 +33907,7 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
 }
 
 // src/script-origins.ts
-import { join as join21 } from "node:path";
+import { join as join22 } from "node:path";
 var UNRESOLVED = /Could not resolve class "([A-Za-z_][A-Za-z0-9_]*)", because of a parser error/;
 function unresolvedClassIn(message) {
   return UNRESOLVED.exec(message)?.[1] ?? null;
@@ -33881,7 +33963,7 @@ function checkWithEngine(godotPath, projectPath) {
       const ran = await runEngine(godotPath, [
         "--headless",
         "--log-file",
-        join21(logDir, "engine.log"),
+        join22(logDir, "engine.log"),
         "--path",
         projectPath,
         "--check-only",
@@ -33918,10 +34000,10 @@ function withoutListed(entries, errors) {
 }
 
 // src/script-profile.ts
-import { readFileSync as readFileSync19 } from "node:fs";
+import { readFileSync as readFileSync20 } from "node:fs";
 function readProfileFile(path) {
   try {
-    const parsed = JSON.parse(readFileSync19(path, "utf8"));
+    const parsed = JSON.parse(readFileSync20(path, "utf8"));
     return typeof parsed === "object" && typeof parsed.connected === "boolean" ? parsed : null;
   } catch {
     return null;
@@ -35380,12 +35462,12 @@ var TOOL_SPECS = [
       },
       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: []
       }
     },
@@ -35876,16 +35958,16 @@ import { spawnSync } from "node:child_process";
 import { createHash as createHash4 } from "node:crypto";
 import {
   cpSync,
-  existsSync as existsSync16,
+  existsSync as existsSync17,
   mkdirSync as mkdirSync13,
-  readdirSync as readdirSync8,
-  readFileSync as readFileSync20,
+  readdirSync as readdirSync9,
+  readFileSync as readFileSync21,
   rmdirSync,
   rmSync as rmSync11,
   statSync as statSync8,
   writeFileSync as writeFileSync14
 } from "node:fs";
-import { dirname as dirname15, join as join22 } from "node:path";
+import { dirname as dirname16, join as join23 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 var ADDONS = ["gdharness_editor", "gdharness_runtime", "auto_reload"];
 var EDITOR_PLUGINS = ["gdharness_editor", "auto_reload"];
@@ -35904,25 +35986,25 @@ function runtimeAddonDigest(from = shippedAddonsDirectory()) {
 function addonsDigest(names, from) {
   const hash = createHash4("sha256");
   const walk = (directory, relative) => {
-    for (const name of readdirSync8(directory).sort()) {
+    for (const name of readdirSync9(directory).sort()) {
       if (name === VERSION_MARKER || name === DIGEST_MARKER) {
         continue;
       }
-      const path = join22(directory, name);
+      const path = join23(directory, name);
       const inside = `${relative}/${name}`;
       if (statSync8(path).isDirectory()) {
         walk(path, inside);
       } else {
         hash.update(`${inside}
 `);
-        hash.update(readFileSync20(path));
+        hash.update(readFileSync21(path));
         hash.update(`
 `);
       }
     }
   };
   for (const name of names) {
-    walk(join22(from, name), name);
+    walk(join23(from, name), name);
   }
   return hash.digest("hex");
 }
@@ -35955,22 +36037,22 @@ function installedRuntimeDigest(projectPath) {
   return digestMarker(projectPath, RUNTIME_ADDON);
 }
 function digestMarker(projectPath, addon) {
-  const marker = join22(projectPath, "addons", addon, DIGEST_MARKER);
-  if (!existsSync16(marker)) {
+  const marker = join23(projectPath, "addons", addon, DIGEST_MARKER);
+  if (!existsSync17(marker)) {
     return null;
   }
-  const said = readFileSync20(marker, "utf8").trim();
+  const said = readFileSync21(marker, "utf8").trim();
   return said === "" ? null : said;
 }
 function shippedAddonsDirectory() {
-  return join22(dirname15(fileURLToPath3(import.meta.url)), "godot", "addons");
+  return join23(dirname16(fileURLToPath3(import.meta.url)), "godot", "addons");
 }
 function installedAddonVersion(projectPath) {
-  const marker = join22(projectPath, "addons", ADDONS[0], VERSION_MARKER);
-  if (!existsSync16(marker)) {
+  const marker = join23(projectPath, "addons", ADDONS[0], VERSION_MARKER);
+  if (!existsSync17(marker)) {
     return null;
   }
-  const said = readFileSync20(marker, "utf8").trim();
+  const said = readFileSync21(marker, "utf8").trim();
   return said === "" ? null : said;
 }
 function loaderAmong(projectPath, named) {
@@ -35981,7 +36063,7 @@ function loaderAmong(projectPath, named) {
     }
     let source = null;
     try {
-      source = readFileSync20(join22(projectPath, path), "utf8");
+      source = readFileSync21(join23(projectPath, path), "utf8");
     } catch {}
     if (source?.includes(RUNTIME_AUTOLOAD.path)) {
       return { name: entry, path, exists: true };
@@ -36023,10 +36105,10 @@ function enabledPlugins(settings) {
 function inspectProject(projectPath) {
   const problems = [];
   const addons = ADDONS.map((name) => {
-    const directory = join22(projectPath, "addons", name);
-    const marker = join22(directory, VERSION_MARKER);
-    const installed = existsSync16(directory);
-    const version = existsSync16(marker) ? readFileSync20(marker, "utf8").trim() : null;
+    const directory = join23(projectPath, "addons", name);
+    const marker = join23(directory, VERSION_MARKER);
+    const installed = existsSync17(directory);
+    const version = existsSync17(marker) ? readFileSync21(marker, "utf8").trim() : null;
     const current = version === SERVER_VERSION;
     if (!installed) {
       problems.push(`addons/${name} is not installed; run gdharness setup`);
@@ -36035,7 +36117,7 @@ function inspectProject(projectPath) {
     }
     return { name, installed, version, current };
   });
-  const settings = parseProjectGodot(readFileSync20(join22(projectPath, "project.godot"), "utf8"));
+  const settings = parseProjectGodot(readFileSync21(join23(projectPath, "project.godot"), "utf8"));
   const pluginsEnabled = enabledPlugins(settings);
   for (const name of EDITOR_PLUGINS) {
     if (!pluginsEnabled.includes(name)) {
@@ -36051,7 +36133,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 (!existsSync16(join22(projectPath, path))) {
+    if (!existsSync17(join23(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`);
       }
@@ -36102,7 +36184,7 @@ function argumentShape(schema) {
 var UPDATE_NOTICE_EVERY = 500;
 var FEEDBACK_NOTICE_EVERY = 250;
 var run4 = promisify5(execFile5);
-var __dirname2 = dirname16(fileURLToPath4(import.meta.url));
+var __dirname2 = dirname17(fileURLToPath4(import.meta.url));
 var PARENT_ASKED_AFTER_MS = 5000;
 function editorRestartTimeoutMs() {
   return waitFromEnv("GDHARNESS_EDITOR_RESTART_TIMEOUT_MS", 90000);
@@ -36134,22 +36216,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(dirname16(path));
-  if (!existsSync17(directory)) {
-    return `${named}'s directory ${dirname16(path)} does not exist; ${what} creates no directories.`;
+  const directory = realPathOr(dirname17(path));
+  if (!existsSync18(directory)) {
+    return `${named}'s directory ${dirname17(path)} does not exist; ${what} creates no directories.`;
   }
-  const where = join23(directory, basename5(path));
+  const where = join24(directory, basename6(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) => existsSync17(file));
+  const taken = rule.writes(where).find((file) => existsSync18(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.`;
   }
@@ -36199,6 +36281,7 @@ function captureDetail(payload) {
 function patienceForFrames(frames, atLeast) {
   return Math.max(atLeast, frames / SLOWEST_FRAME_RATE * 1000 + atLeast);
 }
+var 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.";
 function longerWaitNote(tool, op, waitedMs) {
   const spec = TOOL_SPECS.find((one) => one.name === tool);
   if (spec !== undefined && argumentsOf(spec, op).includes("timeoutMs")) {
@@ -36669,6 +36752,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,
@@ -36677,6 +36761,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) {
@@ -36721,7 +36809,7 @@ var EDITOR_FREE_INSTEAD = {
   scene_tree: "runtime_inspect tree reads the nodes of a game that is running, and needs no editor; scene_tree reads a scene file through the editor"
 };
 function editorAddonMissing(projectPath) {
-  if (!existsSync17(join23(projectPath, "project.godot"))) {
+  if (!existsSync18(join24(projectPath, "project.godot"))) {
     return null;
   }
   const report = inspectProject(projectPath);
@@ -37003,7 +37091,7 @@ function profileFrameFunctions(projectPath) {
   let projectGodot = null;
   if (projectPath !== null) {
     try {
-      projectGodot = readFileSync21(join23(projectPath, "project.godot"), "utf8");
+      projectGodot = readFileSync22(join24(projectPath, "project.godot"), "utf8");
     } catch {}
   }
   return frameFunctionsFor(queuedMessagesOf(projectGodot));
@@ -37029,7 +37117,7 @@ function projectSourceOf(projectPath) {
       let source = null;
       if (inside.ok) {
         try {
-          source = readFileSync21(inside.absolutePath, "utf8");
+          source = readFileSync22(inside.absolutePath, "utf8");
         } catch {}
       }
       read.set(script, source);
@@ -37181,7 +37269,7 @@ function foldedEntriesAnswer(log, floor = "warning") {
 var ERROR_ASSERT = "GdUnitGodotErrorAssertImpl.gd";
 function gdUnitFailsOnScriptErrors(projectPath) {
   try {
-    return settingKeys(readFileSync21(join23(projectPath, "project.godot"), "utf8")).get("gdunit4/report/godot/script_error") !== false;
+    return settingKeys(readFileSync22(join24(projectPath, "project.godot"), "utf8")).get("gdunit4/report/godot/script_error") !== false;
   } catch {
     return true;
   }
@@ -37196,13 +37284,13 @@ function uncaughtNote(uncaught) {
 }
 function elsewhereIn(projectPath, asked) {
   const wanted = asked.replace(/^res:\/\//, "").replace(/\/+$/, "");
-  if (wanted === "" || existsSync17(join23(projectPath, wanted))) {
+  if (wanted === "" || existsSync18(join24(projectPath, wanted))) {
     return "";
   }
   const root = (wanted.split("/")[0] ?? "").toLowerCase();
   let near = [];
   try {
-    near = readdirSync9(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 = readdirSync10(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 "";
   }
@@ -37293,17 +37381,17 @@ function isDirectory(path) {
   }
 }
 function scriptsUnder(directory, prefix) {
-  if (existsSync17(join23(directory, ".gdignore"))) {
+  if (existsSync18(join24(directory, ".gdignore"))) {
     return [];
   }
   const found = [];
-  for (const entry of readdirSync9(directory, { withFileTypes: true }).sort((a, b) => a.name < b.name ? -1 : 1)) {
+  for (const entry of readdirSync10(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(join23(directory, entry.name), path));
+      found.push(...scriptsUnder(join24(directory, entry.name), path));
     } else if (entry.isFile() && entry.name.endsWith(".gd")) {
       found.push(path);
     }
@@ -37311,7 +37399,7 @@ function scriptsUnder(directory, prefix) {
   return found;
 }
 function hasMainScene(projectFile) {
-  const scene = parseProjectGodot(readFileSync21(projectFile, "utf8"))["application"]?.["run/main_scene"];
+  const scene = parseProjectGodot(readFileSync22(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "";
 }
 function runtimeAddonAnnouncesEditors(projectPath) {
@@ -37319,13 +37407,13 @@ function runtimeAddonAnnouncesEditors(projectPath) {
     return false;
   }
   try {
-    return readFileSync21(join23(projectPath, RUNTIME_AUTOLOAD.path), "utf8").includes('"editor_pid"');
+    return readFileSync22(join24(projectPath, RUNTIME_AUTOLOAD.path), "utf8").includes('"editor_pid"');
   } catch {
     return false;
   }
 }
 function editorPlaysHeadless(projectFile) {
-  const runArgs = parseProjectGodot(readFileSync21(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
+  const runArgs = parseProjectGodot(readFileSync22(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
   return typeof runArgs === "string" && /(?:^|\s)--headless(?:\s|$)/.test(runArgs);
 }
 function camelCased(params) {
@@ -37345,7 +37433,7 @@ var STATIC_LIST_HINT = { ttlMs: 5 * 60000, cacheScope: "private" };
 class GodotServer {
   stdio = null;
   locator = new GodotLocator;
-  operationsScript = join23(__dirname2, "godot", "operations", "godot_operations.gd");
+  operationsScript = join24(__dirname2, "godot", "operations", "godot_operations.gd");
   godotBridge;
   tools = buildToolDefinitions();
   activeProcess = null;
@@ -37370,6 +37458,7 @@ class GodotServer {
   launchedDropped = null;
   closedHere = null;
   inFlight = new Map;
+  callsOnGames = new Set;
   callsTaken = 0;
   clientNoted = null;
   parentCommand = null;
@@ -37601,14 +37690,14 @@ class GodotServer {
   }
   noteTheStart() {
     const cwd = process.cwd();
-    const mcpJson = join23(cwd, ".mcp.json");
+    const mcpJson = join24(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: existsSync17(mcpJson) ? mcpJson : null
+      mcpJson: existsSync18(mcpJson) ? mcpJson : null
     });
     if (predecessor !== null) {
       writeLifecycle("replaced", { project: this.ownProject, predecessor });
@@ -37749,7 +37838,7 @@ class GodotServer {
         return checked.response;
       }
       const named = args["projectPath"];
-      if (typeof named === "string" && existsSync17(join23(named, "project.godot"))) {
+      if (typeof named === "string" && existsSync18(join24(named, "project.godot"))) {
         this.lastProjectPath = named;
       }
       this.updates.refresh();
@@ -38307,8 +38396,8 @@ class GodotServer {
     if (path === undefined) {
       return { ok: false, response: this.createErrorResponse("projectPath is required.") };
     }
-    const file = join23(path, "project.godot");
-    if (!existsSync17(file)) {
+    const file = join24(path, "project.godot");
+    if (!existsSync18(file)) {
       return {
         ok: false,
         response: this.createErrorResponse(`Not a Godot project: ${path}`, [
@@ -38354,7 +38443,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}".`, [
@@ -38938,11 +39027,11 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const application = parseProjectGodot(readFileSync21(project.value.file, "utf8"))["application"] ?? {};
+    const application = parseProjectGodot(readFileSync22(project.value.file, "utf8"))["application"] ?? {};
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
-      name: typeof name === "string" && name !== "" ? name : basename5(project.value.path),
+      name: typeof name === "string" && name !== "" ? name : basename6(project.value.path),
       path: project.value.path,
       mainScene: typeof mainScene === "string" && mainScene !== "" ? mainScene : null,
       godotVersion: await this.godotVersion(engine.value),
@@ -38994,18 +39083,18 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const folder = dirname16(output.absolutePath);
+    const folder = dirname17(output.absolutePath);
     try {
       mkdirSync14(folder, { recursive: true });
     } catch (error) {
-      return this.createErrorResponse(`Cannot create ${dirname16(output.relativePath)} to export into: ${errorMessage(error)}`);
+      return this.createErrorResponse(`Cannot create ${dirname17(output.relativePath)} to export into: ${errorMessage(error)}`);
     }
     const debug = readBoolean(args, "debug") ?? false;
     const exportLogs = scratchDirectory("export");
     const exportArgs = [
       "--headless",
       "--log-file",
-      join23(exportLogs, "engine.log"),
+      join24(exportLogs, "engine.log"),
       "--path",
       project.value.path,
       debug ? "--export-debug" : "--export-release",
@@ -39013,8 +39102,12 @@ class GodotServer {
       output.absolutePath
     ];
     this.logDebug(`Exporting: ${engine.value} ${exportArgs.join(" ")}`);
-    const writtenAt = () => existsSync17(output.absolutePath) ? statSync9(output.absolutePath).mtimeMs : null;
+    const writtenAt = () => existsSync18(output.absolutePath) ? statSync9(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" } });
@@ -39077,10 +39170,10 @@ class GodotServer {
     if (movie !== null) {
       return this.createErrorResponse(movie);
     }
-    const missing = paths.value.filter((path) => !existsSync17(join23(project.value.path, path.slice("res://".length))));
+    const missing = paths.value.filter((path) => !existsSync18(join24(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 = !existsSync17(join23(project.value.path, runner));
+    const noRunner = !existsSync18(join24(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}` : "";
@@ -39171,21 +39264,21 @@ class GodotServer {
       await untilGone([run.process.pid]);
     }
     await run.settled;
-    const reportsDir = join23(project.value.path, ".godot", ...ours.split("/"));
+    const reportsDir = join24(project.value.path, ".godot", ...ours.split("/"));
     let report = null;
     let reportProblem = null;
     try {
-      const written = existsSync17(reportsDir) ? readdirSync9(reportsDir).filter((name) => name.startsWith("report_")).sort((a, b) => Number(a.slice("report_".length)) - Number(b.slice("report_".length))) : [];
+      const written = existsSync18(reportsDir) ? readdirSync10(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(readFileSync21(join23(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync22(join24(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
     } finally {
       discard(reportsDir, userData);
       try {
-        rmdirSync2(dirname16(reportsDir));
+        rmdirSync2(dirname17(reportsDir));
       } catch {}
     }
     const engineEntries = foldedRepeats(run.log.select({
@@ -39445,11 +39538,11 @@ class GodotServer {
     const cached = cachedClasses(projectPath);
     const sourceOf = (resourcePath) => {
       const contained = resolveWithinProject(projectPath, resourcePath);
-      if (!contained.ok || !existsSync17(contained.absolutePath)) {
+      if (!contained.ok || !existsSync18(contained.absolutePath)) {
         return null;
       }
       try {
-        return readFileSync21(contained.absolutePath, "utf8");
+        return readFileSync22(contained.absolutePath, "utf8");
       } catch {
         return null;
       }
@@ -39514,11 +39607,11 @@ class GodotServer {
   }
   sourceOfClass(projectPath, resourcePath) {
     const contained = resolveWithinProject(projectPath, resourcePath);
-    if (!contained.ok || !existsSync17(contained.absolutePath)) {
+    if (!contained.ok || !existsSync18(contained.absolutePath)) {
       return null;
     }
     try {
-      return readFileSync21(contained.absolutePath, "utf8");
+      return readFileSync22(contained.absolutePath, "utf8");
     } catch {
       return null;
     }
@@ -39666,7 +39759,7 @@ class GodotServer {
       ...Array.isArray(stack) ? {
         stack: stack.map((frame) => ({
           ...frame,
-          ...projectPath !== "" && typeof frame["script"] === "string" && frame["script"].startsWith("res://") ? { path: join23(projectPath, frame["script"].slice("res://".length)) } : {}
+          ...projectPath !== "" && typeof frame["script"] === "string" && frame["script"].startsWith("res://") ? { path: join24(projectPath, frame["script"].slice("res://".length)) } : {}
         }))
       } : {}
     });
@@ -39936,7 +40029,7 @@ class GodotServer {
       return null;
     }
     try {
-      return settingKeys(readFileSync21(join23(projectPath, "project.godot"), "utf8"));
+      return settingKeys(readFileSync22(join24(projectPath, "project.godot"), "utf8"));
     } catch {
       return null;
     }
@@ -40201,6 +40294,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),
@@ -40359,7 +40453,7 @@ class GodotServer {
   }
   async runtimeUp(projectPath, before, budget, withArgs) {
     const budgetMs = budget.ms;
-    if (!existsSync17(join23(projectPath, RUNTIME_AUTOLOAD.path))) {
+    if (!existsSync18(join24(projectPath, RUNTIME_AUTOLOAD.path))) {
       return runtimeVerdict(null, {
         addon: false,
         budgetMs,
@@ -40638,7 +40732,7 @@ class GodotServer {
       return 0;
     }
     try {
-      return reportAlreadyInTranscript(readFileSync21(game.transcript), readFileSync21(report));
+      return reportAlreadyInTranscript(readFileSync22(game.transcript), readFileSync22(report));
     } catch (error) {
       this.logDebug(`Could not compare a picked-up run's report with its transcript: ${errorMessage(error)}`);
       return 0;
@@ -41318,7 +41412,7 @@ class GodotServer {
     }
     const going = await this.runStillGoing(run);
     const projectPath = run.projectPath;
-    const projectGone = projectPath !== null && !existsSync17(join23(projectPath, "project.godot"));
+    const projectGone = projectPath !== null && !existsSync18(join24(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"]);
     }
@@ -41606,7 +41700,7 @@ class GodotServer {
       notes.push(endedWithoutACode({
         throughEditor: run.throughEditor,
         announced: announced !== undefined || run.announcedPid !== undefined,
-        couldAnnounce: run.projectPath !== null && existsSync17(join23(run.projectPath, RUNTIME_AUTOLOAD.path)),
+        couldAnnounce: run.projectPath !== null && existsSync18(join24(run.projectPath, RUNTIME_AUTOLOAD.path)),
         endedHere: typeof run.endedHere === "string",
         pickedUp: run.pickedUp === true
       }));
@@ -42171,7 +42265,7 @@ class GodotServer {
     if (!scriptPath.ok) {
       return this.createErrorResponse(scriptPath.reason);
     }
-    if (!existsSync17(scriptPath.absolutePath)) {
+    if (!existsSync18(scriptPath.absolutePath)) {
       return this.createErrorResponse(`Script file does not exist: ${scriptPath.absolutePath}`);
     }
     const asked = readNonEmptyString(args, "newScriptPath");
@@ -42499,7 +42593,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) || !existsSync17(join23(project, RUNTIME_AUTOLOAD.path)) || !await this.runStillGoing(run)) {
+    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync18(join24(project, RUNTIME_AUTOLOAD.path)) || !await this.runStillGoing(run)) {
       return null;
     }
     const already = runtimesAnnounced().running;
@@ -42584,12 +42678,25 @@ class GodotServer {
       }
     }
     const screenshotDir = expectsScreenshot ? scratchDirectory("runtime-screenshot") : null;
-    const screenshotPath = screenshotDir ? join23(screenshotDir, "capture.png") : null;
+    const screenshotPath = screenshotDir ? join24(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) {
@@ -42600,7 +42707,8 @@ ${staleNote}`);
           waitedMs: timeoutMs,
           note: `${reply.message} ${longerWaitNote(asked.tool, asked.op, timeoutMs)}`,
           ...answeredBy,
-          ...stale
+          ...stale,
+          ...alongside()
         });
       }
       if (!reply.ok) {
@@ -42608,7 +42716,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) {
@@ -42625,18 +42733,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: readFileSync21(screenshotPath).toString("base64"), mimeType: "image/png" }
+          { type: "image", data: readFileSync22(screenshotPath).toString("base64"), mimeType: "image/png" }
         ]
       };
     } finally {
+      this.callsOnGames.delete(onGame);
       discard(screenshotDir);
     }
   }