gdharness 1.2.26 → 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";
@@ -27929,6 +27929,18 @@ class GodotDAPClient {
       lines: Array.from(lines).sort((a, b) => a - b)
     }));
   }
+  forgetBreakpoint(scriptPath, line) {
+    const key = fileKey(scriptPath);
+    const lines = this.breakpoints.get(key);
+    if (lines === undefined) {
+      return;
+    }
+    lines.delete(line);
+    if (lines.size === 0) {
+      this.breakpoints.delete(key);
+      this.spelled.delete(key);
+    }
+  }
   holdBreakpoints(held) {
     for (const { scriptPath, lines } of held) {
       const key = fileKey(scriptPath);
@@ -28707,6 +28719,22 @@ function howItEnded(run) {
   return run.exitSignal === null ? `exit code ${run.exitCode ?? "unknown"}` : `ended by ${run.exitSignal}`;
 }
 
+// src/godot-variant.ts
+var FLAG_64 = 1 << 16;
+var MOST_MESSAGE_BYTES = (8 << 20) + 4;
+
+// src/game-debugger.ts
+var PAUSE_MS = 30000;
+var STEP_MS = 1e4;
+var READ_MS = 5000;
+var REPLIES = new Set([
+  "debug_enter",
+  "debug_exit",
+  "stack_dump",
+  "stack_frame_vars",
+  "stack_frame_var"
+]);
+
 // src/godot-bridge.ts
 import { randomUUID } from "node:crypto";
 import { EventEmitter } from "node:events";
@@ -29489,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];
@@ -29530,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;
   }
@@ -29546,7 +29655,7 @@ function sweepAbandonedScratch(directory = tmpdir4()) {
       continue;
     }
     try {
-      remove(join13(directory, entry));
+      remove(join14(directory, entry));
     } catch {}
   }
 }
@@ -29584,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);
@@ -29675,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));
@@ -29700,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;
@@ -29708,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();
@@ -29731,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"
@@ -29751,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",
@@ -29827,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)}` };
@@ -30340,7 +30450,31 @@ function testProgressMessage(printed, elapsedMs) {
 
 // src/keeper-channel.ts
 import { connect, createServer as createServer2 } from "node:net";
-function askTheKeeperToStop(address, withinMs) {
+var DEBUG_PREFIX = "debug ";
+async function askTheKeeperToStop(address, withinMs) {
+  const answered = await askTheKeeper(address, "stop", withinMs);
+  if (typeof answered !== "string") {
+    return answered;
+  }
+  return answered === "signalled" || answered === "gone" ? answered : { unreached: `it answered ${JSON.stringify(answered)}` };
+}
+async function askTheKeepersDebugger(address, request, withinMs) {
+  const answered = await askTheKeeper(address, `${DEBUG_PREFIX}${JSON.stringify(request)}`, withinMs);
+  if (typeof answered !== "string") {
+    return answered;
+  }
+  if (answered === "unknown") {
+    return { unreached: "its keeper was started by a gdharness from before game debuggers, and has none" };
+  }
+  try {
+    const parsed = JSON.parse(answered);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {}
+  return { unreached: `it answered ${JSON.stringify(answered.slice(0, 200))}` };
+}
+function askTheKeeper(address, line, withinMs) {
   return new Promise((resolve) => {
     let said = "";
     let settled = false;
@@ -30358,16 +30492,15 @@ function askTheKeeperToStop(address, withinMs) {
     }, withinMs);
     socket.setEncoding("utf8");
     socket.on("connect", () => {
-      socket.write(`stop
+      socket.write(`${line}
 `);
     });
     socket.on("data", (chunk) => {
       said += chunk;
-      const line = said.split(`
-`)[0] ?? "";
       if (said.includes(`
 `)) {
-        settle(line === "signalled" || line === "gone" ? line : { unreached: `it answered ${JSON.stringify(line)}` });
+        settle(said.split(`
+`)[0] ?? "");
       }
     });
     socket.on("error", (error) => {
@@ -30380,20 +30513,20 @@ function askTheKeeperToStop(address, 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 = {
@@ -30423,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;
@@ -30624,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) {
@@ -31182,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);
@@ -31389,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);
@@ -31400,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([
@@ -31442,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)) {
@@ -31471,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);
       }
@@ -31493,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);
       }
     }
