gdharness 1.1.58 → 1.1.60

package/build/cli.js

@@ -9183,6 +9183,65 @@ function enclosingFunction(source, line, code = codeOf(source)) {
   }
   return null;
 }
+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 callSitesOf(source, name) {
   const regions = regionsOf(source);
   const code = codeOf(source, regions);
@@ -9208,7 +9267,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, KEYWORDS;
 var init_gdscript_source = __esm(() => {
   IDENTIFIER_START = /[\p{L}_]/u;
   IDENTIFIER_PART = /[\p{L}\p{N}_]/u;
@@ -9218,6 +9277,8 @@ 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");
   KEYWORDS = new Set([
     "and",
     "as",
@@ -18218,7 +18279,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: []
         }
       },
@@ -18436,7 +18497,10 @@ var init_tool_definitions = __esm(() => {
           summary: "what one property reads on a node, or through the objects it holds, refusing a name nothing along the way has",
           requires: ["nodePath", "property"]
         },
-        metrics: { summary: "frame time, memory, draw calls and the rest", requires: [] }
+        metrics: {
+          summary: "frame time, memory, draw calls and the rest. frame_time is the mean wall time of a frame over the last frames_timed frames (up to 120, timed by the game itself, physics and the wait for the display included), frame_time_max the slowest of them, both in seconds and null before a frame has passed; vsync says whether a frame waits for the display, and max_fps is the game's frame-rate cap, 0 for none. fps, process_time_max and physics_time are the engine's monitors, which it sets once a second: the frames counted in the last second, and the slowest process and physics step in it, so they trail a change by up to a second and the last two are a worst case rather than the frame. The memory, object and render counts are read as asked",
+          requires: []
+        }
       },
       defaultOperation: "tree"
     },
@@ -34128,7 +34192,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");
@@ -42305,6 +42369,13 @@ function readProfileFile(path) {
     return null;
   }
 }
+function frameFunctionsFor(queued) {
+  return Math.max(64, queued - QUEUE_HEADROOM);
+}
+function queuedMessagesOf(projectGodot) {
+  const set = projectGodot === null ? undefined : parseProjectGodot(projectGodot)["network"]?.[QUEUE_SETTING];
+  return typeof set === "number" && Number.isInteger(set) && set > 0 ? set : QUEUE_DEFAULT;
+}
 function signatureParts(signature) {
   const parts = signature.split("::");
   if (parts.length < 3) {
@@ -42315,25 +42386,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));
 }
@@ -42349,27 +42431,35 @@ function placedLambda(row, sourceOf) {
   return within === null ? row : { ...row, within };
 }
 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 sites = [];
-  for (const [script, source] of scripts) {
+  for (const [script, source] of listed) {
     for (const site of callSitesOf(source, bare)) {
       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 } : {}
+        }
       });
     }
   }
   sites.sort((a, b) => (b.withinTotalMs ?? -1) - (a.withinTotalMs ?? -1) || a.script.localeCompare(b.script) || a.line - b.line);
   return { target, sites: sites.slice(0, CALL_SITES), omitted: Math.max(0, sites.length - CALL_SITES) };
 }
-var ms = (seconds) => Math.round(seconds * 1e6) / 1000, CALL_SITES = 40;
+var QUEUE_SETTING = "limits/debugger/max_queued_messages", QUEUE_DEFAULT = 2048, QUEUE_HEADROOM = 512, UNNAMED_PREFIX = "#", ms = (seconds) => Math.round(seconds * 1e6) / 1000, CALL_SITES = 40;
 var init_script_profile = __esm(() => {
   init_gdscript_source();
   init_godot_variant();
+  init_resources();
 });
 
 // src/server.ts
@@ -42395,8 +42485,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;
@@ -42447,6 +42543,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, and this game fell below that rate, so ask for fewer frames at a time` : "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("\\", "/")}`;
 }
@@ -42526,7 +42630,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) {
@@ -42581,7 +42688,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
     };
   }
