gdharness 1.0.29 → 1.0.31

package/build/cli.js

@@ -204,7 +204,9 @@ function ancestorsIn(tree, pid, root) {
   return chain;
 }
 function readCommandLine(command) {
-  const words = commandWords(command);
+  const all = commandWords(command);
+  const separator = all.findIndex((word) => word === "--" || word === "++");
+  const words = separator === -1 ? all : all.slice(0, separator);
   const executable = words[0] === undefined ? "" : basename(words[0].replaceAll("\\", "/"));
   const at = words.indexOf("--path");
   let projectPath = null;
@@ -216,7 +218,7 @@ function readCommandLine(command) {
       }
       taken.push(word);
     }
-    projectPath = taken.join(" ");
+    projectPath = taken.join(" ").replaceAll("%20", " ");
   }
   return {
     executable,
@@ -16356,6 +16358,12 @@ var init_tool_definitions = __esm(() => {
           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."
+        },
+        pid: {
+          type: "integer",
+          minimum: 1,
+          ops: ["stop"],
+          description: "stop: a game of this project that no server here is holding, by its process id as editor_status lists it under runtimes: one a server before a reconnect started and left no note for, or one started some other way. It is ended only when it announced itself for this project and the operating system describes it as this project's engine run, --path on the project and no editor flag, started before it announced; otherwise nothing is signalled and the answer says which of those failed. The run this server holds is ended the ordinary way whether or not its number is given."
         }
       },
       requires: [],
@@ -16365,7 +16373,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: for a run the editor plays, the number its game announced under, read at the stop rather than remembered, and the operating system hands a freed number to the next process, so it can equal the game before it. A game that started processes of its own keeps them unless andChildren says to end those too",
+          summary: "end the run and answer with what it printed last, naming the process ended under endedPid: for a run the editor plays, the number its game announced under, read at the stop rather than remembered, and the operating system hands a freed number to the next process, so it can equal the game before it. A game that started processes of its own keeps them unless andChildren says to end those too. stopped is false, with the number under notSignalled, when that number no longer answers as the process the run was started as and nothing was signalled",
           requires: []
         },
         check: {
@@ -31703,8 +31711,13 @@ function parseAnnouncement(file, pid) {
     name: readString(project, "name") ?? "",
     path: readString(project, "path") ?? ""
   };
+  let announcedAt;
+  try {
+    announcedAt = statSync5(file).mtimeMs;
+  } catch {}
+  const when = announcedAt === undefined ? {} : { announcedAt };
   if (protocol !== RUNTIME_PROTOCOL) {
-    return { kind: "unspoken", unspoken: { pid, protocol: protocol ?? 0, project: named } };
+    return { kind: "unspoken", unspoken: { pid, protocol: protocol ?? 0, project: named, ...when } };
   }
   const editorPid = readNumber(fields, "editor_pid");
   return {
@@ -31715,7 +31728,8 @@ function parseAnnouncement(file, pid) {
       address,
       project: named,
       file,
-      ...editorPid !== undefined && Number.isInteger(editorPid) && editorPid > 0 ? { editorPid } : {}
+      ...editorPid !== undefined && Number.isInteger(editorPid) && editorPid > 0 ? { editorPid } : {},
+      ...when
     }
   };
 }
@@ -37730,6 +37744,72 @@ var init_lsp_client = __esm(() => {
   init_ports();
 });
 
+// src/outside.ts
+import { spawn } from "node:child_process";
+import { fileURLToPath as fileURLToPath5 } from "node:url";
+function changesFrom(env, base) {
+  const changes = {};
+  if (env === undefined) {
+    return changes;
+  }
+  for (const [name, value] of Object.entries(env)) {
+    if (value !== undefined && base[name] !== value) {
+      changes[name] = value;
+    }
+  }
+  for (const name of Object.keys(base)) {
+    if (env[name] === undefined) {
+      changes[name] = null;
+    }
+  }
+  return changes;
+}
+function sendSpec(child, spec) {
+  child.stdin?.end(JSON.stringify(spec), "utf8");
+}
+function readLaunched(printed) {
+  const line = printed.split(`
+`).find((one) => one.trim() !== "")?.trim() ?? "";
+  const pid = /^pid (\d+)$/.exec(line);
+  if (pid?.[1] !== undefined) {
+    return { pid: Number(pid[1]) };
+  }
+  return { error: line.replace(/^error /, "") || "the launcher said nothing" };
+}
+async function launchOutsideTheTree(spec, runtime = process.execPath, keeper = KEEPER_SCRIPT) {
+  return await new Promise((resolve) => {
+    const launcher = spawn(runtime, [keeper, "launch"], {
+      stdio: ["pipe", "pipe", "pipe"],
+      windowsHide: true
+    });
+    sendSpec(launcher, {
+      command: spec.command,
+      args: spec.args,
+      envChanges: changesFrom(spec.env, process.env),
+      ...spec.run === undefined ? {} : { run: spec.run }
+    });
+    let printed = "";
+    let complained = "";
+    launcher.stdout.on("data", (chunk) => {
+      printed += chunk.toString();
+    });
+    launcher.stderr.on("data", (chunk) => {
+      complained += chunk.toString();
+    });
+    launcher.once("error", (error) => {
+      resolve({ error: `the launcher did not start: ${error.message}` });
+    });
+    launcher.once("close", () => {
+      const launched = readLaunched(printed);
+      resolve("error" in launched && complained.trim() !== "" ? { error: `${launched.error}: ${complained.trim()}` } : launched);
+    });
+  });
+}
+var KEEPER_SCRIPT;
+var init_outside = __esm(() => {
+  KEEPER_SCRIPT = fileURLToPath5(new URL("./keeper.js", import.meta.url));
+});
+
 // src/process-time.ts
 import { execFile as execFile6 } from "node:child_process";
 import { promisify as promisify6 } from "node:util";
