gdharness 1.0.28 → 1.0.30

package/build/index.js

@@ -10183,7 +10183,7 @@ function defectReport(where, error, context = {}) {
 }
 
 // src/server.ts
-import { execFile as execFile5, spawn } from "node:child_process";
+import { execFile as execFile5, spawn as spawn2 } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import {
   appendFileSync,
@@ -10204,7 +10204,7 @@ import {
 import { tmpdir as tmpdir4 } from "node:os";
 import { basename as basename3, dirname as dirname10, extname as extname2, isAbsolute as isAbsolute3, join as join16, normalize as normalize2, relative as relative3 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
 import { promisify as promisify5 } from "node:util";
 
 // node_modules/zod/v3/helpers/util.js
@@ -28884,6 +28884,46 @@ async function handleLSPTool(client, toolName, args) {
   }
 }
 
+// src/outside.ts
+import { spawn } from "node:child_process";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+var KEEPER_SCRIPT = fileURLToPath2(new URL("./keeper.js", import.meta.url));
+function encodeSpec(spec) {
+  return Buffer.from(JSON.stringify(spec), "utf8").toString("base64url");
+}
+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", encodeSpec(spec)], {
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true
+    });
+    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);
+    });
+  });
+}
+
 // src/process-time.ts
 import { execFile as execFile4 } from "node:child_process";
 import { promisify as promisify4 } from "node:util";
@@ -29336,9 +29376,6 @@ import { basename as basename2, join as join14 } from "node:path";
 function runsDirectory() {
   return join14(runtimeDirectory(), "runs");
 }
-function recordPath() {
-  return join14(runsDirectory(), "run.json");
-}
 function recordPaths() {
   return runtimeDirectories().map((directory) => join14(directory, "runs", "run.json"));
 }
@@ -29347,10 +29384,6 @@ function openTranscript(startedAt) {
   const path = join14(runsDirectory(), `run-${startedAt}.log`);
   return { path, fd: openSync2(path, "a") };
 }
-function writeRunRecord(record) {
-  mkdirSync8(runsDirectory(), { recursive: true });
-  writeFileSync9(recordPath(), JSON.stringify(record, null, 2), "utf8");
-}
 function editorNotePath() {
   return join14(runsDirectory(), "editor-run.json");
 }
