gdharness 1.3.24 → 1.3.25

package/build/cli.js

@@ -12155,7 +12155,16 @@ function announced(line) {
   };
 }
 function reported(entry) {
-  return entry.detail.length === 0 ? { index: entry.index, severity: entry.severity, source: entry.source, text: entry.text } : { ...entry, detail: framesCollapsed(entry.detail) };
+  return entry.detail.length === 0 ? { index: entry.index, severity: entry.severity, source: entry.source, text: entry.text } : { ...entry, ...scriptRaising(entry.detail), detail: framesCollapsed(entry.detail) };
+}
+function scriptRaising(detail) {
+  for (const line of detail) {
+    const match = LOCATION2.exec(line);
+    if (match?.[1] !== undefined && match[2] !== undefined && match[3] !== undefined) {
+      return { script: match[2], line: Number(match[3]), function: match[1] };
+    }
+  }
+  return {};
 }
 function framesCollapsed(detail) {
   const out = [];
@@ -12370,7 +12379,7 @@ function answersTo(entry, severity, contains) {
   const needle = contains.toLowerCase();
   return [entry.text, ...entry.detail].some((line) => line.toLowerCase().includes(needle));
 }
-var HEADLINE, CRASH, CRASH_FILLER, COLOUR_CODE, STREAMS, ADMITTED, FRAME, LONGEST_CYCLE = 64;
+var HEADLINE, CRASH, CRASH_FILLER, COLOUR_CODE, STREAMS, ADMITTED, LOCATION2, FRAME, LONGEST_CYCLE = 64;
 var init_game_log = __esm(() => {
   HEADLINE = /^(USER )?(SCRIPT ERROR|SHADER ERROR|ERROR|WARNING):\s?(.*)$/;
   CRASH = /^(?:CrashHandlerException|handle_crash): Program crashed with signal \d+/;
@@ -12382,6 +12391,7 @@ var init_game_log = __esm(() => {
     warning: new Set(["error", "warning"]),
     info: new Set(["error", "warning", "info"])
   };
+  LOCATION2 = /^(?:at: |\[\d+\] )(.+) \((res:\/\/.+):(\d+)\)$/;
   FRAME = /^\[(\d+)\] (.+)$/;
 });
 
@@ -16478,7 +16488,7 @@ var init_tool_definitions = __esm(() => {
       name: "project_test",
       title: "Run tests",
       effect: "additive",
-      description: "Runs the project's gdUnit4 tests and answers with every case that did not pass: where it is, and what the assertion said. Each entry under failed carries its first report as message and detail, and, when it has more than one, its reports under reports in the order the case met them: gdUnit4 goes on past a failed assertion, and a case can fail several and then stop on a runtime error, which makes its status error. Identical reports fold into one with times, at most twenty different ones are kept (reportsLeftOut counts the rest), and past about a megabyte the largest cases keep only their first message (failedWithoutDetail). failures counts the cases that failed an assertion and errors the cases that hit an error, so such a case counts in both. Suites where everything passed are counted, not listed, and an engine message keeps the frames above gdUnit4, not the twenty inside it; identical engine messages come back once under engineEntries, with times saying how often they were printed. The class list is rebuilt first, so a suite written a moment ago is found, and the rebuild's answer is under classes. What changed on disk since it was imported is then imported before any suite runs, and named under importedFirst. On Windows and Linux the run gets a user:// of its own, away from a player's saves; on macOS the engine reads user:// off HOME, so it writes where the player keeps theirs, and savesNote says so. The run is headless unless a suite in it needs a window as gdharness test reads it, and then has one, on a desktop of its own on Windows. A run that found nothing to run is never called a pass, and names the path it looked in. A script that does not load stops gdUnit4 before any suite runs: its errors come back in full under scriptErrors, and the scripts that failed only because one they depend on did are listed by path under failedThroughDependency. When they failed on a class whose own script has a parser error, which gdUnit4 never names, that script is checked by the engine and its error comes first under scriptErrors, with the class it declares under declares, and the errors a script has only because that class did not resolve, which the engine reads as Variant, are kept apart under followFromUnresolved. An autoload that does not compile stops the run at once, its errors listed the same way. A client sending a progress token is told as each suite finishes, and at least every twenty seconds. A run that ends without a report, at its timeout or otherwise, names the suites it finished under suitesFinished, the failing ones with their failed cases under suitesFailing, and the one it was in under suiteRunning. When a client cuts a run off, that is kept in the project and the next project_test there carries it under previousRunCut. A run where nothing failed but orphan nodes were left comes back under warnings, with the count per suite: gdUnit4 decides its verdict on those and keeps them out of its report, so they are read off what it printed. A run whose every case passed is still not called passed when it printed a script error that no case failed on: gdUnit4 fails a case on the script errors its logger sees, and it cannot see a stack overflow, so the cases pass on whatever the faulted calls returned. Those errors come back under uncaughtScriptErrors, and under engineEntries by index with detailUnder rather than with their backtrace a second time; a backtrace that repeats, as a recursion's does, has each repeated frame or cycle of frames written once with the frames it covers and how many times. One raised inside assert_error(...).is_runtime_error is the test's own and is not listed there, and none are when the project turns off gdUnit4's report/godot/script_error setting; a suite declares them all the same. Needs gdUnit4 under addons/gdUnit4.",
+      description: "Runs the project's gdUnit4 tests and answers with every case that did not pass: where it is, and what the assertion said. Each entry under failed carries its first report as message and detail, and, when it has more than one, its reports under reports in the order the case met them: gdUnit4 goes on past a failed assertion, and a case can fail several and then stop on a runtime error, which makes its status error. Identical reports fold into one with times, at most twenty different ones are kept (reportsLeftOut counts the rest), and past about a megabyte the largest cases keep only their first message (failedWithoutDetail). failures counts the cases that failed an assertion and errors the cases that hit an error, so such a case counts in both. Suites where everything passed are counted, not listed, and an engine message keeps the frames above gdUnit4, not the twenty inside it; identical engine messages come back once under engineEntries, with times saying how often they were printed, and with script, line and function for the project script one points at, as editor_output's entries have. The class list is rebuilt first, so a suite written a moment ago is found, and the rebuild's answer is under classes. What changed on disk since it was imported is then imported before any suite runs, and named under importedFirst. On Windows and Linux the run gets a user:// of its own, away from a player's saves; on macOS the engine reads user:// off HOME, so it writes where the player keeps theirs, and savesNote says so. The run is headless unless a suite in it needs a window as gdharness test reads it, and then has one, on a desktop of its own on Windows. A run that found nothing to run is never called a pass, and names the path it looked in. A script that does not load stops gdUnit4 before any suite runs: its errors come back in full under scriptErrors, and the scripts that failed only because one they depend on did are listed by path under failedThroughDependency. When they failed on a class whose own script has a parser error, which gdUnit4 never names, that script is checked by the engine and its error comes first under scriptErrors, with the class it declares under declares, and the errors a script has only because that class did not resolve, which the engine reads as Variant, are kept apart under followFromUnresolved. An autoload that does not compile stops the run at once, its errors listed the same way. A client sending a progress token is told as each suite finishes, and at least every twenty seconds. A run that ends without a report, at its timeout or otherwise, names the suites it finished under suitesFinished, the failing ones with their failed cases under suitesFailing, and the one it was in under suiteRunning. When a client cuts a run off, that is kept in the project and the next project_test there carries it under previousRunCut. A run where nothing failed but orphan nodes were left comes back under warnings, with the count per suite: gdUnit4 decides its verdict on those and keeps them out of its report, so they are read off what it printed. A run whose every case passed is still not called passed when it printed a script error that no case failed on: gdUnit4 fails a case on the script errors its logger sees, and it cannot see a stack overflow, so the cases pass on whatever the faulted calls returned. Those errors come back under uncaughtScriptErrors, and under engineEntries by index with detailUnder rather than with their backtrace a second time; a backtrace that repeats, as a recursion's does, has each repeated frame or cycle of frames written once with the frames it covers and how many times. One raised inside assert_error(...).is_runtime_error is the test's own and is not listed there, and none are when the project turns off gdUnit4's report/godot/script_error setting; a suite declares them all the same. Needs gdUnit4 under addons/gdUnit4.",
       answer: "passed is the verdict to read. exitCode is the engine's own exit, gdUnit4's code for what it saw, and is 0 beside passed false when the run is failed for something gdUnit4 does not judge, such as an engine error no suite declared. time is gdUnit4's own sum of the seconds its cases took, from its report. tookMs is the whole call in milliseconds, from the class rebuild to the engine's exit, which is what a caller waits for, and tookMsBy splits it into the class rebuild (classes), the import after it (import) and the engine running the suites (engine), each with any wait for an engine slot or the editor's scan in it. The run is judged as gdharness test judges it: undeclaredErrors names each engine error that no suite declared in its GDHARNESS_EXPECTED_ERRORS constant, and each engine warning a suite printed and did not declare in its GDHARNESS_EXPECTED_WARNINGS, marked warning true, with the suite and the case that printed it, and declaredNotPrinted each declared error or warning its case did not print. A declared text must be the whole line after ERROR: or WARNING: and its space, so a longer one its case printed holding the text is named under printedInstead. Either fails the run, and each suite holding one is listed with its count. leakedAtExit holds the engine's lines saying it exited still holding objects, resources, memory pages or a server's RIDs, which fail the run too, and the note names any script of the project Godot itself never frees. engineErrors counts every engine error the run printed but those a suite declared. orphans totals the orphan nodes gdUnit4 counted, and each suite that left some has its count, and a warning saying how to free them, under warnings, with left naming each case that left some (before or after for one of the suite's hooks, or the one value \"before or after\" where no case began and the two cannot be told apart) and the nodes, by class, name and script. suites lists only the suites with something to say (a case that failed, erred or was skipped, a hook that failed, orphans, or an error undeclared or declared and not printed), and suitesPassed counts the rest. Under classes, the classes each addon declares are counted under addedInAddons and changedInAddons rather than named, and a class the rebuild puts back that the cache had after the last rebuild is named under classes.lostSinceLastRebuild, which is the editor writing its shorter list over the file on every save until restarted. A suite needs a window when it declares const GDHARNESS_NEEDS_WINDOW: bool = true, or calls scene_runner and declares nothing; a run holding one has a window, at the size project.godot gives its viewport and with no sound, and windowed is true and windowNote names those suites and any saying it runs headless that shared the window. On a machine with no display such a run is headless, windowed is false, and windowNote says so. " + IMPORTED_FIRST,
       parameters: {
         projectPath: PROJECT_PATH,
@@ -17322,14 +17332,14 @@ var init_tool_definitions = __esm(() => {
           requires: []
         }
       },
-      answer: "start: through is gdharness for a game this server started itself, and editor for one the editor plays. scene is the scene the game started in, the project's main scene when none was given. runtime carries addonIsStale and staleNote when the game announced on a runtime addon other than this server's, which no runtime_* call is then sent to, and staleNote says what brings it into step. refreshedClasses names the class_name declarations on disk that the engine's class cache was missing, which were added to it before the game started so the game could resolve them; it is empty when the cache was current. stop: endedPid is, for a run the editor plays, the number its game announced under, read at the stop rather than remembered, and the operating system hands a freed number to the next process, so it can equal the game before it. stopped is false, with the number under notSignalled, when that number no longer answers as the process the run was started as and nothing was signalled, the note naming which property it failed on, and false with the number under stillGoing when what was told to end was still running ten seconds later. endedThrough says how the stop ended a run that was going: close (the game was asked to close and exited, so exitCode is its own), keeper (the process that started the game ended it through the handle it holds), signal (its pid was signalled once shown to still be the run), or editor (the editor playing it was asked). exitedBeforeStop is true when the run was already over when the stop came, so nothing was ended and exitCode, when anything collected it, is the one it ended with. A start that ends the run before it says how under endedPreviousRunThrough, with the same values, and one that refused to signal that run names the property it failed on under previousRunLeftBecause. check: hung is a run killed at timeoutMs, and errors and warnings count what it printed, which comes back under entries with repeats folded together. entries holds the errors and warnings and not the ordinary lines the run printed, which printedLinesNotShown counts; a check given --verbose holds those too, and editor_run start then editor_output reads everything. An engine crash is an error whatever it prints after: the crash handler's report is the entry, and the engine version and the native and GDScript backtraces are its detail, so a crashed run is never booted or clean. arguments is the engine command line the check ran, as a start's is, and durationMs runs from that engine's start to the check's answer, after its exit, so it holds no import that came first. start and check: " + IMPORTED_FIRST + " An exported build carries its own imports and is not asked. waitedForEditorScanMs and scanNote are left out when no editor scan was waited for. A silent windowed run has --audio-driver Dummy in its arguments; a headless run is silent without it, and one the editor plays with sound has no arguments of its own. profile: per function its script, the function (Class.name when the script declares a class_name), the line its body's first statement is on, for a lambda the named function it is written in (within), calls, and self and total milliseconds, with functionsCounted, scriptMs (the self time of them all) and coveredMs. The runtime addon's own functions, gdharness answering its tools inside the game, are not among them: their self time is runtimeAddonMs, over runtimeAddonFunctions functions. complete is true when the engine's own totals arrived, which it sends only when the profiler is switched off: the runtime addon does that as a game quits, so a scene that does its work in _ready and quits is covered whole; otherwise the answer is the frames summed so far and the note says what that misses. frames counts the frames of the profile that arrived, and the engine's totals also hold the work after the last of them, so once complete a function run every frame can show a call more than frames. Self time counts a call into the engine's own methods as the caller's, and a call through super too, while the overridden function's row counts it again: such a row carries selfIncludesSuper, so self times along an override chain overlap. The profiler's own cost of timing a call lands in the self time of the function called; with the runtime addon it is measured each run on an empty function, as perCallOverheadUs, and a row with at least half its selfMs in it carries overheadMs, since a small function called often costs that much less without the profiler. A function the profiler started inside is left out, since its time would be counted from the engine's start. The milliseconds are time passed while the function ran, not processor time given to it, so they grow when other processes compete for the processor: compare two profiles taken under the same load. They are also summed over every thread: a function run by WorkerThreadPool or a Thread on several threads at once counts each thread's time, the engine does not say which thread a call ran on, and a function waiting for them has the wait in its own self time, so selfMs is not time taken from frames, and scriptMs can exceed coveredMs, which the note then says. A property's get and set blocks are named Class.@name_getter and Class.@name_setter, as the engine names them, and their rows carry property, the property's name. A game the editor plays that was not started with profile: true says, in the answer, that it was profiled from the moment it was asked. A profile with mark answers marked: true; one with since answers since: \"mark\" and markSetMsAgo, and lessThanAtMark counts the functions left out for reading less than at the mark, which the engine's own totals, capped, can do when they replace the frames' sum.",
+      answer: "start: through is gdharness for a game this server started itself, and editor for one the editor plays. scene is the scene the game started in, the project's main scene when none was given. runtime carries addonIsStale and staleNote when the game announced on a runtime addon other than this server's, which no runtime_* call is then sent to, and staleNote says what brings it into step. refreshedClasses names the class_name declarations on disk that the engine's class cache was missing, which were added to it before the game started so the game could resolve them; it is empty when the cache was current. stop: endedPid is, for a run the editor plays, the number its game announced under, read at the stop rather than remembered, and the operating system hands a freed number to the next process, so it can equal the game before it. stopped is false, with the number under notSignalled, when that number no longer answers as the process the run was started as and nothing was signalled, the note naming which property it failed on, and false with the number under stillGoing when what was told to end was still running ten seconds later. endedThrough says how the stop ended a run that was going: close (the game was asked to close and exited, so exitCode is its own), keeper (the process that started the game ended it through the handle it holds), signal (its pid was signalled once shown to still be the run), or editor (the editor playing it was asked). exitedBeforeStop is true when the run was already over when the stop came, so nothing was ended and exitCode, when anything collected it, is the one it ended with. A start that ends the run before it says how under endedPreviousRunThrough, with the same values, and one that refused to signal that run names the property it failed on under previousRunLeftBecause. check: hung is a run killed at timeoutMs, and errors and warnings count what it printed, which comes back under entries with repeats folded together. entries holds the errors and warnings and not the ordinary lines the run printed, which printedLinesNotShown counts; a check given --verbose holds those too, and editor_run start then editor_output reads everything. An engine crash is an error whatever it prints after: the crash handler's report is the entry, and the engine version and the native and GDScript backtraces are its detail, so a crashed run is never booted or clean. arguments is the engine command line the check ran, as a start's is, and durationMs runs from that engine's start to the check's answer, after its exit, so it holds no import that came first. start and check: " + IMPORTED_FIRST + " An exported build carries its own imports and is not asked. waitedForEditorScanMs and scanNote are left out when no editor scan was waited for. A silent windowed run has --audio-driver Dummy in its arguments; a headless run is silent without it, and one the editor plays with sound has no arguments of its own. profile: per function its script, the function (Class.name when the script declares a class_name), the line its body's first statement is on, for a lambda the named function it is written in (within), calls, and self and total milliseconds, with functionsCounted, scriptMs (the self time of them all) and coveredMs. The functions of gdharness's own runtime are not among them: the runtime addon's, which answer its tools inside the game, and those of res://gdharness/loader.gd, which starts it. Their self time is runtimeAddonMs, over runtimeAddonFunctions functions. complete is true when the engine's own totals arrived, which it sends only when the profiler is switched off: the runtime addon does that as a game quits, so a scene that does its work in _ready and quits is covered whole; otherwise the answer is the frames summed so far and the note says what that misses. frames counts the frames of the profile that arrived, and the engine's totals also hold the work after the last of them, so once complete a function run every frame can show a call more than frames. Self time counts a call into the engine's own methods as the caller's, and a call through super too, while the overridden function's row counts it again: such a row carries selfIncludesSuper, so self times along an override chain overlap. The profiler's own cost of timing a call lands in the self time of the function called; with the runtime addon it is measured each run on an empty function, as perCallOverheadUs, and a row with at least half its selfMs in it carries overheadMs, since a small function called often costs that much less without the profiler. A function the profiler started inside is left out, since its time would be counted from the engine's start. The milliseconds are time passed while the function ran, not processor time given to it, so they grow when other processes compete for the processor: compare two profiles taken under the same load. They are also summed over every thread: a function run by WorkerThreadPool or a Thread on several threads at once counts each thread's time, the engine does not say which thread a call ran on, and a function waiting for them has the wait in its own self time, so selfMs is not time taken from frames, and scriptMs can exceed coveredMs, which the note then says. A property's get and set blocks are named Class.@name_getter and Class.@name_setter, as the engine names them, and their rows carry property, the property's name. A game the editor plays that was not started with profile: true says, in the answer, that it was profiled from the moment it was asked. A profile with mark answers marked: true; one with since answers since: \"mark\" and markSetMsAgo, and lessThanAtMark counts the functions left out for reading less than at the mark, which the engine's own totals, capped, can do when they replace the frames' sum.",
       defaultOperation: "start"
     },
     {
       name: "editor_output",
       title: "Game and 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. A run answers with counts and a verdict: clean is true when no error was reported, and warnings, counted beside it, do not make it false. 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 reported a game as playing fifteen seconds after its process was 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, where the output worth reading usually is, since the class cache, the plugins and the language server speak before any harness connects. It answers counts with no clean, since an editor neither passes nor fails, 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.",
-      answer: "Each entry's source says where it was read: transcript for a line of the run's transcript file, which holds both its streams and is how every run with one is read; stdout or stderr for a line of that stream of a run with no transcript, such as an editor-played run picked up after a reconnect whose first server left no note; debugger for what the editor's debug adapter reported and the game never printed, such as the script error a game stopped on. A printerr line is info: it prints to stderr, and the engine reports no error for it. For op editor with no editor connected, connected is false, editorRunning says whether the editor whose console it is still runs, and editorNote whether this server closed it or it went without a close, as a crash does; the next editor gdharness opens on the project starts a new console.",
+      answer: "An entry with lines under its headline has them as detail, and, when one of them names a project script, script, line and function say where: the at: line when it names one, otherwise the innermost frame of the backtrace that does. A push_error or push_warning has the engine's own push_error as its at: line, so its script and line are the game's call that raised it. Each entry's source says where it was read: transcript for a line of the run's transcript file, which holds both its streams and is how every run with one is read; stdout or stderr for a line of that stream of a run with no transcript, such as an editor-played run picked up after a reconnect whose first server left no note; debugger for what the editor's debug adapter reported and the game never printed, such as the script error a game stopped on. A printerr line is info: it prints to stderr, and the engine reports no error for it. For op editor with no editor connected, connected is false, editorRunning says whether the editor whose console it is still runs, and editorNote whether this server closed it or it went without a close, as a crash does; the next editor gdharness opens on the project starts a new console.",
       parameters: {
         projectPath: {
           type: "string",
@@ -48238,7 +48248,8 @@ function profiledFunctions(totals, limit, sourceOf = () => null) {
   };
 }
 function isRuntimeAddon(signature) {
-  return signatureParts(signature).script.startsWith(RUNTIME_ADDON2);
+  const { script } = signatureParts(signature);
+  return script.startsWith(RUNTIME_ADDON2) || script === RUNTIME_LOADER;
 }
 function isCalibration(signature) {
   const parts = signatureParts(signature);
@@ -48279,12 +48290,15 @@ function totalsSince(now, mark) {
     }
   }
   shrunk += Object.keys(mark.functions).filter((signature) => now.functions[signature] === undefined && (mark.functions[signature]?.calls ?? 0) > 0).length;
+  const { dropped: droppedInAll, ...kept } = now;
+  const dropped = (droppedInAll ?? 0) - (mark.dropped ?? 0);
   return {
     totals: {
-      ...now,
+      ...kept,
       frames: now.frames - mark.frames,
       unreadable: Math.max(0, now.unreadable - mark.unreadable),
       ...now.cappedFrames === undefined ? {} : { cappedFrames: Math.max(0, now.cappedFrames - (mark.cappedFrames ?? 0)) },
+      ...dropped > 0 ? { dropped } : {},
       functions
     },
     shrunk
@@ -48391,13 +48405,15 @@ function callersOf(totals, name, scripts) {
     property
   };
 }
-var QUEUE_SETTING = "limits/debugger/max_queued_messages", QUEUE_DEFAULT = 2048, QUEUE_HEADROOM = 512, UNNAMED_PREFIX = "#", PROFILE_FROM_START = "GDHARNESS_PROFILE_FROM_START", ms = (seconds) => Math.round(seconds * 1e6) / 1000, RUNTIME_SCRIPT2 = "gdharness_runtime/runtime_autoload.gd", PROFILER_PROBE = "_profiler_probe", PROFILER_CALIBRATOR = "_calibrate_the_profiler", CALL_SITES = 40;
+var QUEUE_SETTING = "limits/debugger/max_queued_messages", QUEUE_DEFAULT = 2048, QUEUE_HEADROOM = 512, UNNAMED_PREFIX = "#", PROFILE_FROM_START = "GDHARNESS_PROFILE_FROM_START", ms = (seconds) => Math.round(seconds * 1e6) / 1000, RUNTIME_SCRIPT2 = "gdharness_runtime/runtime_autoload.gd", PROFILER_PROBE = "_profiler_probe", PROFILER_CALIBRATOR = "_calibrate_the_profiler", RUNTIME_LOADER, CALL_SITES = 40;
 var init_script_profile = __esm(() => {
   init_game_debugger();
   init_gdscript_source();
   init_godot_variant();
   init_resources();
+  init_setup();
   init_whole_file();
+  RUNTIME_LOADER = `res://${RUNTIME_AUTOLOAD.path}`;
 });
 
 // src/server-instructions.ts
@@ -49745,7 +49761,9 @@ function profileAnswer(reading, limit) {
   const table = profiledFunctions(totals, limit, reading.sourceOf);
   const notes = [];
   const addonNote = reading.runtimeAddon === true ? "" : reading.runtimeAddon === null ? " The run's project is no longer at its path, so whether it had the gdharness runtime addon, which switches the profiler off as the game quits so the engine sends its totals, cannot be read." : " 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.";
-  const totalsWithheld = reading.runtimeAddon === true ? " 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;
+  const dropped = totals.dropped ?? 0;
+  const droppedNote = dropped > 0 ? ` The game's debugger queue dropped ${dropped === 1 ? "one message" : `${dropped} messages`}, the engine reported, and those can be a frame or the totals: the queue holds as many as the project's network/limits/debugger/max_queued_messages, and raising it makes room.` : "";
+  const totalsWithheld = dropped > 0 ? droppedNote : reading.runtimeAddon === true ? " 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) {
@@ -49768,7 +49786,7 @@ function profileAnswer(reading, limit) {
     notes.push(`scriptMs, ${table.scriptMs}ms, is more than the ${reading.coveredMs}ms the profile covers.${table.superCallers > 0 ? " The super calls above, counted twice, can account for some or all of that; whatever they do not is" : " One thread cannot spend more time than passes, so that is"} functions running on several threads at once, through WorkerThreadPool or Thread. The engine adds every thread's time to the same function and does not say which thread a call ran on, so a function's selfMs is summed over every thread it ran on rather than taken out of frames, and a function that waits for the others, through wait_for_group_task_completion or wait_to_finish, has the wait in its own selfMs as well.`);
   }
   if (table.addonFunctions > 0) {
-    notes.push(`The gdharness runtime addon's own functions took ${table.addonMs}ms of self time over ${table.addonFunctions === 1 ? "one function" : `${table.addonFunctions} functions`}, answering tools such as runtime_invoke and sending the profile. They are left out of functions, functionsCounted and scriptMs and summed under runtimeAddonMs, since they are not the game's work, though that time was spent in the game's frames.`);
+    notes.push(`The gdharness runtime's own functions, its addon's and those of the loader that starts it, took ${table.addonMs}ms of self time over ${table.addonFunctions === 1 ? "one function" : `${table.addonFunctions} functions`}, starting the runtime as the game starts, answering tools such as runtime_invoke and sending the profile. They are left out of functions, functionsCounted and scriptMs and summed under runtimeAddonMs, since they are not the game's work, though that time was spent in the game's process.`);
   }
   notes.push(...cappedNotes(totals));
   if (totals.unreadable > 0) {

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

@@ -10,18 +10,60 @@ extends Node
 ## wanted. Both directions of the socket carry one JSON object per line. Every request names an
 ## id and the reply carries it back.
 
-const GdhAccessibility = preload("runtime_accessibility.gd")
-const GdhCapture = preload("runtime_capture.gd")
-const GdhChanges = preload("runtime_changes.gd")
 const GdhErrorReport = preload("error_report.gd")
-const GdhInputCommands = preload("runtime_input.gd")
-const GdhPad = preload("runtime_pad.gd")
-const GdhQueries = preload("runtime_queries.gd")
+const GdhFrames = preload("runtime_frames.gd")
 const GdhRead = preload("reading.gd")
-const GdhTargets = preload("runtime_targets.gd")
-const GdhTyping = preload("runtime_typing.gd")
-const GdhValues = preload("runtime_values.gd")
-const GdhWaits = preload("runtime_waits.gd")
+
+## Where the modules are loaded from. Kept in step with the markers below.
+const ADDON_DIR: String = "res://addons/gdharness_runtime/"
+
+## The modules that answer commands, loaded at the first command one answers rather than preloaded.
+## A preload compiles as this script parses, and the modules are twelve thousand lines: compiling
+## them took most of a second of every debug start, in games nobody asks anything, a bench's quiet
+## workers and script runs among them.
+const QUERIES: String = "runtime_queries.gd"
+const CHANGES: String = "runtime_changes.gd"
+const INPUT: String = "runtime_input.gd"
+const TYPING: String = "runtime_typing.gd"
+const PAD: String = "runtime_pad.gd"
+const CAPTURE: String = "runtime_capture.gd"
+const WAITS: String = "runtime_waits.gd"
+const ACCESSIBILITY: String = "runtime_accessibility.gd"
+const VALUES: String = "runtime_values.gd"
+
+## Every module command, by the name a request uses, as the module and the method that answers it.
+const MODULE_COMMANDS: Dictionary = {
+	"get_tree": [QUERIES, "get_tree"],
+	"find_nodes": [QUERIES, "find_nodes"],
+	"read_text": [QUERIES, "read_text"],
+	"get_rect": [QUERIES, "get_rect"],
+	"get_property": [QUERIES, "get_property"],
+	"set_property": [CHANGES, "set_property"],
+	"call_method": [CHANGES, "call_method"],
+	"get_metrics": [QUERIES, "get_metrics"],
+	"get_accessibility": [ACCESSIBILITY, "get_accessibility"],
+	"capture_screenshot": [CAPTURE, "capture_screenshot"],
+	"capture_viewport": [CAPTURE, "capture_viewport"],
+	"inject_action": [INPUT, "inject_action"],
+	"inject_key": [INPUT, "inject_key"],
+	"inject_text": [TYPING, "inject_text"],
+	"inject_mouse_click": [INPUT, "inject_mouse_click"],
+	"inject_mouse_motion": [INPUT, "inject_mouse_motion"],
+	"inject_mouse_drag": [INPUT, "inject_mouse_drag"],
+	"inject_joypad_button": [PAD, "inject_joypad_button"],
+	"inject_joypad_motion": [PAD, "inject_joypad_motion"],
+	"click": [INPUT, "click"],
+	"choose": [TYPING, "choose"],
+	"wait_frames": [WAITS, "wait_frames"],
+	"wait_signal": [WAITS, "wait_signal"],
+	"watch_signal": [WAITS, "watch_signal"],
+	"watch_recorded": [WAITS, "recorded"],
+	"wait_until": [WAITS, "wait_until"],
+}
+
+## The size the engine gives a headless game's root viewport. Kept in step with
+## `HEADLESS_VIEWPORT` in runtime_targets.gd, which this script does not load as it starts.
+const HEADLESS_VIEWPORT: Vector2 = Vector2(64, 64)
 
 const PROTOCOL: int = 3
 const DEFAULT_BIND_ADDRESS: String = "127.0.0.1"
@@ -38,10 +80,14 @@ const PROFILE_CAPTURE: String = "gdharness"
 const PROFILE_SENT: String = "gdharness:profile_sent"
 const PROFILE_RECEIVED: String = "gdharness:profile_received"
 
-## The longest a quitting game waits for that answer. A debugger that never gives one, such as an
-## editor without the gdharness addon, holds every profiled exit this long.
+## The longest a quitting game waits for that answer from a debugger that may not give one, such as
+## an editor without the gdharness addon, which holds every profiled exit this long.
 const PROFILE_CONFIRM_MS: int = 3000
 
+## The longest it waits for a debugger gdharness gave it, which answers once it has read that far:
+## long enough for one far behind, and an end for one that has hung.
+const PROFILE_ANSWERED_MS: int = 60000
+
 ## 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
@@ -100,19 +146,20 @@ const ERROR_REPORT_NAME: String = "runtime-%d.log"
 const VERSION_MARKER: String = "res://addons/gdharness_runtime/.gdharness-version"
 const DIGEST_MARKER: String = "res://addons/gdharness_runtime/.gdharness-digest"
 
-var values: GdhValues = GdhValues.new()
-
-# The modules are members and not locals of _init, because a Callable holds its object by id
-# rather than by reference, and a module referenced only by the Callables in the command table
-# would be freed on the way out of _init, leaving every command "unknown".
-var _queries: GdhQueries = GdhQueries.new(self, values)
-var _changes: GdhChanges = GdhChanges.new(self, values)
-var _input: GdhInputCommands = GdhInputCommands.new(self, values)
-var _typing: GdhTyping = GdhTyping.new(self)
-var _pad: GdhPad = GdhPad.new(self)
-var _capture: GdhCapture = GdhCapture.new(self, values)
-var _waits: GdhWaits = GdhWaits.new(self, values)
-var _accessibility: GdhAccessibility = GdhAccessibility.new(self)
+## The values module every other module reads and writes values with, one for them all, loaded with
+## the first of them.
+var values: RefCounted:
+	get:
+		if _values == null:
+			_values = _loaded(VALUES).new()
+		return _values
+
+var _values: RefCounted
+var _frames: GdhFrames = GdhFrames.new()
+## Each module loaded so far, by its file. Held here because a Callable holds its object by id
+## rather than by reference, and a module referenced only by the Callable answering one command
+## would be freed once it answered.
+var _modules: Dictionary = {}
 
 var _server: TCPServer
 var _clients: Array[StreamPeerTCP] = []
@@ -132,7 +179,7 @@ var _announcement: String = ""
 ## Held for as long as the game runs: a Logger the engine has is kept by reference, and one
 ## that goes away mid-run takes the report with it.
 var _errors: GdhErrorReport
-## Every command, by the name a request uses, as the module method that answers it.
+## The commands this script answers itself, by the name a request uses.
 var _commands: Dictionary = {}
 ## The addon this game loaded, read once at start: an upgrade rewrites the markers under a running
 ## game, whose code stays what it loaded, and reading them later would call that code current.
@@ -151,38 +198,53 @@ var _profiler_calibrated: bool = false
 func _init() -> void:
 	_commands = {
 		"ping": _ping,
-		"get_tree": _queries.get_tree,
-		"find_nodes": _queries.find_nodes,
-		"read_text": _queries.read_text,
-		"get_rect": _queries.get_rect,
-		"get_property": _queries.get_property,
-		"set_property": _changes.set_property,
-		"call_method": _changes.call_method,
-		"get_metrics": _queries.get_metrics,
-		"get_accessibility": _accessibility.get_accessibility,
-		"capture_screenshot": _capture.capture_screenshot,
-		"capture_viewport": _capture.capture_viewport,
-		"inject_action": _input.inject_action,
-		"inject_key": _input.inject_key,
-		"inject_text": _typing.inject_text,
-		"inject_mouse_click": _input.inject_mouse_click,
-		"inject_mouse_motion": _input.inject_mouse_motion,
-		"inject_mouse_drag": _input.inject_mouse_drag,
-		"inject_joypad_button": _pad.inject_joypad_button,
-		"inject_joypad_motion": _pad.inject_joypad_motion,
-		"click": _input.click,
-		"choose": _typing.choose,
-		"wait_frames": _waits.wait_frames,
-		"wait_signal": _waits.wait_signal,
-		"watch_signal": _waits.watch_signal,
-		"watch_recorded": _waits.recorded,
-		"wait_until": _waits.wait_until,
 		"send_profile": _send_profile_now,
 		"close_game": _close_game,
 	}
 	_wait_for_the_profiler()
 
 
+## The script of the module in [param file], compiled at the first call that needs it.
+static func _loaded(file: String) -> GDScript:
+	return load(ADDON_DIR + file) as GDScript
+
+
+## The module in [param file], built at its first command with what it is built with.
+func _module(file: String) -> Object:
+	var made: Object = _modules.get(file)
+	if made != null:
+		return made
+	var script: GDScript = _loaded(file)
+	match file:
+		QUERIES:
+			made = script.new(self, values, _frames)
+		TYPING, PAD, ACCESSIBILITY:
+			made = script.new(self)
+		_:
+			made = script.new(self, values)
+	_modules[file] = made
+	_frames.skip_this_frame()
+	return made
+
+
+## What answers [param command], loading its module if no command has needed it yet, or an invalid
+## Callable for a command nothing answers.
+func _handler(command: String) -> Callable:
+	if _commands.has(command):
+		return _commands[command]
+	var answered_by: Array = MODULE_COMMANDS.get(command, [])
+	if answered_by.is_empty():
+		return Callable()
+	var file: String = answered_by[0]
+	var method: String = answered_by[1]
+	return Callable(_module(file), method)
+
+
+## Every command the runtime answers, its own and the modules', loaded or not.
+func _command_names() -> Array:
+	return _commands.keys() + MODULE_COMMANDS.keys()
+
+
 ## Gives a game with no window the size the project opens its window at. Measured: a
 ## headless engine's root viewport is 64 by 64 whatever the project settings or --resolution say, so
 ## a headless game laid its interface out in 64 pixels, and a button every windowed run shows was
@@ -195,7 +257,7 @@ func _size_a_windowless_game() -> void:
 	if DisplayServer.get_name() != "headless" or _script_run() or not OS.is_debug_build():
 		return
 	var root: Window = get_tree().root
-	if Vector2(root.size) != GdhTargets.HEADLESS_VIEWPORT:
+	if Vector2(root.size) != HEADLESS_VIEWPORT:
 		return
 	root.size = Vector2i(_window_dimension("width", 1152), _window_dimension("height", 648))
 
@@ -305,32 +367,54 @@ func _exit_tree() -> void:
 ## every other node's _exit_tree, so what those do is counted. A project that sent this node away
 ## mid-run had the profiler switched off then, and its run answered as complete with none of the
 ## frames after it.
+##
+## The debugger reads in order, so its answer comes once it has read everything the game queued
+## before the totals, and a debugger that has fallen behind answers late rather than not at all. A
+## debugger gdharness gave this game, the keeper of a run the server started or an editor with the
+## gdharness addon, is waited for until it answers; a fixed three seconds lost the totals of a run
+## whose first frame named 1536 functions, on a loaded runner that read them slower than that. Any
+## other debugger may never answer, and holds the exit for the short wait only.
+##
+## The debugger is asked once before the profiler goes off as well, so the totals go into an empty
+## queue. They name each function no frame did, one message apiece, and with the names of a large
+## first frame still queued for a debugger behind on its reading, they did not fit and the engine
+## dropped them. One that does not answer that is not asked again, as it would not answer the second.
 func _send_the_profile() -> void:
 	if not (EngineDebugger.is_active() and EngineDebugger.is_profiling("servers")):
 		return
-	_profile_received = false
 	if not EngineDebugger.has_capture(PROFILE_CAPTURE):
 		EngineDebugger.register_message_capture(PROFILE_CAPTURE, _on_debugger_message)
+	var answers: bool = _profiled_from_start or OS.get_environment(EDITOR_PID_VARIABLE).is_valid_int()
+	var waits: int = PROFILE_ANSWERED_MS if answers else PROFILE_CONFIRM_MS
+	var drained: bool = _debugger_answered(waits)
 	EngineDebugger.profiler_enable("servers", false)
-	EngineDebugger.send_message(PROFILE_SENT, [])
-	var deadline: int = Time.get_ticks_msec() + PROFILE_CONFIRM_MS
-	while not _profile_received and Time.get_ticks_msec() < deadline:
-		for _poll: int in POLLS_PER_READ:
-			EngineDebugger.line_poll()
-		OS.delay_msec(5)
+	var confirmed: bool = drained and _debugger_answered(waits)
 	EngineDebugger.unregister_message_capture(PROFILE_CAPTURE)
-	if not _profile_received:
+	if not confirmed:
 		print(
 			(
 				(
 					"[gdharness] the debugger did not confirm the profiler's totals within %d ms, so the"
 					+ " profile may be the frames that arrived without them"
 				)
-				% PROFILE_CONFIRM_MS
+				% waits
 			)
 		)
 
 
+## Sends the debugger the message it answers once it has read everything sent before it, and waits
+## up to [param waits] ms for the answer, polling for it since the game's loop is over.
+func _debugger_answered(waits: int) -> bool:
+	_profile_received = false
+	EngineDebugger.send_message(PROFILE_SENT, [])
+	var deadline: int = Time.get_ticks_msec() + waits
+	while not _profile_received and Time.get_ticks_msec() < deadline:
+		for _poll: int in POLLS_PER_READ:
+			EngineDebugger.line_poll()
+		OS.delay_msec(5)
+	return _profile_received
+
+
 ## The totals sent now, for a stop that is about to end the game without letting it quit: ended by
 ## its process, a game takes the totals with it, and every stopped profile came back as the frames
 ## summed. Nothing of the game's own runs, which quitting the tree would have done.
@@ -395,7 +479,7 @@ func _report_errors() -> void:
 func _process(_delta: float) -> void:
 	if not _enabled or _server == null:
 		return
-	_queries.note_frame(Time.get_ticks_usec())
+	_frames.note_frame(Time.get_ticks_usec())
 	_calibrate_the_profiler()
 
 	# Every connection waiting rather than one a frame: the engine queues eight a game has not
@@ -678,7 +762,7 @@ func _send_welcome(client: StreamPeerTCP) -> void:
 		str(ProjectSettings.get_setting(BIND_ADDRESS_SETTING, DEFAULT_BIND_ADDRESS))
 	)
 	welcome["type"] = "welcome"
-	welcome["commands"] = _commands.keys()
+	welcome["commands"] = _command_names()
 	_send_response(client, welcome)
 
 
@@ -716,13 +800,16 @@ func _handle_message(client: StreamPeerTCP, line: String) -> void:
 
 
 func _execute_command(command: String, params: Dictionary) -> Dictionary:
-	var handler: Callable = _commands.get(command, Callable())
+	var handler: Callable = _handler(command)
 	if not handler.is_valid():
 		return {
 			"type": "error",
-			"message": "Unknown command: %s. Commands: %s" % [command, ", ".join(_commands.keys())]
+			"message": "Unknown command: %s. Commands: %s" % [command, ", ".join(_command_names())]
 		}
-	_waits.saw_call(command, params)
+	# Only a waits module already loaded can have a trace running to record the call in.
+	var waits: Object = _modules.get(WAITS)
+	if waits != null:
+		var _seen: Variant = waits.call(&"saw_call", command, params)
 	var answer: Variant = await handler.call(params)
 	return answer
 

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

@@ -0,0 +1,46 @@
+extends RefCounted
+
+## How long the game's last frames took, timed from the runtime's first frame. Apart from the
+## queries that report it, because those are loaded at the first request and the frames before it
+## count too.
+
+## How many frames the frame time is the mean of: two seconds at sixty frames a second.
+const FRAMES_TIMED: int = 120
+
+## How long each of the last frames took, oldest first, in microseconds, as the game timed them.
+var usec: PackedInt64Array = PackedInt64Array()
+## How many physics steps ran in each of those frames, in the same order.
+var physics: PackedInt64Array = PackedInt64Array()
+var _last_frame_usec: int = 0
+var _last_physics_frames: int = 0
+
+
+## Called by the autoload once a frame, whatever else it does that frame, with the time it was called.
+##
+## The engine's own monitors do not follow the frame: TIME_PROCESS and the frame rate are set once a
+## second, the first to the slowest process step of that second, so a game whose frames took 16.7ms
+## read 45ms for a second at a time, and a change to the game showed only on the next second's
+## worst frame. The time between two of these calls is the frame as it passed, physics and the wait
+## for the display included.
+##
+## The physics steps are counted beside it because the engine steps physics from the wall clock and
+## nothing else reports how many it took: a game drawing sixty frames a second whose brew advanced
+## by physics steps moved a tenth as far as the frames promised, and every reading available said
+## the game was running well.
+func note_frame(now_usec: int) -> void:
+	var stepped: int = Engine.get_physics_frames()
+	if _last_frame_usec > 0:
+		var _grew: bool = usec.push_back(now_usec - _last_frame_usec)
+		var _counted: bool = physics.push_back(stepped - _last_physics_frames)
+		if usec.size() > FRAMES_TIMED:
+			usec.remove_at(0)
+			physics.remove_at(0)
+	_last_frame_usec = now_usec
+	_last_physics_frames = stepped
+
+
+## Leaves the frame in progress out of the timing, for one the runtime itself slowed: compiling a
+## module at its first command takes up to half a second, which is gdharness's and not the game's,
+## and would stand as the slowest frame for the next two seconds of readings.
+func skip_this_frame() -> void:
+	_last_frame_usec = 0

package/build/godot/addons/gdharness_runtime/runtime_frames.gd.uid

@@ -0,0 +1 @@
+uid://dd8t2ghi83ntg

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

@@ -4,6 +4,7 @@ extends RefCounted
 ## question, where one is on screen, a property's value, the metrics. What it changes, a property
 ## written or a method called, is in runtime_changes.gd.
 
+const GdhFrames = preload("runtime_frames.gd")
 const GdhPaths = preload("runtime_paths.gd")
 const GdhRead = preload("reading.gd")
 const GdhSays = preload("runtime_says.gd")
@@ -28,24 +29,18 @@ const READ_LIMIT: int = 500
 ## and said nothing, and a caller told to raise a number that stays put concludes the screen moved.
 const LIMIT_CEILING: int = 5000
 
-## How many frames the frame time is the mean of: two seconds at sixty frames a second.
-const FRAMES_TIMED: int = 120
-
 var _host: Node
 var _values: GdhValues
-## How long each of the last frames took, oldest first, in microseconds, as the game timed them.
-var _frame_usec: PackedInt64Array = PackedInt64Array()
-## How many physics steps ran in each of those frames, in the same order.
-var _frame_physics: PackedInt64Array = PackedInt64Array()
-var _last_frame_usec: int = 0
-var _last_physics_frames: int = 0
+var _frames: GdhFrames
 
 
 ## The host is the autoload, which is how the tree is reached: it is not in one when the
-## modules are built, and a fixture may put it in one later.
-func _init(host: Node, values: GdhValues) -> void:
+## modules are built, and a fixture may put it in one later. [param frames] is the autoload's,
+## timing the frames since the runtime's first.
+func _init(host: Node, values: GdhValues, frames: GdhFrames) -> void:
 	_host = host
 	_values = values
+	_frames = frames
 
 
 ## The tree under a node, to a depth, with every stored property on each node when asked for all
@@ -801,30 +796,6 @@ func get_property(params: Dictionary) -> Dictionary:
 	}
 
 
-## Called by the autoload once a frame, whatever else it does that frame, with the time it was called.
-##
-## The engine's own monitors do not follow the frame: TIME_PROCESS and the frame rate are set once a
-## second, the first to the slowest process step of that second, so a game whose frames took 16.7ms
-## read 45ms for a second at a time, and a change to the game showed only on the next second's
-## worst frame. The time between two of these calls is the frame as it passed, physics and the wait
-## for the display included.
-##
-## The physics steps are counted beside it because the engine steps physics from the wall clock and
-## nothing else reports how many it took: a game drawing sixty frames a second whose brew advanced
-## by physics steps moved a tenth as far as the frames promised, and every reading available said
-## the game was running well.
-func note_frame(now_usec: int) -> void:
-	var physics: int = Engine.get_physics_frames()
-	if _last_frame_usec > 0:
-		var _grew: bool = _frame_usec.push_back(now_usec - _last_frame_usec)
-		var _stepped: bool = _frame_physics.push_back(physics - _last_physics_frames)
-		if _frame_usec.size() > FRAMES_TIMED:
-			_frame_usec.remove_at(0)
-			_frame_physics.remove_at(0)
-	_last_frame_usec = now_usec
-	_last_physics_frames = physics
-
-
 ## Whether the frame waits for the display, which sets its floor: a game with vsync on cannot
 ## finish a frame sooner than the display refreshes, however little it does.
 static func _vsync() -> String:
@@ -843,15 +814,15 @@ static func _vsync() -> String:
 
 func get_metrics(params: Dictionary) -> Dictionary:
 	var metrics: Array = params.get("metrics", [])
-	var timed: int = _frame_usec.size()
+	var timed: int = _frames.usec.size()
 	var total_usec: int = 0
 	var slowest_usec: int = 0
-	for one: int in _frame_usec:
+	for one: int in _frames.usec:
 		total_usec += one
 		slowest_usec = maxi(slowest_usec, one)
 	# Null rather than zero before a frame has been timed: no frame took no time.
 	var steps: int = 0
-	for one: int in _frame_physics:
+	for one: int in _frames.physics:
 		steps += one
 	var frame_time: Variant = null
 	var frame_time_max: Variant = null

package/build/keeper.js

@@ -8802,6 +8802,10 @@ var SERVER_VERSION = (() => {
 })();
 
 // src/setup.ts
+var RUNTIME_AUTOLOAD = {
+  name: "GdharnessRuntime",
+  path: "gdharness/loader.gd"
+};
 function shippedAddonsDirectory() {
   return join5(dirname3(fileURLToPath(import.meta.url)), "godot", "addons");
 }
@@ -8812,7 +8816,7 @@ var STEP_MS = 1e4;
 var ADDON_FRAMES = 5;
 var ADDON_LINES = 200;
 var RUNTIME_ADDON = "res://addons/gdharness_runtime/";
-var RUNTIME_AUTOLOAD = `${RUNTIME_ADDON}runtime_autoload.gd`;
+var RUNTIME_AUTOLOAD2 = `${RUNTIME_ADDON}runtime_autoload.gd`;
 var frameEnd = null;
 function frameEndLine() {
   if (frameEnd === null) {
@@ -8820,7 +8824,7 @@ function frameEndLine() {
 `);
     const declared = lines.findIndex((line) => line.startsWith("func _notification("));
     if (declared === -1) {
-      throw new Error(`The shipped ${RUNTIME_AUTOLOAD} declares no _notification.`);
+      throw new Error(`The shipped ${RUNTIME_AUTOLOAD2} declares no _notification.`);
     }
     frameEnd = declared + 2;
   }
@@ -9253,7 +9257,7 @@ class GameDebugger {
       if (until !== undefined && Date.now() >= until) {
         return { frames, gaveUp: "time" };
       }
-      if (frames.some((frame) => frame.script === RUNTIME_AUTOLOAD && frame.name === "_process")) {
+      if (frames.some((frame) => frame.script === RUNTIME_AUTOLOAD2 && frame.name === "_process")) {
         if (until === undefined && framesLeft === 0) {
           return { frames, gaveUp: "frames" };
         }
@@ -9284,15 +9288,15 @@ class GameDebugger {
       return null;
     }
     const line = frameEndLine();
-    const theirs = this.breakpointLines.has(`${RUNTIME_AUTOLOAD}:${String(line)}`);
+    const theirs = this.breakpointLines.has(`${RUNTIME_AUTOLOAD2}:${String(line)}`);
     if (!theirs) {
-      this.send("breakpoint", [RUNTIME_AUTOLOAD, line, true], held.thread);
+      this.send("breakpoint", [RUNTIME_AUTOLOAD2, line, true], held.thread);
     }
     this.forget("debug_enter");
     this.send("continue", [], held.thread);
     const stopped = await this.next(GameDebugger.named("debug_enter"), STEP_MS);
     if (!theirs) {
-      this.send("breakpoint", [RUNTIME_AUTOLOAD, line, false], this.held?.thread ?? MAIN_THREAD);
+      this.send("breakpoint", [RUNTIME_AUTOLOAD2, line, false], this.held?.thread ?? MAIN_THREAD);
     }
     return stopped === null ? "lost" : await this.stack();
   }
@@ -9782,6 +9786,8 @@ function withEngineArguments(args, extra) {
   const user = args.indexOf("--");
   return user < 0 ? [...args, ...extra] : [...args.slice(0, user), ...extra, ...args.slice(user)];
 }
+var QUEUE_OVERFLOW = "TOO_MANY_MESSAGES";
+var DROPPED_COUNT = /(\d+) messages were dropped/;
 
 class ProfileAggregate {
   names = new Map;
@@ -9792,6 +9798,7 @@ class ProfileAggregate {
   unreadable = 0;
   cappedFrames = 0;
   totalCapped = false;
+  dropped = 0;
   startedAt;
   frameFunctions;
   constructor(startedAt, frameFunctions) {
@@ -9803,7 +9810,10 @@ class ProfileAggregate {
       this.unreadable += 1;
       return;
     }
-    if (received.message === "servers:function_signature") {
+    if (received.message === "error" && received.data[7] === QUEUE_OVERFLOW) {
+      const said = typeof received.data[8] === "string" ? DROPPED_COUNT.exec(received.data[8]) : null;
+      this.dropped += said === null ? 1 : Number(said[1]);
+    } else if (received.message === "servers:function_signature") {
       const [name, id] = received.data;
       if (typeof name === "string" && typeof id === "number") {
         this.names.set(id, name);
@@ -9873,10 +9883,12 @@ class ProfileAggregate {
       unreadable: this.unreadable,
       frameFunctions: this.frameFunctions,
       cappedFrames: this.cappedFrames,
-      totalCapped: this.totalCapped
+      totalCapped: this.totalCapped,
+      ...this.dropped > 0 ? { dropped: this.dropped } : {}
     };
   }
 }
+var RUNTIME_LOADER = `res://${RUNTIME_AUTOLOAD.path}`;
 class ProfileObserver {
   aggregate = null;
   changed;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdharness",
-  "version": "1.3.24",
+  "version": "1.3.25",
   "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",