gdharness 1.1.23 → 1.1.24

package/build/godot/addons/gdharness_runtime/runtime_autoload.gd

@@ -44,6 +44,11 @@ const EDITOR_PID_VARIABLE: String = "GDHARNESS_EDITOR_PID"
 ## `errorReportPath` in src/runtime-client.ts.
 const ERROR_REPORT_NAME: String = "runtime-%d.log"
 
+## Written beside this addon by setup and upgrade. Kept in step with `VERSION_MARKER` and
+## `DIGEST_MARKER` in src/setup.ts.
+const VERSION_MARKER: String = "res://addons/gdharness_runtime/.gdharness-version"
+const DIGEST_MARKER: String = "res://addons/gdharness_runtime/.gdharness-digest"
+
 var values: Values = Values.new()
 
 # The modules are members and not locals of _init, because a Callable holds its object by id
@@ -76,6 +81,11 @@ var _announcement: String = ""
 var _errors: ErrorReport
 ## Every command, by the name a request uses, as the module method that answers it.
 var _commands: Dictionary = {}
+## The addon this game loaded, read once at start: an upgrade rewrites the markers under a running
+## game, whose code stays what it loaded, and reading them later would call that code current.
+## Empty when the markers cannot be read, as in a copy made by hand.
+var _loaded_version: String = _read_marker(VERSION_MARKER)
+var _loaded_digest: String = _read_marker(DIGEST_MARKER)
 
 
 func _init() -> void:
@@ -336,6 +346,8 @@ func _identity(bind_address: String) -> Dictionary:
 			"path": ProjectSettings.globalize_path("res://").rstrip("/")
 		},
 		"godot": Engine.get_version_info().get("string", ""),
+		"addon_version": _loaded_version,
+		"addon_digest": _loaded_digest,
 	}
 	var played_by: String = OS.get_environment(EDITOR_PID_VARIABLE)
 	if played_by.is_valid_int():
@@ -343,6 +355,17 @@ func _identity(bind_address: String) -> Dictionary:
 	return identity
 
 
+static func _read_marker(path: String) -> String:
+	if not FileAccess.file_exists(path):
+		return ""
+	var file: FileAccess = FileAccess.open(path, FileAccess.READ)
+	if file == null:
+		return ""
+	var text: String = file.get_as_text().strip_edges()
+	file.close()
+	return text
+
+
 func _send_welcome(client: StreamPeerTCP) -> void:
 	var welcome: Dictionary = _identity(
 		str(ProjectSettings.get_setting(BIND_ADDRESS_SETTING, DEFAULT_BIND_ADDRESS))

package/build/index.js

@@ -10074,6 +10074,33 @@ function addonMismatch(addonVersion, serverVersion, addonDigest, shippedDigest,
   }
   return `${both} ${restart}`;
 }