@@ -31534,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}/`);
@@ -31548,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") });
       }
@@ -31564,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);
@@ -31578,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") });
       }
@@ -31601,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;
@@ -31617,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;
       }
@@ -31779,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;
@@ -32502,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;
         }
       }
@@ -32532,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 {}
@@ -32544,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 = [
   {
@@ -32779,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",
@@ -32788,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
@@ -32853,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;
     }
   }
@@ -32906,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.` };
     }
   }
@@ -33082,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);
@@ -33283,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;
 }
@@ -33314,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) {
@@ -33331,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;
     }
@@ -33355,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"]);
@@ -33374,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 ?? "";
@@ -33392,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;
     }
   }
@@ -33416,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 {
@@ -33429,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;
     }
@@ -33445,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 });
@@ -33466,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;
     }
@@ -33476,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;
   }
@@ -33500,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;
     }
@@ -33512,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);
         }
@@ -33530,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;
   }
@@ -33583,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();
@@ -33690,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)) {
@@ -33729,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] : []]) {
@@ -33754,7 +33887,7 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
   ]));
   let entries;
   try {
-    entries = readdirSync7(directory);
+    entries = readdirSync8(directory);
   } catch {
     return;
   }
@@ -33763,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;
     }
@@ -33774,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;
@@ -33830,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",
@@ -33867,16 +34000,10 @@ function withoutListed(entries, errors) {
 }
 
 // src/script-profile.ts
