gdharness 1.1.62 → 1.2.1

package/build/cli.js

@@ -18413,7 +18413,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 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",
+          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. The profiler's own cost of timing a call lands in the self time of the function called; with the runtime addon it is measured each run on an empty function, as perCallOverheadUs, and a row with at least half its selfMs in it carries overheadMs, since a small function called often costs that much less without the profiler. A function the profiler started inside is left out, since its time would be counted from the engine's start. The milliseconds are time passed while the function ran, not processor time given to it, so they grow when other processes compete for the processor: compare two profiles taken under the same load. 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: []
         }
       },
@@ -18421,7 +18421,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "editor_output",
-      description: "What the project started by editor_run has printed, as entries with a severity: the errors and warnings the engine reported, each with where it happened, and everything else as info. For a run the editor plays the reports come from the game itself, through the runtime addon, since the editor's debugger relays what a game prints and not what it reports; a played game without the runtime addon answers here with its prints alone, with errorsUnread true and no clean, since what it raised reaches nothing here. Answers with the counts and the verdict as well as the entries. heldAt is three answers: null for a run this server knows is not held, running or over, an object for one it knows is held at a breakpoint, whether the adapter said so or the runtime did by accepting a connection and never answering, and absent with heldUnknown beside it for a server that connected to the debugger after the stop and has no runtime to ask, since the adapter reports a stop only to the sessions connected when it happened. A run that has quit still answers here, with running false and its exit code, until the next one starts; a run ended by a signal has no exit code, and exitSignal names the signal instead. A run this server started also answers with transcript, the file both its streams are written to: uncapped, written while the run is going, and the thing to read or tail for a long run rather than the engine's own log, which every engine start rotates away. Read the file for output and this answer for state: endedBy says whether gdharness ended the run, and a transcript that has stopped growing is a run between prints rather than a run that is over. running is asked of the operating system whenever there is a process to ask about, which is every run this server started and every editor-played run whose game announced its runtime. For an editor-played run that never announced, there is no process id here and running is the editor's answer, which can lag: one measured elsewhere reported a game as playing for fifteen seconds after its process had been ended from outside. editor_status names that game under runtimes, which does not depend on the editor answering. op: \"editor\" answers about the editor itself instead, which is a different log and the only way anything here can read what an editor printed: its console reaches no plugin, so the addon cannot scrape it, and an editor gdharness opened is asked for a log file as it starts. That covers the whole session from the editor's first line, which is where the output worth reading usually is, since the class cache, the plugins and the language server all say what they have to say before any harness has connected. The answer carries the entries in the order they were printed and, beside them under repeated, each message shape several lines share: how many, what varied in each slot of it and how many different values stood there, the first occurrence, and the ordinary lines above the group, found by walking back past the group rather than by counting lines. An editor somebody opened by hand has no console here and is refused saying so rather than answered empty, because an editor that printed nothing and an editor nobody captured are not the same thing.",
+      description: "What the project started by editor_run has printed, as entries with a severity: the errors and warnings the engine reported, each with where it happened, and everything else as info. For a run the editor plays the reports come from the game itself, through the runtime addon, since the editor's debugger relays what a game prints and not what it reports; a played game without the runtime addon answers here with its prints alone, with errorsUnread true and no clean, since what it raised reaches nothing here. Answers with the counts and the verdict as well as the entries. heldAt is three answers: null for a run this server knows is not held, running or over, an object for one it knows is held at a breakpoint, whether the adapter said so or the runtime did by accepting a connection and never answering, and absent with heldUnknown beside it for a server that connected to the debugger after the stop and has no runtime to ask, since the adapter reports a stop only to the sessions connected when it happened. A run that has quit still answers here, with running false and its exit code, until the next one starts; a run ended by a signal has no exit code, and exitSignal names the signal instead. A run this server started also answers with transcript, the file both its streams are written to: uncapped, written while the run is going, and the thing to read or tail for a long run rather than the engine's own log, which every engine start rotates away. Read the file for output and this answer for state: endedBy says whether gdharness ended the run, and a transcript that has stopped growing is a run between prints rather than a run that is over. running is asked of the operating system whenever there is a process to ask about, which is every run this server started and every editor-played run whose game announced its runtime. For an editor-played run that never announced, there is no process id here and running is the editor's answer, which can lag: one measured elsewhere reported a game as playing for fifteen seconds after its process had been ended from outside. editor_status names that game under runtimes, which does not depend on the editor answering. op: \"editor\" answers about the editor itself instead, which is a different log and the only way anything here can read what an editor printed: its console reaches no plugin, so the addon cannot scrape it, and an editor gdharness opened is asked for a log file as it starts. That covers the whole session from the editor's first line, which is where the output worth reading usually is, since the class cache, the plugins and the language server all say what they have to say before any harness has connected. The answer carries the entries in the order they were printed and, beside them under repeated, each message shape several lines share: how many, what varied in each slot of it and how many different values stood there, the first occurrence, and the ordinary lines above the group, found by walking back past the group rather than by counting lines. An editor somebody opened by hand has no console here and is refused saying so rather than answered empty, because an editor that printed nothing and an editor nobody captured are not the same thing. startedAt is when the run began and elapsedMs how long it has been going; for a run that is over, endedAt is when it ended and elapsedMs how long it ran, and both are left out when nobody saw the end, as for a game closed in the editor or a run picked up from a note written before ends were recorded.",
       parameters: {
         severity: {
           type: "string",
@@ -18469,7 +18469,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. It stays named after the run ends, beside processActive false, so editor_output can still read what that run printed; null when there is no run at all. 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.",
+      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. It stays named after the run ends, beside processActive false, so editor_output can still read what that run printed; null when there is no run at all. startedAt says when it began, and endedAt when it ended, wherever something saw the end: a run adopted from a note another server wrote can have ended hours before this server started. 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: []
     },
@@ -42202,7 +42202,8 @@ function recordAt(path) {
     arguments: Array.isArray(args) ? args.filter((value) => typeof value === "string") : [],
     ...typeof fields["command"] === "string" ? { command: fields["command"] } : {},
     ...typeof fields["exitCode"] === "number" ? { exitCode: fields["exitCode"] } : {},
-    ...typeof fields["exitSignal"] === "string" ? { exitSignal: fields["exitSignal"] } : {}
+    ...typeof fields["exitSignal"] === "string" ? { exitSignal: fields["exitSignal"] } : {},
+    ...typeof fields["endedAt"] === "number" ? { endedAt: fields["endedAt"] } : {}
   };
 }
 async function runningAs(pid) {
@@ -42556,16 +42557,39 @@ 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, sourceOf);
-  const scriptMs = ms(Object.values(totals.functions).reduce((sum, one) => sum + (one.calls > 0 ? one.selfSeconds : 0), 0));
+  const perCallUs = perCallCostOf(totals);
+  const rows = rowsOf(totals, sourceOf).map((row) => withOverhead(row, perCallUs));
+  const scriptMs = ms(Object.entries(totals.functions).reduce((sum, [signature, one]) => sum + (one.calls > 0 && !isCalibration(signature) ? one.selfSeconds : 0), 0));
   return {
     functions: rows.slice(0, limit).map((row) => placedLambda(row, sourceOf)),
     omitted: Math.max(0, rows.length - limit),
     scriptMs,
     counted: rows.length,
-    superCallers: rows.filter((row) => row.selfIncludesSuper === true).length
+    superCallers: rows.filter((row) => row.selfIncludesSuper === true).length,
+    perCallUs,
+    overheadDominated: rows.filter((row) => row.overheadMs !== undefined).length
   };
 }