+function runtimeAddonUnknown(addon) {
+  return addon?.version === "" && addon.digest === "";
+}
+function runtimeMismatch(pid, addon, serverVersion, shippedDigest, onDisk, projectPath) {
+  if (runtimeAddonUnknown(addon)) {
+    return;
+  }
+  if (addon !== undefined && !editorIsStale(addon.version, serverVersion, addon.digest, shippedDigest)) {
+    return;
+  }
+  const game = `The game (pid ${pid})`;
+  if (addon !== undefined && addon.version !== "" && isNewer(addon.version, serverVersion)) {
+    return `${game} is running the ${addon.version} runtime addon while this server ships ${serverVersion}. This server is the older half: reconnect it in your harness so it spawns ${addon.version}.`;
+  }
+  let loaded;
+  if (addon === undefined) {
+    loaded = `a runtime addon from before games reported theirs, while this server ships ${serverVersion}`;
+  } else if (addon.version === serverVersion) {
+    loaded = `a different build of the ${serverVersion} runtime addon from the one this server ships`;
+  } else if (addon.version === "") {
+    loaded = `a runtime addon with no version marker, while this server ships ${serverVersion}`;
+  } else {
+    loaded = `the ${addon.version} runtime addon, while this server ships ${serverVersion}`;
+  }
+  const remedy = onDisk !== undefined && onDisk !== shippedDigest ? `The project's own runtime addon is not this server's either, so starting the game again loads the same code: gdharness upgrade in ${projectPath} installs the ${serverVersion} addons, and the game picks them up when it next starts.` : `The project holds this server's runtime addon, so the game picks it up when it next starts.`;
+  return `${game} is running ${loaded}, and its answers come from that code. ${remedy}`;
+}
 function markIfStale(answer, addonVersion, serverVersion, addonDigest, shippedDigest, onDisk) {
   const staleNote = addonMismatch(addonVersion, serverVersion, addonDigest, shippedDigest, onDisk);
   if (staleNote === undefined || typeof answer !== "object" || answer === null || Array.isArray(answer)) {
@@ -25452,6 +25479,7 @@ function parseAnnouncement(file, pid) {
     return { kind: "unspoken", unspoken: { pid, protocol: protocol ?? 0, project: named, ...when } };
   }
   const editorPid = readNumber(fields, "editor_pid");
+  const addonVersion = readString(fields, "addon_version");
   return {
     kind: "runtime",
     endpoint: {
@@ -25461,7 +25489,8 @@ function parseAnnouncement(file, pid) {
       project: named,
       file,
       ...editorPid !== undefined && Number.isInteger(editorPid) && editorPid > 0 ? { editorPid } : {},
-      ...when
+      ...when,
+      ...addonVersion === undefined ? {} : { addon: { version: addonVersion, digest: readString(fields, "addon_digest") ?? "" } }
     }
   };
 }
@@ -29006,6 +29035,47 @@ function orphansPrinted(printed) {
   };
 }
 
+// src/keeper-channel.ts
+import { connect, createServer as createServer2 } from "node:net";
+function askTheKeeperToStop(address, withinMs) {
+  return new Promise((resolve) => {
+    let said = "";
+    let settled = false;
+    const settle = (answer) => {
+      if (!settled) {
+        settled = true;
+        clearTimeout(timer);
+        socket.destroy();
+        resolve(answer);
+      }
+    };
+    const socket = connect(address);
+    const timer = setTimeout(() => {
+      settle({ unreached: `it did not answer within ${withinMs} ms` });
+    }, withinMs);
+    socket.setEncoding("utf8");
+    socket.on("connect", () => {
+      socket.write(`stop
+`);
+    });
+    socket.on("data", (chunk) => {
+      said += chunk;
+      const line = said.split(`
+`)[0] ?? "";
+      if (said.includes(`
+`)) {
+        settle(line === "signalled" || line === "gone" ? line : { unreached: `it answered ${JSON.stringify(line)}` });
+      }
+    });
+    socket.on("error", (error) => {
+      settle({ unreached: error.code ?? error.message });
+    });
+    socket.on("close", () => {
+      settle({ unreached: "it closed the connection without answering" });
+    });
+  });
+}
+
 // src/lsp_client.ts
 import { existsSync as existsSync11, realpathSync as realpathSync3 } from "node:fs";
 import { readFile, realpath } from "node:fs/promises";
@@ -30293,6 +30363,7 @@ function recordAt(path) {
     ...typeof fields["startedBy"] === "number" ? { startedBy: fields["startedBy"] } : {},
     projectPath: typeof fields["projectPath"] === "string" ? fields["projectPath"] : "",
     ...typeof fields["servedBy"] === "string" && fields["servedBy"] !== "" ? { servedBy: fields["servedBy"] } : {},
+    ...typeof fields["keeper"] === "string" && fields["keeper"] !== "" ? { keeper: fields["keeper"] } : {},
     arguments: Array.isArray(args) ? args.filter((value) => typeof value === "string") : [],
     ...typeof fields["command"] === "string" ? { command: fields["command"] } : {},
     ...typeof fields["exitCode"] === "number" ? { exitCode: fields["exitCode"] } : {},
@@ -30314,11 +30385,8 @@ async function runningAs(pid) {
       }
     }
     const image = await windowsImage(pid);
-    return image === null ? null : {
-      kind: "image",
-      text: image,
-      unread: "unread" in read ? read.unread : "Windows gave an empty command line"
-    };
+    const unread = "unread" in read ? read.unread : "Windows gave an empty command line";
+    return "image" in image ? { kind: "image", text: image.image, unread } : { kind: "none", text: "", unread: `${unread}; tasklist ${image.why}` };
   }
   try {
     const began = await startedAt(pid, null);
@@ -30403,9 +30471,11 @@ async function windowsImage(pid) {
       timeout: 15000,
       windowsHide: true
     });