@@ -29386,21 +29419,6 @@ 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;
-  }
-  const written = {
-    ...record,
-    ...ending.exitCode === null ? {} : { exitCode: ending.exitCode },
-    ...ending.exitSignal === null ? {} : { exitSignal: ending.exitSignal }
-  };
-  try {
-    writeFileSync9(path, JSON.stringify(written, null, 2), "utf8");
-  } catch {}
-}
 function readRunRecord() {
   for (const path of recordPaths()) {
     const record = recordAt(path);
@@ -29635,7 +29653,7 @@ import {
   writeFileSync as writeFileSync10
 } from "node:fs";
 import { dirname as dirname9, join as join15 } from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 var ADDONS = ["gdharness_editor", "gdharness_runtime", "auto_reload"];
 var EDITOR_PLUGINS = ["gdharness_editor", "auto_reload"];
 var RUNTIME_AUTOLOAD = {
@@ -29681,7 +29699,7 @@ function shippedEditorDigest() {
   return shippedDigest ?? undefined;
 }
 function shippedAddonsDirectory() {
-  return join15(dirname9(fileURLToPath2(import.meta.url)), "godot", "addons");
+  return join15(dirname9(fileURLToPath3(import.meta.url)), "godot", "addons");
 }
 function installedAddonVersion(projectPath) {
   const marker = join15(projectPath, "addons", ADDONS[0], VERSION_MARKER);
@@ -30316,7 +30334,7 @@ var TOOL_SPECS = [
   },
   {
     name: "editor_run",
-    description: "The run: starting the project, stopping it, or booting it once to see whether it comes up clean. start keeps it running and collecting output until it quits or is stopped, windowed where there is a display and headless where there is not, unless headless says otherwise; only runtime_capture needs the window. A run that quits on its own is kept, so a scene that prints an answer and quits is start, then editor_output until running is false. What runs is a scene: a SceneTree script is not an entry point here, so put the script on the root of a scene of its own and name that in scene. args hands the game its own flags, the ones it reads with OS.get_cmdline_user_args(), and a run carrying any is started by this server rather than by the editor. check boots it headless for a few frames, waits for it to quit, and answers with the verdict: whether it came up, and every error and warning it printed on the way. A start waits for the game to become something the runtime_* tools can talk to and says which it is under runtime: listening with the port it took, or why not, so the first call after a start does not have to be made twice. When it is not listening, mayYetAnnounce says whether that is final: false is a runtime that is not coming, true is a game still on its way up, which editor_status will see and runtimeWaitMs waits longer for. A start this server made also answers with transcript, the file both the run's streams are written to, so a watch on it can be armed off the start rather than off a second call.",
+    description: "The run: starting the project, stopping it, or booting it once to see whether it comes up clean. start keeps it running and collecting output until it quits or is stopped, windowed where there is a display and headless where there is not, unless headless says otherwise; only runtime_capture needs the window. A run that quits on its own is kept, so a scene that prints an answer and quits is start, then editor_output until running is false. What runs is a scene: a SceneTree script is not an entry point here, so put the script on the root of a scene of its own and name that in scene. args hands the game its own flags, the ones it reads with OS.get_cmdline_user_args(), and a run carrying any is started by this server rather than by the editor. check boots it headless for a few frames, waits for it to quit, and answers with the verdict: whether it came up, and every error and warning it printed on the way. start and check both wait first for a scan the open editor is running and for the class cache it writes just after, since a game booted in between resolves no global class, as does every other engine this server starts on the project; waitedForEditorScanMs says how long, and scanNote says when a scan ran past thirty seconds and the game started during it. A start waits for the game to become something the runtime_* tools can talk to and says which it is under runtime: listening with the port it took, or why not, so the first call after a start does not have to be made twice. When it is not listening, mayYetAnnounce says whether that is final: false is a runtime that is not coming, true is a game still on its way up, which editor_status will see and runtimeWaitMs waits longer for. A start this server made also answers with transcript, the file both the run's streams are written to, so a watch on it can be armed off the start rather than off a second call.",
     parameters: {
       projectPath: { ...PROJECT_PATH, ops: ["start", "check"] },
       scene: {
@@ -30433,7 +30451,7 @@ var TOOL_SPECS = [
   },
   {
     name: "editor_status",
-    description: "Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and whether a game with the runtime addon is reachable: runtimeConnected counts the games of the project this server serves, and runtimes lists every game on the machine with ofThisProject saying which is which, since a game of another project is reached only by naming its projectPath. playingInEditor is null when the editor was not asked or did not answer, which is not the same as a no: with no editor connected there is nobody to ask, and an editor that does not serve the question is given a moment and then left. A game can be playing while this is null, so read it as unanswered rather than as nothing playing, and use processActive and runtimes, which come from elsewhere and do not depend on the editor answering. Each game under runtimes is pinged with a short wait, so one held at a breakpoint is listed as unreachable rather than making this call wait out the runtime timeout; for the run this server is reporting on, heldAt says whether that is what it is, with the same three answers editor_output gives. A game the editor played announces the editor under editorPid, and so does whatever that game started for itself; a game some other server started announces none, which is how the two are told apart when both are running from one project. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means \"not reached yet\" as often as it means \"no editor\". True is worth waiting out; false is an editor that is not there. False beside restartInterrupted is one that an editor_launch restart on a previous server asked to quit, where the launch half never ran because that server was ended in between, usually by the reconnect the restart was taken for; editor_launch open finishes it. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. settingsDropped appears here once when the editor this server opened saved project.godot on its way in, which is the same reading editor_launch restart makes in its own answer. A game that has announced itself in a protocol this server does not speak is listed under unreadable rather than left out, with the protocol it speaks and whether the server or the addon is the older half. This happens during an upgrade that moves the runtime protocol, which most do not: installing replaces the addon on disk as soon as the pin moves, while a server that is already running stays on the version it started with, so the two speak different protocols until the server is reconnected. Those games are real and running, but no tool here can reach them until the halves match, so runtimes stays empty and runtimeConnected stays false. An upgrade that leaves the protocol alone opens no such window and this list stays empty through it. addonIsStale is decided by the code of the editor addons rather than their version, so an editor started before an upgrade that left that code alone reports the older addonVersion, is not stale, and addonNote says so: it needs no restart. port is the one the editor bridge is on; when that is not the one this server was configured with, portWanted names the configured one and portNote says why it moved and, when it was the server this one replaced, which pid kept it. A server replacing another of its project that holds the configured port waits for it to stand down and takes the port over, which takes a few seconds; bridgeHandover says so while it waits, and it moves only if that server has not let go within the wait.",
+    description: "Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and whether a game with the runtime addon is reachable: runtimeConnected counts the games of the project this server serves, and runtimes lists every game on the machine with ofThisProject saying which is which, since a game of another project is reached only by naming its projectPath. playingInEditor is null when the editor was not asked or did not answer, which is not the same as a no: with no editor connected there is nobody to ask, and an editor that does not serve the question is given a moment and then left. A game can be playing while this is null, so read it as unanswered rather than as nothing playing, and use processActive and runtimes, which come from elsewhere and do not depend on the editor answering. editor.scan says whether the editor is scanning or importing and how many milliseconds ago its last scan finished (finishedMsAgo), or is null when it did not answer: the editor rewrites the class cache just after a scan, and editor_run waits that out before starting a game, saying so under waitedForEditorScanMs. Each game under runtimes is pinged with a short wait, so one held at a breakpoint is listed as unreachable rather than making this call wait out the runtime timeout; for the run this server is reporting on, heldAt says whether that is what it is, with the same three answers editor_output gives. A game the editor played announces the editor under editorPid, and so does whatever that game started for itself; a game some other server started announces none, which is how the two are told apart when both are running from one project. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means \"not reached yet\" as often as it means \"no editor\". True is worth waiting out; false is an editor that is not there. False beside restartInterrupted is one that an editor_launch restart on a previous server asked to quit, where the launch half never ran because that server was ended in between, usually by the reconnect the restart was taken for; editor_launch open finishes it. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. settingsDropped appears here once when the editor this server opened saved project.godot on its way in, which is the same reading editor_launch restart makes in its own answer. A game that has announced itself in a protocol this server does not speak is listed under unreadable rather than left out, with the protocol it speaks and whether the server or the addon is the older half. This happens during an upgrade that moves the runtime protocol, which most do not: installing replaces the addon on disk as soon as the pin moves, while a server that is already running stays on the version it started with, so the two speak different protocols until the server is reconnected. Those games are real and running, but no tool here can reach them until the halves match, so runtimes stays empty and runtimeConnected stays false. An upgrade that leaves the protocol alone opens no such window and this list stays empty through it. addonIsStale is decided by the code of the editor addons rather than their version, so an editor started before an upgrade that left that code alone reports the older addonVersion, is not stale, and addonNote says so: it needs no restart. port is the one the editor bridge is on; when that is not the one this server was configured with, portWanted names the configured one and portNote says why it moved and, when it was the server this one replaced, which pid kept it. A server replacing another of its project that holds the configured port waits for it to stand down and takes the port over, which takes a few seconds; bridgeHandover says so while it waits, and it moves only if that server has not let go within the wait.",
     parameters: {},
     requires: []
   },
@@ -30948,7 +30966,7 @@ function buildToolDefinitions() {
 var UPDATE_NOTICE_EVERY = 500;
 var FEEDBACK_NOTICE_EVERY = 250;
 var run5 = promisify5(execFile5);
-var __dirname2 = dirname10(fileURLToPath3(import.meta.url));
+var __dirname2 = dirname10(fileURLToPath4(import.meta.url));
 var EDITOR_RESTART_TIMEOUT_MS = 90000;
 var HOLD_PING_MS = 2000;
 var SLOWEST_FRAME_RATE = 20;
@@ -31019,7 +31037,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)) {
@@ -31044,12 +31062,12 @@ function runIsUp(run, editorSays, now = Date.now()) {
   return editorSays ?? stillRunning(run);
 }
 function noCodeWillCome(run) {
-  return !exited(run) && run.process === null;
+  return !exited(run);
 }
 var STOP_WAIT_MS = 1e4;
 var EXIT_REPORTED_WITHIN_MS = 2000;
-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);
@@ -31057,6 +31075,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.";
   }
@@ -31263,6 +31284,34 @@ var SUCCESSOR_CHECK_MS = 1e4;
 var HANDOVER_MS = SUCCESSOR_CHECK_MS + 5000;
 var HANDOVER_POLL_MS = 250;
 var CACHE_WRITE_MS = 2000;
+var SCAN_WAIT_MS = 30000;
+function scanWaitIn(payload) {
+  const waited = readNumber(payload, "waitedForEditorScanMs");
+  const note = readString(payload, "scanNote");
+  return {
+    ...waited === undefined ? {} : { waitedForEditorScanMs: waited },
+    ...note === undefined ? {} : { scanNote: note }
+  };
+}
+function withScanWait(outcome, scanned) {
+  if (scanned.waitedMs === 0) {
+    return outcome;
+  }
+  const said = scanWaitAnswer(scanned);
+  if (outcome.ok) {
+    return { ...outcome, payload: { ...outcome.payload, ...said } };
+  }
+  return said.scanNote === undefined ? outcome : { ...outcome, message: `${outcome.message} ${said.scanNote}` };
+}
+function scanWaitAnswer(scanned) {
+  if (scanned.waitedMs === 0) {
+    return {};
+  }
+  return {
+    waitedForEditorScanMs: scanned.waitedMs,
+    scanNote: scanned.stillScanning ? `The editor was still scanning the project after ${SCAN_WAIT_MS / 1000} seconds, so this ` + "game started during the scan and may have read a class cache being rewritten. If " + 'editor_output shows "Could not find type" for a class that is declared, editor_rescan ' + "waits for the scan to finish, and a start after it reads the finished cache." : undefined
+  };
+}
 var PLAYING_STATUS_MS = 1000;
 var SCAN_START_MS = 2000;
 var WAIT_FOR_RUN_MS = 600000;
@@ -32230,6 +32279,47 @@ class GodotServer {
     }
     return { ok: true, value: stale };
   }
+  async untilTheEditorsScanIsWritten(projectPath) {
+    const open = this.godotBridge.getStatus().projectPath;
+    if (!this.godotBridge.isConnected() || open === undefined || !isSameDirectory(open, projectPath)) {
+      return { waitedMs: 0, stillScanning: false };
+    }
+    const started = Date.now();
+    let sawAScan = false;
+    let scanEndedAt = null;
+    for (;; ) {
+      const asked = Date.now();
+      let status;
+      try {
+        status = asParams(await this.godotBridge.invokeTool("scan_status", {}));
+      } catch {
+        return { waitedMs: Date.now() - started, stillScanning: false };
+      }
+      if (status["scanning"] === true || status["importing"] === true || status["pending"] === true) {
+        sawAScan = true;
+        if (Date.now() - started >= SCAN_WAIT_MS) {
+          return { waitedMs: Date.now() - started, stillScanning: true };
+        }
+        await new Promise((settle) => setTimeout(settle, 100));
+        continue;
+      }
+      const since = readNumber(status, "sinceScanFinishedMs");
+      scanEndedAt = since !== undefined && since >= 0 ? asked - since : sawAScan ? asked : null;
+      break;
+    }
+    let waitedForTheWrite = false;
+    if (scanEndedAt !== null) {
+      const writeDue = scanEndedAt + CACHE_WRITE_MS;
+      while (Date.now() < writeDue && (cacheWrittenAt(projectPath) ?? 0) < scanEndedAt) {
+        waitedForTheWrite = true;
+        await new Promise((settle) => setTimeout(settle, 50));
+      }
+    }
+    return {
+      waitedMs: sawAScan || waitedForTheWrite ? Date.now() - started : 0,
+      stillScanning: false
+    };
+  }
   containProjectFiles(args) {
     const projectPath = readString(args, "projectPath");
     if (!projectPath) {
@@ -32290,14 +32380,15 @@ class GodotServer {
       return engine.response;
     }
     const projectPath = project.value.path;
+    const scanned = await this.untilTheEditorsScanIsWritten(projectPath);
     const before = scriptsWithoutUid(projectPath);
     const imported = await runImport(engine.value, projectPath);
     if (!imported.ok) {
-      return this.answer(imported);
+      return this.answer(withScanWait(imported, scanned));
     }
     const after = scriptsWithoutUid(projectPath);
     const given = before.filter((script) => !after.includes(script));
-    return this.answer({
+    return this.answer(withScanWait({
       ok: true,
       messages: imported.messages,
       payload: {
@@ -32305,7 +32396,7 @@ class GodotServer {
         stillWithoutUid: after,
         note: uidsLeftNote(after.length)
       }
-    });
+    }, scanned));
   }
   async operation(operation, params, projectPath) {
     const engine = await this.engine();
@@ -32316,8 +32407,10 @@ class GodotServer {
         messages: []
       };
     }
+    const scanned = await this.untilTheEditorsScanIsWritten(projectPath);
     this.logDebug(`Running ${operation} in ${projectPath}: ${JSON.stringify(params)}`);
-    return await runOperation({ godotPath: engine.value, script: this.operationsScript, debug: GODOT_DEBUG_MODE_DEFAULT }, operation, params, projectPath);
+    const outcome = await runOperation({ godotPath: engine.value, script: this.operationsScript, debug: GODOT_DEBUG_MODE_DEFAULT }, operation, params, projectPath);
+    return withScanWait(outcome, scanned);
   }
   answer(outcome) {
     if (!outcome.ok) {
@@ -32499,6 +32592,7 @@ class GodotServer {
     if (!classes.ok) {
       return this.answer(classes);
     }
+    const scanned = scanWaitIn(classes.payload);
     const ours = `gdharness-reports/${randomUUID2()}`;
     const reports = `res://.godot/${ours}`;
     const ignored = readStringArray(args, "ignore") ?? [];
@@ -32589,7 +32683,8 @@ class GodotServer {
               hung,
               arguments: cmdArgs,
               entries: forAnswer(printed.slice(0, 60)),
-              savesNote
+              savesNote,
+              ...scanned
             }, null, 2)
           }
         ],
@@ -32624,6 +32719,7 @@ class GodotServer {
       orphans: orphans.total > 0 ? orphans.total : undefined,
       notRun: notRun > 0 ? notRun : undefined,
       savesNote,
+      ...scanned,
       note: verdict.startsWith("warnings") && warnings.length === 0 ? "gdUnit4 exits 101 for orphan nodes when nothing failed, and this run printed no count of them: orphan reporting may be off in the project settings." : notRun > 0 ? `This run stopped at the first failure in each suite it failed in, so ${notRun} case${notRun === 1 ? "" : "s"} never ran and count as neither passed nor failed. Leave failFast out to run every case.` : undefined,
       suites: unclean.map((suite) => ({
         name: suite.name,
@@ -32781,7 +32877,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);
@@ -32922,6 +33023,28 @@ class GodotServer {
       return null;
     }
   }
+  async editorScanState() {
+    if (!this.godotBridge.getStatus().connected) {
+      return null;
+    }
+    try {
+      const answer = await Promise.race([
+        this.godotBridge.invokeTool("scan_status", {}),
+        delay3(PLAYING_STATUS_MS).then(() => null)
+      ]);
+      if (answer === null) {
+        return null;
+      }
+      const since = readNumber(asParams(answer), "sinceScanFinishedMs");
+      return {
+        scanning: readBoolean(asParams(answer), "scanning") ?? false,
+        importing: readBoolean(asParams(answer), "importing") ?? false,
+        finishedMsAgo: since === undefined || since < 0 ? null : since
+      };
+    } catch {
+      return null;
+    }
+  }
   async handleEditorStatus() {
     const located = await this.locator.find();
     const announced = runtimesAnnounced();
@@ -32952,11 +33075,16 @@ class GodotServer {
         hold: current === null ? {} : await this.holdOf(current, active)
       };
     })();
-    const [games, { playing, active, hold }] = await Promise.all([pinged, asked]);
+    const [games, { playing, active, hold }, scan] = await Promise.all([
+      pinged,
+      asked,
+      this.editorScanState()
+    ]);
     return this.jsonTextResponse({
       editor: {
         ...this.getEditorStatusPayload(),
-        debugPort: playing?.debugPort ?? this.godotBridge.getStatus().debugPort
+        debugPort: playing?.debugPort ?? this.godotBridge.getStatus().debugPort,
+        scan
       },
       godot: {
         path: located.ok ? located.path : null,
@@ -33115,9 +33243,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(),
@@ -33126,23 +33254,15 @@ class GodotServer {
         [OPENED_BY_A_SERVER]: "1"
       }
     });
-    if (editor.pid !== undefined) {
-      writeEditorLogNote(projectPath, editor.pid);
+    if ("error" in launched) {
+      return { pid: null, error: launched.error };
     }
-    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 };
-    }
-    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);
@@ -33177,13 +33297,14 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
+    const scanned = await this.untilTheEditorsScanIsWritten(project.value.path);
     const refreshed = await this.refreshStaleClasses(project.value.path);
     if (!refreshed.ok) {
       return refreshed.response;
     }
     const sceneArgument = sceneToRun?.ok ? sceneToRun.relativePath : null;
     if (op === "check") {
-      return await this.checkBoot(engine.value, project.value.path, sceneArgument, args, given.value, asked.value);
+      return await this.checkBoot(engine.value, project.value.path, sceneArgument, args, given.value, scanned, asked.value);
     }
     await this.pickUpWhatTheEditorIsPlaying();
     let ended = null;
@@ -33202,7 +33323,7 @@ class GodotServer {
     const runtimeWaitMs = this.announceBudget(args, project.value.path);
     const editorWouldPlay = !headless || editorPlaysHeadless(project.value.file);
     if (this.godotBridge.isConnected() && editorWouldPlay && given.value.length === 0 && !needsItsOwnProcess(asked.value)) {
-      return await this.playThroughEditor(sceneArgument, refreshed.value, project.value.path, alreadyPlaying, runtimeWaitMs, ended);
+      return await this.playThroughEditor(sceneArgument, refreshed.value, scanned, project.value.path, alreadyPlaying, runtimeWaitMs, ended);
     }
     const cmdArgs = runArguments({
       projectPath: project.value.path,
@@ -33211,7 +33332,12 @@ 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." : "";
@@ -33223,10 +33349,11 @@ class GodotServer {
       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),
       runtime: await this.runtimeUp(project.value.path, alreadyPlaying, runtimeWaitMs, given.value.length > 0),
@@ -33308,7 +33435,7 @@ class GodotServer {
       writeBootNote(run.projectPath, took);
     }
   }
-  async playThroughEditor(scene, refreshedClasses, projectPath, alreadyPlaying, runtimeWaitMs, ended) {
+  async playThroughEditor(scene, refreshedClasses, scanned, projectPath, alreadyPlaying, runtimeWaitMs, ended) {
     const log = new GameLog;
     try {
       await this.dap().connect();
@@ -33337,7 +33464,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,
@@ -33359,6 +33485,7 @@ class GodotServer {
       through: "editor",
       scene: scene === null ? "the main scene" : `res://${scene}`,
       refreshedClasses,
+      ...scanWaitAnswer(scanned),
       debugPort: readNumber(playAnswer, "debugPort"),
       endedPreviousRun: endedPreviousRun(ended),
       breakpoints: breakpoints.applied.length === 0 ? undefined : this.breakpointsAsProjectSpells(projectPath, breakpoints.applied),
@@ -33435,8 +33562,14 @@ class GodotServer {
   }
   async endActiveGame(reason, going) {
     const running = this.activeProcess;
-    const recorded = running?.process === null ? readRunRecord() : null;
-    clearRunRecord((record) => this.couldBeOurs(record.projectPath));
+    const recorded = running !== null && !running.throughEditor ? readRunRecord() : null;
+    const clearTheRecord = () => {
+      clearRunRecord((record) => this.couldBeOurs(record.projectPath));
+    };
+    const aKeeperHoldsIt = running !== null && going && !running.throughEditor && running.pid !== null;
+    if (!aKeeperHoldsIt) {
+      clearTheRecord();
+    }
     if (!running || !going) {
       return true;
     }
@@ -33444,16 +33577,13 @@ class GodotServer {
     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]);
     }
     if (running.pid === null) {
       return true;
     }
     if (recorded === null || recorded.pid !== running.pid || !stillTheRecordedRun(recorded)) {
+      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;
@@ -33466,12 +33596,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;
   }
   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 = () => {
@@ -33523,25 +33661,23 @@ 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,
@@ -33551,34 +33687,6 @@ class GodotServer {
       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) {
@@ -33634,7 +33742,6 @@ class GodotServer {
     const left = readEditorRunNote();
     const note = left !== null && project !== null && isSameDirectory(left.projectPath, project) ? left : null;
     const picked = {
-      process: null,
       pid: null,
       log: new GameLog,
       transcript: note?.transcript ?? null,
@@ -33771,7 +33878,6 @@ class GodotServer {
       return null;
     }
     const adopted = {
-      process: null,
       pid: record.pid,
       log: new GameLog,
       transcript: record.transcript,
@@ -33781,7 +33887,8 @@ class GodotServer {
       exitCode: null,
       exitSignal: null,
       throughEditor: false,
-      brokeOn: null
+      brokeOn: null,
+      pickedUp: true
     };
     this.drainTranscript(adopted);
     if (!alive(record.pid) || !couldStillBeTheRecordedRun(record)) {
@@ -33862,7 +33969,7 @@ class GodotServer {
   currentRun() {
     return this.activeProcess ?? this.adoptRecordedRun();
   }
-  async checkBoot(godotPath, projectPath, scene, args, userArgs, asked = {}) {
+  async checkBoot(godotPath, projectPath, scene, args, userArgs, scanned, asked = {}) {
     const frames = readPositiveNumber(args, "frames") ?? 3;
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 60000;
     const cmdArgs = runArguments({ projectPath, headless: true, scene, quitAfter: frames, userArgs });
@@ -33892,6 +33999,7 @@ class GodotServer {
       frames,
       errors,
       warnings,
+      ...scanWaitAnswer(scanned),
       savesNote: asked.savesIn !== undefined && savesStayPut() ? SAVES_NOT_MOVED_NOTE : undefined,
       entries: forAnswer(boot.log.select({ severity: "warning", sinceLastCall: false, limit: 200 }).entries)
     });
@@ -33915,8 +34023,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;
     }
@@ -33933,6 +34041,21 @@ class GodotServer {
     }
     return runIsUp(run, said);
   }
+  async untilTheExitIsRecorded(run) {
+    const until = Date.now() + EXIT_REPORTED_WITHIN_MS;
+    for (;; ) {
+      const record = readRunRecord();
+      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;
@@ -34034,7 +34157,8 @@ class GodotServer {
         throughEditor: run.throughEditor,
         announced: announced !== undefined || run.announcedPid !== undefined,
         couldAnnounce: run.projectPath !== null && existsSync10(join16(run.projectPath, RUNTIME_AUTOLOAD.path)),
-        endedHere: typeof run.endedHere === "string"
+        endedHere: typeof run.endedHere === "string",
+        pickedUp: run.pickedUp === true
       }));
     }
     if (run.pickedUpPlaying === true) {
@@ -34060,7 +34184,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,
@@ -34275,6 +34399,10 @@ class GodotServer {
     return now === null ? [] : lost.filter((name) => now.has(name));
   }
   async rebuildClassCache(projectPath) {
+    const scanned = await this.untilTheEditorsScanIsWritten(projectPath);
+    return withScanWait(await this.rebuildClassCacheFromDisk(projectPath), scanned);
+  }
+  async rebuildClassCacheFromDisk(projectPath) {
     const before = cachedClasses(projectPath);
     const writtenBefore = cacheWrittenAt(projectPath);
     const noted = readClassNote(projectPath);