gdharness 1.0.22 → 1.0.24

package/build/index.js

@@ -25504,14 +25504,43 @@ function chooseRuntime(endpoints, projectPath, unspoken = [], pid) {
   };
 }
 var nextRequestId = 1;
-function runtimeRequest(endpoint, command, params, timeoutMs) {
+var LATE_ANSWER_MS = 30 * 60000;
+var LATE_KEPT = 50;
+var lateAnswers = new Map;
+function keepLate(id, answer) {
+  lateAnswers.delete(id);
+  lateAnswers.set(id, answer);
+  while (lateAnswers.size > LATE_KEPT) {
+    const oldest = lateAnswers.keys().next().value;
+    if (oldest === undefined) {
+      break;
+    }
+    lateAnswers.delete(oldest);
+  }
+}
+function lateAnswer(id) {
+  return lateAnswers.get(id);
+}
+function runtimeRequest(endpoint, command, params, timeoutMs, keepListening = false) {
   const id = nextRequestId++;
+  const sentAt = Date.now();
   return new Promise((settle) => {
     let done = false;
+    let late = false;
     let buffered = "";
     let welcomed = false;
     const socket = createConnection({ port: endpoint.port, host: endpoint.address });
+    let lateTimer = null;
     const finish = (reply) => {
+      if (late) {
+        if (lateTimer !== null) {
+          clearTimeout(lateTimer);
+        }
+        socket.destroy();
+        keepLate(id, reply.ok || reply.reason === "error" ? { state: "answered", command, sentAt, answeredAt: Date.now(), reply } : { state: "never", command, sentAt, why: reply.message });
+        late = false;
+        return;
+      }
       if (done) {
         return;
       }
@@ -25521,10 +25550,32 @@ function runtimeRequest(endpoint, command, params, timeoutMs) {
       settle(reply);
     };
     const timer = setTimeout(() => {
-      finish({
+      const still = welcomed ? `The game (${describe2(endpoint)}) has the request and did not answer '${command}' within ${timeoutMs}ms.` : `The game (${describe2(endpoint)}) did not answer '${command}' within ${timeoutMs}ms and had not taken the request: its frame has not ended since it was sent, which a long frame or a breakpoint does, and the request runs when it does.`;
+      if (!keepListening) {
+        finish({
+          ok: false,
+          reason: "busy",
+          message: `${still} It is either working through something long or held at a breakpoint.`
+        });
+        return;
+      }
+      done = true;
+      late = true;
+      keepLate(id, { state: "waiting", command, sentAt });
+      lateTimer = setTimeout(() => {
+        finish({
+          ok: false,
+          reason: "busy",
+          message: `No answer came within ${LATE_ANSWER_MS / 60000} minutes.`
+        });
+      }, LATE_ANSWER_MS);
+      lateTimer.unref();
+      socket.unref();
+      settle({
         ok: false,
         reason: "busy",
-        message: `The game (${describe2(endpoint)}) accepted the connection but did not answer '${command}' within ${timeoutMs}ms. It may be paused at a breakpoint or stuck in a long frame.`
+        requestId: id,
+        message: `${still} Nothing was cancelled: a call that takes longer than the wait goes on and does everything it was asked, so read the state back rather than repeating it. runtime_invoke op result with requestId ${id} answers with its reply once it comes, and timeoutMs waits longer next time. A game held at a breakpoint instead is one debug_state stack answers about.`
       });
     }, timeoutMs);
     socket.setEncoding("utf8");
@@ -25536,7 +25587,7 @@ function runtimeRequest(endpoint, command, params, timeoutMs) {
       buffered += chunk;
       let newline = buffered.indexOf(`
 `);
-      while (newline !== -1 && !done) {
+      while (newline !== -1 && (!done || late)) {
         const line = buffered.slice(0, newline).trim();
         buffered = buffered.slice(newline + 1);
         newline = buffered.indexOf(`
@@ -27107,7 +27158,10 @@ class GodotBridge extends EventEmitter {
   get port() {
     return this.boundPort ?? this.wantedPort;
   }
-  async start() {
+  get configuredPort() {
+    return this.wantedPort;
+  }
+  async start(moveIfHeld = true) {
     if (this.httpServer) {
       return;
     }
@@ -27115,7 +27169,7 @@ class GodotBridge extends EventEmitter {
       await this.listenOn(this.wantedPort);
     } catch (error) {
       const held = error instanceof Error && "code" in error && error.code === "EADDRINUSE";
-      if (!held || !this.mayMove) {
+      if (!held || !this.mayMove || !moveIfHeld) {
         throw error;
       }
       this.log("warn", `Editor bridge port ${this.wantedPort} is held; taking another one.`);
@@ -28189,6 +28243,81 @@ function whyNoReport(printed, asked) {
   }
   return printed.some((line) => NOTHING_RAN.test(line)) ? `no test cases found at ${asked}` : null;
 }
+var ESCAPE = String.fromCharCode(27);
+var PRINTED_ACTUAL = new RegExp(` but was\\n '([\\s\\S]*?)'((?:${ESCAPE}\\[[0-9;]*m)*)\\tat ('[^'\\n]*' in \\S+:\\d+)`, "g");
+var COLOUR = new RegExp(`${ESCAPE}\\[([0-9;]*)m`, "g");
+var SPELLED = {
+  "<LF>": `
+`,
+  "<CR>": "\r",
+  "<TAB>": "\t",
+  "<BS>": "\b",
+  "<FF>": "\f",
+  "<VT>": "\v",
+  "<BEL>": "\x07",
+  "<ESC>": ESCAPE,
+  "<DEL>": ""
+};
+function unspelled(text) {
+  return text.replace(/<(?:LF|CR|TAB|BS|FF|VT|BEL|ESC|DEL|0x[0-9A-F]{2})>/g, (spelling) => spelling.startsWith("<0x") ? String.fromCharCode(Number.parseInt(spelling.slice(3, 5), 16)) : SPELLED[spelling] ?? spelling);
+}
+function readDiff(printed) {
+  let merged = "";
+  let actual = "";
+  let background = null;
+  let last = 0;
+  const take = (text) => {
+    merged += text;
+    if (background === null) {
+      actual += text;
+    } else if (background === "added") {
+      actual += unspelled(text);
+    }
+  };
+  for (const match of printed.matchAll(COLOUR)) {
+    take(printed.slice(last, match.index));
+    last = match.index + match[0].length;
+    const codes = (match[1] ?? "").split(";");
+    if (codes[0] === "48" && codes[1] === "2") {
+      background = Number(codes[2]) > Number(codes[3]) ? "missing" : "added";
+    } else if (codes[0] === "0" || codes[0] === "") {
+      background = null;
+    }
+  }
+  take(printed.slice(last));
+  return { merged, actual };
+}
+var BOTH_SIDES_ALIKE_NOTE = "[gdharness: the expected and the actual printed alike because gdUnit4 drops the marks that tell them apart when it writes its report, and the runner printed no copy of this one, so neither side above is the value the assertion found.]";
+function withActualsPrinted(failed, printed) {
+  const diffs = [...printed.replaceAll(`\r
+`, `
+`).matchAll(PRINTED_ACTUAL)].map((match) => ({
+    at: match[3] ?? "",
+    ...readDiff(match[1] ?? "")
+  }));
+  return failed.map((entry) => {
+    if (entry.detail === null) {
+      return entry;
+    }
+    let detail = entry.detail;
+    for (const diff of diffs) {
+      const wrong = ` but was
+ '${diff.merged.replaceAll("\r", "")}'
+	at ${diff.at}`;
+      if (detail.includes(wrong)) {
+        detail = detail.replace(wrong, () => ` but was
+ '${diff.actual}'
+	at ${diff.at}`);
+      }
+    }
+    const alike = /Expecting:\n '([\s\S]*)'\n but was\n '\1'\n\tat /.test(detail);
+    if (alike) {
+      detail = `${detail}
+${BOTH_SIDES_ALIKE_NOTE}`;
+    }
+    return detail === entry.detail ? entry : { ...entry, detail };
+  });
+}
 var RUNNING_SUITE = /Run Test Suite:\s*(\S+)/;
 var ORPHANS = /(\d+)\s+orphans/;
 var OVERALL = "Overall Summary";
@@ -29257,14 +29386,19 @@ function editorNoteAt(path) {
   }
   return { projectPath, transcript, startedAt };
 }
-function recordRunEnded(pid, exitCode) {
+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({ ...record, exitCode }, null, 2), "utf8");
+    writeFileSync9(path, JSON.stringify(written, null, 2), "utf8");
   } catch {}
 }
 function readRunRecord() {
@@ -29301,7 +29435,8 @@ function recordAt(path) {
     projectPath: typeof fields["projectPath"] === "string" ? fields["projectPath"] : "",
     arguments: Array.isArray(args) ? args.filter((value) => typeof value === "string") : [],
     ...typeof fields["command"] === "string" ? { command: fields["command"] } : {},
-    ...typeof fields["exitCode"] === "number" ? { exitCode: fields["exitCode"] } : {}
+    ...typeof fields["exitCode"] === "number" ? { exitCode: fields["exitCode"] } : {},
+    ...typeof fields["exitSignal"] === "string" ? { exitSignal: fields["exitSignal"] } : {}
   };
 }
 function runningAs(pid) {
@@ -29715,7 +29850,7 @@ var TILEMAP_CELLS = {
     additionalProperties: false
   }
 };
-var COLOUR = {
+var COLOUR2 = {
   type: "object",
   description: "set_theme_color: r, g and b from 0 to 1, with a optional and opaque by default.",
   properties: { r: { type: "number" }, g: { type: "number" }, b: { type: "number" }, a: { type: "number" } },
@@ -30145,7 +30280,7 @@ var TOOL_SPECS = [
       sources: TILESET_SOURCES,
       controlType: { type: "string", description: 'Theme ops: the Control class, such as "Button".' },
       colorName: { type: "string", description: 'set_theme_color: such as "font_color".' },
-      color: COLOUR,
+      color: COLOUR2,
       fontSizeName: { type: "string", description: 'set_theme_font_size: such as "font_size".' },
       size: { type: "number", description: "set_theme_font_size: pixels." }
     },
@@ -30241,7 +30376,7 @@ var TOOL_SPECS = [
   },
   {
     name: "editor_output",
-    description: "What the project started by editor_run has printed, as entries with a severity: the errors and warnings the engine reported, each with where it happened, and everything else as info. For a run the editor plays the reports come from the game itself, through the runtime addon, since the editor's debugger relays what a game prints and not what it reports; a played game without the runtime addon answers here with its prints alone. Answers with the counts and the verdict as well as the entries. heldAt is three answers: null for a run this server knows is not held, running or over, an object for one it knows is held at a breakpoint, whether the adapter said so or the runtime did by accepting a connection and never answering, and absent with heldUnknown beside it for a server that connected to the debugger after the stop and has no runtime to ask, since the adapter reports a stop only to the sessions connected when it happened. A run that has quit still answers here, with running false and its exit code, until the next one starts. A run this server started also answers with transcript, the file both its streams are written to: uncapped, written while the run is going, and the thing to read or tail for a long run rather than the engine's own log, which every engine start rotates away. Read the file for output and this answer for state: endedBy says whether gdharness ended the run, and a transcript that has stopped growing is a run between prints rather than a run that is over. running is asked of the operating system whenever there is a process to ask about, which is every run this server started and every editor-played run whose game announced its runtime. For an editor-played run that never announced, there is no process id here and running is the editor's answer, which can lag: one measured elsewhere reported a game as playing for fifteen seconds after its process had been ended from outside. editor_status names that game under runtimes, which does not depend on the editor answering. op: \"editor\" answers about the editor itself instead, which is a different log and the only way anything here can read what an editor printed: its console reaches no plugin, so the addon cannot scrape it, and an editor gdharness opened is asked for a log file as it starts. That covers the whole session from the editor's first line, which is where the output worth reading usually is, since the class cache, the plugins and the language server all say what they have to say before any harness has connected. The answer carries the entries in the order they were printed and, beside them under repeated, each message shape several lines share: how many, what varied in each slot of it and how many different values stood there, the first occurrence, and the ordinary lines above the group, found by walking back past the group rather than by counting lines. An editor somebody opened by hand has no console here and is refused saying so rather than answered empty, because an editor that printed nothing and an editor nobody captured are not the same thing.",
+    description: "What the project started by editor_run has printed, as entries with a severity: the errors and warnings the engine reported, each with where it happened, and everything else as info. For a run the editor plays the reports come from the game itself, through the runtime addon, since the editor's debugger relays what a game prints and not what it reports; a played game without the runtime addon answers here with its prints alone. Answers with the counts and the verdict as well as the entries. heldAt is three answers: null for a run this server knows is not held, running or over, an object for one it knows is held at a breakpoint, whether the adapter said so or the runtime did by accepting a connection and never answering, and absent with heldUnknown beside it for a server that connected to the debugger after the stop and has no runtime to ask, since the adapter reports a stop only to the sessions connected when it happened. A run that has quit still answers here, with running false and its exit code, until the next one starts; a run ended by a signal has no exit code, and exitSignal names the signal instead. A run this server started also answers with transcript, the file both its streams are written to: uncapped, written while the run is going, and the thing to read or tail for a long run rather than the engine's own log, which every engine start rotates away. Read the file for output and this answer for state: endedBy says whether gdharness ended the run, and a transcript that has stopped growing is a run between prints rather than a run that is over. running is asked of the operating system whenever there is a process to ask about, which is every run this server started and every editor-played run whose game announced its runtime. For an editor-played run that never announced, there is no process id here and running is the editor's answer, which can lag: one measured elsewhere reported a game as playing for fifteen seconds after its process had been ended from outside. editor_status names that game under runtimes, which does not depend on the editor answering. op: \"editor\" answers about the editor itself instead, which is a different log and the only way anything here can read what an editor printed: its console reaches no plugin, so the addon cannot scrape it, and an editor gdharness opened is asked for a log file as it starts. That covers the whole session from the editor's first line, which is where the output worth reading usually is, since the class cache, the plugins and the language server all say what they have to say before any harness has connected. The answer carries the entries in the order they were printed and, beside them under repeated, each message shape several lines share: how many, what varied in each slot of it and how many different values stood there, the first occurrence, and the ordinary lines above the group, found by walking back past the group rather than by counting lines. An editor somebody opened by hand has no console here and is refused saying so rather than answered empty, because an editor that printed nothing and an editor nobody captured are not the same thing.",
     parameters: {
       severity: {
         type: "string",
@@ -30287,7 +30422,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, which is that it was held when the bridge started, most often by the server a reconnect replaced.",
+    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.",
     parameters: {},
     requires: []
   },
@@ -30361,7 +30496,7 @@ var TOOL_SPECS = [
       property: {
         type: "string",
         ops: ["property", "find"],
-        description: 'property: which one to read. find: read this one off every node matched, so a panel of labels is one call rather than one per label. Colons read through what a node holds, "_game:clock:speed", which is where a game keeps what is worth asking about. A number or a key steps into a list or a map, "_game:run:roster:0:traits", which is how the lists a game keeps its state in are walked: a roster, a board, an in-tray. A negative number counts from the end. A step written as a call, "get_viewport():gui_get_focus_owner()", calls a method that takes no arguments and walks into what it returned, which is how a question only a method answers is read in one call: which control holds the focus in the viewport this one is in. A step that is not there is named, and says what was there instead.'
+        description: 'property: which one to read. find: read this one off every node matched, so a panel of labels is one call rather than one per label. Colons read through what a node holds, "_game:clock:speed", which is where a game keeps what is worth asking about. A number or a key steps into a list or a map, "_game:run:roster:0:traits", which is how the lists a game keeps its state in are walked: a roster, a board, an in-tray. A negative number counts from the end. A step written as a call, "get_viewport():gui_get_focus_owner()", calls a method that takes no arguments and walks into what it returned, which is how a question only a method answers is read in one call: which control holds the focus in the viewport this one is in. A list or a map answers the calls that read it and take no arguments, "_game:run:board:size()" or "_game:inbox:keys()", and not those that change it, such as clear() or sort(). A step that is not there is named, and says what was there instead.'
       },
       depth: { type: "number", ops: ["tree"], description: "tree: levels to descend. Default 3." },
       includeProperties: {
@@ -30407,6 +30542,10 @@ var TOOL_SPECS = [
         items: { type: "string" },
         ops: ["metrics"],
         description: "metrics: which to read. Default all."
+      },
+      timeoutMs: {
+        type: "number",
+        description: "How long to wait for the answer before answering pending with a requestId, which runtime_invoke op result collects the reply by. Default 10000, or GDHARNESS_RUNTIME_TIMEOUT_MS."
       }
     },
     requires: [],
@@ -30434,20 +30573,24 @@ var TOOL_SPECS = [
   },
   {
     name: "runtime_invoke",
-    description: "Sets a property or calls a method on a node in the running game. Needs the game running with the runtime addon.",
+    description: "Sets a property or calls a method on a node in the running game. Needs the game running with the runtime addon. A call that takes longer than timeoutMs is not cancelled: the answer is pending: true with a requestId, the call goes on and does everything it was asked, and op result with that requestId collects its reply once it comes.",
     parameters: {
       projectPath: RUNNING_PROJECT_PATH,
       pid: RUNNING_PID,
-      nodePath: { type: "string", description: 'Absolute node path, such as "/root/Main/Player".' },
+      nodePath: {
+        type: "string",
+        ops: ["set", "call"],
+        description: 'Absolute node path, such as "/root/Main/Player".'
+      },
       property: {
         type: "string",
         ops: ["set"],
-        description: 'set: which one to write. Colons write through what a node holds, "_game:run:day", and a number or a key steps into a list or a map on the way, "_game:run:roster:0:name", a negative number counting from the end, and a step written as a call, "get_viewport():gui_embed_subwindows", walks through what a method taking no arguments returned. The answer reads back off the same holder, so a write a typed container refused shows as an unchanged value.'
+        description: 'set: which one to write. Colons write through what a node holds, "_game:run:day", and a number or a key steps into a list or a map on the way, "_game:run:roster:0:name", a negative number counting from the end, and a step written as a call, "get_viewport():gui_embed_subwindows", walks through what a method taking no arguments returned. The answer reads back off the same holder, and a write that leaves the property as it was, because the engine would not take it, is refused and says what the property still holds.'
       },
       value: {
         ops: ["set"],
         blank: true,
-        description: `set: the value, fitted to the property's type. "" writes an empty string. A property typed as or holding an object takes a path naming one the game holds, the way call's args do, and holds that instance.`
+        description: `set: the value, fitted to the property's type. "" writes an empty string. A property typed as or holding an object takes a path naming one the game holds, the way call's args do, and holds that instance. A typed list or map, such as Array[int] or Dictionary[String, int], takes a JSON list or object with each element fitted to its element type, and an element that cannot become one is refused by its index or key.`
       },
       method: {
         type: "string",
@@ -30457,18 +30600,32 @@ var TOOL_SPECS = [
       args: {
         type: "array",
         ops: ["call"],
-        description: `call: the arguments, fitted to the method's parameter types. A parameter typed as an object takes a path naming one the game holds and is handed that instance: a colon path read from nodePath, "_game:run:wares:3", or one starting at a node, "/root/Main/Hud" or "/root/Main:_game:run". A path that reaches no object, or an object of another class than the parameter declares, is refused.`
+        description: `call: the arguments, fitted to the method's parameter types. A parameter typed as an object takes a path naming one the game holds and is handed that instance: a colon path read from nodePath, "_game:run:wares:3", or one starting at a node, "/root/Main/Hud" or "/root/Main:_game:run". A path that reaches no object, or an object of another class than the parameter declares, is refused. A parameter typed as a list or map, such as Array[int] or Array[Gear], is built from a JSON list or object element by element, objects named by their paths.`
+      },
+      timeoutMs: {
+        type: "number",
+        ops: ["set", "call"],
+        description: "set, call: how long to wait for the answer before answering pending with a requestId, which does not stop the call. Default 10000, or GDHARNESS_RUNTIME_TIMEOUT_MS. Give a longer one for a call known to take a while, such as one that plays many turns in one go."
+      },
+      requestId: {
+        type: "number",
+        ops: ["result"],
+        description: "result: the requestId a pending answer gave."
       }
     },
-    requires: ["nodePath"],
+    requires: [],
     operations: {
       set: {
         summary: "set a property, on a node or on an object it holds",
-        requires: ["property", "value"]
+        requires: ["nodePath", "property", "value"]
       },
       call: {
         summary: "call a method, on a node or on an object it holds, and return its result",
-        requires: ["method"]
+        requires: ["nodePath", "method"]
+      },
+      result: {
+        summary: "collect the reply to a set or call whose wait ran out, by the requestId it answered with",
+        requires: ["requestId"]
       }
     }
   },
@@ -30800,8 +30957,21 @@ function describeHalt(halt) {
       return `stopped with reason "${halt.reason}"`;
   }
 }
+function exited(run) {
+  return run.exitCode !== null || run.exitSignal !== null;
+}
+function endingOf(failed) {
+  return {
+    exitCode: typeof failed.code === "number" ? failed.code : null,
+    exitSignal: typeof failed.signal === "string" ? failed.signal : null,
+    failure: typeof failed.code === "string" ? failed.code : null
+  };
+}
+function howItExited(run) {
+  return run.exitSignal === null ? `exit code ${run.exitCode ?? "unknown"}` : `ended by ${run.exitSignal}, with no exit code`;
+}
 function stillRunning(run) {
-  if (run?.exitCode !== null || run.endedUnwatched === true) {
+  if (run === null || exited(run) || run.endedUnwatched === true) {
     return false;
   }
   if (typeof run.endedHere === "string") {
@@ -30832,7 +31002,17 @@ function runIsUp(run, editorSays, now = Date.now()) {
   return editorSays ?? stillRunning(run);
 }
 function noCodeWillCome(run) {
-  return run.exitCode === null && run.process === null;
+  return !exited(run) && run.process === null;
+}
+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));
+  const deadline = Date.now() + withinMs;
+  while (!gone() && Date.now() < deadline) {
+    await delay3(50);
+  }
+  return gone();
 }
 function endedWithoutACode(run) {
   if (!run.throughEditor) {
@@ -31019,6 +31199,8 @@ function outsideTheirLists(spec, args) {
 }
 var BRIDGE_RETRY_MS = 2000;
 var SUCCESSOR_CHECK_MS = 1e4;
+var HANDOVER_MS = SUCCESSOR_CHECK_MS + 5000;
+var HANDOVER_POLL_MS = 250;
 var CACHE_WRITE_MS = 2000;
 var PLAYING_STATUS_MS = 1000;
 var SCAN_START_MS = 2000;
@@ -31152,6 +31334,8 @@ class GodotServer {
   launchedFrom = null;
   ownProject;
   announcedAt = null;
+  handingOverFrom = null;
+  notHandedOverBy = null;
   constructor() {
     this.ownProject = envValue("GDHARNESS_PROJECT") ?? null;
     this.godotBridge = getDefaultBridge(this.ownProject);
@@ -31198,6 +31382,7 @@ class GodotServer {
     });
     console.error("gdharness running on stdio");
     try {
+      await this.takeOverFromAPredecessor();
       await this.godotBridge.start();
       this.bridgeStartupError = null;
       const bridgeStatus = this.godotBridge.getStatus();
@@ -31212,6 +31397,35 @@ class GodotServer {
       this.keepTryingTheBridge();
     }
   }
+  async takeOverFromAPredecessor() {
+    if (this.ownProject === null) {
+      return;
+    }
+    const wanted = this.godotBridge.configuredPort;
+    const announced = readAnnouncement(announcementPath(this.ownProject));
+    if (announced === null || announced.pid === process.pid || announced.port !== wanted || !alive(announced.pid)) {
+      return;
+    }
+    this.handingOverFrom = announced.pid;
+    this.announcedAt = announceBridge(this.ownProject, {
+      host: this.godotBridge.getStatus().host,
+      port: wanted,
+      version: SERVER_VERSION
+    });
+    const until = Date.now() + HANDOVER_MS;
+    let taken = false;
+    while (!taken && Date.now() < until && !this.shutdownInitiated) {
+      try {
+        await this.godotBridge.start(false);
+        taken = true;
+        this.logDebug(`Took port ${wanted} over from pid ${announced.pid}`);
+      } catch {
+        await delay3(HANDOVER_POLL_MS);
+      }
+    }
+    this.handingOverFrom = null;
+    this.notHandedOverBy = taken ? null : announced.pid;
+  }
   keepTryingTheBridge() {
     if (this.bridgeRetry !== null || this.shutdownInitiated) {
       return;
@@ -31670,7 +31884,8 @@ class GodotServer {
         return await this.handleEditorStatus();
       case "editor_rescan":
         return await this.handleRescanFilesystem(args);
-      case "runtime_inspect":
+      case "runtime_inspect": {
+        const patience = readPositiveNumber(args, "timeoutMs") ?? this.runtimeTimeoutMs();
         switch (op) {
           case "tree":
             return await this.handleRuntimeCommand("get_tree", {
@@ -31679,45 +31894,45 @@ class GodotServer {
               depth: readPositiveNumber(args, "depth") ?? 3,
               include_properties: readBoolean(args, "includeProperties") ?? false,
               properties: readArray(args, "properties") ?? []
-            });
+            }, patience);
           case "find":
-            return await this.handleFindRuntimeNodes(args);
+            return await this.handleFindRuntimeNodes(args, patience);
           case "text":
             return await this.handleRuntimeCommand("read_text", {
               ...whichGame(args),
               root: readNonEmptyString(args, "nodePath") ?? "/root",
               include_hidden: readBoolean(args, "includeHidden") ?? false,
               limit: readPositiveNumber(args, "limit") ?? 500
-            });
+            }, patience);
           case "rect":
-            return await this.handleRuntimeCommand("get_rect", {
-              ...whichGame(args),
-              path: readNonEmptyString(args, "nodePath") ?? ""
-            });
+            return await this.handleRuntimeCommand("get_rect", { ...whichGame(args), path: readNonEmptyString(args, "nodePath") ?? "" }, patience);
           case "property":
             return await this.handleRuntimeCommand("get_property", {
               ...whichGame(args),
               path: readNonEmptyString(args, "nodePath") ?? "",
               property: readNonEmptyString(args, "property") ?? ""
-            });
+            }, patience);
           default:
-            return await this.handleRuntimeCommand("get_metrics", {
-              ...whichGame(args),
-              metrics: readArray(args, "metrics") ?? []
-            });
+            return await this.handleRuntimeCommand("get_metrics", { ...whichGame(args), metrics: readArray(args, "metrics") ?? [] }, patience);
+        }
+      }
+      case "runtime_invoke": {
+        if (op === "result") {
+          return this.handleLateAnswer(args);
         }
-      case "runtime_invoke":
+        const patience = readPositiveNumber(args, "timeoutMs") ?? this.runtimeTimeoutMs();
         return op === "set" ? await this.handleRuntimeCommand("set_property", {
           ...whichGame(args),
           path: readNonEmptyString(args, "nodePath") ?? "",
           property: readString(args, "property") ?? "",
           value: args["value"]
-        }) : await this.handleRuntimeCommand("call_method", {
+        }, patience) : await this.handleRuntimeCommand("call_method", {
           ...whichGame(args),
           path: readNonEmptyString(args, "nodePath") ?? "",
           method: readString(args, "method") ?? "",
           args: readArray(args, "args") ?? []
-        });
+        }, patience);
+      }
       case "runtime_capture":
         return await this.handleRuntimeCommand(op === "screenshot" ? "capture_screenshot" : "capture_viewport", args);
       case "runtime_input":
@@ -31868,10 +32083,10 @@ class GodotServer {
   }
   async debuggedGame(intent) {
     const game = this.activeProcess;
-    if (game !== null && game.exitCode !== null) {
+    if (game !== null && exited(game)) {
       return {
         ok: false,
-        response: this.createErrorResponse(`The last run has already finished (exit code ${game.exitCode}), so there is no debug session to answer for.`, [
+        response: this.createErrorResponse(`The last run has already finished (${howItExited(game)}), so there is no debug session to answer for.`, [
           "editor_output still reads what it printed, until the next run starts",
           "editor_run start plays another, which the debugger can hold"
         ])
@@ -32145,10 +32360,11 @@ class GodotServer {
     ];
     this.logDebug(`Exporting: ${engine.value} ${exportArgs.join(" ")}`);
     const log = new GameLog;
-    let exitCode = 0;
+    let ending = { exitCode: 0, exitSignal: null, failure: null };
     try {
       const { stdout, stderr } = await run5(engine.value, exportArgs, {
         timeout: 300000,
+        maxBuffer: 64 * 1024 * 1024,
         signal: callSignal()
       });
       log.append("stdout", stdout);
@@ -32160,26 +32376,32 @@ class GodotServer {
       const failed = error;
       log.append("stdout", failed.stdout);
       log.append("stderr", failed.stderr);
-      exitCode = typeof failed.code === "number" ? failed.code : -1;
+      ending = endingOf(failed);
     } finally {
       discard(exportLogs);
     }
     log.finish();
     const problems = log.select({ severity: "warning", sinceLastCall: false, limit: 200 });
     const verdict = {
-      exported: exitCode === 0 && log.count("error") === 0 && existsSync10(output.absolutePath),
+      exported: ending.exitCode === 0 && log.count("error") === 0 && existsSync10(output.absolutePath),
       preset,
       outputPath: output.relativePath,
       debug,
-      exitCode,
+      exitCode: ending.exitCode,
+      exitSignal: ending.exitSignal ?? undefined,
+      failure: ending.failure ?? undefined,
       errors: log.count("error"),
       warnings: log.count("warning"),
       entries: forAnswer(problems.entries)
     };
     if (!verdict.exported) {
+      const why = ending.exitSignal === null ? ending.failure === null ? "" : ` The engine was ended by Node (${ending.failure}), so it has no exit code.` : ` The engine was ended by ${ending.exitSignal}, so it has no exit code: the export ran past its five minutes or the call was cancelled.`;
       return {
         content: [
-          { type: "text", text: `Export with preset '${preset}' did not produce ${output.relativePath}.` },
+          {
+            type: "text",
+            text: `Export with preset '${preset}' did not produce ${output.relativePath}.${why}`
+          },
           { type: "text", text: JSON.stringify(verdict, null, 2) }
         ],
         isError: true
@@ -32234,6 +32456,10 @@ class GodotServer {
     this.logDebug(`Running tests: ${engine.value} ${cmdArgs.join(" ")}`);
     const userData = mkdtempSync2(join16(tmpdir4(), "gdharness-tests-"));
     const run = this.spawnGame(engine.value, cmdArgs, userDataIn(userData));
+    const console2 = [];
+    run.process.stdout?.on("data", (data) => {
+      console2.push(data);
+    });
     const hung = await new Promise((resolve) => {
       const timer = setTimeout(() => {
         run.process.kill();
@@ -32278,7 +32504,7 @@ class GodotServer {
     const printed = run.log.select({ severity: "info", sinceLastCall: false, limit: 200 }).entries;
     const said = printed.map((entry) => entry.text);
     const nothingRan = hung ? null : whyNoReport(said, asked);
-    const verdict = hung ? `hung: killed after ${timeoutMs} ms` : nothingRan ?? verdicts[exitCode ?? -1] ?? `exit ${exitCode ?? "unknown"}`;
+    const verdict = hung ? `hung: killed after ${timeoutMs} ms` : nothingRan ?? (exitCode === null ? undefined : verdicts[exitCode]) ?? (run.exitSignal === null ? `exit ${exitCode ?? "unknown"}` : howItExited(run));
     const savesNote = savesStayPut() && nothingRan === null ? SAVES_NOT_MOVED_NOTE : undefined;
     if (report === null) {
       const note = nothingRan === null ? `The test run wrote no report (${verdict}${reportProblem ? `; ${reportProblem}` : ""}).` : `No tests ran: ${verdict}.${elsewhereIn(project.value.path, asked)}`;
@@ -32292,6 +32518,7 @@ class GodotServer {
               verdict,
               tests: 0,
               exitCode,
+              exitSignal: run.exitSignal ?? undefined,
               hung,
               arguments: cmdArgs,
               entries: forAnswer(printed.slice(0, 60)),
@@ -32302,7 +32529,7 @@ class GodotServer {
         isError: true
       };
     }
-    const failed = report.suites.flatMap((suite) => suite.cases.filter((entry) => entry.status === "failed" || entry.status === "error").map((entry) => ({ ...entry, path: suite.path })));
+    const failed = withActualsPrinted(report.suites.flatMap((suite) => suite.cases.filter((entry) => entry.status === "failed" || entry.status === "error").map((entry) => ({ ...entry, path: suite.path }))), Buffer.concat(console2).toString("utf8"));
     const orphans = orphansPrinted(said);
     const leftBehind = new Map(orphans.suites.map((suite) => [suite.path, suite.orphans]));
     const orphansIn = (path) => path === null ? 0 : leftBehind.get(path) ?? 0;
@@ -32319,6 +32546,7 @@ class GodotServer {
       passed: !hung && exitCode === 0 && report.failures === 0 && report.errors === 0,
       verdict,
       exitCode,
+      exitSignal: run.exitSignal ?? undefined,
       tests: report.tests,
       failures: report.failures,
       errors: report.errors,
@@ -32585,7 +32813,12 @@ class GodotServer {
       awaitingLaunchedEditor: status.connected || !this.launchedEditorIsUp() ? undefined : this.launchedEditor?.pid ?? undefined,
       ...status.connected ? this.whatTheLaunchedEditorDropped() : {},
       startupError: this.bridgeStartupError,
-      portNote: status.portWanted === undefined ? undefined : `Port ${status.portWanted}, the one this server was configured with, was held by another process when the bridge started, so it took ${status.port} and announced that where the editor looks for it${this.announcedAt === null ? "" : `, ${this.announcedAt}`}. The editor finds it there; the next server started takes ${status.portWanted} again if it is free.`,
+      portNote: status.portWanted === undefined ? undefined : `Port ${status.portWanted}, the one this server was configured with, was held ${this.notHandedOverBy === null ? "by another process" : `by pid ${this.notHandedOverBy}, the gdharness server this one replaced, which had not let go of it ${HANDOVER_MS / 1000} seconds after being told it was replaced`} when the bridge started, so it took ${status.port} and announced that where the editor looks for it${this.announcedAt === null ? "" : `, ${this.announcedAt}`}. The editor finds it there; the next server started takes ${status.portWanted} again if it is free.`,
+      bridgeHandover: this.handingOverFrom === null ? undefined : {
+        fromPid: this.handingOverFrom,
+        port: this.godotBridge.configuredPort,
+        note: `The gdharness server this one replaced, pid ${this.handingOverFrom}, still holds port ${this.godotBridge.configuredPort} and is standing down; this server takes the port when it lets go, and takes another after ${HANDOVER_MS / 1000} seconds if it does not.`
+      },
       staleNote: stale ? addonMismatch(status.addonVersion, SERVER_VERSION, status.addonDigest, shippedEditorDigest()) : undefined,
       addonNote: status.connected ? sameCodeNote(status.addonVersion, SERVER_VERSION, status.addonDigest, shippedEditorDigest()) : undefined,
       ...this.breakpointsAtRisk(),
@@ -33045,6 +33278,7 @@ class GodotServer {
       projectPath,
       startedAt,
       exitCode: null,
+      exitSignal: null,
       throughEditor: true,
       brokeOn: null,
       announcedBefore: alreadyPlaying,
@@ -33137,24 +33371,25 @@ class GodotServer {
     const recorded = running?.process === null ? readRunRecord() : null;
     clearRunRecord((record) => this.couldBeOurs(record.projectPath));
     if (!running || !going) {
-      return;
+      return true;
     }
     running.endedHere = reason;
+    const announced = this.announcedPidOf(running);
     if (running.throughEditor) {
       await this.handleViaBridge("stop_playing", {});
-      return;
+      return await untilGone(null, announced === undefined ? [] : [announced]);
     }
     if (running.process !== null) {
       running.process.kill();
-      return;
+      return await untilGone(running.process, announced === undefined ? [] : [announced]);
     }
     if (running.pid === null) {
-      return;
+      return true;
     }
     if (recorded === null || recorded.pid !== running.pid || !stillTheRecordedRun(recorded)) {
       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;
+      return true;
     }
     const signalled = runningAs(running.pid);
     const described = signalled === null ? "nothing it would name" : `${signalled.kind}: ${signalled.text}`;
@@ -33164,7 +33399,9 @@ class GodotServer {
     } catch {
       landed = false;
     }
+    const gone = await untilGone(null, [running.pid]);
     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 } : {} });
@@ -33195,6 +33432,7 @@ class GodotServer {
       projectPath: null,
       startedAt: Date.now(),
       exitCode: null,
+      exitSignal: null,
       throughEditor: false,
       brokeOn: null
     };
@@ -33204,13 +33442,11 @@ class GodotServer {
     child.stderr.on("data", (data) => {
       log.append("stderr", data);
     });
-    child.on("exit", (code) => {
-      this.logDebug(`Godot process exited with code ${code ?? "none"}`);
+    child.on("exit", (code, signal) => {
+      this.logDebug(`Godot process exited with code ${code ?? "none"}, signal ${signal ?? "none"}`);
       log.finish();
-      started.exitCode = code ?? -1;
-      if (started.pid !== null) {
-        recordRunEnded(started.pid, started.exitCode);
-      }
+      started.exitCode = code;
+      started.exitSignal = code === null ? signal : null;
     });
     child.on("error", (err) => {
       console.error("Failed to start Godot process:", err);
@@ -33244,14 +33480,19 @@ class GodotServer {
       projectPath,
       startedAt,
       exitCode: null,
+      exitSignal: null,
       throughEditor: false,
       brokeOn: null
     };
-    child.on("exit", (code) => {
-      this.logDebug(`Godot process exited with code ${code ?? "none"}`);
+    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 ?? -1;
+      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);
@@ -33334,6 +33575,7 @@ class GodotServer {
       projectPath: project,
       startedAt: note?.startedAt ?? Date.now(),
       exitCode: null,
+      exitSignal: null,
       throughEditor: true,
       brokeOn: null,
       pickedUpPlaying: true
@@ -33470,6 +33712,7 @@ class GodotServer {
       projectPath: record.projectPath === "" ? null : record.projectPath,
       startedAt: record.startedAt,
       exitCode: null,
+      exitSignal: null,
       throughEditor: false,
       brokeOn: null
     };
@@ -33477,7 +33720,8 @@ class GodotServer {
     if (!alive(record.pid) || !couldStillBeTheRecordedRun(record)) {
       adopted.log.finish();
       adopted.exitCode = record.exitCode ?? null;
-      adopted.endedUnwatched = record.exitCode === undefined;
+      adopted.exitSignal = record.exitSignal ?? null;
+      adopted.endedUnwatched = !exited(adopted);
     }
     this.activeProcess = adopted;
     return adopted;
@@ -33576,6 +33820,7 @@ class GodotServer {
       booted: !hung && boot.exitCode === 0 && errors === 0,
       hung,
       exitCode: boot.exitCode,
+      exitSignal: boot.exitSignal ?? undefined,
       durationMs: Date.now() - boot.startedAt,
       frames,
       errors,
@@ -33602,7 +33847,11 @@ class GodotServer {
   }
   async runStillGoing(run, editorSays) {
     if (!run.throughEditor) {
-      return stillRunning(run);
+      const going = stillRunning(run);
+      if (!going && run.process !== null && !exited(run)) {
+        await untilGone(run.process, [], EXIT_REPORTED_WITHIN_MS);
+      }
+      return going;
     }
     const announced = this.announcedPidOf(run);
     if (announced !== undefined && !alive(announced)) {
@@ -33710,8 +33959,8 @@ class GodotServer {
     }
     if (typeof run.endedHere === "string") {
       notes.push(`This run was ended here, by ${run.endedHere}.`);
-    } else if (!stillRunning(run) && !run.throughEditor && run.exitCode !== null) {
-      notes.push(run.exitCode === 0 ? "This run quit on its own, cleanly: exit code 0." : "Nothing here ended this run: it stopped on its own or something outside this server stopped it.");
+    } else if (!stillRunning(run) && !run.throughEditor && exited(run)) {
+      notes.push(run.exitCode === 0 ? "This run quit on its own, cleanly: exit code 0." : run.exitSignal === null ? "Nothing here ended this run: it stopped on its own or something outside this server stopped it." : `Nothing here ended this run: something outside this server sent it ${run.exitSignal}, so it has no exit code.`);
     }
     if (run.endedUnwatched === true) {
       notes.push(endedWithoutACode({
@@ -33734,6 +33983,7 @@ class GodotServer {
     return this.jsonTextResponse({
       running: going,
       exitCode: run.exitCode,
+      exitSignal: run.exitSignal ?? undefined,
       through: run.throughEditor ? "editor" : "gdharness",
       pid: run.pid ?? announced ?? run.announcedPid ?? null,
       errors: run.log.count("error"),
@@ -33766,7 +34016,7 @@ 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");
-    await this.endActiveGame("editor_run stop", wasRunning);
+    const gone = await this.endActiveGame("editor_run stop", wasRunning);
     const ended = children === null ? null : endChildrenAmong(children);
     if (wasRunning) {
       for (const pid of new Set([endedPid, announcedPid])) {
@@ -33787,10 +34037,11 @@ class GodotServer {
       },
       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."} ${aboutTheChildren(ended, stopped.throughEditor)}`,
+      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)}`,
       entries: forAnswer(stopped.log.select({ severity: "warning", sinceLastCall: false, limit: 200 }).entries)
     });
   }
@@ -34206,7 +34457,17 @@ class GodotServer {
     const screenshotDir = expectsScreenshot ? mkdtempSync2(join16(tmpdir4(), "gdharness-runtime-screenshot-")) : null;
     const screenshotPath = screenshotDir ? join16(screenshotDir, "capture.png") : null;
     try {
-      const reply = await runtimeRequest(choice.endpoint, command, screenshotPath ? { ...params, output_path: screenshotPath } : params, timeoutMs);
+      const reply = await runtimeRequest(choice.endpoint, command, screenshotPath ? { ...params, output_path: screenshotPath } : params, timeoutMs, !expectsScreenshot);
+      if (!reply.ok && reply.requestId !== undefined) {
+        return this.jsonTextResponse({
+          pending: true,
+          requestId: reply.requestId,
+          command,
+          waitedMs: timeoutMs,
+          note: reply.message,
+          ...answeredBy
+        });
+      }
       if (!reply.ok) {
         return this.createErrorResponse(reply.message);
       }
@@ -34242,7 +34503,36 @@ class GodotServer {
       discard(screenshotDir);
     }
   }
-  async handleFindRuntimeNodes(args) {
+  handleLateAnswer(args) {
+    const requestId = readPositiveNumber(args, "requestId") ?? 0;
+    const late = lateAnswer(requestId);
+    if (late === undefined) {
+      return this.createErrorResponse(`No request ${requestId} is waiting to be collected here: an id is kept only from a pending answer this server gave, and only for its fifty most recent.`);
+    }
+    if (late.state === "waiting") {
+      return this.jsonTextResponse({
+        pending: true,
+        requestId,
+        command: late.command,
+        sentAgoMs: Date.now() - late.sentAt,
+        note: "The game has not answered it yet. It is still being listened for, and this answers with the reply once it comes."
+      });
+    }
+    if (late.state === "never") {
+      return this.createErrorResponse(`Request ${requestId} ('${late.command}') got no answer: ${late.why} Read the state back to see whether it ran.`);
+    }
+    const reply = late.reply;
+    if (!reply.ok) {
+      return this.createErrorResponse(`Request ${requestId} ('${late.command}') was answered with a refusal: ${reply.message}`);
+    }
+    const { id: _id, ...payload } = reply.payload;
+    return this.jsonTextResponse({
+      ...payload,
+      requestId,
+      answeredAfterMs: late.answeredAt - late.sentAt
+    });
+  }
+  async handleFindRuntimeNodes(args, patience) {
     const filters = {};
     const className = readNonEmptyString(args, "className");
     const script = readNonEmptyString(args, "script");
@@ -34271,7 +34561,7 @@ class GodotServer {
       limit: readPositiveNumber(args, "limit") ?? 100,
       ...property === undefined ? {} : { property },
       ...includeHidden === undefined ? {} : { include_hidden: includeHidden }
-    });
+    }, patience);
   }
   async handleRuntimeWait(op, args) {
     if (op === "frames") {