gdharness 1.0.23 → 1.0.25

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(`
@@ -28192,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";
@@ -29260,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() {
@@ -29304,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) {
@@ -29718,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" } },
@@ -30148,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." }
     },
@@ -30244,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",
@@ -30364,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: {
@@ -30410,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: [],
@@ -30437,11 +30573,15 @@ 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"],
@@ -30461,17 +30601,31 @@ var TOOL_SPECS = [
         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. 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"]
       }
     }
   },
@@ -30632,7 +30786,7 @@ var TOOL_SPECS = [
       says: {
         type: "string",
         ops: ["until"],
-        description: "until: wait for these words to appear anywhere under nodePath, or anywhere in the game when no nodePath is given, instead of for a property, which is how a panel that rebuilds its labels is waited on at all: the labels are named afresh each redraw and the panel is what stays put. Case-insensitive, part of a line, on a node the player can see unless includeHidden says otherwise; a label with a line break is matched with the break in the words, and a backslash followed by n counts as one. Instead of, not as well as: a call carrying this and a property is refused, because they ask about different things and answering one of them silently is how a caller watches a screen believing they are watching a property."
+        description: "until: wait for these words to appear anywhere under nodePath, or anywhere in the game when no nodePath is given, instead of for a property, which is how a panel that rebuilds its labels is waited on at all: the labels are named afresh each redraw and the panel is what stays put. Case-insensitive, part of a line, on a node the player can see unless includeHidden says otherwise; a label with a line break is matched with the break in the words, and a backslash followed by n counts as one. Instead of, not as well as: a call carrying this and a property is refused, because they ask about different things and answering one of them silently is how a caller watches a screen believing they are watching a property. It looks every frame while a look is cheap and less often on a screen large enough for a look to cost a real share of a frame, so the game keeps its speed; the answer counts the frames the wait spanned and the looks it took."
       },
       includeHidden: {
         type: "boolean",
@@ -30803,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") {
@@ -30835,9 +31002,10 @@ 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;
@@ -31716,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", {
@@ -31725,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":
+      }
+      case "runtime_invoke": {
+        if (op === "result") {
+          return this.handleLateAnswer(args);
+        }
+        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":
@@ -31914,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"
         ])
@@ -32191,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);
@@ -32206,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
@@ -32280,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();
@@ -32324,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)}`;
@@ -32338,6 +32518,7 @@ class GodotServer {
               verdict,
               tests: 0,
               exitCode,
+              exitSignal: run.exitSignal ?? undefined,
               hung,
               arguments: cmdArgs,
               entries: forAnswer(printed.slice(0, 60)),
@@ -32348,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;
@@ -32365,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,
@@ -33096,6 +33278,7 @@ class GodotServer {
       projectPath,
       startedAt,
       exitCode: null,
+      exitSignal: null,
       throughEditor: true,
       brokeOn: null,
       announcedBefore: alreadyPlaying,
@@ -33249,6 +33432,7 @@ class GodotServer {
       projectPath: null,
       startedAt: Date.now(),
       exitCode: null,
+      exitSignal: null,
       throughEditor: false,
       brokeOn: null
     };
@@ -33258,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);
@@ -33298,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);
@@ -33388,6 +33575,7 @@ class GodotServer {
       projectPath: project,
       startedAt: note?.startedAt ?? Date.now(),
       exitCode: null,
+      exitSignal: null,
       throughEditor: true,
       brokeOn: null,
       pickedUpPlaying: true
@@ -33524,6 +33712,7 @@ class GodotServer {
       projectPath: record.projectPath === "" ? null : record.projectPath,
       startedAt: record.startedAt,
       exitCode: null,
+      exitSignal: null,
       throughEditor: false,
       brokeOn: null
     };
@@ -33531,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;
@@ -33630,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,
@@ -33656,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)) {
@@ -33764,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({
@@ -33788,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"),
@@ -33841,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."}${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)}`,
+      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)
     });
   }
@@ -34260,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);
       }
@@ -34296,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");
@@ -34325,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") {