gdharness 0.13.41 → 0.13.43

package/build/cli.js

@@ -7283,7 +7283,7 @@ class GameLog {
 }
 var HEADLINE, COLOUR_CODE, STREAMS, ADMITTED;
 var init_game_log = __esm(() => {
-  HEADLINE = /^(USER )?(SCRIPT ERROR|ERROR|WARNING):\s?(.*)$/;
+  HEADLINE = /^(USER )?(SCRIPT ERROR|SHADER ERROR|ERROR|WARNING):\s?(.*)$/;
   COLOUR_CODE = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
   STREAMS = ["stdout", "stderr", "transcript"];
   ADMITTED = {
@@ -15393,7 +15393,7 @@ var init_tool_definitions = __esm(() => {
   };
   RUNNING_PID = {
     type: "number",
-    description: "Which game, when several are running from one project, such as a bench and its workers: its process id, as editor_status lists under runtimes. Not needed with one game per project."
+    description: "Which game, when several are running from one project, such as a bench and its workers: its process id, as editor_status lists under runtimes. Without it the game this server started or plays is the one asked when it is among them, and the answer says so under answeredBy; with one game per project it is not needed at all."
   };
   SCENE_PATH = {
     type: "string",
@@ -16011,6 +16011,11 @@ var init_tool_definitions = __esm(() => {
           type: "number",
           ops: ["check", "wait"],
           description: "check: how long to give the boot before it is called hung. Default 60000. wait: how long to wait for the run to end before answering anyway. Default 600000."
+        },
+        andChildren: {
+          type: "boolean",
+          ops: ["stop"],
+          description: "stop: also end what the game started for itself, with OS.create_process or otherwise, such as a bench's workers and whatever those started in turn. Only the processes under the run's, to any depth, that are games of this project are ended: announced as one, or this project's engine run with --path on this project by its command line, which is how a bench whose workers deliberately carry no runtime is reached. They are named under endedChildren, with what identified each under identifiedBy; any other process under the run is left and named under childrenLeft, and childrenUnknown is true when nothing could be listed, with the note saying whether the platform would not or the run has no process to list under. Default false, and the run's process is ended either way."
         }
       },
       requires: [],
@@ -16020,7 +16025,7 @@ var init_tool_definitions = __esm(() => {
           requires: ["projectPath"]
         },
         stop: {
-          summary: "end the run and answer with what it printed last, naming the process ended under endedPid: a game that started processes of its own keeps them",
+          summary: "end the run and answer with what it printed last, naming the process ended under endedPid: a game that started processes of its own keeps them unless andChildren says to end those too",
           requires: []
         },
         check: {
@@ -16033,7 +16038,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "editor_output",
-      description: "What the project started by editor_run has printed, as entries with a severity: the errors and warnings the engine reported, each with where it happened, and everything else as info. Answers with the counts and the verdict as well as the entries. heldAt is three answers: null for a run this server knows is not held, running or over, an object for one it knows is held at a breakpoint, whether the adapter said so or the runtime did by accepting a connection and never answering, and absent with heldUnknown beside it for a server that connected to the debugger after the stop and has no runtime to ask, since the adapter reports a stop only to the sessions connected when it happened. A run that has quit still answers here, with running false and its exit code, until the next one starts. A run this server started also answers with transcript, the file both its streams are written to: uncapped, written while the run is going, and the thing to read or tail for a long run rather than the engine's own log, which every engine start rotates away. Read the file for output and this answer for state: endedBy says whether gdharness ended the run, and a transcript that has stopped growing is a run between prints rather than a run that is over. running is asked of the operating system whenever there is a process to ask about, which is every run this server started and every editor-played run whose game announced its runtime. For an editor-played run that never announced, there is no process id here and running is the editor's answer, which can lag: one measured elsewhere reported a game as playing for fifteen seconds after its process had been ended from outside. editor_status names that game under runtimes, which does not depend on the editor answering.",
+      description: "What the project started by editor_run has printed, as entries with a severity: the errors and warnings the engine reported, each with where it happened, and everything else as info. For a run the editor plays the reports come from the game itself, through the runtime addon, since the editor's debugger relays what a game prints and not what it reports; a played game without the runtime addon answers here with its prints alone. Answers with the counts and the verdict as well as the entries. heldAt is three answers: null for a run this server knows is not held, running or over, an object for one it knows is held at a breakpoint, whether the adapter said so or the runtime did by accepting a connection and never answering, and absent with heldUnknown beside it for a server that connected to the debugger after the stop and has no runtime to ask, since the adapter reports a stop only to the sessions connected when it happened. A run that has quit still answers here, with running false and its exit code, until the next one starts. A run this server started also answers with transcript, the file both its streams are written to: uncapped, written while the run is going, and the thing to read or tail for a long run rather than the engine's own log, which every engine start rotates away. Read the file for output and this answer for state: endedBy says whether gdharness ended the run, and a transcript that has stopped growing is a run between prints rather than a run that is over. running is asked of the operating system whenever there is a process to ask about, which is every run this server started and every editor-played run whose game announced its runtime. For an editor-played run that never announced, there is no process id here and running is the editor's answer, which can lag: one measured elsewhere reported a game as playing for fifteen seconds after its process had been ended from outside. editor_status names that game under runtimes, which does not depend on the editor answering.",
       parameters: {
         severity: {
           type: "string",
@@ -36413,23 +36418,159 @@ var init_lsp_client = __esm(() => {
   init_ports();
 });
 
-// src/process-time.ts
+// src/process-children.ts
 import { execFile as execFile5 } from "node:child_process";
+import { basename as basename2 } from "node:path";
 import { promisify as promisify5 } from "node:util";
+async function processTree() {
+  try {
+    const printed = process.platform === "win32" ? await askWindows() : await askPosix();
+    return parseProcessTable(printed);
+  } catch {
+    return;
+  }
+}
+function parseProcessTable(printed) {
+  const tree = new Map;
+  for (const line of printed.split(/\r?\n/)) {
+    const fields = /^\s*(\d+)\s+(\d+)(?:\s+(.*))?$/.exec(line);
+    if (fields === null) {
+      continue;
+    }
+    const pid = Number(fields[1]);
+    const parent = Number(fields[2]);
+    if (pid > 0) {
+      tree.set(pid, { parent, command: (fields[3] ?? "").trim() });
+    }
+  }
+  return tree;
+}
+function childrenIn(tree, pid) {
+  const children = [];
+  for (const [child, listed] of tree) {
+    if (listed.parent === pid) {
+      children.push(child);
+    }
+  }
+  return children;
+}
+function descendantsIn(tree, pid) {
+  const found = [];
+  const queue = [pid];
+  const seen = new Set([pid]);
+  while (queue.length > 0) {
+    const next = queue.shift();
+    if (next === undefined) {
+      break;
+    }
+    for (const child of childrenIn(tree, next)) {
+      if (!seen.has(child)) {
+        seen.add(child);
+        found.push(child);
+        queue.push(child);
+      }
+    }
+  }
+  return found;
+}
+function ancestorsIn(tree, pid, root) {
+  const chain = [];
+  const seen = new Set([pid]);
+  let parent = tree.get(pid)?.parent;
+  while (parent !== undefined && !seen.has(parent)) {
+    chain.push(parent);
+    if (parent === root) {
+      break;
+    }
+    seen.add(parent);
+    parent = tree.get(parent)?.parent;
+  }
+  return chain;
+}
+function readCommandLine(command) {
+  const words = commandWords(command);
+  const executable = words[0] === undefined ? "" : basename2(words[0].replaceAll("\\", "/"));
+  const at = words.indexOf("--path");
+  let projectPath = null;
+  if (at !== -1 && at + 1 < words.length) {
+    const taken = [];
+    for (const word of words.slice(at + 1)) {
+      if (taken.length > 0 && (word.startsWith("-") || /^[a-z]+:\/\//.test(word))) {
+        break;
+      }
+      taken.push(word);
+    }
+    projectPath = taken.join(" ");
+  }
+  return {
+    executable,
+    projectPath,
+    editor: words.some((word) => word === "-e" || word === "--editor")
+  };
+}
+function commandWords(command) {
+  const words = [];
+  let word = "";
+  let quoted = false;
+  let started = false;
+  for (const char of command) {
+    if (char === '"') {
+      quoted = !quoted;
+      started = true;
+    } else if (!quoted && /\s/.test(char)) {
+      if (started) {
+        words.push(word);
+        word = "";
+        started = false;
+      }
+    } else {
+      word += char;
+      started = true;
+    }
+  }
+  if (started) {
+    words.push(word);
+  }
+  return words;
+}
+async function askWindows() {
+  const { stdout } = await run5("powershell.exe", [
+    "-NoProfile",
+    "-NonInteractive",
+    "-Command",
+    'Get-CimInstance Win32_Process | ForEach-Object { "$($_.ProcessId) $($_.ParentProcessId) $($_.CommandLine)" }'
+  ], { timeout: ASK_TIMEOUT_MS, windowsHide: true, maxBuffer: 16 * 1024 * 1024 });
+  return stdout;
+}
+async function askPosix() {
+  const { stdout } = await run5("ps", ["-e", "-o", "pid=,ppid=,args="], {
+    timeout: ASK_TIMEOUT_MS,
+    maxBuffer: 16 * 1024 * 1024
+  });
+  return stdout;
+}
+var run5, ASK_TIMEOUT_MS = 15000;
+var init_process_children = __esm(() => {
+  run5 = promisify5(execFile5);
+});
+
+// src/process-time.ts
+import { execFile as execFile6 } from "node:child_process";
+import { promisify as promisify6 } from "node:util";
 async function cpuSecondsOf(pid) {
   try {
-    return process.platform === "win32" ? await askWindows(pid) : await askPosix(pid);
+    return process.platform === "win32" ? await askWindows2(pid) : await askPosix2(pid);
   } catch {
     return;
   }
 }
-async function askWindows(pid) {
-  const { stdout } = await run5("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", `(Get-Process -Id ${pid}).CPU`], { timeout: ASK_TIMEOUT_MS, windowsHide: true });
+async function askWindows2(pid) {
+  const { stdout } = await run6("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", `(Get-Process -Id ${pid}).CPU`], { timeout: ASK_TIMEOUT_MS2, windowsHide: true });
   const seconds = Number(stdout.trim().replace(",", "."));
   return Number.isFinite(seconds) ? seconds : undefined;
 }
-async function askPosix(pid) {
-  const { stdout } = await run5("ps", ["-o", "time=", "-p", String(pid)], { timeout: ASK_TIMEOUT_MS });
+async function askPosix2(pid) {
+  const { stdout } = await run6("ps", ["-o", "time=", "-p", String(pid)], { timeout: ASK_TIMEOUT_MS2 });
   return secondsFromClock(stdout.trim());
 }
 function secondsFromClock(printed) {
@@ -36447,9 +36588,9 @@ function secondsFromClock(printed) {
   const extra = days === null ? 0 : Number(days) * 86400;
   return Number.isFinite(extra) ? seconds + extra : undefined;
 }
-var run5, ASK_TIMEOUT_MS = 6000;
+var run6, ASK_TIMEOUT_MS2 = 6000;
 var init_process_time = __esm(() => {
-  run5 = promisify5(execFile5);
+  run6 = promisify6(execFile6);
 });
 
 // src/project-scan.ts
@@ -36626,7 +36767,7 @@ var init_restart_note = __esm(() => {
 });
 
 // src/runtime-client.ts
-import { existsSync as existsSync13, readdirSync as readdirSync5, readFileSync as readFileSync15, unlinkSync } from "node:fs";
+import { existsSync as existsSync13, readdirSync as readdirSync5, readFileSync as readFileSync15, statSync as statSync3, unlinkSync } from "node:fs";
 import { createConnection as createConnection3 } from "node:net";
 import { tmpdir as tmpdir4 } from "node:os";
 import { join as join17, resolve as resolve4 } from "node:path";
@@ -36647,6 +36788,15 @@ function runtimeDirectories(variables = process.env) {
   }
   return [...new Set(candidates.map((path) => resolve4(path)))];
 }
+function errorReportOf(pid, directories = runtimeDirectories()) {
+  for (const directory of directories) {
+    const path = join17(directory, `runtime-${pid}.log`);
+    if (existsSync13(path)) {
+      return path;
+    }
+  }
+  return null;
+}
 function processAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -36735,6 +36885,11 @@ function announcedIn(directory) {
   }
   const found = [];
   for (const entry of readdirSync5(directory)) {
+    const report = ERROR_REPORT_PATTERN.exec(entry);
+    if (report) {
+      sweepErrorReport(join17(directory, entry), Number.parseInt(report[1] ?? "", 10));
+      continue;
+    }
     const match = ANNOUNCEMENT_PATTERN.exec(entry);
     if (!match) {
       continue;
@@ -36756,6 +36911,16 @@ function announcedIn(directory) {
   }
   return found;
 }
+function sweepErrorReport(path, pid, now = Date.now()) {
+  if (processAlive(pid)) {
+    return;
+  }
+  try {
+    if (now - statSync3(path).mtimeMs >= ERROR_REPORT_KEEP_MS) {
+      unlinkSync(path);
+    }
+  } catch {}
+}
 async function announcedSince(projectPath, before, waiting = {}) {
   const wanted = resolve4(projectPath);
   const directories = waiting.directories ?? runtimeDirectories();
@@ -36926,16 +37091,18 @@ function runtimeRequest(endpoint, command, params, timeoutMs) {
     });
   });
 }
-var RUNTIME_PROTOCOL = 2, ANNOUNCEMENT_PATTERN, GONE_WINDOW_MS = 120000, GONE_KEPT = 32, gone, LOOK_EVERY_MS = 50, ANNOUNCE_BUDGET_MS = 5000, nextRequestId = 1;
+var RUNTIME_PROTOCOL = 2, ANNOUNCEMENT_PATTERN, ERROR_REPORT_PATTERN, ERROR_REPORT_KEEP_MS, GONE_WINDOW_MS = 120000, GONE_KEPT = 32, gone, LOOK_EVERY_MS = 50, ANNOUNCE_BUDGET_MS = 5000, nextRequestId = 1;
 var init_runtime_client = __esm(() => {
   ANNOUNCEMENT_PATTERN = /^runtime-(\d+)\.json$/;
+  ERROR_REPORT_PATTERN = /^runtime-(\d+)\.log$/;
+  ERROR_REPORT_KEEP_MS = 60 * 60 * 1000;
   gone = [];
 });
 
 // src/run-record.ts
 import { execFileSync } from "node:child_process";
-import { mkdirSync as mkdirSync9, openSync, readdirSync as readdirSync6, readFileSync as readFileSync16, rmSync as rmSync9, statSync as statSync3, writeFileSync as writeFileSync11 } from "node:fs";
-import { basename as basename2, join as join18 } from "node:path";
+import { mkdirSync as mkdirSync9, openSync, readdirSync as readdirSync6, readFileSync as readFileSync16, rmSync as rmSync9, statSync as statSync4, writeFileSync as writeFileSync11 } from "node:fs";
+import { basename as basename3, join as join18 } from "node:path";
 function runsDirectory() {
   return join18(runtimeDirectory(), "runs");
 }
@@ -37151,7 +37318,7 @@ function judgeRun(record, running, needed) {
   if (running.startedAt !== undefined && running.startedAt - record.startedAt > SAME_RUN_WINDOW_MS) {
     return false;
   }
-  const engine = record.command === undefined ? null : basename2(record.command);
+  const engine = record.command === undefined ? null : basename3(record.command);
   const said = process.platform === "win32" ? running.text.toLowerCase() : running.text;
   const wanted = engine === null || process.platform !== "win32" ? engine : engine.toLowerCase();
   if (wanted !== null && !said.includes(wanted)) {
@@ -37182,7 +37349,7 @@ function clearRunRecord(ours = () => true) {
 }
 function ageMs(path, now) {
   try {
-    return now - statSync3(path).mtimeMs;
+    return now - statSync4(path).mtimeMs;
   } catch {
     return 0;
   }
@@ -37216,7 +37383,7 @@ var init_run_record = __esm(() => {
 });
 
 // src/server.ts
-import { execFile as execFile6, spawn } from "node:child_process";
+import { execFile as execFile7, spawn } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import {
   appendFileSync,
@@ -37231,10 +37398,10 @@ import {
   readSync
 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
-import { basename as basename3, dirname as dirname11, join as join19, normalize as normalize3, relative as relative3 } from "node:path";
+import { basename as basename4, dirname as dirname11, join as join19, normalize as normalize3, relative as relative3 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
-import { promisify as promisify6 } from "node:util";
+import { promisify as promisify7 } from "node:util";
 function patienceForFrames(frames, atLeast) {
   return Math.max(atLeast, frames / SLOWEST_FRAME_RATE * 1000 + atLeast);
 }
@@ -37285,6 +37452,45 @@ function endedPreviousRun(ended) {
   }
   return ended.pid ?? true;
 }
+function engineNamesOf(executable) {
+  return CONSOLE_WRAPPER.test(executable) ? [executable, executable.replace(CONSOLE_WRAPPER, "$1")] : [executable];
+}
+function gameBetween(tree, pid, root, games) {
+  return ancestorsIn(tree, pid, root).some((one) => one !== root && games.has(one));
+}
+function endChildrenAmong(started) {
+  if (started.unknown !== false) {
+    return { ended: [], left: [], unknown: started.unknown };
+  }
+  for (const game of started.games) {
+    try {
+      process.kill(game.pid);
+    } catch {}
+  }
+  return { ended: started.games, left: [...started.others], unknown: false };
+}
+function aboutTheChildren(ended, throughEditor) {
+  const reaches = "andChildren ends what it started that is a game of this project: announced as one, or this project's engine run with --path on it.";
+  if (ended === null) {
+    return throughEditor ? `Anything that game started for itself, with OS.create_process or otherwise, is not the editor's to stop and was not signalled; ${reaches}` : `Anything that game started for itself, with OS.create_process or otherwise, is a separate process this stop did not signal; ${reaches}`;
+  }
+  if (ended.unknown === "platform") {
+    return "andChildren was asked for and this platform would not list what the game had started, so nothing else was ended.";
+  }
+  if (ended.unknown === "no process") {
+    return "andChildren was asked for and this run has no process id to list under: the editor plays it and its game announced none, so nothing else was ended.";
+  }
+  const counted = (n) => `${n} ${n === 1 ? "process" : "processes"}`;
+  const announced = ended.ended.filter((one) => one.how === "announced").length;
+  const byCommandLine = ended.ended.length - announced;
+  const how = [
+    announced === 0 ? "" : `${announced} announced as ${announced === 1 ? "a game" : "games"} of this project`,
+    byCommandLine === 0 ? "" : `${byCommandLine} this project's engine run with --path on it, by ${byCommandLine === 1 ? "its" : "their"} command line`
+  ].filter((part) => part !== "").join(" and ");
+  const endedToo = ended.ended.length === 0 ? "The game had started nothing that is a game of this project, announced as one or this project's engine run with --path on it, so nothing else was ended." : `${counted(ended.ended.length)} the game had started for itself ${ended.ended.length === 1 ? "was" : "were"} ended with it, named under endedChildren with what identified ${ended.ended.length === 1 ? "it" : "each"} under identifiedBy: ${how}.`;
+  const leftToo = ended.left.length === 0 ? "" : ` ${counted(ended.left.length)} it had started ${ended.left.length === 1 ? "was" : "were"} left, named under childrenLeft: neither announced as a game of this project nor this project's engine run with --path on it, so what ${ended.left.length === 1 ? "it is" : "they are"} cannot be told from here.`;
+  return `${endedToo}${leftToo}`;
+}
 function endedToStartThis(ended) {
   if (ended === null) {
     return "";
@@ -37984,7 +38190,7 @@ class GodotServer {
         return op === "restart" ? await this.handleRestartEditor() : await this.handleLaunchEditor(args);
       case "editor_run":
         if (op === "stop") {
-          return await this.handleStopProject();
+          return await this.handleStopProject(args);
         }
         if (op === "wait") {
           return await this.handleWaitForRun(args);
@@ -38348,7 +38554,7 @@ class GodotServer {
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
-      name: typeof name === "string" && name !== "" ? name : basename3(project.value.path),
+      name: typeof name === "string" && name !== "" ? name : basename4(project.value.path),
       path: project.value.path,
       mainScene: typeof mainScene === "string" && mainScene !== "" ? mainScene : null,
       godotVersion: await this.godotVersion(engine.value),
@@ -38427,7 +38633,7 @@ class GodotServer {
     const log = new GameLog;
     let exitCode = 0;
     try {
-      const { stdout, stderr } = await run6(engine.value, exportArgs, { timeout: 300000 });
+      const { stdout, stderr } = await run7(engine.value, exportArgs, { timeout: 300000 });
       log.append("stdout", stdout);
       log.append("stderr", stderr);
     } catch (error) {
@@ -38624,7 +38830,7 @@ class GodotServer {
   }
   async godotVersion(godotPath) {
     try {
-      const { stdout } = await run6(godotPath, ["--version"], { timeout: 1e4 });
+      const { stdout } = await run7(godotPath, ["--version"], { timeout: 1e4 });
       this.lastGodotVersion = stdout.trim();
       return this.lastGodotVersion;
     } catch (error) {
@@ -39160,6 +39366,7 @@ class GodotServer {
     });
     this.logDebug(`Running Godot project: ${engine.value} ${cmdArgs.join(" ")}`);
     const started = this.spawnKeptGame(engine.value, cmdArgs, project.value.path);
+    started.announcedBefore = alreadyPlaying;
     this.activeProcess = started;
     const spawnedInstead = this.godotBridge.isConnected() && editorWouldPlay && given.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." : "";
     const endedForThis = endedToStartThis(ended);
@@ -39209,7 +39416,7 @@ class GodotServer {
       }
     });
     const going = this.currentRun();
-    if (endpoint !== null && going?.throughEditor === true && going.announcedPid === undefined) {
+    if (endpoint !== null && going !== null && going.announcedPid === undefined) {
       going.announcedPid = endpoint.pid;
     }
     return runtimeVerdict(endpoint, {
@@ -39280,7 +39487,11 @@ class GodotServer {
     });
   }
   drainEditorOutput(game) {
-    if (!game.throughEditor || !this.dapClient) {
+    if (!game.throughEditor) {
+      return;
+    }
+    this.drainErrorReport(game);
+    if (!this.dapClient) {
       return;
     }
     if (game.transcript === null) {
@@ -39295,9 +39506,44 @@ class GodotServer {
     }
     this.recordWhatItBrokeOn(game);
   }
+  drainErrorReport(game) {
+    if (game.errorReport === undefined) {
+      const its = this.announcedPidOf(game);
+      const found = its === undefined ? null : errorReportOf(its);
+      if (found === null) {
+        return;
+      }
+      game.errorReport = found;
+      game.errorReportOffset = 0;
+    }
+    let handle;
+    try {
+      handle = openSync2(game.errorReport, "r");
+    } catch {
+      return;
+    }
+    try {
+      const from = game.errorReportOffset ?? 0;
+      const size = fstatSync(handle).size;
+      if (size <= from) {
+        return;
+      }
+      const buffer = Buffer.alloc(size - from);
+      const read = readSync(handle, buffer, 0, buffer.length, from);
+      game.errorReportOffset = from + read;
+      const reported = buffer.subarray(0, read);
+      if (game.transcript !== null) {
+        appendFileSync(game.transcript, reported);
+      } else {
+        game.log.append("stderr", reported);
+      }
+    } finally {
+      closeSync(handle);
+    }
+  }
   recordWhatItBrokeOn(game) {
     const halt = this.dapClient?.whereItStopped() ?? null;
-    if (halt?.reason !== "exception" || halt.text === "" || game.brokeOn === halt.text) {
+    if (halt?.reason !== "exception" || halt.text === "" || game.brokeOn === halt.text || game.errorReport !== undefined) {
       return;
     }
     game.brokeOn = halt.text;
@@ -39495,18 +39741,93 @@ class GodotServer {
     this.activeProcess = picked;
   }
   announcedPidOf(run, announced) {
-    if (!run.throughEditor || run.announcedPid !== undefined) {
+    if (run.announcedPid !== undefined) {
+      return run.announcedPid;
+    }
+    const ours = this.announcedOfTheRunsProject(run, announced ?? runtimesAnnounced().running);
+    if (run.pid !== null && ours.some((one) => one.pid === run.pid)) {
+      run.announcedPid = run.pid;
       return run.announcedPid;
     }
     const before = run.announcedBefore ?? new Set;
-    const fresh = this.allAnnouncedForOurProject(announced ?? runtimesAnnounced().running).filter((one) => !before.has(one.pid));
-    const candidates = fresh.filter((one) => this.playedByOurEditor(one, run.projectPath));
+    const candidates = ours.filter((one) => !before.has(one.pid) && this.isTheGameOf(run, one, run.projectPath));
     const theOne = candidates.length === 1 ? candidates[0] : undefined;
     if (theOne !== undefined) {
       run.announcedPid = theOne.pid;
     }
     return run.announcedPid;
   }
+  ownGameAmong(running, projectPath) {
+    const run = this.currentRun();
+    if (run === null || !stillRunning(run)) {
+      return;
+    }
+    if (projectPath !== undefined && run.projectPath !== null && !isSameDirectory(run.projectPath, projectPath)) {
+      return;
+    }
+    const its = this.announcedPidOf(run, running);
+    return its !== undefined && running.some((one) => one.pid === its) ? its : undefined;
+  }
+  async ownGameThroughTheTree(running, projectPath) {
+    const run = this.currentRun();
+    if (run === null || !stillRunning(run) || run.announcedPid !== undefined) {
+      return;
+    }
+    if (projectPath !== undefined && run.projectPath !== null && !isSameDirectory(run.projectPath, projectPath)) {
+      return;
+    }
+    const its = await this.tiedThroughTheTree(run, running);
+    return its !== undefined && running.some((one) => one.pid === its) ? its : undefined;
+  }
+  async tiedThroughTheTree(run, announced) {
+    if (run.announcedPid !== undefined) {
+      return run.announcedPid;
+    }
+    const ours = this.announcedOfTheRunsProject(run, announced);
+    if (ours.length === 0) {
+      return;
+    }
+    const tree = await processTree();
+    if (tree === undefined) {
+      return;
+    }
+    return this.tieThroughTheTree(run, tree, new Set(ours.map((one) => one.pid)));
+  }
+  async gameProcessOf(run) {
+    if (run.gamePid !== undefined) {
+      return run.gamePid;
+    }
+    const announced = runtimesAnnounced().running;
+    const tied = await this.tiedThroughTheTree(run, announced);
+    if (tied !== undefined) {
+      return tied;
+    }
+    const tree = await processTree();
+    if (tree === undefined) {
+      return;
+    }
+    const found = this.gameByCommandLineIn(run, tree);
+    if (found !== undefined) {
+      run.gamePid = found;
+    }
+    return found;
+  }
+  tieThroughTheTree(run, tree, games) {
+    const root = run.pid ?? (run.throughEditor ? this.godotBridge.getStatus().editorPid : undefined);
+    if (root === undefined) {
+      return;
+    }
+    if (games.has(root)) {
+      run.announcedPid = root;
+      return root;
+    }
+    const nearest = descendantsIn(tree, root).filter((one) => games.has(one) && !gameBetween(tree, one, root, games));
+    const theOne = nearest.length === 1 ? nearest[0] : undefined;
+    if (theOne !== undefined) {
+      run.announcedPid = theOne;
+    }
+    return theOne;
+  }
   playedByOurEditor(endpoint, projectPath) {
     const editor = this.godotBridge.getStatus().editorPid;
     if (editor === undefined) {
@@ -39583,6 +39904,13 @@ class GodotServer {
   announcedForOurProject(announced) {
     return this.allAnnouncedForOurProject(announced)[0] ?? null;
   }
+  announcedOfTheRunsProject(run, announced) {
+    const project = run.projectPath;
+    if (project === null) {
+      return this.allAnnouncedForOurProject(announced);
+    }
+    return announced.filter((one) => one.project.path !== "" && isSameDirectory(project, one.project.path));
+  }
   allAnnouncedForOurProject(announced) {
     const status = this.godotBridge.getStatus();
     const mine = this.ownProject ?? (status.connected ? status.projectPath ?? null : null);
@@ -39697,7 +40025,8 @@ class GodotServer {
     });
     const hold = await this.holdOf(run, going);
     const wanted = readBoolean(args, "cpu") ?? false;
-    const processToAsk = run.pid ?? this.announcedPidOf(run) ?? null;
+    const announced = this.announcedPidOf(run);
+    const processToAsk = wanted ? announced ?? (stillRunning(run) ? await this.gameProcessOf(run) : undefined) ?? run.pid ?? null : null;
     const cpuSeconds = wanted && processToAsk !== null && stillRunning(run) ? await cpuSecondsOf(processToAsk) : undefined;
     const notes = [];
     if (wanted && cpuSeconds === undefined && stillRunning(run)) {
@@ -39728,7 +40057,7 @@ class GodotServer {
       running: going,
       exitCode: run.exitCode,
       through: run.throughEditor ? "editor" : "gdharness",
-      pid: run.pid ?? this.announcedPidOf(run) ?? null,
+      pid: run.pid ?? announced ?? run.announcedPid ?? null,
       errors: run.log.count("error"),
       warnings: run.log.count("warning"),
       clean: run.consoleLost === true ? undefined : run.log.count("error") === 0,
@@ -39746,7 +40075,7 @@ class GodotServer {
       entries: forAnswer(selected.entries)
     });
   }
-  async handleStopProject() {
+  async handleStopProject(args) {
     await this.pickUpWhatTheEditorIsPlaying();
     const stopped = this.currentRun();
     if (!stopped) {
@@ -39755,21 +40084,98 @@ class GodotServer {
     this.drainEditorOutput(stopped);
     this.drainTranscript(stopped);
     const wasRunning = await this.runStillGoing(stopped);
+    const endedPid = stopped.pid ?? this.announcedPidOf(stopped) ?? null;
+    const children = readBoolean(args, "andChildren") === true && wasRunning ? await this.whatTheRunStarted(stopped) : null;
     this.logDebug("Stopping the running game");
     await this.endActiveGame("editor_run stop");
+    const ended = children === null ? null : endChildrenAmong(children);
     return this.jsonTextResponse({
       stopped: true,
       through: stopped.throughEditor ? "editor" : "gdharness",
-      endedPid: stopped.pid ?? this.announcedPidOf(stopped) ?? null,
+      endedPid,
+      ...ended === null ? {} : {
+        endedChildren: ended.ended.map((one) => one.pid),
+        identifiedBy: ended.ended.length === 0 ? undefined : Object.fromEntries(ended.ended.map((one) => [String(one.pid), one.identifiedBy])),
+        childrenLeft: ended.left.length === 0 ? undefined : ended.left,
+        childrenUnknown: ended.unknown === false ? undefined : true
+      },
       exitedBeforeStop: stopped.exitCode !== null || !wasRunning,
       exitCode: stopped.exitCode,
       errors: stopped.log.count("error"),
       warnings: stopped.log.count("warning"),
       clean: stopped.log.count("error") === 0,
-      note: !wasRunning ? "This run was over before the stop, so nothing was ended here: editor_output has what it printed and how it ended. Anything that game started for itself, with OS.create_process or otherwise, is a separate process and may still be running." : stopped.throughEditor ? "The editor was asked to stop the scene it is playing. Anything that game started for itself, with OS.create_process or otherwise, is not the editor's to stop and is still running." : "The process named under endedPid was ended. Anything that game started for itself, with OS.create_process or otherwise, is a separate process and is still running.",
+      note: !wasRunning ? "This run was over before the stop, so nothing was ended here: editor_output has what it printed and how it ended. Anything that game started for itself, with OS.create_process or otherwise, is a separate process and may still be running." : `${stopped.throughEditor ? "The editor was asked to stop the scene it is playing." : "The process named under endedPid was ended."} ${aboutTheChildren(ended, stopped.throughEditor)}`,
       entries: forAnswer(stopped.log.select({ severity: "warning", sinceLastCall: false, limit: 200 }).entries)
     });
   }
+  async whatTheRunStarted(run) {
+    const tree = await processTree();
+    if (tree === undefined) {
+      return { unknown: "platform" };
+    }
+    const announced = this.announcedOfTheRunsProject(run, runtimesAnnounced().running);
+    const games = new Set(announced.map((one) => one.pid));
+    const own = this.announcedPidOf(run, announced) ?? this.tieThroughTheTree(run, tree, games) ?? run.gamePid ?? this.gameByCommandLineIn(run, tree);
+    if (own !== undefined && run.announcedPid === undefined) {
+      run.gamePid = own;
+    }
+    const roots = [run.pid, own].filter((one) => one !== null && one !== undefined);
+    if (roots.length === 0) {
+      return { unknown: "no process" };
+    }
+    const under = new Set(roots.flatMap((root) => descendantsIn(tree, root)));
+    for (const root of roots) {
+      under.delete(root);
+    }
+    const started = [...under].sort((a, b) => a - b);
+    const found = [];
+    const others = [];
+    for (const pid of started) {
+      if (games.has(pid)) {
+        found.push({ pid, how: "announced", identifiedBy: "announced as a game of this project" });
+        continue;
+      }
+      const engines = [...roots, ...roots.flatMap((root) => ancestorsIn(tree, pid, root))];
+      const read = this.theProjectsEngine(run, tree, pid, engines);
+      if (read !== null) {
+        found.push({
+          pid,
+          how: "command line",
+          identifiedBy: `${read.executable} run with --path ${read.projectPath ?? ""}, this project's engine on this project`
+        });
+        continue;
+      }
+      others.push(pid);
+    }
+    return { unknown: false, games: found, others };
+  }
+  theProjectsEngine(run, tree, pid, engines) {
+    const project = run.projectPath;
+    if (project === null) {
+      return null;
+    }
+    const read = readCommandLine(tree.get(pid)?.command ?? "");
+    if (read.executable === "" || read.editor || read.projectPath === null || !isSameDirectory(read.projectPath, project)) {
+      return null;
+    }
+    const names = engines.flatMap((one) => engineNamesOf(readCommandLine(tree.get(one)?.command ?? "").executable));
+    const sameName = (one, other) => one !== "" && (process.platform === "win32" ? one.toLowerCase() === other.toLowerCase() : one === other);
+    return names.some((name) => sameName(name, read.executable)) ? read : null;
+  }
+  gameByCommandLineIn(run, tree) {
+    const root = run.pid ?? (run.throughEditor ? this.godotBridge.getStatus().editorPid : undefined);
+    if (root === undefined || run.projectPath === null) {
+      return;
+    }
+    const rootRead = readCommandLine(tree.get(root)?.command ?? "");
+    const rootIsTheGame = !rootRead.editor && !CONSOLE_WRAPPER.test(rootRead.executable) && rootRead.projectPath !== null && isSameDirectory(rootRead.projectPath, run.projectPath);
+    if (rootIsTheGame) {
+      return;
+    }
+    const isEngine = (pid) => this.theProjectsEngine(run, tree, pid, [root]) !== null;
+    const nearest = descendantsIn(tree, root).filter((pid) => isEngine(pid) && !ancestorsIn(tree, pid, root).some((one) => one !== root && isEngine(one)));
+    return nearest.length === 1 ? nearest[0] : undefined;
+  }
   async handleRescanFilesystem(args) {
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 30000;
     const started = Date.now();
@@ -39964,10 +40370,15 @@ class GodotServer {
   async handleRuntimeCommand(command, args, timeoutMs = this.runtimeTimeoutMs()) {
     const { op: _op, projectPath, pid, ...params } = asParams(args);
     const announced = runtimesAnnounced();
-    const choice = chooseRuntime(announced.running, typeof projectPath === "string" ? projectPath : this.ownProject ?? undefined, announced.unspoken, typeof pid === "number" ? pid : undefined);
+    const wanted = typeof projectPath === "string" ? projectPath : this.ownProject ?? undefined;
+    const own = typeof pid === "number" ? undefined : this.ownGameAmong(announced.running, wanted) ?? await this.ownGameThroughTheTree(announced.running, wanted);
+    const choice = chooseRuntime(announced.running, wanted, announced.unspoken, typeof pid === "number" ? pid : own);
     if ("problem" in choice) {
       return this.createErrorResponse(choice.problem);
     }
+    const ofProject = announced.running.filter((one) => wanted === undefined || isSameDirectory(one.project.path, wanted));
+    const chosenAmongSeveral = own !== undefined && ofProject.length > 1;
+    const answeredBy = chosenAmongSeveral ? { answeredBy: own } : {};
     const held = this.knownHoldOn(choice.endpoint, announced.running);
     if (held !== null) {
       return this.createErrorResponse(`The game (pid ${choice.endpoint.pid}) is held by the editor's debugger, ${describeHalt(held)}, and answers no runtime call while it is.`, [
@@ -39986,7 +40397,7 @@ class GodotServer {
       }
       const { id: _id, ...payload } = reply.payload;
       if (!expectsScreenshot) {
-        return this.jsonTextResponse(payload);
+        return this.jsonTextResponse({ ...payload, ...answeredBy });
       }
       const returnedPath = readString(payload, "path");
       if (readString(payload, "type") !== "screenshot_file" || !returnedPath || !screenshotPath) {
@@ -39998,7 +40409,10 @@ class GodotServer {
       const dimensions = `${readNumber(payload, "width") ?? 0}x${readNumber(payload, "height") ?? 0} ${readString(payload, "format") ?? "unknown"}`;
       return {
         content: [
-          { type: "text", text: `Screenshot captured: ${dimensions}` },
+          {
+            type: "text",
+            text: `Screenshot captured: ${dimensions}${chosenAmongSeveral ? ` from pid ${own}, the game this server holds` : ""}`
+          },
           { type: "image", data: readFileSync17(screenshotPath).toString("base64"), mimeType: "image/png" }
         ]
       };
@@ -40065,7 +40479,7 @@ async function runGodotServer() {
   const server = new GodotServer;
   await server.run();
 }
-var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run6, __dirname2, EDITOR_RESTART_TIMEOUT_MS = 90000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, CACHE_WRITE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/";
+var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run7, __dirname2, EDITOR_RESTART_TIMEOUT_MS = 90000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, CONSOLE_WRAPPER, VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, CACHE_WRITE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/";
 var init_server3 = __esm(() => {
   init_mcp();
   init_stdio2();
@@ -40086,6 +40500,7 @@ var init_server3 = __esm(() => {
   init_lsp_client();
   init_paths();
   init_ports();
+  init_process_children();
   init_process_time();
   init_project_scan();
   init_resources();
@@ -40097,8 +40512,9 @@ var init_server3 = __esm(() => {
   init_setup();
   init_tool_definitions();
   init_update_check();
-  run6 = promisify6(execFile6);
+  run7 = promisify7(execFile7);
   __dirname2 = dirname11(fileURLToPath4(import.meta.url));
+  CONSOLE_WRAPPER = /_console(\.exe)?$/i;
   VALUE_NAMES = {
     string: "a string",
     number: "a number",
@@ -41608,8 +42024,10 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
 
 - ${projectPathSentence()}. The \`runtime_*\` and \`debug_*\` ones pick between running
   games instead, by \`projectPath\`, or by \`pid\` when several run from one project, as a bench
-  and its workers do; the others answer about the editor this server is connected to. There is no
-  ambient project, and an argument a tool does not declare is refused rather than ignored.
+  and its workers do: without \`pid\` the game this server started or plays is the one asked, and
+  the answer says so under \`answeredBy\`; the others answer about the editor this server is
+  connected to. There is no ambient project, and an argument a tool does not declare is refused
+  rather than ignored.
 - \`editor_status\` says whether an editor is connected and whether its addon matches the server.
   \`addonIsStale\` means they differ, and \`staleNote\` says which half is behind: an editor that
   needs restarting, or a server that needs reconnecting in your harness. Every answer that came
@@ -41621,7 +42039,9 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
   false is a runtime that is not coming and true is a game still on its way up.
 - Read \`editor_output\` after every run. It returns the engine's errors and warnings as entries
   with their backtraces, and a \`clean\` verdict, so a run that printed an error is one call away
-  from being known. For a long run it also names a transcript file: read that for output and this
+  from being known. For a run the editor plays, the errors come from the game through the runtime
+  addon, so a played game without the addon is judged on its prints alone and \`clean\` there says
+  less. For a long run it also names a transcript file: read that for output and this
   answer for state. Never decide a run has ended by watching the file stop growing, or a process
   list, or a timeout; a bench between prints looks exactly like a bench that died to everything else.
   \`endedBy\` says whether gdharness ended it, and \`running\` is asked of the operating system
@@ -41654,6 +42074,7 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
 | Where a 3D node is on screen | \`runtime_inspect\` \`rect\`, rather than unprojecting by hand |
 | Wait for something in a running game | \`runtime_wait\`, never a sleep; \`until\` with \`says\` for a panel that rebuilds its own labels |
 | Wait for a run to finish | \`editor_run wait\`, never a sleep or a shell loop on the pid: it answers as \`editor_output\` does, once the run is over |
+| End a bench and the workers it opened | \`editor_run stop\` with \`andChildren\`, never a process listing by scene name: it ends every process under the run's, to any depth, that is a game of the project, announced as one or the project's engine run with \`--path\` on it, names them under \`endedChildren\` with what identified each, and leaves and names any other |
 | A picture, for a person who asked to see one | \`runtime_capture\` |
 
 These need the runtime autoload, which \`gdharness setup\` registers. \`runtime_capture\` needs a