gdharness 1.3.57 → 1.3.59

package/build/cli.js

@@ -1763,6 +1763,9 @@ function nonEmpty(value) {
 function keptSlotsOf(count) {
   return Math.max(2, Math.floor(count / 4));
 }
+function reservedSlotOf(count) {
+  return count - Math.max(1, count - keptSlotsOf(count)) >= 2 ? count - 1 : null;
+}
 function gamesKeptOf(kept) {
   return Math.max(0, Math.min(Math.floor(kept / 2), kept - GATE_KEPT - 1));
 }
@@ -1777,7 +1780,8 @@ function slotsDrawnOn(count, taker, queue) {
     return { numbers: every };
   }
   if (taker === "tier") {
-    return { numbers: [...kept].reverse(), limit: "tier" };
+    const reserve = reservedSlotOf(count);
+    return { numbers: [...kept].reverse().filter((slot) => slot !== reserve), limit: "tier" };
   }
   return { numbers: kept.slice(0, Math.max(1, kept.length - GATE_KEPT)), limit: "kept" };
 }
@@ -1926,7 +1930,7 @@ class EngineSlots {
     try {
       for (;; ) {
         signal?.throwIfAborted();
-        const lock = await this.takeFree(game);
+        const lock = await this.takeFree(game, Date.now() - began);
         if (lock !== null) {
           return lock;
         }
@@ -1958,7 +1962,7 @@ class EngineSlots {
       }
     }
   }
-  async takeFree(game = false) {
+  async takeFree(game = false, waitedMs = 0) {
     mkdirSync2(this.directory, { recursive: true });
     await this.sweep();
     const inherited = this.inherited === null ? await this.inheritedLock() : null;
@@ -1967,11 +1971,14 @@ class EngineSlots {
       return inherited;
     }
     const taker = this.taker();
-    this.drawn = slotsDrawnOn(this.count, taker, taker === "gate" || taker === "timing" ? "none" : await this.gateQueue());
+    const aged = taker === "other" && !game && waitedMs >= ONE_OFF_AGED_MS;
+    this.drawn = slotsDrawnOn(this.count, taker, taker === "gate" || taker === "timing" || aged ? "none" : await this.gateQueue());
     if (game && this.drawn.limit === "kept") {
-      const share = slotsDrawnOn(this.count, "tier", "queued").numbers;
-      const games = await this.heldByGames(share);
-      if (games.length >= gamesKeptOf(share.length)) {
+      const reserve = reservedSlotOf(this.count);
+      this.drawn = { ...this.drawn, numbers: this.drawn.numbers.filter((slot) => slot !== reserve) };
+      const kept = this.count - Math.max(1, this.count - keptSlotsOf(this.count));
+      const games = await this.heldByGames(Array.from({ length: kept }, (_, at) => this.count - kept + at));
+      if (games.length >= gamesKeptOf(kept)) {
         this.drawn = { numbers: games, limit: "games" };
         return null;
       }
@@ -2122,6 +2129,25 @@ class EngineSlots {
         await this.cleared(join5(this.directory, name), false);
       }
     }
+    const marks = join5(this.directory, WAITING_FOLDER);
+    let waits;
+    try {
+      waits = readdirSync(marks);
+    } catch {
+      return;
+    }
+    for (const name of waits) {
+      let content;
+      try {
+        content = readWhole(join5(marks, name));
+      } catch {
+        continue;
+      }
+      const pid = content === null ? undefined : holderOf(content)?.pid;
+      if (pid !== undefined && !alive(pid)) {
+        removeWhole(join5(marks, name));
+      }
+    }
   }
   takenOver(lock, holder) {
     return this.cleared(lock, true, holder);
@@ -2344,7 +2370,7 @@ async function inASlot(body) {
     held.release();
   }
 }
-var HELD_VARIABLE = "GODOT_ENGINE_HELD", SLOTS_VARIABLE = "GODOT_ENGINE_SLOTS", SLOT_COUNT_VARIABLE = "GODOT_ENGINE_SLOT_COUNT", PROCESSORS_A_SLOT = 2, START_TOLERANCE_MS = 2000, UNWRITTEN_MS = 1e4, SLOT_LOOK_MS = 1000, SLOT_SETTLE_MS = 50, WAIT_SAID_MS = 20000, COMMAND_WAIT_SAID_MS = 2000, START_READ_MS = 1e4, WAITING_FOLDER = "waiting", QUEUED_FOLDER = "queued", SHARE_VARIABLE = "GODOT_ENGINE_SHARE", SHARE_COUNT_VARIABLE = "GODOT_ENGINE_SHARE_COUNT", GATE_KEPT = 1, TIMED_VARIABLE = "GODOT_ENGINE_TIMED", TIER_VARIABLE = "GODOT_ENGINE_TIER", SEATED_SUFFIX = ".seated", waitsMarked = 0, ENGINE_PID_LOOK_MS = 100, ours, saidTo, takenBy;
+var HELD_VARIABLE = "GODOT_ENGINE_HELD", SLOTS_VARIABLE = "GODOT_ENGINE_SLOTS", SLOT_COUNT_VARIABLE = "GODOT_ENGINE_SLOT_COUNT", PROCESSORS_A_SLOT = 2, START_TOLERANCE_MS = 2000, UNWRITTEN_MS = 1e4, SLOT_LOOK_MS = 1000, SLOT_SETTLE_MS = 50, WAIT_SAID_MS = 20000, COMMAND_WAIT_SAID_MS = 2000, START_READ_MS = 1e4, WAITING_FOLDER = "waiting", QUEUED_FOLDER = "queued", SHARE_VARIABLE = "GODOT_ENGINE_SHARE", SHARE_COUNT_VARIABLE = "GODOT_ENGINE_SHARE_COUNT", GATE_KEPT = 1, ONE_OFF_AGED_MS = 120000, TIMED_VARIABLE = "GODOT_ENGINE_TIMED", TIER_VARIABLE = "GODOT_ENGINE_TIER", SEATED_SUFFIX = ".seated", waitsMarked = 0, ENGINE_PID_LOOK_MS = 100, ours, saidTo, takenBy;
 var init_engine_slots = __esm(() => {
   init_alive();
   init_cache_home();
@@ -17960,7 +17986,7 @@ var init_tool_definitions = __esm(() => {
     {
       name: "project_settings",
       title: "Project settings",
-      description: "Reads or writes project.godot (settings, autoloads, the main scene, input actions and plugins) and the audio bus layout, default_bus_layout.tres unless audio/buses/default_bus_layout names another. project_info include lists the autoloads, input actions and audio buses as the project holds them. A write with an editor open on the project is handed to the editor, which takes the settings the write changed or names from the file (named under editorAdopted), including a setting the file already held, since the editor can hold another value after the file was put back, or reloads the bus layout, so it answers the new values and does not save the old ones back over them. editorNote is an editor that could not take the write, or one on another release's addon that was not asked, which still holds the old values until editor_launch restart. An enabled plugin's code still loads on the editor's next start, and enable_plugin notes a script it would not load. set answers old_value and new_value, with was_new true when project.godot did not set the setting before, and was_default true when what it held was the engine's own default, which old_value then is, and overrides with overridesNote when a feature's override still replaces it. add_autoload refuses a name the editor's Autoload tab refuses: not an identifier, a keyword, a built-in type or an engine class. add_input_action on an existing action, a ui_ one included, replaces its events, and its deadzone when one is given, answering was_new false with old_events and old_deadzone. A set of the value the setting already holds, in the same type, writes nothing and answers unchanged true and saved false. unset takes a setting's line out of project.godot and answers removed, old_value and default_value, the value that holds now (null for a setting the engine does not declare; for an override, name.feature, holds is the base setting's value its builds read now); on one the file does not set it answers removed false and writes nothing, its note naming the nearest settings when the engine does not declare it either. Every write changes only the lines of the settings it names and keeps every other line as the file had it, in its place: the engine's own save would sort a dictionary's keys and write what a project_settings_override file laid over the project. get answers exists, true for any setting the engine knows, at_default, true when the value is the engine's own default and so has no line in project.godot, and overrides, the value each feature's override holds. An override answers override_of, its base setting, and one project.godot does not set answers exists false with holds, the base setting's value. Each setting under prefix carries at_default too, so a family read separates what the project sets from the engine's defaults; it is absent for a setting with no engine default, such as an input action the project added.",
+      description: "Reads or writes project.godot (settings, autoloads, the main scene, input actions and plugins) and the audio bus layout, default_bus_layout.tres unless audio/buses/default_bus_layout names another. project_info include lists the autoloads, input actions and audio buses as the project holds them. A write with an editor open on the project is handed to the editor, which takes the settings the write names from the file (named under editorAdopted), even one the file already held, or reloads the bus layout, so it does not save the old values back over them. editorNote is an editor that could not take the write, or one on another release's addon that was not asked, which still holds the old values until editor_launch restart. An enabled plugin's code still loads on the editor's next start, and enable_plugin notes a script it would not load. set answers old_value and new_value, with was_new true when project.godot did not set the setting before, and was_default true when what it held was the engine's own default, which old_value then is, and overrides with overridesNote when a feature's override still replaces it. add_autoload refuses a name the editor's Autoload tab refuses: not an identifier, a keyword, a built-in type or an engine class. add_input_action on an existing action, a ui_ one included, replaces its events, and its deadzone when one is given, answering was_new false with old_events and old_deadzone. A set of the value the setting already holds, in the same type, writes nothing and answers unchanged true and saved false. unset takes a setting's line out of project.godot and answers removed, old_value and default_value, the value that holds now (null for a setting the engine does not declare; for an override, name.feature, holds is the base setting's value its builds read now); on one the file does not set it answers removed false and writes nothing, its note naming the nearest settings when the engine does not declare it either. Every write changes only the lines of the settings it names and keeps every other line as the file had it, in its place. get answers exists, true for any setting the engine knows, at_default, true when the value is the engine's own default and so has no line in project.godot, and overrides, the value each feature's override holds. An override answers override_of, its base setting, and one project.godot does not set answers exists false with holds, the base setting's value. Each setting under prefix carries at_default too; it is absent for a setting with no engine default, such as an input action the project added. A setting res://override.cfg or the project_settings_override file sets, which a run lays over project.godot and the editor does not, is answered with the project's value and overridden_in, the file and the value a run reads; a set adds overriddenNote.",
       parameters: {
         projectPath: PROJECT_PATH,
         setting: {
@@ -18158,7 +18184,7 @@ var init_tool_definitions = __esm(() => {
         direction: {
           type: "string",
           enum: ["forward", "reverse"],
-          description: "forward: what this resource loads or names. Each file named by its path carries kind, as reverse words it: ext_resource, extends, preload, load, include, or path for a path only written in a string, which the file itself may never load. Each reference closing a cycle is marked circular, with the cycle under circular_references. A script's dependencies include every script whose class_name it uses, marked by_class with the name, and the script of every autoload it names, marked by_autoload with the autoload's name. An ext_resource whose uid names another file than its path is followed to that file, as the engine loads it, with the path written under stale_path; one whose uid names no file the project has is followed by its path, as the engine does after warning, with the uid under unknown_uid; and a load or preload of a uid the project does not know is listed under that uid as missing. A shader's #include is followed as the preprocessor reads it, relative to the shader. A file the depth stops at carries beyond_depth, how many files it names that were not walked. A file's dependencies are listed at its first entry, and again further down only where the depth cut that list short and more is left; every other entry for a file naming any carries dependencies_listed_above. summary.total_resources is the file asked about, so 1; total_dependencies counts each file reached, directly or through another, once however many places load it; total_references counts the entries in the tree, and missing names every file referenced that does not exist, with the files referring to it. reverse: every file that refers to it and how, for a file that is gone as well while anything still refers to it, answered with exists: false (a missing file nothing refers to is refused, naming the nearest files), a scene instancing it, a script extending, preloading or loading it, and for a script with a class_name every use of that name, and for an autoload's script every use of the autoload's name, with autoload naming it. Each reference carries a kind: ext_resource, extends, preload, load, include or path for a reference by path, with stale_path when an ext_resource reaches it by its uid under another path, and unknown_uid when one names it by path beside a uid naming no file; setting, plugin, export_preset and import for one in project.godot, a plugin.cfg, export_presets.cfg or an import sidecar; class_name for a use of the declared name, the declaration itself being the script asked about; autoload for code naming the autoload. Three kinds are not uses: doc is a name inside a ## documentation comment, which renaming would break in the generated docs; comment is one in ordinary prose, which it would only make stale; and stale_path is an ext_resource naming it by a path the engine does not load, since its uid leads to the file under loads. summary.in_code is the count with those left out, which is the number to read when the question is whether anything still uses this. Default forward."
+          description: "forward: what this resource loads or names. Each file named by its path carries kind, as reverse words it: ext_resource, extends, preload, load, include, or path for a path only written in a string, which the file itself may never load. Each reference closing a cycle is marked circular, with the cycle under circular_references. A script's dependencies include every script whose class_name it uses, marked by_class with the name, and the script of every autoload it names, marked by_autoload with the autoload's name. An ext_resource whose uid names another file than its path is followed to that file, as the engine loads it, with the path written under stale_path; one whose uid names no file the project has is followed by its path, as the engine does after warning, with the uid under unknown_uid; and a load or preload of a uid the project does not know is listed under that uid as missing. A shader's #include is followed as the preprocessor reads it, relative to the shader. A file the depth stops at carries beyond_depth, how many files it names that were not walked. A file's dependencies are listed at its first entry, and again further down only where the depth cut that list short and more is left; every other entry for a file naming any carries dependencies_listed_above. summary.total_resources is the file asked about, so 1; total_dependencies counts each file reached, directly or through another, once however many places load it; total_references counts the entries in the tree, and missing names every file referenced that does not exist, with the files referring to it. reverse: every file that refers to it and how, for a file that is gone as well while anything still refers to it, answered with exists: false (a missing file nothing refers to is refused, naming the nearest files), a scene instancing it, a script extending, preloading or loading it, and for a script with a class_name every use of that name, and for an autoload's script every use of the autoload's name, with autoload naming it. Each reference carries a kind: ext_resource, extends, preload, load, include or path for a reference by path, with stale_path when an ext_resource reaches it by its uid under another path, and unknown_uid when one names it by path beside a uid naming no file; setting, plugin, export_preset and import for one in project.godot, a plugin.cfg, export_presets.cfg or an import sidecar; class_name for a use of the declared name, the declaration itself being the script asked about; autoload for code naming the autoload. Three kinds are not uses: doc is a name inside a ## documentation comment, which renaming would break in the generated docs; comment is one in ordinary prose, which it would only make stale; and stale_path is an ext_resource naming it by a path the engine does not load, since its uid leads to the file under loads. A file whose header, or an import sidecar, claims the same uid as its own is no use either: it is listed under shares_uid, since the engine maps a uid to one file and loads that one wherever the uid is named. summary.in_code is the count with those left out, which is the number to read when the question is whether anything still uses this. Default forward."
         },
         depth: {
           type: "integer",
@@ -19253,7 +19279,7 @@ var init_tool_definitions = __esm(() => {
       title: "Editor status",
       effect: "read",
       description: "Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and which games with the runtime addon are reachable, of this project and of every other on the machine. Read connected with mayYetConnect: the editor dials this server and backs off between tries, so for the first half-minute after a server starts false means not reached yet as often as no editor; mayYetConnect true is worth waiting out, false is final, and editorCannotConnect, restartInterrupted, restartUnderway, closedHere and editorsNotYetConnected say why. An editor that has connected and not yet greeted reports nothing about itself, and every other call made in that window waits up to ten seconds for it to settle. playingInEditor null means unanswered rather than nothing playing: processActive and runtimes do not depend on the editor answering. game.run names the run editor_output and editor_run stop answer for, and stays named after it ends. addonIsStale, on a connected editor and on each running game (absent with neither), says it runs addon code other than what this server ships, and staleNote says which half moves: the project, by a gdharness upgrade it spells out to run in a shell, the editor by a restart, or this server by a reconnect. A false editor.lspListening or editor.dapListening comes with serversNote: editor_launch rebind binds the debug adapter again in place, and editor_launch restart the language server. editor.scan says whether the editor is scanning, which editor_run waits out before starting a game. A game announced in a protocol this server does not speak is listed under unreadable, during an upgrade that moves the protocol, until the halves match.",
-      answer: "projectIs, when present, is the gdharness version of the addons in the project, which differs from this server's (project_info says which of the two to move), and configIs, when present, the version the project's MCP config starts, which differs from this server's, so the next connection runs that one. server names this server: its pid, its version, and lifecycleLog, the file every gdharness server of the user appends a line to when it starts, when its client first names itself, when it replaces another server of its project, and when it ends, with why it ended (the client closing its end as stdin:end, a signal by name, superseded with the successor's pid, an uncaught exception or rejection with its stack, or the exit code) and the calls it was answering then. The parent's command line follows on its own line a few seconds after the start. A server killed without warning writes no ended line, and on Windows every kill is that, so a started line with no ended line after it is a server something killed. " + "runtimeConnected counts the games of the project this server serves, and runtimes lists every game on the machine with ofThisProject saying which is which, since a game of another project is reached only by naming its projectPath, and userDir, the directory its user:// is, where its saves and settings are read. playingInEditor is null when the editor was not asked or did not answer, which is not the same as a no: with no editor connected there is nobody to ask, and an editor that does not serve the question is given a moment and then left. A game can be playing while this is null, so read it as unanswered rather than as nothing playing, and use processActive and runtimes, which come from elsewhere and do not depend on the editor answering. Its play says which play the editor is on: play.play counts the plays that editor has started since it opened, whoever started them, and play.editorPid is the editor, so two reads with different pairs are two plays even when both say playing. game.run names the run processActive is about, the one editor_output and editor_run stop answer for: its pid, its project, and adopted true when this server read it back from another server rather than starting it. It stays named after the run ends, beside processActive false, so editor_output can still read what that run printed; null when there is no run at all. startedAt says when it began, and endedAt when it ended, wherever something saw the end: a run adopted from a note another server wrote can have ended hours before this server started. editor.lspListening and editor.dapListening say whether anything accepts connections on the ports the editor names, lspPort and dapPort: Godot binds each once, as the editor starts, and reports a failure only in the log panel of the editor itself, so a false comes with serversNote: editor_launch rebind binds the debug adapter again in place, and editor_launch restart the language server. editor.scan says whether the editor is scanning or importing and how many milliseconds ago its last scan finished (finishedMsAgo), or is null when it did not answer: the editor rewrites the class cache just after a scan, and editor_run waits that out before starting a game, saying so under waitedForEditorScanMs. editor.openScenes lists the scenes open in the editor's tabs, leaving out a tab of a scene never saved, editor.editedScene the one it is showing (null when none is, or when that scene was never saved), and editor.unsavedScenes those with changes not yet written to disk, where an empty entry is a scene never saved; all three come with scan and are absent when it is null. Each game under runtimes is pinged with a short wait, so one held at a breakpoint is listed as unreachable rather than making this call wait out the runtime timeout; for the run this server is reporting on, heldAt says whether that is what it is, with the same three answers editor_output gives. A game the editor played announces the editor under editorPid, and so does whatever that game started for itself; a game some other server started announces none, which is how the two are told apart when both are running from one project. Each game also says which runtime addon it loaded, under addonVersion (null when it cannot say); addonIsStale is true when that code is not what this server ships, and staleNote says whether the project needs the gdharness upgrade command, spelled out to run in a shell, the game a restart, or this server a reconnect. A second checkout of a project, such as a git worktree, carries addons of its own and is where this shows. A runtime_* call to such a game is refused with the staleNote and not sent. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means \"not reached yet\" as often as it means \"no editor\". True is worth waiting out; false is an editor that is not there. False beside editorCannotConnect is a project without the gdharness editor addon installed or enabled, where no editor can ever dial in, however young the server or whichever editor is open; its remedies say how to install or enable it. False beside restartInterrupted is one that an editor_launch restart on a previous server asked to quit, where the launch half never ran because that server was ended in between, usually by the reconnect the restart was taken for; editor_launch open finishes it. True beside restartUnderway is a restart still in progress, its server alive and within the wait for the old editor to go: the editor is coming, and opening another would put two on one project. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. Any editor of this project running and not yet connected, whoever opened it, makes it true as well and is named under editorsNotYetConnected with its pid and start time, so a restart a reconnect interrupted after its launch is not read as nothing being there. settingsDropped appears here once when the editor this server opened saved project.godot on its way in and took a key out of it, which is the same reading editor_launch restart makes in its own answer. A game that has announced itself in a protocol this server does not speak is listed under unreadable rather than left out, with the protocol it speaks and whether the server or the addon is the older half. This happens during an upgrade that moves the runtime protocol, which most do not: installing replaces the addon on disk as soon as the pin moves, while a server that is already running stays on the version it started with, so the two speak different protocols until the server is reconnected. Those games are real and running, but no tool here can reach them until the halves match, so runtimes stays empty and runtimeConnected stays false. An upgrade that leaves the protocol alone opens no such window and this list stays empty through it. addonIsStale is decided by the code of the editor addons rather than their version, so an editor started before an upgrade that left that code alone reports the older addonVersion, is not stale, and addonNote says so: it needs no restart. A stale editor is asked nothing but to quit: every other call to it is refused with staleNote, which names editor_launch restart, the upgrade command or a reconnect. port is the one the editor bridge is on; when that is not the one this server was configured with, portWanted names the configured one and portNote says why it moved and, when it was the server this one replaced, which pid kept it. A server replacing another of its project that holds the configured port waits for it to stand down and takes the port over, which takes a few seconds; bridgeHandover says so while it waits, and it moves only if that server has not let go within the wait. An editor that has connected and not yet greeted, which lasts a frame and longer while it imports, reports nothing about itself: greeting says so, addonIsStale is absent rather than guessed, and a restart asked then waits for the greeting to learn who opened it. startedByAnEditor is an editor another editor started, by Godot's own restart or the project manager, which has none of the arguments a server gave the one before it; startedByAnEditorNote says what that costs. An engine run that loads the editor addon to do one job and quit, such as a gate's godot --headless --import, an export or a script, is not taken as the editor: a process that greets without a server's mark has its command line read first, and from the socket opening until its greeting and that read are done, identifying is true and connected false; one started with such an option is turned away, and turnedAway names the last one, its pid and the option. Every other call made while an editor is arriving, before its greeting or while it is looked up, waits up to ten seconds for it to settle rather than acting on connected as it reads in that window. serverVersion is the gdharness version of this server. bridgeAvailable says the editor bridge is listening; when it failed to start, startupError gives the error, and retryingBridge is true while this server tries again. announcedAt is the file where this server told editors of its project which port to dial. connectedAt is when the editor connected, and lastPongAt when it last answered this server's keep-alive ping. addonDigest is a hash of the editor addon's code, which addonIsStale compares with what this server ships. debugPort is the port of the editor's remote debugger, the one games it plays connect to. openedByAServer says a gdharness server started this editor, syncsBreakpoints that it keeps its breakpoints when a debug session opens, which Godot otherwise clears, and hidden that it runs headless with no window anybody can see. pendingRequests counts the requests sent to the editor and not yet answered, and queuedResources the files with writes waiting behind another write to the same file.",
+      answer: "projectIs, when present, is the gdharness version of the addons in the project, which differs from this server's (project_info says which of the two to move), and configIs, when present, the version the project's MCP config starts, which differs from this server's, so the next connection runs that one. server names this server: its pid, its version, and lifecycleLog, the file every gdharness server of the user appends a line to when it starts, when its client first names itself, when it replaces another server of its project, and when it ends, with why it ended (the client closing its end as stdin:end, a signal by name, superseded with the successor's pid, an uncaught exception or rejection with its stack, or the exit code) and the calls it was answering then. The parent's command line follows on its own line a few seconds after the start. A server killed without warning writes no ended line, and on Windows every kill is that, so a started line with no ended line after it is a server something killed. " + "runtimeConnected counts the games of the project this server serves on this release's runtime addon, and runtimes lists every game on the machine with ofThisProject saying which is which, since a game of another project is reached only by naming its projectPath, and userDir, the directory its user:// is, where its saves and settings are read. playingInEditor is null when the editor was not asked or did not answer, which is not the same as a no: with no editor connected there is nobody to ask, and an editor that does not serve the question is given a moment and then left. A game can be playing while this is null, so read it as unanswered rather than as nothing playing, and use processActive and runtimes, which come from elsewhere and do not depend on the editor answering. Its play says which play the editor is on: play.play counts the plays that editor has started since it opened, whoever started them, and play.editorPid is the editor, so two reads with different pairs are two plays even when both say playing. game.run names the run processActive is about, the one editor_output and editor_run stop answer for: its pid, its project, and adopted true when this server read it back from another server rather than starting it. It stays named after the run ends, beside processActive false, so editor_output can still read what that run printed; null when there is no run at all. startedAt says when it began, and endedAt when it ended, wherever something saw the end: a run adopted from a note another server wrote can have ended hours before this server started. editor.lspListening and editor.dapListening say whether anything accepts connections on the ports the editor names, lspPort and dapPort: Godot binds each once, as the editor starts, and reports a failure only in the log panel of the editor itself, so a false comes with serversNote: editor_launch rebind binds the debug adapter again in place, and editor_launch restart the language server. editor.scan says whether the editor is scanning or importing and how many milliseconds ago its last scan finished (finishedMsAgo), or is null when it did not answer: the editor rewrites the class cache just after a scan, and editor_run waits that out before starting a game, saying so under waitedForEditorScanMs. editor.openScenes lists the scenes open in the editor's tabs, leaving out a tab of a scene never saved, editor.editedScene the one it is showing (null when none is, or when that scene was never saved), and editor.unsavedScenes those with changes not yet written to disk, where an empty entry is a scene never saved; all three come with scan and are absent when it is null. Each game under runtimes is pinged with a short wait, so one held at a breakpoint is listed as unreachable rather than making this call wait out the runtime timeout; for the run this server is reporting on, heldAt says whether that is what it is, with the same three answers editor_output gives. A game the editor played announces the editor under editorPid, and so does whatever that game started for itself; a game some other server started announces none, which is how the two are told apart when both are running from one project. Each game also says which runtime addon it loaded, under addonVersion (null when it cannot say); addonIsStale is true when that code is not what this server ships, and staleNote says whether the project needs the gdharness upgrade command, spelled out to run in a shell, the game a restart, or this server a reconnect. A second checkout of a project, such as a git worktree, carries addons of its own and is where this shows. A runtime_* call to such a game is refused with the staleNote and not sent. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means \"not reached yet\" as often as it means \"no editor\". True is worth waiting out; false is an editor that is not there. False beside editorCannotConnect is a project without the gdharness editor addon installed or enabled, where no editor can ever dial in, however young the server or whichever editor is open; its remedies say how to install or enable it. False beside restartInterrupted is one that an editor_launch restart on a previous server asked to quit, where the launch half never ran because that server was ended in between, usually by the reconnect the restart was taken for; editor_launch open finishes it. True beside restartUnderway is a restart still in progress, its server alive and within the wait for the old editor to go: the editor is coming, and opening another would put two on one project. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. Any editor of this project running and not yet connected, whoever opened it, makes it true as well and is named under editorsNotYetConnected with its pid and start time, so a restart a reconnect interrupted after its launch is not read as nothing being there. settingsDropped appears here once when the editor this server opened saved project.godot on its way in and took a key out of it, which is the same reading editor_launch restart makes in its own answer. A game that has announced itself in a protocol this server does not speak is listed under unreadable rather than left out, with the protocol it speaks and whether the server or the addon is the older half. This happens during an upgrade that moves the runtime protocol, which most do not: installing replaces the addon on disk as soon as the pin moves, while a server that is already running stays on the version it started with, so the two speak different protocols until the server is reconnected. Those games are real and running, but no tool here can reach them until the halves match, so runtimes stays empty and runtimeConnected stays false. An upgrade that leaves the protocol alone opens no such window and this list stays empty through it. addonIsStale is decided by the code of the editor addons rather than their version, so an editor started before an upgrade that left that code alone reports the older addonVersion, is not stale, and addonNote says so: it needs no restart. A stale editor is asked nothing but to quit: every other call to it is refused with staleNote, which names editor_launch restart, the upgrade command or a reconnect. port is the one the editor bridge is on; when that is not the one this server was configured with, portWanted names the configured one and portNote says why it moved and, when it was the server this one replaced, which pid kept it. A server replacing another of its project that holds the configured port waits for it to stand down and takes the port over, which takes a few seconds; bridgeHandover says so while it waits, and it moves only if that server has not let go within the wait. An editor that has connected and not yet greeted, which lasts a frame and longer while it imports, reports nothing about itself: greeting says so, addonIsStale is absent rather than guessed, and a restart asked then waits for the greeting to learn who opened it. startedByAnEditor is an editor another editor started, by Godot's own restart or the project manager, which has none of the arguments a server gave the one before it; startedByAnEditorNote says what that costs. An engine run that loads the editor addon to do one job and quit, such as a gate's godot --headless --import, an export or a script, is not taken as the editor: a process that greets without a server's mark has its command line read first, and from the socket opening until its greeting and that read are done, identifying is true and connected false; one started with such an option is turned away, and turnedAway names the last one, its pid and the option. Every other call made while an editor is arriving, before its greeting or while it is looked up, waits up to ten seconds for it to settle rather than acting on connected as it reads in that window. serverVersion is the gdharness version of this server. bridgeAvailable says the editor bridge is listening; when it failed to start, startupError gives the error, and retryingBridge is true while this server tries again. announcedAt is the file where this server told editors of its project which port to dial. connectedAt is when the editor connected, and lastPongAt when it last answered this server's keep-alive ping. addonDigest is a hash of the editor addon's code, which addonIsStale compares with what this server ships. debugPort is the port of the editor's remote debugger, the one games it plays connect to. openedByAServer says a gdharness server started this editor, syncsBreakpoints that it keeps its breakpoints when a debug session opens, which Godot otherwise clears, and hidden that it runs headless with no window anybody can see. pendingRequests counts the requests sent to the editor and not yet answered, and queuedResources the files with writes waiting behind another write to the same file.",
       parameters: {},
       requires: []
     },
@@ -55661,7 +55687,7 @@ ${error.text}`;
         run,
         playingInEditor: playing,
         ...hold,
-        runtimeConnected: games.some((game) => game.reachable && game.ofThisProject !== false),
+        runtimeConnected: games.some((game) => game.reachable && game.ofThisProject !== false && game.addonIsStale !== true),
         runtimes: games,
         unreadable: announced.unspoken.map((game) => ({
           pid: game.pid,

package/build/godot/addons/gdharness_editor/setting_reads.gd

@@ -16,6 +16,13 @@ static func one(setting_path: String, values: GdhSerialisation) -> Dictionary:
 
 	if result["exists"]:
 		var value: Variant = ProjectSettings.get_setting(setting_path)
+		var laid: Dictionary = laid_over(setting_path, override_files())
+		if not laid.is_empty():
+			if not Engine.is_editor_hint():
+				value = laid["project"]
+			result["overridden_in"] = {
+				"file": laid["file"], "value": values.serialize_value(laid["value"]),
+			}
 		result["value"] = values.serialize_value(value)
 		# A setting the engine registers exists whether or not the project sets it, so exists did
 		# not say whether project.godot has a line for it. At its default it has none: the engine
@@ -54,17 +61,25 @@ static func one(setting_path: String, values: GdhSerialisation) -> Dictionary:
 ## wrong: 2 is as true as true is.
 static func under(prefix: String, values: GdhSerialisation) -> Dictionary:
 	var found: Array[Dictionary] = []
+	var overrides: Array[Dictionary] = override_files()
 	for property: Dictionary in ProjectSettings.get_property_list():
 		var name: String = str(property.get("name", ""))
 		if not name.begins_with(prefix):
 			continue
 		var kind: int = GdhRead.as_int(property.get("type", TYPE_NIL), TYPE_NIL)
 		var value: Variant = ProjectSettings.get_setting(name)
+		var laid: Dictionary = laid_over(name, overrides)
+		if not laid.is_empty() and not Engine.is_editor_hint():
+			value = laid["project"]
 		var described: Dictionary = {
 			"setting": name,
 			"type": type_named(kind, value),
 			"value": values.serialize_value(value),
 		}
+		if not laid.is_empty():
+			described["overridden_in"] = {
+				"file": laid["file"], "value": values.serialize_value(laid["value"]),
+			}
 		# As a single get says it, so a family read can be told apart into what the project sets and
 		# the engine's defaults: "input/" is ninety actions the engine ships and the project's few.
 		var default_value: Variant = ProjectSettings.property_get_revert(name)
@@ -81,6 +96,49 @@ static func under(prefix: String, values: GdhSerialisation) -> Dictionary:
 	return { "prefix": prefix, "count": found.size(), "settings": found }
 
 
+## The files a run lays over project.godot, loaded, in the order the engine lays them, each as
+## {"file", "config"}: res://override.cfg, then the file
+## application/config/project_settings_override
+## names. The editor lays neither, so a game keeping a player's window size in user:// had that size
+## answered headless as the project's own setting, while the editor answered the project's.
+static func override_files() -> Array[Dictionary]:
+	var files: Array[Dictionary] = []
+	var named: String = str(
+		ProjectSettings.get_setting("application/config/project_settings_override", "")
+	)
+	for file: String in ["res://override.cfg", named]:
+		var config: ConfigFile = ConfigFile.new()
+		if not file.is_empty() and config.load(file) == OK:
+			files.append({ "file": file, "config": config })
+	return files
+
+
+## What the last of [param overrides], from [method override_files], to set [param setting_path]
+## sets it to, as {"file", "value", "project"}, where project is what project.godot holds, or the
+## engine's default where it has no line: the value the editor holds, unsaved changes aside. Empty
+## when none sets it.
+static func laid_over(setting_path: String, overrides: Array[Dictionary]) -> Dictionary:
+	var at: int = setting_path.find("/")
+	if at <= 0:
+		return {}
+	var section: String = setting_path.left(at)
+	var key: String = setting_path.substr(at + 1)
+	for index: int in range(overrides.size() - 1, -1, -1):
+		var config: ConfigFile = overrides[index]["config"]
+		if not config.has_section_key(section, key):
+			continue
+		var project: ConfigFile = ConfigFile.new()
+		var held: Variant = ProjectSettings.property_get_revert(setting_path)
+		if project.load("res://project.godot") == OK and project.has_section_key(section, key):
+			held = project.get_value(section, key)
+		return {
+			"file": overrides[index]["file"],
+			"value": config.get_value(section, key),
+			"project": held,
+		}
+	return {}
+
+
 ## The type [param kind] names, with what [param value] holds when it is a typed array or
 ## dictionary, as project.godot writes it: a `Dictionary[String, bool]` was answered as Dictionary,
 ## which hides what its keys and values must be.

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

@@ -16,8 +16,9 @@ const SETTLE_MS: int = 8000
 ## How long a window with nothing in it is walked before the client stops: a game building its tree
 ## fills the window within a few frames of being asked, and one building none never does.
 const EMPTY_MS: int = 4000
-## How long starting PowerShell and loading UI Automation may take before the client is stopped. It
-## waits on the machine alone: a warm start takes under a second, and a cold one on a loaded Windows
+## How long starting PowerShell, loading UI Automation and the client's other cold loads may take
+## before the client is stopped. It waits on the machine alone: a warm start takes under a second,
+## and a cold one on a loaded Windows
 ## runner took the whole of a single 23 s budget meant for the walk as well.
 const START_MS: int = 45000
 ## How long the walks may take beyond [constant SETTLE_MS] a window once UI Automation is loaded,
@@ -39,6 +40,7 @@ const NODE_ID: String = "_node_instance"
 const WALK: String = r"""
 $ErrorActionPreference = 'Stop'
 function Answer($value) {
+  Mark 'answering'
   [System.IO.File]::WriteAllText($Out, (ConvertTo-Json -InputObject $value -Depth 100 -Compress))
   Mark 'answered'
 }
@@ -48,7 +50,6 @@ function Mark($stage) {
 try {
   Mark 'began'
   Add-Type -AssemblyName UIAutomationClient, UIAutomationTypes
-  Mark 'loaded'
   $walker = [System.Windows.Automation.TreeWalker]::RawViewWalker
   function Patterned($element, $name) {
     $pattern = ("System.Windows.Automation.$($name)Pattern" -as [type])::Pattern
@@ -70,6 +71,10 @@ try {
   } catch {
     $script:unread = "$_"
   }
+  # Serialised once here, since the first ConvertTo-Json loads its serialiser, and on a loaded
+  # machine that cold load belongs to the start's budget, not to the walks'.
+  $null = ConvertTo-Json -InputObject @{ warm = @(1) } -Depth 100 -Compress
+  Mark 'loaded'
   function FullDescription($element) {
     if ($null -ne $script:unread) { return '' }
     try {
@@ -281,7 +286,9 @@ func get_accessibility(params: Dictionary) -> Dictionary:
 	var looked_at: int = began_at
 	while OS.is_process_running(pid):
 		var now: int = Time.get_ticks_msec()
-		if now - looked_at >= LOOK_MS:
+		# Read again at the deadline too, so an answer marked since the last look is taken rather
+		# than stopped.
+		if now - looked_at >= LOOK_MS or now > deadline:
 			looked_at = now
 			var marked: String = FileAccess.get_file_as_string(progress)
 			if not walking and marked.contains("loaded "):
@@ -756,8 +763,8 @@ static func _marks(progress: String) -> Array:
 
 ## How far a client started at [param started_ms] and stopped at [param stopped_ms] got by the marks
 ## in [param progress], said for a caller whose read it stopped: the time went to starting
-## PowerShell, loading UI Automation, the walks, or after the last walk, and which tells a loaded
-## machine from a window that never answers.
+## PowerShell, loading UI Automation, the walks, after the last walk, or writing the answer, and
+## which tells a loaded machine from a window that never answers.
 static func _reached(progress: String, started_ms: int, stopped_ms: int) -> String:
 	var marks: Array = _marks(progress)
 	var at: Dictionary = {}
@@ -786,7 +793,7 @@ static func _reached(progress: String, started_ms: int, stopped_ms: int) -> Stri
 			)
 			% [began, loaded]
 		)
-	return (
+	var walked: String = (
 		(
 			"PowerShell began the client after %d ms and loaded UI Automation in %d ms, and the "
 			+ "windows were walked %d time%s, the last finding %s element%s and ending %d ms "
@@ -802,6 +809,10 @@ static func _reached(progress: String, started_ms: int, stopped_ms: int) -> Stri
 			stopped_ms - last_at,
 		]
 	)
+	if not at.has("answering"):
+		return walked
+	var answering: int = stopped_ms - at["answering"]
+	return walked + ", which had been writing the answer for %d ms" % answering
 
 
 ## Where the time of a client started at [param started_ms] and done at [param done_ms] went, by

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

@@ -804,12 +804,15 @@ static func with_methods_offered(said: String, object: Object, method: String) -
 			# to a refusal.
 			var flags: int = entry.get("flags", 0)
 			var callable: bool = not object is Script or flags & METHOD_FLAG_STATIC
-			if callable and not name.is_empty() and not own.has(name):
+			# A property's setter and getter are named by the engine, @asked_setter, and offered
+			# they
+			# crowded out the script's own methods with names nobody means.
+			if callable and not name.begins_with("@") and not name.is_empty() and not own.has(name):
 				own.append(name)
 	var every: Array[String] = own.duplicate()
 	for entry: Dictionary in GdhValues.methods_of(object):
 		var name: String = str(entry.get("name", ""))
-		if not every.has(name):
+		if not name.begins_with("@") and not every.has(name):
 			every.append(name)
 	var close: PackedStringArray = GdhRead.nearest(method, PackedStringArray(every))
 	if not close.is_empty():

package/build/godot/operations/dependencies.gd

@@ -281,6 +281,8 @@ func find_resource_usages(params: Dictionary) -> Dictionary:
 	var by_kind: Dictionary = {}
 	var total: int = 0
 	var in_code: int = 0
+	var shares_uid: Array[String] = []
+	var target_uid: String = target["uid"]
 
 	for file_path: String in all_files:
 		# Its own sidecar names it as the file it was imported from, which is not a use of it.
@@ -305,6 +307,11 @@ func find_resource_usages(params: Dictionary) -> Dictionary:
 		var references: Array[Dictionary] = []
 		for i: int in range(lines.size()):
 			var line: String = lines[i]
+			# A file declaring the target's uid as its own is not using it: a resource copied with
+			# its header claims the same uid, and its header line was answered as a use by path.
+			if not target_uid.is_empty() and _own_uid(line, i, file_path) == target_uid:
+				shares_uid.append(file_path)
+				continue
 			var by_its_path: bool = _names_target(line, file_path, target)
 			var by_its_name: bool = false
 			var name_in_comment: bool = false
@@ -408,9 +415,30 @@ func find_resource_usages(params: Dictionary) -> Dictionary:
 	}
 	if not autoload_named.is_empty():
 		answer["autoload"] = autoload_named
+	if not shares_uid.is_empty():
+		answer["shares_uid"] = shares_uid
 	return answer
 
 
+# The uid [param line], line [param index] of [param file_path], declares as the file's own: a
+# scene's or a resource's header, or an import sidecar's uid of the file it imports; empty for any
+# other line.
+static func _own_uid(line: String, index: int, file_path: String) -> String:
+	var trimmed: String = line.strip_edges()
+	var declares: bool = (
+		(
+			index == 0
+			and file_path.get_extension() in ["tscn", "tres"]
+			and (trimmed.begins_with("[gd_scene") or trimmed.begins_with("[gd_resource"))
+		)
+		or (file_path.get_extension() == "import" and trimmed.begins_with('uid="'))
+	)
+	if not declares:
+		return ""
+	var found: RegExMatch = GdhPatterns.compiled('uid="(uid://[^"]+)"').search(trimmed)
+	return "" if found == null else found.get_string(1)
+
+
 # The class_name a script declares, or empty for a scene, a resource or a script without one.
 func _declared_class_name(path: String) -> String:
 	if not path.ends_with(".gd"):

package/build/godot/operations/project_config.gd

@@ -89,8 +89,13 @@ func set_project_setting(params: Dictionary) -> Dictionary:
 
 	var old_value: Variant = null
 	var had_value: bool = ProjectSettings.has_setting(setting_path)
+	var laid: Dictionary = GdhSettingReads.laid_over(
+		setting_path, GdhSettingReads.override_files()
+	)
 	if had_value:
-		old_value = ProjectSettings.get_setting(setting_path)
+		old_value = (
+			ProjectSettings.get_setting(setting_path) if laid.is_empty() else laid["project"]
+		)
 	# A setting the engine registers is there with its default whether or not project.godot sets it,
 	# so has_setting alone called the description of a project that had never set one an old value.
 	# Whether it is new is the file's to say: one at its default has a line only where the project
@@ -131,6 +136,16 @@ func set_project_setting(params: Dictionary) -> Dictionary:
 		"was_default": was_default,
 		"saved": true,
 	}
+	if not laid.is_empty():
+		var read: Variant = _values.serialize_value(laid["value"])
+		answer["overridden_in"] = { "file": laid["file"], "value": read }
+		answer["overriddenNote"] = (
+			(
+				"A run on this machine still reads %s for it from %s, which a run lays over "
+				+ "project.godot and the editor does not."
+			)
+			% [JSON.stringify(read), laid["file"]]
+		)
 	# The same value in the same type is no change, and the file is left alone: a save rewrites it
 	# whole. The type is compared as well, so an int setting the file holds as 50.0 is still put
 	# right.
@@ -254,6 +269,11 @@ func unset_project_setting(params: Dictionary) -> Dictionary:
 	var default_value: Variant = ProjectSettings.property_get_revert(setting_path)
 	var held: bool = ProjectSettings.has_setting(setting_path)
 	var value: Variant = ProjectSettings.get_setting(setting_path) if held else null
+	var laid: Dictionary = GdhSettingReads.laid_over(
+		setting_path, GdhSettingReads.override_files()
+	)
+	if held and not laid.is_empty():
+		value = laid["project"]
 	var answer: Dictionary = {
 		"setting_path": setting_path,
 		"default_value": _values.serialize_value(default_value) if default_value != null else null,

package/build/godot/operations/setting_reads.gd

@@ -16,6 +16,13 @@ static func one(setting_path: String, values: GdhSerialisation) -> Dictionary:
 
 	if result["exists"]:
 		var value: Variant = ProjectSettings.get_setting(setting_path)
+		var laid: Dictionary = laid_over(setting_path, override_files())
+		if not laid.is_empty():
+			if not Engine.is_editor_hint():
+				value = laid["project"]
+			result["overridden_in"] = {
+				"file": laid["file"], "value": values.serialize_value(laid["value"]),
+			}
 		result["value"] = values.serialize_value(value)
 		# A setting the engine registers exists whether or not the project sets it, so exists did
 		# not say whether project.godot has a line for it. At its default it has none: the engine
@@ -54,17 +61,25 @@ static func one(setting_path: String, values: GdhSerialisation) -> Dictionary:
 ## wrong: 2 is as true as true is.
 static func under(prefix: String, values: GdhSerialisation) -> Dictionary:
 	var found: Array[Dictionary] = []
+	var overrides: Array[Dictionary] = override_files()
 	for property: Dictionary in ProjectSettings.get_property_list():
 		var name: String = str(property.get("name", ""))
 		if not name.begins_with(prefix):
 			continue
 		var kind: int = GdhRead.as_int(property.get("type", TYPE_NIL), TYPE_NIL)
 		var value: Variant = ProjectSettings.get_setting(name)
+		var laid: Dictionary = laid_over(name, overrides)
+		if not laid.is_empty() and not Engine.is_editor_hint():
+			value = laid["project"]
 		var described: Dictionary = {
 			"setting": name,
 			"type": type_named(kind, value),
 			"value": values.serialize_value(value),
 		}
+		if not laid.is_empty():
+			described["overridden_in"] = {
+				"file": laid["file"], "value": values.serialize_value(laid["value"]),
+			}
 		# As a single get says it, so a family read can be told apart into what the project sets and
 		# the engine's defaults: "input/" is ninety actions the engine ships and the project's few.
 		var default_value: Variant = ProjectSettings.property_get_revert(name)
@@ -81,6 +96,49 @@ static func under(prefix: String, values: GdhSerialisation) -> Dictionary:
 	return { "prefix": prefix, "count": found.size(), "settings": found }
 
 
+## The files a run lays over project.godot, loaded, in the order the engine lays them, each as
+## {"file", "config"}: res://override.cfg, then the file
+## application/config/project_settings_override
+## names. The editor lays neither, so a game keeping a player's window size in user:// had that size
+## answered headless as the project's own setting, while the editor answered the project's.
+static func override_files() -> Array[Dictionary]:
+	var files: Array[Dictionary] = []
+	var named: String = str(
+		ProjectSettings.get_setting("application/config/project_settings_override", "")
+	)
+	for file: String in ["res://override.cfg", named]:
+		var config: ConfigFile = ConfigFile.new()
+		if not file.is_empty() and config.load(file) == OK:
+			files.append({ "file": file, "config": config })
+	return files
+
+
+## What the last of [param overrides], from [method override_files], to set [param setting_path]
+## sets it to, as {"file", "value", "project"}, where project is what project.godot holds, or the
+## engine's default where it has no line: the value the editor holds, unsaved changes aside. Empty
+## when none sets it.
+static func laid_over(setting_path: String, overrides: Array[Dictionary]) -> Dictionary:
+	var at: int = setting_path.find("/")
+	if at <= 0:
+		return {}
+	var section: String = setting_path.left(at)
+	var key: String = setting_path.substr(at + 1)
+	for index: int in range(overrides.size() - 1, -1, -1):
+		var config: ConfigFile = overrides[index]["config"]
+		if not config.has_section_key(section, key):
+			continue
+		var project: ConfigFile = ConfigFile.new()
+		var held: Variant = ProjectSettings.property_get_revert(setting_path)
+		if project.load("res://project.godot") == OK and project.has_section_key(section, key):
+			held = project.get_value(section, key)
+		return {
+			"file": overrides[index]["file"],
+			"value": config.get_value(section, key),
+			"project": held,
+		}
+	return {}
+
+
 ## The type [param kind] names, with what [param value] holds when it is a typed array or
 ## dictionary, as project.godot writes it: a `Dictionary[String, bool]` was answered as Dictionary,
 ## which hides what its keys and values must be.

package/package.json

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