@@ -42699,7 +42806,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.`;
 }
@@ -42816,6 +42923,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");
@@ -42874,7 +42984,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."
@@ -43072,6 +43182,26 @@ function profileOnStart(profiled, through, runtimeAddon) {
     totals: `On from the game's start, through ${debuggerOf}. editor_run profile answers at any time: each frame is added as it ends, so a scene still inside a long _ready shows nothing until that returns, and the engine's own totals replace the sum when the game quits` + (runtimeAddon ? "." : ", which takes the runtime addon: without it the frames that arrived before the exit are what is kept.")
   };
 }
+function profileFrameFunctions(projectPath) {
+  let projectGodot = null;
+  if (projectPath !== null) {
+    try {
+      projectGodot = readFileSync23(join26(projectPath, "project.godot"), "utf8");
+    } catch {}
+  }
+  return frameFunctionsFor(queuedMessagesOf(projectGodot));
+}
+function playedCap(held) {
+  const frameFunctions = readPositiveNumber(held, "frameFunctions");
+  if (frameFunctions === undefined) {
+    return {};
+  }
+  return {
+    frameFunctions,
+    cappedFrames: readNonNegativeNumber(held, "cappedFrames") ?? 0,
+    totalCapped: readBoolean(held, "totalCapped") === true
+  };
+}
 function projectSourceOf(projectPath) {
   const read = new Map;
   return (script) => {
@@ -43109,15 +43239,22 @@ 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) {
     notes.push(`${totals.unreadable} message${totals.unreadable === 1 ? "" : "s"} from the game could not be read, so the totals have that many gaps.`);
   }
@@ -43136,6 +43273,22 @@ function profileAnswer(reading, limit) {
     note: notes.length > 0 ? notes.join(" ") : undefined
   };
 }
+function cappedNotes(totals) {
+  const notes = [];
+  const most = totals.frameFunctions;
+  const why = `${most} is kept below the game's debugger queue (network/limits/debugger/max_queued_messages), which drops the message naming a function when one frame names more than it holds, and a function whose name is dropped is never named afterwards.`;
+  if (most !== undefined && totals.complete && totals.totalCapped === true) {
+    notes.push(`The engine's totals carried the most functions the profiler asks for, ${most}, so the functions with the least time are not in them: ${why}`);
+  } else if (most !== undefined && !totals.complete && (totals.cappedFrames ?? 0) > 0) {
+    const capped = totals.cappedFrames ?? 0;
+    notes.push(`${capped === totals.frames ? capped === 1 ? "The one frame" : `All ${capped} frames` : `${capped} of the ${totals.frames} frames`} carried the most functions the profiler asks for in one, ${most}, so the functions with the least time in ${capped === 1 ? "it" : "them"} are not counted there: ${why}`);
+  }
+  const unnamed = Object.entries(totals.functions).filter(([name, sum]) => name.startsWith(UNNAMED_PREFIX) && sum.calls > 0).length;
+  if (unnamed > 0) {
+    notes.push(`${unnamed === 1 ? "One function" : `${unnamed} functions`} arrived without ${unnamed === 1 ? "its name" : "their names"}, shown as ${UNNAMED_PREFIX} and the number the engine gave ${unnamed === 1 ? "it" : "them"}: the engine names a function once, as it first appears, and the game's debugger queue was full when that message was sent. They are script functions of the game; which ones cannot be recovered from this profile.`);
+  }
+  return notes;
+}
 function callersAnswer(totals, asked) {
   const found = callersOf(totals, asked.name, asked.scripts());
   return {
@@ -43836,7 +43989,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);
@@ -43996,7 +44149,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);
@@ -44006,17 +44159,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": {
@@ -44029,16 +44182,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) {
@@ -44051,7 +44204,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", {
@@ -44059,9 +44212,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": {
@@ -44290,7 +44443,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));
@@ -45637,7 +45790,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) {
@@ -46082,7 +46235,10 @@ class GodotServer {
     const breakpoints = await this.dapHoldingBreakpointsOf(projectPath).reapplyBreakpoints();
     this.logDebug(`Breakpoints were sent again after ${Date.now() - sendingFrom}ms`);
     if (profiled) {
-      const armed = await this.handleViaBridge("profile_start", { arm: true });
+      const armed = await this.handleViaBridge("profile_start", {
+        arm: true,
+        frameFunctions: profileFrameFunctions(projectPath)
+      });
       if (armed.isError === true) {
         return this.profilerRefusal(armed);
       }
@@ -46249,7 +46405,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) {
@@ -46343,7 +46499,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) {
@@ -46363,7 +46519,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) {
@@ -46865,7 +47021,7 @@ class GodotServer {
       ...callersName === undefined ? {} : { callersOf: { name: callersName, scripts: () => projectScripts(projectPath) } }
     };
     if (run.throughEditor) {
-      return await this.profileOfThePlayedGame(going, fromProject, limit);
+      return await this.profileOfThePlayedGame(going, projectPath, fromProject, limit);
     }
     const record = run.projectPath === null ? null : readRunRecord(run.projectPath);
     const path = record !== null && record.pid === run.pid ? record.profile : undefined;
@@ -46887,7 +47043,7 @@ class GodotServer {
       ...fromProject
     }, limit));
   }
