gdharness 1.1.59 → 1.1.61

package/build/cli.js

@@ -9183,11 +9183,175 @@ function enclosingFunction(source, line, code = codeOf(source)) {
   }
   return null;
 }
-function callSitesOf(source, name) {
+function afterHeader(text, from) {
+  let depth = 0;
+  for (let at = text.indexOf("(", from);at !== -1 && at < text.length; at += 1) {
+    if (text[at] === "(") {
+      depth += 1;
+    } else if (text[at] === ")") {
+      depth -= 1;
+      if (depth === 0) {
+        const colon = text.indexOf(":", at);
+        return colon === -1 ? -1 : colon + 1;
+      }
+    }
+  }
+  return -1;
+}
+function bodyCallsSuper(code, line, lambda) {
+  const lines = code.split(`
+`);
+  const first = lines[line - 1];
+  if (first === undefined) {
+    return false;
+  }
+  const header = lambda ? LAMBDA_HEADER.exec(first) : FUNC_LINE.exec(first);
+  if (header !== null) {
+    const body = afterHeader(first, header.index);
+    if (body !== -1 && first.slice(body).trim() !== "") {
+      return SUPER_CALL.test(first.slice(body));
+    }
+  }
+  const indent = indentOf(first);
+  let lambdaIndent = null;
+  for (let index = line - 1;index < lines.length; index += 1) {
+    const text = lines[index] ?? "";
+    if (text.trim() === "") {
+      continue;
+    }
+    const at = indentOf(text);
+    if (at < indent) {
+      break;
+    }
+    if (lambdaIndent !== null) {
+      if (at > lambdaIndent) {
+        continue;
+      }
+      lambdaIndent = null;
+    }
+    const inner = LAMBDA_HEADER.exec(text);
+    if (SUPER_CALL.test(inner === null ? text : text.slice(0, inner.index))) {
+      return true;
+    }
+    if (inner !== null) {
+      const body = afterHeader(text, inner.index);
+      if (body !== -1 && text.slice(body).trim() === "") {
+        lambdaIndent = at;
+      }
+    }
+  }
+  return false;
+}
+function parametersOf(text, from) {
+  const open = text.indexOf("(", from);
+  if (open === -1) {
+    return [];
+  }
+  const names = [];
+  let depth = 0;
+  let start = open + 1;
+  for (let at = open;at < text.length; at += 1) {
+    const here = text[at];
+    if (here === "(" || here === "[" || here === "{") {
+      depth += 1;
+    } else if (here === ")" || here === "]" || here === "}") {
+      depth -= 1;
+    }
+    if (here === "," && depth === 1 || depth === 0) {
+      const named = new RegExp(`^\\s*(${NAME})`, "u").exec(text.slice(start, at));
+      if (named?.[1] !== undefined) {
+        names.push(named[1]);
+      }
+      start = at + 1;
+      if (depth === 0) {
+        break;
+      }
+    }
+  }
+  return names;
+}
+function isLocalAt(lines, index, name) {
+  const word = escapedForPattern(name);
+  const declares = new RegExp(`(?<![\\p{L}\\p{N}_.])(?:var|const)\\s+${word}(?![\\p{L}\\p{N}_])`, "u");
+  const iterates = new RegExp(`^\\s*for\\s+${word}(?![\\p{L}\\p{N}_])`, "u");
+  const own = lines[index] ?? "";
+  const headerOnOwnLine = FUNC_LINE.exec(own) ?? LAMBDA_HEADER.exec(own);
+  if (headerOnOwnLine !== null && parametersOf(own, headerOnOwnLine.index).includes(name)) {
+    return true;
+  }
+  if (FUNC_LINE.test(own)) {
+    return false;
+  }
+  let depth = indentOf(own);
+  for (let at = index - 1;at >= 0; at -= 1) {
+    const text = lines[at] ?? "";
+    if (text.trim() === "") {
+      continue;
+    }
+    const indent = indentOf(text);
+    if (indent > depth) {
+      continue;
+    }
+    const named = FUNC_LINE.exec(text);
+    if (indent < depth) {
+      depth = indent;
+      if (named !== null) {
+        return parametersOf(text, named.index).includes(name);
+      }
+      const lambda = LAMBDA_HEADER.exec(text);
+      if (lambda !== null && parametersOf(text, lambda.index).includes(name) || iterates.test(text)) {
+        return true;
+      }
+    }
+    if (named !== null || depth === 0) {
+      return false;
+    }
+    if (declares.test(text)) {
+      return true;
+    }
+  }
+  return false;
+}
+function receiverBefore(code, offset) {
+  let at = offset - 1;
+  while (at >= 0 && /\s/.test(code[at] ?? "")) {
+    at -= 1;
+  }
+  if (code[at] !== ".") {
+    return null;
+  }
+  at -= 1;
+  while (at >= 0 && /\s/.test(code[at] ?? "")) {
+    at -= 1;
+  }
+  let start = at + 1;
+  while (start > 0 && isIdentifierPart(code[start - 1])) {
+    start -= 1;
+  }
+  return start <= at ? code.slice(start, at + 1) : null;
+}
+function bodyHolding(body, offset) {
+  const inner = body.inner.find((one) => one.start <= offset && offset <= one.end);
+  return inner === undefined ? body : bodyHolding(inner, offset);
+}
+function callSitesOf(source, name, otherClasses = new Set) {
   const regions = regionsOf(source);
   const code = codeOf(source, regions);
+  const codeLines = code.split(`
+`);
   const lines = new Lines(source);
-  return occurrencesOf(source, name, regions).filter((one) => one.kind === "code" && one.declaredAs === null).map((one) => {
+  const shape = shapeOf(source);
+  return occurrencesOf(source, name, regions).filter((one) => one.kind === "code" && one.declaredAs === null).filter((one) => {
+    if (one.afterDot) {
+      const receiver = receiverBefore(code, one.offset);
+      return receiver === null || !otherClasses.has(receiver);
+    }
+    const index = lines.positionOf(one.offset).line;
+    if (isLocalAt(codeLines, index, name)) {
+      return false;
+    }
+    return !bodyHolding(shape.body, one.offset).declarations.some((declared) => declared.name === name && MEMBER_KINDS.has(declared.kind));
+  }).map((one) => {
     const line = lines.positionOf(one.offset).line + 1;
     const after = code.slice(one.offset + name.length).trimStart();
     return { line, within: enclosingFunction(source, line, code), called: after.startsWith("(") };
@@ -9208,7 +9372,7 @@ function collectEnumValues(text, from, into) {
 function isIdentifier(name) {
   return new RegExp(`^${NAME}$`, "u").test(name) && !KEYWORDS.has(name);
 }
-var IDENTIFIER_START, IDENTIFIER_PART, DECLARING, NAME = "[\\p{L}_][\\p{L}\\p{N}_]*", ANNOTATIONS = "(?:@[\\p{L}_][\\p{L}\\p{N}_]*(?:\\([^)]*\\))?\\s+)*", DECLARATION_LINE, CLASS_NAME_LINE, EXTENDS_LINE, EXTENDS_CLAUSE, FUNC_LINE, KEYWORDS;
+var IDENTIFIER_START, IDENTIFIER_PART, DECLARING, NAME = "[\\p{L}_][\\p{L}\\p{N}_]*", ANNOTATIONS = "(?:@[\\p{L}_][\\p{L}\\p{N}_]*(?:\\([^)]*\\))?\\s+)*", DECLARATION_LINE, CLASS_NAME_LINE, EXTENDS_LINE, EXTENDS_CLAUSE, FUNC_LINE, SUPER_CALL, LAMBDA_HEADER, MEMBER_KINDS, KEYWORDS;
 var init_gdscript_source = __esm(() => {
   IDENTIFIER_START = /[\p{L}_]/u;
   IDENTIFIER_PART = /[\p{L}\p{N}_]/u;
@@ -9218,6 +9382,9 @@ var init_gdscript_source = __esm(() => {
   EXTENDS_LINE = new RegExp(`^${ANNOTATIONS}(?:class_name\\s+${NAME}\\s+)?extends\\s`, "u");
   EXTENDS_CLAUSE = /\bextends(?=\s)/u;
   FUNC_LINE = new RegExp(`^[ \\t]*${ANNOTATIONS}(?:static\\s+)?func\\s+(${NAME})\\s*\\(`, "u");
+  SUPER_CALL = /(?<![\p{L}\p{N}_.])super\s*[.(]/u;
+  LAMBDA_HEADER = new RegExp(`(?<![\\p{L}\\p{N}_])func(?:\\s+${NAME})?\\s*\\(`, "u");
+  MEMBER_KINDS = new Set(["var", "const", "signal", "enum", "enumValue"]);
   KEYWORDS = new Set([
     "and",
     "as",
@@ -18182,7 +18349,7 @@ var init_tool_definitions = __esm(() => {
         callersOf: {
           type: "string",
           ops: ["profile"],
-          description: "profile: also answer, under callers, where the project's scripts name this function in code: its name, or Class.name for the functions of one class. Each place has its script, line, the named function it is written in (within), whether the function is called there or passed on as a Callable (called), and the profile's calls, self and total milliseconds for the function it is in, those taking the most time first, forty at most. Found by name in the source, since the engine's profiler records nothing about who made a call, so a method of the same name on another class is listed too and a call made through a string is not."
+          description: "profile: also answer, under callers, where the project's scripts name this function in code: its name, or Class.name for the functions of one class. Each place has its script, line, the named function it is written in (within), whether the function is called there or passed on as a Callable (called), and the profile's calls, self and total milliseconds for the function it is in, those taking the most time first, forty at most. Found by name in the source, since the engine's profiler records nothing about who made a call, so a method of the same name on another class is listed too, except one called through another class of the project by name when Class.name was asked, and a call made through a string is not. A parameter, local or class variable of the same name is not the function and is not listed."
         },
         limit: {
           type: "integer",
@@ -18218,7 +18385,7 @@ var init_tool_definitions = __esm(() => {
         },
         wait: { summary: "wait for the run to end, then answer as editor_output does", requires: [] },
         profile: {
-          summary: "where the run spends its time by GDScript function, while it runs or after it ended: 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, sorted by self time, 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 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. A run started with profile: true is profiled from its start. A game the editor plays that was not is profiled from the moment this is asked, and the answer says so; a run this server started without it is refused, since its debugger is fixed as it starts",
+          summary: "where the run spends its time by GDScript function, while it runs or after it ended: 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, sorted by self time, 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. 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. A run started with profile: true is profiled from its start. A game the editor plays that was not is profiled from the moment this is asked, and the answer says so; a run this server started without it is refused, since its debugger is fixed as it starts",
           requires: []
         }
       },
@@ -18274,7 +18441,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "editor_status",
-      description: "Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and whether a game with the runtime addon is reachable: runtimeConnected counts the games of the project this server serves, and runtimes lists every game on the machine with ofThisProject saying which is which, since a game of another project is reached only by naming its projectPath. playingInEditor is null when the editor was not asked or did not answer, which is not the same as a no: with no editor connected there is nobody to ask, and an editor that does not serve the question is given a moment and then left. A game can be playing while this is null, so read it as unanswered rather than as nothing playing, and use processActive and runtimes, which come from elsewhere and do not depend on the editor answering. game.run names the run processActive is about, the one editor_output and editor_run stop answer for: its pid, its project, and adopted true when this server read it back from another server rather than starting it; null when there is none. editor.scan says whether the editor is scanning or importing and how many milliseconds ago its last scan finished (finishedMsAgo), or is null when it did not answer: the editor rewrites the class cache just after a scan, and editor_run waits that out before starting a game, saying so under waitedForEditorScanMs. Each game under runtimes is pinged with a short wait, so one held at a breakpoint is listed as unreachable rather than making this call wait out the runtime timeout; for the run this server is reporting on, heldAt says whether that is what it is, with the same three answers editor_output gives. A game the editor played announces the editor under editorPid, and so does whatever that game started for itself; a game some other server started announces none, which is how the two are told apart when both are running from one project. Each game also says which runtime addon it loaded, under addonVersion (null when it cannot say); addonIsStale is true when that code is not what this server ships, and staleNote says whether the project needs gdharness upgrade, the game a restart, or this server a reconnect. A second checkout of a project, such as a git worktree, carries addons of its own and is where this shows. Every runtime_* answer from such a game carries addonIsStale and staleNote too. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means \"not reached yet\" as often as it means \"no editor\". True is worth waiting out; false is an editor that is not there. False beside restartInterrupted is one that an editor_launch restart on a previous server asked to quit, where the launch half never ran because that server was ended in between, usually by the reconnect the restart was taken for; editor_launch open finishes it. True beside restartUnderway is a restart still in progress, its server alive and within the wait for the old editor to go: the editor is coming, and opening another would put two on one project. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. Any editor of this project running and not yet connected, whoever opened it, makes it true as well and is named under editorsNotYetConnected with its pid and start time, so a restart a reconnect interrupted after its launch is not read as nothing being there. settingsDropped appears here once when the editor this server opened saved project.godot on its way in, which is the same reading editor_launch restart makes in its own answer. A game that has announced itself in a protocol this server does not speak is listed under unreadable rather than left out, with the protocol it speaks and whether the server or the addon is the older half. This happens during an upgrade that moves the runtime protocol, which most do not: installing replaces the addon on disk as soon as the pin moves, while a server that is already running stays on the version it started with, so the two speak different protocols until the server is reconnected. Those games are real and running, but no tool here can reach them until the halves match, so runtimes stays empty and runtimeConnected stays false. An upgrade that leaves the protocol alone opens no such window and this list stays empty through it. addonIsStale is decided by the code of the editor addons rather than their version, so an editor started before an upgrade that left that code alone reports the older addonVersion, is not stale, and addonNote says so: it needs no restart. port is the one the editor bridge is on; when that is not the one this server was configured with, portWanted names the configured one and portNote says why it moved and, when it was the server this one replaced, which pid kept it. A server replacing another of its project that holds the configured port waits for it to stand down and takes the port over, which takes a few seconds; bridgeHandover says so while it waits, and it moves only if that server has not let go within the wait. An editor that has connected and not yet greeted, which lasts a frame and longer while it imports, reports nothing about itself: greeting says so, addonIsStale is absent rather than guessed, and a restart asked then waits for the greeting to learn who opened it. startedByAnEditor is an editor another editor started, by Godot's own restart or the project manager, which has none of the arguments a server gave the one before it; startedByAnEditorNote says what that costs. An engine run that loads the editor addon to do one job and quit, such as a gate's godot --headless --import, an export or a script, is not taken as the editor: a process that greets without a server's mark has its command line read first, and while that is read identifying is true and connected false; one started with such an option is turned away, and turnedAway names the last one, its pid and the option. Every other call made while an editor is arriving, before its greeting or while it is looked up, waits up to ten seconds for it to settle rather than acting on connected as it reads in that window.",
+      description: "Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and whether a game with the runtime addon is reachable: runtimeConnected counts the games of the project this server serves, and runtimes lists every game on the machine with ofThisProject saying which is which, since a game of another project is reached only by naming its projectPath. playingInEditor is null when the editor was not asked or did not answer, which is not the same as a no: with no editor connected there is nobody to ask, and an editor that does not serve the question is given a moment and then left. A game can be playing while this is null, so read it as unanswered rather than as nothing playing, and use processActive and runtimes, which come from elsewhere and do not depend on the editor answering. game.run names the run processActive is about, the one editor_output and editor_run stop answer for: its pid, its project, and adopted true when this server read it back from another server rather than starting it; null when there is none. editor.lspListening and editor.dapListening say whether anything accepts connections on the ports the editor names, lspPort and dapPort: Godot binds each once, as the editor starts, and reports a failure only in the log panel of the editor itself, so a false comes with serversNote, and editor_launch restart binds it again. editor.scan says whether the editor is scanning or importing and how many milliseconds ago its last scan finished (finishedMsAgo), or is null when it did not answer: the editor rewrites the class cache just after a scan, and editor_run waits that out before starting a game, saying so under waitedForEditorScanMs. Each game under runtimes is pinged with a short wait, so one held at a breakpoint is listed as unreachable rather than making this call wait out the runtime timeout; for the run this server is reporting on, heldAt says whether that is what it is, with the same three answers editor_output gives. A game the editor played announces the editor under editorPid, and so does whatever that game started for itself; a game some other server started announces none, which is how the two are told apart when both are running from one project. Each game also says which runtime addon it loaded, under addonVersion (null when it cannot say); addonIsStale is true when that code is not what this server ships, and staleNote says whether the project needs gdharness upgrade, the game a restart, or this server a reconnect. A second checkout of a project, such as a git worktree, carries addons of its own and is where this shows. Every runtime_* answer from such a game carries addonIsStale and staleNote too. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means \"not reached yet\" as often as it means \"no editor\". True is worth waiting out; false is an editor that is not there. False beside restartInterrupted is one that an editor_launch restart on a previous server asked to quit, where the launch half never ran because that server was ended in between, usually by the reconnect the restart was taken for; editor_launch open finishes it. True beside restartUnderway is a restart still in progress, its server alive and within the wait for the old editor to go: the editor is coming, and opening another would put two on one project. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. Any editor of this project running and not yet connected, whoever opened it, makes it true as well and is named under editorsNotYetConnected with its pid and start time, so a restart a reconnect interrupted after its launch is not read as nothing being there. settingsDropped appears here once when the editor this server opened saved project.godot on its way in, which is the same reading editor_launch restart makes in its own answer. A game that has announced itself in a protocol this server does not speak is listed under unreadable rather than left out, with the protocol it speaks and whether the server or the addon is the older half. This happens during an upgrade that moves the runtime protocol, which most do not: installing replaces the addon on disk as soon as the pin moves, while a server that is already running stays on the version it started with, so the two speak different protocols until the server is reconnected. Those games are real and running, but no tool here can reach them until the halves match, so runtimes stays empty and runtimeConnected stays false. An upgrade that leaves the protocol alone opens no such window and this list stays empty through it. addonIsStale is decided by the code of the editor addons rather than their version, so an editor started before an upgrade that left that code alone reports the older addonVersion, is not stale, and addonNote says so: it needs no restart. port is the one the editor bridge is on; when that is not the one this server was configured with, portWanted names the configured one and portNote says why it moved and, when it was the server this one replaced, which pid kept it. A server replacing another of its project that holds the configured port waits for it to stand down and takes the port over, which takes a few seconds; bridgeHandover says so while it waits, and it moves only if that server has not let go within the wait. An editor that has connected and not yet greeted, which lasts a frame and longer while it imports, reports nothing about itself: greeting says so, addonIsStale is absent rather than guessed, and a restart asked then waits for the greeting to learn who opened it. startedByAnEditor is an editor another editor started, by Godot's own restart or the project manager, which has none of the arguments a server gave the one before it; startedByAnEditorNote says what that costs. An engine run that loads the editor addon to do one job and quit, such as a gate's godot --headless --import, an export or a script, is not taken as the editor: a process that greets without a server's mark has its command line read first, and while that is read identifying is true and connected false; one started with such an option is turned away, and turnedAway names the last one, its pid and the option. Every other call made while an editor is arriving, before its greeting or while it is looked up, waits up to ten seconds for it to settle rather than acting on connected as it reads in that window.",
       parameters: {},
       requires: []
     },
@@ -34131,7 +34298,7 @@ function runtimeRequest(endpoint, command, params, timeoutMs, keepListening = fa
         ok: false,
         reason: "busy",
         requestId: id,
-        message: `${still} Nothing was cancelled: a call that takes longer than the wait goes on and does everything it was asked, so read the state back rather than repeating it. runtime_invoke op result with requestId ${id} answers with its reply once it comes, and timeoutMs waits longer next time. A game held at a breakpoint instead is one debug_state stack answers about.`
+        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");
@@ -40250,6 +40417,42 @@ var init_outside = __esm(() => {
   KEEPER_SCRIPT = fileURLToPath4(new URL("./keeper.js", import.meta.url));
 });
 
+// src/port-probe.ts
+import { connect as connect3 } from "node:net";
+function acceptsConnections(port, withinMs = 2000) {
+  return new Promise((resolve) => {
+    const socket = connect3({ host: "127.0.0.1", port });
+    const settle = (answer) => {
+      socket.destroy();
+      resolve(answer);
+    };
+    socket.setTimeout(withinMs, () => {
+      settle(null);
+    });
+    socket.once("connect", () => {
+      settle(true);
+    });
+    socket.once("error", () => {
+      settle(false);
+    });
+  });
+}
+function notListeningNote(servers, greetedAgoMs) {
+  const down = [
+    ...servers.lsp.listening === false ? [{ name: "language server", port: servers.lsp.port }] : [],
+    ...servers.dap.listening === false ? [{ name: "debug adapter", port: servers.dap.port }] : []
+  ];
+  if (down.length === 0) {
+    return;
+  }
+  const named = down.map((one) => `its ${one.name} on port ${one.port}`).join(" and ");
+  const needs = down.map((one) => one.name === "debug adapter" ? "played runs and the debug tools need the debug adapter" : "diagnostics, symbols and renames need the language server").join(", and ");
+  const starting = greetedAgoMs !== null && greetedAgoMs < STARTING_MS ? ` The editor greeted ${Math.round(greetedAgoMs / 1000)}s ago, so ${down.length === 1 ? "it" : "they"} may still be starting: ask again in a few seconds.` : "";
+  return `The editor names ${named}, and nothing accepts connections there. Godot binds each once, as the editor starts, and reports a failure only in the editor's own log panel; ${needs}. editor_launch restart binds ${down.length === 1 ? "it" : "them"} again.${starting}`;
+}
+var STARTING_MS = 20000;
+var init_port_probe = () => {};
+
 // src/process-time.ts
 import { execFile as execFile3 } from "node:child_process";
 import { promisify as promisify3 } from "node:util";
@@ -42325,25 +42528,36 @@ function signatureParts(signature) {
   return { script: parts.slice(0, -2).join("::"), line: Number.isFinite(line) ? line : 0, function: name };
 }
 function profiledFunctions(totals, limit, sourceOf = () => null) {
-  const rows = rowsOf(totals);
+  const rows = rowsOf(totals, sourceOf);
   const scriptMs = ms(Object.values(totals.functions).reduce((sum, one) => sum + (one.calls > 0 ? one.selfSeconds : 0), 0));
   return {
     functions: rows.slice(0, limit).map((row) => placedLambda(row, sourceOf)),
     omitted: Math.max(0, rows.length - limit),
     scriptMs,
-    counted: rows.length
+    counted: rows.length,
+    superCallers: rows.filter((row) => row.selfIncludesSuper === true).length
   };
 }
-function rowsOf(totals) {
+function rowsOf(totals, sourceOf) {
+  const codes = new Map;
+  const codeOfScript = (script) => {
+    if (!codes.has(script)) {
+      const source = sourceOf(script);
+      codes.set(script, source === null ? null : codeOf(source));
+    }
+    return codes.get(script) ?? null;
+  };
   return Object.entries(totals.functions).filter(([, sum]) => sum.calls > 0).map(([signature, sum]) => {
     const parts = signatureParts(signature);
+    const code = codeOfScript(parts.script);
     return {
       script: parts.script,
       function: parts.function,
       line: parts.line,
       calls: sum.calls,
       selfMs: ms(sum.selfSeconds),
-      totalMs: ms(sum.totalSeconds)
+      totalMs: ms(sum.totalSeconds),
+      ...code !== null && bodyCallsSuper(code, parts.line, parts.function.endsWith("(lambda)")) ? { selfIncludesSuper: true } : {}
     };
   }).sort((a, b) => b.selfMs - a.selfMs || b.totalMs - a.totalMs || a.function.localeCompare(b.function));
 }
@@ -42358,18 +42572,41 @@ function placedLambda(row, sourceOf) {
   const within = source === null ? null : enclosingFunction(source, row.line);
   return within === null ? row : { ...row, within };
 }
+function classNamesOf(source) {
+  const shape = shapeOf(source);
+  const inner = (body) => body.inner.flatMap((one) => [...one.name === null ? [] : [one.name], ...inner(one)]);
+  return [...shape.className === null ? [] : [shape.className.name], ...inner(shape.body)];
+}
 function callersOf(totals, name, scripts) {
-  const rows = rowsOf(totals);
+  const listed = [...scripts];
+  const sources = new Map(listed);
+  const rows = rowsOf(totals, (script) => sources.get(script) ?? null);
   const bare = bareName(name);
   const target = rows.filter((row) => name.includes(".") ? row.function === name : bareName(row.function) === bare);
+  const asked = name.includes(".") ? name.slice(0, name.lastIndexOf(".")) : null;
+  const otherClasses = new Set;
+  if (asked !== null) {
+    for (const [, source] of listed) {
+      for (const declared of classNamesOf(source)) {
+        if (declared !== asked) {
+          otherClasses.add(declared);
+        }
+      }
+    }
+  }
   const sites = [];
-  for (const [script, source] of scripts) {
-    for (const site of callSitesOf(source, bare)) {
+  for (const [script, source] of listed) {
+    for (const site of callSitesOf(source, bare, otherClasses)) {
       const within = site.within === null ? undefined : rows.find((row) => row.script === script && bareName(row.function) === site.within);
       sites.push({
         script,
         ...site,
-        ...within === undefined ? {} : { withinCalls: within.calls, withinSelfMs: within.selfMs, withinTotalMs: within.totalMs }
+        ...within === undefined ? {} : {
+          withinCalls: within.calls,
+          withinSelfMs: within.selfMs,
+          withinTotalMs: within.totalMs,
+          ...within.selfIncludesSuper === true ? { withinSelfIncludesSuper: true } : {}
+        }
       });
     }
   }
@@ -42406,8 +42643,14 @@ import { setTimeout as delay4 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 import { promisify as promisify5 } from "node:util";
 function editorRestartTimeoutMs() {
-  const override = Number.parseInt(envValue("GDHARNESS_EDITOR_RESTART_TIMEOUT_MS") ?? "", 10);
-  return Number.isInteger(override) && override > 0 ? override : 90000;
+  return waitFromEnv("GDHARNESS_EDITOR_RESTART_TIMEOUT_MS", 90000);
+}
+function waitFromEnv(variable, fallback) {
+  const override = Number.parseInt(envValue(variable) ?? "", 10);
+  return Number.isInteger(override) && override > 0 ? override : fallback;
+}
+function greetingWaitMs() {
+  return waitFromEnv("GDHARNESS_GREETING_WAIT_MS", 1e4);
 }
 function restartUnderway(note, now = Date.now()) {
   return alive(note.byPid) && now - Date.parse(note.quitAt) < editorRestartTimeoutMs() + 30000;
@@ -42458,6 +42701,14 @@ function captureDetail(payload) {
 function patienceForFrames(frames, atLeast) {
   return Math.max(atLeast, frames / SLOWEST_FRAME_RATE * 1000 + atLeast);
 }
+function longerWaitNote(tool, op, waitedMs) {
+  const spec = TOOL_SPECS.find((one) => one.name === tool);
+  if (spec !== undefined && argumentsOf(spec, op).includes("timeoutMs")) {
+    return "timeoutMs waits longer next time.";
+  }
+  const how = tool === "runtime_wait" && op === "frames" ? `the wait is counted from the number of frames, at ${SLOWEST_FRAME_RATE} a second on top of GDHARNESS_RUNTIME_TIMEOUT_MS: a game drawing frames more slowly than that is waited on in fewer frames at a time, and a game inside one long frame, such as a long _ready, answers no call however few frames are asked for` : "the wait is GDHARNESS_RUNTIME_TIMEOUT_MS, which is set in the environment the server is started with";
+  return `${tool} ${op} takes no timeoutMs: it was given ${waitedMs}ms, and ${how}.`;
+}
 function projectSpelling(projectPath, absolutePath) {
   return `res://${relative5(realPathOr(projectPath), realPathOr(absolutePath)).replaceAll("\\", "/")}`;
 }
@@ -42537,7 +42788,10 @@ function runIsUp(run, editorSays, editorPlay = null, now = Date.now()) {
 function noCodeWillCome(run) {
   return !exited(run);
 }
-async function untilGone(pids, withinMs = STOP_WAIT_MS) {
+function stopWaitMs() {
+  return waitFromEnv("GDHARNESS_STOP_WAIT_MS", 1e4);
+}
+async function untilGone(pids, withinMs = stopWaitMs()) {
   const gone = () => pids.every((pid) => !alive(pid));
   const deadline = Date.now() + withinMs;
   while (!gone() && Date.now() < deadline) {
@@ -42592,7 +42846,7 @@ function stopVerdict(stop) {
     return {
       stopped: false,
       stillGoing: stop.endedPid,
-      note: `${told} ${STOP_WAIT_MS / 1000} seconds later, so it has not stopped. editor_status says when it has gone, and editor_run stop asks again.`,
+      note: `${told} ${stopWaitMs() / 1000} seconds later, so it has not stopped. editor_status says when it has gone, and editor_run stop asks again.`,
       withChildren: true
     };
   }
@@ -42710,7 +42964,7 @@ function endedToStartThis(ended) {
     return ` ${which} was not ended here: the editor could not be asked to stop it. The editor stops a play before starting the next, so it is not running beside this one if this start reached the editor.`;
   }
   if (ended.ending === "lingering") {
-    return ` ${which} was told to end to start this one and was still running ${STOP_WAIT_MS / 1000} seconds later, so it is running beside this one: editor_status says when it has gone.`;
+    return ` ${which} was told to end to start this one and was still running ${stopWaitMs() / 1000} seconds later, so it is running beside this one: editor_status says when it has gone.`;
   }
   return ` ${which} was ended to start this one; its output is no longer what editor_output answers about.`;
 }
@@ -42827,6 +43081,9 @@ function outsideTheirRanges(spec, args) {
   }
   return complaints;
 }
+function scanWaitMs() {
+  return waitFromEnv("GDHARNESS_SCAN_WAIT_MS", 30000);
+}
 function scanWaitIn(payload) {
   const waited = readNumber(payload, "waitedForEditorScanMs");
   const note = readString(payload, "scanNote");
@@ -42885,7 +43142,7 @@ function scanWaitAnswer(scanned, started = "game") {
   if (scanned.waitedMs === 0) {
     return {};
   }
-  const still = `The editor was still scanning the project after ${SCAN_WAIT_MS / 1000} seconds, so`;
+  const still = `The editor was still scanning the project after ${scanWaitMs() / 1000} seconds, so`;
   return {
     waitedForEditorScanMs: scanned.waitedMs,
     scanNote: !scanned.stillScanning ? undefined : started === "game" ? `${still} this game started during the scan and may have read a class cache being rewritten. If ` + 'editor_output shows "Could not find type" for a class that is declared, editor_rescan ' + "waits for the scan to finish, and a start after it reads the finished cache." : `${still} the engine answering this started during the scan and may have read a class cache being ` + "rewritten, and a class cache it wrote can be written over when the scan finishes. If " + 'engine_messages shows "Could not find type" for a class that is declared, editor_rescan waits ' + "for the scan to finish, and the same call after it reads the finished cache."
@@ -43140,14 +43397,20 @@ function profileAnswer(reading, limit) {
   const table = profiledFunctions(totals, limit, reading.sourceOf);
   const notes = [];
   const addonNote = reading.runtimeAddon ? "" : " This project has no gdharness runtime addon, which switches the profiler off as the game quits so the engine sends its totals: setup installs it.";
-  if (totals.complete) {} else if (reading.running && totals.frames === 0) {
+  const totalsWithheld = reading.runtimeAddon ? " The runtime addon switches the profiler off as the game quits, and did not here: either it was no longer running in this game by then, which a project can arrange for some scenes; or the game ended without taking its tree down, as a crash or a kill does; or the totals did not reach the debugger before the game exited, which the game then says in its output." : addonNote;
+  if (totals.complete && reading.running) {
+    notes.push(`The engine's totals arrived while the game is still running, which it sends only when the profiler is switched off, so ${reading.through === "editor" ? "the editor's Profiler tab or the game itself, through EngineDebugger," : "the game itself, through EngineDebugger,"} switched it off before the game ended. They cover the run up to then and nothing after.`);
+  } else if (totals.complete) {} else if (reading.running && totals.frames === 0) {
     notes.push(`The profiler is on and the game has not finished its first frame yet: a frame is sent as it ends, so a scene doing its work in _ready shows nothing until that returns, and the engine's own totals arrive when the game quits.${addonNote}`);
   } else if (reading.running) {
     notes.push(`The run is still going, so these are the ${totals.frames === 1 ? "one frame" : `${totals.frames} frames`} summed so far${reading.through === "gdharness" ? ", written at most half a second behind" : ""}.`);
   } else if (totals.frames === 0) {
-    notes.push(`The game connected and ended before a frame of the profile reached ${reading.through === "editor" ? "the editor" : "this server"}: the engine sends its totals only when the profiler is switched off, and stops sending as it exits without emptying what it has queued.${addonNote}`);
+    notes.push(`The game connected and ended before a frame of the profile reached ${reading.through === "editor" ? "the editor" : "this server"}: the engine sends its totals only when the profiler is switched off, and stops sending as it exits without emptying what it has queued.${totalsWithheld}`);
   } else {
-    notes.push(`These are the ${totals.frames === 1 ? "one frame" : `${totals.frames} frames`} that arrived, summed, without the engine's own totals, so what the game did after the last of them is not in it: the engine sends its totals only when the profiler is switched off, and stops sending as it exits without emptying what it has queued.${addonNote}`);
+    notes.push(`These are the ${totals.frames === 1 ? "one frame" : `${totals.frames} frames`} that arrived, summed, without the engine's own totals, which it sends only when the profiler is switched off.${totalsWithheld} Not in them is any script time after the last frame sent: a frame still queued as the game exited, since the engine stops sending without emptying its queue, and what scripts did as it quit, such as in _exit_tree. That can be nothing: a scene that does its work in _ready and quits has all of it in its first frame.`);
+  }
+  if (table.superCallers > 0) {
+    notes.push(`${table.superCallers === 1 ? "One function calls" : `${table.superCallers} functions call`} through super, marked selfIncludesSuper: the engine takes every other call out of the caller's self time, and not a super call, so ${table.superCallers === 1 ? "its" : "their"} selfMs holds the overridden function's time, which that function's own row counts again. Self time therefore cannot be added along an override chain, and scriptMs counts the time under a super call once more for each level above it.`);
   }
   notes.push(...cappedNotes(totals));
   if (totals.unreadable > 0) {
@@ -43884,7 +44147,7 @@ class GodotServer {
   }
   async dispatch(tool, op, args) {
     if (tool !== "editor_status" && this.godotBridge.isArriving()) {
-      await this.waitForBridge(() => !this.godotBridge.isArriving(), Date.now() + GREETING_WAIT_MS);
+      await this.waitForBridge(() => !this.godotBridge.isArriving(), Date.now() + greetingWaitMs());
     }
     if (ENGINE_PASSES[tool]?.[op] !== undefined) {
       return op === "reimport" ? await this.handleReimport(args) : await this.handleRefreshUids(args);
@@ -44044,7 +44307,7 @@ class GodotServer {
               depth: depth ?? 3,
               include_properties: readBoolean(args, "includeProperties") ?? false,
               properties: readArray(args, "properties") ?? []
-            }, patience);
+            }, { tool: "runtime_inspect", op, patience });
           }
           case "find":
             return await this.handleFindRuntimeNodes(args, patience);
@@ -44054,17 +44317,17 @@ class GodotServer {
               root: readNonEmptyString(args, "nodePath") ?? "/root",
               include_hidden: readBoolean(args, "includeHidden") ?? false,
               limit: readPositiveNumber(args, "limit") ?? 500
-            }, patience);
+            }, { tool: "runtime_inspect", op, patience });
           case "rect":
-            return await this.handleRuntimeCommand("get_rect", { ...whichGame(args), path: readNonEmptyString(args, "nodePath") ?? "" }, patience);
+            return await this.handleRuntimeCommand("get_rect", { ...whichGame(args), path: readNonEmptyString(args, "nodePath") ?? "" }, { tool: "runtime_inspect", op, patience });
           case "property":
             return await this.handleRuntimeCommand("get_property", {
               ...whichGame(args),
               path: readNonEmptyString(args, "nodePath") ?? "",
               property: readNonEmptyString(args, "property") ?? ""
-            }, patience);
+            }, { tool: "runtime_inspect", op, patience });
           default:
-            return await this.handleRuntimeCommand("get_metrics", { ...whichGame(args), metrics: readArray(args, "metrics") ?? [] }, patience);
+            return await this.handleRuntimeCommand("get_metrics", { ...whichGame(args), metrics: readArray(args, "metrics") ?? [] }, { tool: "runtime_inspect", op, patience });
         }
       }
       case "runtime_invoke": {
@@ -44077,16 +44340,16 @@ class GodotServer {
           path: readNonEmptyString(args, "nodePath") ?? "",
           property: readString(args, "property") ?? "",
           value: args["value"]
-        }, patience) : await this.handleRuntimeCommand("call_method", {
+        }, { tool: "runtime_invoke", op, patience }) : await this.handleRuntimeCommand("call_method", {
           ...whichGame(args),
           path: readNonEmptyString(args, "nodePath") ?? "",
           method: readString(args, "method") ?? "",
           args: readArray(args, "args") ?? [],
           ...args["properties"] === undefined ? {} : { properties: args["properties"] }
-        }, patience);
+        }, { tool: "runtime_invoke", op, patience });
       }
       case "runtime_capture":
-        return await this.handleRuntimeCommand(op === "screenshot" ? "capture_screenshot" : "capture_viewport", args);
+        return await this.handleRuntimeCommand(op === "screenshot" ? "capture_screenshot" : "capture_viewport", args, { tool: "runtime_capture", op });
       case "runtime_input":
         if (op === "click") {
           if (readNonEmptyString(args, "nodePath") === undefined && readNonEmptyString(args, "says") === undefined) {
@@ -44099,7 +44362,7 @@ class GodotServer {
             double: readBoolean(args, "doubleClick") ?? false,
             ...readNonEmptyString(args, "says") === undefined ? {} : { says: readNonEmptyString(args, "says") },
             ...args["index"] === undefined ? {} : { index: args["index"] }
-          });
+          }, { tool: "runtime_input", op });
         }
         if (op === "choose") {
           return await this.handleRuntimeCommand("choose", {
@@ -44107,9 +44370,9 @@ class GodotServer {
             path: readNonEmptyString(args, "nodePath") ?? "",
             text: readString(args, "text") ?? "",
             ...args["index"] === undefined ? {} : { index: args["index"] }
-          });
+          }, { tool: "runtime_input", op });
         }
-        return await this.handleRuntimeCommand(`inject_${op}`, args);
+        return await this.handleRuntimeCommand(`inject_${op}`, args, { tool: "runtime_input", op });
       case "runtime_wait":
         return await this.handleRuntimeWait(op, args);
       case "debug_breakpoint": {
@@ -44338,7 +44601,7 @@ class GodotServer {
       const answered = Date.now();
       if (status["scanning"] === true || status["importing"] === true || status["pending"] === true) {
         sawAScan = true;
-        if (Date.now() - started >= SCAN_WAIT_MS) {
+        if (Date.now() - started >= scanWaitMs()) {
           return { waitedMs: Date.now() - started, stillScanning: true };
         }
         await new Promise((settle) => setTimeout(settle, 100));
@@ -45632,15 +45895,17 @@ class GodotServer {
         hold: current === null ? {} : await this.holdOf(current, active)
       };
     })();
-    const [games, { playing, active, run, hold }, scan, editorStatus] = await Promise.all([
+    const [games, { playing, active, run, hold }, scan, editorStatus, servers] = await Promise.all([
       pinged,
       asked,
       this.editorScanState(),
-      this.getEditorStatusPayload()
+      this.getEditorStatusPayload(),
+      this.editorServersListening()
     ]);
     return this.jsonTextResponse({
       editor: {
         ...editorStatus,
+        ...servers,
         debugPort: playing?.debugPort ?? this.godotBridge.getStatus().debugPort,
         scan
       },
@@ -45666,6 +45931,30 @@ class GodotServer {
       }
     });
   }
+  async editorServersListening() {
+    const status = this.godotBridge.getStatus();
+    const { lspPort, dapPort } = status;
+    if (!status.connected || lspPort === undefined || dapPort === undefined) {
+      return {};
+    }
+    const [lsp, dap] = await Promise.all([acceptsConnections(lspPort), acceptsConnections(dapPort)]);
+    const greetedAgoMs = status.connectedAt === undefined ? null : Date.now() - status.connectedAt.getTime();
+    return {
+      ...lsp === null ? {} : { lspListening: lsp },
+      ...dap === null ? {} : { dapListening: dap },
+      serversNote: notListeningNote({ lsp: { port: lspPort, listening: lsp }, dap: { port: dapPort, listening: dap } }, greetedAgoMs)
+    };
+  }
+  async editorServersOnceStarted() {
+    const deadline = Date.now() + EDITOR_SERVERS_START_MS;
+    for (;; ) {
+      const answer = await this.editorServersListening();
+      if (answer.serversNote === undefined || Date.now() >= deadline) {
+        return answer;
+      }
+      await delay4(500);
+    }
+  }
   settingKeysOf(projectPath) {
     if (projectPath === undefined) {
       return null;
@@ -45685,7 +45974,7 @@ class GodotServer {
       ]);
     }
     if (!hasSaidWhoItIs(before)) {
-      return this.createErrorResponse(`The editor has connected and has not said who it is within ${GREETING_WAIT_MS / 1000}s, so whether this server or the editor itself restarts it cannot be told.`, ["editor_status says when it has, under greeting while it has not", "Then ask for the restart again"]);
+      return this.createErrorResponse(`The editor has connected and has not said who it is within ${greetingWaitMs() / 1000}s, so whether this server or the editor itself restarts it cannot be told.`, ["editor_status says when it has, under greeting while it has not", "Then ask for the restart again"]);
     }
     const mine = before.openedByAServer === true && before.projectPath !== undefined;
     if (!mine && args["hidden"] === true) {
@@ -45709,6 +45998,7 @@ class GodotServer {
         "editor_status says whether anything has reached the bridge since"
       ]);
     }
+    const servers = await this.editorServersOnceStarted();
     const now = this.godotBridge.getStatus();
     const after = this.settingKeysOf(before.projectPath);
     return this.jsonTextResponse({
@@ -45719,6 +46009,7 @@ class GodotServer {
       addonIsStale: editorIsStale(now.addonVersion, SERVER_VERSION, now.addonDigest, shippedEditorDigest()),
       staleNote: addonMismatch(now.addonVersion, SERVER_VERSION, now.addonDigest, shippedEditorDigest(), this.editorCodeOnDisk()),
       ...this.whatTheEditorDropped(settingsBefore, after),
+      ...servers,
       tookMs: Date.now() - began
     });
   }
@@ -46115,6 +46406,7 @@ class GodotServer {
     } catch (error) {
       return this.createErrorResponse(`The editor is connected but its debug adapter is not: ${errorMessage(error)}`, [
         `This asked on port ${this.dap().port}, which is where the connected editor says it serves`,
+        "Godot binds its debug adapter once, as the editor starts, and reports a failure only in the editor's own log panel: editor_launch restart binds it again",
         "GDHARNESS_DAP_PORT points this server at another one"
       ]);
     }
@@ -46300,7 +46592,7 @@ class GodotServer {
     game.brokeOn = halt.text;
     game.log.record("error", halt.text);
   }
-  async untilTheEditorStopsPlaying(withinMs = STOP_WAIT_MS) {
+  async untilTheEditorStopsPlaying(withinMs = stopWaitMs()) {
     const deadline = Date.now() + withinMs;
     for (;; ) {
       if ((await this.editorPlayingState())?.playing === false) {
@@ -46394,7 +46686,7 @@ class GodotServer {
       running.endedThrough = "signal";
     }
     clearTheRecord();
-    running.log.record(gone ? "info" : "warning", declined !== null ? `gdharness could not signal pid ${running.pid}: the operating system refused it (${declined}). It had described that process as ${described}.` : !gone ? `gdharness signalled pid ${running.pid}, which the operating system described as ${described}, and it was still running ${STOP_WAIT_MS / 1000} seconds later.` : landed ? `gdharness ended pid ${running.pid}, which the operating system described as ${described}.` : `gdharness signalled pid ${running.pid} and it was already gone; the operating system had described it as ${described}.`);
+    running.log.record(gone ? "info" : "warning", declined !== null ? `gdharness could not signal pid ${running.pid}: the operating system refused it (${declined}). It had described that process as ${described}.` : !gone ? `gdharness signalled pid ${running.pid}, which the operating system described as ${described}, and it was still running ${stopWaitMs() / 1000} seconds later.` : landed ? `gdharness ended pid ${running.pid}, which the operating system described as ${described}.` : `gdharness signalled pid ${running.pid} and it was already gone; the operating system had described it as ${described}.`);
     return gone ? "gone" : "lingering";
   }
   async endThroughTheKeeper(run, pid, keeper) {
@@ -46414,7 +46706,7 @@ class GodotServer {
       run.exitCode = null;
       run.exitSignal = "SIGTERM";
     }
-    run.log.record(gone ? "info" : "warning", !gone ? `gdharness had the keeper holding pid ${pid} end it, and it was still running ${STOP_WAIT_MS / 1000} seconds later.` : asked === "signalled" ? `gdharness ended pid ${pid} through the keeper holding it.` : `gdharness asked the keeper holding pid ${pid} to end it, and it had already gone.`);
+    run.log.record(gone ? "info" : "warning", !gone ? `gdharness had the keeper holding pid ${pid} end it, and it was still running ${stopWaitMs() / 1000} seconds later.` : asked === "signalled" ? `gdharness ended pid ${pid} through the keeper holding it.` : `gdharness asked the keeper holding pid ${pid} to end it, and it had already gone.`);
     return gone ? "gone" : "lingering";
   }
   spawnGame(godotPath, cmdArgs, env) {
@@ -47339,7 +47631,7 @@ class GodotServer {
       ...landed ? { endedThrough: "signal" } : {},
       ...childrenFields(ended),
       exitedBeforeStop: !landed,
-      note: `${!gone ? `pid ${pid} was told to end and was still running ${STOP_WAIT_MS / 1000} seconds later, so it has not stopped: a game of this project that no server here was holding,` : landed ? `pid ${pid} was ended: a game of this project that no server here was holding,` : `pid ${pid} had already gone when it was signalled: a game of this project that no server here was holding,`} identified by its announcement and by its command line, ${read.executable} run with --path ${read.projectPath ?? ""}. Nothing here read what it printed or holds its exit code, so neither is in this answer.${gone ? "" : " editor_status says when it has gone."} ${aboutTheChildren(ended, false)}`
+      note: `${!gone ? `pid ${pid} was told to end and was still running ${stopWaitMs() / 1000} seconds later, so it has not stopped: a game of this project that no server here was holding,` : landed ? `pid ${pid} was ended: a game of this project that no server here was holding,` : `pid ${pid} had already gone when it was signalled: a game of this project that no server here was holding,`} identified by its announcement and by its command line, ${read.executable} run with --path ${read.projectPath ?? ""}. Nothing here read what it printed or holds its exit code, so neither is in this answer.${gone ? "" : " editor_status says when it has gone."} ${aboutTheChildren(ended, false)}`
     });
   }
   async whatTheRunStarted(run) {
@@ -48075,7 +48367,8 @@ class GodotServer {
     }
     return `The game this server started (${which}) is still coming up and has not announced its runtime after a wait of ${Math.min(budgetMs, remaining)}ms, so there is nothing to talk to yet. It is still running: ask again in a moment rather than starting another.`;
   }
-  async handleRuntimeCommand(command, args, timeoutMs = this.runtimeTimeoutMs()) {
+  async handleRuntimeCommand(command, args, asked) {
+    const timeoutMs = asked.patience ?? this.runtimeTimeoutMs();
     const { op: _op, projectPath, pid, outputPath, ...params } = asParams(args);
     const waited = typeof pid === "number" ? null : await this.ownRunOnItsWay(typeof projectPath === "string" ? projectPath : this.ownProject, timeoutMs);
     if (waited !== null) {
@@ -48128,7 +48421,7 @@ ${staleNote}`);
           requestId: reply.requestId,
           command,
           waitedMs: timeoutMs,
-          note: reply.message,
+          note: `${reply.message} ${longerWaitNote(asked.tool, asked.op, timeoutMs)}`,
           ...answeredBy,
           ...stale
         });
@@ -48228,13 +48521,13 @@ ${staleNote}`}`
       limit: readPositiveNumber(args, "limit") ?? 100,
       ...property === undefined ? {} : { property },
       ...includeHidden === undefined ? {} : { include_hidden: includeHidden }
-    }, patience);
+    }, { tool: "runtime_inspect", op: "find", patience });
   }
   async handleRuntimeWait(op, args) {
     if (op === "frames") {
       const frames = readPositiveNumber(args, "frames") ?? 1;
       const waited = patienceForFrames(frames, this.runtimeTimeoutMs());
-      return await this.handleRuntimeCommand("wait_frames", { ...whichGame(args), frames }, waited);
+      return await this.handleRuntimeCommand("wait_frames", { ...whichGame(args), frames }, { tool: "runtime_wait", op, patience: waited });
     }
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 5000;
     const asked = readNonEmptyString(args, "nodePath");
@@ -48248,7 +48541,7 @@ ${staleNote}`}`
       path: nodePath,
       signal: readString(args, "signal") ?? "",
       timeout_ms: timeoutMs
-    }, patience) : await this.handleRuntimeCommand("wait_until", {
+    }, { tool: "runtime_wait", op, patience }) : await this.handleRuntimeCommand("wait_until", {
       ...whichGame(args),
       path: nodePath,
       property: readString(args, "property") ?? "",
@@ -48256,7 +48549,7 @@ ${staleNote}`}`
       ...readNonEmptyString(args, "says") === undefined ? {} : { says: readNonEmptyString(args, "says") },
       ...readBoolean(args, "includeHidden") === undefined ? {} : { include_hidden: readBoolean(args, "includeHidden") },
       timeout_ms: timeoutMs
-    }, patience);
+    }, { tool: "runtime_wait", op, patience });
   }
 }
 async function runGodotServer() {
@@ -48264,7 +48557,7 @@ async function runGodotServer() {
   const server = new GodotServer;
   await server.run();
 }
-var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run4, __dirname2, GREETING_WAIT_MS = 1e4, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, PLAY_STARTS_WITHIN_MS = 30000, STOP_WAIT_MS = 1e4, KEEPER_ANSWER_MS = 15000, EXIT_REPORTED_WITHIN_MS = 2000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, MOST_GROUPS = 20, 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, SCAN_WAIT_MS = 30000, STREAMS_GRACE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, SCAN_SETTLED_MS = 500, REIMPORT_TIMEOUT_MS = 300000, 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, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/", PROFILE_FUNCTIONS = 30, PROFILER_ON_MS = 3000, 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. 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 "';
+var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run4, __dirname2, EDITOR_SERVERS_START_MS = 20000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, PLAY_STARTS_WITHIN_MS = 30000, KEEPER_ANSWER_MS = 15000, EXIT_REPORTED_WITHIN_MS = 2000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, MOST_GROUPS = 20, 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, 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, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/", PROFILE_FUNCTIONS = 30, PROFILER_ON_MS = 3000, 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 it is called through that class by name and one class was asked about. 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 "';
 var init_server3 = __esm(() => {
   init_mcp();
   init_stdio2();
@@ -48296,6 +48589,7 @@ var init_server3 = __esm(() => {
   init_lsp_client();
   init_outside();
   init_paths();
+  init_port_probe();
   init_ports();
   init_process_children();
   init_process_time();