gdharness 1.2.38 → 1.2.39

package/build/cli.js

@@ -11424,7 +11424,7 @@ var init_tool_definitions = __esm(() => {
       name: "project_info",
       title: "Project info",
       effect: "read",
-      description: "What a project is: its name and main scene from project.godot, the Godot that answers, and how many scenes, scripts and assets it holds, with optional sections on top.",
+      description: "What a project is: its name and main scene from project.godot, the Godot that answers, and how many scenes, scripts and assets it holds, other counting every remaining file, leaving out the addons gdharness installed and any folder holding a .gdignore, with optional sections on top.",
       parameters: {
         projectPath: PROJECT_PATH,
         include: {
@@ -11666,7 +11666,7 @@ var init_tool_definitions = __esm(() => {
         },
         reimport: {
           effect: "destructive",
-          summary: "reimport what status says is outdated or failed, one resource with resourcePath, or what is current as well with force. Through the open editor when one serves the project, so it reloads what it holds, waiting for it to finish; otherwise through the engine's own import pass. The editor scans first, since its reimport passes over a file it has not taken in, such as one an installer has just written; what that scan imported is named under importedByTheScan and is not imported again unless force asks. Answered from a second status read: reimported lists what is current now, notReimported what is not, one entry per status and reason with the paths sharing them, and via says which of the two did the work. A whole-project reimport also answers missingSource, the .import files whose source is not beside them, empty when there are none, whether or not anything needed reimporting; one resourcePath is not a walk of the project and leaves it out. stillImporting is an editor that had not finished within timeoutMs",
+          summary: "reimport what status says is outdated or failed, one resource with resourcePath, or what is current as well with force. Through the open editor when one serves the project, so it reloads what it holds, waiting for it to finish; otherwise through the engine's own import pass. The editor scans first, since its reimport passes over a file it has not taken in, such as one an installer has just written; what that scan imported is named under importedByTheScan and is not imported again unless force asks. Answered from a second status read: reimported lists what is current now, notReimported what is not, one entry per status and reason with the paths sharing them, and via says which of the two did the work. When nothing needs reimporting, nothing runs, and the answer has the two lists empty, a note saying so, and no via. A whole-project reimport also answers missingSource, the .import files whose source is not beside them, empty when there are none, whether or not anything needed reimporting; one resourcePath is not a walk of the project and leaves it out. stillImporting is an editor that had not finished within timeoutMs",
           requires: []
         },
         uid: {
@@ -11750,7 +11750,7 @@ var init_tool_definitions = __esm(() => {
         timeoutMs: {
           type: "integer",
           minimum: 1,
-          description: "How long the run may take before it is killed. Default 600000. A run killed at the limit answers timedOut and silentForMs, how long it had printed nothing; it is called hung only when that was half the limit, or thirty seconds of a longer one, and otherwise it was still running and wants a longer timeoutMs or a narrower path."
+          description: "How long the run may take before it is killed. Default 600000. A run killed at the limit answers timedOut and silentForMs, how long it had printed nothing; it is called hung only when that was half the limit, or thirty seconds of a longer one, and otherwise it was still running and wants a longer timeoutMs or a narrower path, unless it ended repeating one script error, which the verdict names instead. A run whose autoload did not compile is stopped as soon as the engine says so, and names the script that did not under scriptErrors."
         },
         printed: {
           type: "string",
@@ -12421,7 +12421,7 @@ var init_tool_definitions = __esm(() => {
           requires: []
         }
       },
-      answer: "stop: endedPid is, for a run the editor plays, the number its game announced under, read at the stop rather than remembered, and the operating system hands a freed number to the next process, so it can equal the game before it. stopped is false, with the number under notSignalled, when that number no longer answers as the process the run was started as and nothing was signalled, the note naming which property it failed on, and false with the number under stillGoing when what was told to end was still running ten seconds later. endedThrough says how the stop ended a run that was going: close (the game was asked to close and exited, so exitCode is its own), keeper (the process that started the game ended it through the handle it holds), signal (its pid was signalled once shown to still be the run), or editor (the editor playing it was asked). A start that ends the run before it says how under endedPreviousRunThrough, with the same values, and one that refused to signal that run names the property it failed on under previousRunLeftBecause. check: hung is a run killed at timeoutMs, and errors and warnings count what it printed, which comes back under entries with repeats folded together. entries holds the errors and warnings and not the ordinary lines the run printed, which printedLinesNotShown counts; a check given --verbose holds those too, and editor_run start then editor_output reads everything. An engine crash is an error whatever it prints after: the crash handler's report is the entry, and the engine version and the native and GDScript backtraces are its detail, so a crashed run is never booted or clean. arguments is the engine command line the check ran, as a start's is. profile: per function its script, the function (Class.name when the script declares a class_name), the line its body's first statement is on, for a lambda the named function it is written in (within), calls, and self and total milliseconds, with functionsCounted, scriptMs (the self time of them all) and coveredMs. complete is true when the engine's own totals arrived, which it sends only when the profiler is switched off: the runtime addon does that as a game quits, so a scene that does its work in _ready and quits is covered whole; otherwise the answer is the frames summed so far and the note says what that misses. Self time counts a call into the engine's own methods as the caller's, and a call through super too, while the overridden function's row counts it again: such a row carries selfIncludesSuper, so self times along an override chain overlap. The profiler's own cost of timing a call lands in the self time of the function called; with the runtime addon it is measured each run on an empty function, as perCallOverheadUs, and a row with at least half its selfMs in it carries overheadMs, since a small function called often costs that much less without the profiler. A function the profiler started inside is left out, since its time would be counted from the engine's start. The milliseconds are time passed while the function ran, not processor time given to it, so they grow when other processes compete for the processor: compare two profiles taken under the same load. They are also summed over every thread: a function run by WorkerThreadPool or a Thread on several threads at once counts each thread's time, the engine does not say which thread a call ran on, and a function waiting for them has the wait in its own self time, so selfMs is not time taken from frames, and scriptMs can exceed coveredMs, which the note then says. A property's get and set blocks are named Class.@name_getter and Class.@name_setter, as the engine names them, and their rows carry property, the property's name. A game the editor plays that was not started with profile: true says, in the answer, that it was profiled from the moment it was asked. A profile with mark answers marked: true; one with since answers since: \"mark\" and markSetMsAgo, and lessThanAtMark counts the functions left out for reading less than at the mark, which the engine's own totals, capped, can do when they replace the frames' sum.",
+      answer: "stop: endedPid is, for a run the editor plays, the number its game announced under, read at the stop rather than remembered, and the operating system hands a freed number to the next process, so it can equal the game before it. stopped is false, with the number under notSignalled, when that number no longer answers as the process the run was started as and nothing was signalled, the note naming which property it failed on, and false with the number under stillGoing when what was told to end was still running ten seconds later. endedThrough says how the stop ended a run that was going: close (the game was asked to close and exited, so exitCode is its own), keeper (the process that started the game ended it through the handle it holds), signal (its pid was signalled once shown to still be the run), or editor (the editor playing it was asked). A start that ends the run before it says how under endedPreviousRunThrough, with the same values, and one that refused to signal that run names the property it failed on under previousRunLeftBecause. check: hung is a run killed at timeoutMs, and errors and warnings count what it printed, which comes back under entries with repeats folded together. entries holds the errors and warnings and not the ordinary lines the run printed, which printedLinesNotShown counts; a check given --verbose holds those too, and editor_run start then editor_output reads everything. An engine crash is an error whatever it prints after: the crash handler's report is the entry, and the engine version and the native and GDScript backtraces are its detail, so a crashed run is never booted or clean. arguments is the engine command line the check ran, as a start's is. profile: per function its script, the function (Class.name when the script declares a class_name), the line its body's first statement is on, for a lambda the named function it is written in (within), calls, and self and total milliseconds, with functionsCounted, scriptMs (the self time of them all) and coveredMs. The runtime addon's own functions, gdharness answering its tools inside the game, are not among them: their self time is runtimeAddonMs, over runtimeAddonFunctions functions. complete is true when the engine's own totals arrived, which it sends only when the profiler is switched off: the runtime addon does that as a game quits, so a scene that does its work in _ready and quits is covered whole; otherwise the answer is the frames summed so far and the note says what that misses. frames counts the frames of the profile that arrived, and the engine's totals also hold the work after the last of them, so once complete a function run every frame can show a call more than frames. Self time counts a call into the engine's own methods as the caller's, and a call through super too, while the overridden function's row counts it again: such a row carries selfIncludesSuper, so self times along an override chain overlap. The profiler's own cost of timing a call lands in the self time of the function called; with the runtime addon it is measured each run on an empty function, as perCallOverheadUs, and a row with at least half its selfMs in it carries overheadMs, since a small function called often costs that much less without the profiler. A function the profiler started inside is left out, since its time would be counted from the engine's start. The milliseconds are time passed while the function ran, not processor time given to it, so they grow when other processes compete for the processor: compare two profiles taken under the same load. They are also summed over every thread: a function run by WorkerThreadPool or a Thread on several threads at once counts each thread's time, the engine does not say which thread a call ran on, and a function waiting for them has the wait in its own self time, so selfMs is not time taken from frames, and scriptMs can exceed coveredMs, which the note then says. A property's get and set blocks are named Class.@name_getter and Class.@name_setter, as the engine names them, and their rows carry property, the property's name. A game the editor plays that was not started with profile: true says, in the answer, that it was profiled from the moment it was asked. A profile with mark answers marked: true; one with since answers since: \"mark\" and markSetMsAgo, and lessThanAtMark counts the functions left out for reading less than at the mark, which the engine's own totals, capped, can do when they replace the frames' sum.",
       defaultOperation: "start"
     },
     {
@@ -34899,11 +34899,51 @@ var init_stdio = __esm(() => {
   swallowsErrorsAfterClose = Symbol("swallowsErrorsAfterClose");
 });
 
+// src/autoload-failure.ts
+import { existsSync as existsSync15, readFileSync as readFileSync13 } from "node:fs";
+import { join as join16 } from "node:path";
+function scriptsAutoloaded(projectPath) {
+  const scripts = new Map;
+  let settings;
+  try {
+    settings = parseProjectGodot(readFileSync13(join16(projectPath, "project.godot"), "utf8"));
+  } catch {
+    return scripts;
+  }
+  for (const [name, path] of autoloadPaths(settings)) {
+    if (!path.endsWith(".tscn")) {
+      scripts.set(`res://${path}`, name);
+      continue;
+    }
+    const scene = join16(projectPath, path);
+    if (!existsSync15(scene)) {
+      continue;
+    }
+    try {
+      for (const named of readFileSync13(scene, "utf8").matchAll(/^\[ext_resource\b[^\]]*\btype="Script"[^\]]*\bpath="(res:\/\/[^"]+)"/gm)) {
+        scripts.set(named[1] ?? "", name);
+      }
+    } catch {}
+  }
+  return scripts;
+}
+function autoloadNotCompiled(entry, autoloaded) {
+  const path = NOT_COMPILED.exec(entry.text)?.[1];
+  const name = path === undefined ? undefined : autoloaded.get(path);
+  return path === undefined || name === undefined ? null : { name, path };
+}
+var NOT_COMPILED;
+var init_autoload_failure = __esm(() => {
+  init_resources();
+  init_setup();
+  NOT_COMPILED = /^Failed to load script "(res:\/\/[^"]+)" with error "Compilation failed"/;
+});
+
 // src/runtime-client.ts
-import { existsSync as existsSync15, readdirSync as readdirSync10, readFileSync as readFileSync13, statSync as statSync8, unlinkSync as unlinkSync2 } from "node:fs";
+import { existsSync as existsSync16, readdirSync as readdirSync10, readFileSync as readFileSync14, statSync as statSync8, unlinkSync as unlinkSync2 } from "node:fs";
 import { createConnection } from "node:net";
 import { tmpdir as tmpdir4 } from "node:os";
-import { dirname as dirname10, join as join16, resolve as resolve4 } from "node:path";
+import { dirname as dirname10, join as join17, resolve as resolve4 } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 function runtimeDirectory(variables = process.env) {
   const explicit = envValue("GDHARNESS_RUNTIME_DIR", variables);
@@ -34911,20 +34951,20 @@ function runtimeDirectory(variables = process.env) {
     return explicit;
   }
   const perUser = envValue("XDG_RUNTIME_DIR", variables);
-  return join16(perUser ?? tmpdir4(), "gdharness");
+  return join17(perUser ?? tmpdir4(), "gdharness");
 }
 function runtimeDirectories(variables = process.env) {
   const candidates = [runtimeDirectory(variables)];
   const fallbacks = process.platform === "win32" ? [envValue("SystemRoot", variables) ?? envValue("windir", variables) ?? "C:\\Windows"] : ["/tmp", "/var/tmp"];
   for (const base of fallbacks) {
-    candidates.push(join16(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
+    candidates.push(join17(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
   }
   return [...new Set(candidates.map((path) => resolve4(path)))];
 }
 function errorReportOf(pid, directories = runtimeDirectories()) {
   for (const directory of directories) {
-    const path = join16(directory, `runtime-${pid}.log`);
-    if (existsSync15(path)) {
+    const path = join17(directory, `runtime-${pid}.log`);
+    if (existsSync16(path)) {
       return path;
     }
   }
@@ -34955,7 +34995,7 @@ function reportAlreadyInTranscript(transcript, report) {
 function parseAnnouncement(file, pid) {
   let fields;
   try {
-    fields = asParams(JSON.parse(readFileSync13(file, "utf8")));
+    fields = asParams(JSON.parse(readFileSync14(file, "utf8")));
   } catch {
     return { kind: "rubbish" };
   }
@@ -35021,7 +35061,7 @@ function discoverRuntimes(directories = runtimeDirectories()) {
 function wentAway(file, pid) {
   let project = "";
   try {
-    const fields = asParams(JSON.parse(readFileSync13(file, "utf8")));
+    const fields = asParams(JSON.parse(readFileSync14(file, "utf8")));
     project = readString(readParams(fields, "project") ?? {}, "path") ?? "";
   } catch {
     return;
@@ -35064,7 +35104,7 @@ function strangersAmong(candidates, now, startTimes = startTimesOf) {
   }).map((one) => one.file));
 }
 function announcedIn(directory) {
-  if (!existsSync15(directory)) {
+  if (!existsSync16(directory)) {
     return [];
   }
   const found = [];
@@ -35073,14 +35113,14 @@ function announcedIn(directory) {
   for (const entry of readdirSync10(directory)) {
     const report = ERROR_REPORT_PATTERN.exec(entry);
     if (report) {
-      sweepErrorReport(join16(directory, entry), Number.parseInt(report[1] ?? "", 10));
+      sweepErrorReport(join17(directory, entry), Number.parseInt(report[1] ?? "", 10));
       continue;
     }
     const match = ANNOUNCEMENT_PATTERN.exec(entry);
     if (!match) {
       continue;
     }
-    const file = join16(directory, entry);
+    const file = join17(directory, entry);
     const pid = Number.parseInt(match[1] ?? "", 10);
     const running = alive(pid);
     entries.push({ file, pid, running });
@@ -35108,7 +35148,7 @@ function announcedIn(directory) {
     found.push(announced);
   }
   const held = new Set(entries.map((one) => one.file));
-  const here = join16(directory, ".");
+  const here = join17(directory, ".");
   for (const file of verdicts.keys()) {
     if (dirname10(file) === here && !held.has(file)) {
       verdicts.delete(file);
@@ -35117,7 +35157,7 @@ function announcedIn(directory) {
   return found;
 }
 async function announcementEnded(pid, directories = runtimeDirectories()) {
-  const files = directories.map((directory) => join16(directory, `runtime-${pid}.json`)).filter((file) => existsSync15(file));
+  const files = directories.map((directory) => join17(directory, `runtime-${pid}.json`)).filter((file) => existsSync16(file));
   const first = files[0];
   if (first === undefined) {
     return;
@@ -35281,7 +35321,36 @@ function keepLate(id, answer) {
 function lateAnswer(id) {
   return lateAnswers.get(id);
 }
-function runtimeRequest(endpoint, command, params, timeoutMs, keepListening = false) {
+function placeOf(endpoint) {
+  return `${dialAddress(endpoint.address)}:${endpoint.port}`;
+}
+function waitForAPlace(game, granted) {
+  const line = untaken.get(game) ?? { held: 0, waiting: [] };
+  untaken.set(game, line);
+  const grant = () => {
+    line.held += 1;
+    let given = false;
+    granted(() => {
+      if (given) {
+        return;
+      }
+      given = true;
+      line.held -= 1;
+      const next = line.waiting.shift();
+      if (next !== undefined) {
+        next();
+      } else if (line.held === 0 && untaken.get(game) === line) {
+        untaken.delete(game);
+      }
+    });
+  };
+  if (line.held < UNTAKEN_PER_GAME) {
+    grant();
+  } else {
+    line.waiting.push(grant);
+  }
+}
+function runtimeRequest(endpoint, command, params, timeoutMs, afterTheWait = "drop") {
   const id = nextRequestId++;
   const sentAt = Date.now();
   return new Promise((settle) => {
@@ -35289,16 +35358,32 @@ function runtimeRequest(endpoint, command, params, timeoutMs, keepListening = fa
     let late = false;
     let buffered = "";
     let welcomed = false;
-    const socket = createConnection({ port: endpoint.port, host: dialAddress(endpoint.address) });
+    let socket = null;
+    let refusals = 0;
+    let redial = null;
+    let giveBackThePlace = null;
+    const taken = () => {
+      giveBackThePlace?.();
+      giveBackThePlace = null;
+    };
     let lateTimer = null;
     const finish = (reply) => {
+      taken();
+      if (redial !== null) {
+        clearTimeout(redial);
+        redial = null;
+      }
       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 });
+        socket?.destroy();
         late = false;
+        if (typeof afterTheWait === "function") {
+          afterTheWait(reply);
+          return;
+        }
+        keepLate(id, reply.ok || reply.reason === "error" ? { state: "answered", command, sentAt, answeredAt: Date.now(), reply } : { state: "never", command, sentAt, why: reply.message });
         return;
       }
       if (done) {
@@ -35306,12 +35391,24 @@ function runtimeRequest(endpoint, command, params, timeoutMs, keepListening = fa
       }
       done = true;
       clearTimeout(timer);
-      socket.destroy();
+      socket?.destroy();
       settle(reply);
     };
     const timer = setTimeout(() => {
+      if (socket === null) {
+        finish(refusals > 0 ? {
+          ok: false,
+          reason: "refused",
+          message: `The game (${describe2(endpoint)}) is running but nothing answered on its port: it refused ${refusals === 1 ? "the connection" : `all ${refusals} connections tried`} within ${timeoutMs}ms. Nothing listens there while a game is starting or shutting down, and the engine refuses connections while more are waiting for the game than the eight it queues, which several servers calling one game at once, or a long frame or a breakpoint holding it, can make it do. Nothing was sent, so nothing ran.`
+        } : {
+          ok: false,
+          reason: "busy",
+          message: `'${command}' was not sent to the game (${describe2(endpoint)}) within ${timeoutMs}ms: ${UNTAKEN_PER_GAME} connections from this server were already waiting for the game to take them, which it does between frames, so a long frame or a breakpoint holds them. Nothing was sent, so nothing ran.`
+        });
+        return;
+      }
       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) {
+      if (afterTheWait === "drop") {
         finish({
           ok: false,
           reason: "busy",
@@ -35321,7 +35418,9 @@ function runtimeRequest(endpoint, command, params, timeoutMs, keepListening = fa
       }
       done = true;
       late = true;
-      keepLate(id, { state: "waiting", command, sentAt });
+      if (afterTheWait === "keep") {
+        keepLate(id, { state: "waiting", command, sentAt });
+      }
       lateTimer = setTimeout(() => {
         finish({
           ok: false,
@@ -35331,6 +35430,15 @@ function runtimeRequest(endpoint, command, params, timeoutMs, keepListening = fa
       }, LATE_ANSWER_MS);
       lateTimer.unref();
       socket.unref();
+      if (afterTheWait !== "keep") {
+        settle({
+          ok: false,
+          reason: "busy",
+          stillWithTheGame: true,
+          message: `${still} Nothing was cancelled: the game runs it when it gets to it, and what it answers then is not kept, so ask again once the game answers. A game held at a breakpoint instead is one debug_state stack answers about.`
+        });
+        return;
+      }
       settle({
         ok: false,
         reason: "busy",
@@ -35338,71 +35446,112 @@ function runtimeRequest(endpoint, command, params, timeoutMs, keepListening = fa
         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. A game held at a breakpoint instead is one debug_state stack answers about.`
       });
     }, timeoutMs);
-    socket.setEncoding("utf8");
-    socket.on("connect", () => {
-      socket.write(`${JSON.stringify({ id, command, params })}
+    const open = () => {
+      const opened = createConnection({ port: endpoint.port, host: dialAddress(endpoint.address) });
+      socket = opened;
+      opened.setEncoding("utf8");
+      opened.on("connect", () => {
+        opened.write(`${JSON.stringify({ id, command, params })}
 `);
-    });
-    socket.on("data", (chunk) => {
-      buffered += chunk;
-      let newline = buffered.indexOf(`
+      });
+      opened.on("data", (chunk) => {
+        buffered += chunk;
+        let newline = buffered.indexOf(`
 `);
-      while (newline !== -1 && (!done || late)) {
-        const line = buffered.slice(0, newline).trim();
-        buffered = buffered.slice(newline + 1);
-        newline = buffered.indexOf(`
+        while (newline !== -1 && (!done || late)) {
+          const line = buffered.slice(0, newline).trim();
+          buffered = buffered.slice(newline + 1);
+          newline = buffered.indexOf(`
 `);
-        if (line === "") {
-          continue;
-        }
-        let message;
-        try {
-          message = asParams(JSON.parse(line));
-        } catch {
-          continue;
-        }
-        if (!welcomed) {
-          welcomed = true;
-          if (readString(message, "type") === "welcome") {
-            const spoken = readNumber(message, "protocol");
-            if (spoken !== RUNTIME_PROTOCOL) {
-              finish({
-                ok: false,
-                reason: "protocol",
-                message: `The game (${describe2(endpoint)}) speaks runtime protocol ${spoken ?? "unknown"} and this server speaks ${RUNTIME_PROTOCOL}. Reinstall the runtime addon into the project.`
-              });
-              return;
+          if (line === "") {
+            continue;
+          }
+          let message;
+          try {
+            message = asParams(JSON.parse(line));
+          } catch {
+            continue;
+          }
+          if (!welcomed) {
+            welcomed = true;
+            taken();
+            if (readString(message, "type") === "welcome") {
+              const spoken = readNumber(message, "protocol");
+              if (spoken !== RUNTIME_PROTOCOL) {
+                finish({
+                  ok: false,
+                  reason: "protocol",
+                  message: `The game (${describe2(endpoint)}) speaks runtime protocol ${spoken ?? "unknown"} and this server speaks ${RUNTIME_PROTOCOL}. Reinstall the runtime addon into the project.`
+                });
+                return;
+              }
+              continue;
             }
+          }
+          if (message["id"] !== id) {
             continue;
           }
+          if (readString(message, "type") === "error") {
+            finish({
+              ok: false,
+              reason: "error",
+              message: readString(message, "message") ?? "unknown error"
+            });
+            return;
+          }
+          finish({ ok: true, payload: message, endpoint });
         }
-        if (message["id"] !== id) {
-          continue;
+      });
+      opened.on("error", (error) => {
+        if (socket !== opened) {
+          return;
         }
-        if (readString(message, "type") === "error") {
-          finish({ ok: false, reason: "error", message: readString(message, "message") ?? "unknown error" });
+        if (error.code === "ECONNREFUSED" && !done) {
+          if (alive(endpoint.pid)) {
+            refusals += 1;
+            socket = null;
+            opened.destroy();
+            redial = setTimeout(() => {
+              redial = null;
+              open();
+            }, REDIAL_MS);
+            return;
+          }
+          finish({
+            ok: false,
+            reason: "refused",
+            message: `The game (${describe2(endpoint)}) has ended: its port refused the connection and its process is gone.`
+          });
           return;
         }
-        finish({ ok: true, payload: message, endpoint });
-      }
-    });
-    socket.on("error", (error) => {
-      finish({
-        ok: false,
-        reason: "refused",
-        message: `The game (${describe2(endpoint)}) is running but nothing answered on its port: ${error.code ?? error.message}. It may still be starting, or be shutting down.`
+        finish({
+          ok: false,
+          reason: "refused",
+          message: `The game (${describe2(endpoint)}) is running but nothing answered on its port: ${error.code ?? error.message}. It may still be starting or be shutting down.`
+        });
       });
-    });
-    socket.on("close", () => {
-      finish({
-        ok: false,
-        reason: "refused",
-        message: `The game (${describe2(endpoint)}) closed the connection before answering '${command}'.`
+      opened.on("close", () => {
+        if (socket !== opened) {
+          return;
+        }
+        finish({
+          ok: false,
+          reason: "refused",
+          message: `The game (${describe2(endpoint)}) closed the connection before answering '${command}'.`
+        });
       });
+    };
+    waitForAPlace(placeOf(endpoint), (giveBack) => {
+      if (done) {
+        giveBack();
+        return;
+      }
+      giveBackThePlace = giveBack;
+      open();
     });
   });
 }
-var RUNTIME_PROTOCOL = 2, ANNOUNCEMENT_PATTERN, ERROR_REPORT_PATTERN, CONSOLE_BOUNDARY = "[gdharness] runtime listening on ", ERROR_REPORT_KEEP_MS, GONE_WINDOW_MS = 120000, GONE_KEPT = 32, gone, STARTED_AFTER_ANNOUNCING_MS = 2000, CONFIRMED_FOR_MS = 60000, JUDGED_AFTER_MS = 60000, verdicts, judging = null, ENDED_WITHIN_MS = 3000, LOOK_EVERY_MS = 50, ANNOUNCE_BUDGET_MS = 5000, nextRequestId = 1, LATE_ANSWER_MS, LATE_KEPT = 50, lateAnswers;
+var RUNTIME_PROTOCOL = 2, ANNOUNCEMENT_PATTERN, ERROR_REPORT_PATTERN, CONSOLE_BOUNDARY = "[gdharness] runtime listening on ", ERROR_REPORT_KEEP_MS, GONE_WINDOW_MS = 120000, GONE_KEPT = 32, gone, STARTED_AFTER_ANNOUNCING_MS = 2000, CONFIRMED_FOR_MS = 60000, JUDGED_AFTER_MS = 60000, verdicts, judging = null, ENDED_WITHIN_MS = 3000, LOOK_EVERY_MS = 50, ANNOUNCE_BUDGET_MS = 5000, nextRequestId = 1, LATE_ANSWER_MS, LATE_KEPT = 50, lateAnswers, UNTAKEN_PER_GAME = 4, REDIAL_MS = 50, untaken;
 var init_runtime_client = __esm(() => {
   init_alive();
   init_launch();
@@ -35415,17 +35564,18 @@ var init_runtime_client = __esm(() => {
   verdicts = new Map;
   LATE_ANSWER_MS = 30 * 60000;
   lateAnswers = new Map;
+  untaken = new Map;
 });
 
 // src/boot-note.ts
-import { mkdirSync as mkdirSync6, readFileSync as readFileSync14, writeFileSync as writeFileSync8 } from "node:fs";
-import { dirname as dirname11, join as join17 } from "node:path";
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync15, writeFileSync as writeFileSync8 } from "node:fs";
+import { dirname as dirname11, join as join18 } from "node:path";
 function bootNotePath(projectPath) {
-  return join17(projectPath, ".godot", "gdharness-boot.json");
+  return join18(projectPath, ".godot", "gdharness-boot.json");
 }
 function readScenes(projectPath) {
   try {
-    return asParams(asParams(JSON.parse(readFileSync14(bootNotePath(projectPath), "utf8")))["scenes"]);
+    return asParams(asParams(JSON.parse(readFileSync15(bootNotePath(projectPath), "utf8")))["scenes"]);
   } catch {
     return {};
   }
@@ -35467,10 +35617,10 @@ var init_boot_note = __esm(() => {
 });
 
 // src/breakpoint-note.ts
-import { mkdirSync as mkdirSync7, readFileSync as readFileSync15, rmSync as rmSync7, writeFileSync as writeFileSync9 } from "node:fs";
-import { dirname as dirname12, isAbsolute as isAbsolute4, join as join18, relative as relative3 } from "node:path";
+import { mkdirSync as mkdirSync7, readFileSync as readFileSync16, rmSync as rmSync7, writeFileSync as writeFileSync9 } from "node:fs";
+import { dirname as dirname12, isAbsolute as isAbsolute4, join as join19, relative as relative3 } from "node:path";
 function breakpointNotePath(projectPath) {
-  return join18(projectPath, ".godot", "gdharness-breakpoints.json");
+  return join19(projectPath, ".godot", "gdharness-breakpoints.json");
 }
 function writeBreakpointNote(projectPath, held) {
   const path = breakpointNotePath(projectPath);
@@ -35496,7 +35646,7 @@ function writeBreakpointNote(projectPath, held) {
 }
 function readBreakpointNote(projectPath) {
   try {
-    const parsed = JSON.parse(readFileSync15(breakpointNotePath(projectPath), "utf8"));
+    const parsed = JSON.parse(readFileSync16(breakpointNotePath(projectPath), "utf8"));
     if (typeof parsed !== "object" || parsed === null || !Array.isArray(parsed.breakpoints)) {
       return [];
     }
@@ -35511,7 +35661,7 @@ function readBreakpointNote(projectPath) {
       }
       const lines = Array.isArray(listed) ? listed.filter((line) => Number.isInteger(line) && line > 0) : [];
       if (lines.length > 0) {
-        held.push({ scriptPath: realPathOr(join18(projectPath, script)), lines });
+        held.push({ scriptPath: realPathOr(join19(projectPath, script)), lines });
       }
     }
     return held;
@@ -35560,14 +35710,14 @@ var init_whole_file = __esm(() => {
 });
 
 // src/class-note.ts
-import { mkdirSync as mkdirSync8, readFileSync as readFileSync16 } from "node:fs";
-import { dirname as dirname13, join as join19 } from "node:path";
+import { mkdirSync as mkdirSync8, readFileSync as readFileSync17 } from "node:fs";
+import { dirname as dirname13, join as join20 } from "node:path";
 function classNotePath(projectPath) {
-  return join19(projectPath, ".godot", "gdharness-classes.json");
+  return join20(projectPath, ".godot", "gdharness-classes.json");
 }
 function readClassNote(projectPath) {
   try {
-    const fields = asParams(JSON.parse(readFileSync16(classNotePath(projectPath), "utf8")));
+    const fields = asParams(JSON.parse(readFileSync17(classNotePath(projectPath), "utf8")));
     const rebuiltWith = readArray(fields, "rebuiltWith");
     if (rebuiltWith === undefined || !rebuiltWith.every((name) => typeof name === "string")) {
       return null;
@@ -35609,16 +35759,16 @@ var init_class_note = __esm(() => {
 });
 
 // src/config-pin.ts
-import { existsSync as existsSync16, readFileSync as readFileSync17 } from "node:fs";
-import { join as join20 } from "node:path";
+import { existsSync as existsSync17, readFileSync as readFileSync18 } from "node:fs";
+import { join as join21 } from "node:path";
 function versionsNamedInConfig(projectPath) {
-  const config = join20(projectPath, ".mcp.json");
-  if (!existsSync16(config)) {
+  const config = join21(projectPath, ".mcp.json");
+  if (!existsSync17(config)) {
     return [];
   }
   let text;
   try {
-    text = readFileSync17(config, "utf8");
+    text = readFileSync18(config, "utf8");
     JSON.parse(text);
   } catch {
     return [];
@@ -35639,10 +35789,10 @@ var init_config_pin = __esm(() => {
 });
 
 // src/cut-test-run.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync9, readFileSync as readFileSync18, rmSync as rmSync9, writeFileSync as writeFileSync11 } from "node:fs";
-import { dirname as dirname14, join as join21 } from "node:path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync9, readFileSync as readFileSync19, rmSync as rmSync9, writeFileSync as writeFileSync11 } from "node:fs";
+import { dirname as dirname14, join as join22 } from "node:path";
 function keptAt(projectPath) {
-  return join21(projectPath, ".godot", "gdharness-reports", "cut-run.json");
+  return join22(projectPath, ".godot", "gdharness-reports", "cut-run.json");
 }
 function keepCutTestRun(projectPath, run) {
   const path = keptAt(projectPath);
@@ -35654,11 +35804,11 @@ function keepCutTestRun(projectPath, run) {
 }
 function takeCutTestRun(projectPath) {
   const path = keptAt(projectPath);
-  if (!existsSync17(path)) {
+  if (!existsSync18(path)) {
     return null;
   }
   try {
-    const run = JSON.parse(readFileSync18(path, "utf8"));
+    const run = JSON.parse(readFileSync19(path, "utf8"));
     rmSync9(path, { force: true });
     return typeof run.cutAt === "string" && Array.isArray(run.paths) && run.paths.every((path) => typeof path === "string") ? run : null;
   } catch {
@@ -36471,27 +36621,27 @@ var init_dap_client = __esm(() => {
 import { createHash as createHash4 } from "node:crypto";
 import {
   closeSync,
-  existsSync as existsSync18,
+  existsSync as existsSync19,
   mkdtempSync as mkdtempSync2,
   openSync,
-  readFileSync as readFileSync19,
+  readFileSync as readFileSync20,
   rmSync as rmSync10,
   statSync as statSync9,
   writeFileSync as writeFileSync12,
   writeSync
 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
-import { join as join22 } from "node:path";
+import { join as join23 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 function helperAssembly(directory = tmpdir5()) {
-  return join22(directory, `gdharness-desktop-${DIGEST}.dll`);
+  return join23(directory, `gdharness-desktop-${DIGEST}.dll`);
 }
 async function ensureHelperCompiled(directory = tmpdir5(), budgetMs = HELPER_COMPILE_MS, wait = true) {
   const assembly = helperAssembly(directory);
   const lock = `${assembly}.compiling`;
   const until = Date.now() + budgetMs;
   while (Date.now() < until) {
-    if (existsSync18(assembly)) {
+    if (existsSync19(assembly)) {
       return null;
     }
     let mine = false;
@@ -36509,7 +36659,7 @@ async function ensureHelperCompiled(directory = tmpdir5(), budgetMs = HELPER_COM
       }
     }
     try {
-      const holder = Number(readFileSync19(lock, "utf8").trim());
+      const holder = Number(readFileSync20(lock, "utf8").trim());
       const old = Date.now() - statSync9(lock).mtimeMs > budgetMs;
       if (old || Number.isInteger(holder) && holder > 0 && !alive(holder)) {
         rmSync10(lock, { force: true });
@@ -36524,8 +36674,8 @@ async function ensureHelperCompiled(directory = tmpdir5(), budgetMs = HELPER_COM
   return `the desktop helper was not compiled within ${String(budgetMs)} ms`;
 }
 async function compileHelper(directory, assembly, budgetMs) {
-  const scratch = mkdtempSync2(join22(directory, "gdharness-desktop-source-"));
-  const source = join22(scratch, "helper.cs");
+  const scratch = mkdtempSync2(join23(directory, "gdharness-desktop-source-"));
+  const source = join23(scratch, "helper.cs");
   writeFileSync12(source, SOURCE, "utf8");
   const literal = (path) => `'${path.replaceAll("'", "''")}'`;
   const script = [
@@ -36563,7 +36713,7 @@ async function compileHelper(directory, assembly, budgetMs) {
       });
       compiler.once("close", (code) => {
         clearTimeout(timer);
-        resolve(existsSync18(assembly) ? null : `Windows PowerShell could not compile it${code === null ? " in time" : ""}: ${complained.trim() || `exit code ${String(code)}`}`);
+        resolve(existsSync19(assembly) ? null : `Windows PowerShell could not compile it${code === null ? " in time" : ""}: ${complained.trim() || `exit code ${String(code)}`}`);
       });
     });
   } finally {
@@ -36730,25 +36880,25 @@ var init_desktop = __esm(() => {
 // src/editor-log.ts
 import {
   closeSync as closeSync2,
-  existsSync as existsSync19,
+  existsSync as existsSync20,
   mkdirSync as mkdirSync10,
   openSync as openSync2,
-  readFileSync as readFileSync20,
+  readFileSync as readFileSync21,
   readSync,
   rmSync as rmSync11,
   statSync as statSync10,
   writeFileSync as writeFileSync13
 } from "node:fs";
-import { dirname as dirname15, join as join23 } from "node:path";
+import { dirname as dirname15, join as join24 } from "node:path";
 function editorLogPath(projectPath) {
-  return join23(projectPath, ".godot", "gdharness-editor.log");
+  return join24(projectPath, ".godot", "gdharness-editor.log");
 }
 function editorLogNotePath(projectPath) {
-  return join23(projectPath, ".godot", "gdharness-editor.json");
+  return join24(projectPath, ".godot", "gdharness-editor.json");
 }
 function readEditorLogNote(projectPath) {
   try {
-    const fields = asParams(JSON.parse(readFileSync20(editorLogNotePath(projectPath), "utf8")));
+    const fields = asParams(JSON.parse(readFileSync21(editorLogNotePath(projectPath), "utf8")));
     const pid = readNumber(fields, "pid");
     const startedAt = readString(fields, "startedAt");
     return pid !== undefined && Number.isInteger(pid) && pid > 0 && startedAt !== undefined ? { pid, startedAt } : null;
@@ -36789,7 +36939,7 @@ function editorConsole(projectPath, editorPid, openedByAServer) {
     return { kind: "older server", notedPid: noted?.pid ?? null };
   }
   const path = editorLogPath(projectPath);
-  if (!existsSync19(path)) {
+  if (!existsSync20(path)) {
     return { kind: "not written" };
   }
   const log = new GameLog;
@@ -36847,7 +36997,7 @@ function foldProgress(text) {
 function theFirstOf(path) {
   const whole = statSync10(path).size;
   if (whole <= MOST_CONSOLE_BYTES) {
-    return { text: readFileSync20(path, "utf8") };
+    return { text: readFileSync21(path, "utf8") };
   }
   const handle = openSync2(path, "r");
   try {
@@ -37008,7 +37158,7 @@ var init_editor_log = __esm(() => {
 });
 
 // src/rename.ts
-import { existsSync as existsSync20, mkdirSync as mkdirSync11, readFileSync as readFileSync21, renameSync as renameSync3, unlinkSync as unlinkSync3, writeFileSync as writeFileSync14 } from "node:fs";
+import { existsSync as existsSync21, mkdirSync as mkdirSync11, readFileSync as readFileSync22, renameSync as renameSync3, unlinkSync as unlinkSync3, writeFileSync as writeFileSync14 } from "node:fs";
 import { dirname as dirname16, posix as posix2 } from "node:path";
 
 class Script {
@@ -37713,11 +37863,11 @@ function rewritesOf(plan, texts, move) {
 }
 function applyRewrites(rewrites) {
   for (const rewrite of rewrites) {
-    const now = readFileSync21(rewrite.absolute, "utf8");
+    const now = readFileSync22(rewrite.absolute, "utf8");
     if (now !== rewrite.before) {
       throw new Error(`${rewrite.path} changed on disk while the rename was being worked out; nothing was written`);
     }
-    if (rewrite.writeTo !== rewrite.absolute && existsSync20(rewrite.writeTo)) {
+    if (rewrite.writeTo !== rewrite.absolute && existsSync21(rewrite.writeTo)) {
       throw new Error(`${rewrite.writeTo} already exists; nothing was written`);
     }
   }
@@ -37731,7 +37881,7 @@ function applyRewrites(rewrites) {
       let movedUid = false;
       if (rewrite.writeTo !== rewrite.absolute) {
         unlinkSync3(rewrite.absolute);
-        if (existsSync20(`${rewrite.absolute}.uid`)) {
+        if (existsSync21(`${rewrite.absolute}.uid`)) {
           renameSync3(`${rewrite.absolute}.uid`, `${rewrite.writeTo}.uid`);
           movedUid = true;
         }
@@ -37777,10 +37927,10 @@ var init_rename = __esm(() => {
 });
 
 // src/lsp_client.ts
-import { existsSync as existsSync21, realpathSync as realpathSync4 } from "node:fs";
+import { existsSync as existsSync22, realpathSync as realpathSync4 } from "node:fs";
 import { readFile, realpath } from "node:fs/promises";
 import { createConnection as createConnection3 } from "node:net";
-import { dirname as dirname17, join as join24, resolve as resolve5 } from "node:path";
+import { dirname as dirname17, join as join25, resolve as resolve5 } from "node:path";
 import { setTimeout as delay4 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
 function initializeTimeoutMs() {
@@ -38458,7 +38608,7 @@ async function resolveLSPPaths(projectPathValue, scriptPathValue) {
   } catch {
     throw new ArgumentRefusal(`Project path does not exist: ${requestedProjectPath}`);
   }
-  if (!existsSync21(join24(projectPath, "project.godot"))) {
+  if (!existsSync22(join25(projectPath, "project.godot"))) {
     throw new ArgumentRefusal(`Not a Godot project: ${projectPath}. Point projectPath at the directory holding project.godot.`);
   }
   const contained = resolveWithinProject(projectPath, scriptPathValue);
@@ -38618,8 +38768,8 @@ var init_lsp_client = __esm(() => {
 });
 
 // src/rename-symbol.ts
-import { existsSync as existsSync22, mkdirSync as mkdirSync12, readdirSync as readdirSync11, realpathSync as realpathSync5, rmSync as rmSync12, writeFileSync as writeFileSync15 } from "node:fs";
-import { basename as basename7, dirname as dirname18, join as join25, relative as relative4, resolve as resolve6 } from "node:path";
+import { existsSync as existsSync23, mkdirSync as mkdirSync12, readdirSync as readdirSync11, realpathSync as realpathSync5, rmSync as rmSync12, writeFileSync as writeFileSync15 } from "node:fs";
+import { basename as basename7, dirname as dirname18, join as join26, relative as relative4, resolve as resolve6 } from "node:path";
 function resourcePathOf(projectPath, absolute) {
   const inside = relative4(onDiskSpelling(projectPath), onDiskSpelling(absolute));
   if (inside === "" || inside.startsWith("..") || /^[A-Za-z]:/.test(inside)) {
@@ -38632,7 +38782,7 @@ function onDiskSpelling(path) {
   let at = resolve6(path);
   for (;; ) {
     try {
-      return join25(realpathSync5.native(at), ...missing.reverse());
+      return join26(realpathSync5.native(at), ...missing.reverse());
     } catch {
       const parent = dirname18(at);
       if (parent === at) {
@@ -38685,7 +38835,7 @@ async function renameSymbol(request, services) {
         reason: `newScriptPath must be a .gd path inside the project, and ${request.newScriptPath} is not.`
       };
     }
-    if (existsSync22(request.newScriptPath)) {
+    if (existsSync23(request.newScriptPath)) {
       return { ok: false, reason: `${moveTo} already exists, so the script cannot be moved there.` };
     }
   }
@@ -38861,7 +39011,7 @@ async function renameSymbol(request, services) {
       scripts,
       moves: new Map([[declaringPath, moveTo]]),
       named: [declaringPath],
-      exists: (path) => existsSync22(`${projectPath}/${path.slice("res://".length)}`)
+      exists: (path) => existsSync23(`${projectPath}/${path.slice("res://".length)}`)
     }, plan);
   }
   plan = mentionIgnored(plan, ignoredTexts(projectPath), symbol, moveTo === null ? [] : [declaringPath]);
@@ -39060,15 +39210,15 @@ ${mention.kind}`;
   };
 }
 function writeLeftAloneDetail(projectPath, symbol, detail) {
-  const directory = join25(projectPath, ".godot", "gdharness-renames");
+  const directory = join26(projectPath, ".godot", "gdharness-renames");
   mkdirSync12(directory, { recursive: true });
   detailWrites += 1;
-  const path = join25(directory, `${String(Date.now())}-${String(detailWrites).padStart(6, "0")}-${String(process.pid)}-${symbol}.json`);
+  const path = join26(directory, `${String(Date.now())}-${String(detailWrites).padStart(6, "0")}-${String(process.pid)}-${symbol}.json`);
   writeFileSync15(path, `${JSON.stringify(detail, null, 2)}
 `, "utf8");
   const kept = readdirSync11(directory).filter((name) => name.endsWith(".json")).sort().reverse();
   for (const old of kept.slice(10)) {
-    rmSync12(join25(directory, old), { force: true });
+    rmSync12(join26(directory, old), { force: true });
   }
   return path;
 }
@@ -39109,18 +39259,18 @@ var init_rename_symbol = __esm(() => {
 
 // src/file-move.ts
 import {
-  existsSync as existsSync23,
+  existsSync as existsSync24,
   mkdirSync as mkdirSync13,
   readdirSync as readdirSync12,
-  readFileSync as readFileSync22,
+  readFileSync as readFileSync23,
   renameSync as renameSync4,
   statSync as statSync11,
   writeFileSync as writeFileSync16
 } from "node:fs";
-import { basename as basename8, dirname as dirname19, extname as extname3, join as join26, relative as relative5 } from "node:path";
+import { basename as basename8, dirname as dirname19, extname as extname3, join as join27, relative as relative5 } from "node:path";
 function filesUnder(directory) {
   return readdirSync12(directory, { withFileTypes: true }).flatMap((entry) => {
-    const path = join26(directory, entry.name);
+    const path = join27(directory, entry.name);
     return entry.isDirectory() ? filesUnder(path) : [path];
   });
 }
@@ -39141,8 +39291,8 @@ function unseenByTheEngine(projectPath, path) {
       return `${path} is under ${step}, and the engine passes over every directory whose name starts with a dot`;
     }
     if (at < steps.length - 1) {
-      directory = join26(directory, step);
-      if (existsSync23(join26(directory, ".gdignore"))) {
+      directory = join27(directory, step);
+      if (existsSync24(join27(directory, ".gdignore"))) {
         return `${path} is under a directory holding a .gdignore, which the engine does not load`;
       }
     }
@@ -39154,12 +39304,12 @@ function installedAddonOf(projectPath, path) {
   if (steps[0] !== "addons" || steps[1] === undefined) {
     return null;
   }
-  return existsSync23(join26(projectPath, "addons", steps[1], VERSION_MARKER)) ? `res://addons/${steps[1]}` : null;
+  return existsSync24(join27(projectPath, "addons", steps[1], VERSION_MARKER)) ? `res://addons/${steps[1]}` : null;
 }
 function binaryResources(projectPath) {
   const found = [];
   const visit = (directory, prefix) => {
-    if (existsSync23(join26(directory, ".gdignore"))) {
+    if (existsSync24(join27(directory, ".gdignore"))) {
       return;
     }
     for (const entry of readdirSync12(directory, { withFileTypes: true })) {
@@ -39168,7 +39318,7 @@ function binaryResources(projectPath) {
       }
       const path = `${prefix}${entry.name}`;
       if (entry.isDirectory()) {
-        visit(join26(directory, entry.name), `${path}/`);
+        visit(join27(directory, entry.name), `${path}/`);
       } else if (/\.(scn|res)$/i.test(entry.name)) {
         found.push(path);
       }
@@ -39178,7 +39328,7 @@ function binaryResources(projectPath) {
   return found;
 }
 function targetPathOf(projectPath, absolute) {
-  const inside = relative5(onDiskSpelling(projectPath), join26(onDiskSpelling(dirname19(absolute)), basename8(absolute)));
+  const inside = relative5(onDiskSpelling(projectPath), join27(onDiskSpelling(dirname19(absolute)), basename8(absolute)));
   if (inside === "" || inside.startsWith("..") || /^[A-Za-z]:/.test(inside)) {
     return null;
   }
@@ -39196,7 +39346,7 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
   if (to === null) {
     return { ok: false, reason: `newPath must be a path inside the project, and ${absoluteTo} is not.` };
   }
-  if (!existsSync23(absoluteFrom)) {
+  if (!existsSync24(absoluteFrom)) {
     return { ok: false, reason: `There is nothing at ${from} to move.` };
   }
   if (from === to) {
@@ -39225,7 +39375,7 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
   if (isDirectory && to.startsWith(`${from}/`)) {
     return { ok: false, reason: `${from} cannot be moved into itself.` };
   }
-  if (existsSync23(absoluteTo) && !sameFile(absoluteFrom, absoluteTo)) {
+  if (existsSync24(absoluteTo) && !sameFile(absoluteFrom, absoluteTo)) {
     return { ok: false, reason: `${to} already exists, so nothing was moved there.` };
   }
   const unseen = unseenByTheEngine(projectPath, to);
@@ -39233,7 +39383,7 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
     return { ok: false, reason: `${unseen}, so nothing there could load what was moved.` };
   }
   if (!isDirectory) {
-    const owner = SIDECARS.map((sidecar) => from.endsWith(sidecar) ? from.slice(0, -sidecar.length) : null).find((path) => path !== null && existsSync23(join26(projectPath, path.slice("res://".length))));
+    const owner = SIDECARS.map((sidecar) => from.endsWith(sidecar) ? from.slice(0, -sidecar.length) : null).find((path) => path !== null && existsSync24(join27(projectPath, path.slice("res://".length))));
     if (owner !== undefined && owner !== null) {
       return { ok: false, reason: `${from} belongs to ${owner} and moves with it: move ${owner} instead.` };
     }
@@ -39255,7 +39405,7 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
   } else {
     moves.set(from, to);
     for (const sidecar of SIDECARS) {
-      if (existsSync23(`${absoluteFrom}${sidecar}`)) {
+      if (existsSync24(`${absoluteFrom}${sidecar}`)) {
         moves.set(`${from}${sidecar}`, `${to}${sidecar}`);
       }
     }
@@ -39267,12 +39417,12 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
     scripts,
     moves,
     named: [from],
-    exists: (path) => existsSync23(join26(projectPath, path.slice("res://".length)))
+    exists: (path) => existsSync24(join27(projectPath, path.slice("res://".length)))
   }, { edits: [], mentions: [] });
   plan = mentionIgnored(plan, ignoredTexts(projectPath), null, [from]);
   const binaries = [];
   for (const path of binaryResources(projectPath)) {
-    const bytes = readFileSync22(join26(projectPath, path.slice("res://".length)));
+    const bytes = readFileSync23(join27(projectPath, path.slice("res://".length)));
     const names = [...moves.keys()].find((moving) => bytes.includes(moving));
     if (names !== undefined) {
       binaries.push({
@@ -39291,7 +39441,7 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
   }));
   const left = leftAloneReport(mentions);
   const rewrites = rewritesOf(plan, texts, null);
-  const absoluteOf = (path) => join26(projectPath, path.slice("res://".length));
+  const absoluteOf = (path) => join27(projectPath, path.slice("res://".length));
   const rewritten = new Map(rewrites.map((rewrite) => [rewrite.path, rewrite]));
   const moved = [...moves].map(([source, target]) => {
     const rewrite = rewritten.get(source);
@@ -39333,18 +39483,18 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
 }
 function applyFileMove(outcome) {
   for (const rewrite of outcome.inPlace) {
-    if (readFileSync22(rewrite.absolute, "utf8") !== rewrite.before) {
+    if (readFileSync23(rewrite.absolute, "utf8") !== rewrite.before) {
       throw new Error(`${rewrite.path} changed on disk while the move was being worked out; nothing was written`);
     }
   }
   for (const file of outcome.moved) {
-    if (!existsSync23(file.absoluteFrom)) {
+    if (!existsSync24(file.absoluteFrom)) {
       throw new Error(`${file.from} is gone from disk; nothing was written`);
     }
-    if (file.text !== null && readFileSync22(file.absoluteFrom, "utf8") !== file.text.before) {
+    if (file.text !== null && readFileSync23(file.absoluteFrom, "utf8") !== file.text.before) {
       throw new Error(`${file.from} changed on disk while the move was being worked out; nothing was written`);
     }
-    if (existsSync23(file.absoluteTo) && !sameFile(file.absoluteFrom, file.absoluteTo)) {
+    if (existsSync24(file.absoluteTo) && !sameFile(file.absoluteFrom, file.absoluteTo)) {
       throw new Error(`${file.to} already exists; nothing was written`);
     }
   }
@@ -43537,10 +43687,10 @@ var init_keeper_channel = () => {};
 
 // src/lifecycle-log.ts
 import { appendFileSync, mkdirSync as mkdirSync14, renameSync as renameSync5, statSync as statSync12 } from "node:fs";
-import { dirname as dirname20, join as join27 } from "node:path";
+import { dirname as dirname20, join as join28 } from "node:path";
 import process11 from "node:process";
 function lifecycleLogPath() {
-  return join27(runtimeDirectory(), "servers.log");
+  return join28(runtimeDirectory(), "servers.log");
 }
 function writeLifecycle(event, fields = {}) {
   const path = lifecycleLogPath();
@@ -43860,10 +44010,10 @@ var init_prompts = __esm(() => {
 });
 
 // src/restart-note.ts
-import { mkdirSync as mkdirSync15, readFileSync as readFileSync23, rmSync as rmSync13, writeFileSync as writeFileSync17 } from "node:fs";
-import { dirname as dirname21, join as join28 } from "node:path";
+import { mkdirSync as mkdirSync15, readFileSync as readFileSync24, rmSync as rmSync13, writeFileSync as writeFileSync17 } from "node:fs";
+import { dirname as dirname21, join as join29 } from "node:path";
 function restartNotePath(projectPath) {
-  return join28(projectPath, ".godot", "gdharness-restart.json");
+  return join29(projectPath, ".godot", "gdharness-restart.json");
 }
 function noteRestartBegun(note) {
   const path = restartNotePath(note.projectPath);
@@ -43877,7 +44027,7 @@ function noteRestartBegun(note) {
 }
 function restartOwed(projectPath) {
   try {
-    const parsed = JSON.parse(readFileSync23(restartNotePath(projectPath), "utf8"));
+    const parsed = JSON.parse(readFileSync24(restartNotePath(projectPath), "utf8"));
     if (typeof parsed !== "object" || parsed === null) {
       return null;
     }
@@ -43903,17 +44053,17 @@ var init_restart_note = __esm(() => {
 
 // src/run-record.ts
 import { createHash as createHash5 } from "node:crypto";
-import { mkdirSync as mkdirSync16, openSync as openSync3, readdirSync as readdirSync13, readFileSync as readFileSync24, realpathSync as realpathSync6, rmSync as rmSync14, statSync as statSync13 } from "node:fs";
-import { basename as basename9, dirname as dirname22, join as join29, resolve as resolve7 } from "node:path";
+import { mkdirSync as mkdirSync16, openSync as openSync3, readdirSync as readdirSync13, readFileSync as readFileSync25, realpathSync as realpathSync6, rmSync as rmSync14, statSync as statSync13 } from "node:fs";
+import { basename as basename9, dirname as dirname22, join as join30, resolve as resolve7 } from "node:path";
 function runsDirectory() {
-  return join29(runtimeDirectory(), "runs");
+  return join30(runtimeDirectory(), "runs");
 }
 function realAsFarAsItExists(path) {
   const missing = [];
   let at = path;
   for (;; ) {
     try {
-      return join29(realpathSync6.native(at), ...missing);
+      return join30(realpathSync6.native(at), ...missing);
     } catch {
       const parent = dirname22(at);
       if (parent === at) {
@@ -43930,10 +44080,10 @@ function projectKey(projectPath) {
   return createHash5("sha256").update(folded.replaceAll("\\", "/")).digest("hex").slice(0, 16);
 }
 function runRecordPath(projectPath, directory = runtimeDirectory()) {
-  return join29(directory, "runs", `note-${projectKey(projectPath)}.json`);
+  return join30(directory, "runs", `note-${projectKey(projectPath)}.json`);
 }
 function latestRunPath(servedBy, directory = runtimeDirectory()) {
-  return join29(directory, "runs", `latest-${projectKey(servedBy)}.json`);
+  return join30(directory, "runs", `latest-${projectKey(servedBy)}.json`);
 }
 function writeLatestRun(servedBy, latest) {
   try {
@@ -43943,7 +44093,7 @@ function writeLatestRun(servedBy, latest) {
 }
 function readLatestRun(servedBy, directory = runtimeDirectory()) {
   try {
-    const fields = JSON.parse(readFileSync24(latestRunPath(servedBy, directory), "utf8"));
+    const fields = JSON.parse(readFileSync25(latestRunPath(servedBy, directory), "utf8"));
     if (typeof fields !== "object" || fields === null) {
       return null;
     }
@@ -43958,20 +44108,20 @@ function readLatestRun(servedBy, directory = runtimeDirectory()) {
 }
 function openTranscript(startedAt) {
   mkdirSync16(runsDirectory(), { recursive: true });
-  const path = join29(runsDirectory(), `run-${startedAt}.log`);
+  const path = join30(runsDirectory(), `run-${startedAt}.log`);
   return { path, fd: openSync3(path, "a") };
 }
 function profilePath(startedAt) {
-  return join29(runsDirectory(), `run-${startedAt}.profile.json`);
+  return join30(runsDirectory(), `run-${startedAt}.profile.json`);
 }
 function profileMarkPath(startedAt) {
-  return join29(runsDirectory(), `run-${startedAt}.profile-mark.json`);
+  return join30(runsDirectory(), `run-${startedAt}.profile-mark.json`);
 }
 function noteIsAbout(note, playing) {
   return note.play !== undefined && playing !== null && note.play.play === playing.play && note.play.editorPid === playing.editorPid;
 }
 function editorNotePath(projectPath, directory = runtimeDirectory()) {
-  return join29(directory, "runs", `editor-${projectKey(projectPath)}.json`);
+  return join30(directory, "runs", `editor-${projectKey(projectPath)}.json`);
 }
 function writeEditorRunNote(note) {
   mkdirSync16(runsDirectory(), { recursive: true });
@@ -43982,7 +44132,7 @@ function writeEditorRunNote(note) {
 }
 function readEditorRunNote(projectPath) {
   for (const directory of runtimeDirectories()) {
-    const note = editorNoteAt(editorNotePath(projectPath, directory)) ?? editorNoteAt(join29(directory, "runs", "editor-run.json"));
+    const note = editorNoteAt(editorNotePath(projectPath, directory)) ?? editorNoteAt(join30(directory, "runs", "editor-run.json"));
     if (note !== null && isSameDirectory(note.projectPath, projectPath)) {
       return note;
     }
@@ -43992,7 +44142,7 @@ function readEditorRunNote(projectPath) {
 function editorNoteAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync24(path, "utf8"));
+    parsed = JSON.parse(readFileSync25(path, "utf8"));
   } catch {
     return null;
   }
@@ -44016,7 +44166,7 @@ function readRunRecord(projectPath) {
     if (own !== null) {
       return own;
     }
-    const shared = recordAt(join29(directory, "runs", SHARED_NOTE));
+    const shared = recordAt(join30(directory, "runs", SHARED_NOTE));
     if (shared !== null && shared.projectPath !== "" && isSameDirectory(shared.projectPath, projectPath)) {
       return shared;
     }
@@ -44028,13 +44178,13 @@ function everyRunRecord() {
   for (const directory of runtimeDirectories()) {
     let entries;
     try {
-      entries = readdirSync13(join29(directory, "runs"));
+      entries = readdirSync13(join30(directory, "runs"));
     } catch {
       continue;
     }
     for (const entry of entries) {
       if (entry === SHARED_NOTE || entry.startsWith("note-") && entry.endsWith(".json")) {
-        const record = recordAt(join29(directory, "runs", entry));
+        const record = recordAt(join30(directory, "runs", entry));
         if (record !== null) {
           found.push(record);
         }
@@ -44046,7 +44196,7 @@ function everyRunRecord() {
 function recordAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync24(path, "utf8"));
+    parsed = JSON.parse(readFileSync25(path, "utf8"));
   } catch {
     return null;
   }
@@ -44099,7 +44249,7 @@ async function runningAs(pid) {
     const began = await startedAt(pid, null);
     const when = began === null ? {} : { startedAt: began };
     if (process.platform === "linux") {
-      const raw = readFileSync24(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
+      const raw = readFileSync25(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
       return raw === "" ? null : { kind: "commandLine", text: raw, ...when };
     }
     const args = (await runHidden("ps", ["-p", String(pid), "-o", "args="], { timeout: 15000 })).stdout.trim();
@@ -44242,7 +44392,7 @@ function judgeAnnouncedGame(running, projectPath, announcedAt) {
 }
 function clearRunRecord(projectPath) {
   for (const directory of runtimeDirectories()) {
-    const shared = join29(directory, "runs", SHARED_NOTE);
+    const shared = join30(directory, "runs", SHARED_NOTE);
     const sharedRecord = recordAt(shared);
     const ours = sharedRecord !== null && sharedRecord.projectPath !== "" && isSameDirectory(sharedRecord.projectPath, projectPath);
     for (const path of [runRecordPath(projectPath, directory), ...ours ? [shared] : []]) {
@@ -44277,7 +44427,7 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
     if (!transcript && !entry.endsWith(".partial")) {
       continue;
     }
-    const path = join29(directory, entry);
+    const path = join30(directory, entry);
     if (kept.has(path) || ageMs(path, now) < keepMs) {
       continue;
     }
@@ -44298,7 +44448,7 @@ var init_run_record = __esm(() => {
 });
 
 // src/script-origins.ts
-import { join as join30 } from "node:path";
+import { join as join31 } from "node:path";
 function unresolvedClassIn(message) {
   return UNRESOLVED.exec(message)?.[1] ?? null;
 }
@@ -44335,6 +44485,12 @@ async function originsOf(errors, declared, check) {
   }
   return { origins, unconfirmed };
 }
+function compileErrorsIn(entries) {
+  return entries.flatMap((entry) => {
+    const at = entry.severity === "error" ? reloadedAt(entry) : null;
+    return at === null ? [] : [{ ...at, message: entry.text }];
+  });
+}
 function reloadedAt(entry) {
   for (const line of entry.detail) {
     const at = RELOADED_AT.exec(line.trim());
@@ -44351,7 +44507,7 @@ function checkWithEngine(godotPath, projectPath) {
       const ran = await runEngine(godotPath, [
         "--headless",
         "--log-file",
-        join30(logDir, "engine.log"),
+        join31(logDir, "engine.log"),
         "--path",
         projectPath,
         "--check-only",
@@ -44396,10 +44552,10 @@ var init_script_origins = __esm(() => {
 });
 
 // src/script-profile.ts
-import { readFileSync as readFileSync25 } from "node:fs";
+import { readFileSync as readFileSync26 } from "node:fs";
 function readProfileFile(path) {
   try {
-    const parsed = JSON.parse(readFileSync25(path, "utf8"));
+    const parsed = JSON.parse(readFileSync26(path, "utf8"));
     return typeof parsed === "object" && typeof parsed.connected === "boolean" ? parsed : null;
   } catch {
     return null;
@@ -44427,12 +44583,16 @@ function signatureParts(signature) {
 function profiledFunctions(totals, limit, sourceOf = () => null) {
   const perCallUs = perCallCostOf(totals);
   const rows = rowsOf(totals, sourceOf).map((row) => withOverhead(row, perCallUs));
-  const scriptMs = ms(Object.entries(totals.functions).reduce((sum, [signature, one]) => sum + (one.calls > 0 && !isCalibration(signature) ? one.selfSeconds : 0), 0));
+  const called = Object.entries(totals.functions).filter(([signature, one]) => one.calls > 0 && !isCalibration(signature));
+  const addon = called.filter(([signature]) => isRuntimeAddon(signature));
+  const selfOf = (entries) => ms(entries.reduce((sum, [, one]) => sum + one.selfSeconds, 0));
   return {
     functions: rows.slice(0, limit).map((row) => placedLambda(row, sourceOf)),
     omitted: Math.max(0, rows.length - limit),
-    scriptMs,
+    scriptMs: selfOf(called.filter(([signature]) => !isRuntimeAddon(signature))),
     counted: rows.length,
+    addonMs: selfOf(addon),
+    addonFunctions: addon.length,
     superCallers: rows.filter((row) => row.selfIncludesSuper === true).length,
     perCallUs,
     overheadDominated: rows.filter((row) => row.overheadMs !== undefined).length,
@@ -44440,6 +44600,9 @@ function profiledFunctions(totals, limit, sourceOf = () => null) {
     overheadReach: rows.findLastIndex((row) => row.overheadMs !== undefined) + 1
   };
 }
+function isRuntimeAddon(signature) {
+  return signatureParts(signature).script.startsWith(RUNTIME_ADDON2);
+}
 function isCalibration(signature) {
   const parts = signatureParts(signature);
   return parts.script.endsWith(RUNTIME_SCRIPT) && (parts.function === PROFILER_PROBE || parts.function === PROFILER_CALIBRATOR);
@@ -44449,7 +44612,7 @@ function writeProfileMark(path, mark) {
 }
 function readProfileMark(path) {
   try {
-    const parsed = JSON.parse(readFileSync25(path, "utf8"));
+    const parsed = JSON.parse(readFileSync26(path, "utf8"));
     return typeof parsed === "object" && typeof parsed.totals === "object" ? parsed : null;
   } catch {
     return null;
@@ -44515,7 +44678,7 @@ function rowsOf(totals, sourceOf) {
     }
     return codes.get(script) ?? null;
   };
-  return Object.entries(totals.functions).filter(([signature, sum]) => sum.calls > 0 && !isCalibration(signature)).map(([signature, sum]) => {
+  return Object.entries(totals.functions).filter(([signature, sum]) => sum.calls > 0 && !isRuntimeAddon(signature) && !isCalibration(signature)).map(([signature, sum]) => {
     const parts = signatureParts(signature);
     const code = codeOfScript(parts.script);
     const property = propertyOf(parts.function);
@@ -44591,7 +44754,7 @@ function callersOf(totals, name, scripts) {
     property
   };
 }
-var QUEUE_SETTING = "limits/debugger/max_queued_messages", QUEUE_DEFAULT = 2048, QUEUE_HEADROOM = 512, UNNAMED_PREFIX = "#", PROFILE_FROM_START = "GDHARNESS_PROFILE_FROM_START", ms = (seconds) => Math.round(seconds * 1e6) / 1000, RUNTIME_SCRIPT = "gdharness_runtime/runtime_autoload.gd", PROFILER_PROBE = "_profiler_probe", PROFILER_CALIBRATOR = "_calibrate_the_profiler", CALL_SITES = 40;
+var QUEUE_SETTING = "limits/debugger/max_queued_messages", QUEUE_DEFAULT = 2048, QUEUE_HEADROOM = 512, UNNAMED_PREFIX = "#", PROFILE_FROM_START = "GDHARNESS_PROFILE_FROM_START", ms = (seconds) => Math.round(seconds * 1e6) / 1000, RUNTIME_SCRIPT = "gdharness_runtime/runtime_autoload.gd", PROFILER_PROBE = "_profiler_probe", PROFILER_CALIBRATOR = "_calibrate_the_profiler", RUNTIME_ADDON2 = "res://addons/gdharness_runtime/", CALL_SITES = 40;
 var init_script_profile = __esm(() => {
   init_gdscript_source();
   init_godot_variant();
@@ -44622,18 +44785,18 @@ import {
   closeSync as closeSync3,
   constants,
   copyFileSync,
-  existsSync as existsSync24,
+  existsSync as existsSync25,
   fstatSync,
   mkdirSync as mkdirSync17,
   openSync as openSync4,
   readdirSync as readdirSync14,
-  readFileSync as readFileSync26,
+  readFileSync as readFileSync27,
   readSync as readSync2,
   rmdirSync as rmdirSync2,
   statSync as statSync14,
   writeFileSync as writeFileSync18
 } from "node:fs";
-import { basename as basename10, dirname as dirname23, extname as extname4, isAbsolute as isAbsolute5, join as join31, normalize as normalize2, relative as relative6 } from "node:path";
+import { basename as basename10, dirname as dirname23, extname as extname4, isAbsolute as isAbsolute5, join as join32, normalize as normalize2, relative as relative6 } from "node:path";
 import { setTimeout as delay5 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 function editorRestartTimeoutMs() {
@@ -44670,15 +44833,15 @@ function writtenFileRefusal(path, rule) {
     return `${named} ${path} does not end in ${rule.extensions.join(" or ")}, which is what ${what} is.`;
   }
   const directory = realPathOr(dirname23(path));
-  if (!existsSync24(directory)) {
+  if (!existsSync25(directory)) {
     return `${named}'s directory ${dirname23(path)} does not exist; ${what} creates no directories.`;
   }
-  const where = join31(directory, basename10(path));
+  const where = join32(directory, basename10(path));
   const inside = rule.projects.find((project) => project !== "" && isWithinRoot(realPathOr(project), where));
   if (inside !== undefined) {
     return `${named} ${path} is inside the project at ${inside}; ${what} is saved outside it, so it never becomes part of the game.`;
   }
-  const taken = rule.writes(where).find((file) => existsSync24(file));
+  const taken = rule.writes(where).find((file) => existsSync25(file));
   if (taken !== undefined) {
     return taken === where ? `${named} ${path} already exists; ${what} is not written over a file. Name a new one.` : `${named} ${path} would write ${taken}, which already exists; ${what} is not written over a file. Name a new one.`;
   }
@@ -45150,7 +45313,12 @@ function unlistedValues(schema, value, path) {
   const fields = schema;
   const listed = fields["enum"];
   if (Array.isArray(listed) && typeof value === "string") {
-    return listed.includes(value) ? [] : [`${path} as one of ${listed.join(", ")}, not ${JSON.stringify(value)}`];
+    if (listed.includes(value)) {
+      return [];
+    }
+    return [
+      listed.length === 1 ? `${path} only as ${String(listed[0])}, not ${JSON.stringify(value)}` : `${path} as one of ${listed.join(", ")}, not ${JSON.stringify(value)}`
+    ];
   }
   if (Array.isArray(value)) {
     return value.flatMap((element, index) => unlistedValues(fields["items"], element, `${path}[${index}]`));
@@ -45214,7 +45382,7 @@ function notRunNote(notRun, failFast) {
 function exportPresetRefusal(projectPath, preset) {
   let text;
   try {
-    text = readFileSync26(join31(projectPath, "export_presets.cfg"), "utf8");
+    text = readFileSync27(join32(projectPath, "export_presets.cfg"), "utf8");
   } catch {
     return `This project has no export_presets.cfg, so it has no preset '${preset}' to export with. project_export add_preset writes one, as the editor's Project > Export does.`;
   }
@@ -45280,7 +45448,7 @@ function filesIn(folder) {
   try {
     for (const entry of readdirSync14(folder, { withFileTypes: true })) {
       if (entry.isFile()) {
-        found.set(entry.name, statSync14(join31(folder, entry.name)).mtimeMs);
+        found.set(entry.name, statSync14(join32(folder, entry.name)).mtimeMs);
       }
     }
   } catch {}
@@ -45310,7 +45478,7 @@ function unsavedInEditorNote(scripts) {
   return `${named} ${one ? "is" : "are"} open in the editor's script ${one ? "tab" : "tabs"} with unsaved edits, and saving ${one ? "that tab" : "them"} there writes ${one ? "its" : "their"} text over what was written here: close ${one ? "it" : "them"} without saving, or save first and edit again.`;
 }
 function editorAddonMissing(projectPath) {
-  if (!existsSync24(join31(projectPath, "project.godot"))) {
+  if (!existsSync25(join32(projectPath, "project.godot"))) {
     return null;
   }
   const report = inspectProject(projectPath);
@@ -45476,8 +45644,34 @@ function scriptErrorsNote(errors, {
   const opening = unnamed === 0 ? `No tests ran: gdUnit4 could not load ${scripts === 1 ? "one script" : `${scripts} scripts`} while looking for suites, and it runs no suite at all when one fails to load.` : `No tests ran: ${scripts + unnamed} scripts did not compile, and gdUnit4 runs no suite at all when one fails to load. It could not load ${scripts === 1 ? "one" : scripts} of them while looking for suites, and ${unnamed === 1 ? "the one it did not name comes" : `the ${unnamed} it did not name come`} first.`;
   return [opening, named, following, rest, after].filter((part) => part !== "").join(" ");
 }
-function timedOutVerdict(timeoutMs, silentForMs) {
+function autoloadNotCompiledNote(at, errors, stoppedEarly) {
+  const first = errors.scriptErrors[0];
+  const where = first === undefined ? "" : `, and the first error the engine raised compiling was at ${first.path}${first.line === null ? "" : `:${first.line}`}: ${first.message}`;
+  const others = errors.scriptErrors.length - 1;
+  const more = others > 0 ? ` ${others === 1 ? "One more error is" : `${others} more errors are`} under scriptErrors.` : "";
+  const through = errors.failedThroughDependency.length;
+  const dependents = through > 0 ? ` ${through === 1 ? "One script" : `${through} scripts`} failed only through ${first === undefined ? "it" : "that"}, listed under failedThroughDependency.` : "";
+  const ended = stoppedEarly ? "The run was stopped as soon as the engine said so rather than left to its timeout" : "The run ended before that was read, and what its suites said is set aside";
+  const stop = /[.!?]\)?$/.test(where) ? "" : ".";
+  return `No result counts: the autoload ${at.name} (${at.path}) did not compile${where}${stop}${more}${dependents} Every suite runs with the autoloads, so a case calling into a script that did not compile fails the same way on every pass, and one waiting in a loop for the call to succeed never ends. ${ended}. script_diagnostics checks a script without running anything.`;
+}
+function repeatingScriptError(entries, byScript) {
+  const last = entries.at(-1);
+  if (last === undefined || !byScript(last)) {
+    return null;
+  }
+  const where = last.detail[0] ?? null;
+  const times = entries.filter((entry) => entry.text === last.text && (entry.detail[0] ?? null) === where && byScript(entry)).length;
+  return times >= LOOPING_AFTER ? { text: last.text, where: where?.replace(/^at: /, "") ?? null, times } : null;
+}
+function timedOutVerdict(timeoutMs, silentForMs, repeating = null) {
   const quiet = Math.round(silentForMs);
+  if (repeating !== null) {
+    return {
+      verdict: `timed out after ${timeoutMs} ms repeating one script error, printed ${repeating.times} times: ${repeating.text}${repeating.where === null ? "" : ` (${repeating.where})`}. A line that fails on every pass of a loop does this, and a longer timeoutMs would not end it`,
+      hung: false
+    };
+  }
   return quiet >= Math.min(STALLED_AFTER_MS, timeoutMs / 2) ? {
     verdict: `hung: killed after ${timeoutMs} ms, having printed nothing for the last ${quiet} ms`,
     hung: true
@@ -45548,7 +45742,7 @@ function profileFrameFunctions(projectPath) {
   let projectGodot = null;
   if (projectPath !== null) {
     try {
-      projectGodot = readFileSync26(join31(projectPath, "project.godot"), "utf8");
+      projectGodot = readFileSync27(join32(projectPath, "project.godot"), "utf8");
     } catch {}
   }
   return frameFunctionsFor(queuedMessagesOf(projectGodot));
@@ -45572,7 +45766,7 @@ function projectSourceOf(projectPath) {
       let source = null;
       if (inside.ok) {
         try {
-          source = readFileSync26(inside.absolutePath, "utf8");
+          source = readFileSync27(inside.absolutePath, "utf8");
         } catch {}
       }
       read.set(script, source);
@@ -45623,6 +45817,9 @@ function profileAnswer(reading, limit) {
   if (reading.coveredMs > 0 && table.scriptMs > reading.coveredMs) {
     notes.push(`scriptMs, ${table.scriptMs}ms, is more than the ${reading.coveredMs}ms the profile covers.${table.superCallers > 0 ? " The super calls above, counted twice, can account for some or all of that; whatever they do not is" : " One thread cannot spend more time than passes, so that is"} functions running on several threads at once, through WorkerThreadPool or Thread. The engine adds every thread's time to the same function and does not say which thread a call ran on, so a function's selfMs is summed over every thread it ran on rather than taken out of frames, and a function that waits for the others, through wait_for_group_task_completion or wait_to_finish, has the wait in its own selfMs as well.`);
   }
+  if (table.addonFunctions > 0) {
+    notes.push(`The gdharness runtime addon's own functions took ${table.addonMs}ms of self time over ${table.addonFunctions === 1 ? "one function" : `${table.addonFunctions} functions`}, answering tools such as runtime_invoke and sending the profile. They are left out of functions, functionsCounted and scriptMs and summed under runtimeAddonMs, since they are not the game's work, though that time was spent in the game's frames.`);
+  }
   notes.push(...cappedNotes(totals));
   if (totals.unreadable > 0) {
     notes.push(`${totals.unreadable} message${totals.unreadable === 1 ? "" : "s"} from the game could not be read, so the totals have that many gaps.`);
@@ -45637,6 +45834,8 @@ function profileAnswer(reading, limit) {
     scriptMs: table.scriptMs,
     perCallOverheadUs: table.perCallUs ?? undefined,
     functionsCounted: table.counted,
+    runtimeAddonMs: table.addonFunctions > 0 ? table.addonMs : undefined,
+    runtimeAddonFunctions: table.addonFunctions > 0 ? table.addonFunctions : undefined,
     omitted: table.omitted > 0 ? table.omitted : undefined,
     functions: table.functions,
     callers: reading.callersOf === undefined ? undefined : callersAnswer(totals, reading.callersOf),
@@ -45722,7 +45921,7 @@ function foldedEntriesAnswer(log, floor = "warning") {
 }
 function gdUnitFailsOnScriptErrors(projectPath) {
   try {
-    return settingKeys(readFileSync26(join31(projectPath, "project.godot"), "utf8")).get("gdunit4/report/godot/script_error") !== false;
+    return settingKeys(readFileSync27(join32(projectPath, "project.godot"), "utf8")).get("gdunit4/report/godot/script_error") !== false;
   } catch {
     return true;
   }
@@ -45737,7 +45936,7 @@ function uncaughtNote(uncaught) {
 }
 function elsewhereIn(projectPath, asked) {
   const wanted = asked.replace(/^res:\/\//, "").replace(/\/+$/, "");
-  if (wanted === "" || existsSync24(join31(projectPath, wanted))) {
+  if (wanted === "" || existsSync25(join32(projectPath, wanted))) {
     return "";
   }
   const root = (wanted.split("/")[0] ?? "").toLowerCase();
@@ -45840,7 +46039,7 @@ function isDirectory(path) {
   }
 }
 function scriptsUnder(directory, prefix) {
-  if (existsSync24(join31(directory, ".gdignore"))) {
+  if (existsSync25(join32(directory, ".gdignore"))) {
     return [];
   }
   const found = [];
@@ -45850,7 +46049,7 @@ function scriptsUnder(directory, prefix) {
     }
     const path = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
     if (entry.isDirectory()) {
-      found.push(...scriptsUnder(join31(directory, entry.name), path));
+      found.push(...scriptsUnder(join32(directory, entry.name), path));
     } else if (entry.isFile() && entry.name.endsWith(".gd")) {
       found.push(path);
     }
@@ -45858,7 +46057,7 @@ function scriptsUnder(directory, prefix) {
   return found;
 }
 function hasMainScene(projectFile) {
-  const scene = parseProjectGodot(readFileSync26(projectFile, "utf8"))["application"]?.["run/main_scene"];
+  const scene = parseProjectGodot(readFileSync27(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "";
 }
 function runtimeAddonAnnouncesEditors(projectPath) {
@@ -45866,13 +46065,13 @@ function runtimeAddonAnnouncesEditors(projectPath) {
     return false;
   }
   try {
-    return readFileSync26(join31(projectPath, RUNTIME_AUTOLOAD.path), "utf8").includes('"editor_pid"');
+    return readFileSync27(join32(projectPath, RUNTIME_AUTOLOAD.path), "utf8").includes('"editor_pid"');
   } catch {
     return false;
   }
 }
 function editorPlaysHeadless(projectFile) {
-  const runArgs = parseProjectGodot(readFileSync26(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
+  const runArgs = parseProjectGodot(readFileSync27(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
   return typeof runArgs === "string" && /(?:^|\s)--headless(?:\s|$)/.test(runArgs);
 }
 function camelCased(params) {
@@ -45891,7 +46090,7 @@ function needsItsOwnProcess(asked) {
 class GodotServer {
   stdio = null;
   locator = new GodotLocator;
-  operationsScript = join31(__dirname2, "godot", "operations", "godot_operations.gd");
+  operationsScript = join32(__dirname2, "godot", "operations", "godot_operations.gd");
   godotBridge;
   tools = buildToolDefinitions();
   activeProcess = null;
@@ -46152,14 +46351,14 @@ class GodotServer {
   }
   noteTheStart() {
     const cwd = process.cwd();
-    const mcpJson = join31(cwd, ".mcp.json");
+    const mcpJson = join32(cwd, ".mcp.json");
     const announced = this.ownProject === null ? null : readAnnouncement(announcementPath(this.ownProject));
     const predecessor = announced !== null && announced.pid !== process.pid && alive(announced.pid) ? announced.pid : null;
     writeLifecycle("started", {
       argv: process.argv.slice(1),
       cwd,
       project: this.ownProject,
-      mcpJson: existsSync24(mcpJson) ? mcpJson : null
+      mcpJson: existsSync25(mcpJson) ? mcpJson : null
     });
     if (predecessor !== null) {
       writeLifecycle("replaced", { project: this.ownProject, predecessor });
@@ -46300,7 +46499,7 @@ class GodotServer {
         return checked.response;
       }
       const named = args["projectPath"];
-      if (typeof named === "string" && existsSync24(join31(named, "project.godot"))) {
+      if (typeof named === "string" && existsSync25(join32(named, "project.godot"))) {
         this.lastProjectPath = named;
       }
       this.updates.refresh();
@@ -46336,7 +46535,7 @@ class GodotServer {
     let notSaved;
     try {
       savedAt = answer.content.map((item, index) => {
-        const file = join31(directory, item.type === "text" ? `${stem}-${index}.txt` : `${stem}-${index}.${item.mimeType.split("/")[1] ?? "bin"}`);
+        const file = join32(directory, item.type === "text" ? `${stem}-${index}.txt` : `${stem}-${index}.${item.mimeType.split("/")[1] ?? "bin"}`);
         writeFileSync18(file, item.type === "text" ? item.text : Buffer.from(item.data, "base64"));
         return file;
       });
@@ -46954,8 +47153,8 @@ class GodotServer {
     if (path === undefined) {
       return { ok: false, response: this.createErrorResponse("projectPath is required.") };
     }
-    const file = join31(path, "project.godot");
-    if (!existsSync24(file)) {
+    const file = join32(path, "project.godot");
+    if (!existsSync25(file)) {
       return {
         ok: false,
         response: this.createErrorResponse(`Not a Godot project: ${path}`, [
@@ -47615,7 +47814,7 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const application = parseProjectGodot(readFileSync26(project.value.file, "utf8"))["application"] ?? {};
+    const application = parseProjectGodot(readFileSync27(project.value.file, "utf8"))["application"] ?? {};
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
@@ -47713,7 +47912,7 @@ class GodotServer {
     const exportArgs = [
       "--headless",
       "--log-file",
-      join31(exportLogs, "engine.log"),
+      join32(exportLogs, "engine.log"),
       "--path",
       project.value.path,
       debug ? "--export-debug" : "--export-release",
@@ -47721,7 +47920,7 @@ class GodotServer {
       output.absolutePath
     ];
     this.logDebug(`Exporting: ${engine.value} ${exportArgs.join(" ")}`);
-    const writtenAt = () => existsSync24(output.absolutePath) ? statSync14(output.absolutePath).mtimeMs : null;
+    const writtenAt = () => existsSync25(output.absolutePath) ? statSync14(output.absolutePath).mtimeMs : null;
     const caches = editorCacheDirectory(engine.value);
     const exportOnce = async () => {
       const before = writtenAt();
@@ -47804,10 +48003,10 @@ class GodotServer {
     if (movie !== null) {
       return this.createErrorResponse(movie);
     }
-    const missing = paths.value.filter((path) => !existsSync24(join31(project.value.path, path.slice("res://".length))));
+    const missing = paths.value.filter((path) => !existsSync25(join32(project.value.path, path.slice("res://".length))));
     const asked = paths.value.filter((path) => !missing.includes(path));
     const runner = "addons/gdUnit4/bin/GdUnitCmdTool.gd";
-    const noRunner = !existsSync24(join31(project.value.path, runner));
+    const noRunner = !existsSync25(join32(project.value.path, runner));
     if (asked.length === 0) {
       const verdict = `nothing at ${missing.join(" and ")}`;
       const andNoRunner = noRunner ? `, and gdUnit4 is not installed in this project: no ${runner}` : "";
@@ -47877,35 +48076,50 @@ class GodotServer {
       lastSaid = Date.now();
     });
     const reporting = this.reportTestProgress(run.log);
+    const autoloaded = scriptsAutoloaded(project.value.path);
     let silentForMs = 0;
+    const stopped = { for: null };
     const timedOut = await new Promise((resolve) => {
+      let read = 0;
+      const watching = setInterval(() => {
+        const entries = run.log.all;
+        for (const entry of entries.slice(read)) {
+          stopped.for ??= autoloadNotCompiled(entry, autoloaded);
+        }
+        read = entries.length;
+        if (stopped.for !== null) {
+          clearInterval(watching);
+          run.process.kill();
+        }
+      }, 100);
       const timer = setTimeout(() => {
+        clearInterval(watching);
         silentForMs = Date.now() - lastSaid;
         run.process.kill();
         resolve(true);
       }, timeoutMs);
-      run.process.once("exit", () => {
-        clearTimeout(timer);
-        resolve(false);
-      });
-      run.process.once("error", () => {
+      const ended = () => {
+        clearInterval(watching);
         clearTimeout(timer);
         resolve(false);
-      });
+      };
+      run.process.once("exit", ended);
+      run.process.once("error", ended);
     });
     clearInterval(reporting);
-    if (timedOut && run.process.pid !== undefined) {
+    if ((timedOut || stopped.for !== null) && run.process.pid !== undefined) {
       await untilGone([run.process.pid]);
     }
     await run.settled;
-    const reportsDir = join31(project.value.path, ".godot", ...ours.split("/"));
+    const notCompiled = stopped.for ?? run.log.all.map((entry) => autoloadNotCompiled(entry, autoloaded)).find((found) => found !== null) ?? null;
+    const reportsDir = join32(project.value.path, ".godot", ...ours.split("/"));
     let report = null;
     let reportProblem = null;
     try {
-      const written = existsSync24(reportsDir) ? readdirSync14(reportsDir).filter((name) => name.startsWith("report_")).sort((a, b) => Number(a.slice("report_".length)) - Number(b.slice("report_".length))) : [];
+      const written = existsSync25(reportsDir) && notCompiled === null ? readdirSync14(reportsDir).filter((name) => name.startsWith("report_")).sort((a, b) => Number(a.slice("report_".length)) - Number(b.slice("report_".length))) : [];
       const newest = written.at(-1);
       if (newest !== undefined) {
-        report = parseJUnit(readFileSync26(join31(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync27(join32(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
@@ -47937,14 +48151,14 @@ class GodotServer {
       limit: Number.POSITIVE_INFINITY
     }).entries;
     const said = printed.map((entry) => entry.text);
-    const nothingRan = timedOut ? null : whyNoReport(said, asked.join(" and "));
-    const cutShort = timedOut ? timedOutVerdict(timeoutMs, silentForMs) : null;
+    const nothingRan = timedOut || notCompiled !== null ? null : whyNoReport(said, asked.join(" and "));
+    const cutShort = timedOut && notCompiled === null ? timedOutVerdict(timeoutMs, silentForMs, repeatingScriptError(run.log.all, (entry) => run.log.raisedByScript(entry))) : null;
     const hung = cutShort?.hung ?? false;
-    const printedErrors = timedOut || exitCode !== 105 ? [] : scriptErrorsPrinted(said);
+    const printedErrors = notCompiled !== null ? compileErrorsIn(run.log.all) : timedOut || exitCode !== 105 ? [] : scriptErrorsPrinted(said);
     const declaring = printedErrors.some((error) => unresolvedClassIn(error.message) !== null) ? await originsOf(printedErrors, declaredClasses(project.value.path), checkWithEngine(engine.value, project.value.path)) : { origins: [], unconfirmed: [] };
     const scriptErrors = [...declaring.origins, ...printedErrors];
     const brokenScripts = new Set(scriptErrors.map((error) => error.path)).size;
-    const ranAs = cutShort !== null ? cutShort.verdict : nothingRan ?? (brokenScripts > 0 ? `script errors in ${brokenScripts === 1 ? "one script" : `${brokenScripts} scripts`}, so no suite ran` : undefined) ?? (uncaught.length > 0 ? `${uncaught.length === 1 ? "one script error" : `${uncaught.length} script errors`} that failed no case` : undefined) ?? (exitCode === null ? undefined : verdicts[exitCode]) ?? howItExited(run);
+    const ranAs = notCompiled !== null ? `the autoload ${notCompiled.name} (${notCompiled.path}) did not compile, so no result counts` : cutShort !== null ? cutShort.verdict : nothingRan ?? (brokenScripts > 0 ? `script errors in ${brokenScripts === 1 ? "one script" : `${brokenScripts} scripts`}, so no suite ran` : undefined) ?? (uncaught.length > 0 ? `${uncaught.length === 1 ? "one script error" : `${uncaught.length} script errors`} that failed no case` : undefined) ?? (exitCode === null ? undefined : verdicts[exitCode]) ?? howItExited(run);
     const nothingAt = missing.join(" and ");
     const verdict = missing.length === 0 ? ranAs : `${ranAs}; nothing at ${nothingAt}`;
     const missingNote = missing.length === 0 ? undefined : `Nothing at ${nothingAt}, so ${missing.length === 1 ? "it was" : "they were"} left out and only ${asked.join(", ")} ran; a run of fewer paths than were asked for is not called a pass.${elsewhereIn(project.value.path, missing[0] ?? "")}`;
@@ -47972,7 +48186,7 @@ class GodotServer {
         }),
         ...running === null ? {} : { suiteRunning: running }
       };
-      const said = nothingRan !== null ? `No tests ran: ${ranAs}.` : scriptErrors.length > 0 ? scriptErrorsNote(printedErrors, declaring) : reportProblem !== null ? `The test run's report could not be read (${reportProblem}); the engine's own verdict was ${ranAs}.` : `The test run wrote no report (${ranAs}).${finishedBeforeTheEnd(finished.length, failing.length, running)}`;
+      const said = notCompiled !== null ? autoloadNotCompiledNote(notCompiled, foldedScriptErrors(scriptErrors), stopped.for !== null) : nothingRan !== null ? `No tests ran: ${ranAs}.` : scriptErrors.length > 0 ? scriptErrorsNote(printedErrors, declaring) : reportProblem !== null ? `The test run's report could not be read (${reportProblem}); the engine's own verdict was ${ranAs}.` : `The test run wrote no report (${ranAs}).${finishedBeforeTheEnd(finished.length, failing.length, running)}`;
       const note = missingNote === undefined ? said : `${said} ${missingNote}`;
       if (callSignal()?.aborted === true) {
         keepCutTestRun(project.value.path, { cutAt: new Date().toISOString(), paths: asked, ...atTheEnd });
@@ -48271,11 +48485,11 @@ class GodotServer {
     const cached = cachedClasses(projectPath);
     const sourceOf = (resourcePath) => {
       const contained = resolveWithinProject(projectPath, resourcePath);
-      if (!contained.ok || !existsSync24(contained.absolutePath)) {
+      if (!contained.ok || !existsSync25(contained.absolutePath)) {
         return null;
       }
       try {
-        return readFileSync26(contained.absolutePath, "utf8");
+        return readFileSync27(contained.absolutePath, "utf8");
       } catch {
         return null;
       }
@@ -48365,11 +48579,11 @@ class GodotServer {
   }
   sourceOfClass(projectPath, resourcePath) {
     const contained = resolveWithinProject(projectPath, resourcePath);
-    if (!contained.ok || !existsSync24(contained.absolutePath)) {
+    if (!contained.ok || !existsSync25(contained.absolutePath)) {
       return null;
     }
     try {
-      return readFileSync26(contained.absolutePath, "utf8");
+      return readFileSync27(contained.absolutePath, "utf8");
     } catch {
       return null;
     }
@@ -48527,7 +48741,7 @@ class GodotServer {
       ...Array.isArray(stack) ? {
         stack: stack.map((frame) => ({
           ...frame,
-          ...projectPath !== "" && typeof frame["script"] === "string" && frame["script"].startsWith("res://") ? { path: join31(projectPath, frame["script"].slice("res://".length)) } : {}
+          ...projectPath !== "" && typeof frame["script"] === "string" && frame["script"].startsWith("res://") ? { path: join32(projectPath, frame["script"].slice("res://".length)) } : {}
         }))
       } : {}
     });
@@ -48806,7 +49020,7 @@ class GodotServer {
       return null;
     }
     try {
-      return settingKeys(readFileSync26(join31(projectPath, "project.godot"), "utf8"));
+      return settingKeys(readFileSync27(join32(projectPath, "project.godot"), "utf8"));
     } catch {
       return null;
     }
@@ -49243,7 +49457,7 @@ class GodotServer {
   }
   async runtimeUp(projectPath, before, budget, withArgs) {
     const budgetMs = budget.ms;
-    if (!existsSync24(join31(projectPath, RUNTIME_AUTOLOAD.path))) {
+    if (!existsSync25(join32(projectPath, RUNTIME_AUTOLOAD.path))) {
       return runtimeVerdict(null, {
         addon: false,
         budgetMs,
@@ -49523,7 +49737,7 @@ class GodotServer {
       return 0;
     }
     try {
-      return reportAlreadyInTranscript(readFileSync26(game.transcript), readFileSync26(report));
+      return reportAlreadyInTranscript(readFileSync27(game.transcript), readFileSync27(report));
     } catch (error) {
       this.logDebug(`Could not compare a picked-up run's report with its transcript: ${errorMessage(error)}`);
       return 0;
@@ -50225,7 +50439,7 @@ class GodotServer {
     };
     const going = await this.runStillGoing(run);
     const projectPath = run.projectPath;
-    const projectGone = projectPath !== null && !existsSync24(join31(projectPath, "project.godot"));
+    const projectGone = projectPath !== null && !existsSync25(join32(projectPath, "project.godot"));
     if (projectGone && callersName !== undefined) {
       return this.createErrorResponse(`callersOf reads the project's scripts, and the run's project at ${projectPath} has no project.godot any more.`, ["editor_run profile without callersOf answers with the profile itself"]);
     }
@@ -50572,7 +50786,7 @@ class GodotServer {
       notes.push(endedWithoutACode({
         throughEditor: run.throughEditor,
         announced: announced !== undefined || run.announcedPid !== undefined,
-        couldAnnounce: run.projectPath !== null && existsSync24(join31(run.projectPath, RUNTIME_AUTOLOAD.path)),
+        couldAnnounce: run.projectPath !== null && existsSync25(join32(run.projectPath, RUNTIME_AUTOLOAD.path)),
         endedHere: typeof run.endedHere === "string",
         pickedUp: run.pickedUp === true
       }));
@@ -51202,7 +51416,7 @@ class GodotServer {
     if (!scriptPath.ok) {
       return this.createErrorResponse(scriptPath.reason);
     }
-    if (!existsSync24(scriptPath.absolutePath)) {
+    if (!existsSync25(scriptPath.absolutePath)) {
       return this.createErrorResponse(`Script file does not exist: ${scriptPath.absolutePath}`);
     }
     const asked = readNonEmptyString(args, "newScriptPath");
@@ -51616,7 +51830,7 @@ class GodotServer {
     }
     const escaped = symbol.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const declared = new RegExp(`^\\s*(?:@\\w+(?:\\([^)]*\\))?\\s+)*class_name\\s+${escaped}\\b`, "m");
-    if (declared.test(readFileSync26(scriptPath, "utf8"))) {
+    if (declared.test(readFileSync27(scriptPath, "utf8"))) {
       return null;
     }
     const checked = await this.classesTheEditorCannotSee(args);
@@ -51784,7 +51998,7 @@ class GodotServer {
   async ownRunOnItsWay(projectPath, budgetMs) {
     const run = await this.currentRun();
     const project = projectPath ?? run?.projectPath ?? null;
-    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync24(join31(project, RUNTIME_AUTOLOAD.path)) || !await this.runStillGoing(run)) {
+    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync25(join32(project, RUNTIME_AUTOLOAD.path)) || !await this.runStillGoing(run)) {
       return null;
     }
     const already = runtimesAnnounced().running;
@@ -51874,7 +52088,7 @@ class GodotServer {
       }
     }
     const screenshotDir = expectsScreenshot ? scratchDirectory("runtime-screenshot") : null;
-    const screenshotPath = screenshotDir ? join31(screenshotDir, "capture.png") : null;
+    const screenshotPath = screenshotDir ? join32(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}
@@ -51893,8 +52107,10 @@ ${staleNote}`);
     }
     this.callsOnGames.add(onGame);
     const alongside = () => onGame.alongside.size === 0 ? {} : { ranAlongside: [...onGame.alongside], alongsideNote: ALONGSIDE_NOTE };
+    let savedLater = false;
     try {
-      const reply = await runtimeRequest(choice.endpoint, command, screenshotPath ? { ...params, output_path: screenshotPath } : params, timeoutMs, !expectsScreenshot);
+      const reply = await runtimeRequest(choice.endpoint, command, screenshotPath ? { ...params, output_path: screenshotPath } : params, timeoutMs, expectsScreenshot ? () => discard(screenshotDir) : "keep");
+      savedLater = !reply.ok && reply.stillWithTheGame === true;
       if (!reply.ok && reply.requestId !== undefined) {
         return this.jsonTextResponse({
           pending: true,
@@ -51940,12 +52156,14 @@ Ran alongside ${ranWith.join(", ")}. ${ALONGSIDE_NOTE}`}${staleNote === undefine
 
 ${staleNote}`}`
           },
-          { type: "image", data: readFileSync26(screenshotPath).toString("base64"), mimeType: "image/png" }
+          { type: "image", data: readFileSync27(screenshotPath).toString("base64"), mimeType: "image/png" }
         ]
       };
     } finally {
       this.callsOnGames.delete(onGame);
-      discard(screenshotDir);
+      if (!savedLater) {
+        discard(screenshotDir);
+      }
     }
   }
   handleLateAnswer(args) {
@@ -52055,12 +52273,13 @@ async function runGodotServer() {
   const server = new GodotServer;
   await server.run();
 }
-var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, FAILED_BUDGET = 1e6, ANSWER_BUDGET = 4000000, __dirname2, PARENT_ASKED_AFTER_MS = 5000, EDITOR_SERVERS_START_MS = 20000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, ALONGSIDE_NOTE = "Another call on this game was running while this one was: calls sent together run together and are answered as each finishes, so this answer is not from after the other. Send a call meant to come after another once that one has answered.", OWN_DEBUGGER = " Its debugger is the keeper holding it rather than the editor, so the debug_* tools answer for it all the same: breakpoints stop it, and debug_control pause breaks into it wherever it is, which the editor offers no way to do.", PLAY_STARTS_WITHIN_MS = 30000, KEEPER_ANSWER_MS = 15000, KEEPER_DEBUG_MS, EXIT_REPORTED_WITHIN_MS = 2000, CLOSE_ASK_MS = 3000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, PROFILE_SEND_MS = 5000, MOST_GROUPS = 20, RUNTIME_LISTENING_LINE = "[gdharness] runtime listening on ", VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, CONSOLE_WATCH_MS = 250, BOUNDARY_WAIT_MS = 2000, HANDOVER_MS, HANDOVER_POLL_MS = 250, CACHE_WRITE_MS = 2000, STREAMS_GRACE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, SCAN_SETTLED_MS = 500, REIMPORT_TIMEOUT_MS = 300000, OPS_ELSEWHERE, AUDIO_BUS_OPS, STALLED_AFTER_MS = 30000, TEST_HEARTBEAT_MS = 20000, DEPENDED_FAILED = "Failed to compile depended scripts", WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, OUTPUT_PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/", PROFILE_FUNCTIONS = 30, PROFILER_ON_MS = 3000, PROPERTY_PLACES = "It is a property, so each place says whether it writes it (access write), which runs its set block, or reads it (access read), which runs its get block: withinCalls on a read says nothing of the set block, nor on a write of the get block unless the write is a compound one such as +=. Inside the property's own blocks its name is the value stored, which the engine reads and writes without running them, so those lines are not listed.", CALLERS_FOUND_BY_NAME = "Found by name in the project's scripts, since the engine's profiler counts calls and time per function and records nothing about who made them: a method of the same name on another class is listed too, unless one class was asked about and it is called through another class by name or through a variable declared as one. Each place carries the profile's numbers for the function it is written in.", MOST_ENGINE_ENTRIES = 200, ERROR_ASSERT = "GdUnitGodotErrorAssertImpl.gd", EXTERNAL_MEMBER = 'Could not resolve external class member "', STATIC_LIST_HINT;
+var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, FAILED_BUDGET = 1e6, ANSWER_BUDGET = 4000000, __dirname2, PARENT_ASKED_AFTER_MS = 5000, EDITOR_SERVERS_START_MS = 20000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, ALONGSIDE_NOTE = "Another call on this game was running while this one was: calls sent together run together and are answered as each finishes, so this answer is not from after the other. Send a call meant to come after another once that one has answered.", OWN_DEBUGGER = " Its debugger is the keeper holding it rather than the editor, so the debug_* tools answer for it all the same: breakpoints stop it, and debug_control pause breaks into it wherever it is, which the editor offers no way to do.", PLAY_STARTS_WITHIN_MS = 30000, KEEPER_ANSWER_MS = 15000, KEEPER_DEBUG_MS, EXIT_REPORTED_WITHIN_MS = 2000, CLOSE_ASK_MS = 3000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, PROFILE_SEND_MS = 5000, MOST_GROUPS = 20, RUNTIME_LISTENING_LINE = "[gdharness] runtime listening on ", VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, CONSOLE_WATCH_MS = 250, BOUNDARY_WAIT_MS = 2000, HANDOVER_MS, HANDOVER_POLL_MS = 250, CACHE_WRITE_MS = 2000, STREAMS_GRACE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, SCAN_SETTLED_MS = 500, REIMPORT_TIMEOUT_MS = 300000, OPS_ELSEWHERE, AUDIO_BUS_OPS, STALLED_AFTER_MS = 30000, TEST_HEARTBEAT_MS = 20000, DEPENDED_FAILED = "Failed to compile depended scripts", LOOPING_AFTER = 100, WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, OUTPUT_PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/", PROFILE_FUNCTIONS = 30, PROFILER_ON_MS = 3000, PROPERTY_PLACES = "It is a property, so each place says whether it writes it (access write), which runs its set block, or reads it (access read), which runs its get block: withinCalls on a read says nothing of the set block, nor on a write of the get block unless the write is a compound one such as +=. Inside the property's own blocks its name is the value stored, which the engine reads and writes without running them, so those lines are not listed.", CALLERS_FOUND_BY_NAME = "Found by name in the project's scripts, since the engine's profiler counts calls and time per function and records nothing about who made them: a method of the same name on another class is listed too, unless one class was asked about and it is called through another class by name or through a variable declared as one. Each place carries the profile's numbers for the function it is written in.", MOST_ENGINE_ENTRIES = 200, ERROR_ASSERT = "GdUnitGodotErrorAssertImpl.gd", EXTERNAL_MEMBER = 'Could not resolve external class member "', STATIC_LIST_HINT;
 var init_server = __esm(() => {
   init_dist();
   init_stdio();
   init_alive();
   init_answer_json();
+  init_autoload_failure();
   init_boot_note();
   init_breakpoint_note();
   init_bridge_announce();
@@ -52174,8 +52393,8 @@ var init_server = __esm(() => {
 init_bridge_announce();
 init_errors();
 init_godot_path();
-import { existsSync as existsSync25 } from "node:fs";
-import { join as join32, resolve as resolve8 } from "node:path";
+import { existsSync as existsSync26 } from "node:fs";
+import { join as join33, resolve as resolve8 } from "node:path";
 
 // src/harnesses.ts
 import { existsSync as existsSync4, mkdirSync as mkdirSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, rmSync as rmSync2, statSync as statSync3, writeFileSync as writeFileSync2 } from "node:fs";
@@ -53459,7 +53678,7 @@ class UsageError extends Refusal {
 function projectArgument(at) {
   const named = args.slice(at).find((value) => !value.startsWith("--"));
   const projectPath = resolve8(named ?? ".");
-  if (!existsSync25(join32(projectPath, "project.godot"))) {
+  if (!existsSync26(join33(projectPath, "project.godot"))) {
     throw new UsageError(`Not a Godot project: ${projectPath} holds no project.godot.`);
   }
   return projectPath;
@@ -53504,7 +53723,7 @@ async function registerRuntime(godot, projectPath) {
     return;
   }
   console.log(`${RUNTIME_AUTOLOAD.name} autoload left at ${named}, which this project registers itself`);
-  if (!existsSync25(join32(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
+  if (!existsSync26(join33(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
     console.log(`  that file is not in this project, so it boots with a missing script: restore it, or point the entry at res://${RUNTIME_AUTOLOAD.path}`);
   }
 }
@@ -53636,7 +53855,7 @@ async function setup() {
       console.log("no harness configured; name one yourself, and gdharness harnesses lists them all");
     }
     if (!args.includes("--no-skill")) {
-      const directories = skillDirectories(chosen.harnesses, projectPath, existsSync25);
+      const directories = skillDirectories(chosen.harnesses, projectPath, existsSync26);
       for (const written of writeSkill(directories, getLocalVersion())) {
         console.log(`skill: ${written.replaced ? "replaced" : "written"} ${written.path}`);
       }
@@ -53750,7 +53969,7 @@ async function upgrade() {
       moved.push(took.from);
     }
   }
-  for (const written of writeSkill(skillDirectories(already, projectPath, existsSync25), version)) {
+  for (const written of writeSkill(skillDirectories(already, projectPath, existsSync26), version)) {
     console.log(`skill: ${written.replaced ? "replaced" : "written"} ${written.path}`);
   }
   console.log(`