+function isCalibration(signature) {
+  const parts = signatureParts(signature);
+  return parts.script.endsWith(RUNTIME_SCRIPT) && (parts.function === PROFILER_PROBE || parts.function === PROFILER_CALIBRATOR);
+}
+function perCallCostOf(totals) {
+  for (const [signature, sum] of Object.entries(totals.functions)) {
+    const parts = signatureParts(signature);
+    if (parts.script.endsWith(RUNTIME_SCRIPT) && parts.function === PROFILER_PROBE && sum.calls > 0) {
+      return Math.round(sum.selfSeconds / sum.calls * 1e9) / 1000;
+    }
+  }
+  return null;
+}
+function withOverhead(row, perCallUs) {
+  if (perCallUs === null || row.selfMs <= 0) {
+    return row;
+  }
+  const overheadMs = Math.round(row.calls * perCallUs) / 1000;
+  return overheadMs >= row.selfMs / 2 ? { ...row, overheadMs: Math.min(overheadMs, row.selfMs) } : row;
+}
 function rowsOf(totals, sourceOf) {
   const codes = new Map;
   const codeOfScript = (script) => {
@@ -42575,7 +42599,7 @@ function rowsOf(totals, sourceOf) {
     }
     return codes.get(script) ?? null;
   };
-  return Object.entries(totals.functions).filter(([, sum]) => sum.calls > 0).map(([signature, sum]) => {
+  return Object.entries(totals.functions).filter(([signature, sum]) => sum.calls > 0 && !isCalibration(signature)).map(([signature, sum]) => {
     const parts = signatureParts(signature);
     const code = codeOfScript(parts.script);
     return {
@@ -42641,7 +42665,7 @@ function callersOf(totals, name, scripts) {
   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 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 QUEUE_SETTING = "limits/debugger/max_queued_messages", QUEUE_DEFAULT = 2048, QUEUE_HEADROOM = 512, UNNAMED_PREFIX = "#", ms = (seconds) => Math.round(seconds * 1e6) / 1000, RUNTIME_SCRIPT = "gdharness_runtime/runtime_autoload.gd", PROFILER_PROBE = "_profiler_probe", PROFILER_CALIBRATOR = "_calibrate_the_profiler", CALL_SITES = 40;
 var init_script_profile = __esm(() => {
   init_gdscript_source();
   init_godot_variant();
@@ -43229,6 +43253,24 @@ function foldedScriptErrors(errors) {
 function nonEmpty(lists) {
   return Object.fromEntries(Object.entries(lists).filter(([, list]) => list.length > 0));
 }
+function withoutUidUnder(unminted, paths) {
+  return unminted.map((script) => `res://${script}`).filter((script) => paths.some((path) => script === path || script.startsWith(path.endsWith("/") ? path : `${path}/`)));
+}
+function withUidsMissing(answer, missing) {
+  const content = answer.content.map((part) => ({ ...part }));
+  const last = content.at(-1);
+  try {
+    const parsed = JSON.parse(last?.text ?? "");
+    if (last !== undefined && typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      last.text = answerJson({
+        ...parsed,
+        uidsMissing: missing,
+        uidsNote: `${missing.length === 1 ? "This script has" : "These scripts have"} no .uid sidecar yet: the engine writes one when it imports the project, which a test run does not, so a check that tracks the sidecars fails on ${missing.length === 1 ? "it" : "them"}. project_import refresh_uids writes them.`
+      });
+    }
+  } catch {}
+  return { ...answer, content };
+}
 function withPreviousCut(answer, previous) {
   const content = answer.content.map((part) => ({ ...part }));
   const last = content.at(-1);
@@ -43440,6 +43482,9 @@ function profileAnswer(reading, limit) {
   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.`);
   }
+  if (table.overheadDominated > 0 && table.perCallUs !== null) {
+    notes.push(`The profiler costs about ${table.perCallUs}µs a call in this run, measured on an empty function the runtime addon calls as it goes on, and that time lands in the self time of the function called. ${table.overheadDominated === 1 ? "One function has" : `${table.overheadDominated} functions have`} at least half ${table.overheadDominated === 1 ? "its" : "their"} selfMs in it, under overheadMs: that much of its time is the profiler's and goes once the profiler is off, whether the function is inlined or not. What inlining saves is the call itself, which costs something without the profiler too, not the work inside 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.`);
@@ -43452,6 +43497,7 @@ function profileAnswer(reading, limit) {
     frames: totals.frames,
     coveredMs: reading.coveredMs,
     scriptMs: table.scriptMs,
+    perCallOverheadUs: table.perCallUs ?? undefined,
     functionsCounted: table.counted,
     omitted: table.omitted > 0 ? table.omitted : undefined,
     functions: table.functions,
@@ -45181,11 +45227,14 @@ class GodotServer {
     return ticker;
   }
   async handleRunTests(args) {
-    const answer = await this.runTests(args);
+    const ran = await this.runTests(args);
     const project = this.project(args);
     if (!project.ok || callSignal()?.aborted === true) {
-      return answer;
+      return ran;
     }
+    const paths = testPathsIn(project.value.path, args["path"]);
+    const unminted = paths.ok ? withoutUidUnder(scriptsWithoutUid(project.value.path), paths.value) : [];
+    const answer = unminted.length === 0 ? ran : withUidsMissing(ran, unminted);
     const previous = takeCutTestRun(project.value.path);
     return previous === null ? answer : withPreviousCut(answer, previous);
   }
@@ -45884,7 +45933,9 @@ class GodotServer {
     return {
       pid: run.pid ?? this.announcedPidOf(run) ?? run.announcedPid ?? null,
       ...run.throughEditor || run.projectPath === null ? {} : { project: run.projectPath },
-      ...run.pickedUp === true ? { adopted: true } : {}
+      ...run.pickedUp === true ? { adopted: true } : {},
+      startedAt: new Date(run.startedAt).toISOString(),
+      ...run.endedAt === undefined ? {} : { endedAt: new Date(run.endedAt).toISOString() }
     };
   }
   async handleEditorStatus() {
@@ -46657,10 +46708,11 @@ class GodotServer {
         return "unreached";
       }
       running.endedThrough = "editor";
-      if (announced === undefined) {
-        return await this.untilTheEditorStopsPlaying() ? "gone" : "lingering";
+      const stopped = announced === undefined ? await this.untilTheEditorStopsPlaying() : await untilGone([announced]);
+      if (stopped) {
+        running.endedAt = Date.now();
       }
-      return await untilGone([announced]) ? "gone" : "lingering";
+      return stopped ? "gone" : "lingering";
     }
     if (running.pid === null) {
       return "gone";
@@ -46709,6 +46761,7 @@ class GodotServer {
     if (landed && gone) {
       running.exitCode = null;
       running.exitSignal = "SIGTERM";
+      running.endedAt ??= Date.now();
     }
     if (landed) {
       running.endedThrough = "signal";
@@ -46733,6 +46786,7 @@ class GodotServer {
     if (asked === "signalled" && gone) {
       run.exitCode = null;
       run.exitSignal = "SIGTERM";
+      run.endedAt ??= Date.now();
     }
     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";
@@ -46780,6 +46834,7 @@ class GodotServer {
       this.logDebug(`Godot process exited with code ${code ?? "none"}, signal ${signal ?? "none"}`);
       started.exitCode = code;
       started.exitSignal = code === null ? signal : null;
+      started.endedAt = Date.now();
     });
     child.on("error", (err) => {
       console.error("Failed to start Godot process:", err);
@@ -47094,6 +47149,9 @@ class GodotServer {
       adopted.log.finish();
       adopted.exitCode = record.exitCode ?? null;
       adopted.exitSignal = record.exitSignal ?? null;
+      if (record.endedAt !== undefined) {
+        adopted.endedAt = record.endedAt;
+      }
       const exitMayBeComing = !alive(record.pid) && !exited(adopted);
       if (!exitMayBeComing) {
         adopted.endedUnwatched = !exited(adopted);
@@ -47387,6 +47445,9 @@ class GodotServer {
       if (record !== null && record.pid === run.pid && (record.exitCode !== undefined || record.exitSignal !== undefined)) {
         run.exitCode = record.exitCode ?? null;
         run.exitSignal = record.exitSignal ?? null;
+        if (record.endedAt !== undefined) {
+          run.endedAt = record.endedAt;
+        }
         return true;
       }
       if (Date.now() >= until) {
@@ -47533,7 +47594,8 @@ class GodotServer {
       project: run.throughEditor ? undefined : run.projectPath ?? undefined,
       transcript: run.transcript ?? undefined,
       startedAt: new Date(run.startedAt).toISOString(),
-      elapsedMs: Date.now() - run.startedAt,
+      endedAt: stillRunning(run) || run.endedAt === undefined ? undefined : new Date(run.endedAt).toISOString(),
+      elapsedMs: stillRunning(run) ? Date.now() - run.startedAt : run.endedAt === undefined ? undefined : run.endedAt - run.startedAt,
       cpuSeconds,
       note: notes.length > 0 ? notes.join(" ") : undefined,
       omitted: selected.omitted,

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

@@ -39,6 +39,10 @@ const PROFILE_RECEIVED: String = "gdharness:profile_received"
 ## editor without the gdharness addon, holds every profiled exit this long.
 const PROFILE_CONFIRM_MS: int = 3000
 
+## How many times the empty function is called to measure what the profiler costs per call: enough
+## that the clock's microsecond steps are lost in the sum, and a few milliseconds of one frame.
+const PROFILER_PROBE_CALLS: int = 10000
+
 ## How many calls of `EngineDebugger.line_poll` read the debugger's messages once: it reads them
 ## on every 2048th call and only counts the others.
 const POLLS_PER_READ: int = 2048
@@ -103,6 +107,7 @@ var _commands: Dictionary = {}
 var _loaded_version: String = _read_marker(VERSION_MARKER)
 var _loaded_digest: String = _read_marker(DIGEST_MARKER)
 var _profile_received: bool = false
+var _profiler_calibrated: bool = false
 
 
 func _init() -> void:
@@ -193,6 +198,31 @@ func _send_the_profile() -> void:
 		)
 
 
+## What the script profiler costs per call in this game, measured once each time it is switched on.
+##
+## The profiler times every call it counts, and that bookkeeping lands in the self time of the
+## function called, so a function doing almost nothing, called six hundred thousand times, can read
+## as a second of its own that is mostly the profiler's. So an empty function
+## is called here [constant PROFILER_PROBE_CALLS] times while the profiler watches, under the load
+## the game is under, and the server reads its row as the cost of one call.
+func _calibrate_the_profiler() -> void:
+	var profiling: bool = EngineDebugger.is_active() and EngineDebugger.is_profiling("servers")
+	if not profiling:
+		_profiler_calibrated = false
+		return
+	if _profiler_calibrated:
+		return
+	_profiler_calibrated = true
+	for _call: int in PROFILER_PROBE_CALLS:
+		_profiler_probe()
+
+
+## Does nothing, so its time under the profiler is the profiler's own. Kept in step with
+## `PROFILER_PROBE` in src/script-profile.ts.
+func _profiler_probe() -> void:
+	pass
+
+
 func _on_debugger_message(message: String, _data: Array) -> bool:
 	if PROFILE_CAPTURE + ":" + message == PROFILE_RECEIVED:
 		_profile_received = true
@@ -223,6 +253,7 @@ func _process(_delta: float) -> void:
 	if not _enabled or _server == null:
 		return
 	_queries.note_frame(Time.get_ticks_usec())
+	_calibrate_the_profiler()
 
 	if _server.is_connection_available():
 		var client: StreamPeerTCP = _server.take_connection()

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

@@ -25,6 +25,15 @@ const HEADLESS_VIEWPORT: Vector2 = Vector2(64, 64)
 ## everything that process starts. Kept in step with `DESKTOP_VARIABLE` in src/desktop.ts.
 const DESKTOP_VARIABLE: String = "GDHARNESS_DESKTOP"
 
+## Node.ProcessMode as its names, for a refusal to say which one is in force.
+const PROCESS_MODES: Dictionary[int, String] = {
+	Node.PROCESS_MODE_INHERIT: "INHERIT",
+	Node.PROCESS_MODE_PAUSABLE: "PAUSABLE",
+	Node.PROCESS_MODE_WHEN_PAUSED: "WHEN_PAUSED",
+	Node.PROCESS_MODE_ALWAYS: "ALWAYS",
+	Node.PROCESS_MODE_DISABLED: "DISABLED",
+}
+
 ## Whether this run has had the pointer note in full; the game process is the run.
 static var _pointer_explained: bool = false
 
@@ -551,20 +560,40 @@ func click(params: Dictionary) -> Dictionary:
 ## that does not process while the game is paused is hovered and never handed the event.
 func _takes_no_click(control: Control, node_path: String) -> String:
 	if not control.is_visible_in_tree():
-		return "%s is not visible, so nothing can click it" % node_path
+		return "%s is not visible%s, so nothing can click it" % [node_path, Targets.why_hidden(control)]
 	var button: BaseButton = control as BaseButton
 	if button != null and button.disabled:
 		return "%s is disabled, so clicking it presses nothing" % node_path
 	if not control.can_process():
+		var why: String = _why_it_does_not_process(control, node_path)
+		var over: Node = Targets.drawn_over(control)
+		var cover: String = "" if over == null else "; %s is drawn over it" % over.get_path()
 		if _host.get_tree().paused:
 			return (
-				"the game is paused and %s does not process while it is, so clicking it does nothing"
-				% node_path
+				"the game is paused and %s does not process while it is (%s), so clicking it does nothing%s"
+				% [node_path, why, cover]
 			)
-		return "%s has its processing disabled, so clicking it does nothing" % node_path
+		return "%s does not process (%s), so clicking it does nothing%s" % [node_path, why, cover]
 	return ""
 
 
+## Which node's process_mode keeps [param control] from processing, and what it is. A node set to
+## inherit takes its parent's, so the one deciding can be any node above it: the game turning a
+## whole screen off while a menu shows over it reads, on the button, as a button turned off.
+static func _why_it_does_not_process(control: Control, node_path: String) -> String:
+	var deciding: Node = control
+	while deciding.process_mode == Node.PROCESS_MODE_INHERIT and deciding.get_parent() != null:
+		deciding = deciding.get_parent()
+	# The root inherits from nothing, which processes as pausable.
+	var value: int = deciding.process_mode
+	if value == Node.PROCESS_MODE_INHERIT:
+		value = Node.PROCESS_MODE_PAUSABLE
+	var mode: String = PROCESS_MODES.get(value, str(value))
+	if deciding == control:
+		return "its process_mode is %s" % mode
+	return "%s inherits process_mode %s from %s" % [node_path, mode, deciding.get_path()]
+
+
 ## Why a click at [param control]'s centre would reach nothing, or "" when it would reach it: the
 ## centre outside the viewport it is drawn in, at [param local]; outside the viewport showing that
 ## one on the screen, which [param reached] holds with the centre there; or clipped away by a
@@ -652,7 +681,10 @@ func _press_button(viewport: Viewport, event: InputEventMouseButton) -> void:
 ## anything the engine can be asked, so it is not claimed.
 func _click_in_the_world(node_path: String, item: Node3D, params: Dictionary) -> Dictionary:
 	if not item.is_visible_in_tree():
-		return {"type": "error", "message": "%s is not visible, so nothing can click it" % node_path}
+		return {
+			"type": "error",
+			"message": "%s is not visible%s, so nothing can click it" % [node_path, Targets.why_hidden(item)]
+		}
 
 	var found: Dictionary = Queries.in_frame(item)
 	if found.is_empty():

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

@@ -370,6 +370,99 @@ static func _pressed_through(control: Control) -> Control:
 	return control
 
 
+## What a pointer at [param target]'s centre would reach instead of it, drawn over it, or null.
+static func drawn_over(target: Control) -> Node:
+	var drawn: Array[Node] = _pointer_takers(target.get_tree().root)
+	return _cover_of(target, drawn, _areas_of(drawn))
+
+
+## Why [param node], which is not visible in the tree, is not, as a parenthesis to follow its path:
+## which nodes hide it, nearest first, and what is shown beside the nearest. Reading visible off
+## the node itself says true when only an ancestor is hidden, so without this a caller had nothing
+## to unhide; every hidden one is named because unhiding only the nearest leaves the rest hiding it.
+## "" when nothing on the way up says so.
+static func why_hidden(node: Node) -> String:
+	var hiding: Array[Node] = _hiding(node)
+	if hiding.is_empty():
+		return ""
+	var named: Array[String] = []
+	for one: Node in hiding:
+		if one == node:
+			named.append("its own visible is false")
+		else:
+			named.append("%s is hidden%s" % [one.get_path(), "" if named.is_empty() else " too"])
+	var beside: Array[String] = []
+	var parent: Node = hiding[0].get_parent()
+	if parent != null:
+		for sibling: Node in parent.get_children():
+			if sibling != hiding[0] and _shown(sibling):
+				beside.append(str(sibling.get_path()))
+	return " (%s%s)" % [", and ".join(named), _shown_beside(beside)]
+
+
+## "; A, B and C beside it are shown" for [param beside], naming three at most and counting the rest.
+static func _shown_beside(beside: Array[String]) -> String:
+	if beside.is_empty():
+		return ""
+	if beside.size() == 1:
+		return "; %s beside it is shown" % beside[0]
+	var listed: Array[String] = beside.slice(0, 3)
+	var rest: int = beside.size() - listed.size()
+	if rest > 0:
+		return "; %s and %d more beside it are shown" % [", ".join(listed), rest]
+	var last: String = listed.pop_back()
+	return "; %s and %s beside it are shown" % [", ".join(listed), last]
+
+
+## The nodes whose visible is false and keeps [param node] from being drawn, nearest first. Walked
+## the way the engine inherits visibility rather than by parent: an item under a plain Node is drawn
+## from its canvas layer, whatever a control above that Node says, so naming that control would send
+## a caller to unhide something that hides nothing.
+static func _hiding(node: Node) -> Array[Node]:
+	var hiding: Array[Node] = []
+	var at: Node = node
+	while at != null:
+		var item: CanvasItem = at as CanvasItem
+		var spatial: Node3D = at as Node3D
+		if item != null:
+			if not item.visible:
+				hiding.append(item)
+			var above: CanvasItem = item.get_parent() as CanvasItem
+			if above != null:
+				at = above
+				continue
+			var layer: CanvasLayer = item.get_canvas_layer_node()
+			if layer != null and not layer.visible:
+				hiding.append(layer)
+			at = item.get_viewport()
+		elif spatial != null:
+			if not spatial.visible:
+				hiding.append(spatial)
+			at = spatial.get_parent_node_3d()
+			if at == null:
+				at = spatial.get_viewport()
+		else:
+			var window: Window = at as Window
+			if window != null and not window.visible:
+				hiding.append(window)
+			at = null
+	return hiding
+
+
+## Whether [param node] is something drawn and on show, for naming what stands beside a hidden one.
+static func _shown(node: Node) -> bool:
+	var item: CanvasItem = node as CanvasItem
+	if item != null:
+		return item.is_visible_in_tree()
+	var spatial: Node3D = node as Node3D
+	if spatial != null:
+		return spatial.is_visible_in_tree()
+	var layer: CanvasLayer = node as CanvasLayer
+	if layer != null:
+		return layer.visible
+	return false
+
+
 ## Everything in the tree [param root] heads that a pointer can land on: each control on screen
 ## that does not let the pointer through, and each window embedded in another.
 static func _pointer_takers(root: Node) -> Array[Node]:

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

@@ -5,6 +5,7 @@ extends RefCounted
 
 const Menus = preload("runtime_menus.gd")
 const Read = preload("reading.gd")
+const Targets = preload("runtime_targets.gd")
 const Values = preload("runtime_values.gd")
 const Words = preload("runtime_words.gd")
 
@@ -251,7 +252,11 @@ func choose(params: Dictionary) -> Dictionary:
 	if holder != null and holder.disabled:
 		return {"type": "error", "message": "%s is disabled, so its menu cannot be opened" % node_path}
 	if holder != null and not holder.is_visible_in_tree():
-		return {"type": "error", "message": "%s is not visible, so its menu cannot be opened" % node_path}
+		return {
+			"type": "error",
+			"message":
+			"%s is not visible%s, so its menu cannot be opened" % [node_path, Targets.why_hidden(holder)]
+		}
 
 	# Shown first, because a menu nobody has opened has no focus to move and the press would go to
 	# whatever is behind it, and before the item is looked for, because opening is when a game fills

package/build/index.js

@@ -33008,7 +33008,8 @@ function recordAt(path) {
     arguments: Array.isArray(args) ? args.filter((value) => typeof value === "string") : [],
     ...typeof fields["command"] === "string" ? { command: fields["command"] } : {},
     ...typeof fields["exitCode"] === "number" ? { exitCode: fields["exitCode"] } : {},
-    ...typeof fields["exitSignal"] === "string" ? { exitSignal: fields["exitSignal"] } : {}
+    ...typeof fields["exitSignal"] === "string" ? { exitSignal: fields["exitSignal"] } : {},
+    ...typeof fields["endedAt"] === "number" ? { endedAt: fields["endedAt"] } : {}
   };
 }
 async function runningAs(pid) {
@@ -33353,16 +33354,42 @@ function signatureParts(signature) {
 }
 var ms = (seconds) => Math.round(seconds * 1e6) / 1000;
 function profiledFunctions(totals, limit, sourceOf = () => null) {
-  const rows = rowsOf(totals, sourceOf);
-  const scriptMs = ms(Object.values(totals.functions).reduce((sum, one) => sum + (one.calls > 0 ? one.selfSeconds : 0), 0));
+  const perCallUs = perCallCostOf(totals);
+  const rows = rowsOf(totals, sourceOf).map((row) => withOverhead(row, perCallUs));
+  const scriptMs = ms(Object.entries(totals.functions).reduce((sum, [signature, one]) => sum + (one.calls > 0 && !isCalibration(signature) ? one.selfSeconds : 0), 0));
   return {
     functions: rows.slice(0, limit).map((row) => placedLambda(row, sourceOf)),
     omitted: Math.max(0, rows.length - limit),
     scriptMs,
     counted: rows.length,
-    superCallers: rows.filter((row) => row.selfIncludesSuper === true).length
+    superCallers: rows.filter((row) => row.selfIncludesSuper === true).length,
+    perCallUs,
+    overheadDominated: rows.filter((row) => row.overheadMs !== undefined).length
   };
 }
+var RUNTIME_SCRIPT = "gdharness_runtime/runtime_autoload.gd";
+var PROFILER_PROBE = "_profiler_probe";
+var PROFILER_CALIBRATOR = "_calibrate_the_profiler";
+function isCalibration(signature) {
+  const parts = signatureParts(signature);
+  return parts.script.endsWith(RUNTIME_SCRIPT) && (parts.function === PROFILER_PROBE || parts.function === PROFILER_CALIBRATOR);
+}
+function perCallCostOf(totals) {
+  for (const [signature, sum] of Object.entries(totals.functions)) {
+    const parts = signatureParts(signature);
+    if (parts.script.endsWith(RUNTIME_SCRIPT) && parts.function === PROFILER_PROBE && sum.calls > 0) {
+      return Math.round(sum.selfSeconds / sum.calls * 1e9) / 1000;
+    }
+  }
+  return null;
+}
+function withOverhead(row, perCallUs) {
+  if (perCallUs === null || row.selfMs <= 0) {
+    return row;
+  }
+  const overheadMs = Math.round(row.calls * perCallUs) / 1000;
+  return overheadMs >= row.selfMs / 2 ? { ...row, overheadMs: Math.min(overheadMs, row.selfMs) } : row;
+}
 function rowsOf(totals, sourceOf) {
   const codes = new Map;
   const codeOfScript = (script) => {
@@ -33372,7 +33399,7 @@ function rowsOf(totals, sourceOf) {
     }
     return codes.get(script) ?? null;
   };
-  return Object.entries(totals.functions).filter(([, sum]) => sum.calls > 0).map(([signature, sum]) => {
+  return Object.entries(totals.functions).filter(([signature, sum]) => sum.calls > 0 && !isCalibration(signature)).map(([signature, sum]) => {
     const parts = signatureParts(signature);
     const code = codeOfScript(parts.script);
     return {
@@ -34463,7 +34490,7 @@ var TOOL_SPECS = [
       },
       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 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",
+        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. The profiler's own cost of timing a call lands in the self time of the function called; with the runtime addon it is measured each run on an empty function, as perCallOverheadUs, and a row with at least half its selfMs in it carries overheadMs, since a small function called often costs that much less without the profiler. A function the profiler started inside is left out, since its time would be counted from the engine's start. The milliseconds are time passed while the function ran, not processor time given to it, so they grow when other processes compete for the processor: compare two profiles taken under the same load. 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: []
       }
     },
@@ -34471,7 +34498,7 @@ var TOOL_SPECS = [
   },
   {
     name: "editor_output",
-    description: "What the project started by editor_run has printed, as entries with a severity: the errors and warnings the engine reported, each with where it happened, and everything else as info. For a run the editor plays the reports come from the game itself, through the runtime addon, since the editor's debugger relays what a game prints and not what it reports; a played game without the runtime addon answers here with its prints alone, with errorsUnread true and no clean, since what it raised reaches nothing here. Answers with the counts and the verdict as well as the entries. heldAt is three answers: null for a run this server knows is not held, running or over, an object for one it knows is held at a breakpoint, whether the adapter said so or the runtime did by accepting a connection and never answering, and absent with heldUnknown beside it for a server that connected to the debugger after the stop and has no runtime to ask, since the adapter reports a stop only to the sessions connected when it happened. A run that has quit still answers here, with running false and its exit code, until the next one starts; a run ended by a signal has no exit code, and exitSignal names the signal instead. A run this server started also answers with transcript, the file both its streams are written to: uncapped, written while the run is going, and the thing to read or tail for a long run rather than the engine's own log, which every engine start rotates away. Read the file for output and this answer for state: endedBy says whether gdharness ended the run, and a transcript that has stopped growing is a run between prints rather than a run that is over. running is asked of the operating system whenever there is a process to ask about, which is every run this server started and every editor-played run whose game announced its runtime. For an editor-played run that never announced, there is no process id here and running is the editor's answer, which can lag: one measured elsewhere reported a game as playing for fifteen seconds after its process had been ended from outside. editor_status names that game under runtimes, which does not depend on the editor answering. op: \"editor\" answers about the editor itself instead, which is a different log and the only way anything here can read what an editor printed: its console reaches no plugin, so the addon cannot scrape it, and an editor gdharness opened is asked for a log file as it starts. That covers the whole session from the editor's first line, which is where the output worth reading usually is, since the class cache, the plugins and the language server all say what they have to say before any harness has connected. The answer carries the entries in the order they were printed and, beside them under repeated, each message shape several lines share: how many, what varied in each slot of it and how many different values stood there, the first occurrence, and the ordinary lines above the group, found by walking back past the group rather than by counting lines. An editor somebody opened by hand has no console here and is refused saying so rather than answered empty, because an editor that printed nothing and an editor nobody captured are not the same thing.",
+    description: "What the project started by editor_run has printed, as entries with a severity: the errors and warnings the engine reported, each with where it happened, and everything else as info. For a run the editor plays the reports come from the game itself, through the runtime addon, since the editor's debugger relays what a game prints and not what it reports; a played game without the runtime addon answers here with its prints alone, with errorsUnread true and no clean, since what it raised reaches nothing here. Answers with the counts and the verdict as well as the entries. heldAt is three answers: null for a run this server knows is not held, running or over, an object for one it knows is held at a breakpoint, whether the adapter said so or the runtime did by accepting a connection and never answering, and absent with heldUnknown beside it for a server that connected to the debugger after the stop and has no runtime to ask, since the adapter reports a stop only to the sessions connected when it happened. A run that has quit still answers here, with running false and its exit code, until the next one starts; a run ended by a signal has no exit code, and exitSignal names the signal instead. A run this server started also answers with transcript, the file both its streams are written to: uncapped, written while the run is going, and the thing to read or tail for a long run rather than the engine's own log, which every engine start rotates away. Read the file for output and this answer for state: endedBy says whether gdharness ended the run, and a transcript that has stopped growing is a run between prints rather than a run that is over. running is asked of the operating system whenever there is a process to ask about, which is every run this server started and every editor-played run whose game announced its runtime. For an editor-played run that never announced, there is no process id here and running is the editor's answer, which can lag: one measured elsewhere reported a game as playing for fifteen seconds after its process had been ended from outside. editor_status names that game under runtimes, which does not depend on the editor answering. op: \"editor\" answers about the editor itself instead, which is a different log and the only way anything here can read what an editor printed: its console reaches no plugin, so the addon cannot scrape it, and an editor gdharness opened is asked for a log file as it starts. That covers the whole session from the editor's first line, which is where the output worth reading usually is, since the class cache, the plugins and the language server all say what they have to say before any harness has connected. The answer carries the entries in the order they were printed and, beside them under repeated, each message shape several lines share: how many, what varied in each slot of it and how many different values stood there, the first occurrence, and the ordinary lines above the group, found by walking back past the group rather than by counting lines. An editor somebody opened by hand has no console here and is refused saying so rather than answered empty, because an editor that printed nothing and an editor nobody captured are not the same thing. startedAt is when the run began and elapsedMs how long it has been going; for a run that is over, endedAt is when it ended and elapsedMs how long it ran, and both are left out when nobody saw the end, as for a game closed in the editor or a run picked up from a note written before ends were recorded.",
     parameters: {
       severity: {
         type: "string",
@@ -34519,7 +34546,7 @@ var TOOL_SPECS = [
   },
   {
     name: "editor_status",
-    description: "Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and whether a game with the runtime addon is reachable: runtimeConnected counts the games of the project this server serves, and runtimes lists every game on the machine with ofThisProject saying which is which, since a game of another project is reached only by naming its projectPath. playingInEditor is null when the editor was not asked or did not answer, which is not the same as a no: with no editor connected there is nobody to ask, and an editor that does not serve the question is given a moment and then left. A game can be playing while this is null, so read it as unanswered rather than as nothing playing, and use processActive and runtimes, which come from elsewhere and do not depend on the editor answering. 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. It stays named after the run ends, beside processActive false, so editor_output can still read what that run printed; null when there is no run at all. 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.",
+    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. It stays named after the run ends, beside processActive false, so editor_output can still read what that run printed; null when there is no run at all. startedAt says when it began, and endedAt when it ended, wherever something saw the end: a run adopted from a note another server wrote can have ended hours before this server started. 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: []
   },
@@ -35685,6 +35712,24 @@ function foldedScriptErrors(errors) {
 function nonEmpty(lists) {
   return Object.fromEntries(Object.entries(lists).filter(([, list]) => list.length > 0));
 }
+function withoutUidUnder(unminted, paths) {
+  return unminted.map((script) => `res://${script}`).filter((script) => paths.some((path) => script === path || script.startsWith(path.endsWith("/") ? path : `${path}/`)));
+}
+function withUidsMissing(answer, missing) {
+  const content = answer.content.map((part) => ({ ...part }));
+  const last = content.at(-1);
+  try {
+    const parsed = JSON.parse(last?.text ?? "");
+    if (last !== undefined && typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      last.text = answerJson({
+        ...parsed,
+        uidsMissing: missing,
+        uidsNote: `${missing.length === 1 ? "This script has" : "These scripts have"} no .uid sidecar yet: the engine writes one when it imports the project, which a test run does not, so a check that tracks the sidecars fails on ${missing.length === 1 ? "it" : "them"}. project_import refresh_uids writes them.`
+      });
+    }
+  } catch {}
+  return { ...answer, content };
+}
 function withPreviousCut(answer, previous) {
   const content = answer.content.map((part) => ({ ...part }));
   const last = content.at(-1);
@@ -35931,6 +35976,9 @@ function profileAnswer(reading, limit) {
   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.`);
   }
+  if (table.overheadDominated > 0 && table.perCallUs !== null) {
+    notes.push(`The profiler costs about ${table.perCallUs}µs a call in this run, measured on an empty function the runtime addon calls as it goes on, and that time lands in the self time of the function called. ${table.overheadDominated === 1 ? "One function has" : `${table.overheadDominated} functions have`} at least half ${table.overheadDominated === 1 ? "its" : "their"} selfMs in it, under overheadMs: that much of its time is the profiler's and goes once the profiler is off, whether the function is inlined or not. What inlining saves is the call itself, which costs something without the profiler too, not the work inside 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.`);
@@ -35943,6 +35991,7 @@ function profileAnswer(reading, limit) {
     frames: totals.frames,
     coveredMs: reading.coveredMs,
     scriptMs: table.scriptMs,
+    perCallOverheadUs: table.perCallUs ?? undefined,
     functionsCounted: table.counted,
     omitted: table.omitted > 0 ? table.omitted : undefined,
     functions: table.functions,
@@ -37675,11 +37724,14 @@ class GodotServer {
     return ticker;
   }
   async handleRunTests(args) {
-    const answer = await this.runTests(args);
+    const ran = await this.runTests(args);
     const project = this.project(args);
     if (!project.ok || callSignal()?.aborted === true) {
-      return answer;
+      return ran;
     }
+    const paths = testPathsIn(project.value.path, args["path"]);
+    const unminted = paths.ok ? withoutUidUnder(scriptsWithoutUid(project.value.path), paths.value) : [];
+    const answer = unminted.length === 0 ? ran : withUidsMissing(ran, unminted);
     const previous = takeCutTestRun(project.value.path);
     return previous === null ? answer : withPreviousCut(answer, previous);
   }
@@ -38378,7 +38430,9 @@ class GodotServer {
     return {
       pid: run.pid ?? this.announcedPidOf(run) ?? run.announcedPid ?? null,
       ...run.throughEditor || run.projectPath === null ? {} : { project: run.projectPath },
-      ...run.pickedUp === true ? { adopted: true } : {}
+      ...run.pickedUp === true ? { adopted: true } : {},
+      startedAt: new Date(run.startedAt).toISOString(),
+      ...run.endedAt === undefined ? {} : { endedAt: new Date(run.endedAt).toISOString() }
     };
   }
   async handleEditorStatus() {
@@ -39151,10 +39205,11 @@ class GodotServer {
         return "unreached";
       }
       running.endedThrough = "editor";
-      if (announced === undefined) {
-        return await this.untilTheEditorStopsPlaying() ? "gone" : "lingering";
+      const stopped = announced === undefined ? await this.untilTheEditorStopsPlaying() : await untilGone([announced]);
+      if (stopped) {
+        running.endedAt = Date.now();
       }
-      return await untilGone([announced]) ? "gone" : "lingering";
+      return stopped ? "gone" : "lingering";
     }
     if (running.pid === null) {
       return "gone";
@@ -39203,6 +39258,7 @@ class GodotServer {
     if (landed && gone) {
       running.exitCode = null;
       running.exitSignal = "SIGTERM";
+      running.endedAt ??= Date.now();
     }
     if (landed) {
       running.endedThrough = "signal";
@@ -39227,6 +39283,7 @@ class GodotServer {
     if (asked === "signalled" && gone) {
       run.exitCode = null;
       run.exitSignal = "SIGTERM";
+      run.endedAt ??= Date.now();
     }
     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";
@@ -39274,6 +39331,7 @@ class GodotServer {
       this.logDebug(`Godot process exited with code ${code ?? "none"}, signal ${signal ?? "none"}`);
       started.exitCode = code;
       started.exitSignal = code === null ? signal : null;
+      started.endedAt = Date.now();
     });
     child.on("error", (err) => {
       console.error("Failed to start Godot process:", err);
@@ -39588,6 +39646,9 @@ class GodotServer {
       adopted.log.finish();
       adopted.exitCode = record.exitCode ?? null;
       adopted.exitSignal = record.exitSignal ?? null;
+      if (record.endedAt !== undefined) {
+        adopted.endedAt = record.endedAt;
+      }
       const exitMayBeComing = !alive(record.pid) && !exited(adopted);
       if (!exitMayBeComing) {
         adopted.endedUnwatched = !exited(adopted);
@@ -39881,6 +39942,9 @@ class GodotServer {
       if (record !== null && record.pid === run.pid && (record.exitCode !== undefined || record.exitSignal !== undefined)) {
         run.exitCode = record.exitCode ?? null;
         run.exitSignal = record.exitSignal ?? null;
+        if (record.endedAt !== undefined) {
+          run.endedAt = record.endedAt;
+        }
         return true;
       }
       if (Date.now() >= until) {
@@ -40027,7 +40091,8 @@ class GodotServer {
       project: run.throughEditor ? undefined : run.projectPath ?? undefined,
       transcript: run.transcript ?? undefined,
       startedAt: new Date(run.startedAt).toISOString(),
-      elapsedMs: Date.now() - run.startedAt,
+      endedAt: stillRunning(run) || run.endedAt === undefined ? undefined : new Date(run.endedAt).toISOString(),
+      elapsedMs: stillRunning(run) ? Date.now() - run.startedAt : run.endedAt === undefined ? undefined : run.endedAt - run.startedAt,
       cpuSeconds,
       note: notes.length > 0 ? notes.join(" ") : undefined,
       omitted: selected.omitted,

package/build/keeper.js

@@ -421,7 +421,8 @@ function recordRunEnded(projectPath, pid, ending) {
   const written = {
     ...record,
     ...ending.exitCode === null ? {} : { exitCode: ending.exitCode },
-    ...ending.exitSignal === null ? {} : { exitSignal: ending.exitSignal }
+    ...ending.exitSignal === null ? {} : { exitSignal: ending.exitSignal },
+    endedAt: Date.now()
   };
   try {
     writeFileSync2(path, JSON.stringify(written, null, 2), "utf8");
@@ -457,7 +458,8 @@ function recordAt(path) {
     arguments: Array.isArray(args) ? args.filter((value) => typeof value === "string") : [],
     ...typeof fields["command"] === "string" ? { command: fields["command"] } : {},
     ...typeof fields["exitCode"] === "number" ? { exitCode: fields["exitCode"] } : {},
-    ...typeof fields["exitSignal"] === "string" ? { exitSignal: fields["exitSignal"] } : {}
+    ...typeof fields["exitSignal"] === "string" ? { exitSignal: fields["exitSignal"] } : {},
+    ...typeof fields["endedAt"] === "number" ? { endedAt: fields["endedAt"] } : {}
   };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdharness",
-  "version": "1.1.62",
+  "version": "1.2.1",
   "mcpName": "io.github.Aureliolo/gdharness",
   "description": "A harness for driving a Godot 4 project from an agent: editor addons, a runtime bridge into the running game, an MCP server in front of them, and a CLI that installs and diagnoses the Godot side.",
   "type": "module",