-import { readFileSync as readFileSync19 } from "node:fs";
-
-// src/godot-variant.ts
-var FLAG_64 = 1 << 16;
-var MOST_MESSAGE_BYTES = (8 << 20) + 4;
-
-// src/script-profile.ts
+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;
@@ -34992,7 +35119,7 @@ var TOOL_SPECS = [
         type: "array",
         items: { type: "string" },
         ops: ["start", "check"],
-        description: `The game's own arguments, what OS.get_cmdline_user_args() answers, such as ["--level=2"]. The separator is added here, so a flag the engine reads goes to the game instead, and the answer says so under argsNote. A run with any is started by this server rather than by the editor, which fixes the game's command line when it opens the project, so the debug_* tools do not answer for it.`
+        description: `The game's own arguments, what OS.get_cmdline_user_args() answers, such as ["--level=2"]. The separator is added here, so a flag the engine reads goes to the game instead, and the answer says so under argsNote. A run with any is started by this server rather than by the editor, which fixes the game's command line when it opens the project, so its debugger is the keeper holding it rather than the editor; the debug_* tools answer for it all the same.`
       },
       engineArgs: {
         type: "array",
@@ -35009,7 +35136,7 @@ var TOOL_SPECS = [
       silent: {
         type: "boolean",
         ops: ["start"],
-        description: "start: run the game with no sound out of the machine, by starting the engine with --audio-driver Dummy: every stream still plays and every playback position still advances, so what is playing can still be asked. The editor takes no engine flags for a game it plays, so a silent windowed run is started by this server, and the debug_* tools do not answer for it. A headless run, check's included, is silent already. Default false, or true when GDHARNESS_SILENT is set in the server's environment to anything but 0 or false; silent: false then plays through the editor as before."
+        description: "start: run the game with no sound out of the machine, by starting the engine with --audio-driver Dummy: every stream still plays and every playback position still advances, so what is playing can still be asked. The editor takes no engine flags for a game it plays, so a silent windowed run is started by this server, whose keeper is its debugger rather than the editor. A headless run, check's included, is silent already. Default false, or true when GDHARNESS_SILENT is set in the server's environment to anything but 0 or false; silent: false then plays through the editor as before."
       },
       savesIn: {
         type: "string",
@@ -35335,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: []
       }
     },
@@ -35690,7 +35817,7 @@ var TOOL_SPECS = [
   {
     name: "debug_breakpoint",
     title: "Breakpoints",
-    description: "Sets or removes a breakpoint through the editor's debug adapter. Needs the editor, not a running game: set them first, then editor_run, and the game stops where you asked. The editor keeps a breakpoint set this way for one play, so every breakpoint this server holds is sent again before each play editor_run starts, and the start answer lists them under breakpoints. The set is also kept in the project, for the server that comes after a reconnect: a breakpoint stays until it is removed here, whichever server set it. Every answer lists the whole set under held, and the breakpoints the user set in the editor's own gutter under setInEditor; setting one here never takes those away, and removing a line here clears it whoever set it. Godot clears every breakpoint in the editor when a debug session opens unless network/debug_adapter/sync_breakpoints is on, which the addon turns on as it loads; an editor running an older addon is said so under breakpointsAtRisk, here and in editor_status.",
+    description: "Sets or removes a breakpoint. Set them first, then editor_run, and the game stops where you asked. With the editor connected it goes through the editor's debug adapter; with none, it is held here. A game this server starts itself, which editor_run start does for a run given args, savesIn, env or silent, or with no editor, is handed every breakpoint held here as it starts, and one set while that game runs reaches it at once (runningGame says so). The editor keeps a breakpoint set this way for one play, so every breakpoint this server holds is sent again before each play editor_run starts, and the start answer lists them under breakpoints. The set is also kept in the project, for the server that comes after a reconnect: a breakpoint stays until it is removed here, whichever server set it. Every answer lists the whole set under held, and the breakpoints the user set in the editor's own gutter under setInEditor; setting one here never takes those away, and removing a line here clears it whoever set it. Godot clears every breakpoint in the editor when a debug session opens unless network/debug_adapter/sync_breakpoints is on, which the addon turns on as it loads; an editor running an older addon is said so under breakpointsAtRisk, here and in editor_status.",
     parameters: {
       projectPath: PROJECT_PATH2,
       scriptPath: SCRIPT_PATH,
@@ -35705,23 +35832,33 @@ var TOOL_SPECS = [
   {
     name: "debug_control",
     title: "Step the debugger",
-    description: "Continues or steps the debugged game through the editor's debug adapter. A step waits for the game to stop again and answers with the stack where it ended up; one that has not stopped the game again within ten seconds answers heldAgain false and no stack. There is no pause and no step_out: Godot's adapter answers a pause by reporting the game stopped and leaving it running, and implements no stepOut at all, so hold the game where you want it with a breakpoint and step over or into from there.",
+    description: "Pauses, continues or steps the debugged game. A step waits for the game to stop again and answers with the stack where it ended up; one that has not stopped the game again within ten seconds answers heldAgain false and no stack. A game the editor plays is moved through the editor's debug adapter, which cannot pause or step out: it answers a pause by reporting the game stopped and leaving it running, and implements no stepOut, so hold such a game with a breakpoint and step over or into from there. A game this server started itself has its keeper as its debugger, which does both: pause breaks into the game wherever it is, a script spinning in a loop included, which is how a game hung on its first frame is asked where it is.",
     parameters: {},
     requires: [],
     operations: {
+      pause: {
+        effect: "additive",
+        summary: "stop a game this server started where it is, answering with the stack. The game takes it between frames, and in a script every 2048 lines it runs, so a loop that sleeps between few lines can take seconds; the call waits thirty, and past that answers paused false with the request still standing. Stopped between frames, where no script runs, the game is stepped on to the next line of script it runs",
+        requires: []
+      },
       continue: { effect: "additive", summary: "resume after a breakpoint", requires: [] },
       step_over: { effect: "additive", summary: "run the current line", requires: [] },
       step_into: {
         effect: "additive",
         summary: "run the current line, stopping inside whatever it calls",
         requires: []
+      },
+      step_out: {
+        effect: "additive",
+        summary: "run to the end of the current function and stop in its caller; a game this server started only",
+        requires: []
       }
     }
   },
   {
     name: "debug_state",
     title: "Debugger state",
-    description: "Where the debugged game is stopped: the stack trace, what is in scope at a frame with the values, or the debug adapter's console output so far, its last thousand lines, with any earlier ones counted under notShown. A stop is reported by the editor's adapter only to the sessions connected when it happened, so a server that connected afterwards, which is every server after a reconnect, is shown a thread and no frames about a game still sitting at its breakpoint. That server asks the runtime instead: a held game accepts a connection and never answers, and the refusal then says held rather than running, and that the stack cannot be read from here. debug_control continue lets it go, and the next stop is one this session is told about, with its stack.",
+    description: "Where the debugged game is stopped: the stack trace, what is in scope at a frame with the values, or the debugger's console output so far, its last thousand lines, with any earlier ones counted under notShown. For a game this server started, its keeper's debugger answers: each frame names its script as the project spells it under script and on this machine under path, and held says which thread stopped and why. For a game the editor plays, the editor's debug adapter answers. A stop is reported by the editor's adapter only to the sessions connected when it happened, so a server that connected afterwards, which is every server after a reconnect, is shown a thread and no frames about a game still sitting at its breakpoint. That server asks the runtime instead: a held game accepts a connection and never answers, and the refusal then says held rather than running, and that the stack cannot be read from here. debug_control continue lets it go, and the next stop is one this session is told about, with its stack.",
     parameters: {
       frameId: {
         type: "number",
@@ -35811,7 +35948,7 @@ function serverInstructions() {
     "Call editor_status first: it says whether an editor is connected and whether its addon matches this server.",
     "Start the game with editor_run start, never by spawning an engine, and read editor_output after every run:",
     "its clean verdict and its error entries are how a run is judged, and editor_run wait is how to wait for one.",
-    "The runtime_* tools work on the running game and the debug_* tools on the editor's debugger.",
+    "The runtime_* tools work on the running game and the debug_* tools on its debugger.",
     "A refusal names what would have worked, so read it before calling again."
   ].join(" ");
 }
@@ -35821,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"];
@@ -35849,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");
 }
@@ -35900,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) {
@@ -35926,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 };
@@ -35968,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`);
@@ -35980,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)) {
@@ -35996,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`);
       }
@@ -36047,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);
@@ -36079,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.`;
   }
@@ -36144,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")) {
@@ -36152,6 +36290,31 @@ function longerWaitNote(tool, op, waitedMs) {
   const how = tool === "runtime_wait" && op === "frames" ? `the wait is counted from the number of frames, at ${SLOWEST_FRAME_RATE} a second on top of GDHARNESS_RUNTIME_TIMEOUT_MS: a game drawing frames more slowly than that is waited on in fewer frames at a time, and a game inside one long frame, such as a long _ready, answers no call however few frames are asked for` : "the wait is GDHARNESS_RUNTIME_TIMEOUT_MS, which is set in the environment the server is started with";
   return `${tool} ${op} takes no timeoutMs: it was given ${waitedMs}ms, and ${how}.`;
 }
+function keptGameRequest(tool, op, args) {
+  if (tool === "debug_state") {
+    if (op === "output") {
+      return { op: "output" };
+    }
+    if (op === "variables") {
+      const frame = args["frameId"];
+      return { op: "variables", frame: typeof frame === "number" ? frame : 0 };
+    }
+    return { op: "stack" };
+  }
+  switch (op) {
+    case "pause":
+      return { op: "pause" };
+    case "step_over":
+      return { op: "resume", how: "next" };
+    case "step_into":
+      return { op: "resume", how: "step" };
+    case "step_out":
+      return { op: "resume", how: "out" };
+    default:
+      return { op: "resume", how: "continue" };
+  }
+}
+var 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.";
 function projectSpelling(projectPath, absolutePath) {
   return `res://${relative4(realPathOr(projectPath), realPathOr(absolutePath)).replaceAll("\\", "/")}`;
 }
@@ -36239,6 +36402,7 @@ function stopWaitMs() {
   return waitFromEnv("GDHARNESS_STOP_WAIT_MS", 1e4);
 }
 var KEEPER_ANSWER_MS = 15000;
+var KEEPER_DEBUG_MS = PAUSE_MS + STEP_MS + 2 * READ_MS;
 var EXIT_REPORTED_WITHIN_MS = 2000;
 async function untilGone(pids, withinMs = stopWaitMs()) {
   const gone = () => pids.every((pid) => !alive(pid));
@@ -36588,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,
@@ -36596,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) {
@@ -36640,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);
@@ -36922,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));
@@ -36948,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);
@@ -37100,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;
   }
