gdharness 1.2.42 → 1.3.1

package/build/cli.js

@@ -504,16 +504,23 @@ function readAnnouncement(path) {
       return null;
     }
     const said = parsed;
-    if (typeof said.port !== "number" || typeof said.pid !== "number") {
+    if (said.protocol !== BRIDGE_ANNOUNCE_PROTOCOL || typeof said.host !== "string" || typeof said.port !== "number" || typeof said.pid !== "number" || typeof said.version !== "string" || typeof said.startedAt !== "string") {
       return null;
     }
-    return said;
+    return {
+      protocol: said.protocol,
+      host: said.host,
+      port: said.port,
+      pid: said.pid,
+      version: said.version,
+      startedAt: said.startedAt
+    };
   } catch {
     return null;
   }
 }
 function serverBehind(announcement, startedAt) {
-  if (announcement === null || typeof announcement.version !== "string" || startedAt === undefined) {
+  if (announcement === null || startedAt === undefined) {
     return null;
   }
   const announcedAt = Date.parse(announcement.startedAt);
@@ -668,12 +675,8 @@ function resolveHeadless(requested, host) {
   }
   return envValue("DISPLAY", host.variables) === undefined && envValue("WAYLAND_DISPLAY", host.variables) === undefined;
 }
-function resolveSilent(requested, variables) {
-  if (typeof requested === "boolean") {
-    return requested;
-  }
-  const said = envValue("GDHARNESS_SILENT", variables)?.toLowerCase();
-  return said !== undefined && said !== "0" && said !== "false";
+function resolveSilent(requested) {
+  return requested !== false;
 }
 function engineFlags(given) {
   const offered = Object.keys(ENGINE_FLAGS).join(", ");
@@ -727,10 +730,11 @@ function runArguments(options) {
   }
   return args;
 }
-function editorArguments(projectPath, ports, logFile, hidden) {
+function editorArguments(projectPath, ports, logFile, hidden, silent) {
   return [
     "-e",
     ...hidden ? ["--headless"] : [],
+    ...silent && !hidden ? ["--audio-driver", "Dummy"] : [],
     "--path",
     projectPath,
     "--lsp-port",
@@ -9653,32 +9657,30 @@ var init_update_check = __esm(() => {
 
 // src/server-version.ts
 import { readFileSync as readFileSync7 } from "node:fs";
-function editorIsStale(addonVersion, serverVersion, addonDigest, shippedDigest) {
-  if (addonDigest !== undefined && addonDigest !== "" && shippedDigest !== undefined) {
-    return addonDigest !== shippedDigest;
-  }
-  return addonVersion !== serverVersion;
+function staleAddon(addonDigest, shippedDigest) {
+  return addonDigest !== shippedDigest;
 }
-function sameCodeNote(addonVersion, serverVersion, addonDigest, shippedDigest) {
-  if (addonVersion === undefined || addonVersion === serverVersion || addonDigest === undefined || addonDigest === "" || addonDigest !== shippedDigest) {
+function sameCodeNote(addonVersion, serverVersion) {
+  if (addonVersion === "" || addonVersion === serverVersion) {
     return;
   }
   const same = `The editor loaded the ${addonVersion} addons, which are the same code this ${serverVersion} server ships, so nothing needs restarting`;
   return isNewer(addonVersion, serverVersion) ? `${same}. This server is the older of the two, which a reconnect in your harness settles once the project pins ${addonVersion}.` : `${same}; addonVersion is the version the editor loaded when it started.`;
 }
 function addonMismatch(addonVersion, serverVersion, addonDigest, shippedDigest, onDisk) {
-  if (!editorIsStale(addonVersion, serverVersion, addonDigest, shippedDigest)) {
+  if (!staleAddon(addonDigest, shippedDigest)) {
     return;
   }
-  const reported = addonVersion ?? "";
+  const reported = addonVersion;
   const restart = onDisk !== undefined && onDisk !== shippedDigest ? `The project's own addons are not this server's either, so a restart would load the same code again: run  ${gdharnessCommand(serverVersion, "upgrade")}  in a shell in the project directory, which installs the ${serverVersion} addons, and editor_launch restart then picks them up.` : "Restart it with editor_launch restart to pick this one up.";
+  const asked = "so this server asks it nothing but to quit:";
   if (reported === serverVersion) {
-    return `The editor is running a different build of the ${reported} addon from the one this server ships. ${restart}`;
+    return `The editor is running a different build of the ${reported} addon from the one this server ships, ${asked} ${restart}`;
   }
-  const editor = reported === "" ? UNVERSIONED : `the ${reported} addon`;
-  const both = `The editor is running ${editor} while this server ships ${serverVersion}.`;
+  const editor = reported === "" ? "an addon with no version marker" : `the ${reported} addon`;
+  const both = `The editor is running ${editor} while this server ships ${serverVersion}, ${asked}`;
   if (reported !== "" && isNewer(reported, serverVersion)) {
-    return `${both} This server is the older half: reconnect it in your harness so it spawns ${reported}.`;
+    return `${both} this server is the older half; reconnect it in your harness so it spawns ${reported}.`;
   }
   return `${both} ${restart}`;
 }
@@ -9686,23 +9688,18 @@ function gdharnessCommand(version, args) {
   return `npx -y gdharness@${version} ${args}`;
 }
 function runtimeAddonUnknown(addon) {
-  return addon?.version === "" && addon.digest === "";
+  return addon.version === "" && addon.digest === "";
 }
 function runtimeMismatch(pid, addon, serverVersion, shippedDigest, onDisk, projectPath) {
-  if (runtimeAddonUnknown(addon)) {
-    return;
-  }
-  if (addon !== undefined && !editorIsStale(addon.version, serverVersion, addon.digest, shippedDigest)) {
+  if (runtimeAddonUnknown(addon) || !staleAddon(addon.digest, shippedDigest)) {
     return;
   }
   const game = `The game (pid ${pid})`;
-  if (addon !== undefined && addon.version !== "" && isNewer(addon.version, serverVersion)) {
-    return `${game} is running the ${addon.version} runtime addon while this server ships ${serverVersion}. This server is the older half: reconnect it in your harness so it spawns ${addon.version}.`;
+  if (addon.version !== "" && isNewer(addon.version, serverVersion)) {
+    return `${game} is running the ${addon.version} runtime addon while this server ships ${serverVersion}, so this server asks it nothing. This server is the older half: reconnect it in your harness so it spawns ${addon.version}.`;
   }
   let loaded;
-  if (addon === undefined) {
-    loaded = `a runtime addon from before games reported theirs, while this server ships ${serverVersion}`;
-  } else if (addon.version === serverVersion) {
+  if (addon.version === serverVersion) {
     loaded = `a different build of the ${serverVersion} runtime addon from the one this server ships`;
   } else if (addon.version === "") {
     loaded = `a runtime addon with no version marker, while this server ships ${serverVersion}`;
@@ -9710,20 +9707,12 @@ function runtimeMismatch(pid, addon, serverVersion, shippedDigest, onDisk, proje
     loaded = `the ${addon.version} runtime addon, while this server ships ${serverVersion}`;
   }
   const remedy = onDisk !== undefined && onDisk !== shippedDigest ? `The project's own runtime addon is not this server's either, so starting the game again loads the same code: run  ${gdharnessCommand(serverVersion, `upgrade "${projectPath}"`)}  in a shell, which installs the ${serverVersion} addons, and the game picks them up when it next starts.` : `The project holds this server's runtime addon, so the game picks it up when it next starts.`;
-  return `${game} is running ${loaded}, and its answers come from that code. ${remedy}`;
-}
-function markIfStale(answer, addonVersion, serverVersion, addonDigest, shippedDigest, onDisk) {
-  const staleNote = addonMismatch(addonVersion, serverVersion, addonDigest, shippedDigest, onDisk);
-  if (staleNote === undefined || typeof answer !== "object" || answer === null || Array.isArray(answer)) {
-    return answer;
-  }
-  return { ...answer, addonIsStale: true, staleNote };
+  return `${game} is running ${loaded}, so this server asks it nothing: its answers would come from that code. ${remedy}`;
 }
-var DEBUG_MODE, GODOT_DEBUG_MODE_DEFAULT, SERVER_VERSION, UNVERSIONED = "an addon from before versions were reported";
+var DEBUG_MODE, SERVER_VERSION;
 var init_server_version = __esm(() => {
   init_update_check();
-  DEBUG_MODE = process.env["DEBUG"] === "true";
-  GODOT_DEBUG_MODE_DEFAULT = process.env["GODOT_DEBUG"] === "true" || DEBUG_MODE;
+  DEBUG_MODE = process.env["GDHARNESS_DEBUG"] === "1";
   SERVER_VERSION = (() => {
     try {
       const pkg = JSON.parse(readFileSync7(new URL("../package.json", import.meta.url), "utf8"));
@@ -10812,9 +10801,7 @@ function failedReloadNote(failed) {
   const answered = failed.codeName === "" ? `error ${failed.code}` : `error ${failed.code}, ${failed.codeName}`;
   const unusable = "A failed compile leaves the copy the editor holds unusable, measured on 4.7.2: the editor can make no instance of it, and one it already made has lost its methods, while its member lists read as before.";
   let copy;
-  if (failed.restored === null) {
-    copy = `${unusable} This editor's addon does not put it back, so it stays that way until the script compiles: reload it then, or restart the editor with editor_launch restart.`;
-  } else if (!failed.restored) {
+  if (!failed.restored) {
     copy = `${unusable} The editor compiled it again from the text it was built from, and that failed too${failed.restoredAs === "" ? "" : ` (${failed.restoredAs})`}, so it stays that way until the script compiles: reload it then, or restart the editor with editor_launch restart.`;
   } else if (unchanged) {
     copy = "The copy the editor holds was compiled again from the text it was built from, which puts it back as it was, with the members it held before, which listMembers lists.";
@@ -11568,24 +11555,12 @@ function addonsDigest(names, from) {
   return hash.digest("hex");
 }
 function shippedEditorDigest() {
-  if (shippedDigest === undefined) {
-    try {
-      shippedDigest = editorAddonDigest();
-    } catch {
-      shippedDigest = null;
-    }
-  }
-  return shippedDigest ?? undefined;
+  shippedDigest ??= editorAddonDigest();
+  return shippedDigest;
 }
 function shippedRuntimeDigest() {
-  if (shippedRuntime === undefined) {
-    try {
-      shippedRuntime = runtimeAddonDigest();
-    } catch {
-      shippedRuntime = null;
-    }
-  }
-  return shippedRuntime ?? undefined;
+  shippedRuntime ??= runtimeAddonDigest();
+  return shippedRuntime;
 }
 function installedEditorDigest(projectPath) {
   return digestMarker(projectPath, ADDONS[0]);
@@ -11899,7 +11874,7 @@ function annotationsOf(spec) {
     openWorldHint: false
   };
 }
-var PROJECT_INFO_SECTIONS, PROJECT_PATH, RUNNING_PROJECT_PATH, RUNNING_PID, SCENE_PATH, WITHOUT_AN_EDITOR = "Through the editor when one serves the project; with none, a headless engine runs the editor's own tool and the answer says so under writtenBy, or readBy for a read. That engine runs every script of the file, 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 anything is saved, and a file where that cannot be done, such as a scene whose script does not compile, is refused and nothing is written. Each file the written one refers to is named by its uid, as the editor names it, except a file the project's uid cache has no uid for yet (one made since the project was last scanned), which is named by path and listed under namedByPath with the call that scans it. An editor of the project that is running and has not reached this server is waited for rather than written around.", WHOLE_NUMBERS = 'A whole number of 2^53 or more, such as a 64-bit seed or a resource uid, is written as its digits, {"_type": "int", "value": "9007199254740993"}, the form a read answers with: a JSON number that large can arrive as a neighbour of the one sent, so sent as a number it is refused.', SCRIPT_PATH, RESOURCE_FILE = 'File inside the project, such as "sprites/hero.png" or "materials/steel.tres".', RESOURCE_PATH, NODE_PATH, PROPERTIES, XY, ANIMATION_TRACK, SCRIPT_MODIFICATIONS, INPUT_EVENTS, TILESET_SOURCES, TILEMAP_CELLS, COLOUR2, TOOL_SPECS, SPECS_BY_NAME;
+var PROJECT_INFO_SECTIONS, PROJECT_PATH, RUNNING_PROJECT_PATH, RUNNING_PID, SCENE_PATH, WITHOUT_AN_EDITOR = "Through the editor when one serves the project; with none, a headless engine runs the editor's own tool and the answer says so under writtenBy, or readBy for a read. That engine runs every script of the file, 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 anything is saved, and a file where that cannot be done, such as a scene whose script does not compile, is refused and nothing is written. Each file the written one refers to is named by its uid, as the editor names it, except a file the project's uid cache has no uid for yet (one made since the project was last scanned), which is named by path and listed under namedByPath with the call that scans it. An editor of the project that is running and has not reached this server is waited for rather than written around.", IMPORTED_FIRST = "importedFirst names the files whose import was behind them on disk, such as a picture changed since it was imported or one never imported, which were imported before the run through project_import reimport, so the run reads them as they are now; it is left out when every import was current. notImportedFirst lists, as project_import reimport does, any it could not import, and importNote says that the run reads those as they were. The import gives every script without a .uid sidecar one, as the editor's scan does, and uidsWrittenFirst names those scripts. importTookMs is how long the import took; it is outside the run's own time limit, so a call that imported can take that much longer than the limit it was given.", WHOLE_NUMBERS = 'A whole number of 2^53 or more, such as a 64-bit seed or a resource uid, is written as its digits, {"_type": "int", "value": "9007199254740993"}, the form a read answers with: a JSON number that large can arrive as a neighbour of the one sent, so sent as a number it is refused.', SCRIPT_PATH, RESOURCE_FILE = 'File inside the project, such as "sprites/hero.png" or "materials/steel.tres".', RESOURCE_PATH, NODE_PATH, PROPERTIES, XY, ANIMATION_TRACK, SCRIPT_MODIFICATIONS, INPUT_EVENTS, TILESET_SOURCES, TILEMAP_CELLS, COLOUR2, TOOL_SPECS, SPECS_BY_NAME;
 var init_tool_definitions = __esm(() => {
   init_launch();
   PROJECT_INFO_SECTIONS = [
@@ -11937,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 = {
@@ -12090,7 +12065,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, plugins and audio buses. 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, one on an addon from before this, which still holds the old values until editor_launch restart. An enabled plugin's code still loads on the editor's next start. 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. add_input_action on an action that exists, one of the engine's ui_ actions included, replaces its events and deadzone, and answers was_new false with what it held under 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. Every write keeps the sections and keys of project.godot in the order the file had them, so a change moves no other line; the save is the engine's, and like the editor's it writes Godot's header and config/features into a file that lacks them. get answers exists, true for any setting the engine knows, and at_default, true when the value is the engine's own default and so has no line in project.godot. 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 the engine registers no default for, such as an input action the project added, which only the project can have set.",
+      description: "Reads or writes project.godot: settings, autoloads, the main scene, input actions, plugins and audio buses. 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. 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. add_input_action on an action that exists, one of the engine's ui_ actions included, replaces its events and deadzone, and answers was_new false with what it held under 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. Every write keeps the sections and keys of project.godot in the order the file had them, so a change moves no other line; the save is the engine's, and like the editor's it writes Godot's header and config/features into a file that lacks them. get answers exists, true for any setting the engine knows, and at_default, true when the value is the engine's own default and so has no line in project.godot. 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 the engine registers no default for, such as an input action the project added, which only the project can have set.",
       parameters: {
         projectPath: PROJECT_PATH,
         setting: {
@@ -12112,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: {
@@ -12371,8 +12346,8 @@ 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.",
-      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.",
+      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,
         path: {
@@ -12462,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,
@@ -12807,7 +12782,7 @@ var init_tool_definitions = __esm(() => {
         scriptPath: {
           type: ["string", "array"],
           items: { type: "string" },
-          description: 'A script inside the project, a folder, or a list of either, such as "scripts/player.gd" or ["scripts/economy", "ui/shop.gd"]. A folder is its .gd files at any depth, skipping what the engine skips. One script is answered as it always was. Several are answered together, with clean, errors and warnings for all of them: a script with nothing to report is named in nothingReported, and every other is answered under scripts in that same shape, including a script that could not be read, named with why while the rest are still asked about. Any number of scripts is one call, which reports progress as it goes.'
+          description: 'A script inside the project, a folder, or a list of either, such as "scripts/player.gd" or ["scripts/economy", "ui/shop.gd"]. A folder is its .gd files at any depth, skipping what the engine skips. One script is answered on its own. Several are answered together, with clean, errors and warnings for all of them: a script with nothing to report is named in nothingReported, and every other is answered under scripts in that same shape, including a script that could not be read, named with why while the rest are still asked about. Any number of scripts is one call, which reports progress as it goes.'
         }
       },
       requires: ["projectPath", "scriptPath"]
@@ -12815,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: {
@@ -12924,6 +12899,11 @@ var init_tool_definitions = __esm(() => {
           type: "boolean",
           ops: ["open", "restart"],
           description: "Open the editor headless and, on Windows, on a desktop of its own, so no window of it or of the games it plays appears. Default false: one visible editor, shown without taking the focus. On restart only for an editor a server opened; one opened by hand comes back as it was, so hidden is refused there."
+        },
+        silent: {
+          type: "boolean",
+          ops: ["open", "restart"],
+          description: "Open the editor with no sound out of the machine, started with --audio-driver Dummy, so a tool script, a preview or a scene playing in its viewport is heard by nobody. Default true: pass false to hear it. The answer's arguments are what the editor was started with. The editor hands no audio driver to a game it plays, so editor_run's own silent decides that game's sound. A hidden editor is headless and silent either way. On restart only for an editor a server opened; one opened by hand comes back as it was."
         }
       },
       requires: [],
@@ -12945,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,
@@ -12978,7 +12958,7 @@ var init_tool_definitions = __esm(() => {
         silent: {
           type: "boolean",
           ops: ["start"],
-          description: "start: run the game with no sound out of the machine, by starting the engine with --audio-driver Dummy: every stream still plays and every playback position still advances, so what is playing can still be asked. The editor takes no engine flags for a game it plays, so a silent windowed run is started by this server, whose keeper is its debugger rather than the editor. A headless run, check's included, is silent already. Default false, or true when GDHARNESS_SILENT is set in the server's environment to anything but 0 or false; silent: false then plays through the editor as before."
+          description: "start: run the game with no sound out of the machine, by starting the engine with --audio-driver Dummy: every stream still plays and every playback position still advances, so what is playing can still be asked. The editor takes no engine flags for a game it plays, so a silent windowed run is started by this server, whose keeper is its debugger rather than the editor. A headless run, check's included, is silent already, and so is a test run. Default true, for an exported build too: pass false to hear the game, which a windowed run with the editor connected then plays through the editor."
         },
         executable: {
           type: "string",
@@ -13048,7 +13028,7 @@ var init_tool_definitions = __esm(() => {
         graceful: {
           type: "boolean",
           ops: ["start", "stop"],
-          description: "stop, and a start that ends the run going before it: ask the game to close first, the way a player's close asks it, so its own handling of a close runs, which a game keeping a crash mark needs to take the mark down. The runtime addon delivers the close request to every node and then the root window's close_requested, and a tree with auto_accept_quit on then quits. The game is given ten seconds to exit, GDHARNESS_CLOSE_WAIT_MS sets another, and is ended the ordinary way when it does not, or when it has no runtime listening, an older addon, or does not answer within three seconds, as a game held at a breakpoint does not; notClosedBecause (previousRunNotClosedBecause on a start) then says which. Default true; false ends the process at once."
+          description: "stop, and a start that ends the run going before it: ask the game to close first, the way a player's close asks it, so its own handling of a close runs, which a game keeping a crash mark needs to take the mark down. The runtime addon delivers the close request to every node and then the root window's close_requested, and a tree with auto_accept_quit on then quits. The game is given ten seconds to exit, GDHARNESS_CLOSE_WAIT_MS sets another, and is ended the ordinary way when it does not, or when it has no runtime listening, refuses the close, or does not answer within three seconds, as a game held at a breakpoint does not; notClosedBecause (previousRunNotClosedBecause on a start) then says which. Default true; false ends the process at once."
         },
         pid: {
           type: "integer",
@@ -13085,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. 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",
@@ -13148,7 +13129,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, and editor_launch restart binds the port again. 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. 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, and editor_launch restart binds it again. editor.scan says whether the editor is scanning or importing and how many milliseconds ago its last scan finished (finishedMsAgo), or is null when it did not answer: the editor rewrites the class cache just after a scan, and editor_run waits that out before starting a game, saying so under waitedForEditorScanMs. Each game under runtimes is pinged with a short wait, so one held at a breakpoint is listed as unreachable rather than making this call wait out the runtime timeout; for the run this server is reporting on, heldAt says whether that is what it is, with the same three answers editor_output gives. A game the editor played announces the editor under editorPid, and so does whatever that game started for itself; a game some other server started announces none, which is how the two are told apart when both are running from one project. Each game also says which runtime addon it loaded, under addonVersion (null when it cannot say); addonIsStale is true when that code is not what this server ships, and staleNote says whether the project needs 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. Every runtime_* answer from such a game carries addonIsStale and staleNote too. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means \"not reached yet\" as often as it means \"no editor\". True is worth waiting out; false is an editor that is not there. False beside 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, which is the same reading editor_launch restart makes in its own answer. A game that has announced itself in a protocol this server does not speak is listed under unreadable rather than left out, with the protocol it speaks and whether the server or the addon is the older half. This happens during an upgrade that moves the runtime protocol, which most do not: installing replaces the addon on disk as soon as the pin moves, while a server that is already running stays on the version it started with, so the two speak different protocols until the server is reconnected. Those games are real and running, but no tool here can reach them until the halves match, so runtimes stays empty and runtimeConnected stays false. An upgrade that leaves the protocol alone opens no such window and this list stays empty through it. addonIsStale is decided by the code of the editor addons rather than their version, so an editor started before an upgrade that left that code alone reports the older addonVersion, is not stale, and addonNote says so: it needs no restart. port is the one the editor bridge is on; when that is not the one this server was configured with, portWanted names the configured one and portNote says why it moved and, when it was the server this one replaced, which pid kept it. A server replacing another of its project that holds the configured port waits for it to stand down and takes the port over, which takes a few seconds; bridgeHandover says so while it waits, and it moves only if that server has not let go within the wait. An editor that has connected and not yet greeted, which lasts a frame and longer while it imports, reports nothing about itself: greeting says so, addonIsStale is absent rather than guessed, and a restart asked then waits for the greeting to learn who opened it. startedByAnEditor is an editor another editor started, by Godot's own restart or the project manager, which has none of the arguments a server gave the one before it; startedByAnEditorNote says what that costs. An engine run that loads the editor addon to do one job and quit, such as a gate's godot --headless --import, an export or a script, is not taken as the editor: a process that greets without a server's mark has its command line read first, and while that is read identifying is true and connected false; one started with such an option is turned away, and turnedAway names the last one, its pid and the option. Every other call made while an editor is arriving, before its greeting or while it is looked up, waits up to ten seconds for it to settle rather than acting on connected as it reads in that window. 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, and syncsBreakpoints that it keeps its breakpoints when a debug session opens, which Godot otherwise clears. 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, and runtimes lists every game on the machine with ofThisProject saying which is which, since a game of another project is reached only by naming its projectPath. playingInEditor is null when the editor was not asked or did not answer, which is not the same as a no: with no editor connected there is nobody to ask, and an editor that does not serve the question is given a moment and then left. A game can be playing while this is null, so read it as unanswered rather than as nothing playing, and use processActive and runtimes, which come from elsewhere and do not depend on the editor answering. 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, and editor_launch restart binds it again. editor.scan says whether the editor is scanning or importing and how many milliseconds ago its last scan finished (finishedMsAgo), or is null when it did not answer: the editor rewrites the class cache just after a scan, and editor_run waits that out before starting a game, saying so under waitedForEditorScanMs. Each game under runtimes is pinged with a short wait, so one held at a breakpoint is listed as unreachable rather than making this call wait out the runtime timeout; for the run this server is reporting on, heldAt says whether that is what it is, with the same three answers editor_output gives. A game the editor played announces the editor under editorPid, and so does whatever that game started for itself; a game some other server started announces none, which is how the two are told apart when both are running from one project. Each game also says which runtime addon it loaded, under addonVersion (null when it cannot say); addonIsStale is true when that code is not what this server ships, and staleNote says whether the project needs 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, 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 while that is read identifying is true and connected false; one started with such an option is turned away, and turnedAway names the last one, its pid and the option. Every other call made while an editor is arriving, before its greeting or while it is looked up, waits up to ten seconds for it to settle rather than acting on connected as it reads in that window. 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, and syncsBreakpoints that it keeps its breakpoints when a debug session opens, which Godot otherwise clears. 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: []
     },
@@ -13369,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",
@@ -13422,14 +13403,14 @@ 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,
         viewportPath: {
           type: "string",
           ops: ["viewport"],
-          description: "viewport: the Viewport node. Default the root viewport."
+          description: "viewport: the Viewport node. Default the root viewport. A Window of the game that is hidden or minimised has nothing drawn to it, and is refused naming which."
         },
         width: {
           type: "integer",
@@ -13735,7 +13716,7 @@ var init_tool_definitions = __esm(() => {
     {
       name: "debug_breakpoint",
       title: "Breakpoints",
-      description: "Sets or removes a breakpoint. Set them first, then editor_run, and the game stops where you asked. With the editor connected it goes through the editor's debug adapter; with none, it is held here. A game this server starts itself, which editor_run start does for a run given args, savesIn, env or silent, or with no editor, is handed every breakpoint held here as it starts, and one set while that game runs reaches it at once (runningGame says so). The editor keeps a breakpoint set this way for one play, so every breakpoint this server holds is sent again before each play editor_run starts, and the start answer lists them under breakpoints. The set is also kept in the project, for the server that comes after a reconnect: a breakpoint stays until it is removed here, whichever server set it. Every answer lists the whole set under held, and the breakpoints the user set in the editor's own gutter under setInEditor; setting one here never takes those away, and removing a line here clears it whoever set it. Godot clears every breakpoint in the editor when a debug session opens unless network/debug_adapter/sync_breakpoints is on, which the addon turns on as it loads; an editor running an older addon is said so under breakpointsAtRisk, here and in editor_status.",
+      description: "Sets or removes a breakpoint. Set them first, then editor_run, and the game stops where you asked. With the editor connected it goes through the editor's debug adapter; with none, it is held here. A game this server starts itself, which editor_run start does for a run given args, savesIn, env or silent, or with no editor, is handed every breakpoint held here as it starts, and one set while that game runs reaches it at once (runningGame says so). The editor keeps a breakpoint set this way for one play, so every breakpoint this server holds is sent again before each play editor_run starts, and the start answer lists them under breakpoints. The set is also kept in the project, for the server that comes after a reconnect: a breakpoint stays until it is removed here, whichever server set it. Every answer lists the whole set under held, and the breakpoints the user set in the editor's own gutter under setInEditor; setting one here never takes those away, and removing a line here clears it whoever set it. Godot clears every breakpoint in the editor when a debug session opens unless network/debug_adapter/sync_breakpoints is on, which the addon turns on as it loads; an editor where it was turned off again is said so under breakpointsAtRisk, here and in editor_status.",
       parameters: {
         projectPath: PROJECT_PATH,
         scriptPath: SCRIPT_PATH,
@@ -35683,6 +35664,10 @@ function parseAnnouncement(file, pid) {
   }
   const editorPid = readNumber(fields, "editor_pid");
   const addonVersion = readString(fields, "addon_version");
+  const addonDigest = readString(fields, "addon_digest");
+  if (addonVersion === undefined || addonDigest === undefined) {
+    return { kind: "rubbish" };
+  }
   return {
     kind: "runtime",
     endpoint: {
@@ -35693,7 +35678,7 @@ function parseAnnouncement(file, pid) {
       file,
       ...editorPid !== undefined && Number.isInteger(editorPid) && editorPid > 0 ? { editorPid } : {},
       ...when,
-      ...addonVersion === undefined ? {} : { addon: { version: addonVersion, digest: readString(fields, "addon_digest") ?? "" } }
+      addon: { version: addonVersion, digest: addonDigest }
     }
   };
 }
@@ -36148,18 +36133,16 @@ function runtimeRequest(endpoint, command, params, timeoutMs, afterTheWait = "dr
           if (!welcomed) {
             welcomed = true;
             taken();
-            if (readString(message, "type") === "welcome") {
-              const spoken = readNumber(message, "protocol");
-              if (spoken !== RUNTIME_PROTOCOL) {
-                finish({
-                  ok: false,
-                  reason: "protocol",
-                  message: `The game (${describe2(endpoint)}) speaks runtime protocol ${spoken ?? "unknown"} and this server speaks ${RUNTIME_PROTOCOL}. Reinstall the runtime addon into the project.`
-                });
-                return;
-              }
-              continue;
+            const spoken = readString(message, "type") === "welcome" ? readNumber(message, "protocol") : undefined;
+            if (spoken !== RUNTIME_PROTOCOL) {
+              finish({
+                ok: false,
+                reason: "protocol",
+                message: `The game (${describe2(endpoint)}) speaks runtime protocol ${spoken ?? "unknown"} and this server speaks ${RUNTIME_PROTOCOL}. Reinstall the runtime addon into the project.`
+              });
+              return;
             }
+            continue;
           }
           if (message["id"] !== id) {
             continue;
@@ -36224,7 +36207,7 @@ function runtimeRequest(endpoint, command, params, timeoutMs, afterTheWait = "dr
     });
   });
 }
-var RUNTIME_PROTOCOL = 2, ANNOUNCEMENT_PATTERN, ERROR_REPORT_PATTERN, CONSOLE_BOUNDARY = "[gdharness] runtime listening on ", ERROR_REPORT_KEEP_MS, GONE_WINDOW_MS = 120000, GONE_KEPT = 32, gone, STARTED_AFTER_ANNOUNCING_MS = 2000, CONFIRMED_FOR_MS = 60000, JUDGED_AFTER_MS = 60000, verdicts, judging = null, ENDED_WITHIN_MS = 3000, LOOK_EVERY_MS = 50, ANNOUNCE_BUDGET_MS = 5000, nextRequestId = 1, LATE_ANSWER_MS, LATE_KEPT = 50, lateAnswers, UNTAKEN_PER_GAME = 4, REDIAL_MS = 50, untaken;
+var RUNTIME_PROTOCOL = 3, ANNOUNCEMENT_PATTERN, ERROR_REPORT_PATTERN, CONSOLE_BOUNDARY = "[gdharness] runtime listening on ", ERROR_REPORT_KEEP_MS, GONE_WINDOW_MS = 120000, GONE_KEPT = 32, gone, STARTED_AFTER_ANNOUNCING_MS = 2000, CONFIRMED_FOR_MS = 60000, JUDGED_AFTER_MS = 60000, verdicts, judging = null, ENDED_WITHIN_MS = 3000, LOOK_EVERY_MS = 50, ANNOUNCE_BUDGET_MS = 5000, nextRequestId = 1, LATE_ANSWER_MS, LATE_KEPT = 50, lateAnswers, UNTAKEN_PER_GAME = 4, REDIAL_MS = 50, untaken;
 var init_runtime_client = __esm(() => {
   init_alive();
   init_launch();
@@ -36890,8 +36873,8 @@ class GodotDAPClient {
     }
     const response = await this.sendRequest("initialize", {
       adapterID: "godot",
-      clientID: "godot-mcp",
-      clientName: "godot-mcp",
+      clientID: "gdharness",
+      clientName: "gdharness",
       locale: "en",
       linesStartAt1: true,
       columnsStartAt1: true,
@@ -37598,8 +37581,8 @@ function theConsoleWasNotCaptured(why, projectPath) {
   if (why.kind === "not ours") {
     return "This editor was not opened by gdharness, so its console was never captured and nothing " + "here has it: an editor prints to a console no plugin can read, and the addon cannot get " + "at it from inside. This is not an editor that printed nothing.";
   }
-  if (why.kind === "older server") {
-    return `This editor was opened by a gdharness server, but the console beside ${projectPath} belongs ` + `to editor ${why.notedPid ?? "none recorded"} rather than to this one, so it holds an ` + "earlier session and is not offered as this one. A server from before consoles were " + "captured leaves exactly this.";
+  if (why.kind === "another editor") {
+    return `This editor was opened by a gdharness server, but the console beside ${projectPath} belongs ` + `to editor ${why.notedPid ?? "none recorded"} rather than to this one, so it holds an ` + "earlier session and is not offered as this one.";
   }
   return "This editor was opened by gdharness and has written nothing to its console file yet, not " + "even the engine version it prints first, so the file is missing rather than empty. An " + "editor that could not open the file for writing leaves this.";
 }
@@ -37609,7 +37592,7 @@ function editorConsole(projectPath, editorPid, openedByAServer) {
   }
   const noted = readEditorLogNote(projectPath);
   if (noted === null || editorPid === null || noted.pid !== editorPid) {
-    return { kind: "older server", notedPid: noted?.pid ?? null };
+    return { kind: "another editor", notedPid: noted?.pid ?? null };
   }
   const path = editorLogPath(projectPath);
   if (!existsSync20(path)) {
@@ -43172,8 +43155,11 @@ function resolveDefaultBridgeHost() {
   const host = process.env["GDHARNESS_BRIDGE_HOST"]?.trim();
   return host === undefined || host === "" ? DEFAULT_HOST : host;
 }
+function greetingFaults(message) {
+  return Object.entries(GREETING_FIELDS).filter(([field, type]) => typeof message[field] !== type).map(([field]) => field);
+}
 function servedPort(said) {
-  return typeof said === "number" && Number.isInteger(said) && said > 0 && said <= 65535 ? said : undefined;
+  return Number.isInteger(said) && said > 0 && said <= 65535 ? said : undefined;
 }
 function mayYetConnect(listeningSince, now = Date.now()) {
   return listeningSince === undefined || now - listeningSince.getTime() < CONNECT_WINDOW_MS;
@@ -43201,13 +43187,27 @@ function getDefaultBridge(ownProject = null) {
   defaultBridge ??= new GodotBridge(resolveDefaultBridgePort(), resolveDefaultBridgeHost(), DEFAULT_TIMEOUT_MS, ownProject);
   return defaultBridge;
 }
-var DEFAULT_PORT = 6505, DEFAULT_HOST = "127.0.0.1", DEFAULT_TIMEOUT_MS = 30000, KEEPALIVE_INTERVAL_MS = 1e4, SECOND_CONNECTION_CLOSE_CODE = 4000, MOST_CLOSE_REASON_BYTES = 123, OTHER_PROJECT_CLOSE_CODE = 4001, ONE_SHOT_CLOSE_CODE = 4002, CONNECT_WINDOW_MS = 35000, BridgeTimeout, EditorBusy, BUSY_RETRY_MS = 100, GodotBridge, defaultBridge = null;
+var DEFAULT_PORT = 6505, DEFAULT_HOST = "127.0.0.1", DEFAULT_TIMEOUT_MS = 30000, KEEPALIVE_INTERVAL_MS = 1e4, SECOND_CONNECTION_CLOSE_CODE = 4000, MOST_CLOSE_REASON_BYTES = 123, OTHER_PROJECT_CLOSE_CODE = 4001, ONE_SHOT_CLOSE_CODE = 4002, GREETING_FIELDS, CONNECT_WINDOW_MS = 35000, BridgeTimeout, AddonOfAnotherRelease, ASKED_OF_ANY_RELEASE, EditorBusy, BUSY_RETRY_MS = 100, GodotBridge, defaultBridge = null;
 var init_godot_bridge = __esm(() => {
   init_wrapper();
   init_errors();
   init_launch();
   init_paths();
   init_ports();
+  init_server_version();
+  init_setup();
+  GREETING_FIELDS = {
+    project_path: "string",
+    addon_version: "string",
+    addon_digest: "string",
+    editor_pid: "number",
+    lsp_port: "number",
+    dap_port: "number",
+    debug_port: "number",
+    syncs_breakpoints: "boolean",
+    opened_by_a_server: "boolean",
+    started_by_an_editor: "boolean"
+  };
   BridgeTimeout = class BridgeTimeout extends Error {
     toolName;
     waitedMs;
@@ -43217,6 +43217,9 @@ var init_godot_bridge = __esm(() => {
       this.waitedMs = waitedMs;
     }
   };
+  AddonOfAnotherRelease = class AddonOfAnotherRelease extends Error {
+  };
+  ASKED_OF_ANY_RELEASE = new Set(["quit_editor", "restart_editor"]);
   EditorBusy = class EditorBusy extends Error {
     constructor(toolName) {
       super(`The editor was scanning or importing its files, so ${toolName} was not run.`);
@@ -43391,6 +43394,14 @@ var init_godot_bridge = __esm(() => {
         portWanted: this.wantedPort !== 0 && this.boundPort !== null && this.boundPort !== this.wantedPort ? this.wantedPort : undefined
       };
     }
+    anotherRelease() {
+      const info = this.connectionInfo;
+      if (info?.greeted !== true || info.addonVersion === undefined || info.addonDigest === undefined) {
+        return;
+      }
+      const project = info.projectPath;
+      return addonMismatch(info.addonVersion, SERVER_VERSION, info.addonDigest, shippedEditorDigest(), project === undefined || project === "" ? undefined : installedEditorDigest(project));
+    }
     invokeTool(toolName, args, options = {}) {
       const counted = options.counted ?? true;
       const resourceKey = this.getResourceKey(args);
@@ -43538,24 +43549,33 @@ var init_godot_bridge = __esm(() => {
         case "godot_ready":
           if (this.connectionInfo) {
             if (this.belongsElsewhere(message.project_path)) {
-              this.elsewhereUnlessOneShot(message.project_path, message.editor_pid, message.opened_by_a_server === true);
+              this.elsewhereUnlessOneShot(message.project_path, message.editor_pid, message.opened_by_a_server);
               return;
             }
             this.connectionInfo.projectPath = withoutTrailingSeparator(message.project_path);
-            this.connectionInfo.addonVersion = message.addon_version ?? "";
+            const faults = greetingFaults(message);
+            if (faults.length > 0) {
+              this.log("info", `Godot ready from another release's addon, which sent no ${faults.join(", ")}`);
+              this.connectionInfo.addonVersion = typeof message.addon_version === "string" ? message.addon_version : "";
+              this.connectionInfo.addonDigest = "";
+              this.connectionInfo.editorPid = typeof message.editor_pid === "number" ? message.editor_pid : undefined;
+              this.connectionInfo.greeted = true;
+              this.emitBridgeEvent("godot_connected", { projectPath: message.project_path });
+              return;
+            }
+            this.connectionInfo.addonVersion = message.addon_version;
             this.connectionInfo.addonDigest = message.addon_digest;
             this.connectionInfo.editorPid = message.editor_pid;
             this.connectionInfo.lspPort = servedPort(message.lsp_port);
             this.connectionInfo.dapPort = servedPort(message.dap_port);
             this.connectionInfo.debugPort = servedPort(message.debug_port);
-            this.connectionInfo.openedByAServer = message.opened_by_a_server === true;
-            this.connectionInfo.startedByAnEditor = typeof message.started_by_an_editor === "boolean" ? message.started_by_an_editor : undefined;
-            this.connectionInfo.syncsBreakpoints = typeof message.syncs_breakpoints === "boolean" ? message.syncs_breakpoints : undefined;
+            this.connectionInfo.openedByAServer = message.opened_by_a_server;
+            this.connectionInfo.startedByAnEditor = message.started_by_an_editor;
+            this.connectionInfo.syncsBreakpoints = message.syncs_breakpoints;
             this.log("info", `Godot ready: ${message.project_path}`);
             this.connectionInfo.greeted = true;
-            const pid = this.connectionInfo.editorPid;
-            if (!this.connectionInfo.openedByAServer && pid !== undefined && this.oneShotReader !== null) {
-              this.identify(pid);
+            if (!message.opened_by_a_server && this.oneShotReader !== null) {
+              this.identify(message.editor_pid);
               return;
             }
             this.emitBridgeEvent("godot_connected", { projectPath: message.project_path });
@@ -43572,6 +43592,10 @@ var init_godot_bridge = __esm(() => {
       if (!this.isConnected()) {
         return Promise.reject(new Error("Godot is not connected"));
       }
+      const otherRelease = ASKED_OF_ANY_RELEASE.has(toolName) ? undefined : this.anotherRelease();
+      if (otherRelease !== undefined) {
+        return Promise.reject(new AddonOfAnotherRelease(otherRelease));
+      }
       const requestId = randomUUID();
       const message = {
         type: "tool_invoke",
@@ -43794,6 +43818,168 @@ var init_godot_bridge = __esm(() => {
   };
 });
 
+// src/import-freshness.ts
+import { createHash as createHash5 } from "node:crypto";
+import { existsSync as existsSync25, readdirSync as readdirSync13, readFileSync as readFileSync24, statSync as statSync12 } from "node:fs";
+import { join as join29 } from "node:path";
+function md5Of(file) {
+  let stats;
+  try {
+    stats = statSync12(file);
+  } catch {
+    return null;
+  }
+  const known = hashes.get(file);
+  if (known !== undefined && known.size === stats.size && known.mtimeMs === stats.mtimeMs) {
+    return known.md5;
+  }
+  let md5;
+  try {
+    md5 = createHash5("md5").update(readFileSync24(file)).digest("hex");
+  } catch {
+    return null;
+  }
+  hashes.set(file, { size: stats.size, mtimeMs: stats.mtimeMs, md5 });
+  return md5;
+}
+function sectionOf(text, section) {
+  const keys = new Map;
+  let inside = false;
+  for (const line of text.split(/\r?\n/)) {
+    const header = /^\[([^\]]+)\]\s*$/.exec(line);
+    if (header !== null) {
+      inside = header[1] === section;
+      continue;
+    }
+    const pair = inside ? /^([A-Za-z0-9_./]+)=(.*)$/.exec(line) : null;
+    if (pair?.[1] !== undefined && pair[2] !== undefined) {
+      keys.set(pair[1], pair[2]);
+    }
+  }
+  return keys;
+}
+function unquoted(value) {
+  return value === undefined ? "" : value.replace(/^"(.*)"$/, "$1");
+}
+function listed2(value) {
+  return [...(value ?? "").matchAll(/"((?:[^"\\]|\\.)*)"/g)].map((match) => match[1] ?? "");
+}
+function onDisk(projectPath, resPath) {
+  return join29(projectPath, resPath.slice("res://".length));
+}
+function behind(projectPath, resPath, sidecar) {
+  const remap = sectionOf(sidecar, "remap");
+  const importer = unquoted(remap.get("importer"));
+  if (importer === "keep" || importer === "skip") {
+    return null;
+  }
+  const outputs = listed2(sectionOf(sidecar, "deps").get("dest_files"));
+  if (outputs.some((output) => !existsSync25(onDisk(projectPath, output)))) {
+    return "its imported output is not on disk";
+  }
+  const name = resPath.slice(resPath.lastIndexOf("/") + 1);
+  const record = join29(projectPath, ".godot", "imported", `${name}-${createHash5("md5").update(resPath, "utf8").digest("hex")}.md5`);
+  let recorded = "";
+  try {
+    recorded = /^source_md5="([0-9a-f]*)"/m.exec(readFileSync24(record, "utf8"))?.[1] ?? "";
+  } catch {
+    recorded = "";
+  }
+  if (recorded === "") {
+    return "its import recorded no hash of its source";
+  }
+  const current = md5Of(onDisk(projectPath, resPath));
+  return current === null || current === recorded ? null : "the source changed after it was imported";
+}
+function staleImports(projectPath) {
+  const stale = [];
+  const visit = (directory, resDirectory) => {
+    if (existsSync25(join29(directory, ".gdignore")) || existsSync25(join29(directory, VERSION_MARKER))) {
+      return;
+    }
+    let entries;
+    try {
+      entries = readdirSync13(directory, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    const names = new Set(entries.map((entry) => entry.name));
+    for (const entry of entries) {
+      if (entry.name.startsWith(".")) {
+        continue;
+      }
+      const resPath = `${resDirectory}${entry.name}`;
+      if (entry.isDirectory()) {
+        visit(join29(directory, entry.name), `${resPath}/`);
+        continue;
+      }
+      if (!entry.isFile()) {
+        continue;
+      }
+      if (entry.name.endsWith(".import")) {
+        const source = resPath.slice(0, -".import".length);
+        if (!names.has(entry.name.slice(0, -".import".length))) {
+          continue;
+        }
+        let sidecar;
+        try {
+          sidecar = readFileSync24(join29(directory, entry.name), "utf8");
+        } catch {
+          continue;
+        }
+        const reason = behind(projectPath, source, sidecar);
+        if (reason !== null) {
+          stale.push({ path: source, reason });
+        }
+        continue;
+      }
+      const extension = entry.name.slice(entry.name.lastIndexOf(".") + 1).toLowerCase();
+      if (IMPORTABLE.has(extension) && !names.has(`${entry.name}.import`)) {
+        stale.push({ path: resPath, reason: "it has not been imported" });
+      }
+    }
+  };
+  visit(projectPath, "res://");
+  return stale.sort((one, other) => one.path.localeCompare(other.path));
+}
+var IMPORTABLE_EXTENSIONS, IMPORTABLE, hashes;
+var init_import_freshness = __esm(() => {
+  init_project_scan();
+  IMPORTABLE_EXTENSIONS = [
+    "png",
+    "jpg",
+    "jpeg",
+    "webp",
+    "svg",
+    "bmp",
+    "tga",
+    "exr",
+    "hdr",
+    "dds",
+    "ktx",
+    "wav",
+    "mp3",
+    "ogg",
+    "ttf",
+    "otf",
+    "ttc",
+    "otc",
+    "woff",
+    "woff2",
+    "pfb",
+    "pfm",
+    "fnt",
+    "font",
+    "glb",
+    "gltf",
+    "fbx",
+    "obj",
+    "dae"
+  ];
+  IMPORTABLE = new Set(IMPORTABLE_EXTENSIONS);
+  hashes = new Map;
+});
+
 // src/keeper-channel.ts
 import { connect as connect2, createServer as createServer2 } from "node:net";
 async function askTheKeeperToStop(address, withinMs) {
@@ -43808,9 +43994,6 @@ async function askTheKeepersDebugger(address, request, withinMs) {
   if (typeof answered !== "string") {
     return answered;
   }
-  if (answered === "unknown") {
-    return { unreached: "its keeper was started by a gdharness from before game debuggers, and has none" };
-  }
   try {
     const parsed = JSON.parse(answered);
     if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
@@ -43860,17 +44043,17 @@ var DEBUG_PREFIX = "debug ";
 var init_keeper_channel = () => {};
 
 // src/lifecycle-log.ts
-import { appendFileSync, mkdirSync as mkdirSync14, renameSync as renameSync5, statSync as statSync12 } from "node:fs";
-import { dirname as dirname20, join as join29 } from "node:path";
+import { appendFileSync, mkdirSync as mkdirSync14, renameSync as renameSync5, statSync as statSync13 } from "node:fs";
+import { dirname as dirname20, join as join30 } from "node:path";
 import process11 from "node:process";
 function lifecycleLogPath() {
-  return join29(runtimeDirectory(), "servers.log");
+  return join30(runtimeDirectory(), "servers.log");
 }
 function writeLifecycle(event, fields = {}) {
   const path = lifecycleLogPath();
   try {
     mkdirSync14(dirname20(path), { recursive: true });
-    if ((statSync12(path, { throwIfNoEntry: false })?.size ?? 0) > LIFECYCLE_LOG_LIMIT) {
+    if ((statSync13(path, { throwIfNoEntry: false })?.size ?? 0) > LIFECYCLE_LOG_LIMIT) {
       try {
         renameSync5(path, `${path}.1`);
       } catch {}
@@ -44184,10 +44367,10 @@ var init_prompts = __esm(() => {
 });
 
 // src/restart-note.ts
-import { mkdirSync as mkdirSync15, readFileSync as readFileSync24, rmSync as rmSync13, writeFileSync as writeFileSync17 } from "node:fs";
-import { dirname as dirname21, join as join30 } from "node:path";
+import { mkdirSync as mkdirSync15, readFileSync as readFileSync25, rmSync as rmSync13, writeFileSync as writeFileSync17 } from "node:fs";
+import { dirname as dirname21, join as join31 } from "node:path";
 function restartNotePath(projectPath) {
-  return join30(projectPath, ".godot", "gdharness-restart.json");
+  return join31(projectPath, ".godot", "gdharness-restart.json");
 }
 function noteRestartBegun(note) {
   const path = restartNotePath(note.projectPath);
@@ -44201,7 +44384,7 @@ function noteRestartBegun(note) {
 }
 function restartOwed(projectPath) {
   try {
-    const parsed = JSON.parse(readFileSync24(restartNotePath(projectPath), "utf8"));
+    const parsed = JSON.parse(readFileSync25(restartNotePath(projectPath), "utf8"));
     if (typeof parsed !== "object" || parsed === null) {
       return null;
     }
@@ -44226,18 +44409,18 @@ var init_restart_note = __esm(() => {
 });
 
 // src/run-record.ts
-import { createHash as createHash5 } from "node:crypto";
-import { mkdirSync as mkdirSync16, openSync as openSync3, readdirSync as readdirSync13, readFileSync as readFileSync25, realpathSync as realpathSync6, rmSync as rmSync14, statSync as statSync13 } from "node:fs";
-import { basename as basename9, dirname as dirname22, join as join31, resolve as resolve7 } from "node:path";
+import { createHash as createHash6 } from "node:crypto";
+import { mkdirSync as mkdirSync16, openSync as openSync3, readdirSync as readdirSync14, readFileSync as readFileSync26, realpathSync as realpathSync6, rmSync as rmSync14, statSync as statSync14 } from "node:fs";
+import { basename as basename9, dirname as dirname22, join as join32, resolve as resolve7 } from "node:path";
 function runsDirectory() {
-  return join31(runtimeDirectory(), "runs");
+  return join32(runtimeDirectory(), "runs");
 }
 function realAsFarAsItExists(path) {
   const missing = [];
   let at = path;
   for (;; ) {
     try {
-      return join31(realpathSync6.native(at), ...missing);
+      return join32(realpathSync6.native(at), ...missing);
     } catch {
       const parent = dirname22(at);
       if (parent === at) {
@@ -44251,13 +44434,13 @@ function realAsFarAsItExists(path) {
 function projectKey(projectPath) {
   const real = realAsFarAsItExists(resolve7(projectPath)).replace(/[\\/]+$/, "");
   const folded = process.platform === "win32" || process.platform === "darwin" ? real.toLowerCase() : real;
-  return createHash5("sha256").update(folded.replaceAll("\\", "/")).digest("hex").slice(0, 16);
+  return createHash6("sha256").update(folded.replaceAll("\\", "/")).digest("hex").slice(0, 16);
 }
 function runRecordPath(projectPath, directory = runtimeDirectory()) {
-  return join31(directory, "runs", `note-${projectKey(projectPath)}.json`);
+  return join32(directory, "runs", `note-${projectKey(projectPath)}.json`);
 }
 function latestRunPath(servedBy, directory = runtimeDirectory()) {
-  return join31(directory, "runs", `latest-${projectKey(servedBy)}.json`);
+  return join32(directory, "runs", `latest-${projectKey(servedBy)}.json`);
 }
 function writeLatestRun(servedBy, latest) {
   try {
@@ -44267,7 +44450,7 @@ function writeLatestRun(servedBy, latest) {
 }
 function readLatestRun(servedBy, directory = runtimeDirectory()) {
   try {
-    const fields = JSON.parse(readFileSync25(latestRunPath(servedBy, directory), "utf8"));
+    const fields = JSON.parse(readFileSync26(latestRunPath(servedBy, directory), "utf8"));
     if (typeof fields !== "object" || fields === null) {
       return null;
     }
@@ -44282,20 +44465,20 @@ function readLatestRun(servedBy, directory = runtimeDirectory()) {
 }
 function openTranscript(startedAt) {
   mkdirSync16(runsDirectory(), { recursive: true });
-  const path = join31(runsDirectory(), `run-${startedAt}.log`);
+  const path = join32(runsDirectory(), `run-${startedAt}.log`);
   return { path, fd: openSync3(path, "a") };
 }
 function profilePath(startedAt) {
-  return join31(runsDirectory(), `run-${startedAt}.profile.json`);
+  return join32(runsDirectory(), `run-${startedAt}.profile.json`);
 }
 function profileMarkPath(startedAt) {
-  return join31(runsDirectory(), `run-${startedAt}.profile-mark.json`);
+  return join32(runsDirectory(), `run-${startedAt}.profile-mark.json`);
 }
 function noteIsAbout(note, playing) {
   return note.play !== undefined && playing !== null && note.play.play === playing.play && note.play.editorPid === playing.editorPid;
 }
 function editorNotePath(projectPath, directory = runtimeDirectory()) {
-  return join31(directory, "runs", `editor-${projectKey(projectPath)}.json`);
+  return join32(directory, "runs", `editor-${projectKey(projectPath)}.json`);
 }
 function writeEditorRunNote(note) {
   mkdirSync16(runsDirectory(), { recursive: true });
@@ -44306,7 +44489,7 @@ function writeEditorRunNote(note) {
 }
 function readEditorRunNote(projectPath) {
   for (const directory of runtimeDirectories()) {
-    const note = editorNoteAt(editorNotePath(projectPath, directory)) ?? editorNoteAt(join31(directory, "runs", "editor-run.json"));
+    const note = editorNoteAt(editorNotePath(projectPath, directory));
     if (note !== null && isSameDirectory(note.projectPath, projectPath)) {
       return note;
     }
@@ -44316,7 +44499,7 @@ function readEditorRunNote(projectPath) {
 function editorNoteAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync25(path, "utf8"));
+    parsed = JSON.parse(readFileSync26(path, "utf8"));
   } catch {
     return null;
   }
@@ -44340,10 +44523,6 @@ function readRunRecord(projectPath) {
     if (own !== null) {
       return own;
     }
-    const shared = recordAt(join31(directory, "runs", SHARED_NOTE));
-    if (shared !== null && shared.projectPath !== "" && isSameDirectory(shared.projectPath, projectPath)) {
-      return shared;
-    }
   }
   return null;
 }
@@ -44352,13 +44531,13 @@ function everyRunRecord() {
   for (const directory of runtimeDirectories()) {
     let entries;
     try {
-      entries = readdirSync13(join31(directory, "runs"));
+      entries = readdirSync14(join32(directory, "runs"));
     } catch {
       continue;
     }
     for (const entry of entries) {
-      if (entry === SHARED_NOTE || entry.startsWith("note-") && entry.endsWith(".json")) {
-        const record = recordAt(join31(directory, "runs", entry));
+      if (entry.startsWith("note-") && entry.endsWith(".json")) {
+        const record = recordAt(join32(directory, "runs", entry));
         if (record !== null) {
           found.push(record);
         }
@@ -44370,7 +44549,7 @@ function everyRunRecord() {
 function recordAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync25(path, "utf8"));
+    parsed = JSON.parse(readFileSync26(path, "utf8"));
   } catch {
     return null;
   }
@@ -44385,17 +44564,23 @@ function recordAt(path) {
     return null;
   }
   const args = fields["arguments"];
+  const startedBy = fields["startedBy"];
+  const projectPath = fields["projectPath"];
+  const command = fields["command"];
+  if (typeof startedBy !== "number" || typeof projectPath !== "string" || projectPath === "" || typeof command !== "string" || !Array.isArray(args)) {
+    return null;
+  }
   return {
     pid,
     transcript,
     startedAt,
-    ...typeof fields["startedBy"] === "number" ? { startedBy: fields["startedBy"] } : {},
-    projectPath: typeof fields["projectPath"] === "string" ? fields["projectPath"] : "",
+    startedBy,
+    projectPath,
     ...typeof fields["servedBy"] === "string" && fields["servedBy"] !== "" ? { servedBy: fields["servedBy"] } : {},
     ...typeof fields["keeper"] === "string" && fields["keeper"] !== "" ? { keeper: fields["keeper"] } : {},
     ...typeof fields["profile"] === "string" && fields["profile"] !== "" ? { profile: fields["profile"] } : {},
-    arguments: Array.isArray(args) ? args.filter((value) => typeof value === "string") : [],
-    ...typeof fields["command"] === "string" ? { command: fields["command"] } : {},
+    arguments: args.filter((value) => typeof value === "string"),
+    command,
     ...typeof fields["exitCode"] === "number" ? { exitCode: fields["exitCode"] } : {},
     ...typeof fields["exitSignal"] === "string" ? { exitSignal: fields["exitSignal"] } : {},
     ...typeof fields["endedAt"] === "number" ? { endedAt: fields["endedAt"] } : {}
@@ -44423,7 +44608,7 @@ async function runningAs(pid) {
     const began = await startedAt(pid, null);
     const when = began === null ? {} : { startedAt: began };
     if (process.platform === "linux") {
-      const raw = readFileSync25(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
+      const raw = readFileSync26(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
       return raw === "" ? null : { kind: "commandLine", text: raw, ...when };
     }
     const args = (await runHidden("ps", ["-p", String(pid), "-o", "args="], { timeout: 15000 })).stdout.trim();
@@ -44523,26 +44708,20 @@ function whyNotTheRun(record, running, needed) {
   if (running.kind === "none") {
     return `the operating system would not describe that process (${running.unread ?? "no reason given"})`;
   }
-  const after = running.startedAt === undefined ? 0 : running.startedAt - (record.startedBy ?? record.startedAt);
+  const after = running.startedAt === undefined ? 0 : running.startedAt - record.startedBy;
   if (after > SAME_RUN_WINDOW_MS) {
     return `that process started ${Math.round(after / 1000)} seconds after the run had`;
   }
-  const engine = record.command === undefined ? null : basename9(record.command);
+  const engine = basename9(record.command);
   const said = process.platform === "win32" ? running.text.toLowerCase() : running.text;
-  const wanted = engine === null || process.platform !== "win32" ? engine : engine.toLowerCase();
-  if (wanted !== null && !said.includes(wanted)) {
-    return `that process is not ${engine ?? "the engine"}, which the run was started with`;
+  const wanted = process.platform === "win32" ? engine.toLowerCase() : engine;
+  if (!said.includes(wanted)) {
+    return `that process is not ${engine}, which the run was started with`;
   }
   if (running.kind === "commandLine" && readCommandLine(running.text).editor) {
     return "that process is an editor";
   }
-  if (record.projectPath === "") {
-    return wanted !== null ? null : "the record names neither the project nor the engine";
-  }
   if (running.kind === "image") {
-    if (wanted === null) {
-      return "the operating system named only its executable, and the record names no engine";
-    }
     return needed === "possible" ? null : `the operating system named only its executable and not its command line (${running.unread ?? "no reason given"}), which is not enough to signal it on`;
   }
   const project = process.platform === "win32" ? record.projectPath.toLowerCase() : record.projectPath;
@@ -44566,19 +44745,14 @@ function judgeAnnouncedGame(running, projectPath, announcedAt) {
 }
 function clearRunRecord(projectPath) {
   for (const directory of runtimeDirectories()) {
-    const shared = join31(directory, "runs", SHARED_NOTE);
-    const sharedRecord = recordAt(shared);
-    const ours = sharedRecord !== null && sharedRecord.projectPath !== "" && isSameDirectory(sharedRecord.projectPath, projectPath);
-    for (const path of [runRecordPath(projectPath, directory), ...ours ? [shared] : []]) {
-      try {
-        rmSync14(path, { force: true });
-      } catch {}
-    }
+    try {
+      rmSync14(runRecordPath(projectPath, directory), { force: true });
+    } catch {}
   }
 }
 function ageMs(path, now) {
   try {
-    return now - statSync13(path).mtimeMs;
+    return now - statSync14(path).mtimeMs;
   } catch {
     return 0;
   }
@@ -44592,7 +44766,7 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
   ]));
   let entries;
   try {
-    entries = readdirSync13(directory);
+    entries = readdirSync14(directory);
   } catch {
     return;
   }
@@ -44601,7 +44775,7 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
     if (!transcript && !entry.endsWith(".partial")) {
       continue;
     }
-    const path = join31(directory, entry);
+    const path = join32(directory, entry);
     if (kept.has(path) || ageMs(path, now) < keepMs) {
       continue;
     }
@@ -44610,7 +44784,7 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
     } catch {}
   }
 }
-var SHARED_NOTE = "run.json", SAME_RUN_WINDOW_MS = 1e4;
+var SAME_RUN_WINDOW_MS = 1e4;
 var init_run_record = __esm(() => {
   init_errors();
   init_paths();
@@ -44622,10 +44796,10 @@ var init_run_record = __esm(() => {
 });
 
 // src/script-profile.ts
-import { readFileSync as readFileSync26 } from "node:fs";
+import { readFileSync as readFileSync27 } from "node:fs";
 function readProfileFile(path) {
   try {
-    const parsed = JSON.parse(readFileSync26(path, "utf8"));
+    const parsed = JSON.parse(readFileSync27(path, "utf8"));
     return typeof parsed === "object" && typeof parsed.connected === "boolean" ? parsed : null;
   } catch {
     return null;
@@ -44682,7 +44856,7 @@ function writeProfileMark(path, mark) {
 }
 function readProfileMark(path) {
   try {
-    const parsed = JSON.parse(readFileSync26(path, "utf8"));
+    const parsed = JSON.parse(readFileSync27(path, "utf8"));
     return typeof parsed === "object" && typeof parsed.totals === "object" ? parsed : null;
   } catch {
     return null;
@@ -44855,18 +45029,18 @@ import {
   closeSync as closeSync3,
   constants,
   copyFileSync,
-  existsSync as existsSync25,
+  existsSync as existsSync26,
   fstatSync,
   mkdirSync as mkdirSync17,
   openSync as openSync4,
-  readdirSync as readdirSync14,
-  readFileSync as readFileSync27,
+  readdirSync as readdirSync15,
+  readFileSync as readFileSync28,
   readSync as readSync2,
   rmdirSync as rmdirSync2,
-  statSync as statSync14,
+  statSync as statSync15,
   writeFileSync as writeFileSync18
 } from "node:fs";
-import { basename as basename10, dirname as dirname23, extname as extname4, isAbsolute as isAbsolute5, join as join32, normalize as normalize2, relative as relative6 } from "node:path";
+import { basename as basename10, dirname as dirname23, extname as extname4, isAbsolute as isAbsolute5, join as join33, normalize as normalize2, relative as relative6 } from "node:path";
 import { setTimeout as delay5 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 function editorRestartTimeoutMs() {
@@ -44903,15 +45077,15 @@ function writtenFileRefusal(path, rule) {
     return `${named} ${path} does not end in ${rule.extensions.join(" or ")}, which is what ${what} is.`;
   }
   const directory = realPathOr(dirname23(path));
-  if (!existsSync25(directory)) {
+  if (!existsSync26(directory)) {
     return `${named}'s directory ${dirname23(path)} does not exist; ${what} creates no directories.`;
   }
-  const where = join32(directory, basename10(path));
+  const where = join33(directory, basename10(path));
   const inside = rule.projects.find((project) => project !== "" && isWithinRoot(realPathOr(project), where));
   if (inside !== undefined) {
     return `${named} ${path} is inside the project at ${inside}; ${what} is saved outside it, so it never becomes part of the game.`;
   }
-  const taken = rule.writes(where).find((file) => existsSync25(file));
+  const taken = rule.writes(where).find((file) => existsSync26(file));
   if (taken !== undefined) {
     return taken === where ? `${named} ${path} already exists; ${what} is not written over a file. Name a new one.` : `${named} ${path} would write ${taken}, which already exists; ${what} is not written over a file. Name a new one.`;
   }
@@ -45102,7 +45276,7 @@ async function closeLikeAPlayer(announced, alsoGoing, projectPath) {
   }
   const asked = await runtimeRequest(endpoint, "close_game", {}, CLOSE_ASK_MS);
   if (!asked.ok) {
-    return asked.reason === "error" ? `its runtime did not take the close (${asked.message}), as an addon older than this server's does not` : `its runtime did not answer the close within ${CLOSE_ASK_MS / 1000} seconds, as a game held at a breakpoint or stuck in a frame does not`;
+    return asked.reason === "error" ? `its runtime refused the close (${asked.message})` : `its runtime did not answer the close within ${CLOSE_ASK_MS / 1000} seconds, as a game held at a breakpoint or stuck in a frame does not`;
   }
   if (await untilGone([announced, ...alsoGoing], closeWaitMs())) {
     return null;
@@ -45424,6 +45598,18 @@ function outsideTheirRanges(spec, args) {
 function scanWaitMs() {
   return waitFromEnv("GDHARNESS_SCAN_WAIT_MS", 30000);
 }
+function importedFirstAnswer(importedFirst) {
+  if (importedFirst === undefined) {
+    return {};
+  }
+  return {
+    ...importedFirst.imported.length === 0 ? {} : { importedFirst: importedFirst.imported },
+    ...importedFirst.notImported.length === 0 ? {} : { notImportedFirst: importedFirst.notImported },
+    ...importedFirst.uidsWritten.length === 0 ? {} : { uidsWrittenFirst: importedFirst.uidsWritten },
+    importTookMs: importedFirst.tookMs,
+    ...importedFirst.note === undefined ? {} : { importNote: importedFirst.note }
+  };
+}
 function scanWaitIn(payload) {
   const waited = readNumber(payload, "waitedForEditorScanMs");
   const note = readString(payload, "scanNote");
@@ -45452,7 +45638,7 @@ function notRunNote(notRun, failFast) {
 function exportPresetRefusal(projectPath, preset) {
   let text;
   try {
-    text = readFileSync27(join32(projectPath, "export_presets.cfg"), "utf8");
+    text = readFileSync28(join33(projectPath, "export_presets.cfg"), "utf8");
   } catch {
     return `This project has no export_presets.cfg, so it has no preset '${preset}' to export with. project_export add_preset writes one, as the editor's Project > Export does.`;
   }
@@ -45516,20 +45702,22 @@ function writtenBeside(before, after, output, within) {
 function filesIn(folder) {
   const found = new Map;
   try {
-    for (const entry of readdirSync14(folder, { withFileTypes: true })) {
+    for (const entry of readdirSync15(folder, { withFileTypes: true })) {
       if (entry.isFile()) {
-        found.set(entry.name, statSync14(join32(folder, entry.name)).mtimeMs);
+        found.set(entry.name, statSync15(join33(folder, entry.name)).mtimeMs);
       }
     }
   } catch {}
   return found;
 }
 function scanWaitAnswer(scanned, started = "game") {
+  const imports = importedFirstAnswer(scanned.importedFirst);
   if (scanned.waitedMs === 0) {
-    return {};
+    return imports;
   }
   const still = `The editor was still scanning the project after ${scanWaitMs() / 1000} seconds, so`;
   return {
+    ...imports,
     waitedForEditorScanMs: scanned.waitedMs,
     scanNote: !scanned.stillScanning ? undefined : started === "game" ? `${still} this game started during the scan and may have read a class cache being rewritten. If ` + 'editor_output shows "Could not find type" for a class that is declared, editor_rescan ' + "waits for the scan to finish, and a start after it reads the finished cache." : `${still} the engine answering this started during the scan and may have read a class cache being ` + "rewritten, and a class cache it wrote can be written over when the scan finishes. If " + 'engine_messages shows "Could not find type" for a class that is declared, editor_rescan waits ' + "for the scan to finish, and the same call after it reads the finished cache."
   };
@@ -45548,7 +45736,7 @@ function unsavedInEditorNote(scripts) {
   return `${named} ${one ? "is" : "are"} open in the editor's script ${one ? "tab" : "tabs"} with unsaved edits, and saving ${one ? "that tab" : "them"} there writes ${one ? "its" : "their"} text over what was written here: close ${one ? "it" : "them"} without saving, or save first and edit again.`;
 }
 function editorAddonMissing(projectPath) {
-  if (!existsSync25(join32(projectPath, "project.godot"))) {
+  if (!existsSync26(join33(projectPath, "project.godot"))) {
     return null;
   }
   const report = inspectProject(projectPath);
@@ -45637,7 +45825,7 @@ function withUidsMissing(answer, missing) {
       last.text = answerJson({
         ...parsed,
         uidsMissing: missing,
-        uidsNote: `${missing.length === 1 ? "This script has" : "These scripts have"} no .uid sidecar yet: the engine writes one when it imports the project, which a test run does not, so a check that tracks the sidecars fails on ${missing.length === 1 ? "it" : "them"}. project_import refresh_uids writes them.`
+        uidsNote: `${missing.length === 1 ? "This script has" : "These scripts have"} no .uid sidecar yet: the engine writes one when it imports the project, and this run had nothing to import, so a check that tracks the sidecars fails on ${missing.length === 1 ? "it" : "them"}. project_import refresh_uids writes them.`
       });
     }
   } catch {}
@@ -45813,7 +46001,7 @@ function profileFrameFunctions(projectPath) {
   let projectGodot = null;
   if (projectPath !== null) {
     try {
-      projectGodot = readFileSync27(join32(projectPath, "project.godot"), "utf8");
+      projectGodot = readFileSync28(join33(projectPath, "project.godot"), "utf8");
     } catch {}
   }
   return frameFunctionsFor(queuedMessagesOf(projectGodot));
@@ -45837,7 +46025,7 @@ function projectSourceOf(projectPath) {
       let source = null;
       if (inside.ok) {
         try {
-          source = readFileSync27(inside.absolutePath, "utf8");
+          source = readFileSync28(inside.absolutePath, "utf8");
         } catch {}
       }
       read.set(script, source);
@@ -45992,7 +46180,7 @@ function foldedEntriesAnswer(log, floor = "warning") {
 }
 function gdUnitFailsOnScriptErrors(projectPath) {
   try {
-    return settingKeys(readFileSync27(join32(projectPath, "project.godot"), "utf8")).get("gdunit4/report/godot/script_error") !== false;
+    return settingKeys(readFileSync28(join33(projectPath, "project.godot"), "utf8")).get("gdunit4/report/godot/script_error") !== false;
   } catch {
     return true;
   }
@@ -46007,13 +46195,13 @@ function uncaughtNote(uncaught) {
 }
 function elsewhereIn(projectPath, asked) {
   const wanted = asked.replace(/^res:\/\//, "").replace(/\/+$/, "");
-  if (wanted === "" || existsSync25(join32(projectPath, wanted))) {
+  if (wanted === "" || existsSync26(join33(projectPath, wanted))) {
     return "";
   }
   const root = (wanted.split("/")[0] ?? "").toLowerCase();
   let near = [];
   try {
-    near = readdirSync14(projectPath, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.toLowerCase() !== root).map((entry) => entry.name).filter((name) => name.toLowerCase().startsWith("test") || root.startsWith(name.toLowerCase()));
+    near = readdirSync15(projectPath, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.toLowerCase() !== root).map((entry) => entry.name).filter((name) => name.toLowerCase().startsWith("test") || root.startsWith(name.toLowerCase()));
   } catch {
     return "";
   }
@@ -46104,23 +46292,23 @@ function engineChecked(why) {
 }
 function isDirectory(path) {
   try {
-    return statSync14(path).isDirectory();
+    return statSync15(path).isDirectory();
   } catch {
     return false;
   }
 }
 function scriptsUnder(directory, prefix) {
-  if (existsSync25(join32(directory, ".gdignore"))) {
+  if (existsSync26(join33(directory, ".gdignore"))) {
     return [];
   }
   const found = [];
-  for (const entry of readdirSync14(directory, { withFileTypes: true }).sort((a, b) => a.name < b.name ? -1 : 1)) {
+  for (const entry of readdirSync15(directory, { withFileTypes: true }).sort((a, b) => a.name < b.name ? -1 : 1)) {
     if (entry.name.startsWith(".")) {
       continue;
     }
     const path = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
     if (entry.isDirectory()) {
-      found.push(...scriptsUnder(join32(directory, entry.name), path));
+      found.push(...scriptsUnder(join33(directory, entry.name), path));
     } else if (entry.isFile() && entry.name.endsWith(".gd")) {
       found.push(path);
     }
@@ -46128,29 +46316,18 @@ function scriptsUnder(directory, prefix) {
   return found;
 }
 function mainSceneOf(projectFile) {
-  const scene = parseProjectGodot(readFileSync27(projectFile, "utf8"))["application"]?.["run/main_scene"];
+  const scene = parseProjectGodot(readFileSync28(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "" ? scene : null;
 }
-function runtimeAddonAnnouncesEditors(projectPath) {
-  if (projectPath === null) {
-    return false;
-  }
-  try {
-    return readFileSync27(join32(projectPath, RUNTIME_AUTOLOAD.path), "utf8").includes('"editor_pid"');
-  } catch {
-    return false;
-  }
-}
 function editorPlaysHeadless(projectFile) {
-  const runArgs = parseProjectGodot(readFileSync27(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
+  const runArgs = parseProjectGodot(readFileSync28(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
   return typeof runArgs === "string" && /(?:^|\s)--headless(?:\s|$)/.test(runArgs);
 }
-function camelCased(params) {
+function ownArguments(params) {
   const result = emptyRecord();
   const source = asParams(params);
   for (const key of Object.keys(source)) {
-    const name = key.startsWith("_") ? key : key.replace(/_([a-zA-Z0-9])/g, (_, letter) => letter.toUpperCase());
-    result[name] = source[key];
+    result[key] = source[key];
   }
   return result;
 }
@@ -46161,7 +46338,7 @@ function needsItsOwnProcess(asked) {
 class GodotServer {
   stdio = null;
   locator = new GodotLocator;
-  operationsScript = join32(__dirname2, "godot", "operations", "godot_operations.gd");
+  operationsScript = join33(__dirname2, "godot", "operations", "godot_operations.gd");
   godotBridge;
   tools = buildToolDefinitions();
   activeProcess = null;
@@ -46236,6 +46413,7 @@ class GodotServer {
       console.error(`[SERVER] Using Godot at: ${located.path}`);
     }
     this.stdio = serveStdio(() => this.protocol(), {
+      legacy: "reject",
       onerror: (error) => {
         console.error("[MCP Error]", error);
       }
@@ -46422,14 +46600,14 @@ class GodotServer {
   }
   noteTheStart() {
     const cwd = process.cwd();
-    const mcpJson = join32(cwd, ".mcp.json");
+    const mcpJson = join33(cwd, ".mcp.json");
     const announced = this.ownProject === null ? null : readAnnouncement(announcementPath(this.ownProject));
     const predecessor = announced !== null && announced.pid !== process.pid && alive(announced.pid) ? announced.pid : null;
     writeLifecycle("started", {
       argv: process.argv.slice(1),
       cwd,
       project: this.ownProject,
-      mcpJson: existsSync25(mcpJson) ? mcpJson : null
+      mcpJson: existsSync26(mcpJson) ? mcpJson : null
     });
     if (predecessor !== null) {
       writeLifecycle("replaced", { project: this.ownProject, predecessor });
@@ -46551,7 +46729,7 @@ class GodotServer {
           return { name, version };
         }
       }
-      return protocol.getClientVersion();
+      return;
     };
     protocol.setRequestHandler("tools/list", (_request, ctx) => {
       this.noteTheClient(clientOf(ctx.mcpReq.envelope));
@@ -46564,13 +46742,13 @@ class GodotServer {
       if (!spec) {
         throw new ProtocolError(ProtocolErrorCode.MethodNotFound, `Unknown tool: ${request.params.name}. Tools: ${TOOL_SPECS.map((tool) => tool.name).join(", ")}`);
       }
-      const args = camelCased(request.params.arguments);
+      const args = ownArguments(request.params.arguments);
       const checked = this.validateArguments(spec, args);
       if (!checked.ok) {
         return checked.response;
       }
       const named = args["projectPath"];
-      if (typeof named === "string" && existsSync25(join32(named, "project.godot"))) {
+      if (typeof named === "string" && existsSync26(join33(named, "project.godot"))) {
         this.lastProjectPath = named;
       }
       this.updates.refresh();
@@ -46606,7 +46784,7 @@ class GodotServer {
     let notSaved;
     try {
       savedAt = answer.content.map((item, index) => {
-        const file = join32(directory, item.type === "text" ? `${stem}-${index}.txt` : `${stem}-${index}.${item.mimeType.split("/")[1] ?? "bin"}`);
+        const file = join33(directory, item.type === "text" ? `${stem}-${index}.txt` : `${stem}-${index}.${item.mimeType.split("/")[1] ?? "bin"}`);
         writeFileSync18(file, item.type === "text" ? item.text : Buffer.from(item.data, "base64"));
         return file;
       });
@@ -46740,11 +46918,6 @@ class GodotServer {
     const installed = installedAddonVersion(this.ownProject);
     return installed === null || installed === SERVER_VERSION ? null : installed;
   }
-  editorCodeOnDisk() {
-    const status = this.godotBridge.getStatus();
-    const project = (status.connected ? status.projectPath : undefined) ?? this.ownProject;
-    return project === null || project === "" ? undefined : installedEditorDigest(project);
-  }
   runtimeStaleNote(endpoint) {
     const project = endpoint.project.path;
     return runtimeMismatch(endpoint.pid, endpoint.addon, SERVER_VERSION, shippedRuntimeDigest(), project === "" ? undefined : installedRuntimeDigest(project), project);
@@ -46779,9 +46952,13 @@ class GodotServer {
       });
       const takes = wanted.length === 0 ? "It takes no arguments." : `It takes: ${shaped.join(", ")}.`;
       const where = named === null ? spec.name : `${spec.name} ${named}`;
+      const spelled = unknown.flatMap((key) => {
+        const camel = key.replace(/_([a-zA-Z0-9])/g, (_, letter) => letter.toUpperCase());
+        return camel !== key && known.has(camel) ? [`${key} is spelled ${camel}`] : [];
+      });
       return {
         ok: false,
-        response: this.createErrorResponse(`${where} does not take ${unknown.join(", ")}. ${takes} This is gdharness ${SERVER_VERSION}, which is what decides whether an argument exists.`)
+        response: this.createErrorResponse(`${where} does not take ${unknown.join(", ")}.${spelled.length === 0 ? "" : ` ${spelled.join(", ")}.`} ${takes} This is gdharness ${SERVER_VERSION}, which is what decides whether an argument exists.`)
       };
     }
     const wrong = [
@@ -46898,7 +47075,7 @@ class GodotServer {
       const contained = this.containProjectFiles({ ...arguments_, ...extra });
       return contained.ok ? await this.handleViaBridge(command, contained.value, op === "" ? tool : `${tool} ${op}`) : contained.response;
     };
-    const editorOrEngine = async (command, effect, extra = {}) => await this.editorOrEngine(command, { ...arguments_, ...extra }, `${tool} ${op}`, effect);
+    const editorOrEngine = async (command, effect) => await this.editorOrEngine(command, arguments_, `${tool} ${op}`, effect);
     switch (tool) {
       case "project_info":
         return await this.handleProjectInfo(args);
@@ -46927,13 +47104,13 @@ class GodotServer {
           case "set":
             return await editorOrEngine("set_node_properties", "writes");
           case "duplicate":
-            return await editorOrEngine("duplicate_node", "writes", { parentPath: args["parentNodePath"] });
+            return await editorOrEngine("duplicate_node", "writes");
           case "reparent":
             return await editorOrEngine("reparent_node", "writes");
           case "delete":
             return await editorOrEngine("delete_node", "writes");
           default:
-            return await editorOrEngine("set_tilemap_cells", "writes", { tilemapNodePath: args["nodePath"] });
+            return await editorOrEngine("set_tilemap_cells", "writes");
         }
       case "scene_signal":
         switch (op) {
@@ -46997,13 +47174,13 @@ class GodotServer {
           case "modify":
             return await editorOrEngine("modify_resource", "writes");
           case "create_shader":
-            return await editorOrEngine("create_shader", "writes", { shaderPath: args["resourcePath"] });
+            return await editorOrEngine("create_shader", "writes");
           case "create_tileset":
-            return await editorOrEngine("create_tileset", "writes", { tilesetPath: args["resourcePath"] });
+            return await editorOrEngine("create_tileset", "writes");
           case "set_theme_color":
-            return await editorOrEngine("set_theme_color", "writes", { themePath: args["resourcePath"] });
+            return await editorOrEngine("set_theme_color", "writes");
           default:
-            return await editorOrEngine("set_theme_font_size", "writes", { themePath: args["resourcePath"] });
+            return await editorOrEngine("set_theme_font_size", "writes");
         }
       case "editor_launch":
         if (op === "close") {
@@ -47224,8 +47401,8 @@ class GodotServer {
     if (path === undefined) {
       return { ok: false, response: this.createErrorResponse("projectPath is required.") };
     }
-    const file = join32(path, "project.godot");
-    if (!existsSync25(file)) {
+    const file = join33(path, "project.godot");
+    if (!existsSync26(file)) {
       return {
         ok: false,
         response: this.createErrorResponse(`Not a Godot project: ${path}`, [
@@ -47396,6 +47573,42 @@ class GodotServer {
     }
     return { ok: true, value: stale };
   }
+  async importWhatChanged(projectPath) {
+    if (staleImports(projectPath).length === 0) {
+      return;
+    }
+    const unminted = scriptsWithoutUid(projectPath);
+    const began = Date.now();
+    const done = await this.reimport(projectPath, undefined, false, scanWaitMs());
+    const tookMs = Date.now() - began;
+    const stillUnminted = scriptsWithoutUid(projectPath);
+    const uidsWritten = unminted.filter((script) => !stillUnminted.includes(script)).map((script) => `res://${script}`);
+    if (!done.ok) {
+      const why = done.response.content.map((block) => block.text).join(" ");
+      return {
+        imported: [],
+        notImported: [],
+        uidsWritten,
+        tookMs,
+        note: `Files changed since they were imported could not be imported before this run, so it reads their previous import: ${why}`
+      };
+    }
+    const imported = (readArray(done.payload, "reimported") ?? []).map(String);
+    const notImported = readArray(done.payload, "notReimported") ?? [];
+    const note = done.payload["stillImporting"] === true ? `The editor was still importing files changed since they were imported when the wait ran out after ${scanWaitMs() / 1000} seconds, so this run may read their previous import. project_import status says where each stands.` : notImported.length > 0 ? "The files under notImportedFirst are still on their previous import, so this run shows what they held before. project_import status says why." : undefined;
+    return { imported, notImported, uidsWritten, tookMs, ...note === undefined ? {} : { note } };
+  }
+  async afterTheImport(projectPath, waited, importedFirst) {
+    if (importedFirst === undefined) {
+      return waited;
+    }
+    const settled = await this.untilTheEditorsScanIsWritten(projectPath);
+    return {
+      waitedMs: waited.waitedMs + settled.waitedMs,
+      stillScanning: settled.stillScanning,
+      importedFirst
+    };
+  }
   async untilTheEditorsScanIsWritten(projectPath) {
     const open = this.godotBridge.getStatus().projectPath;
     if (!this.godotBridge.isConnected() || open === undefined || !isSameDirectory(open, projectPath)) {
@@ -47606,9 +47819,8 @@ class GodotServer {
       return {};
     } catch (error) {
       const message = errorMessage(error);
-      const why = message.includes("Unknown tool") ? "runs an addon from before writes were handed to it" : `could not take the change (${message})`;
       return {
-        editorNote: `The open editor ${why}, so it still holds the old values, answers them when asked, and writes them back over the file the next time it saves. editor_launch restart loads the file and the addon this server ships.`
+        editorNote: error instanceof AddonOfAnotherRelease ? `The open editor was not asked to take the change, so it still holds the old values, answers them when asked, and writes them back over the file the next time it saves. ${message}` : `The open editor could not take the change (${message}), so it still holds the old values, answers them when asked, and writes them back over the file the next time it saves. editor_launch restart loads the file again.`
       };
     }
   }
@@ -47821,8 +48033,7 @@ class GodotServer {
         const message = errorMessage(error);
         return {
           ok: false,
-          response: message.includes("Unknown tool") ? this.createErrorResponse("The editor is running an addon from before reimport_files, so it cannot be asked to reimport.", [
-            "editor_launch restart loads the addon this server ships",
+          response: error instanceof AddonOfAnotherRelease ? this.createErrorResponse(message, [
             "Or close the editor, and project_import reimport runs the engine import instead"
           ]) : this.createErrorResponse(`The editor answered reimport_files with an error: ${message}`)
         };
@@ -47859,7 +48070,7 @@ class GodotServer {
     }
     const scanned = await this.untilTheEditorsScanIsWritten(projectPath);
     this.logDebug(`Running ${operation} in ${projectPath}: ${JSON.stringify(params)}`);
-    const outcome = await runOperation({ godotPath: engine.value, script: this.operationsScript, debug: GODOT_DEBUG_MODE_DEFAULT }, operation, params, projectPath);
+    const outcome = await runOperation({ godotPath: engine.value, script: this.operationsScript, debug: DEBUG_MODE }, operation, params, projectPath);
     return withScanWait(outcome, scanned);
   }
   answer(outcome) {
@@ -47891,7 +48102,7 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const application = parseProjectGodot(readFileSync27(project.value.file, "utf8"))["application"] ?? {};
+    const application = parseProjectGodot(readFileSync28(project.value.file, "utf8"))["application"] ?? {};
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
@@ -47989,7 +48200,7 @@ class GodotServer {
     const exportArgs = [
       "--headless",
       "--log-file",
-      join32(exportLogs, "engine.log"),
+      join33(exportLogs, "engine.log"),
       "--path",
       project.value.path,
       debug ? "--export-debug" : "--export-release",
@@ -47997,7 +48208,7 @@ class GodotServer {
       output.absolutePath
     ];
     this.logDebug(`Exporting: ${engine.value} ${exportArgs.join(" ")}`);
-    const writtenAt = () => existsSync25(output.absolutePath) ? statSync14(output.absolutePath).mtimeMs : null;
+    const writtenAt = () => existsSync26(output.absolutePath) ? statSync15(output.absolutePath).mtimeMs : null;
     const caches = editorCacheDirectory(engine.value);
     const exportOnce = async () => {
       const before = writtenAt();
@@ -48080,10 +48291,10 @@ class GodotServer {
     if (movie !== null) {
       return this.createErrorResponse(movie);
     }
-    const missing = paths.value.filter((path) => !existsSync25(join32(project.value.path, path.slice("res://".length))));
+    const missing = paths.value.filter((path) => !existsSync26(join33(project.value.path, path.slice("res://".length))));
     const asked = paths.value.filter((path) => !missing.includes(path));
     const runner = "addons/gdUnit4/bin/GdUnitCmdTool.gd";
-    const noRunner = !existsSync25(join32(project.value.path, runner));
+    const noRunner = !existsSync26(join33(project.value.path, runner));
     if (asked.length === 0) {
       const verdict = `nothing at ${missing.join(" and ")}`;
       const andNoRunner = noRunner ? `, and gdUnit4 is not installed in this project: no ${runner}` : "";
@@ -48120,7 +48331,15 @@ class GodotServer {
     if (!classes.ok) {
       return this.answer(classes);
     }
-    const scanned = scanWaitIn(classes.payload);
+    const rebuildWaited = scanWaitIn(classes.payload);
+    const importWaited = scanWaitAnswer(await this.afterTheImport(project.value.path, { waitedMs: 0, stillScanning: false }, await this.importWhatChanged(project.value.path)));
+    const waitedMs = (rebuildWaited.waitedForEditorScanMs ?? 0) + (importWaited.waitedForEditorScanMs ?? 0);
+    const scanNote = importWaited.scanNote ?? rebuildWaited.scanNote;
+    const scanned = {
+      ...importWaited,
+      ...waitedMs > 0 ? { waitedForEditorScanMs: waitedMs } : {},
+      ...scanNote === undefined ? {} : { scanNote }
+    };
     const ours = `gdharness-reports/${randomUUID2()}`;
     const reports = `res://.godot/${ours}`;
     const ignored = readStringArray(args, "ignore") ?? [];
@@ -48191,14 +48410,14 @@ class GodotServer {
     await run.settled;
     const tookMs = Date.now() - began;
     const notCompiled = stopped.for ?? run.log.all.map((entry) => autoloadNotCompiled(entry, autoloaded)).find((found) => found !== null) ?? null;
-    const reportsDir = join32(project.value.path, ".godot", ...ours.split("/"));
+    const reportsDir = join33(project.value.path, ".godot", ...ours.split("/"));
     let report = null;
     let reportProblem = null;
     try {
-      const written = existsSync25(reportsDir) && notCompiled === null ? readdirSync14(reportsDir).filter((name) => name.startsWith("report_")).sort((a, b) => Number(a.slice("report_".length)) - Number(b.slice("report_".length))) : [];
+      const written = existsSync26(reportsDir) && notCompiled === null ? readdirSync15(reportsDir).filter((name) => name.startsWith("report_")).sort((a, b) => Number(a.slice("report_".length)) - Number(b.slice("report_".length))) : [];
       const newest = written.at(-1);
       if (newest !== undefined) {
-        report = parseJUnit(readFileSync27(join32(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync28(join33(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
@@ -48398,7 +48617,7 @@ class GodotServer {
         const checked = project.ok ? await this.engineDiagnostics(project.value.path, [readString(args, "scriptPath") ?? ""], one.noLanguageServer) : { refusal: project.response };
         return "refusal" in checked ? checked.refusal : this.jsonTextResponse({ ...checked.answers[0], ...engineChecked(one.noLanguageServer.reason) });
       }
-      return "refusal" in one ? one.refusal : this.jsonTextResponse(this.markedIfStale(one.answer));
+      return "refusal" in one ? one.refusal : this.jsonTextResponse(one.answer);
     }
     const progress = callProgress();
     const cancelled = callSignal();
@@ -48448,7 +48667,7 @@ class GodotServer {
         reported.push(one.answer);
       }
     }
-    return this.jsonTextResponse(this.markedIfStale({
+    return this.jsonTextResponse({
       clean: errors === 0 && unread === 0,
       scriptsChecked: scripts.value.length,
       errors,
@@ -48457,7 +48676,7 @@ class GodotServer {
       scripts: reported,
       nothingReported,
       ...byEngine === null ? {} : engineChecked(byEngine)
-    }));
+    });
   }
   async compileScripts(projectPath, paths) {
     const payload = { checked: [], failed: [], scripts: [] };
@@ -48514,13 +48733,6 @@ class GodotServer {
       })
     };
   }
-  markedIfStale(answer) {
-    const status = this.godotBridge.getStatus();
-    if (!hasSaidWhoItIs(status)) {
-      return answer;
-    }
-    return markIfStale(answer, status.addonVersion, SERVER_VERSION, status.addonDigest, shippedEditorDigest(), this.editorCodeOnDisk());
-  }
   async diagnosticsOf(args) {
     const waited = await this.waitForTheEditorOpenedHere(args, []);
     if (waited !== null) {
@@ -48566,11 +48778,11 @@ class GodotServer {
     const cached = cachedClasses(projectPath);
     const sourceOf = (resourcePath) => {
       const contained = resolveWithinProject(projectPath, resourcePath);
-      if (!contained.ok || !existsSync25(contained.absolutePath)) {
+      if (!contained.ok || !existsSync26(contained.absolutePath)) {
         return null;
       }
       try {
-        return readFileSync27(contained.absolutePath, "utf8");
+        return readFileSync28(contained.absolutePath, "utf8");
       } catch {
         return null;
       }
@@ -48660,11 +48872,11 @@ class GodotServer {
   }
   sourceOfClass(projectPath, resourcePath) {
     const contained = resolveWithinProject(projectPath, resourcePath);
-    if (!contained.ok || !existsSync25(contained.absolutePath)) {
+    if (!contained.ok || !existsSync26(contained.absolutePath)) {
       return null;
     }
     try {
-      return readFileSync27(contained.absolutePath, "utf8");
+      return readFileSync28(contained.absolutePath, "utf8");
     } catch {
       return null;
     }
@@ -48787,12 +48999,11 @@ class GodotServer {
     return client;
   }
   breakpointsAtRisk() {
-    const status = this.godotBridge.getStatus();
-    if (!hasSaidWhoItIs(status) || status.syncsBreakpoints === true) {
+    if (this.godotBridge.getStatus().syncsBreakpoints !== false) {
       return {};
     }
     return {
-      breakpointsAtRisk: status.syncsBreakpoints === false ? "This editor clears every breakpoint in its script editor whenever a debug session opens on its adapter, which this server does for its first breakpoint or stack read: network/debug_adapter/sync_breakpoints is off. The installed addon turns it on as it loads, so the editor is running an older one; editor_launch restart puts the installed addon in, or turn the setting on in Editor Settings > Network > Debug Adapter." : "Whether this editor keeps its breakpoints when a debug session opens cannot be told: the addon it is running predates the report. Godot clears them unless network/debug_adapter/sync_breakpoints is on, which the installed addon turns on as it loads; editor_launch restart puts the installed addon in."
+      breakpointsAtRisk: "This editor clears every breakpoint in its script editor whenever a debug session opens on its adapter, which this server does for its first breakpoint or stack read: network/debug_adapter/sync_breakpoints is off. The addon turns it on as it loads, so it was turned off since; turn it on in Editor Settings > Network > Debug Adapter, or editor_launch restart turns it on again."
     };
   }
   breakpointsForAGame(projectPath) {
@@ -48822,7 +49033,7 @@ class GodotServer {
       ...Array.isArray(stack) ? {
         stack: stack.map((frame) => ({
           ...frame,
-          ...projectPath !== "" && typeof frame["script"] === "string" && frame["script"].startsWith("res://") ? { path: join32(projectPath, frame["script"].slice("res://".length)) } : {}
+          ...projectPath !== "" && typeof frame["script"] === "string" && frame["script"].startsWith("res://") ? { path: join33(projectPath, frame["script"].slice("res://".length)) } : {}
         }))
       } : {}
     });
@@ -48886,13 +49097,13 @@ class GodotServer {
     const arriving = status.connected ? [] : arrivingFound;
     const isPortConflict = this.bridgeStartupError?.includes("EADDRINUSE") ?? false;
     const greeted = hasSaidWhoItIs(status);
-    const stale = greeted && editorIsStale(status.addonVersion, SERVER_VERSION, status.addonDigest, shippedEditorDigest());
+    const staleNote = this.godotBridge.anotherRelease();
     const unfinished = this.restartLeftUnfinished(status.connected);
     const cannotConnect = status.connected || this.ownProject === null ? null : editorAddonMissing(this.ownProject);
     return {
       ...status,
       serverVersion: SERVER_VERSION,
-      addonIsStale: greeted ? stale : undefined,
+      addonIsStale: greeted ? staleNote !== undefined : undefined,
       greeting: status.connected && !greeted ? "The editor has connected and has not yet said who it is: its project, pid, addon version and ports arrive with its greeting a moment after the socket opens, later while it imports. Ask again for them." : undefined,
       bridgeAvailable: this.bridgeStartupError === null && status.port !== null,
       mayYetConnect: status.connected ? undefined : cannotConnect !== null ? false : arriving.length > 0 ? true : unfinished !== null ? unfinished.underway : this.closedHere !== null ? false : anEditorIsStillComing(status.listeningSince, launchedIsUp),
@@ -48926,8 +49137,8 @@ class GodotServer {
         port: this.godotBridge.configuredPort,
         note: `The gdharness server this one replaced, pid ${this.handingOverFrom}, still holds port ${this.godotBridge.configuredPort} and is standing down; this server takes the port when it lets go, and takes another after ${HANDOVER_MS / 1000} seconds if it does not.`
       },
-      staleNote: stale ? addonMismatch(status.addonVersion, SERVER_VERSION, status.addonDigest, shippedEditorDigest(), this.editorCodeOnDisk()) : undefined,
-      addonNote: greeted ? sameCodeNote(status.addonVersion, SERVER_VERSION, status.addonDigest, shippedEditorDigest()) : undefined,
+      staleNote,
+      addonNote: greeted && staleNote === undefined ? sameCodeNote(status.addonVersion ?? "", SERVER_VERSION) : undefined,
       startedByAnEditorNote: status.startedByAnEditor === true ? "Another editor started this one: Godot's own restart, or the project manager opening a project. None of the arguments a server gave the editor before it reached this one, so it serves the ports its editor settings name (and none at all while another editor holds those, when the script and debug tools reach that editor instead), its console is not captured, and it restarts itself. Close it and use editor_launch open to have an editor this server started." : undefined,
       ...this.breakpointsAtRisk(),
       retryingBridge: this.bridgeRetry === null ? undefined : true,
@@ -49012,7 +49223,7 @@ class GodotServer {
         project: endpoint.project,
         ...this.ownProject === null ? {} : { ofThisProject: isSameDirectory(endpoint.project.path, this.ownProject) },
         editorPid: endpoint.editorPid,
-        addonVersion: endpoint.addon === undefined || endpoint.addon.version === "" ? null : endpoint.addon.version,
+        addonVersion: endpoint.addon.version === "" ? null : endpoint.addon.version,
         ...unknown ? {} : { addonIsStale: staleNote !== undefined },
         ...staleNote === undefined ? {} : { staleNote },
         reachable: reply.ok,
@@ -49101,7 +49312,7 @@ class GodotServer {
       return null;
     }
     try {
-      return settingKeys(readFileSync27(join32(projectPath, "project.godot"), "utf8"));
+      return settingKeys(readFileSync28(join33(projectPath, "project.godot"), "utf8"));
     } catch {
       return null;
     }
@@ -49125,7 +49336,7 @@ class GodotServer {
       ]);
     }
     const settingsBefore = this.settingKeysOf(before.projectPath);
-    const asked = mine ? await this.startItAgain(before.projectPath ?? "", before.editorPid, args["hidden"] === true) : await this.handleViaBridge("restart_editor", {});
+    const asked = mine ? await this.startItAgain(before.projectPath ?? "", before.editorPid, args["hidden"] === true, resolveSilent(args["silent"])) : await this.handleViaBridge("restart_editor", {});
     if (asked.isError === true) {
       return asked;
     }
@@ -49147,10 +49358,11 @@ class GodotServer {
       editorPid: now.editorPid,
       addonVersion: now.addonVersion,
       serverVersion: SERVER_VERSION,
-      addonIsStale: editorIsStale(now.addonVersion, SERVER_VERSION, now.addonDigest, shippedEditorDigest()),
-      staleNote: addonMismatch(now.addonVersion, SERVER_VERSION, now.addonDigest, shippedEditorDigest(), this.editorCodeOnDisk()),
+      addonIsStale: this.godotBridge.anotherRelease() !== undefined,
+      staleNote: this.godotBridge.anotherRelease(),
       ...this.whatTheEditorDropped(settingsBefore, after),
       ...servers,
+      ...mine && this.launchedEditor !== null ? { arguments: this.launchedEditor.arguments } : {},
       tookMs: Date.now() - began
     });
   }
@@ -49239,7 +49451,7 @@ class GodotServer {
   whatTheEditorDropped(before, after) {
     return settingsDroppedReport(before, after);
   }
-  async startItAgain(projectPath, editorPid, hidden) {
+  async startItAgain(projectPath, editorPid, hidden, silent) {
     const engine = await this.engine();
     if (!engine.ok) {
       return engine.response;
@@ -49268,7 +49480,7 @@ class GodotServer {
         `editor_launch open starts one on ${projectPath} once it has gone`
       ]);
     }
-    const opened = await this.openAnEditor(engine.value, projectPath, ports, hidden);
+    const opened = await this.openAnEditor(engine.value, projectPath, ports, hidden, silent);
     restartSettled(projectPath);
     if (opened.error !== null) {
       return this.createErrorResponse(`The editor was asked to go and could not be started again: ${opened.error}`, [`editor_launch opens one on ${projectPath}`]);
@@ -49318,7 +49530,7 @@ class GodotServer {
     const ports = await this.portsForAnEditor();
     const before = this.settingKeysOf(project.value.path);
     const unfinished = restartOwed(project.value.path);
-    const opened = await this.openAnEditor(engine.value, project.value.path, ports, args["hidden"] === true);
+    const opened = await this.openAnEditor(engine.value, project.value.path, ports, args["hidden"] === true, resolveSilent(args["silent"]));
     if (opened.error !== null) {
       return this.createErrorResponse(`Could not start the editor: ${opened.error}`);
     }
@@ -49330,6 +49542,7 @@ class GodotServer {
       projectPath: project.value.path,
       lspPort: ports.lsp,
       dapPort: ports.dap,
+      arguments: opened.arguments,
       finishesRestart: unfinished === null ? undefined : `This is the launch half of a restart begun at ${unfinished.quitAt} by server pid ${unfinished.byPid}, which quit editor pid ${unfinished.editorPid ?? "unknown"} and was ended before it could start one.`,
       settingsNote: before === null ? "project.godot could not be read before this editor was opened, so nothing here will be able to say what the import saved away. Opening a project rewrites the file and drops any key sitting at its own default." : before.size === 0 ? undefined : "Opening a project imports it and saves project.godot, and Godot drops any key sitting at its own default. editor_status names anything lost under settingsDropped once this editor has connected."
     });
@@ -49364,12 +49577,13 @@ class GodotServer {
     }
     return null;
   }
-  async openAnEditor(engine, projectPath, ports, hidden) {
+  async openAnEditor(engine, projectPath, ports, hidden, silent) {
     clearEditorLog(projectPath);
     freeLibraryCopies(projectPath);
+    const args = editorArguments(projectPath, ports, editorLogPath(projectPath), hidden, silent);
     const launched = await launchOutsideTheTree({
       command: engine,
-      args: editorArguments(projectPath, ports, editorLogPath(projectPath), hidden),
+      args,
       env: {
         ...process.env,
         GDHARNESS_RUNTIME_DIR: runtimeDirectory(),
@@ -49380,16 +49594,17 @@ class GodotServer {
       ...hidden ? { desktop: HIDDEN_DESKTOP } : { noActivate: true }
     });
     if ("error" in launched) {
-      return { pid: null, error: launched.error };
+      return { pid: null, error: launched.error, arguments: args };
     }
     writeEditorLogNote(projectPath, launched.pid);
     this.launchedEditor = {
       pid: launched.pid,
       startedAt: (await startTimesOf([launched.pid])).get(launched.pid) ?? null,
-      projectPath
+      projectPath,
+      arguments: args
     };
     this.closedHere = null;
-    return { pid: launched.pid, error: null };
+    return { pid: launched.pid, error: null, arguments: args };
   }
   async portsForAnEditor() {
     const lsp = portFromEnvOrNull("GDHARNESS_LSP_PORT") ?? await freePort(DEFAULT_LSP_PORT);
@@ -49454,11 +49669,13 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const scanned = await this.untilTheEditorsScanIsWritten(project.value.path);
+    const waited = await this.untilTheEditorsScanIsWritten(project.value.path);
     const refreshed = await this.refreshStaleClasses(project.value.path);
     if (!refreshed.ok) {
       return refreshed.response;
     }
+    const imported = exported === null ? await this.importWhatChanged(project.value.path) : undefined;
+    const scanned = await this.afterTheImport(project.value.path, waited, imported);
     const sceneArgument = sceneToRun?.ok ? sceneToRun.relativePath : null;
     if (op === "check") {
       return await this.checkBoot(engine.value, project.value.path, sceneArgument, args, given.value, scanned, asked.value, flags.value);
@@ -49487,9 +49704,10 @@ class GodotServer {
     });
     const runtimeWaitMs = this.announceBudget(args, project.value.path, sceneArgument);
     const editorWouldPlay = !headless || editorPlaysHeadless(project.value.file);
-    const silent = resolveSilent(args["silent"], process.env) && !headless;
+    const silent = resolveSilent(args["silent"]) && !headless;
+    const silentOnlyHere = silent && !editorPlaysHeadless(project.value.file);
     const profiled = readBoolean(args, "profile") === true;
-    if (exported === null && this.godotBridge.isConnected() && editorWouldPlay && given.value.length === 0 && flags.value.length === 0 && !needsItsOwnProcess(asked.value) && !silent) {
+    if (exported === null && this.godotBridge.isConnected() && editorWouldPlay && given.value.length === 0 && flags.value.length === 0 && !needsItsOwnProcess(asked.value) && !silentOnlyHere) {
       return await this.playThroughEditor(sceneArgument, refreshed.value, scanned, project.value.path, alreadyPlaying, runtimeWaitMs, ended, profiled);
     }
     const cmdArgs = runArguments({
@@ -49510,7 +49728,7 @@ class GodotServer {
     started.announcedBefore = alreadyPlaying;
     started.bootScene = runtimeWaitMs.scene;
     this.activeProcess = started;
-    const spawnedInstead = exported !== null ? " An exported build is started without a debugger, since a release build quits when given one, so breakpoints and debug_state do not reach it." : this.godotBridge.isConnected() && editorWouldPlay && (given.value.length > 0 || flags.value.length > 0) ? ` The editor cannot be handed arguments for a game it plays, so this one was started here.${OWN_DEBUGGER}` : this.godotBridge.isConnected() && editorWouldPlay && needsItsOwnProcess(asked.value) ? ` The editor plays a game with its own environment, so a run given one was started here.${OWN_DEBUGGER}` : this.godotBridge.isConnected() && editorWouldPlay && silent ? " The editor cannot play a game silent, which takes an engine flag, so this one was " + `started here${args["silent"] === true ? "" : ", silent because GDHARNESS_SILENT says so"}, and silent: false plays it through the editor.${OWN_DEBUGGER}` : "";
+    const spawnedInstead = exported !== null ? " An exported build is started without a debugger, since a release build quits when given one, so breakpoints and debug_state do not reach it." : this.godotBridge.isConnected() && editorWouldPlay && (given.value.length > 0 || flags.value.length > 0) ? ` The editor cannot be handed arguments for a game it plays, so this one was started here.${OWN_DEBUGGER}` : this.godotBridge.isConnected() && editorWouldPlay && needsItsOwnProcess(asked.value) ? ` The editor plays a game with its own environment, so a run given one was started here.${OWN_DEBUGGER}` : this.godotBridge.isConnected() && editorWouldPlay && silentOnlyHere ? " The editor cannot play a game silent, which takes an engine flag, so this one was " + `started here, silent as every run is unless asked otherwise, and silent: false plays it through the editor, with sound.${OWN_DEBUGGER}` : "";
     const endedForThis = endedToStartThis(ended);
     const stranded = wereHereFirst.filter((one) => one.pid !== ended?.pid && alive(one.pid));
     const handed = this.dapHoldingBreakpointsOf(project.value.path).breakpointsHeld();
@@ -49539,7 +49757,7 @@ class GodotServer {
   }
   async runtimeUp(projectPath, before, budget, withArgs) {
     const budgetMs = budget.ms;
-    if (!existsSync25(join32(projectPath, RUNTIME_AUTOLOAD.path))) {
+    if (!existsSync26(join33(projectPath, RUNTIME_AUTOLOAD.path))) {
       return runtimeVerdict(null, {
         addon: false,
         budgetMs,
@@ -49558,7 +49776,7 @@ class GodotServer {
     const lastSaid = () => editorSaysGoing ? "playing" : "not playing";
     const fresh = await announcedSince(projectPath, before, {
       budgetMs: Math.max(runBegan + budgetMs - waitBegan, 0),
-      accept: (one) => this.isTheGameOf(this.activeProcess, one, projectPath),
+      accept: (one) => this.isTheGameOf(this.activeProcess, one),
       giveUp: () => {
         if (this.dapClient?.isStopped() === true) {
           return true;
@@ -49597,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 },
@@ -49608,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;
@@ -49625,7 +49845,7 @@ class GodotServer {
     }
     let announcedAt;
     try {
-      announcedAt = statSync14(endpoint.file).mtimeMs;
+      announcedAt = statSync15(endpoint.file).mtimeMs;
     } catch {
       return;
     }
@@ -49808,7 +50028,7 @@ class GodotServer {
       return;
     }
     const before = run.announcedBefore ?? new Set;
-    const theOne = this.announcedOfTheRunsProject(run, runtimesAnnounced().running).find((one) => one.pid === Number(named) && !before.has(one.pid) && this.isTheGameOf(run, one, run.projectPath));
+    const theOne = this.announcedOfTheRunsProject(run, runtimesAnnounced().running).find((one) => one.pid === Number(named) && !before.has(one.pid) && this.isTheGameOf(run, one));
     if (theOne !== undefined) {
       this.tie(run, theOne);
     }
@@ -49819,7 +50039,7 @@ class GodotServer {
       return 0;
     }
     try {
-      return reportAlreadyInTranscript(readFileSync27(game.transcript), readFileSync27(report));
+      return reportAlreadyInTranscript(readFileSync28(game.transcript), readFileSync28(report));
     } catch (error) {
       this.logDebug(`Could not compare a picked-up run's report with its transcript: ${errorMessage(error)}`);
       return 0;
@@ -49902,16 +50122,16 @@ class GodotServer {
         return ended;
       }
     }
-    const startedAs = {
+    const { startedBy, command, projectPath } = running;
+    const why = startedBy === undefined || command === undefined || projectPath === null ? "this server holds no engine, project and start of it to check the process against" : await whyNotStillTheRecordedRun({
       pid: running.pid,
       transcript: running.transcript ?? "",
       startedAt: running.startedAt,
-      ...running.startedBy === undefined ? {} : { startedBy: running.startedBy },
-      projectPath: running.projectPath ?? "",
+      startedBy,
+      projectPath,
       arguments: [],
-      ...running.command === undefined ? {} : { command: running.command }
-    };
-    const why = await whyNotStillTheRecordedRun(startedAs);
+      command
+    });
     if (why !== null) {
       clearTheRecord();
       running.endedHere = null;
@@ -50196,7 +50416,7 @@ class GodotServer {
       return run.announcedPid;
     }
     const before = run.announcedBefore ?? new Set;
-    const candidates = ours.filter((one) => !before.has(one.pid) && this.isTheGameOf(run, one, run.projectPath));
+    const candidates = ours.filter((one) => !before.has(one.pid) && this.isTheGameOf(run, one));
     const theOne = candidates.length === 1 ? candidates[0] : undefined;
     if (theOne !== undefined) {
       this.tie(run, theOne);
@@ -50306,22 +50526,16 @@ class GodotServer {
     run.announcedPid = endpoint.pid;
     this.noteBootOf(run, endpoint);
   }
-  playedByOurEditor(endpoint, projectPath) {
+  playedByOurEditor(endpoint) {
     const editor = this.godotBridge.getStatus().editorPid;
-    if (editor === undefined) {
-      return true;
-    }
-    if (endpoint.editorPid !== undefined) {
-      return endpoint.editorPid === editor;
-    }
-    return !runtimeAddonAnnouncesEditors(projectPath ?? this.ownProject);
+    return editor === undefined || endpoint.editorPid === editor;
   }
-  isTheGameOf(run, endpoint, projectPath) {
+  isTheGameOf(run, endpoint) {
     if (run === null) {
       return false;
     }
     if (run.throughEditor) {
-      return this.playedByOurEditor(endpoint, projectPath);
+      return this.playedByOurEditor(endpoint);
     }
     const editor = this.godotBridge.getStatus().editorPid;
     return endpoint.editorPid === undefined || endpoint.editorPid !== editor;
@@ -50339,12 +50553,12 @@ class GodotServer {
       log: new GameLog,
       transcript: record.transcript,
       readOffset: 0,
-      projectPath: record.projectPath === "" ? null : record.projectPath,
+      projectPath: record.projectPath,
       startedAt: record.startedAt,
-      ...record.startedBy === undefined ? {} : { startedBy: record.startedBy },
+      startedBy: record.startedBy,
       ...record.keeper === undefined ? {} : { keeper: record.keeper },
       ...record.profile === undefined ? {} : { profile: record.profile },
-      ...record.command === undefined ? {} : { command: record.command },
+      command: record.command,
       exitCode: null,
       exitSignal: null,
       throughEditor: false,
@@ -50397,9 +50611,8 @@ class GodotServer {
     if (record === null) {
       return `No game is running.${noEditor} Start one with editor_run.`;
     }
-    const whose = record.projectPath === "" ? "a project it does not name" : record.projectPath;
     const ours = mine === null ? "this server was started without GDHARNESS_PROJECT and has no editor connected, so it cannot say whose that run is" : `this server serves ${mine}`;
-    return `No game of this server's is running.${noEditor} A run started from ${whose} is recorded on this machine, and ${ours}, so it is not this server's to answer for or to end. Start one with editor_run.`;
+    return `No game of this server's is running.${noEditor} A run started from ${record.projectPath} is recorded on this machine, and ${ours}, so it is not this server's to answer for or to end. Start one with editor_run.`;
   }
   aRuntimeOfOursIsAnswering() {
     return this.announcedForOurProject(discoverRuntimes());
@@ -50521,7 +50734,7 @@ class GodotServer {
     };
     const going = await this.runStillGoing(run);
     const projectPath = run.projectPath;
-    const projectGone = projectPath !== null && !existsSync25(join32(projectPath, "project.godot"));
+    const projectGone = projectPath !== null && !existsSync26(join33(projectPath, "project.godot"));
     if (projectGone && callersName !== undefined) {
       return this.createErrorResponse(`callersOf reads the project's scripts, and the run's project at ${projectPath} has no project.godot any more.`, ["editor_run profile without callersOf answers with the profile itself"]);
     }
@@ -50868,7 +51081,7 @@ class GodotServer {
       notes.push(endedWithoutACode({
         throughEditor: run.throughEditor,
         announced: announced !== undefined || run.announcedPid !== undefined,
-        couldAnnounce: run.projectPath !== null && existsSync25(join32(run.projectPath, RUNTIME_AUTOLOAD.path)),
+        couldAnnounce: run.projectPath !== null && existsSync26(join33(run.projectPath, RUNTIME_AUTOLOAD.path)),
         endedHere: typeof run.endedHere === "string",
         pickedUp: run.pickedUp === true
       }));
@@ -51185,10 +51398,9 @@ class GodotServer {
         idleSince = null;
         continue;
       }
-      const pending = Boolean(status["pending"]) && Date.now() - started < SCAN_START_MS;
       const completed = readNumber(status, "scansCompleted");
       const notYetOver = completedBefore !== undefined && completed !== undefined && completed <= completedBefore;
-      busy = Boolean(status["scanning"]) || Boolean(status["importing"]) || pending || notYetOver;
+      busy = Boolean(status["scanning"]) || Boolean(status["importing"]) || notYetOver;
       if (busy) {
         idleSince = null;
       } else {
@@ -51248,7 +51460,7 @@ class GodotServer {
               constantsBefore: listed("heldConstantsBefore")["heldConstantsBefore"] ?? [],
               constantsAfter: listed("constants")["constants"] ?? [],
               names: projectPath === "" ? [] : this.classesAScriptNames(projectPath, script),
-              restored: typeof answer["restored"] === "boolean" ? answer["restored"] : null,
+              restored: answer["restored"] === true,
               restoredAs: readString(answer, "restoredAs") ?? ""
             })
           };
@@ -51352,7 +51564,7 @@ class GodotServer {
         }
         const failed = answer["failed"];
         if (typeof failed === "number" && failed !== 0) {
-          const left = answer["restored"] === true ? "" : answer["restored"] === false ? "; compiling it again from the text it was built from failed too, so the editor holds it unusable until it compiles" : "; a failed compile leaves the copy the editor holds unusable until it compiles, and this editor does not put it back";
+          const left = answer["restored"] === true ? "" : "; compiling it again from the text it was built from failed too, so the editor holds it unusable until it compiles";
           notReloaded.push({
             scriptPath,
             problem: `it did not compile: Godot answered error ${failed}${readString(answer, "failedAs") ? `, ${readString(answer, "failedAs")}` : ""}${left}`
@@ -51498,7 +51710,7 @@ class GodotServer {
     if (!scriptPath.ok) {
       return this.createErrorResponse(scriptPath.reason);
     }
-    if (!existsSync25(scriptPath.absolutePath)) {
+    if (!existsSync26(scriptPath.absolutePath)) {
       return this.createErrorResponse(`Script file does not exist: ${scriptPath.absolutePath}`);
     }
     const asked = readNonEmptyString(args, "newScriptPath");
@@ -51912,7 +52124,7 @@ class GodotServer {
     }
     const escaped = symbol.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const declared = new RegExp(`^\\s*(?:@\\w+(?:\\([^)]*\\))?\\s+)*class_name\\s+${escaped}\\b`, "m");
-    if (declared.test(readFileSync27(scriptPath, "utf8"))) {
+    if (declared.test(readFileSync28(scriptPath, "utf8"))) {
       return null;
     }
     const checked = await this.classesTheEditorCannotSee(args);
@@ -52011,20 +52223,18 @@ class GodotServer {
       ]);
     }
     try {
-      return this.jsonTextResponse(markIfStale(await this.godotBridge.invokeTool(toolName, args), this.godotBridge.getStatus().addonVersion, SERVER_VERSION, this.godotBridge.getStatus().addonDigest, shippedEditorDigest(), this.editorCodeOnDisk()));
+      return this.jsonTextResponse(await this.godotBridge.invokeTool(toolName, args));
     } catch (error) {
       if (error instanceof BridgeTimeout) {
         return error;
       }
+      if (error instanceof AddonOfAnotherRelease) {
+        return this.createErrorResponse(error.message, ["editor_status says which addon the editor holds"]);
+      }
       const message = errorMessage(error);
       if (message.includes(`Unknown tool: ${toolName}`)) {
-        const status = this.godotBridge.getStatus();
-        const remedy = addonMismatch(status.addonVersion, SERVER_VERSION, status.addonDigest, shippedEditorDigest(), this.editorCodeOnDisk());
-        if (remedy === undefined) {
-          const log = open === undefined || open === "" ? "the editor's Output panel" : `${editorLogPath(open)} for an editor editor_launch opened, or the Output panel of one opened by hand`;
-          return this.createErrorResponse(`The editor's gdharness addon is this ${SERVER_VERSION} server's own and still has no ${named}, so a script of the addon failed to load in this editor and the commands it holds were never registered. The script and the error are in ${log}.`, ["editor_status says which addon the editor holds"]);
-        }
-        return this.createErrorResponse(`The editor's gdharness addon is older than this ${SERVER_VERSION} server and has no ${named}, so it cannot answer this call. ${remedy}`, ["editor_status says which addon the editor holds"]);
+        const log = open === undefined || open === "" ? "the editor's Output panel" : `${editorLogPath(open)} for an editor editor_launch opened, or the Output panel of one opened by hand`;
+        return this.createErrorResponse(`The editor's gdharness addon is this ${SERVER_VERSION} server's own and still has no ${named}, so a script of the addon failed to load in this editor and the commands it holds were never registered. The script and the error are in ${log}.`, ["editor_status says which addon the editor holds"]);
       }
       return this.createErrorResponse(`The editor answered ${named} with an error: ${message}`);
     }
@@ -52080,7 +52290,7 @@ class GodotServer {
   async ownRunOnItsWay(projectPath, budgetMs) {
     const run = await this.currentRun();
     const project = projectPath ?? run?.projectPath ?? null;
-    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync25(join32(project, RUNTIME_AUTOLOAD.path)) || !await this.runStillGoing(run)) {
+    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync26(join33(project, RUNTIME_AUTOLOAD.path)) || !await this.runStillGoing(run)) {
       return null;
     }
     const already = runtimesAnnounced().running;
@@ -52089,12 +52299,12 @@ class GodotServer {
         return !run.announcedBefore.has(one.pid);
       }
       try {
-        return statSync14(one.file).mtimeMs >= run.startedAt;
+        return statSync15(one.file).mtimeMs >= run.startedAt;
       } catch {
         return false;
       }
     };
-    if (already.some((one) => announcedSinceTheStart(one) && this.isTheGameOf(run, one, project))) {
+    if (already.some((one) => announcedSinceTheStart(one) && this.isTheGameOf(run, one))) {
       return null;
     }
     const which = run.throughEditor ? "the game the editor is playing for it" : `pid ${run.pid ?? "unknown"}`;
@@ -52106,7 +52316,7 @@ class GodotServer {
     }
     const fresh = await announcedSince(project, new Set(already.map((one) => one.pid)), {
       budgetMs: Math.min(budgetMs, remaining),
-      accept: (one) => this.isTheGameOf(this.activeProcess, one, project),
+      accept: (one) => this.isTheGameOf(this.activeProcess, one),
       giveUp: () => this.activeProcess !== run || this.dapClient?.isStopped() === true || !stillRunning(run)
     });
     const endpoint = await this.theRunsAmong(run, fresh);
@@ -52169,13 +52379,13 @@ class GodotServer {
         return this.createErrorResponse(refusal);
       }
     }
-    const screenshotDir = expectsScreenshot ? scratchDirectory("runtime-screenshot") : null;
-    const screenshotPath = screenshotDir ? join32(screenshotDir, "capture.png") : null;
     const staleNote = this.runtimeStaleNote(choice.endpoint);
-    const stale = staleNote === undefined ? {} : { addonIsStale: true, staleNote };
-    const refused = (message) => this.createErrorResponse(staleNote === undefined ? message : `${message}
-
-${staleNote}`);
+    if (staleNote !== undefined) {
+      return this.createErrorResponse(staleNote);
+    }
+    const screenshotDir = expectsScreenshot ? scratchDirectory("runtime-screenshot") : null;
+    const screenshotPath = screenshotDir ? join33(screenshotDir, "capture.png") : null;
+    const refused = (message) => this.createErrorResponse(message);
     const onGame = {
       pid: choice.endpoint.pid,
       what: `${asked.tool} ${asked.op}`,
@@ -52201,7 +52411,6 @@ ${staleNote}`);
           waitedMs: timeoutMs,
           note: `${reply.message} ${longerWaitNote(asked.tool, asked.op, timeoutMs)}`,
           ...answeredBy,
-          ...stale,
           ...alongside()
         });
       }
@@ -52210,7 +52419,7 @@ ${staleNote}`);
       }
       const { id: _id, ...payload } = reply.payload;
       if (!expectsScreenshot) {
-        return this.jsonTextResponse({ ...payload, ...answeredBy, ...stale, ...alongside() });
+        return this.jsonTextResponse({ ...payload, ...answeredBy, ...alongside() });
       }
       const returnedPath = readString(payload, "path");
       if (readString(payload, "type") !== "screenshot_file" || !returnedPath || !screenshotPath) {
@@ -52234,11 +52443,9 @@ ${staleNote}`);
             type: "text",
             text: `Screenshot captured: ${dimensions}${chosenAmongSeveral ? ` from pid ${own}, the game this server holds` : ""}${captureDetail(payload)}${saveTo === null ? "" : `. Saved to ${saveTo}`}${ranWith.length === 0 ? "" : `
 
-Ran alongside ${ranWith.join(", ")}. ${ALONGSIDE_NOTE}`}${staleNote === undefined ? "" : `
-
-${staleNote}`}`
+Ran alongside ${ranWith.join(", ")}. ${ALONGSIDE_NOTE}`}`
           },
-          { type: "image", data: readFileSync27(screenshotPath).toString("base64"), mimeType: "image/png" }
+          { type: "image", data: readFileSync28(screenshotPath).toString("base64"), mimeType: "image/png" }
         ]
       };
     } finally {
@@ -52355,7 +52562,7 @@ async function runGodotServer() {
   const server = new GodotServer;
   await server.run();
 }
-var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, FAILED_BUDGET = 1e6, ANSWER_BUDGET = 4000000, __dirname2, PARENT_ASKED_AFTER_MS = 5000, EDITOR_SERVERS_START_MS = 20000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, ALONGSIDE_NOTE = "Another call on this game was running while this one was: calls sent together run together and are answered as each finishes, so this answer is not from after the other. Send a call meant to come after another once that one has answered.", OWN_DEBUGGER = " Its debugger is the keeper holding it rather than the editor, so the debug_* tools answer for it all the same: breakpoints stop it, and debug_control pause breaks into it wherever it is, which the editor offers no way to do.", PLAY_STARTS_WITHIN_MS = 30000, KEEPER_ANSWER_MS = 15000, KEEPER_DEBUG_MS, EXIT_REPORTED_WITHIN_MS = 2000, CLOSE_ASK_MS = 3000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, PROFILE_SEND_MS = 5000, MOST_GROUPS = 20, RUNTIME_LISTENING_LINE = "[gdharness] runtime listening on ", VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, CONSOLE_WATCH_MS = 250, BOUNDARY_WAIT_MS = 2000, HANDOVER_MS, HANDOVER_POLL_MS = 250, CACHE_WRITE_MS = 2000, STREAMS_GRACE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, SCAN_SETTLED_MS = 500, REIMPORT_TIMEOUT_MS = 300000, OPS_ELSEWHERE, AUDIO_BUS_OPS, STALLED_AFTER_MS = 30000, TEST_HEARTBEAT_MS = 20000, DEPENDED_FAILED = "Failed to compile depended scripts", LOOPING_AFTER = 100, WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, OUTPUT_PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/", PROFILE_FUNCTIONS = 30, PROFILER_ON_MS = 3000, PROPERTY_PLACES = "It is a property, so each place says whether it writes it (access write), which runs its set block, or reads it (access read), which runs its get block: withinCalls on a read says nothing of the set block, nor on a write of the get block unless the write is a compound one such as +=. Inside the property's own blocks its name is the value stored, which the engine reads and writes without running them, so those lines are not listed.", CALLERS_FOUND_BY_NAME = "Found by name in the project's scripts, since the engine's profiler counts calls and time per function and records nothing about who made them: a method of the same name on another class is listed too, unless one class was asked about and it is called through another class by name or through a variable declared as one. Each place carries the profile's numbers for the function it is written in.", MOST_ENGINE_ENTRIES = 200, ERROR_ASSERT = "GdUnitGodotErrorAssertImpl.gd", EXTERNAL_MEMBER = 'Could not resolve external class member "', STATIC_LIST_HINT;
+var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, FAILED_BUDGET = 1e6, ANSWER_BUDGET = 4000000, __dirname2, PARENT_ASKED_AFTER_MS = 5000, EDITOR_SERVERS_START_MS = 20000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, ALONGSIDE_NOTE = "Another call on this game was running while this one was: calls sent together run together and are answered as each finishes, so this answer is not from after the other. Send a call meant to come after another once that one has answered.", OWN_DEBUGGER = " Its debugger is the keeper holding it rather than the editor, so the debug_* tools answer for it all the same: breakpoints stop it, and debug_control pause breaks into it wherever it is, which the editor offers no way to do.", PLAY_STARTS_WITHIN_MS = 30000, KEEPER_ANSWER_MS = 15000, KEEPER_DEBUG_MS, EXIT_REPORTED_WITHIN_MS = 2000, CLOSE_ASK_MS = 3000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, PROFILE_SEND_MS = 5000, MOST_GROUPS = 20, RUNTIME_LISTENING_LINE = "[gdharness] runtime listening on ", VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, CONSOLE_WATCH_MS = 250, BOUNDARY_WAIT_MS = 2000, HANDOVER_MS, HANDOVER_POLL_MS = 250, CACHE_WRITE_MS = 2000, STREAMS_GRACE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_SETTLED_MS = 500, REIMPORT_TIMEOUT_MS = 300000, OPS_ELSEWHERE, AUDIO_BUS_OPS, STALLED_AFTER_MS = 30000, TEST_HEARTBEAT_MS = 20000, DEPENDED_FAILED = "Failed to compile depended scripts", LOOPING_AFTER = 100, WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, OUTPUT_PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/", PROFILE_FUNCTIONS = 30, PROFILER_ON_MS = 3000, PROPERTY_PLACES = "It is a property, so each place says whether it writes it (access write), which runs its set block, or reads it (access read), which runs its get block: withinCalls on a read says nothing of the set block, nor on a write of the get block unless the write is a compound one such as +=. Inside the property's own blocks its name is the value stored, which the engine reads and writes without running them, so those lines are not listed.", CALLERS_FOUND_BY_NAME = "Found by name in the project's scripts, since the engine's profiler counts calls and time per function and records nothing about who made them: a method of the same name on another class is listed too, unless one class was asked about and it is called through another class by name or through a variable declared as one. Each place carries the profile's numbers for the function it is written in.", MOST_ENGINE_ENTRIES = 200, ERROR_ASSERT = "GdUnitGodotErrorAssertImpl.gd", EXTERNAL_MEMBER = 'Could not resolve external class member "', STATIC_LIST_HINT;
 var init_server = __esm(() => {
   init_dist();
   init_stdio();
@@ -52384,6 +52591,7 @@ var init_server = __esm(() => {
   init_godot_path();
   init_headless();
   init_headless_operations();
+  init_import_freshness();
   init_issues();
   init_junit();
   init_keeper_channel();
@@ -52476,8 +52684,8 @@ var init_server = __esm(() => {
 init_bridge_announce();
 init_errors();
 init_godot_path();
-import { existsSync as existsSync26 } from "node:fs";
-import { join as join33, resolve as resolve8 } from "node:path";
+import { existsSync as existsSync27 } from "node:fs";
+import { join as join34, resolve as resolve8 } from "node:path";
 
 // src/harnesses.ts
 import { existsSync as existsSync4, mkdirSync as mkdirSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, rmSync as rmSync2, statSync as statSync3, writeFileSync as writeFileSync2 } from "node:fs";
@@ -53472,10 +53680,10 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
 - \`editor_status\` says whether an editor is connected and whether its addon matches the server.
   \`addonIsStale\` means the editor is running different addon code from what the server ships
   (an older \`addonVersion\` on the same code is not stale), and \`staleNote\` says which half is behind: an editor that
-  needs restarting, or a server that needs reconnecting in your harness. Every answer that came
-  from the editor carries the same two when they differ, so a stale addon cannot answer quietly:
-  believe a restart over a diagnostic that arrived with them. A game's runtime addon is judged
-  the same way, under each entry in \`runtimes\` and on every \`runtime_*\` answer from it.
+  needs restarting, a project that needs the upgrade command, or a server that needs reconnecting
+  in your harness. A stale editor is asked nothing but to quit, and every other call to it is
+  refused with the same note. A game's runtime addon is judged the same way, under each entry in
+  \`runtimes\`, and a \`runtime_*\` call to a stale game is refused with its note.
 - Start the game with \`editor_run start\`, never by spawning an engine. The editor plays it, so
   its debugger holds it, which is what gives the \`debug_*\` tools something to talk to. Its answer
   says under \`runtime\` whether the game can be talked to yet; when it cannot, \`mayYetAnnounce\`
@@ -53761,7 +53969,7 @@ class UsageError extends Refusal {
 function projectArgument(at) {
   const named = args.slice(at).find((value) => !value.startsWith("--"));
   const projectPath = resolve8(named ?? ".");
-  if (!existsSync26(join33(projectPath, "project.godot"))) {
+  if (!existsSync27(join34(projectPath, "project.godot"))) {
     throw new UsageError(`Not a Godot project: ${projectPath} holds no project.godot.`);
   }
   return projectPath;
@@ -53769,11 +53977,11 @@ function projectArgument(at) {
 async function engine(projectPath) {
   const located = await new GodotLocator().find();
   if (located.ok) {
-    return { godotPath: located.path, script: shippedOperationsScript(), debug: GODOT_DEBUG_MODE_DEFAULT };
+    return { godotPath: located.path, script: shippedOperationsScript(), debug: DEBUG_MODE };
   }
   const recorded = located.named === null && projectPath !== undefined ? recordedEnginePath(projectPath) : null;
   if (recorded !== null) {
-    return { godotPath: recorded, script: shippedOperationsScript(), debug: GODOT_DEBUG_MODE_DEFAULT };
+    return { godotPath: recorded, script: shippedOperationsScript(), debug: DEBUG_MODE };
   }
   const main = located.named === null && projectPath !== undefined ? mainCheckoutOf(projectPath) : null;
   const theirs = main === null ? null : recordedEnginePath(main);
@@ -53782,7 +53990,7 @@ async function engine(projectPath) {
     throw new UsageError(`${refusal.message} ${refusal.advice.join(". ")}.`);
   }
   console.error(`engine: ${theirs}, which the harness config of ${main} names; this project is a git worktree of it`);
-  return { godotPath: theirs, script: shippedOperationsScript(), debug: GODOT_DEBUG_MODE_DEFAULT };
+  return { godotPath: theirs, script: shippedOperationsScript(), debug: DEBUG_MODE };
 }
 function said2(outcome, what) {
   if (!outcome.ok) {
@@ -53806,7 +54014,7 @@ async function registerRuntime(godot, projectPath) {
     return;
   }
   console.log(`${RUNTIME_AUTOLOAD.name} autoload left at ${named}, which this project registers itself`);
-  if (!existsSync26(join33(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
+  if (!existsSync27(join34(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
     console.log(`  that file is not in this project, so it boots with a missing script: restore it, or point the entry at res://${RUNTIME_AUTOLOAD.path}`);
   }
 }
@@ -53938,7 +54146,7 @@ async function setup() {
       console.log("no harness configured; name one yourself, and gdharness harnesses lists them all");
     }
     if (!args.includes("--no-skill")) {
-      const directories = skillDirectories(chosen.harnesses, projectPath, existsSync26);
+      const directories = skillDirectories(chosen.harnesses, projectPath, existsSync27);
       for (const written of writeSkill(directories, getLocalVersion())) {
         console.log(`skill: ${written.replaced ? "replaced" : "written"} ${written.path}`);
       }
@@ -54052,14 +54260,14 @@ async function upgrade() {
       moved.push(took.from);
     }
   }
-  for (const written of writeSkill(skillDirectories(already, projectPath, existsSync26), version)) {
+  for (const written of writeSkill(skillDirectories(already, projectPath, existsSync27), version)) {
     console.log(`skill: ${written.replaced ? "replaced" : "written"} ${written.path}`);
   }
   console.log(`
 On ${version}. What is left for you:`);
   console.log(digestBefore !== null && digestBefore === installedEditorDigest(projectPath) ? `  1. Nothing for the editor: this upgrade left the editor addons the same code as before,
 ` + `     so it gives an open editor nothing to restart for. editor_status says addonIsStale
-` + "     if the editor is older than that." : `  1. The open editor is still running the addons it loaded at startup. Restart it with the
+` + "     if the editor is running other code." : `  1. The open editor is still running the addons it loaded at startup. Restart it with the
 ` + "     editor_launch restart tool, which closes and reopens the window.");
   const serving = await serverServing(projectPath);
   console.log(harnessNote({ moved, written, byHand }, [launch.command, ...launch.args].join(" "), serving === null ? null : { server: serving, isThisVersion: serving.version === version }));