@@ -37944,37 +38024,61 @@ var init_restart_note = __esm(() => {
 
 // src/run-record.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { mkdirSync as mkdirSync13, openSync as openSync2, readdirSync as readdirSync8, readFileSync as readFileSync20, rmSync as rmSync11, statSync as statSync7, writeFileSync as writeFileSync15 } from "node:fs";
-import { basename as basename3, join as join22 } from "node:path";
+import { createHash as createHash5 } from "node:crypto";
+import {
+  mkdirSync as mkdirSync13,
+  openSync as openSync2,
+  readdirSync as readdirSync8,
+  readFileSync as readFileSync20,
+  realpathSync as realpathSync3,
+  rmSync as rmSync11,
+  statSync as statSync7,
+  writeFileSync as writeFileSync15
+} from "node:fs";
+import { basename as basename3, dirname as dirname16, join as join22, resolve as resolve5 } from "node:path";
 function runsDirectory() {
   return join22(runtimeDirectory(), "runs");
 }
-function recordPath() {
-  return join22(runsDirectory(), "run.json");
+function realAsFarAsItExists(path) {
+  const missing = [];
+  let at = path;
+  for (;; ) {
+    try {
+      return join22(realpathSync3.native(at), ...missing);
+    } catch {
+      const parent = dirname16(at);
+      if (parent === at) {
+        return path;
+      }
+      missing.unshift(basename3(at));
+      at = parent;
+    }
+  }
+}
+function projectKey(projectPath) {
+  const real = realAsFarAsItExists(resolve5(projectPath)).replace(/[\\/]+$/, "");
+  const folded = process.platform === "win32" || process.platform === "darwin" ? real.toLowerCase() : real;
+  return createHash5("sha256").update(folded.replaceAll("\\", "/")).digest("hex").slice(0, 16);
 }
-function recordPaths() {
-  return runtimeDirectories().map((directory) => join22(directory, "runs", "run.json"));
+function runRecordPath(projectPath, directory = runtimeDirectory()) {
+  return join22(directory, "runs", `note-${projectKey(projectPath)}.json`);
 }
 function openTranscript(startedAt) {
   mkdirSync13(runsDirectory(), { recursive: true });
   const path = join22(runsDirectory(), `run-${startedAt}.log`);
   return { path, fd: openSync2(path, "a") };
 }
-function writeRunRecord(record) {
-  mkdirSync13(runsDirectory(), { recursive: true });
-  writeFileSync15(recordPath(), JSON.stringify(record, null, 2), "utf8");
-}
-function editorNotePath() {
-  return join22(runsDirectory(), "editor-run.json");
+function editorNotePath(projectPath, directory = runtimeDirectory()) {
+  return join22(directory, "runs", `editor-${projectKey(projectPath)}.json`);
 }
 function writeEditorRunNote(note) {
   mkdirSync13(runsDirectory(), { recursive: true });
-  writeFileSync15(editorNotePath(), JSON.stringify(note, null, 2), "utf8");
+  writeFileSync15(editorNotePath(note.projectPath), JSON.stringify(note, null, 2), "utf8");
 }
-function readEditorRunNote() {
+function readEditorRunNote(projectPath) {
   for (const directory of runtimeDirectories()) {
-    const note = editorNoteAt(join22(directory, "runs", "editor-run.json"));
-    if (note !== null) {
+    const note = editorNoteAt(editorNotePath(projectPath, directory)) ?? editorNoteAt(join22(directory, "runs", "editor-run.json"));
+    if (note !== null && isSameDirectory(note.projectPath, projectPath)) {
       return note;
     }
   }
@@ -37999,29 +38103,38 @@ function editorNoteAt(path) {
   }
   return { projectPath, transcript, startedAt };
 }
-function recordRunEnded(pid, ending) {
-  const path = recordPath();
-  const record = recordAt(path);
-  if (record === null || record.pid !== pid) {
-    return;
+function readRunRecord(projectPath) {
+  for (const directory of runtimeDirectories()) {
+    const own = recordAt(runRecordPath(projectPath, directory));
+    if (own !== null) {
+      return own;
+    }
+    const shared = recordAt(join22(directory, "runs", SHARED_NOTE));
+    if (shared !== null && shared.projectPath !== "" && isSameDirectory(shared.projectPath, projectPath)) {
+      return shared;
+    }
   }
-  const written = {
-    ...record,
-    ...ending.exitCode === null ? {} : { exitCode: ending.exitCode },
-    ...ending.exitSignal === null ? {} : { exitSignal: ending.exitSignal }
-  };
-  try {
-    writeFileSync15(path, JSON.stringify(written, null, 2), "utf8");
-  } catch {}
+  return null;
 }
-function readRunRecord() {
-  for (const path of recordPaths()) {
-    const record = recordAt(path);
-    if (record !== null) {
-      return record;
+function everyRunRecord() {
+  const found = [];
+  for (const directory of runtimeDirectories()) {
+    let entries;
+    try {
+      entries = readdirSync8(join22(directory, "runs"));
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (entry === SHARED_NOTE || entry.startsWith("note-") && entry.endsWith(".json")) {
+        const record = recordAt(join22(directory, "runs", entry));
+        if (record !== null) {
+          found.push(record);
+        }
+      }
     }
   }
-  return null;
+  return found.sort((one, other) => other.startedAt - one.startedAt);
 }
 function recordAt(path) {
   let parsed;
@@ -38180,7 +38293,7 @@ function judgeRun(record, running, needed) {
   if (wanted !== null && !said.includes(wanted)) {
     return false;
   }
-  if (running.kind === "commandLine" && AN_EDITOR.test(said)) {
+  if (running.kind === "commandLine" && readCommandLine(running.text).editor) {
     return false;
   }
   if (record.projectPath === "") {
@@ -38192,15 +38305,32 @@ function judgeRun(record, running, needed) {
   const project = process.platform === "win32" ? record.projectPath.toLowerCase() : record.projectPath;
   return said.includes(project);
 }
-function clearRunRecord(ours = () => true) {
-  for (const path of recordPaths()) {
-    const record = recordAt(path);
-    if (record === null || !ours(record)) {
-      continue;
+function stillTheAnnouncedGame(pid, projectPath, announcedAt) {
+  return judgeAnnouncedGame(runningAs(pid), projectPath, announcedAt);
+}
+function judgeAnnouncedGame(running, projectPath, announcedAt) {
+  if (running?.kind !== "commandLine" || running.startedAt === undefined) {
+    return null;
+  }
+  if (running.startedAt - announcedAt > STARTED_AFTER_ANNOUNCING_MS) {
+    return null;
+  }
+  const read = readCommandLine(running.text);
+  if (read.editor || read.projectPath === null || !isSameDirectory(read.projectPath, projectPath)) {
+    return null;
+  }
+  return read;
+}
+function clearRunRecord(projectPath) {
+  for (const directory of runtimeDirectories()) {
+    const shared = join22(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] : []]) {
+      try {
+        rmSync11(path, { force: true });
+      } catch {}
     }
-    try {
-      rmSync11(path);
-    } catch {}
   }
 }
 function ageMs(path, now) {
@@ -38212,7 +38342,7 @@ function ageMs(path, now) {
 }
 function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
   const directory = runsDirectory();
-  const keep = readRunRecord()?.transcript;
+  const kept = new Set(everyRunRecord().map((record) => record.transcript));
   let entries;
   try {
     entries = readdirSync8(directory);
@@ -38224,7 +38354,7 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
       continue;
     }
     const path = join22(directory, entry);
-    if (path === keep || ageMs(path, now) < keepMs) {
+    if (kept.has(path) || ageMs(path, now) < keepMs) {
       continue;
     }
     try {
@@ -38232,15 +38362,15 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
     } catch {}
   }
 }
-var AN_EDITOR, SAME_RUN_WINDOW_MS = 1e4;
+var SHARED_NOTE = "run.json", SAME_RUN_WINDOW_MS = 1e4;
 var init_run_record = __esm(() => {
+  init_paths();
   init_process_children();
   init_runtime_client();
-  AN_EDITOR = /(?:^|\s)(?:-e|--editor)(?:\s|$)/;
 });
 
 // src/server.ts
-import { execFile as execFile7, spawn } from "node:child_process";
+import { execFile as execFile7, spawn as spawn2 } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import {
   appendFileSync,
@@ -38259,9 +38389,9 @@ import {
   statSync as statSync8
 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
-import { basename as basename4, dirname as dirname16, extname as extname2, isAbsolute as isAbsolute3, join as join23, normalize as normalize3, relative as relative3 } from "node:path";
+import { basename as basename4, dirname as dirname17, extname as extname2, isAbsolute as isAbsolute3, join as join23, normalize as normalize3, relative as relative3 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
-import { fileURLToPath as fileURLToPath5 } from "node:url";
+import { fileURLToPath as fileURLToPath6 } from "node:url";
 import { promisify as promisify7 } from "node:util";
 function captureDestinationRefusal(outputPath, projects) {
   if (/^(res|user):\/\//.test(outputPath)) {
@@ -38273,9 +38403,9 @@ function captureDestinationRefusal(outputPath, projects) {
   if (extname2(outputPath).toLowerCase() !== ".png") {
     return `outputPath ${outputPath} does not end in .png, which is what a capture is.`;
   }
-  const directory = realPathOr(dirname16(outputPath));
+  const directory = realPathOr(dirname17(outputPath));
   if (!existsSync15(directory)) {
-    return `outputPath's directory ${dirname16(outputPath)} does not exist; a capture creates no directories.`;
+    return `outputPath's directory ${dirname17(outputPath)} does not exist; a capture creates no directories.`;
   }
   const where = join23(directory, basename4(outputPath));
   const inside = projects.find((project) => project !== "" && isWithinRoot(realPathOr(project), where));
@@ -38330,7 +38460,7 @@ function stillRunning(run) {
   if (typeof run.endedHere === "string") {
     return false;
   }
-  if (!run.throughEditor && run.process === null && run.pid !== null) {
+  if (!run.throughEditor && run.pid !== null) {
     return alive(run.pid);
   }
   if (run.announcedPid !== undefined && !alive(run.announcedPid)) {
@@ -38354,10 +38484,10 @@ function runIsUp(run, editorSays, now = Date.now()) {
   return editorSays ?? stillRunning(run);
 }
 function noCodeWillCome(run) {
-  return !exited(run) && run.process === null;
+  return !exited(run);
 }
-async function untilGone(handle, pids, withinMs = STOP_WAIT_MS) {
-  const gone = () => (handle?.exitCode !== null || handle.signalCode !== null) && pids.every((pid) => !alive(pid));
+async function untilGone(pids, withinMs = STOP_WAIT_MS) {
+  const gone = () => pids.every((pid) => !alive(pid));
   const deadline = Date.now() + withinMs;
   while (!gone() && Date.now() < deadline) {
     await delay3(50);
@@ -38365,6 +38495,9 @@ async function untilGone(handle, pids, withinMs = STOP_WAIT_MS) {
   return gone();
 }
 function endedWithoutACode(run) {
+  if (!run.throughEditor && !run.pickedUp) {
+    return "This run was started here, and the keeper holding it wrote no exit code into its note: the keeper was ended before the game, or another run replaced the note. Everything it printed is below, read back from its transcript.";
+  }
   if (!run.throughEditor) {
     return run.endedHere ? "This run was started by another server, so nothing here held it and its exit code was never collected. Everything it printed is below, read back from its transcript." : "This run was started by another server, the one this server replaced or one running beside it, and it ended with nothing here waiting on it, so its exit code was never collected. Everything it printed is below, read back from its transcript.";
   }
@@ -38377,12 +38510,41 @@ function endedWithoutACode(run) {
   }
   return `The editor stopped playing this run. ${kept} What it printed is below.`;
 }
+function stopVerdict(stop) {
+  if (!stop.wasRunning) {
+    return {
+      stopped: true,
+      endedPid: stop.endedPid,
+      clean: stop.errors === 0,
+      note: "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.",
+      withChildren: false
+    };
+  }
+  if (stop.ending === "refused") {
+    return {
+      stopped: false,
+      notSignalled: stop.endedPid,
+      note: `Nothing was ended: pid ${stop.endedPid ?? "unknown"} no longer answers as the process this run was started as (its engine, its project and when it started), so it was not signalled. If that process is still the game, end it yourself, for instance with runtime_invoke calling get_tree().quit() when the game has the runtime addon; if it is not, it belongs to something else.`,
+      withChildren: false
+    };
+  }
+  return {
+    stopped: true,
+    endedPid: stop.endedPid,
+    clean: stop.errors === 0,
+    note: `${stop.throughEditor ? stop.endedPid === null ? "The editor was asked to stop the scene it is playing. Its game had not announced a runtime, so no process was named under endedPid, and its exit code stays with the editor." : "The editor was asked to stop the scene it is playing." : "The process named under endedPid was ended."}${stop.exitSignal === null ? "" : ` It was ended by ${stop.exitSignal} and so has no exit code.`}${stop.ending === "gone" ? "" : ` It had not exited ${STOP_WAIT_MS / 1000} seconds after being told to, so it may still be going: editor_status says whether it is.`}`,
+    withChildren: true
+  };
+}
 function endedPreviousRun(ended) {
-  if (ended === null) {
+  if (ended === null || ended.ending === "refused") {
     return;
   }
   return ended.pid ?? true;
 }
+function previousRunLeft(ended) {
+  return ended?.ending === "refused" && ended.pid !== null ? ended.pid : undefined;
+}
 function engineNamesOf(executable) {
   return CONSOLE_WRAPPER.test(executable) ? [executable, executable.replace(CONSOLE_WRAPPER, "$1")] : [executable];
 }
@@ -38422,6 +38584,17 @@ function aboutTheChildren(ended, throughEditor) {
   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 childrenFields(ended) {
+  if (ended === null) {
+    return {};
+  }
+  return {
+    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
+  };
+}
 function uidsLeftNote(left) {
   if (left === 0) {
     return "No scene was written: this reads the project and imports it, and does not resave anything.";
@@ -38429,12 +38602,24 @@ function uidsLeftNote(left) {
   const them = left === 1 ? "it" : "them";
   return `${left === 1 ? "One file" : `${left} files`} still ${left === 1 ? "has" : "have"} no .uid, named under stillWithoutUid, which is the engine declining to import ${them} rather than this op skipping ${them}. No scene was written.`;
 }
+function leftRunningNote(stranded) {
+  if (stranded.length === 0) {
+    return "";
+  }
+  const named = stranded.map((one) => one.protocol === null ? `pid ${one.pid}` : `pid ${one.pid} on protocol ${one.protocol}`).join(", ");
+  const [only] = stranded;
+  return stranded.length === 1 && only !== undefined ? ` A game of this project was already running and still is: ${named}. Starting this one did not end it, because this server did not start it. editor_run stop with pid ${only.pid} ends it and leaves this run going.` : ` ${stranded.length} games of this project were already running and still are: ${named}. Starting this one did not end them, because this server did not start them. editor_run stop with the pid of each ends it and leaves this run going.`;
+}
 function endedToStartThis(ended) {
   if (ended === null) {
     return "";
   }
   const which = ended.pid === null ? "The game the editor was playing" : `The run that was going, pid ${ended.pid},`;
-  return ` ${which} was ended to start this one; its output is no longer what editor_output answers about.`;
+  if (ended.ending === "refused") {
+    return ` ${which} was not ended: that pid no longer answers as the process the run was started as, so nothing was signalled. If it is still the game, it is running beside this one and you have to end it yourself; if it is not, it belongs to something else.`;
+  }
+  const after = ended.ending === "lingering" ? ` It had not exited ${STOP_WAIT_MS / 1000} seconds after being told to, so it may still be running beside this one: editor_status says whether it is.` : "";
+  return ` ${which} was ended to start this one; its output is no longer what editor_output answers about.${after}`;
 }
 function runtimeVerdict(endpoint, after) {
   if (endpoint !== null) {
@@ -39739,11 +39924,11 @@ 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 = mkdtempSync3(join23(tmpdir5(), "gdharness-export-"));
@@ -39888,7 +40073,7 @@ class GodotServer {
     } finally {
       discard(reportsDir, userData);
       try {
-        rmdirSync(dirname16(reportsDir));
+        rmdirSync(dirname17(reportsDir));
       } catch {}
     }
     const engineEntries = run.log.select({ severity: "warning", sinceLastCall: false, limit: 200 }).entries.map(aboveTheRunner);
@@ -40116,7 +40301,12 @@ class GodotServer {
     return anEditorIsStillComing(listeningSince, this.launchedEditorIsUp());
   }
   launchedEditorIsUp() {
-    return this.launchedEditor?.exitCode === null && this.launchedEditor.signalCode === null;
+    const launched = this.launchedEditor;
+    if (launched === null || !alive(launched.pid)) {
+      return false;
+    }
+    const now = startTimesOf([launched.pid]).get(launched.pid);
+    return launched.startedAt === null || now === undefined || now === launched.startedAt;
   }
   dap() {
     const port = this.editorServes("dapPort", "GDHARNESS_DAP_PORT", DEFAULT_DAP_PORT);
@@ -40477,9 +40667,9 @@ class GodotServer {
   }
   async openAnEditor(engine, projectPath, ports) {
     clearEditorLog(projectPath);
-    const editor = spawn(engine, editorArguments(projectPath, ports, editorLogPath(projectPath)), {
-      stdio: "ignore",
-      detached: true,
+    const launched = await launchOutsideTheTree({
+      command: engine,
+      args: editorArguments(projectPath, ports, editorLogPath(projectPath)),
       env: {
         ...process.env,
         GDHARNESS_RUNTIME_DIR: runtimeDirectory(),
@@ -40488,23 +40678,15 @@ class GodotServer {
         [OPENED_BY_A_SERVER]: "1"
       }
     });
-    if (editor.pid !== undefined) {
-      writeEditorLogNote(projectPath, editor.pid);
-    }
-    const started = await new Promise((resolve) => {
-      editor.once("spawn", () => {
-        resolve(null);
-      });
-      editor.once("error", (error) => {
-        resolve(error.message);
-      });
-    });
-    if (started !== null) {
-      return { pid: null, error: started };
+    if ("error" in launched) {
+      return { pid: null, error: launched.error };
     }
-    editor.unref();
-    this.launchedEditor = editor.pid === undefined ? null : editor;
-    return { pid: editor.pid ?? null, error: null };
+    writeEditorLogNote(projectPath, launched.pid);
+    this.launchedEditor = {
+      pid: launched.pid,
+      startedAt: startTimesOf([launched.pid]).get(launched.pid) ?? null
+    };
+    return { pid: launched.pid, error: null };
   }
   async portsForAnEditor() {
     const lsp = portFromEnvOrNull("GDHARNESS_LSP_PORT") ?? await freePort(DEFAULT_LSP_PORT);
@@ -40553,8 +40735,10 @@ class GodotServer {
     const before = this.currentRun();
     if (before !== null && await this.runStillGoing(before)) {
       this.logDebug("Ending the running game before starting another");
-      ended = { pid: before.pid ?? this.announcedPidOf(before) ?? null };
-      await this.endActiveGame("editor_run start, which ends the run that was going before it starts another", true);
+      ended = {
+        pid: before.pid ?? this.announcedPidOf(before) ?? null,
+        ending: await this.endActiveGame("editor_run start, which ends the run that was going before it starts another", true)
+      };
     }
     const alreadyPlaying = new Set(discoverRuntimes().map((endpoint) => endpoint.pid));
     const wereHereFirst = this.everyRuntimeOfOurs();
@@ -40574,25 +40758,30 @@ class GodotServer {
       userArgs: given.value
     });
     this.logDebug(`Running Godot project: ${engine.value} ${cmdArgs.join(" ")}`);
-    const started = this.spawnKeptGame(engine.value, cmdArgs, project.value.path, needsItsOwnProcess(asked.value) ? environmentFor({ ...asked.value, runtimeDirectory: runtimeDirectory() }) : undefined);
+    const started = await this.launchKeptGame(engine.value, cmdArgs, project.value.path, needsItsOwnProcess(asked.value) ? environmentFor({ ...asked.value, runtimeDirectory: runtimeDirectory() }) : undefined);
+    if ("error" in started) {
+      return this.createErrorResponse(`The game could not be started: ${started.error}`, [
+        "editor_status says which Godot this server runs and whether it answers"
+      ]);
+    }
     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." : 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." : "";
     const endedForThis = endedToStartThis(ended);
     const stranded = wereHereFirst.filter((one) => one.pid !== ended?.pid && alive(one.pid));
-    const named = stranded.map((one) => one.protocol === null ? `pid ${one.pid}` : `pid ${one.pid} on protocol ${one.protocol}`).join(", ");
-    const alsoRunning = stranded.length === 0 ? "" : ` A game of this project was already running and still is: ${named}. Starting this one did not end it and nothing here can, because this server did not start it. End it yourself, or bring the halves to one version where a protocol is named.`;
+    const alsoRunning = leftRunningNote(stranded);
     return this.jsonTextResponse({
       started: true,
       through: "gdharness",
       alsoRunning: stranded.length === 0 ? undefined : stranded.map((one) => one.pid),
-      pid: started.process.pid ?? null,
+      pid: started.pid,
       arguments: cmdArgs,
       transcript: started.transcript,
       refreshedClasses: refreshed.value,
       ...scanWaitAnswer(scanned),
       savesNote: asked.value.savesIn !== undefined && savesStayPut() ? SAVES_NOT_MOVED_NOTE : undefined,
       endedPreviousRun: endedPreviousRun(ended),
+      previousRunLeft: previousRunLeft(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}`
     });
@@ -40701,7 +40890,6 @@ class GodotServer {
     closeSync2(transcript.fd);
     const playAnswer = asParams(JSON.parse(answer.content[0]?.text ?? "{}"));
     const played = {
-      process: null,
       pid: null,
       log,
       transcript: transcript.path,
@@ -40726,6 +40914,7 @@ class GodotServer {
       ...scanWaitAnswer(scanned),
       debugPort: readNumber(playAnswer, "debugPort"),
       endedPreviousRun: endedPreviousRun(ended),
+      previousRunLeft: previousRunLeft(ended),
       breakpoints: breakpoints.applied.length === 0 ? undefined : this.breakpointsAsProjectSpells(projectPath, breakpoints.applied),
       breakpointsRefused: breakpoints.refused.length === 0 ? undefined : breakpoints.refused.map((one) => ({
         scriptPath: projectSpelling(projectPath, one.scriptPath),
@@ -40800,28 +40989,41 @@ class GodotServer {
   }
   async endActiveGame(reason, going) {
     const running = this.activeProcess;
-    const recorded = running?.process === null ? readRunRecord() : null;
-    clearRunRecord((record) => this.couldBeOurs(record.projectPath));
+    const project = running?.projectPath ?? this.ourProject();
+    const clearTheRecord = () => {
+      if (project !== null) {
+        clearRunRecord(project);
+      }
+    };
+    const aKeeperHoldsIt = running !== null && going && !running.throughEditor && running.pid !== null;
+    if (!aKeeperHoldsIt) {
+      clearTheRecord();
+    }
     if (!running || !going) {
-      return true;
+      return "gone";
     }
     running.endedHere = reason;
     const announced = this.announcedPidOf(running);
     if (running.throughEditor) {
       await this.handleViaBridge("stop_playing", {});
-      return await untilGone(null, announced === undefined ? [] : [announced]);
-    }
-    if (running.process !== null) {
-      running.process.kill();
-      return await untilGone(running.process, announced === undefined ? [] : [announced]);
+      return await untilGone(announced === undefined ? [] : [announced]) ? "gone" : "lingering";
     }
     if (running.pid === null) {
-      return true;
-    }
-    if (recorded === null || recorded.pid !== running.pid || !stillTheRecordedRun(recorded)) {
+      return "gone";
+    }
+    const startedAs = {
+      pid: running.pid,
+      transcript: running.transcript ?? "",
+      startedAt: running.startedAt,
+      projectPath: running.projectPath ?? "",
+      arguments: [],
+      ...running.command === undefined ? {} : { command: running.command }
+    };
+    if (!stillTheRecordedRun(startedAs)) {
+      clearTheRecord();
       running.endedHere = null;
-      running.log.record("warning", `This run was not ended here: pid ${running.pid} no longer answers as the run that was recorded, so nothing was signalled. If that process is still the game, end it yourself; if it is not, it belongs to something else.`);
-      return true;
+      running.log.record("warning", `This run was not ended here: pid ${running.pid} no longer answers as the process the run was started as, so nothing was signalled. If that process is still the game, end it yourself; if it is not, it belongs to something else.`);
+      return "refused";
     }
     const signalled = runningAs(running.pid);
     const described = signalled === null ? "nothing it would name" : `${signalled.kind}: ${signalled.text}`;
@@ -40831,12 +41033,20 @@ class GodotServer {
     } catch {
       landed = false;
     }
-    const gone = await untilGone(null, [running.pid]);
+    const gone = await untilGone([running.pid]);
+    if (gone) {
+      await this.untilTheExitIsRecorded(running);
+    }
+    if (landed && gone) {
+      running.exitCode = null;
+      running.exitSignal = "SIGTERM";
+    }
+    clearTheRecord();
     running.log.record("info", landed ? `gdharness ended pid ${running.pid}, which the operating system described as ${described}.` : `gdharness signalled pid ${running.pid} and it was already gone; the operating system had described it as ${described}.`);
-    return gone;
+    return gone ? "gone" : "lingering";
   }
   spawnGame(godotPath, cmdArgs, env) {
-    const child = spawn(godotPath, cmdArgs, { stdio: ["ignore", "pipe", "pipe"], ...env ? { env } : {} });
+    const child = spawn2(godotPath, cmdArgs, { stdio: ["ignore", "pipe", "pipe"], ...env ? { env } : {} });
     const cancelled = callSignal();
     if (cancelled !== undefined) {
       const end = () => {
@@ -40888,62 +41098,33 @@ class GodotServer {
     });
     return started;
   }
-  spawnKeptGame(godotPath, cmdArgs, projectPath, env) {
+  async launchKeptGame(godotPath, cmdArgs, projectPath, env) {
     const startedAt = Date.now();
     const transcript = openTranscript(startedAt);
-    let child;
-    try {
-      child = spawn(godotPath, cmdArgs, {
-        stdio: ["ignore", transcript.fd, transcript.fd],
-        detached: true,
-        ...env ? { env } : {}
-      });
-    } finally {
-      closeSync2(transcript.fd);
+    closeSync2(transcript.fd);
+    const launched = await launchOutsideTheTree({
+      command: godotPath,
+      args: cmdArgs,
+      ...env === undefined ? {} : { env },
+      run: { transcript: transcript.path, startedAt, projectPath }
+    });
+    if ("error" in launched) {
+      return launched;
     }
-    child.unref();
-    const log = new GameLog;
-    const started = {
-      process: child,
-      pid: child.pid ?? null,
-      log,
+    sweepTranscripts();
+    return {
+      pid: launched.pid,
+      log: new GameLog,
       transcript: transcript.path,
       readOffset: 0,
       projectPath,
       startedAt,
+      command: godotPath,
       exitCode: null,
       exitSignal: null,
       throughEditor: false,
       brokeOn: null
     };
-    child.on("exit", (code, signal) => {
-      this.logDebug(`Godot process exited with code ${code ?? "none"}, signal ${signal ?? "none"}`);
-      this.drainTranscript(started);
-      log.finish();
-      started.exitCode = code;
-      started.exitSignal = code === null ? signal : null;
-      if (started.pid !== null) {
-        recordRunEnded(started.pid, { exitCode: started.exitCode, exitSignal: started.exitSignal });
-      }
-    });
-    child.on("error", (err) => {
-      console.error("Failed to start Godot process:", err);
-      log.append("stderr", `${err.message}
-`);
-      started.exitCode = -1;
-    });
-    if (started.pid !== null) {
-      writeRunRecord({
-        pid: started.pid,
-        transcript: transcript.path,
-        startedAt,
-        projectPath,
-        arguments: cmdArgs,
-        command: godotPath
-      });
-    }
-    sweepTranscripts();
-    return started;
   }
   drainTranscript(game) {
     if (game.transcript === null) {
@@ -40996,10 +41177,8 @@ class GodotServer {
       this.logDebug(`Picked up an editor-played run without its adapter: ${errorMessage(error)}`);
     }
     const project = this.godotBridge.getStatus().projectPath ?? null;
-    const left = readEditorRunNote();
-    const note = left !== null && project !== null && isSameDirectory(left.projectPath, project) ? left : null;
+    const note = project === null ? null : readEditorRunNote(project);
     const picked = {
-      process: null,
       pid: null,
       log: new GameLog,
       transcript: note?.transcript ?? null,
@@ -41131,22 +41310,24 @@ class GodotServer {
     return endpoint.editorPid === undefined || endpoint.editorPid !== editor;
   }
   adoptRecordedRun() {
-    const record = readRunRecord();
+    const project = this.ourProject();
+    const record = project === null ? null : readRunRecord(project);
     if (record === null || !this.couldBeOurs(record.projectPath)) {
       return null;
     }
     const adopted = {
-      process: null,
       pid: record.pid,
       log: new GameLog,
       transcript: record.transcript,
       readOffset: 0,
       projectPath: record.projectPath === "" ? null : record.projectPath,
       startedAt: record.startedAt,
+      ...record.command === undefined ? {} : { command: record.command },
       exitCode: null,
       exitSignal: null,
       throughEditor: false,
-      brokeOn: null
+      brokeOn: null,
+      pickedUp: true
     };
     this.drainTranscript(adopted);
     if (!alive(record.pid) || !couldStillBeTheRecordedRun(record)) {
@@ -41163,18 +41344,18 @@ class GodotServer {
     const noEditor = !status.connected ? " No editor is connected, so a game the editor is playing cannot be seen from here at all:" + " editor_status says whether one is on its way, and a run of yours that is still up is" + " reachable again once it is." : "";
     const live = this.aRuntimeOfOursIsAnswering();
     if (live !== null) {
-      return `A game is running for ${live.project.path} and has announced its runtime on port ${live.port}, pid ${live.pid},` + " but this server did not start it and cannot reach it through the editor, so editor_run and" + " editor_output have nothing to answer about. The runtime_* tools reach it now." + " A run started here is a separate process rather than a replacement, so starting one leaves" + " this game running as well." + (this.godotBridge.getStatus().connected ? "" : " editor_status says whether an editor is on its way, and editor_run can end it once one is.");
+      return `A game is running for ${live.project.path} and has announced its runtime on port ${live.port}, pid ${live.pid},` + " but this server did not start it and cannot reach it through the editor, so editor_run and" + ` editor_output have nothing to answer about. The runtime_* tools reach it now, and editor_run stop with pid ${live.pid} ends it.` + " A run started here is a separate process rather than a replacement, so starting one leaves" + " this game running as well.";
     }
     const unreadable = this.aRuntimeOfOursIsTooFarOff();
     if (unreadable !== null) {
       const behind = whichHalfIsBehind([unreadable]);
-      return `A game is running for ${unreadable.project.path}, pid ${unreadable.pid}, announced in protocol` + ` ${unreadable.protocol}, which this server does not speak: it speaks ${RUNTIME_PROTOCOL}, so ${behind}.` + " Until then neither editor_run nor the runtime_* tools can reach it." + " A run started here is a separate process rather than a replacement, so starting one leaves" + " this game running as well.";
+      return `A game is running for ${unreadable.project.path}, pid ${unreadable.pid}, announced in protocol` + ` ${unreadable.protocol}, which this server does not speak: it speaks ${RUNTIME_PROTOCOL}, so ${behind}.` + ` Until then the runtime_* tools cannot reach it, and editor_run stop with pid ${unreadable.pid} ends it.` + " A run started here is a separate process rather than a replacement, so starting one leaves" + " this game running as well.";
     }
-    const record = readRunRecord();
+    const mine = this.ourProject();
+    const record = everyRunRecord().find((one) => mine === null || !isSameDirectory(one.projectPath, mine)) ?? null;
     if (record === null) {
       return `No game is running.${noEditor} Start one with editor_run.`;
     }
-    const mine = this.ownProject ?? (status.connected ? status.projectPath ?? null : null);
     const whose = record.projectPath === "" ? "a project it does not name" : record.projectPath;
     const ours = mine === null ? "this server was started without GDHARNESS_PROJECT and has no editor connected, so it cannot say whose that run is" : `this server serves ${mine}`;
     return `No game of this server's is running.${noEditor} A run started from ${whose} is recorded on this machine, and ${ours}, so it is not this server's to answer for or to end. Start one with editor_run.`;
@@ -41217,13 +41398,16 @@ class GodotServer {
     ];
   }
   couldBeOurs(project) {
-    const status = this.godotBridge.getStatus();
-    const mine = this.ownProject ?? (status.connected ? status.projectPath ?? null : null);
+    const mine = this.ourProject();
     if (mine === null) {
       return false;
     }
     return project !== "" && isSameDirectory(mine, project);
   }
+  ourProject() {
+    const status = this.godotBridge.getStatus();
+    return this.ownProject ?? (status.connected ? status.projectPath ?? null : null);
+  }
   currentRun() {
     return this.activeProcess ?? this.adoptRecordedRun();
   }
@@ -41281,8 +41465,8 @@ class GodotServer {
   async runStillGoing(run, editorSays) {
     if (!run.throughEditor) {
       const going = stillRunning(run);
-      if (!going && run.process !== null && !exited(run)) {
-        await untilGone(run.process, [], EXIT_REPORTED_WITHIN_MS);
+      if (!going && run.pid !== null && !exited(run) && run.endedUnwatched !== true && typeof run.endedHere !== "string" && !await this.untilTheExitIsRecorded(run)) {
+        run.endedUnwatched = true;
       }
       return going;
     }
@@ -41299,6 +41483,21 @@ class GodotServer {
     }
     return runIsUp(run, said);
   }
+  async untilTheExitIsRecorded(run) {
+    const until = Date.now() + EXIT_REPORTED_WITHIN_MS;
+    for (;; ) {
+      const record = run.projectPath === null ? null : readRunRecord(run.projectPath);
+      if (record !== null && record.pid === run.pid && (record.exitCode !== undefined || record.exitSignal !== undefined)) {
+        run.exitCode = record.exitCode ?? null;
+        run.exitSignal = record.exitSignal ?? null;
+        return true;
+      }
+      if (Date.now() >= until) {
+        return false;
+      }
+      await delay3(50);
+    }
+  }
   handleEditorConsole(args) {
     const status = this.godotBridge.getStatus();
     const projectPath = status.projectPath ?? this.ownProject ?? undefined;
@@ -41400,7 +41599,8 @@ class GodotServer {
         throughEditor: run.throughEditor,
         announced: announced !== undefined || run.announcedPid !== undefined,
         couldAnnounce: run.projectPath !== null && existsSync15(join23(run.projectPath, RUNTIME_AUTOLOAD2.path)),
-        endedHere: typeof run.endedHere === "string"
+        endedHere: typeof run.endedHere === "string",
+        pickedUp: run.pickedUp === true
       }));
     }
     if (run.pickedUpPlaying === true) {
@@ -41426,7 +41626,7 @@ class GodotServer {
       ...hold,
       endedUnwatched: run.endedUnwatched === true ? true : undefined,
       endedBy: stillRunning(run) ? undefined : run.endedHere ?? null,
-      project: !run.throughEditor && run.process === null ? run.projectPath ?? undefined : undefined,
+      project: run.throughEditor ? undefined : run.projectPath ?? undefined,
       transcript: run.transcript ?? undefined,
       startedAt: new Date(run.startedAt).toISOString(),
       elapsedMs: Date.now() - run.startedAt,
@@ -41439,6 +41639,10 @@ class GodotServer {
   async handleStopProject(args) {
     await this.pickUpWhatTheEditorIsPlaying();
     const stopped = this.currentRun();
+    const named = readNumber(args, "pid");
+    if (named !== undefined && (stopped === null || named !== stopped.pid && named !== this.announcedPidOf(stopped))) {
+      return await this.stopAnnouncedGame(named, readBoolean(args, "andChildren") === true);
+    }
     if (!stopped) {
       return this.createErrorResponse(this.nothingOfOursIsRunning());
     }
@@ -41449,35 +41653,87 @@ class GodotServer {
     const endedPid = stopped.pid ?? announcedPid;
     const children = readBoolean(args, "andChildren") === true && wasRunning ? await this.whatTheRunStarted(stopped) : null;
     this.logDebug("Stopping the running game");
-    const gone = await this.endActiveGame("editor_run stop", wasRunning);
-    const ended = children === null ? null : endChildrenAmong(children);
-    if (wasRunning) {
+    const ending = await this.endActiveGame("editor_run stop", wasRunning);
+    const refused = ending === "refused";
+    const ended = children === null || refused ? null : endChildrenAmong(children);
+    if (wasRunning && !refused) {
       for (const pid of new Set([endedPid, announcedPid])) {
         if (pid !== null) {
           await announcementEnded(pid);
         }
       }
     }
+    const verdict = stopVerdict({
+      wasRunning,
+      ending,
+      endedPid,
+      throughEditor: stopped.throughEditor,
+      exitSignal: stopped.exitSignal,
+      errors: stopped.log.count("error")
+    });
     return this.jsonTextResponse({
-      stopped: true,
+      stopped: verdict.stopped,
       through: stopped.throughEditor ? "editor" : "gdharness",
-      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
-      },
+      endedPid: verdict.endedPid,
+      notSignalled: verdict.notSignalled,
+      ...childrenFields(ended),
       exitedBeforeStop: !wasRunning,
       exitCode: stopped.exitCode,
       exitSignal: stopped.exitSignal ?? undefined,
       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 ? endedPid === null ? "The editor was asked to stop the scene it is playing. Its game had not announced a runtime, so no process was named under endedPid, and its exit code stays with the editor." : "The editor was asked to stop the scene it is playing." : "The process named under endedPid was ended."}${stopped.exitSignal === null ? "" : ` It was ended by ${stopped.exitSignal} and so has no exit code.`}${gone ? "" : ` It had not exited ${STOP_WAIT_MS / 1000} seconds after being told to, so it may still be going: editor_status says whether it is.`} ${aboutTheChildren(ended, stopped.throughEditor)}`,
+      clean: verdict.clean,
+      note: verdict.withChildren ? `${verdict.note} ${aboutTheChildren(ended, stopped.throughEditor)}` : verdict.note,
       entries: forAnswer(stopped.log.select({ severity: "warning", sinceLastCall: false, limit: 200 }).entries)
     });
   }
+  async stopAnnouncedGame(pid, andChildren) {
+    const announced = runtimesAnnounced();
+    const game = [
+      ...this.allAnnouncedForOurProject(announced.running),
+      ...this.allAnnouncedForOurProject(announced.unspoken)
+    ].find((one) => one.pid === pid);
+    if (game === undefined) {
+      return this.createErrorResponse(`pid ${pid} is not a game announced for this project, so nothing was signalled. editor_status lists this project's games under runtimes. A game that announces no runtime is ended by the server holding its run, or with andChildren by a stop of the run that started it.`);
+    }
+    const read = game.announcedAt === undefined ? null : stillTheAnnouncedGame(pid, game.project.path, game.announcedAt);
+    if (read === null) {
+      return this.createErrorResponse(`pid ${pid} announced itself as a game of this project, but the operating system does not describe it as this project's engine run started before that announcement (the engine with --path on the project and no editor flag), so nothing was signalled. If it is still the game, runtime_invoke can ask it to quit.`);
+    }
+    const run = {
+      pid,
+      log: new GameLog,
+      transcript: null,
+      readOffset: 0,
+      projectPath: game.project.path,
+      startedAt: game.announcedAt ?? Date.now(),
+      exitCode: null,
+      exitSignal: null,
+      throughEditor: false,
+      brokeOn: null,
+      announcedPid: pid
+    };
+    const children = andChildren ? await this.whatTheRunStarted(run) : null;
+    let landed = true;
+    try {
+      process.kill(pid);
+    } catch {
+      landed = false;
+    }
+    const gone = await untilGone([pid]);
+    const ended = children === null ? null : endChildrenAmong(children);
+    if (gone) {
+      await announcementEnded(pid);
+    }
+    return this.jsonTextResponse({
+      stopped: true,
+      through: "gdharness",
+      endedPid: pid,
+      ...childrenFields(ended),
+      exitedBeforeStop: !landed,
+      note: `${landed ? `pid ${pid} was ended: a game of this project that no server here was holding,` : `pid ${pid} had already gone when it was signalled: a game of this project that no server here was holding,`} identified by its announcement and by its command line, ${read.executable} run with --path ${read.projectPath ?? ""}. Nothing here read what it printed or holds its exit code, so neither is in this answer.${gone ? "" : ` It had not exited ${STOP_WAIT_MS / 1000} seconds after being told to, so it may still be going: editor_status says whether it is.`} ${aboutTheChildren(ended, false)}`
+    });
+  }
   async whatTheRunStarted(run) {
     const tree = await processTree();
     if (tree === undefined) {
@@ -42056,6 +42312,7 @@ var init_server3 = __esm(() => {
   init_issues();
   init_junit();
   init_lsp_client();
+  init_outside();
   init_paths();
   init_ports();
   init_process_children();
@@ -42071,7 +42328,7 @@ var init_server3 = __esm(() => {
   init_tool_definitions();
   init_update_check();
   run7 = promisify7(execFile7);
-  __dirname2 = dirname16(fileURLToPath5(import.meta.url));
+  __dirname2 = dirname17(fileURLToPath6(import.meta.url));
   CONSOLE_WRAPPER = /_console(\.exe)?$/i;
   LONGEST_BOOT_NOTED_MS = 5 * 60000;
   VALUE_NAMES = {
@@ -42113,7 +42370,7 @@ var init_server3 = __esm(() => {
 
 // src/cli.ts
 import { existsSync as existsSync16 } from "fs";
-import { join as join24, resolve as resolve5 } from "path";
+import { join as join24, resolve as resolve6 } from "path";
 
 // src/bridge-announce.ts
 init_errors();
@@ -43742,6 +43999,7 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
 | Whether this engine has a method or property, and what it takes | \`editor_classes info\` with \`member\`, which answers that one member and which class declares it rather than the whole class |
 | 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 |
+| End a game of the project that no server is holding | \`editor_run stop\` with its \`pid\` from \`editor_status\` \`runtimes\`, never a process kill by hand: it is ended only when it announced itself for the project and its command line is the project's engine run |
 | Play a game without touching the player's saves | \`editor_run start\` with \`savesIn\`, a directory for this run's \`user://\`: the editor plays with its own environment, so a run given one is started by the server, and the answer says under \`savesNote\` when the platform ignores it |
 | A picture, for a person who asked to see one | \`runtime_capture\` |
 
@@ -43935,7 +44193,7 @@ class UsageError extends Refusal2 {
 }
 function projectArgument(at) {
   const named = args.slice(at).find((value) => !value.startsWith("--"));
-  const projectPath = resolve5(named ?? ".");
+  const projectPath = resolve6(named ?? ".");
   if (!existsSync16(join24(projectPath, "project.godot"))) {
     throw new UsageError(`Not a Godot project: ${projectPath} holds no project.godot.`);
   }