@@ -37115,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 "";
   }
@@ -37212,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);
     }
@@ -37230,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) {
@@ -37238,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) {
@@ -37264,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;
@@ -37289,6 +37458,7 @@ class GodotServer {
   launchedDropped = null;
   closedHere = null;
   inFlight = new Map;
+  callsOnGames = new Set;
   callsTaken = 0;
   clientNoted = null;
   parentCommand = null;
@@ -37520,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 });
@@ -37668,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();
@@ -38139,28 +38309,70 @@ class GodotServer {
           return this.createErrorResponse(located.reason, PATH_SOLUTIONS);
         }
         const session = this.dapHoldingBreakpointsOf(project.value.path);
-        const answered = await this.handleDAP(op === "set" ? "dap_set_breakpoint" : "dap_remove_breakpoint", {
-          ...args,
-          scriptPath: realPathOr(located.absolutePath)
-        });
-        if (answered.isError === true) {
-          return answered;
+        const scriptPath = realPathOr(located.absolutePath);
+        const line = readPositiveNumber(args, "line");
+        if (line === undefined) {
+          return this.createErrorResponse("line is required: the one-based line to stop on.");
+        }
+        const editor = this.godotBridge.isConnected();
+        let answer;
+        if (editor) {
+          const answered = await this.handleDAP(op === "set" ? "dap_set_breakpoint" : "dap_remove_breakpoint", {
+            ...args,
+            scriptPath
+          });
+          if (answered.isError === true) {
+            return answered;
+          }
+          answer = asParams(JSON.parse(answered.content[0]?.text ?? "{}"));
+        } else {
+          if (op === "set") {
+            session.holdBreakpoints([{ scriptPath, lines: [line] }]);
+          } else {
+            session.forgetBreakpoint(scriptPath, line);
+          }
+          answer = { [op === "set" ? "set" : "removed"]: true };
         }
         const held = session.breakpointsHeld();
         writeBreakpointNote(project.value.path, held);
+        const kept = this.keptRun();
+        const told = kept === null ? null : await askTheKeepersDebugger(kept.keeper, {
+          op: "breakpoint",
+          script: projectSpelling(project.value.path, scriptPath),
+          line,
+          set: op === "set"
+        }, KEEPER_DEBUG_MS);
         return this.jsonTextResponse({
-          ...asParams(JSON.parse(answered.content[0]?.text ?? "{}")),
+          ...answer,
           held: this.breakpointsAsProjectSpells(project.value.path, held),
-          setInEditor: this.breakpointsAsProjectSpells(project.value.path, session.breakpointsInEditor()),
-          note: "The editor keeps a breakpoint set this way for one play. Every breakpoint held here is sent again before each play editor_run starts, and kept in the project for the server after a reconnect.",
-          ...this.breakpointsAtRisk()
+          ...editor ? {
+            setInEditor: this.breakpointsAsProjectSpells(project.value.path, session.breakpointsInEditor())
+          } : {},
+          ...told === null ? {} : ("unreached" in told) || typeof told["refused"] === "string" ? {
+            runningGame: `The game this server started is running, and its debugger was not told: ${String("unreached" in told ? told.unreached : told["refused"])}. It takes the line when it is started again.`
+          } : {
+            runningGame: `Told to the running game (pid ${kept?.pid ?? "?"}), which this server started.`
+          },
+          note: editor ? "The editor keeps a breakpoint set this way for one play. Every breakpoint held here is sent again before each play editor_run starts, handed to every game this server starts itself, and kept in the project for the server after a reconnect." : "No editor is connected, so the set under held is kept here: every game this server starts is handed it as it starts, an editor that connects is sent it before its first play, and it is kept in the project for the server after a reconnect.",
+          ...editor ? this.breakpointsAtRisk() : {}
         });
       }
       case "debug_control":
       case "debug_state": {
+        const kept = this.keptRun();
+        if (kept !== null) {
+          return await this.askTheKeptGame(kept.keeper, keptGameRequest(tool, op, args), kept.projectPath ?? "");
+        }
         if (tool === "debug_state" && op === "output") {
           return await this.handleDAP("dap_get_output", args);
         }
+        const played = this.activeProcess;
+        if ((op === "pause" || op === "step_out") && played?.throughEditor === true && !exited(played)) {
+          return this.createErrorResponse(op === "pause" ? "A game the editor plays cannot be paused from here: Godot's debug adapter answers a pause by reporting the game stopped and leaving it running." : "A game the editor plays cannot be stepped out of a function from here: Godot's debug adapter implements no stepOut.", [
+            "Set a breakpoint where it should stop, then step over or into from there",
+            "A game this server starts, as editor_run start does with args, savesIn or env, has a debugger here that pauses and steps out"
+          ]);
+        }
         const held = await this.debuggedGame(tool === "debug_control" ? "move" : "read");
         if (!held.ok) {
           return held.response;
@@ -38184,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}`, [
@@ -38231,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}".`, [
@@ -38304,8 +38516,8 @@ class GodotServer {
     if (!game.throughEditor) {
       return {
         ok: false,
-        response: this.createErrorResponse("The running game is its own process, so no debugger is holding it: breakpoints never hit and there is no stack to read.", [
-          "editor_run start plays it through the open editor, whose debugger the debug_* tools speak to",
+        response: this.createErrorResponse("The running game has no debugger: it was started with none, or by a keeper that could not take questions, so breakpoints never hit and there is no stack to read.", [
+          "editor_run start starts it again, and the keeper holding a game this server starts is its debugger",
           "editor_status says whether an editor has reached this server"
         ])
       };
@@ -38815,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),
@@ -38871,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",
@@ -38890,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" } });
@@ -38954,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}` : "";
@@ -39048,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({
@@ -39322,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;
       }
@@ -39391,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;
     }
@@ -39516,6 +39732,38 @@ class GodotServer {
       breakpointsAtRisk: status.syncsBreakpoints === false ? "This editor clears every breakpoint in its script editor whenever a debug session opens on its adapter, which this server does for its first breakpoint or stack read: network/debug_adapter/sync_breakpoints is off. The installed addon turns it on as it loads, so the editor is running an older one; editor_launch restart puts the installed addon in, or turn the setting on in Editor Settings > Network > Debug Adapter." : "Whether this editor keeps its breakpoints when a debug session opens cannot be told: the addon it is running predates the report. Godot clears them unless network/debug_adapter/sync_breakpoints is on, which the installed addon turns on as it loads; editor_launch restart puts the installed addon in."
     };
   }
+  breakpointsForAGame(projectPath) {
+    return this.dapHoldingBreakpointsOf(projectPath).breakpointsHeld().flatMap((one) => one.lines.map((line) => `${projectSpelling(projectPath, one.scriptPath)}:${line}`));
+  }
+  keptRun() {
+    const game = this.activeProcess;
+    if (game === null || game.throughEditor || exited(game) || game.keeper === undefined) {
+      return null;
+    }
+    return { ...game, keeper: game.keeper };
+  }
+  async askTheKeptGame(keeper, request, projectPath) {
+    const answered = await askTheKeepersDebugger(keeper, request, KEEPER_DEBUG_MS);
+    if ("unreached" in answered) {
+      return this.createErrorResponse(`The debugger of the running game did not answer: ${String(answered.unreached)}.`, [
+        "editor_run start starts the game again, with a debugger",
+        "editor_status says whether it is still running"
+      ]);
+    }
+    if (typeof answered["refused"] === "string") {
+      return this.createErrorResponse(answered["refused"]);
+    }
+    const stack = answered["stack"];
+    return this.jsonTextResponse({
+      ...answered,
+      ...Array.isArray(stack) ? {
+        stack: stack.map((frame) => ({
+          ...frame,
+          ...projectPath !== "" && typeof frame["script"] === "string" && frame["script"].startsWith("res://") ? { path: join24(projectPath, frame["script"].slice("res://".length)) } : {}
+        }))
+      } : {}
+    });
+  }
   breakpointsAsProjectSpells(projectPath, held) {
     return held.map((one) => ({
       scriptPath: projectSpelling(projectPath, one.scriptPath),
@@ -39781,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;
     }
@@ -40046,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),
@@ -40177,9 +40426,10 @@ class GodotServer {
     started.announcedBefore = alreadyPlaying;
     started.bootScene = runtimeWaitMs.scene;
     this.activeProcess = started;
-    const spawnedInstead = this.godotBridge.isConnected() && editorWouldPlay && (given.value.length > 0 || flags.value.length > 0) ? " The editor cannot be handed arguments for a game it plays, so this one was started " + "here: the debug_* tools answer only for a game the editor is playing." : this.godotBridge.isConnected() && editorWouldPlay && needsItsOwnProcess(asked.value) ? " The editor plays a game with its own environment, so a run given one was started " + "here: the debug_* tools answer only for a game the editor is playing." : this.godotBridge.isConnected() && editorWouldPlay && silent ? " The editor cannot play a game silent, which takes an engine flag, so this one was " + `started here${args["silent"] === true ? "" : ", silent because GDHARNESS_SILENT says so"}: the debug_* tools answer only for a game the editor is playing, and silent: false plays it through the editor.` : "";
+    const spawnedInstead = this.godotBridge.isConnected() && editorWouldPlay && (given.value.length > 0 || flags.value.length > 0) ? ` The editor cannot be handed arguments for a game it plays, so this one was started here.${OWN_DEBUGGER}` : this.godotBridge.isConnected() && editorWouldPlay && needsItsOwnProcess(asked.value) ? ` The editor plays a game with its own environment, so a run given one was started here.${OWN_DEBUGGER}` : this.godotBridge.isConnected() && editorWouldPlay && silent ? " The editor cannot play a game silent, which takes an engine flag, so this one was " + `started here${args["silent"] === true ? "" : ", silent because GDHARNESS_SILENT says so"}, and silent: false plays it through the editor.${OWN_DEBUGGER}` : "";
     const endedForThis = endedToStartThis(ended);
     const stranded = wereHereFirst.filter((one) => one.pid !== ended?.pid && alive(one.pid));
+    const handed = this.dapHoldingBreakpointsOf(project.value.path).breakpointsHeld();
     const alsoRunning = leftRunningNote(stranded);
     return this.jsonTextResponse({
       started: true,
@@ -40189,6 +40439,7 @@ class GodotServer {
       arguments: cmdArgs,
       argsNote: engineFlagsNote(given.value),
       transcript: started.transcript,
+      breakpoints: started.keeper === undefined || handed.length === 0 ? undefined : this.breakpointsAsProjectSpells(project.value.path, handed),
       profile: profileOnStart(profiled, "gdharness", runtimeAddonRegistered(project.value.path)),
       refreshedClasses: refreshed.value,
       ...scanWaitAnswer(scanned),
@@ -40197,12 +40448,12 @@ class GodotServer {
       previousRunLeft: previousRunLeft(ended),
       ...previousRunHow(ended),
       runtime: await this.runtimeUp(project.value.path, alreadyPlaying, runtimeWaitMs, given.value.length > 0),
-      message: `Use editor_output for what it prints and editor_run stop to end it.${spawnedInstead}${endedForThis}${alsoRunning}`
+      message: `Use editor_output for what it prints and editor_run stop to end it.${started.keeper !== undefined && handed.length > 0 ? " It stops at the lines under breakpoints, and debug_state stack reads where it is held." : ""}${spawnedInstead}${endedForThis}${alsoRunning}`
     });
   }
   async runtimeUp(projectPath, before, budget, withArgs) {
     const budgetMs = budget.ms;
-    if (!existsSync17(join23(projectPath, RUNTIME_AUTOLOAD.path))) {
+    if (!existsSync18(join24(projectPath, RUNTIME_AUTOLOAD.path))) {
       return runtimeVerdict(null, {
         addon: false,
         budgetMs,
@@ -40481,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;
@@ -40724,7 +40975,8 @@ class GodotServer {
         startedAt,
         projectPath,
         ...this.servedBy(),
-        ...profile === undefined ? {} : { profile }
+        ...profile === undefined ? {} : { profile },
+        breakpoints: this.breakpointsForAGame(projectPath)
       },
       ...desktop === undefined ? {} : { desktop }
     });
@@ -41160,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"]);
     }
@@ -41448,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
       }));
@@ -42013,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");
@@ -42341,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;
@@ -42426,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) {
@@ -42442,7 +42707,8 @@ ${staleNote}`);
           waitedMs: timeoutMs,
           note: `${reply.message} ${longerWaitNote(asked.tool, asked.op, timeoutMs)}`,
           ...answeredBy,
-          ...stale
+          ...stale,
+          ...alongside()
         });
       }
       if (!reply.ok) {
@@ -42450,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) {
@@ -42467,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);
     }
   }