gdharness 1.3.28 → 1.3.29

package/build/cli.js

@@ -12072,6 +12072,37 @@ function editorArguments(projectPath, ports, logFile, hidden, silent) {
     logFile
   ];
 }
+function startedAs(commandLine) {
+  const words = commandLineWords(commandLine);
+  const hidden = words.includes("--headless");
+  const driver = words.indexOf("--audio-driver");
+  return { hidden, silent: hidden || driver >= 0 && words[driver + 1] === "Dummy" };
+}
+function commandLineWords(line) {
+  const words = [];
+  let word = "";
+  let inWord = false;
+  let quoted = false;
+  for (const character of line) {
+    if (character === '"') {
+      quoted = !quoted;
+      inWord = true;
+    } else if (!quoted && /\s/.test(character)) {
+      if (inWord) {
+        words.push(word);
+      }
+      word = "";
+      inWord = false;
+    } else {
+      word += character;
+      inWord = true;
+    }
+  }
+  if (inWord) {
+    words.push(word);
+  }
+  return words;
+}
 function userDataIn(home, variables = process.env) {
   const moved = ["APPDATA", "XDG_DATA_HOME"];
   const carried = {};
@@ -17229,19 +17260,19 @@ var init_tool_definitions = __esm(() => {
     {
       name: "editor_launch",
       title: "Open, restart or close the editor, or bind its debug adapter again",
-      description: "Opens the Godot editor on a project, or restarts or closes the one already connected, or binds its debug adapter again. close saves open scenes, quits the editor and waits for its process to go, which is the only way to end a hidden one short of killing it; an editor this server opened that has not connected yet has nothing of this server's to save, so close stops its process instead. open answers once the process has started, and the editor dials in after its import; a call needing the editor made before then waits for the one this server opened, for as long as a restart waits, and is refused naming it if it has not arrived. open refuses while an editor of the project is already running and has not reached this server, naming its pid, rather than putting a second on the project. The editor is an ordinary visible one on the desktop in use, and on Windows it is shown without being activated, so opening or reopening it does not take the keyboard from whatever the user is typing in. hidden: true opens it headless instead and, on Windows, on a desktop of its own, where the games it plays go too; a hidden editor serves the bridge, the language server and the debug adapter as a visible one does. A game a visible editor plays opens as a window on the desktop in use. An editor goes on serving the addon it read at startup, so restart is what puts a gdharness upgrade into effect, and nothing else here restarts one; it saves open scenes on the way out. An editor a server opened is started again by the server, visible unless hidden: true is passed again, once the old one has gone: it waits 90 seconds for that, or GDHARNESS_EDITOR_RESTART_TIMEOUT_MS, and an old editor still running after it is not replaced, since the new one would find its ports held. One opened by hand restarts itself, which only one with a window can do, because the engine hands back none of the arguments it was started with. Godot tries each server port once, as the editor starts, so a restart binds a debug adapter that came back without its port again, in the editor that came back. rebind does the same for the connected editor without restarting it, whoever opened it; a debug session open on the adapter ends with it and is opened again by the next debug call. editor_status says which editor is connected and whether it is holding an old addon. Opening a project is a save and so is closing one, which is the part that is not obvious from outside: the editor imports the project on open and writes project.godot back, and Godot writes only what differs from its own defaults, so a key named deliberately at its default value is dropped either way. A restart of an editor this server opened is a quit and then a launch, and this server can be ended between them, usually by the reconnect the restart was being taken for: the editor is gone and nothing replaces it. That is written down before the quit, so the next server says so in editor_status rather than waiting for an editor that is not coming, and open finishes it. An open is refused when the editor it would start could never reach this server: a project other than the one this server serves, whose editor dials that project's own server; a project without the gdharness editor addon installed and enabled; and a project whose editor a restart is already bringing back.",
-      answer: "close answers settingsDropped, naming what its save took out of project.godot and left out when it took nothing, and settingsNote when the file could not be read to tell; an editor stopped before it connected is answered with beforeConnecting. close and restart name under savedScenes the open scenes that had unsaved changes and were saved on the way out, an empty list when none had; a scene that would not save refuses the close or restart and leaves the editor running. Both answer tookMs, how long the editor took to go or to come back. restart answers with the version that came back, and says under settingsDropped which keys its save dropped, because it waits for the editor to return. An open cannot, since it answers as soon as the process exists and the save happens during the import minutes later, so editor_status carries that reading once the editor has connected. Nothing else will say a key went until something depends on one. A restart answers lspListening and dapListening once the editor's servers are up. When either came back without its port, serversSaid gives the lines the editor's log panel has about its servers, the one place Godot says why a port would not bind, and when it was the debug adapter, which is bound again in the editor that came back, debugAdapterRebound says whether that took; neither is there when both came up. Godot clears that panel whenever a game is played, unless its run/output/always_clear_output_on_play setting is off, so after a play the lines from the editor's own start are gone. rebind answers rebound, with lspListening, dapListening and serversSaid, the lines that rebind made the panel print. A restart that a server's end interrupted shows as restartInterrupted in editor_status, and the open that finishes it says so under finishesRestart.",
+      description: "Opens the Godot editor on a project, or restarts or closes the one already connected, or binds its debug adapter again. close saves open scenes, quits the editor and waits for its process to go, which is the only way to end a hidden one short of killing it; an editor this server opened that has not connected yet has nothing of this server's to save, so close stops its process instead. open answers once the process has started, and the editor dials in after its import; a call needing the editor made before then waits for the one this server opened, for as long as a restart waits, and is refused naming it if it has not arrived. open refuses while an editor of the project is already running and has not reached this server, naming its pid, rather than putting a second on the project. The editor is an ordinary visible one on the desktop in use, and on Windows it is shown without being activated, so opening or reopening it does not take the keyboard from whatever the user is typing in. hidden: true opens it headless instead and, on Windows, on a desktop of its own, where the games it plays go too; a hidden editor serves the bridge, the language server and the debug adapter as a visible one does. A game a visible editor plays opens as a window on the desktop in use. An editor goes on serving the addon it read at startup, so restart is what puts a gdharness upgrade into effect, and nothing else here restarts one; it saves open scenes on the way out. An editor a server opened is started again by the server, hidden or visible and silent or not as it was started unless hidden or silent says otherwise, once the old one has gone: it waits 90 seconds for that, or GDHARNESS_EDITOR_RESTART_TIMEOUT_MS, and an old editor still running after it is not replaced, since the new one would find its ports held. One opened by hand restarts itself, which only one with a window can do, because the engine hands back none of the arguments it was started with. Godot tries each server port once, as the editor starts, so a restart binds a debug adapter that came back without its port again, in the editor that came back. rebind does the same for the connected editor without restarting it, whoever opened it; a debug session open on the adapter ends with it and is opened again by the next debug call. editor_status says which editor is connected and whether it is holding an old addon. Opening a project is a save and so is closing one, which is the part that is not obvious from outside: the editor imports the project on open and writes project.godot back, and Godot writes only what differs from its own defaults, so a key named deliberately at its default value is dropped either way. A restart of an editor this server opened is a quit and then a launch, and this server can be ended between them, usually by the reconnect the restart was being taken for: the editor is gone and nothing replaces it. That is written down before the quit, so the next server says so in editor_status rather than waiting for an editor that is not coming, and open finishes it. An open is refused when the editor it would start could never reach this server: a project other than the one this server serves, whose editor dials that project's own server; a project without the gdharness editor addon installed and enabled; and a project whose editor a restart is already bringing back.",
+      answer: "close answers settingsDropped, naming what its save took out of project.godot and left out when it took nothing, and settingsNote when the file could not be read to tell; an editor stopped before it connected is answered with beforeConnecting. close and restart name under savedScenes the open scenes that had unsaved changes and were saved on the way out, an empty list when none had; a scene that would not save refuses the close or restart and leaves the editor running. Both answer tookMs, how long the editor took to go or to come back. restart answers with the version that came back, and hidden, whether it came back with no window, and says under settingsDropped which keys its save dropped, because it waits for the editor to return. An open cannot, since it answers as soon as the process exists and the save happens during the import minutes later, so editor_status carries that reading once the editor has connected. Nothing else will say a key went until something depends on one. A restart answers lspListening and dapListening once the editor's servers are up. When either came back without its port, serversSaid gives the lines the editor's log panel has about its servers, the one place Godot says why a port would not bind, and when it was the debug adapter, which is bound again in the editor that came back, debugAdapterRebound says whether that took; neither is there when both came up. Godot clears that panel whenever a game is played, unless its run/output/always_clear_output_on_play setting is off, so after a play the lines from the editor's own start are gone. rebind answers rebound, with lspListening, dapListening and serversSaid, the lines that rebind made the panel print. A restart that a server's end interrupted shows as restartInterrupted in editor_status, and the open that finishes it says so under finishesRestart.",
       parameters: {
         projectPath: { ...PROJECT_PATH, ops: ["open"] },
         hidden: {
           type: "boolean",
           ops: ["open", "restart"],
-          description: "Open the editor headless and, on Windows, on a desktop of its own, so no window of it or of the games it plays appears. Default false: one visible editor, shown without taking the focus. On restart only for an editor a server opened; one opened by hand comes back as it was, so hidden is refused there."
+          description: "Open the editor headless and, on Windows, on a desktop of its own, so no window of it or of the games it plays appears. Default false on open: one visible editor, shown without taking the focus. On restart only for an editor a server opened, where the default is how the editor being replaced was started, read from its process; one whose start cannot be read is left running and refused until hidden is passed. One opened by hand comes back as it was, so hidden is refused there."
         },
         silent: {
           type: "boolean",
           ops: ["open", "restart"],
-          description: "Open the editor with no sound out of the machine, started with --audio-driver Dummy, so a tool script, a preview or a scene playing in its viewport is heard by nobody. Default true: pass false to hear it. The answer's arguments are what the editor was started with. The editor hands no audio driver to a game it plays, so editor_run's own silent decides that game's sound. A hidden editor is headless and silent either way. On restart only for an editor a server opened; one opened by hand comes back as it was."
+          description: "Open the editor with no sound out of the machine, started with --audio-driver Dummy, so a tool script, a preview or a scene playing in its viewport is heard by nobody. Default true on open, and on restart how the editor being replaced was started: pass false to hear it. The answer's arguments are what the editor was started with. The editor hands no audio driver to a game it plays, so editor_run's own silent decides that game's sound. A hidden editor is headless and silent either way. On restart only for an editor a server opened; one opened by hand comes back as it was."
         }
       },
       requires: [],
@@ -17418,7 +17449,7 @@ 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 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.",
+      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. firstFrame and lastFrame are the game's own numbers, counted from 0, for the first and the last of them, in a run this server started; a firstFrame above 0 is frames run before the profiler came on, and a gap between the two is frames that never arrived, which the note says. 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"
     },
     {
@@ -17662,7 +17693,7 @@ var init_tool_definitions = __esm(() => {
         },
         find: {
           effect: "read",
-          summary: "the paths of every node matching className, script, namePattern, group or says, with property read off each, hidden ones included unless includeHidden says otherwise; with it false, a control drawn wholly outside the viewport or a ScrollContainer is left out too. A match drawn under a matching node saying the same words, as an outline or a glow copy is, names that node under copyOf, and the answer counts the rest under distinct",
+          summary: "the paths of every node matching className, script, namePattern, group or says, with property read off each, hidden ones included unless includeHidden says otherwise; with it false, a control drawn wholly outside the viewport or a ScrollContainer is left out too. A match drawn under a matching node drawing the same words, as an outline or a glow copy is, names that node under copyOf (a name given only for a screen reader is not drawn, so a node holding one is never what a copy copies), and the answer counts the rest under distinct",
           requires: []
         },
         rect: {
@@ -48345,7 +48376,7 @@ 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, firstFrame: _first, lastFrame: _last, ...kept } = now;
   const dropped = (droppedInAll ?? 0) - (mark.dropped ?? 0);
   return {
     totals: {
@@ -49830,6 +49861,15 @@ function profileAnswer(reading, limit) {
   } else {
     notes.push(`These are the ${totals.frames === 1 ? "one frame" : `${totals.frames} frames`} that arrived, summed, without the engine's own totals, which it sends only when the profiler is switched off.${totalsWithheld} Not in them is any script time after the last frame sent: a frame still queued as the game exited, since the engine stops sending without emptying its queue, and what scripts did as it quit, such as in _exit_tree. That can be nothing: a scene that does its work in _ready and quits has all of it in its first frame.`);
   }
+  const unprofiled = totals.firstFrame ?? 0;
+  if (reading.through === "gdharness" && unprofiled > 0) {
+    notes.push(`The profiler came on at the game's frame ${unprofiled}, so ${unprofiled === 1 ? "its first frame is" : `its first ${unprofiled} frames are`} not in these, the main scene's _ready among them${reading.runtimeAddon === true ? "" : ": without the runtime addon nothing holds the game's start until the profiler is on"}.`);
+  }
+  const unarrived = totals.firstFrame === undefined || totals.lastFrame === undefined ? 0 : totals.lastFrame - totals.firstFrame + 1 - totals.frames - totals.unreadable;
+  if (unarrived > 0) {
+    const howMany = unarrived === 1 ? "One" : String(unarrived);
+    notes.push(`${howMany} of the game's frames between the first and the last that arrived did not arrive, so ${unarrived === 1 ? "its" : "their"} script time is not in these.`);
+  }
   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.`);
   }
@@ -49853,6 +49893,8 @@ function profileAnswer(reading, limit) {
     connected: true,
     complete: totals.complete,
     frames: totals.frames,
+    firstFrame: totals.firstFrame,
+    lastFrame: totals.lastFrame,
     coveredMs: reading.coveredMs,
     scriptMs: table.scriptMs,
     perCallOverheadUs: table.perCallUs ?? undefined,
@@ -53601,8 +53643,21 @@ ${error.text}`;
         "editor_launch restart without hidden restarts it as it is"
       ]);
     }
+    let hidden = args["hidden"] === true;
+    let silent = resolveSilent(args["silent"]);
+    if (mine && (typeof args["hidden"] !== "boolean" || typeof args["silent"] !== "boolean")) {
+      const was = before.editorPid === undefined ? null : await runningAs(before.editorPid);
+      if (was?.kind === "commandLine") {
+        const as = startedAs(was.text);
+        hidden = typeof args["hidden"] === "boolean" ? args["hidden"] : as.hidden;
+        silent = typeof args["silent"] === "boolean" ? args["silent"] : as.silent;
+      } else if (typeof args["hidden"] !== "boolean") {
+        const why = was === null ? "the operating system would not say" : was.unread ?? "it gave no command line";
+        return this.createErrorResponse(`How the editor (pid ${before.editorPid ?? "unknown"}) was started could not be read (${why}), so whether it was hidden cannot be told and it was left running.`, ["Pass hidden: true to bring it back with no window, or hidden: false to bring it back visible"]);
+      }
+    }
     const settingsBefore = this.settingKeysOf(before.projectPath);
-    const asked = mine ? await this.startItAgain(before.projectPath ?? "", before.editorPid, args["hidden"] === true, resolveSilent(args["silent"])) : await this.handleViaBridge("restart_editor", {});
+    const asked = mine ? await this.startItAgain(before.projectPath ?? "", before.editorPid, hidden, silent) : await this.handleViaBridge("restart_editor", {});
     if (asked.isError === true) {
       return asked;
     }
@@ -53621,6 +53676,7 @@ ${error.text}`;
     const after = this.settingKeysOf(before.projectPath);
     return this.jsonTextResponse({
       restarted: true,
+      hidden: mine && hidden,
       editorPid: now.editorPid,
       addonVersion: now.addonVersion,
       serverVersion: SERVER_VERSION,

package/build/godot/addons/auto_reload/auto_reload.gd

@@ -133,6 +133,21 @@ func _reload_script(path: String) -> void:
 
 func _reload_scene(path: String) -> void:
 	var edited_scene: Node = EditorInterface.get_edited_scene_root()
-	if edited_scene and edited_scene.scene_file_path == path:
-		print("[gdharness] Scene changed on disk, reloading: ", path)
-		EditorInterface.reload_scene_from_path(path)
+	if not edited_scene or edited_scene.scene_file_path != path:
+		return
+	# A reload from the file drops the edits the editor holds, without a prompt. gdharness refuses to
+	# write over them, so what is seen here is a write by somebody else or one the editor's tab has
+	# already taken in, made just before an edit inside the same poll, and neither is worth the edit.
+	if EditorInterface.get_unsaved_scenes().has(path):
+		push_warning(
+			(
+				(
+					"gdharness: %s changed on disk while the editor holds unsaved changes to it, so it "
+					+ "was not reloaded; saving it writes the editor's copy over the file"
+				)
+				% path
+			)
+		)
+		return
+	print("[gdharness] Scene changed on disk, reloading: ", path)
+	EditorInterface.reload_scene_from_path(path)

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

@@ -20,21 +20,27 @@ extends RefCounted
 ## A label is asked about first and read directly, because a screen is mostly labels and this runs
 ## for each of them on every look a wait takes.
 static func said_by(node: Node) -> String:
-	var label: Label = node as Label
-	if label != null:
-		return _label_says(label)
-	if draws_a_list(node):
-		return "\n".join(lines_said_by(node))
-	var own: String = _text_of(node)
+	var own: String = drawn_by(node)
 	# A control showing a picture rather than words is named for a player who cannot see it, and that
 	# name is the one the words a caller asks by are meant for: the rail's "Out" tab is a square with
 	# an icon on it, and a click on "Out" found only the words around it.
-	if own.is_empty() and node is Control:
+	if own.is_empty() and node is Control and not node is Label and not draws_a_list(node):
 		var control: Control = node
 		return control.atr(control.accessibility_name).strip_edges()
 	return own
 
 
+## The words [param node] draws: what [method said_by] answers, without the name a control is given
+## for a player who cannot see it, which nothing on the screen shows.
+static func drawn_by(node: Node) -> String:
+	var label: Label = node as Label
+	if label != null:
+		return _label_says(label)
+	if draws_a_list(node):
+		return "\n".join(lines_said_by(node))
+	return _text_of(node)
+
+
 ## Every line [param node] draws for a player to read, one to an entry: a label's one line, or each
 ## item of a control that draws a list of them. Tab titles, list items, tree rows, menu titles and
 ## the items of an open menu are held by the control rather than in any `text`, so a screen read as
@@ -55,10 +61,12 @@ static func lines_said_by(node: Node) -> Array[String]:
 	return lines
 
 
-## The node [param node] is drawn as a copy of, or null: the nearest node above it that says
-## anything, when it says the same words, followed up while that one is a copy in turn. A word drawn
+## The node [param node] is drawn as a copy of, or null: the nearest node above it that draws any
+## words, when it draws the same ones, followed up while that one is a copy in turn. A word drawn
 ## with an outline or a glow is often a label holding copies of itself, offset or tinted, and a
-## player reads one sign where a find counted four.
+## player reads one sign where a find counted four. Drawn words only: a page's root named for a
+## screen reader by the title its heading shows draws nothing, and taken for the original it left
+## the heading read as a copy of words nobody reads.
 static func copied_from(node: Node) -> Node:
 	var chain: Array[Node] = copied_through(node)
 	return null if chain.is_empty() else chain.back()
@@ -68,12 +76,12 @@ static func copied_from(node: Node) -> Node:
 ## [method copied_from], which is the last of them.
 static func copied_through(node: Node) -> Array[Node]:
 	var chain: Array[Node] = []
-	var words: String = said_by(node)
+	var words: String = drawn_by(node)
 	if words.is_empty():
 		return chain
 	var above: Node = node.get_parent()
 	while above != null:
-		var said: String = said_by(above)
+		var said: String = drawn_by(above)
 		if not said.is_empty():
 			if said != words:
 				break

package/build/keeper.js

@@ -9795,6 +9795,8 @@ class ProfileAggregate {
   complete = false;
   frames = 0;
   lastFrameAt = null;
+  firstFrame = null;
+  lastFrame = null;
   unreadable = 0;
   cappedFrames = 0;
   totalCapped = false;
@@ -9826,6 +9828,11 @@ class ProfileAggregate {
         this.frames += 1;
         this.lastFrameAt = now;
         this.cappedFrames += carried >= this.frameFunctions ? 1 : 0;
+        const numbered = received.data[0];
+        if (typeof numbered === "number") {
+          this.firstFrame ??= numbered;
+          this.lastFrame = numbered;
+        }
       }
     } else if (received.message === "servers:profile_total") {
       const whole = new Map;
@@ -9884,7 +9891,8 @@ class ProfileAggregate {
       frameFunctions: this.frameFunctions,
       cappedFrames: this.cappedFrames,
       totalCapped: this.totalCapped,
-      ...this.dropped > 0 ? { dropped: this.dropped } : {}
+      ...this.dropped > 0 ? { dropped: this.dropped } : {},
+      ...this.firstFrame === null || this.lastFrame === null ? {} : { firstFrame: this.firstFrame, lastFrame: this.lastFrame }
     };
   }
 }

package/package.json

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