gdharness 1.3.0 → 1.3.1

package/build/cli.js

@@ -11912,7 +11912,7 @@ var init_tool_definitions = __esm(() => {
   };
   PROPERTIES = {
     type: "object",
-    description: `Properties to set, keyed by Godot property name. Vectors, colours and the like may be written as {"x": 1, "y": 2} or tagged {"_type": "Vector2", "x": 1, "y": 2}, which is the form a read answers with, so a value read off one node can be written straight to another. A key may also be a colon path into one of the components of a vector, a colour, a rectangle or a transform, as GDScript names them, so one axis is written alone: "position:x", "modulate:a", "region_rect:size:y"; a component the value does not have is refused, naming the ones it has. A property holding a node takes the path to it from the node being set, such as "../Player". Each value is read back once set, and one the engine changed or refused is refused with what it holds. ${WHOLE_NUMBERS}`,
+    description: `Properties to set, keyed by Godot property name. Vectors, colours and the like may be written as {"x": 1, "y": 2} or tagged {"_type": "Vector2", "x": 1, "y": 2}, which is the form a read answers with, so a value read off one node can be written straight to another. One carrying a field its type has not, such as a z for a Vector2, is refused naming it. A colour may also be given as its html code, "#ff8000" or "#ff800080". A key may also be a colon path into one of the components of a vector, a colour, a rectangle or a transform, as GDScript names them, so one axis is written alone: "position:x", "modulate:a", "region_rect:size:y"; a component the value does not have is refused, naming the ones it has. A property holding a node takes the path to it from the node being set, such as "../Player". Each value is read back once set, and one the engine changed or refused is refused with what it holds. ${WHOLE_NUMBERS}`,
     additionalProperties: true
   };
   XY = {
@@ -12087,7 +12087,7 @@ var init_tool_definitions = __esm(() => {
         value: {
           blank: true,
           ops: ["set"],
-          description: 'The value to write. Engine types may be tagged, {"_type": "Vector2", "x": 1, "y": 2}, and infinity as {"_type": "float", "value": "inf"}, the form a read answers with. "" writes an empty string.'
+          description: 'The value to write, fitted to the type the setting is registered as, the way scene_node set fits a property. Engine types may be written as their fields, {"x": 1, "y": 2}, or tagged, {"_type": "Vector2", "x": 1, "y": 2}, and infinity as {"_type": "float", "value": "inf"}, the form a read answers with; one carrying a field its type has not is refused naming it, and a colour may also be its html code, "#ff8000". "" writes an empty string.'
         },
         name: { type: "string", ops: ["add_autoload", "remove_autoload"], description: "Autoload name." },
         path: {
@@ -12346,7 +12346,7 @@ var init_tool_definitions = __esm(() => {
       name: "project_test",
       title: "Run tests",
       effect: "additive",
-      description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Each entry under failed carries its first report as message and detail, and, when it has more than one, its reports under reports in the order the case met them: gdUnit4 goes on past a failed assertion, and a case can fail several and then stop on a runtime error, which makes its status error. Identical reports fold into one with times, at most twenty different ones are kept (reportsLeftOut counts the rest), and past about a megabyte the largest cases keep only their first message (failedWithoutDetail). failures counts the cases that failed an assertion and errors the cases that hit an error, so such a case counts in both. Suites where everything passed are counted, not listed, and an engine message keeps the frames above gdUnit4, not the twenty inside it; identical engine messages come back once under engineEntries, with times saying how often they were printed, and engineErrors counts every one. The class list is rebuilt first, so a suite written a moment ago is found, and the rebuild's answer is under classes, with the classes each addon declares counted under addedInAddons and changedInAddons rather than named: a class it puts back that the cache had after the last rebuild is named under classes.lostSinceLastRebuild, which is the editor writing its shorter list over the file on every save until restarted. On Windows and Linux the run gets a user:// of its own, away from a player's saves; on macOS the engine reads user:// off HOME, so it writes where the player keeps theirs, and savesNote says so. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. A script that does not load stops gdUnit4 before any suite runs: its errors come back in full under scriptErrors, and the scripts that failed only because one they depend on did are listed by path under failedThroughDependency. When they failed on a class whose own script has a parser error, which gdUnit4 never names, that script is checked by the engine and its error comes first under scriptErrors, with the class it declares under declares, and the errors a script has only because that class did not resolve, which the engine reads as Variant, are kept apart under followFromUnresolved. An autoload that does not compile stops the run at once, its errors listed the same way. A client sending a progress token is told as each suite finishes, and at least every twenty seconds, so an idle limit does not end a long tier. A run that ends without a report, at its timeout or otherwise, names the suites it finished under suitesFinished, the failing ones with their failed cases under suitesFailing, and the one it was in under suiteRunning. When a client cuts a run off, that is kept in the project and the next project_test there carries it under previousRunCut. A run where nothing failed but nodes were left in the tree comes back under warnings, with the count per suite: gdUnit4 decides its verdict on those and keeps them out of its report, so they are read off what it printed. A run whose every case passed is still not called passed when it printed a script error that no case failed on: gdUnit4 fails a case on the script errors its logger sees, and it cannot see a stack overflow, so the cases pass on whatever the faulted calls returned. Those errors come back under uncaughtScriptErrors, and under engineEntries by index with detailUnder rather than with their backtrace a second time; a backtrace that repeats, as a recursion's does, has each repeated frame or cycle of frames written once with the frames it covers and how many times. One raised inside assert_error(...).is_runtime_error is the test's own and does not count, and none count when the project turns off gdUnit4's report/godot/script_error setting. Needs gdUnit4 under addons/gdUnit4.",
+      description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Each entry under failed carries its first report as message and detail, and, when it has more than one, its reports under reports in the order the case met them: gdUnit4 goes on past a failed assertion, and a case can fail several and then stop on a runtime error, which makes its status error. Identical reports fold into one with times, at most twenty different ones are kept (reportsLeftOut counts the rest), and past about a megabyte the largest cases keep only their first message (failedWithoutDetail). failures counts the cases that failed an assertion and errors the cases that hit an error, so such a case counts in both. Suites where everything passed are counted, not listed, and an engine message keeps the frames above gdUnit4, not the twenty inside it; identical engine messages come back once under engineEntries, with times saying how often they were printed, and engineErrors counts every one. The class list is rebuilt first, so a suite written a moment ago is found, and the rebuild's answer is under classes, with the classes each addon declares counted under addedInAddons and changedInAddons rather than named: a class it puts back that the cache had after the last rebuild is named under classes.lostSinceLastRebuild, which is the editor writing its shorter list over the file on every save until restarted. What changed on disk since it was imported is then imported before any suite runs, and named under importedFirst. On Windows and Linux the run gets a user:// of its own, away from a player's saves; on macOS the engine reads user:// off HOME, so it writes where the player keeps theirs, and savesNote says so. A run that found nothing to run is never called a pass, and names the path it looked in. A script that does not load stops gdUnit4 before any suite runs: its errors come back in full under scriptErrors, and the scripts that failed only because one they depend on did are listed by path under failedThroughDependency. When they failed on a class whose own script has a parser error, which gdUnit4 never names, that script is checked by the engine and its error comes first under scriptErrors, with the class it declares under declares, and the errors a script has only because that class did not resolve, which the engine reads as Variant, are kept apart under followFromUnresolved. An autoload that does not compile stops the run at once, its errors listed the same way. A client sending a progress token is told as each suite finishes, and at least every twenty seconds. A run that ends without a report, at its timeout or otherwise, names the suites it finished under suitesFinished, the failing ones with their failed cases under suitesFailing, and the one it was in under suiteRunning. When a client cuts a run off, that is kept in the project and the next project_test there carries it under previousRunCut. A run where nothing failed but nodes were left in the tree comes back under warnings, with the count per suite: gdUnit4 decides its verdict on those and keeps them out of its report, so they are read off what it printed. A run whose every case passed is still not called passed when it printed a script error that no case failed on: gdUnit4 fails a case on the script errors its logger sees, and it cannot see a stack overflow, so the cases pass on whatever the faulted calls returned. Those errors come back under uncaughtScriptErrors, and under engineEntries by index with detailUnder rather than with their backtrace a second time; a backtrace that repeats, as a recursion's does, has each repeated frame or cycle of frames written once with the frames it covers and how many times. One raised inside assert_error(...).is_runtime_error is the test's own and does not count, and none count when the project turns off gdUnit4's report/godot/script_error setting. Needs gdUnit4 under addons/gdUnit4.",
       answer: "time is gdUnit4's own sum of the seconds its cases took, from its report. tookMs is the whole call in milliseconds, from the class rebuild to the engine's exit, which is what a caller waits for. " + IMPORTED_FIRST,
       parameters: {
         projectPath: PROJECT_PATH,
@@ -12437,7 +12437,7 @@ var init_tool_definitions = __esm(() => {
     {
       name: "scene_node",
       title: "Scene nodes",
-      description: `One node in a scene file: add, read, set, duplicate, reparent or delete it, or paint TileMap cells. Any ClassDB node type or script class can be added, so a NavigationRegion2D, an AnimationTree or a Camera3D is an add with that nodeType and its properties, and another scene is instanced by an add with instancePath. A set with properties {"name": "Boss"} renames a node, and answers nodePath as its new path. A rename or a reparent carries the node paths naming the node, as the editor's rename does: NodePath values on nodes (in arrays, dictionaries, built-in resources, %unique paths) and the tracks its players' animations hold, saving a library kept in a .tres of its own. Each rewrite is listed under retargeted ({scenePath, nodePath, property or animation and track, from, to}), and under notRetargeted, with a reason, each left: a track kept in another scene or an imported file, or a value another scene gives that the move left naming nothing. The move is followed into every other .tscn that instances or inherits this scene at any depth: the editable children, values, added nodes and connections named by the old path are rewritten, since Godot finds a moved node's values by unique_id but editable children only by path and drops the values kept below them on the next save, and that scene's node paths and tracks are carried as above. A reparent also drops the node ids saved along each rewritten path, which ran through the old parent; the next save writes them again. The scenes rewritten are named under followed, and under notFollowed any left as they were, with why. A delete rewrites no path and lists under stillNaming each node path and track, here and in the scenes instancing or inheriting this one, that named the deleted node and now names nothing. A property holding a Resource takes the res:// path of one, so a texture, a material or a theme is a set like any other. A write is refused while the editor holds unsaved changes to the scene. A node this scene inherits takes values of this scene's own, and so does a node inside an instance of another scene once that instance's editableChildren is true; neither can be moved, renamed, copied or deleted, since the other scene makes it again on load. ${WITHOUT_AN_EDITOR}`,
+      description: `One node in a scene file: add, read, set, duplicate, reparent or delete it, or paint TileMap cells. Any ClassDB node type or script class can be added, so a NavigationRegion2D, an AnimationTree or a Camera3D is an add with that nodeType and its properties, and another scene is instanced by an add with instancePath. A set with properties {"name": "Boss"} renames a node, and answers nodePath as its new path. A rename or a reparent carries the node paths naming the node, as the editor's rename does: NodePath values on nodes (in arrays, dictionaries, built-in resources, %unique paths) and the tracks its players' animations hold, saving a library kept in a .tres of its own. Each rewrite is listed under retargeted ({scenePath, nodePath, property or animation and track, from, to}), and under notRetargeted, with a reason, each left: a track kept in another scene or an imported file, or a value another scene gives that the move left naming nothing. The move is followed into every other .tscn that instances or inherits this scene at any depth: the editable children, values, added nodes and connections named by the old path are rewritten, since Godot finds a moved node's values by unique_id but editable children only by path and drops the values kept below them on the next save, and that scene's node paths and tracks are carried as above. A reparent also drops the node ids saved along each rewritten path, which ran through the old parent; the next save writes them again. The scenes rewritten are named under followed, and under notFollowed any left as they were, with why. A delete rewrites no path and lists under stillNaming each node path and track, here and in the scenes instancing or inheriting this one, that named the deleted node and now names nothing. A property holding a Resource takes the res:// path of one, so a texture, a material or a theme is a set like any other. Other properties the engine changed in step, as a Control's offsets with its size, come back under alsoChanged as {was, now}.A write is refused while the editor holds unsaved changes to the scene. A node this scene inherits takes values of this scene's own, and so does a node inside an instance of another scene once that instance's editableChildren is true; neither can be moved, renamed, copied or deleted, since the other scene makes it again on load. ${WITHOUT_AN_EDITOR}`,
       parameters: {
         projectPath: PROJECT_PATH,
         scenePath: SCENE_PATH,
@@ -12790,7 +12790,7 @@ var init_tool_definitions = __esm(() => {
     {
       name: "resource_edit",
       title: "Edit resources",
-      description: 'Resource files: read one, create any ClassDB resource as .tres, change one, write a shader, build a TileSet, or set a Theme colour or font size. A material is a create with resourceType StandardMaterial3D, ShaderMaterial or CanvasItemMaterial. read answers with the properties the file sets, in the form modify takes, and a Theme lists its items there as "Button/colors/font_color". move takes any file of the project, a script or an image as much as a resource, or a directory, and works from the files, so it needs no editor; one serving the project is brought up to it as after a move in its own FileSystem dock, its open scenes and cached resources named for the new paths and the project settings the move rewrote taken from the file. read needs no editor either: with none serving the project, a headless engine reads the file. The ops that write a resource go through the editor when one serves the project; with none, a headless engine runs the tool the editor would and the answer says so under writtenBy. That engine runs the script of the resource, where the editor runs only tool scripts, so what a script changes as the file loads or as a property is set is put back before the save, and a resource where that cannot be done is refused and the file left as it was.',
+      description: 'Resource files: read one, create any ClassDB resource as .tres, change one, write a shader, build a TileSet, or set a Theme colour or font size. A material is a create with resourceType StandardMaterial3D, ShaderMaterial or CanvasItemMaterial. read answers with the properties the file sets, in the form modify takes, and a Theme lists its items there as "Button/colors/font_color". A create or modify whose properties made the engine change others, as a Gradient given more colours than offsets gives each new point an offset of 0, names each of those under alsoChanged with what it held before and holds now. move takes any file of the project, a script or an image as much as a resource, or a directory, and works from the files, so it needs no editor; one serving the project is brought up to it as after a move in its own FileSystem dock, its open scenes and cached resources named for the new paths and the project settings the move rewrote taken from the file. read needs no editor either: with none serving the project, a headless engine reads the file. The ops that write a resource go through the editor when one serves the project; with none, a headless engine runs the tool the editor would and the answer says so under writtenBy. That engine runs the script of the resource, where the editor runs only tool scripts, so what a script changes as the file loads or as a property is set is put back before the save, and a resource where that cannot be done is refused and the file left as it was.',
       parameters: {
         projectPath: PROJECT_PATH,
         resourcePath: {
@@ -12925,7 +12925,7 @@ var init_tool_definitions = __esm(() => {
     {
       name: "editor_run",
       title: "Run the game",
-      description: "The run: starting the project, stopping it, or booting it once to see whether it comes up clean. start keeps it running and collecting output until it quits or is stopped, windowed where there is a display and headless where there is not, unless headless says otherwise; only runtime_capture needs the window. A run that quits on its own is kept, so a scene that prints an answer and quits is start, then editor_output until running is false. What runs is a scene: a SceneTree script is not an entry point here, so put the script on the root of a scene of its own and name that in scene. args hands the game its own flags, the ones it reads with OS.get_cmdline_user_args(), and a run carrying any is started by this server rather than by the editor. check boots it headless for a few frames, waits for it to quit, and answers with the verdict: whether it came up, and every error and warning it printed on the way. start and check both wait first for a scan the open editor is running and for the class cache it writes just after, since a game booted in between resolves no global class, as does every other engine this server starts on the project; waitedForEditorScanMs says how long, and scanNote says when a scan ran past thirty seconds and the game started during it. A start waits for the game to become something the runtime_* tools can talk to and says which it is under runtime: listening with the port it took, or why not, so the first call after a start does not have to be made twice. When it is not listening, mayYetAnnounce says whether that is final: false is a runtime that is not coming, true is a game still on its way up, which editor_status will see and runtimeWaitMs waits longer for, and the note then says what a runtime_* call naming no projectPath meets until it announces. A start this server made also answers with transcript, the file both the run's streams are written to, so a watch on it can be armed off the start rather than off a second call.",
+      description: "The run: starting the project, stopping it, or booting it once to see whether it comes up clean. start keeps it running and collecting output until it quits or is stopped, windowed where there is a display and headless where there is not, unless headless says otherwise; only runtime_capture needs the window. A run that quits on its own is kept, so a scene that prints an answer and quits is start, then editor_output until running is false. What runs is a scene: a SceneTree script is not an entry point here, so put the script on the root of a scene of its own and name that in scene. args hands the game its own flags, the ones it reads with OS.get_cmdline_user_args(), and a run carrying any is started by this server rather than by the editor. check boots it headless for a few frames, waits for it to quit, and answers with the verdict: whether it came up, and every error and warning it printed on the way. start and check both wait first for a scan the open editor is running and for the class cache it writes just after, since a game booted in between resolves no global class, as does every other engine this server starts on the project; waitedForEditorScanMs says how long, and scanNote says when a scan ran past thirty seconds and the game started during it. Then whatever changed on disk since it was imported is imported, and named under importedFirst. A start waits for the game to become something the runtime_* tools can talk to and says which it is under runtime: listening with the port it took, or why not, so the first call after a start does not have to be made twice. When it is not listening, mayYetAnnounce says whether that is final: false is a runtime that is not coming, true is a game still on its way up, which editor_status will see and runtimeWaitMs waits longer for, and the note then says what a runtime_* call naming no projectPath meets until it announces. A start this server made also answers with transcript, the file both the run's streams are written to, so a watch on it can be armed off the start rather than off a second call.",
       parameters: {
         projectPath: {
           ...PROJECT_PATH,
@@ -13065,13 +13065,14 @@ var init_tool_definitions = __esm(() => {
           requires: []
         }
       },
-      answer: "start: through is gdharness for a game this server started itself, and editor for one the editor plays. scene is the scene the game started in, the project's main scene when none was given. 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). 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. start and check: " + IMPORTED_FIRST + " An exported build carries its own imports and is not asked. profile: per function its script, the function (Class.name when the script declares a class_name), the line its body's first statement is on, for a lambda the named function it is written in (within), calls, and self and total milliseconds, with functionsCounted, scriptMs (the self time of them all) and coveredMs. The runtime addon's own functions, gdharness answering its tools inside the game, are not among them: their self time is runtimeAddonMs, over runtimeAddonFunctions functions. complete is true when the engine's own totals arrived, which it sends only when the profiler is switched off: the runtime addon does that as a game quits, so a scene that does its work in _ready and quits is covered whole; otherwise the answer is the frames summed so far and the note says what that misses. frames counts the frames of the profile that arrived, and the engine's totals also hold the work after the last of them, so once complete a function run every frame can show a call more than frames. Self time counts a call into the engine's own methods as the caller's, and a call through super too, while the overridden function's row counts it again: such a row carries selfIncludesSuper, so self times along an override chain overlap. The profiler's own cost of timing a call lands in the self time of the function called; with the runtime addon it is measured each run on an empty function, as perCallOverheadUs, and a row with at least half its selfMs in it carries overheadMs, since a small function called often costs that much less without the profiler. A function the profiler started inside is left out, since its time would be counted from the engine's start. The milliseconds are time passed while the function ran, not processor time given to it, so they grow when other processes compete for the processor: compare two profiles taken under the same load. They are also summed over every thread: a function run by WorkerThreadPool or a Thread on several threads at once counts each thread's time, the engine does not say which thread a call ran on, and a function waiting for them has the wait in its own self time, so selfMs is not time taken from frames, and scriptMs can exceed coveredMs, which the note then says. A property's get and set blocks are named Class.@name_getter and Class.@name_setter, as the engine names them, and their rows carry property, the property's name. A game the editor plays that was not started with profile: true says, in the answer, that it was profiled from the moment it was asked. A profile with mark answers marked: true; one with since answers since: \"mark\" and markSetMsAgo, and lessThanAtMark counts the functions left out for reading less than at the mark, which the engine's own totals, capped, can do when they replace the frames' sum.",
+      answer: "start: through is gdharness for a game this server started itself, and editor for one the editor plays. scene is the scene the game started in, the project's main scene when none was given. runtime carries addonIsStale and staleNote when the game announced on a runtime addon other than this server's, which no runtime_* call is then sent to, and staleNote says what brings it into step. refreshedClasses names the class_name declarations on disk that the engine's class cache was missing, which were added to it before the game started so the game could resolve them; it is empty when the cache was current. stop: endedPid is, for a run the editor plays, the number its game announced under, read at the stop rather than remembered, and the operating system hands a freed number to the next process, so it can equal the game before it. stopped is false, with the number under notSignalled, when that number no longer answers as the process the run was started as and nothing was signalled, the note naming which property it failed on, and false with the number under stillGoing when what was told to end was still running ten seconds later. endedThrough says how the stop ended a run that was going: close (the game was asked to close and exited, so exitCode is its own), keeper (the process that started the game ended it through the handle it holds), signal (its pid was signalled once shown to still be the run), or editor (the editor playing it was asked). exitedBeforeStop is true when the run was already over when the stop came, so nothing was ended and exitCode, when anything collected it, is the one it ended with. A start that ends the run before it says how under endedPreviousRunThrough, with the same values, and one that refused to signal that run names the property it failed on under previousRunLeftBecause. check: hung is a run killed at timeoutMs, and errors and warnings count what it printed, which comes back under entries with repeats folded together. entries holds the errors and warnings and not the ordinary lines the run printed, which printedLinesNotShown counts; a check given --verbose holds those too, and editor_run start then editor_output reads everything. An engine crash is an error whatever it prints after: the crash handler's report is the entry, and the engine version and the native and GDScript backtraces are its detail, so a crashed run is never booted or clean. arguments is the engine command line the check ran, as a start's is, and durationMs runs from that engine's start to the check's answer, after its exit, so it holds no import that came first. start and check: " + IMPORTED_FIRST + " An exported build carries its own imports and is not asked. waitedForEditorScanMs and scanNote are left out when no editor scan was waited for. A silent windowed run has --audio-driver Dummy in its arguments; a headless run is silent without it, and one the editor plays with sound has no arguments of its own. profile: per function its script, the function (Class.name when the script declares a class_name), the line its body's first statement is on, for a lambda the named function it is written in (within), calls, and self and total milliseconds, with functionsCounted, scriptMs (the self time of them all) and coveredMs. The runtime addon's own functions, gdharness answering its tools inside the game, are not among them: their self time is runtimeAddonMs, over runtimeAddonFunctions functions. complete is true when the engine's own totals arrived, which it sends only when the profiler is switched off: the runtime addon does that as a game quits, so a scene that does its work in _ready and quits is covered whole; otherwise the answer is the frames summed so far and the note says what that misses. frames counts the frames of the profile that arrived, and the engine's totals also hold the work after the last of them, so once complete a function run every frame can show a call more than frames. Self time counts a call into the engine's own methods as the caller's, and a call through super too, while the overridden function's row counts it again: such a row carries selfIncludesSuper, so self times along an override chain overlap. The profiler's own cost of timing a call lands in the self time of the function called; with the runtime addon it is measured each run on an empty function, as perCallOverheadUs, and a row with at least half its selfMs in it carries overheadMs, since a small function called often costs that much less without the profiler. A function the profiler started inside is left out, since its time would be counted from the engine's start. The milliseconds are time passed while the function ran, not processor time given to it, so they grow when other processes compete for the processor: compare two profiles taken under the same load. They are also summed over every thread: a function run by WorkerThreadPool or a Thread on several threads at once counts each thread's time, the engine does not say which thread a call ran on, and a function waiting for them has the wait in its own self time, so selfMs is not time taken from frames, and scriptMs can exceed coveredMs, which the note then says. A property's get and set blocks are named Class.@name_getter and Class.@name_setter, as the engine names them, and their rows carry property, the property's name. A game the editor plays that was not started with profile: true says, in the answer, that it was profiled from the moment it was asked. A profile with mark answers marked: true; one with since answers since: \"mark\" and markSetMsAgo, and lessThanAtMark counts the functions left out for reading less than at the mark, which the engine's own totals, capped, can do when they replace the frames' sum.",
       defaultOperation: "start"
     },
     {
       name: "editor_output",
       title: "Game and editor output",
       description: "What the project started by editor_run has printed, as entries with a severity: the errors and warnings the engine reported, each with where it happened, and everything else as info. For a run the editor plays the reports come from the game itself, through the runtime addon, since the editor's debugger relays what a game prints and not what it reports; a played game without the runtime addon answers here with its prints alone, with errorsUnread true and no clean, since what it raised reaches nothing here. Answers with the counts and the verdict as well as the entries: clean is true when no error was reported, and warnings, counted beside it, do not make it false. heldAt is three answers: null for a run this server knows is not held, running or over, an object for one it knows is held at a breakpoint, whether the adapter said so or the runtime did by accepting a connection and never answering, and absent with heldUnknown beside it for a server that connected to the debugger after the stop and has no runtime to ask, since the adapter reports a stop only to the sessions connected when it happened. A run that has quit still answers here, with running false and its exit code, until the next one starts; a run ended by a signal has no exit code, and exitSignal names the signal instead. A run this server started also answers with transcript, the file both its streams are written to: uncapped, written while the run is going, and the thing to read or tail for a long run rather than the engine's own log, which every engine start rotates away. Read the file for output and this answer for state: endedBy says whether gdharness ended the run, and a transcript that has stopped growing is a run between prints rather than a run that is over. running is asked of the operating system whenever there is a process to ask about, which is every run this server started and every editor-played run whose game announced its runtime. For an editor-played run that never announced, there is no process id here and running is the editor's answer, which can lag: one measured elsewhere reported a game as playing for fifteen seconds after its process had been ended from outside. editor_status names that game under runtimes, which does not depend on the editor answering. op: \"editor\" answers about the editor itself instead, which is a different log and the only way anything here can read what an editor printed: its console reaches no plugin, so the addon cannot scrape it, and an editor gdharness opened is asked for a log file as it starts. That covers the whole session from the editor's first line, which is where the output worth reading usually is, since the class cache, the plugins and the language server all say what they have to say before any harness has connected. The answer carries the entries in the order they were printed and, beside them under repeated, each message shape several lines share: how many, what varied in each slot of it and how many different values stood there, the first occurrence, and the ordinary lines above the group, found by walking back past the group rather than by counting lines. An editor somebody opened by hand has no console here and is refused saying so rather than answered empty, because an editor that printed nothing and an editor nobody captured are not the same thing. startedAt is when the run began and elapsedMs how long it has been going; for a run that is over, endedAt is when it ended and elapsedMs how long it ran, and both are left out when nobody saw the end, as for a game closed in the editor or a run picked up from a note written before ends were recorded.",
+      answer: "Each entry's source says where it was read: transcript for a line of the run's transcript file, which holds both its streams and is how every run with one is read; stdout or stderr for a line of that stream of a run with no transcript, such as an editor-played run picked up after a reconnect whose first server left no note; debugger for what the editor's debug adapter reported and the game never printed, such as the script error a game stopped on.",
       parameters: {
         projectPath: {
           type: "string",
@@ -13349,7 +13350,7 @@ var init_tool_definitions = __esm(() => {
         value: {
           ops: ["set"],
           blank: true,
-          description: `set: the value, fitted to the property's type. ${WHOLE_NUMBERS} A number the property would have to cut is refused rather than truncated: a fraction into an int, a number other than 0 or 1 into a bool. A vector, colour or the like may be written as its fields, {"x": 140, "y": 300}, or tagged, {"_type": "Vector2", "x": 140, "y": 300}, which is the form a read answers with. "" writes an empty string. A property typed as or holding an object takes a path naming one the game holds, the way call's args do, and holds that instance, or null, which the text null also means, to empty it. One declared as Variant or untyped takes anything, as the engine does: a value of the kind it holds is fitted to it, an int staying an int, and any other is stored as sent, a fraction into one holding an int included. A typed list or map, such as Array[int] or Dictionary[String, int], takes a JSON list or object with each element fitted to its element type, and an element that cannot become one is refused by its index or key, as is an object of another script than the one the list holds, whether or not that script has a class_name.`
+          description: `set: the value, fitted to the property's type. ${WHOLE_NUMBERS} A number the property would have to cut is refused rather than truncated: a fraction into an int, a number other than 0 or 1 into a bool. A vector, colour or the like may be written as its fields, {"x": 140, "y": 300}, or tagged, {"_type": "Vector2", "x": 140, "y": 300}, which is the form a read answers with, and one carrying a field its type has not, such as a z for a Vector2, is refused naming it. A colour may also be given as its html code, "#ff8000" or "#ff800080". "" writes an empty string. A property typed as or holding an object takes a path naming one the game holds, the way call's args do, and holds that instance, or null, which the text null also means, to empty it. One declared as Variant or untyped takes anything, as the engine does: a value of the kind it holds is fitted to it, an int staying an int, and any other is stored as sent, a fraction into one holding an int included. A typed list or map, such as Array[int] or Dictionary[String, int], takes a JSON list or object with each element fitted to its element type, and an element that cannot become one is refused by its index or key, as is an object of another script than the one the list holds, whether or not that script has a class_name.`
         },
         method: {
           type: "string",
@@ -13402,7 +13403,7 @@ var init_tool_definitions = __esm(() => {
     {
       name: "runtime_capture",
       title: "Capture the screen",
-      description: "A picture of the running game: the whole screen, one region or node of it at full resolution, or one viewport, as an image. The whole screen includes the game's own dialogs and popups where they sit, also when a project opens them as windows of their own (subwindows not embedded). Needs the game running with a window. A capture asked for before the game's first frame is drawn waits for that frame, since the game announces itself before it and the viewport holds nothing it drew until then.",
+      description: "A picture of the running game: the whole screen, one region or node of it at full resolution, or one viewport, as an image. The whole screen is the game's window, with the game's own dialogs and popups laid over it where they sit, also when a project opens them as windows of their own (subwindows not embedded); one of its windows lying outside the game's window, or minimised, is not in it, and viewport captures a shown one by its path. Needs the game running with a window. A capture asked for before the game's first frame is drawn waits for that frame, since the game announces itself before it and the viewport holds nothing it drew until then.",
       parameters: {
         projectPath: RUNNING_PROJECT_PATH,
         pid: RUNNING_PID,
@@ -49814,7 +49815,7 @@ class GodotServer {
     if (going !== null && !running) {
       this.drainTranscript(going);
     }
-    return runtimeVerdict(endpoint, {
+    const verdict = runtimeVerdict(endpoint, {
       addon: true,
       budgetMs,
       ...budget.sizedToMs === undefined ? {} : { sizedToMs: budget.sizedToMs },
@@ -49825,6 +49826,8 @@ class GodotServer {
       ...going?.throughEditor === true ? { playingSeen: going.seenPlaying === true } : {},
       runtimeCameUp: going !== null && !running && going.log.all.some((entry) => entry.text.startsWith(RUNTIME_LISTENING_LINE))
     });
+    const staleNote = endpoint === null ? undefined : this.runtimeStaleNote(endpoint);
+    return staleNote === undefined ? verdict : { ...verdict, addonIsStale: true, staleNote };
   }
   announceBudget(args, projectPath, scene) {
     const key = scene ?? MAIN_SCENE;
@@ -52378,9 +52381,7 @@ class GodotServer {
     }
     const staleNote = this.runtimeStaleNote(choice.endpoint);
     if (staleNote !== undefined) {
-      return this.createErrorResponse(staleNote, [
-        "editor_status lists the game and the runtime addon it loaded"
-      ]);
+      return this.createErrorResponse(staleNote);
     }
     const screenshotDir = expectsScreenshot ? scratchDirectory("runtime-screenshot") : null;
     const screenshotPath = screenshotDir ? join33(screenshotDir, "capture.png") : null;

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

@@ -4,9 +4,8 @@ extends RefCounted
 ## and by a headless engine with none connected from a bare node of the class given what the file
 ## stores, which runs no script of the scene's, so a read answers the same either way.
 
-const FileReads = preload("file_reads.gd")
-const Read = preload("reading.gd")
-const Serialisation = preload("serialisation.gd")
+const GdhFileReads = preload("file_reads.gd")
+const GdhSerialisation = preload("serialisation.gd")
 
 const LOOP_MODE_NAMES: Dictionary[int, String] = {
 	Animation.LOOP_NONE: "none",
@@ -56,21 +55,10 @@ static func scene_states(scene_path: String, tree_path: String, state_machine_pa
 ## A node of the class the file gives the node at [param node_path], holding every property the
 ## files set but its script, as [node, null] or [null, refusal]. The caller frees it.
 static func _bare(scene_path: String, node_path: String, kind: String) -> Array:
-	var read: Dictionary = FileReads.scene_node(scene_path, node_path)
-	if not read.is_empty() and not read.get("ok", false):
+	var read: Dictionary = GdhFileReads.scene_node_of_kind(scene_path, node_path, kind)
+	if not read.get("ok", false):
 		return [null, read]
-	var type: String = str(read.get("type", ""))
-	if not ClassDB.class_exists(type) or not ClassDB.is_parent_class(type, kind):
-		var said: String = "%s not found at: %s" % [kind, node_path]
-		if read.is_empty():
-			var hinted: String = said
-			if FileReads.scene_node(scene_path, node_path.get_slice("/", 0)).is_empty():
-				hinted = Read.from_the_root(
-					said, node_path, str(FileReads.scene_node(scene_path, ".").get("name", ""))
-				)
-			said = hinted if hinted != said else FileReads.missing_from(said, scene_path, node_path)
-		return [null, {"ok": false, "error": said}]
-	var bare: Node = ClassDB.instantiate(type)
+	var bare: Node = ClassDB.instantiate(str(read["type"]))
 	bare.name = str(read["name"])
 	var given: Dictionary = read["properties"]
 	for property: Variant in given:
@@ -107,7 +95,7 @@ static func animations(player: AnimationPlayer, animation_name: String) -> Dicti
 	answer["ok"] = true
 	answer["animationName"] = animation_name
 	var tracks: Array[Dictionary] = []
-	var values: Serialisation = Serialisation.new()
+	var values: GdhSerialisation = GdhSerialisation.new()
 	for track: int in anim.get_track_count():
 		tracks.append(_track(anim, track, values))
 	answer["tracks"] = tracks
@@ -122,7 +110,7 @@ static func _summary(anim: Animation) -> Dictionary:
 	}
 
 
-static func _track(anim: Animation, track: int, values: Serialisation) -> Dictionary:
+static func _track(anim: Animation, track: int, values: GdhSerialisation) -> Dictionary:
 	var kind: int = anim.track_get_type(track)
 	var path: NodePath = anim.track_get_path(track)
 	var shaped: Dictionary = {

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

@@ -8,7 +8,7 @@ signal connected
 signal disconnected
 signal tool_requested(request_id: String, tool_name: String, args: Dictionary)
 
-const Read = preload("reading.gd")
+const GdhRead = preload("reading.gd")
 
 const DEFAULT_URL: String = "ws://127.0.0.1:6505/godot"
 ## Written beside the addon by the install, so it names the version this copy came from.
@@ -256,15 +256,15 @@ func announced_url() -> String:
 	var file: FileAccess = FileAccess.open(ANNOUNCEMENT, FileAccess.READ)
 	if file == null:
 		return ""
-	var said: Variant = Read.json_or_null(file.get_as_text())
+	var said: Variant = GdhRead.json_or_null(file.get_as_text())
 	file.close()
 	if not said is Dictionary:
 		return ""
 
 	var announcement: Dictionary = said
-	if Read.as_int(announcement.get("protocol", 0)) != ANNOUNCE_PROTOCOL:
+	if GdhRead.as_int(announcement.get("protocol", 0)) != ANNOUNCE_PROTOCOL:
 		return ""
-	var port: int = Read.as_int(announcement.get("port", 0))
+	var port: int = GdhRead.as_int(announcement.get("port", 0))
 	if port < 1 or port > 65535:
 		return ""
 	var host: String = str(announcement.get("host", "127.0.0.1"))
@@ -382,7 +382,7 @@ func _keep_breakpoints_through_sessions() -> void:
 	var settings: EditorSettings = EditorInterface.get_editor_settings()
 	if settings == null or not settings.has_setting(SYNC_BREAKPOINTS_SETTING):
 		return
-	if Read.as_bool(settings.get_setting(SYNC_BREAKPOINTS_SETTING)):
+	if GdhRead.as_bool(settings.get_setting(SYNC_BREAKPOINTS_SETTING)):
 		return
 	settings.set_setting(SYNC_BREAKPOINTS_SETTING, true)
 	# Stored is not the same as noticed. The adapter reads this setting again on the editor-wide
@@ -406,7 +406,7 @@ func _syncs_breakpoints() -> bool:
 	var settings: EditorSettings = EditorInterface.get_editor_settings()
 	if settings == null or not settings.has_setting(SYNC_BREAKPOINTS_SETTING):
 		return false
-	return Read.as_bool(settings.get_setting(SYNC_BREAKPOINTS_SETTING))
+	return GdhRead.as_bool(settings.get_setting(SYNC_BREAKPOINTS_SETTING))
 
 
 ## What the settings say this editor serves on, or 0 when there is nothing to ask.
@@ -416,7 +416,7 @@ func _serving(setting: String) -> int:
 	var settings: EditorSettings = EditorInterface.get_editor_settings()
 	if settings == null or not settings.has_setting(setting):
 		return 0
-	return Read.as_int(settings.get_setting(setting))
+	return GdhRead.as_int(settings.get_setting(setting))
 
 
 ## The version marker beside this addon, or "" when the copy was not installed by gdharness.
@@ -497,7 +497,7 @@ func _on_reconnect_timer() -> void:
 
 
 func _handle_message(json_string: String) -> void:
-	var parsed: Variant = Read.json_or_null(json_string)
+	var parsed: Variant = GdhRead.json_or_null(json_string)
 	if not parsed is Dictionary:
 		push_error("[gdharness] The server sent something that is not a message: %s" % json_string)
 		return

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

@@ -10,9 +10,9 @@ extends RefCounted
 ## without making a node. Loading the file still does what loading does in the game: static
 ## initialisers run, and a resource with a script is made with it.
 
-const PropertyValues = preload("property_values.gd")
-const Read = preload("reading.gd")
-const Serialisation = preload("serialisation.gd")
+const GdhPropertyValues = preload("property_values.gd")
+const GdhRead = preload("reading.gd")
+const GdhSerialisation = preload("serialisation.gd")
 
 
 ## The nodes of [param scene_path] as {name, type, path, children}, with instanceOf and
@@ -42,13 +42,43 @@ static func scene_node(scene_path: String, node_path: String) -> Dictionary:
 	return {"ok": true, "name": found["name"], "type": found["type"], "properties": found["properties"]}
 
 
-## [param said], the refusal for [param node_path], which [param scene_path] does not have, with
-## where the path leaves the scene as [method Read.missing_below] says it.
-static func missing_from(said: String, scene_path: String, node_path: String) -> String:
+## The node at [param node_path] in [param scene_path] as [method scene_node] answers it, when it is
+## a [param kind]; otherwise a refusal saying what the scene has there and where its nodes of that
+## kind are, so the caller has the path to pass. The file is read once, because every load prints
+## the engine's warnings about it again.
+static func scene_node_of_kind(scene_path: String, node_path: String, kind: String) -> Dictionary:
 	var laid: Dictionary = _laid(scene_path)
 	if not laid.get("ok", false):
-		return said
+		return laid
 	var nodes: Dictionary = laid["nodes"]
+	var path: String = _joined(".", node_path)
+	var said: String = "%s not found at: %s" % [kind, node_path]
+	var found: String = ""
+	if nodes.has(path):
+		found = str(nodes[path]["type"])
+		if ClassDB.class_exists(found) and ClassDB.is_parent_class(found, kind):
+			return {
+				"ok": true,
+				"name": nodes[path]["name"],
+				"type": found,
+				"properties": nodes[path]["properties"]
+			}
+	else:
+		var hinted: String = said
+		if not nodes.has(_joined(".", node_path.get_slice("/", 0))):
+			hinted = GdhRead.from_the_root(said, node_path, str(nodes["."]["name"]))
+		said = hinted if hinted != said else _missing_in(nodes, said, node_path)
+	var held: PackedStringArray = []
+	for at: Variant in nodes:
+		var type: String = str(nodes[at]["type"])
+		if ClassDB.class_exists(type) and ClassDB.is_parent_class(type, kind):
+			var _held: bool = held.append(str(at))
+	return {"ok": false, "error": GdhRead.not_of_kind(said, node_path, found, kind, held)}
+
+
+## [param said], the refusal for [param node_path], which the scene laid as [param nodes] does not
+## have, with where the path leaves the scene as [method GdhRead.missing_below] says it.
+static func _missing_in(nodes: Dictionary, said: String, node_path: String) -> String:
 	var parts: PackedStringArray = node_path.trim_prefix("./").split("/", false)
 	var at: String = "."
 	var reached: PackedStringArray = []
@@ -64,7 +94,7 @@ static func missing_from(said: String, scene_path: String, node_path: String) ->
 	var children: Array[String] = nodes[at]["children"]
 	for child: String in children:
 		var _named: bool = names.append(str(nodes[child]["name"]))
-	return Read.missing_below(said, str(nodes["."]["name"]), reached, parts[reached.size()], names)
+	return GdhRead.missing_below(said, str(nodes["."]["name"]), reached, parts[reached.size()], names)
 
 
 ## Every node of [param scene_path] as {ok, nodes}, keyed by path, or a refusal.
@@ -77,15 +107,14 @@ static func _laid(scene_path: String) -> Dictionary:
 	if loaded == null:
 		return {"ok": false, "error": "Failed to load %s as a scene" % scene_path}
 	if not loaded is PackedScene:
-		var kind: String = loaded.get_class()
-		var sort: String = ("an " if kind.left(1).to_upper() in ["A", "E", "I", "O", "U"] else "a ") + kind
+		var sort: String = GdhRead.with_article(loaded.get_class())
 		return {
 			"ok": false,
 			"error": "%s is %s, not a scene: resource_edit read reads its properties." % [scene_path, sort]
 		}
 	var packed: PackedScene = loaded
 	var nodes: Dictionary = {}
-	var refused: String = _lay(packed.get_state(), ".", nodes, [scene_path])
+	var refused: String = _lay(packed.get_state(), ".", nodes, [scene_path], packed)
 	if not refused.is_empty():
 		return {"ok": false, "error": refused}
 	if not nodes.has("."):
@@ -99,8 +128,11 @@ static func _laid(scene_path: String) -> Dictionary:
 ##
 ## [param within] is the files being laid, outermost first, so a scene that instances one of them
 ## is refused rather than laid forever; the engine refuses to load such a scene, so this is only
-## reached through a state built some other way.
-static func _lay(state: SceneState, prefix: String, nodes: Dictionary, within: Array) -> String:
+## reached through a state built some other way. [param loaded] is the scene [param state] is read
+## from, when the caller has it loaded already.
+static func _lay(
+	state: SceneState, prefix: String, nodes: Dictionary, within: Array, loaded: PackedScene = null
+) -> String:
 	var base: SceneState = state.get_base_scene_state()
 	if base != null and not nodes.has(prefix):
 		var refused: String = _lay(base, prefix, nodes, within)
@@ -164,7 +196,7 @@ static func _lay(state: SceneState, prefix: String, nodes: Dictionary, within: A
 	# Only the scene being read and the scenes it inherits share its root, the owner whose editable
 	# instances a write here sets; a file instanced below makes its own owner's editable.
 	if prefix == ".":
-		for editable: String in _editable_in(state.get_path()):
+		for editable: String in _editable_in(state.get_path(), loaded):
 			var at: String = _joined(prefix, editable)
 			var marked: Dictionary = nodes.get(at, {})
 			if marked.has("editableChildren"):
@@ -173,10 +205,13 @@ static func _lay(state: SceneState, prefix: String, nodes: Dictionary, within: A
 
 
 ## The paths of the instances [param scene_path] gives editable children, from its root. SceneState
-## does not give them to a script, so they are read off the scene's bundle.
-static func _editable_in(scene_path: String) -> PackedStringArray:
+## does not give them to a script, so they are read off the scene's bundle: [param given_scene]'s,
+## when the caller has the file loaded, since loading it again prints its warnings again.
+static func _editable_in(scene_path: String, given_scene: PackedScene = null) -> PackedStringArray:
 	var found: PackedStringArray = []
-	var loaded: Resource = ResourceLoader.load(scene_path, "", ResourceLoader.CACHE_MODE_IGNORE)
+	var loaded: Resource = given_scene
+	if loaded == null:
+		loaded = ResourceLoader.load(scene_path, "", ResourceLoader.CACHE_MODE_IGNORE)
 	if not loaded is PackedScene:
 		return found
 	var given: Variant = loaded.get("_bundled")
@@ -236,7 +271,7 @@ static func _by_id(nodes: Dictionary, owner: String, id: int) -> String:
 		if path == owner or not (owner == "." or path.begins_with(owner + "/")):
 			continue
 		var entry: Dictionary = nodes[path]
-		if Read.as_int(entry.get("uniqueId", -1), -1) != id:
+		if GdhRead.as_int(entry.get("uniqueId", -1), -1) != id:
 			continue
 		var above: String = "." if not path.contains("/") else path.get_base_dir()
 		if _owner_of(nodes, above, owner) == owner:
@@ -311,7 +346,7 @@ static func _stored(type: String, given: Dictionary) -> Dictionary:
 	if script != null:
 		for declared: Dictionary in script.get_script_property_list():
 			var property: String = str(declared.get("name", ""))
-			if not property.is_empty() and Read.as_int(declared.get("usage", 0)) & PROPERTY_USAGE_STORAGE:
+			if not property.is_empty() and GdhRead.as_int(declared.get("usage", 0)) & PROPERTY_USAGE_STORAGE:
 				scripted[property] = script.get_property_default_value(property)
 	var values: Dictionary = {}
 	if ClassDB.class_exists(type) and ClassDB.can_instantiate(type):
@@ -321,7 +356,7 @@ static func _stored(type: String, given: Dictionary) -> Dictionary:
 				bare.set(str(property), given[property])
 		for declared: Dictionary in bare.get_property_list():
 			var property: String = str(declared.get("name", ""))
-			if not property.is_empty() and Read.as_int(declared.get("usage", 0)) & PROPERTY_USAGE_STORAGE:
+			if not property.is_empty() and GdhRead.as_int(declared.get("usage", 0)) & PROPERTY_USAGE_STORAGE:
 				values[property] = bare.get(property)
 		if bare is Node:
 			bare.free()
@@ -330,7 +365,7 @@ static func _stored(type: String, given: Dictionary) -> Dictionary:
 	# Given last, which keeps what a bare node cannot hold: the script itself, and a path to a node
 	# for a property that holds the node once it is in a tree.
 	values.merge(given, true)
-	var serialiser: Serialisation = Serialisation.new()
+	var serialiser: GdhSerialisation = GdhSerialisation.new()
 	var answered: Dictionary = {}
 	for property: Variant in values:
 		answered[property] = serialiser.serialize_value(values[property])
@@ -369,13 +404,13 @@ static func resource(res_path: String, include_defaults: bool) -> Dictionary:
 	if script != null:
 		for declared: Dictionary in script.get_script_property_list():
 			scripted[str(declared.get("name", ""))] = true
-	var serialiser: Serialisation = Serialisation.new()
+	var serialiser: GdhSerialisation = GdhSerialisation.new()
 	var properties: Dictionary = {}
 	for p: Dictionary in loaded.get_property_list():
 		var property: String = str(p.get("name", ""))
 		if property.is_empty() or property == "script":
 			continue
-		if not (Read.as_int(p.get("usage", 0)) & PROPERTY_USAGE_STORAGE):
+		if not (GdhRead.as_int(p.get("usage", 0)) & PROPERTY_USAGE_STORAGE):
 			continue
 		var value: Variant = loaded.get(property)
 		if not include_defaults:
@@ -384,7 +419,7 @@ static func resource(res_path: String, include_defaults: bool) -> Dictionary:
 				if scripted.has(property)
 				else ClassDB.class_get_property_default_value(loaded.get_class(), property)
 			)
-			if PropertyValues.same(value, default):
+			if GdhPropertyValues.same(value, default):
 				continue
 		properties[property] = serialiser.serialize_value(value)
 	var answer: Dictionary = {
@@ -412,7 +447,7 @@ static func _kept_in(value: Variant, file: String, id: String, seen: Dictionary)
 		if held.resource_scene_unique_id == id:
 			return held
 		for p: Dictionary in held.get_property_list():
-			if Read.as_int(p.get("usage", 0)) & PROPERTY_USAGE_STORAGE:
+			if GdhRead.as_int(p.get("usage", 0)) & PROPERTY_USAGE_STORAGE:
 				var found: Resource = _kept_in(held.get(str(p.get("name", ""))), file, id, seen)
 				if found != null:
 					return found

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

@@ -11,8 +11,8 @@ extends RefCounted
 ## both, so a property a built-in setter derives (a Control's offsets from its size) is left alone
 ## unless a script that is not a tool is involved.
 
-const PropertyValues = preload("property_values.gd")
-const Read = preload("reading.gd")
+const GdhPropertyValues = preload("property_values.gd")
+const GdhRead = preload("reading.gd")
 
 const REMEDY: String = (
 	"Open the project's editor (editor_launch with hidden: true) and ask again: the write then goes "
@@ -25,7 +25,7 @@ const REMEDY: String = (
 static func stored(object: Object) -> Dictionary:
 	var values: Dictionary = {}
 	for declared: Dictionary in object.get_property_list():
-		if not (Read.as_int(declared.get("usage", 0)) & PROPERTY_USAGE_STORAGE):
+		if not (GdhRead.as_int(declared.get("usage", 0)) & PROPERTY_USAGE_STORAGE):
 			continue
 		var name: String = str(declared.get("name", ""))
 		if name.is_empty():
@@ -78,7 +78,7 @@ static func differing(object: Object, before: Dictionary, names: Dictionary) ->
 		if names.has(name):
 			continue
 		var was: Variant = before[name] if before.has(name) else default_of(object, name)
-		if not PropertyValues.same(now[name], was):
+		if not GdhPropertyValues.same(now[name], was):
 			changed.append(name)
 	return changed
 
@@ -93,7 +93,7 @@ static func default_of(object: Object, name: String) -> Variant:
 				var given: Variant = script.get_property_default_value(name)
 				if given != null:
 					return given
-				return _initialised(script, name, Read.as_int(declared.get("type", TYPE_NIL)))
+				return _initialised(script, name, GdhRead.as_int(declared.get("type", TYPE_NIL)))
 	return ClassDB.class_get_property_default_value(object.get_class(), name)
 
 
@@ -122,7 +122,7 @@ static func _initialised(script: Script, name: String, type: int) -> Variant:
 ## nothing a script did: the saver writes a property whose default the engine cannot report whatever
 ## it holds, the editor's save as well.
 static func at_default(object: Object, name: String) -> bool:
-	return PropertyValues.same(object.get(name), default_of(object, name))
+	return GdhPropertyValues.same(object.get(name), default_of(object, name))
 
 
 ## The ids, in the file, of the embedded resources [param property] reaches into on [param object],
@@ -276,7 +276,7 @@ static func reads_the_same(was: Variant, now: Variant, default: Variant) -> bool
 			return false
 		else:
 			values.append(str_to_var(str(text)))
-	return PropertyValues.same(values[0], values[1])
+	return GdhPropertyValues.same(values[0], values[1])
 
 
 static func _main_entries(text: String) -> Dictionary:

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

@@ -5,8 +5,8 @@ extends EditorPlugin
 ## that does what the server asks, with a label in the toolbar saying whether the two are
 ## connected.
 
-const BridgeClient = preload("bridge_client.gd")
-const ToolExecutor = preload("tool_executor.gd")
+const GdhBridgeClient = preload("bridge_client.gd")
+const GdhToolExecutor = preload("tool_executor.gd")
 
 ## The tools answered while the editor scans or imports, because none of them saves a file: the
 ## ones a caller waits on a scan with, and the ones that only read or stop a played game.
@@ -19,17 +19,17 @@ const ANSWERED_WHILE_SCANNING: Array[String] = [
 	"profile_read",
 ]
 
-var _client: BridgeClient
-var _tool_executor: ToolExecutor
+var _client: GdhBridgeClient
+var _tool_executor: GdhToolExecutor
 var _status_label: Label
 
 
 func _enter_tree() -> void:
-	_client = BridgeClient.new()
+	_client = GdhBridgeClient.new()
 	_client.name = "GdharnessBridgeClient"
 	add_child(_client)
 
-	_tool_executor = ToolExecutor.new()
+	_tool_executor = GdhToolExecutor.new()
 	_tool_executor.name = "GdharnessToolExecutor"
 	add_child(_tool_executor)
 	_tool_executor.set_editor_plugin(self)