-  async profileOfThePlayedGame(going, fromProject, limit) {
+  async profileOfThePlayedGame(going, projectPath, fromProject, limit) {
     const read = await this.handleViaBridge("profile_read", {});
     if (read.isError === true) {
       return this.profilerRefusal(read);
@@ -46899,7 +47055,9 @@ class GodotServer {
           "editor_run start with profile: true plays it again with the profiler on from its start"
         ]);
       }
-      const started = await this.handleViaBridge("profile_start", {});
+      const started = await this.handleViaBridge("profile_start", {
+        frameFunctions: profileFrameFunctions(projectPath)
+      });
       if (started.isError === true) {
         return this.profilerRefusal(started);
       }
@@ -46922,6 +47080,7 @@ class GodotServer {
       frames: readNonNegativeNumber(held, "frames") ?? 0,
       complete: readBoolean(held, "complete") === true,
       unreadable: 0,
+      ...playedCap(held),
       functions: Object.fromEntries(Object.entries(functions).map(([signature, sum]) => {
         const [calls, self, total] = Array.isArray(sum) ? sum : [];
         return [
@@ -47285,7 +47444,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) {
@@ -48021,7 +48180,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) {
@@ -48074,7 +48234,7 @@ ${staleNote}`);
           requestId: reply.requestId,
           command,
           waitedMs: timeoutMs,
-          note: reply.message,
+          note: `${reply.message} ${longerWaitNote(asked.tool, asked.op, timeoutMs)}`,
           ...answeredBy,
           ...stale
         });
@@ -48174,13 +48334,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");
@@ -48194,7 +48354,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") ?? "",
@@ -48202,7 +48362,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() {
@@ -48210,7 +48370,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, 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. 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();

package/build/godot/addons/gdharness_editor/tools/play_tools.gd

@@ -34,6 +34,14 @@ func set_editor_plugin(plugin: EditorPlugin) -> void:
 
 
 func _process(_delta: float) -> void:
+	_count_a_play_begun()
+
+
+## Counts a play the editor has begun since the last look, whoever began it. Looked at every frame
+## and before the count is read: read alone, a play begun in this frame went uncounted until this
+## node's turn came round, and a server asking before then was told the earlier play's number with
+## "playing", which it took for the earlier play still going.
+func _count_a_play_begun() -> void:
 	var playing: bool = EditorInterface.is_playing_scene()
 	if playing and not _was_playing:
 		if _awaited:
@@ -231,6 +239,7 @@ static func _leave() -> void:
 
 
 func playing_status(_args: Dictionary) -> Dictionary:
+	_count_a_play_begun()
 	var playing: bool = EditorInterface.is_playing_scene()
 	# The debugger's port with it, read now rather than remembered: it is taken again before every
 	# play, so the one from when this editor greeted the server is a number it has moved off.