-    return /^"([^"]+)"/.exec(csv.trim())?.[1] ?? null;
-  } catch {
-    return null;
+    const image = /^"([^"]+)"/.exec(csv.trim())?.[1];
+    return image === undefined ? { why: "named no process under that number" } : { image };
+  } catch (error) {
+    const failed = error;
+    return { why: failed.killed === true ? "did not answer within 15000 ms" : errorMessage(error) };
   }
 }
 async function whyNotStillTheRecordedRun(record) {
@@ -30422,6 +30492,9 @@ function whyNotTheRun(record, running, needed) {
   if (running === null) {
     return "the operating system would not describe that process";
   }
+  if (running.kind === "none") {
+    return `the operating system would not describe that process (${running.unread ?? "no reason given"})`;
+  }
   const after = running.startedAt === undefined ? 0 : running.startedAt - (record.startedBy ?? record.startedAt);
   if (after > SAME_RUN_WINDOW_MS) {
     return `that process started ${Math.round(after / 1000)} seconds after the run had`;
@@ -30529,7 +30602,14 @@ var RUNTIME_AUTOLOAD = {
 };
 var VERSION_MARKER = ".gdharness-version";
 var DIGEST_MARKER = ".gdharness-digest";
+var RUNTIME_ADDON = "gdharness_runtime";
 function editorAddonDigest(from = shippedAddonsDirectory()) {
+  return addonsDigest(EDITOR_PLUGINS, from);
+}
+function runtimeAddonDigest(from = shippedAddonsDirectory()) {
+  return addonsDigest([RUNTIME_ADDON], from);
+}
+function addonsDigest(names, from) {
   const hash = createHash4("sha256");
   const walk = (directory, relative) => {
     for (const name of readdirSync7(directory).sort()) {
@@ -30549,12 +30629,13 @@ function editorAddonDigest(from = shippedAddonsDirectory()) {
       }
     }
   };
-  for (const name of EDITOR_PLUGINS) {
+  for (const name of names) {
     walk(join18(from, name), name);
   }
   return hash.digest("hex");
 }
 var shippedDigest;
+var shippedRuntime;
 function shippedEditorDigest() {
   if (shippedDigest === undefined) {
     try {
@@ -30565,8 +30646,24 @@ function shippedEditorDigest() {
   }
   return shippedDigest ?? undefined;
 }
+function shippedRuntimeDigest() {
+  if (shippedRuntime === undefined) {
+    try {
+      shippedRuntime = runtimeAddonDigest();
+    } catch {
+      shippedRuntime = null;
+    }
+  }
+  return shippedRuntime ?? undefined;
+}
 function installedEditorDigest(projectPath) {
-  const marker = join18(projectPath, "addons", ADDONS[0], DIGEST_MARKER);
+  return digestMarker(projectPath, ADDONS[0]);
+}
+function installedRuntimeDigest(projectPath) {
+  return digestMarker(projectPath, RUNTIME_ADDON);
+}
+function digestMarker(projectPath, addon) {
+  const marker = join18(projectPath, "addons", addon, DIGEST_MARKER);
   if (!existsSync13(marker)) {
     return null;
   }
@@ -31504,7 +31601,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. editor.scan says whether the editor is scanning or importing and how many milliseconds ago its last scan finished (finishedMsAgo), or is null when it did not answer: the editor rewrites the class cache just after a scan, and editor_run waits that out before starting a game, saying so under waitedForEditorScanMs. Each game under runtimes is pinged with a short wait, so one held at a breakpoint is listed as unreachable rather than making this call wait out the runtime timeout; for the run this server is reporting on, heldAt says whether that is what it is, with the same three answers editor_output gives. A game the editor played announces the editor under editorPid, and so does whatever that game started for itself; a game some other server started announces none, which is how the two are told apart when both are running from one project. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means \"not reached yet\" as often as it means \"no editor\". True is worth waiting out; false is an editor that is not there. False beside restartInterrupted is one that an editor_launch restart on a previous server asked to quit, where the launch half never ran because that server was ended in between, usually by the reconnect the restart was taken for; editor_launch open finishes it. True beside restartUnderway is a restart still in progress, its server alive and within the wait for the old editor to go: the editor is coming, and opening another would put two on one project. 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. An editor that has connected and not yet greeted, which lasts a frame and longer while it imports, reports nothing about itself: greeting says so, addonIsStale is absent rather than guessed, and a restart asked then waits for the greeting to learn who opened it. startedByAnEditor is an editor another editor started, by Godot's own restart or the project manager, which has none of the arguments a server gave the one before it; startedByAnEditorNote says what that costs.",
+    description: "Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and whether a game with the runtime addon is reachable: runtimeConnected counts the games of the project this server serves, and runtimes lists every game on the machine with ofThisProject saying which is which, since a game of another project is reached only by naming its projectPath. playingInEditor is null when the editor was not asked or did not answer, which is not the same as a no: with no editor connected there is nobody to ask, and an editor that does not serve the question is given a moment and then left. A game can be playing while this is null, so read it as unanswered rather than as nothing playing, and use processActive and runtimes, which come from elsewhere and do not depend on the editor answering. editor.scan says whether the editor is scanning or importing and how many milliseconds ago its last scan finished (finishedMsAgo), or is null when it did not answer: the editor rewrites the class cache just after a scan, and editor_run waits that out before starting a game, saying so under waitedForEditorScanMs. Each game under runtimes is pinged with a short wait, so one held at a breakpoint is listed as unreachable rather than making this call wait out the runtime timeout; for the run this server is reporting on, heldAt says whether that is what it is, with the same three answers editor_output gives. A game the editor played announces the editor under editorPid, and so does whatever that game started for itself; a game some other server started announces none, which is how the two are told apart when both are running from one project. Each game also says which runtime addon it loaded, under addonVersion (null when it cannot say); addonIsStale is true when that code is not what this server ships, and staleNote says whether the project needs gdharness upgrade, the game a restart, or this server a reconnect. A second checkout of a project, such as a git worktree, carries addons of its own and is where this shows. Every runtime_* answer from such a game carries addonIsStale and staleNote too. 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. True beside restartUnderway is a restart still in progress, its server alive and within the wait for the old editor to go: the editor is coming, and opening another would put two on one project. 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. An editor that has connected and not yet greeted, which lasts a frame and longer while it imports, reports nothing about itself: greeting says so, addonIsStale is absent rather than guessed, and a restart asked then waits for the greeting to learn who opened it. startedByAnEditor is an editor another editor started, by Godot's own restart or the project manager, which has none of the arguments a server gave the one before it; startedByAnEditorNote says what that costs.",
     parameters: {},
     requires: []
   },
@@ -32142,6 +32239,7 @@ function noCodeWillCome(run) {
   return !exited(run);
 }
 var STOP_WAIT_MS = 1e4;
+var KEEPER_ANSWER_MS = 15000;
 var EXIT_REPORTED_WITHIN_MS = 2000;
 async function untilGone(pids, withinMs = STOP_WAIT_MS) {
   const gone = () => pids.every((pid) => !alive(pid));
@@ -33075,6 +33173,10 @@ class GodotServer {
     const project = (status.connected ? status.projectPath : undefined) ?? this.ownProject;
     return project === null || project === "" ? undefined : installedEditorDigest(project);
   }
+  runtimeStaleNote(endpoint) {
+    const project = endpoint.project.path;
+    return runtimeMismatch(endpoint.pid, endpoint.addon, SERVER_VERSION, shippedRuntimeDigest(), project === "" ? undefined : installedRuntimeDigest(project), project);
+  }
   configDisagreement() {
     return this.ownProject === null ? null : configDisagrees(this.ownProject, SERVER_VERSION);
   }
@@ -34661,12 +34763,17 @@ class GodotServer {
         ok: false,
         message: `The game is held by the editor's debugger, ${describeHalt(held)}, and answers no runtime call while it is. debug_control continue lets it go.`
       };
+      const staleNote = this.runtimeStaleNote(endpoint);
+      const unknown = runtimeAddonUnknown(endpoint.addon);
       return {
         pid: endpoint.pid,
         port: endpoint.port,
         project: endpoint.project,
         ...this.ownProject === null ? {} : { ofThisProject: isSameDirectory(endpoint.project.path, this.ownProject) },
         editorPid: endpoint.editorPid,
+        addonVersion: endpoint.addon === undefined || endpoint.addon.version === "" ? null : endpoint.addon.version,
+        ...unknown ? {} : { addonIsStale: staleNote !== undefined },
+        ...staleNote === undefined ? {} : { staleNote },
         reachable: reply.ok,
         problem: reply.ok ? null : reply.message
       };
@@ -35349,6 +35456,13 @@ class GodotServer {
     if (running.pid === null) {
       return "gone";
     }
+    if (running.keeper !== undefined) {
+      const ended = await this.endThroughTheKeeper(running, running.pid, running.keeper);
+      if (ended !== null) {
+        clearTheRecord();
+        return ended;
+      }
+    }
     const startedAs = {
       pid: running.pid,
       transcript: running.transcript ?? "",
@@ -35366,7 +35480,7 @@ class GodotServer {
       return "refused";
     }
     const signalled = await runningAs(running.pid);
-    const described = signalled === null ? "nothing it would name" : `${signalled.kind}: ${signalled.text}`;
+    const described = signalled === null || signalled.kind === "none" ? "nothing it would name" : `${signalled.kind}: ${signalled.text}`;
     let landed = true;
     let declined = null;
     try {
@@ -35390,6 +35504,23 @@ class GodotServer {
     running.log.record(gone ? "info" : "warning", declined !== null ? `gdharness could not signal pid ${running.pid}: the operating system refused it (${declined}). It had described that process as ${described}.` : !gone ? `gdharness signalled pid ${running.pid}, which the operating system described as ${described}, and it was still running ${STOP_WAIT_MS / 1000} seconds later.` : 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 ? "gone" : "lingering";
   }
+  async endThroughTheKeeper(run, pid, keeper) {
+    const asked = await askTheKeeperToStop(keeper, KEEPER_ANSWER_MS);
+    if (typeof asked !== "string") {
+      this.logDebug(`The keeper of pid ${pid} could not be asked to end it (${asked.unreached})`);
+      return null;
+    }
+    const gone = await untilGone([pid]);
+    if (gone) {
+      await this.untilTheExitIsRecorded(run);
+    }
+    if (asked === "signalled" && gone) {
+      run.exitCode = null;
+      run.exitSignal = "SIGTERM";
+    }
+    run.log.record(gone ? "info" : "warning", !gone ? `gdharness had the keeper holding pid ${pid} end it, and it was still running ${STOP_WAIT_MS / 1000} seconds later.` : asked === "signalled" ? `gdharness ended pid ${pid} through the keeper holding it.` : `gdharness asked the keeper holding pid ${pid} to end it, and it had already gone.`);
+    return gone ? "gone" : "lingering";
+  }
   spawnGame(godotPath, cmdArgs, env) {
     const child = spawn4(godotPath, cmdArgs, { stdio: ["ignore", "pipe", "pipe"], ...env ? { env } : {} });
     const cancelled = callSignal();
@@ -35479,6 +35610,8 @@ class GodotServer {
     }
     const startedBy = Date.now();
     sweepTranscripts();
+    const noted = readRunRecord(projectPath);
+    const keeper = noted?.pid === launched.pid ? noted.keeper : undefined;
     return {
       pid: launched.pid,
       log: new GameLog,
@@ -35487,6 +35620,7 @@ class GodotServer {
       projectPath,
       startedAt,
       startedBy,
+      ...keeper === undefined ? {} : { keeper },
       command: godotPath,
       exitCode: null,
       exitSignal: null,
@@ -35719,6 +35853,7 @@ class GodotServer {
       projectPath: record.projectPath === "" ? null : record.projectPath,
       startedAt: record.startedAt,
       ...record.startedBy === undefined ? {} : { startedBy: record.startedBy },
+      ...record.keeper === undefined ? {} : { keeper: record.keeper },
       ...record.command === undefined ? {} : { command: record.command },
       exitCode: null,
       exitSignal: null,
@@ -36762,6 +36897,11 @@ class GodotServer {
     }
     const screenshotDir = expectsScreenshot ? scratchDirectory("runtime-screenshot") : null;
     const screenshotPath = screenshotDir ? join19(screenshotDir, "capture.png") : null;
+    const staleNote = this.runtimeStaleNote(choice.endpoint);
+    const stale = staleNote === undefined ? {} : { addonIsStale: true, staleNote };
+    const refused = (message) => this.createErrorResponse(staleNote === undefined ? message : `${message}
+
+${staleNote}`);
     try {
       const reply = await runtimeRequest(choice.endpoint, command, screenshotPath ? { ...params, output_path: screenshotPath } : params, timeoutMs, !expectsScreenshot);
       if (!reply.ok && reply.requestId !== undefined) {
@@ -36771,22 +36911,23 @@ class GodotServer {
           command,
           waitedMs: timeoutMs,
           note: reply.message,
-          ...answeredBy
+          ...answeredBy,
+          ...stale
         });
       }
       if (!reply.ok) {
-        return this.createErrorResponse(reply.message);
+        return refused(reply.message);
       }
       const { id: _id, ...payload } = reply.payload;
       if (!expectsScreenshot) {
-        return this.jsonTextResponse({ ...payload, ...answeredBy });
+        return this.jsonTextResponse({ ...payload, ...answeredBy, ...stale });
       }
       const returnedPath = readString(payload, "path");
       if (readString(payload, "type") !== "screenshot_file" || !returnedPath || !screenshotPath) {
-        return this.createErrorResponse(`The game answered a capture with ${JSON.stringify(payload)}`);
+        return refused(`The game answered a capture with ${JSON.stringify(payload)}`);
       }
       if (normalize2(returnedPath) !== normalize2(screenshotPath)) {
-        return this.createErrorResponse(`Rejected screenshot file path outside the managed capture path: '${returnedPath}'`);
+        return refused(`Rejected screenshot file path outside the managed capture path: '${returnedPath}'`);
       }
       const dimensions = `${readNumber(payload, "width") ?? 0}x${readNumber(payload, "height") ?? 0} ${readString(payload, "format") ?? "unknown"}`;
       if (saveTo !== null) {
@@ -36800,7 +36941,9 @@ class GodotServer {
         content: [
           {
             type: "text",
-            text: `Screenshot captured: ${dimensions}${chosenAmongSeveral ? ` from pid ${own}, the game this server holds` : ""}${saveTo === null ? "" : `. Saved to ${saveTo}`}`
+            text: `Screenshot captured: ${dimensions}${chosenAmongSeveral ? ` from pid ${own}, the game this server holds` : ""}${saveTo === null ? "" : `. Saved to ${saveTo}`}${staleNote === undefined ? "" : `
+
+${staleNote}`}`
           },
           { type: "image", data: readFileSync18(screenshotPath).toString("base64"), mimeType: "image/png" }
         ]