gdharness 1.3.1 → 1.3.3

package/build/cli.js

@@ -7864,7 +7864,8 @@ function resolveWithinProject(projectPath, candidatePath, options = {}) {
   if (trimmed.includes("\x00")) {
     return { ok: false, reason: "Path contains a null byte." };
   }
-  const withoutScheme = trimmed.startsWith(RESOURCE_SCHEME) ? trimmed.slice(RESOURCE_SCHEME.length) : trimmed;
+  const root = resolve(projectPath);
+  const withoutScheme = trimmed.startsWith(RESOURCE_SCHEME) ? trimmed.slice(RESOURCE_SCHEME.length) : isAbsolute(trimmed) && isWithinRoot(root, trimmed) ? relative(root, resolve(trimmed)).split(sep).join("/") : trimmed;
   if (withoutScheme.startsWith("uid://")) {
     return {
       ok: false,
@@ -7881,7 +7882,7 @@ function resolveWithinProject(projectPath, candidatePath, options = {}) {
   if (withoutScheme.startsWith("/") || withoutScheme.startsWith("\\") || isAbsolute(withoutScheme)) {
     return {
       ok: false,
-      reason: `Path '${trimmed}' is absolute; give a path inside the project, such as 'scenes/main.tscn'.`
+      reason: `Path '${trimmed}' is absolute and outside the project; give a path inside it, such as 'scenes/main.tscn'.`
     };
   }
   const kept = keptInside(trimmed);
@@ -7897,7 +7898,6 @@ function resolveWithinProject(projectPath, candidatePath, options = {}) {
       reason: `Path '${trimmed}' contains ':', which no file inside a project is named with.`
     };
   }
-  const root = resolve(projectPath);
   const absolutePath = resolve(root, withoutScheme);
   if (!isWithinRoot(root, absolutePath)) {
     return { ok: false, reason: `Path '${trimmed}' resolves outside the project directory.` };
@@ -10678,6 +10678,14 @@ function unloadedTypes(messages, declared, cached) {
   }
   return found;
 }
+function uncachedFor(projectPath, messagesPer) {
+  if (!messagesPer.some((messages) => messages.some((message) => unknownTypeIn(message) !== null))) {
+    return messagesPer.map(() => []);
+  }
+  const declared = declaredClasses(projectPath);
+  const cached = cachedClasses(projectPath);
+  return messagesPer.map((messages) => unloadedTypes(messages, declared, cached).filter((type) => !type.inTheClassCache));
+}
 function classesNamedIn(source, known) {
   const named = new Set;
   for (const [word] of source.matchAll(/\b[A-Z][A-Za-z0-9_]*\b/g)) {
@@ -10818,6 +10826,16 @@ function uncachedClassNote(types) {
   const one = types.length === 1;
   return `${types.join(", ")} ${one ? "is declared" : "are declared"} in this project and missing from ` + `.godot/global_script_class_cache.cfg, so a game launched now would not resolve ${one ? "it" : "them"} ` + "either. Try editor_rescan first: it asks the editor already running and starts nothing, and it " + "cleared this in 314ms in a second project with a 31-worker fan-out still importing. It is not " + "always enough, because a file another engine has already imported reads as settled and the " + "walk does not look inside it. project_import refresh_classes rewrites the cache from the " + "declarations on disk and does reach that case, at the cost of a short headless engine, which " + "is worth knowing when something else is already running against this project.";
 }
+function uncachedForTheEngineNote(projectPath, types) {
+  if (types.length === 0) {
+    return "";
+  }
+  const one = types.length === 1;
+  const named = types.map((type) => `${type.type} (${type.declaredIn})`).join(", ");
+  const cacheExists = existsSync11(join12(projectPath, ".godot", "global_script_class_cache.cfg"));
+  const state = cacheExists ? `missing from .godot/global_script_class_cache.cfg, which is where the engine that compiled these scripts resolves a class name from, so the error is the cache being behind the files rather than the script.` : `the engine that compiled these scripts resolves a class name from .godot/global_script_class_cache.cfg, which has not been written yet, as in a project no editor has opened, so the error is the missing cache rather than the script.`;
+  return `${named} ${one ? "is" : "are"} declared in this project${cacheExists ? " and" : ", but"} ${state} ` + "project_import refresh_classes writes the cache from the declarations on disk; editor_run start " + "writes it before a game, and an editor opening the project writes it when it scans.";
+}
 function cacheWrittenAt(projectPath) {
   const cache = join12(projectPath, ".godot", "global_script_class_cache.cfg");
   try {
@@ -11046,6 +11064,17 @@ function ignoredTexts(projectPath) {
   visit(projectPath, "", false);
   return found;
 }
+function plainMatch(line, needle, caseSensitive) {
+  if (caseSensitive) {
+    return line.includes(needle) ? [needle] : null;
+  }
+  const lowered = line.toLowerCase();
+  const at = lowered.indexOf(needle);
+  if (at < 0) {
+    return null;
+  }
+  return [lowered.length === line.length ? line.slice(at, at + needle.length) : needle];
+}
 function searchProject(projectPath, options) {
   const extensions = options.fileTypes === undefined ? null : new Set(options.fileTypes.map((ext) => ext.replace(/^\./, "").toLowerCase()).filter(Boolean));
   const result = {
@@ -11083,7 +11112,7 @@ function searchProject(projectPath, options) {
       result.summary.files_searched += 1;
       const matches = [];
       for (const [index, line] of bytes.toString("utf8").split(/\r?\n/).entries()) {
-        const found = regex ? regex.exec(line) : (options.caseSensitive ? line : line.toLowerCase()).includes(needle) ? [options.query] : null;
+        const found = regex ? regex.exec(line) : plainMatch(line, needle, options.caseSensitive);
         if (found === null) {
           continue;
         }
@@ -11091,7 +11120,7 @@ function searchProject(projectPath, options) {
           result.summary.truncated = true;
           break;
         }
-        matches.push({ line: index + 1, content: line.trim(), match: found[0] ?? "" });
+        matches.push({ line: index + 1, content: line.trim(), match: found[0] });
         result.summary.total_matches += 1;
       }
       if (matches.length > 0) {
@@ -11879,6 +11908,7 @@ var init_tool_definitions = __esm(() => {
   init_launch();
   PROJECT_INFO_SECTIONS = [
     "autoloads",
+    "input_actions",
     "plugins",
     "export_presets",
     "audio_buses",
@@ -11912,7 +11942,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. 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}`,
+    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. An enum property takes the name of a value, as the script spells it, or its number; a value past an export range, or a number no value of an enum has, is written as given and named under outsideDeclared. ${WHOLE_NUMBERS}`,
     additionalProperties: true
   };
   XY = {
@@ -12005,7 +12035,7 @@ var init_tool_definitions = __esm(() => {
   };
   TILESET_SOURCES = {
     type: "array",
-    description: "Atlas sources, one per texture.",
+    description: "Atlas sources, one per texture. A wholly transparent cell gets no tile, and the answer lists those cells as leftBlank; a strip at the right or bottom that no whole tile reaches is described in notInAnyTile. A path that already exists is refused, as create_tileset would replace the whole TileSet.",
     items: {
       type: "object",
       properties: {
@@ -12025,17 +12055,17 @@ var init_tool_definitions = __esm(() => {
       type: "object",
       properties: {
         coords: XY,
-        sourceId: { type: "number", description: "TileSet source index." },
-        atlasCoords: XY,
+        sourceId: { type: "number", description: "TileSet source id, or -1 to erase the cell." },
+        atlasCoords: { ...XY, description: "The tile in the source. Needed by every cell but an erased one." },
         alternativeTile: { type: "number" }
       },
-      required: ["coords", "sourceId", "atlasCoords"],
+      required: ["coords", "sourceId"],
       additionalProperties: false
     }
   };
   COLOUR2 = {
-    type: "object",
-    description: "set_theme_color: r, g and b from 0 to 1, with a optional and opaque by default.",
+    type: ["object", "string"],
+    description: 'set_theme_color: r, g and b from 0 to 1, with a optional and opaque by default, or an html code such as "#ff8000" or "#ff800080".',
     properties: { r: { type: "number" }, g: { type: "number" }, b: { type: "number" }, a: { type: "number" } },
     required: ["r", "g", "b"],
     additionalProperties: false
@@ -12051,7 +12081,7 @@ var init_tool_definitions = __esm(() => {
         include: {
           type: "array",
           items: { type: "string", enum: [...PROJECT_INFO_SECTIONS] },
-          description: "Extra sections: registered autoloads, addons and whether each is enabled, export presets, the audio bus layout, a health report, or export validation."
+          description: "Extra sections: registered autoloads, the input actions project.godot holds with their events (an engine ui_ action only when the project rebinds it, as engineAction), addons and whether each is enabled, export presets, the audio bus layout, a health report, or export validation. health and validation compile every script of the project in headless engines and name each that fails with its first error, and each file a scene, resource or script refers to that does not exist."
         },
         preset: { type: "string", description: "For validation: the export preset to validate against." },
         detail: {
@@ -12065,7 +12095,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, 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.",
+      description: "Reads or writes project.godot: settings, autoloads, the main scene, input actions, plugins and audio buses. project_info include lists the autoloads, input actions and audio buses as the project holds them. A write with an editor open on the project is handed to the editor, which takes the settings the write changed or names from the file (named under editorAdopted), including a setting the file already held, since the editor can hold another value after the file was put back, or reloads the bus layout, so it answers the new values and does not save the old ones back over them. editorNote is an editor that could not take the write, or one on another release's addon that was not asked, which still holds the old values until editor_launch restart. An enabled plugin's code still loads on the editor's next start. 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: {
@@ -12087,7 +12117,7 @@ var init_tool_definitions = __esm(() => {
         value: {
           blank: true,
           ops: ["set"],
-          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.'
+          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. A setting the engine does not declare is written as given, a whole number as an int, and when one in its section is named like it, note names the nearest, as it may be a misspelt one.'
         },
         name: { type: "string", ops: ["add_autoload", "remove_autoload"], description: "Autoload name." },
         path: {
@@ -12222,7 +12252,7 @@ var init_tool_definitions = __esm(() => {
         direction: {
           type: "string",
           enum: ["forward", "reverse"],
-          description: "forward: what this resource loads, with cycles reported, a script's dependencies including every script whose class_name it uses, marked by_class with the name. summary.total_dependencies counts each file once however many places load it, and total_references counts the entries in the tree. reverse: every file that refers to it and how, a scene instancing it, a script extending, preloading or loading it, and for a script with a class_name every use of that name. Each reference carries a kind: ext_resource, extends, preload, load or path for a reference by path; setting, plugin, export_preset and import for one in project.godot, a plugin.cfg, export_presets.cfg or an import sidecar; class_name for a use of the declared name, the declaration itself being the script asked about. Two kinds are mentions rather than uses: doc is a name inside a ## documentation comment, which renaming would break in the generated docs, and comment is one in ordinary prose, which it would only make stale. summary.in_code is the count with both of those left out, which is the number to read when the question is whether anything still uses this. Default forward."
+          description: "forward: what this resource loads, with cycles reported, a script's dependencies including every script whose class_name it uses, marked by_class with the name. summary.total_dependencies counts each file once however many places load it, total_references counts the entries in the tree, and missing names every file referenced that does not exist, with the files referring to it. reverse: every file that refers to it and how, for a file that is gone as well, answered with exists: false, a scene instancing it, a script extending, preloading or loading it, and for a script with a class_name every use of that name. Each reference carries a kind: ext_resource, extends, preload, load or path for a reference by path; setting, plugin, export_preset and import for one in project.godot, a plugin.cfg, export_presets.cfg or an import sidecar; class_name for a use of the declared name, the declaration itself being the script asked about. Two kinds are mentions rather than uses: doc is a name inside a ## documentation comment, which renaming would break in the generated docs, and comment is one in ordinary prose, which it would only make stale. summary.in_code is the count with both of those left out, which is the number to read when the question is whether anything still uses this. Default forward."
         },
         depth: { type: "number", description: "forward: how many levels to follow. Default unlimited." },
         includeBuiltin: {
@@ -12287,7 +12317,7 @@ var init_tool_definitions = __esm(() => {
         },
         reimport: {
           effect: "destructive",
-          summary: "reimport what status says is outdated or failed, one resource with resourcePath, or what is current as well with force. Through the open editor when one serves the project, so it reloads what it holds, waiting for it to finish; otherwise through the engine's own import pass. The editor scans first, since its reimport passes over a file it has not taken in, such as one an installer has just written; what that scan imported is named under importedByTheScan and is not imported again unless force asks. Answered from a second status read: reimported lists what is current now, notReimported what is not, one entry per status and reason with the paths sharing them, and via says which of the two did the work. When nothing needs reimporting, nothing runs, and the answer has the two lists empty, a note saying so, and no via. A whole-project reimport also answers missingSource, the .import files whose source is not beside them, empty when there are none, whether or not anything needed reimporting; one resourcePath is not a walk of the project and leaves it out. stillImporting is an editor that had not finished within timeoutMs",
+          summary: "reimport what status says is outdated or failed, one resource with resourcePath, or what is current as well with force. Through the open editor when one serves the project, so it reloads what it holds, waiting for it to finish; otherwise through the engine's own import pass. The editor scans first, since its reimport passes over a file it has not taken in, such as one an installer has just written; what that scan imported is named under importedByTheScan and is not imported again unless force asks. Answered from a second status read: reimported lists what is current now, notReimported what is not, one entry per status and reason with the paths sharing them, and via says which of the two did the work. Either takes in every file that is behind, so a reimport of one resourcePath names under alsoImported the others it imported. When nothing needs reimporting, nothing runs, and the answer has the two lists empty, a note saying so, and no via. A whole-project reimport also answers missingSource, the .import files whose source is not beside them, empty when there are none, whether or not anything needed reimporting; one resourcePath is not a walk of the project and leaves it out. stillImporting is an editor that had not finished within timeoutMs",
           requires: []
         },
         uid: {
@@ -12360,6 +12390,11 @@ var init_tool_definitions = __esm(() => {
           items: { type: "string" },
           description: 'Suites or cases to leave out, as "suite_name" or "suite_name:test_name". A bare test name is read as a suite name and leaves out nothing; an entry that named a case which ran all the same comes back under ignoreNotApplied with the form that would have left it out.'
         },
+        tests: {
+          type: "array",
+          items: { type: "string" },
+          description: 'Run only these cases of the suites under path, each "test_name" or "suite_name:test_name", the suite by its file name without .gd or its res:// path. Only the suites holding them run, with their other cases left out. A name no suite there declares as a top-level func is refused before the engine starts, with the nearest names; a case asked for that gdUnit4 did not report comes back under testsNotRun, and the run is not called passed.'
+        },
         engineArgs: {
           type: "array",
           items: { type: "string" },
@@ -12384,7 +12419,7 @@ var init_tool_definitions = __esm(() => {
     {
       name: "scene_create",
       title: "Create or save a scene",
-      description: `Creates a scene file where none is, saves one, or saves a copy under a new path. A save of a scene open in the editor saves the editor's copy, unsaved changes included. ${WITHOUT_AN_EDITOR}`,
+      description: `Creates a scene file where none is, saves one, or saves a copy under a new path. create makes a folder the path names that is not there, and names it under madeFolder. A save of a scene open in the editor saves the editor's copy, unsaved changes included. ${WITHOUT_AN_EDITOR}`,
       parameters: {
         projectPath: PROJECT_PATH,
         scenePath: SCENE_PATH,
@@ -12571,31 +12606,40 @@ var init_tool_definitions = __esm(() => {
     {
       name: "scene_animation",
       title: "Animations",
-      description: "Animations in an AnimationPlayer and states in an AnimationTree state machine. read answers with every track of an animation in the shape add_track takes, so a track read off one animation can be added to another. read and read_states need no editor: one serving the project answers and says whether it holds unsaved changes to the scene, and with none a headless engine reads the file without running the scene's scripts. The ops that write go 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. That engine runs every script of the file, where the editor runs only tool scripts, so what a script changes as the file loads 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. An editor of the project that is running and has not reached this server is waited for rather than written around.",
+      description: "Animations in an AnimationPlayer and states in an AnimationTree state machine. read answers with every track of an animation in the shape add_track takes, so a track read off one animation can be added to another. add_track on a path the animation already has a track of that type for adds the keys to that track, as the editor keys a property it already animates, answering existingTrack true and keysAdded beside keys, the track's count; a key at a time that track already has a key at is refused. A key past the animation's end, where it never plays, is written and named under pastLength. remove clears the player's autoplay when it named the animation and names under statesPlayingNothing the states that played it. read and read_states need no editor: one serving the project answers and says whether it holds unsaved changes to the scene, and with none a headless engine reads the file without running the scene's scripts. The ops that write go 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. That engine runs every script of the file, where the editor runs only tool scripts, so what a script changes as the file loads 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. An editor of the project that is running and has not reached this server is waited for rather than written around.",
       parameters: {
         projectPath: PROJECT_PATH,
         scenePath: SCENE_PATH,
         playerNodePath: {
           type: "string",
-          ops: ["read", "create", "add_track"],
+          ops: ["read", "create", "add_track", "set", "rename", "remove"],
           description: "The AnimationPlayer node."
         },
         animationName: {
           type: "string",
-          ops: ["read", "create", "add_track", "add_state"],
+          ops: ["read", "create", "add_track", "set", "rename", "remove", "add_state"],
           description: "The animation in the player. read: the one to answer with whole, its tracks a list; without it, read lists them, each with the number of its tracks under tracks. add_state: the one that state plays."
         },
-        length: { type: "number", ops: ["create"], description: "create: seconds. Default 1." },
+        newName: {
+          type: "string",
+          ops: ["rename"],
+          description: "rename: the animation's new name in the library it is in. The player's autoplay and every state of the scene's AnimationTrees that plays it are renamed with it, named under autoplay and statesFollowed."
+        },
+        length: {
+          type: "number",
+          ops: ["create", "set"],
+          description: "create and set: seconds, more than 0. create: default 1. set: a key past the new end is kept, as the editor keeps it, and named under pastLength, since it never plays."
+        },
         loopMode: {
           type: "string",
-          ops: ["create"],
+          ops: ["create", "set"],
           enum: ["none", "linear", "pingpong"],
           description: "create: default none."
         },
         step: {
           type: "number",
-          ops: ["create"],
-          description: "create: keyframe snap in seconds. Default 0.1."
+          ops: ["create", "set"],
+          description: "create and set: keyframe snap in seconds, 0 or more. create: default 0.1."
         },
         track: { ...ANIMATION_TRACK, ops: ["add_track"] },
         animTreePath: {
@@ -12657,6 +12701,21 @@ var init_tool_definitions = __esm(() => {
           summary: "a property or method track with keyframes",
           requires: ["playerNodePath", "animationName", "track"]
         },
+        set: {
+          effect: "destructive",
+          summary: "an animation's length, loop mode or step",
+          requires: ["playerNodePath", "animationName"]
+        },
+        rename: {
+          effect: "destructive",
+          summary: "an animation, with what plays it",
+          requires: ["playerNodePath", "animationName", "newName"]
+        },
+        remove: {
+          effect: "destructive",
+          summary: "an animation from its player",
+          requires: ["playerNodePath", "animationName"]
+        },
         add_state: {
           effect: "additive",
           summary: "a state playing an animation, in an AnimationTree",
@@ -12672,7 +12731,7 @@ var init_tool_definitions = __esm(() => {
     {
       name: "script_edit",
       title: "Edit scripts",
-      description: "Creates a GDScript file, or adds functions, variables and signals to one. Every declaration written carries a type. Both load what they wrote under the project's own warning settings and answer with parses; the engine's reasons for a refusal come back under engine_messages. create answers with the extends and class_name the engine read, and a script declaring a class_name is put in the project's class list, with registered saying whether it is there. modify makes every addition or none, and answers with the line each one is on in the file written; with an editor serving the project it reloads the script there too, so the editor's answers read what was written, and editorReloaded says so (editorNote when it could not, or when a script tab holds unsaved edits that saving would write over the file). rename renames a class or a member wherever the engine uses it and writes every file or none. A new name already taken is refused with nothing written, a member's included when a class inheriting it already uses the name in code, as a local or a parameter. changed lists each file with its changed lines as they now read, and leftAlone lists every other whole-word occurrence of the old name with what the tokenizer makes of it (code, string, comment, doc, nodePath, scene, text, or ignored for a file under a .gdignore directory, which is never changed) and, where it is not plain, why: a string that is the old name whole, such as find_children's type or a call's method name, which nothing renames or compiles and which is listed first; a node named like the class; a call on a value whose type the analyser could not tell. A member rename answers under languageServer how many requests it made and how long they took. A comment, documentation line, string or text file line with nothing more to say is given under leftAloneInProse by file, kind and line instead, and code that is certainly another symbol of the same name, a bare name in a file where nothing inherits the member or one the language server resolved to another declaration, under leftAloneOtherSymbols as each why with the files and lines it covers. summary.leftAlone counts each of the three lists beside the total. When those two grouped lists run past 300 lines, they are written with each line's text to a file under the project's .godot directory instead, of which the newest ten are kept, and leftAloneDetail names the file and counts what is in it. Read both before calling the rename done; nothing in them was changed. Afterwards an open editor scans the changed files and reloads every changed script, which is also the compile check, and its answer comes back under editor; with no editor the class cache is rebuilt and the changed scripts are compiled in a fresh engine, under classCache and compiled. written is true once the files are written, and ok is false when what came after the write failed: the files are left changed, and note says so.",
+      description: "Creates a GDScript file, or adds functions, variables and signals to one. Every declaration written carries a type. Both load what they wrote under the project's own warning settings and answer with parses; the engine's reasons for a refusal come back under engine_messages. create answers with the extends and class_name the engine read, and a script declaring a class_name is put in the project's class list, with registered saying whether it is there; a class_name another script or an engine class holds, or an extends naming no class, is refused with nothing written. modify makes every addition or none, refuses with nothing changed additions that would stop a script that parses from parsing, giving the engine's reasons, and answers with the line each one is on in the file written; with an editor serving the project it reloads the script there too, so the editor's answers read what was written, and editorReloaded says so (editorNote when it could not, or when a script tab holds unsaved edits that saving would write over the file). rename renames a class or a member wherever the engine uses it and writes every file or none. A new name already taken is refused with nothing written, a member's included when a class inheriting it already uses the name in code, as a local or a parameter. changed lists each file with its changed lines as they now read, and leftAlone lists every other whole-word occurrence of the old name with what the tokenizer makes of it (code, string, comment, doc, nodePath, scene, text, or ignored for a file under a .gdignore directory, which is never changed) and, where it is not plain, why: a string that is the old name whole, such as find_children's type or a call's method name, which nothing renames or compiles and which is listed first; a node named like the class; a call on a value whose type the analyser could not tell. A member rename answers under languageServer how many requests it made and how long they took. A comment, documentation line, string or text file line with nothing more to say is given under leftAloneInProse by file, kind and line instead, and code that is certainly another symbol of the same name, a bare name in a file where nothing inherits the member or one the language server resolved to another declaration, under leftAloneOtherSymbols as each why with the files and lines it covers. summary.leftAlone counts each of the three lists beside the total. When those two grouped lists run past 300 lines, they are written with each line's text to a file under the project's .godot directory instead, of which the newest ten are kept, and leftAloneDetail names the file and counts what is in it. Read both before calling the rename done; nothing in them was changed. Afterwards an open editor scans the changed files and reloads every changed script, which is also the compile check, and its answer comes back under editor; with no editor the class cache is rebuilt and the changed scripts are compiled in a fresh engine, under classCache and compiled. written is true once the files are written, and ok is false when what came after the write failed: the files are left changed, and note says so.",
       parameters: {
         projectPath: PROJECT_PATH,
         scriptPath: SCRIPT_PATH,
@@ -12755,7 +12814,7 @@ var init_tool_definitions = __esm(() => {
       operations: {
         structure: {
           effect: "read",
-          summary: "functions, variables, signals, class_name and extends, read from the file, and dependencies: the paths it loads or preloads as written, then the scripts declaring each project class_name its code uses, which classes_used names with the class; autoloads_used names each autoload the code uses by its global name, with the autoload's script, which the project loads rather than this script, so it is not under dependencies",
+          summary: "functions, variables, signals, constants, enums, inner_classes, class_name, extends and line_count, read from the file, and dependencies: the paths it loads or preloads as written, then the scripts declaring each project class_name its code uses, which classes_used names with the class; autoloads_used names each autoload the code uses by its global name, with the autoload's script, which the project loads rather than this script, so it is not under dependencies",
           requires: []
         },
         symbols: {
@@ -12776,7 +12835,7 @@ var init_tool_definitions = __esm(() => {
       name: "script_diagnostics",
       title: "Script diagnostics",
       effect: "read",
-      description: "Errors and warnings for a script, or for several, from the editor's language server, and whether each is clean. With no editor of this project open, so no language server of it to ask, a short headless engine compiles the scripts instead and the answer says checkedBy: engine: every error that stops a script compiling, with its line and no column, dependenciesWithErrors naming the other scripts that failed while it loaded, and warnings null, since the engine reports warnings only to an editor. Each diagnostic carries its severity (error or warning), its message, and where it is as the editor shows it: line and column counted from 1, and endLine and endColumn just past its end. Diagnostics are checked against the project's own files, and the two that the files disprove are named rather than passed on: a member the class cache's file declares, or a project class it extends does, a method, property, constant, static function or enum member, comes back under contradictedByTheFile with the script declaring it, and so does one a diagnostic names alone as an external class member, read against the class it is looked up on in the line it is on; and a class this project declares that the diagnostic could not resolve comes back under typesTheEditorHasNotLoaded, with inTheClassCache saying whether a launched game would resolve it. staleAnalysis then says what to do, and for both states it is editor_rescan first: it asks the editor already running, starts nothing, and has cleared each in every reproduction measured. Two exceptions are named when they apply. For an enum member, constant or static function of a global class the reload comes first: in the one project that has reproduced a stale enum member, editor_rescan with reloadScript on the declaring script cleared it and a plain rescan did not. And an editor whose last scan wrote the class cache shorter than the file holds a list behind the files and writes it on every scan, so on that editor the rescan loads nothing and staleAnalysis says editor_launch restart instead. What follows differs: for a stale analysed type, editor_rescan with reloadScript recompiles the held copy and editor_launch restart is the last resort that costs a window; for a class missing from the cache, project_import refresh_classes rewrites the cache from disk at the cost of a short headless engine, which matters beside a running bench.",
+      description: "Errors and warnings for a script, or for several, from the editor's language server, and whether each is clean. With no editor of this project open, so no language server of it to ask, a short headless engine compiles the scripts instead and the answer says checkedBy: engine: every error that stops a script compiling, with its line and no column, dependenciesWithErrors naming the other scripts that failed while it loaded, typesMissingFromTheClassCache naming a class the project declares that the engine could not resolve because the class cache lacks it, with staleAnalysis saying what rewrites the cache, and warnings null, since the engine reports warnings only to an editor. Each diagnostic carries its severity (error or warning), its message, and where it is as the editor shows it: line and column counted from 1, and endLine and endColumn just past its end. Diagnostics are checked against the project's own files, and the two that the files disprove are named rather than passed on: a member the class cache's file declares, or a project class it extends does, a method, property, constant, static function or enum member, comes back under contradictedByTheFile with the script declaring it, and so does one a diagnostic names alone as an external class member, read against the class it is looked up on in the line it is on; and a class this project declares that the diagnostic could not resolve comes back under typesTheEditorHasNotLoaded, with inTheClassCache saying whether a launched game would resolve it. staleAnalysis then says what to do, and for both states it is editor_rescan first: it asks the editor already running, starts nothing, and has cleared each in every reproduction measured. Two exceptions are named when they apply. For an enum member, constant or static function of a global class the reload comes first: in the one project that has reproduced a stale enum member, editor_rescan with reloadScript on the declaring script cleared it and a plain rescan did not. And an editor whose last scan wrote the class cache shorter than the file holds a list behind the files and writes it on every scan, so on that editor the rescan loads nothing and staleAnalysis says editor_launch restart instead. What follows differs: for a stale analysed type, editor_rescan with reloadScript recompiles the held copy and editor_launch restart is the last resort that costs a window; for a class missing from the cache, project_import refresh_classes rewrites the cache from disk at the cost of a short headless engine, which matters beside a running bench.",
       parameters: {
         projectPath: PROJECT_PATH,
         scriptPath: {
@@ -12790,7 +12849,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". 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.',
+      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, with resourceType the engine class and scriptClass the class_name of its script when it declares one, 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. A property holding a resource takes its res:// path; a file never imported is refused with the reimport that imports it. 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: {
@@ -12833,7 +12892,7 @@ var init_tool_definitions = __esm(() => {
         preview: {
           type: "boolean",
           ops: ["move"],
-          description: "move: answer with what would move and change, and write nothing. Default false."
+          description: "move: answer with what would move and change, and write nothing. A move that would be refused is refused here too, with the same reason. Default false."
         },
         controlType: {
           type: "string",
@@ -13716,7 +13775,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 where it was turned off again is said so under breakpointsAtRisk, here and in editor_status.",
+      description: "Sets or removes a breakpoint. A set on a script that is not there, or past its last line, is refused, as nothing would ever stop there; a remove takes any. 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,
@@ -39275,7 +39334,7 @@ async function resolveLSPPaths(projectPathValue, scriptPathValue) {
   try {
     scriptPath = await realpath(contained.absolutePath);
   } catch {
-    throw new ArgumentRefusal(`Script file does not exist: ${contained.absolutePath}`);
+    throw new ArgumentRefusal(`Script file does not exist: res://${contained.relativePath}`);
   }
   if (!isWithinRoot(projectPath, scriptPath)) {
     throw new ArgumentRefusal("scriptPath resolves outside the project root boundary.");
@@ -39361,7 +39420,7 @@ var init_lsp_client = __esm(() => {
   AnotherProjectsServer = class AnotherProjectsServer extends Refusal {
     serves;
     constructor(port, serves, asked) {
-      super(`The language server on port ${port} belongs to the editor of ${serves}, not ${asked}.`);
+      super(`The language server on port ${port} belongs to the editor of ${serves}; no editor of ${asked} answers there.`);
       this.serves = serves;
     }
   };
@@ -44089,6 +44148,46 @@ var init_lifecycle_log = __esm(() => {
   init_server_version();
 });
 
+// src/nearest.ts
+function similarity(one, other) {
+  if (one === other) {
+    return 1;
+  }
+  if (one.length < 2 || other.length < 2) {
+    return 0;
+  }
+  const pairs = (text) => Array.from({ length: text.length - 1 }, (_, at) => text.slice(at, at + 2));
+  const ones = pairs(one);
+  const others = pairs(other);
+  const shared = ones.filter((pair) => others.includes(pair)).length;
+  return 2 * shared / (ones.length + others.length);
+}
+function withNearestFiles(said, wanted, files) {
+  const extension = /\.([^./]+)$/.exec(wanted)?.[1];
+  if (extension === undefined) {
+    return said;
+  }
+  if (files.length === 0) {
+    return `${said}. The project holds no .${extension} file.`;
+  }
+  const stem = (path) => (path.split("/").pop() ?? path).replace(/\.[^.]*$/, "");
+  const close = nearest(stem(wanted), files.map((file) => stem(file)));
+  const offered = files.filter((file) => close.includes(stem(file)));
+  if (offered.length > 0) {
+    return `${said}. The nearest .${extension} ${offered.length === 1 ? "file is" : "files are"} ${offered.join(", ")}.`;
+  }
+  if (files.length <= LISTED_FILES) {
+    return `${said}. The project's .${extension} files are ${files.join(", ")}.`;
+  }
+  return `${said}. None of the project's ${files.length} .${extension} files is named like it.`;
+}
+function nearest(word, names) {
+  const wanted = word.toLowerCase();
+  const score = (name) => similarity(name.toLowerCase(), wanted);
+  return names.filter((name) => score(name) >= 0.5).sort((one, other) => score(other) - score(one)).slice(0, 3);
+}
+var LISTED_FILES = 12;
+
 // src/outside.ts
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 function changesFrom(env, base) {
@@ -45022,6 +45121,70 @@ var init_server_instructions = __esm(() => {
   init_tool_definitions();
 });
 
+// src/test-selection.ts
+import { existsSync as existsSync26, readFileSync as readFileSync28 } from "node:fs";
+import { basename as basename10, join as join33 } from "node:path";
+function casesIn(projectPath, suite) {
+  const text = readFileSync28(join33(projectPath, suite.slice("res://".length)), "utf8");
+  return [...text.matchAll(/^func\s+(test_\w*)\s*\(/gm)].map((match) => match[1] ?? "");
+}
+function suitesUnder(projectPath, asked) {
+  const scripts = projectFiles(projectPath, [".gd"]).map((path) => `res://${path}`);
+  return [
+    ...new Set(asked.flatMap((path) => path.endsWith(".gd") ? existsSync26(join33(projectPath, path.slice("res://".length))) ? [path] : [] : scripts.filter((script) => script.startsWith(`${path}/`))))
+  ];
+}
+function selectTests(projectPath, asked, given) {
+  if (given === undefined || given === null) {
+    return { ok: true, value: null };
+  }
+  const entries = Array.isArray(given) ? given : [given];
+  if (entries.length === 0) {
+    return { ok: false, reason: "tests is an empty list: name a case, or leave tests out to run every one." };
+  }
+  const declared = suitesUnder(projectPath, asked).flatMap((suite) => casesIn(projectPath, suite).map((test) => ({ suite, test })));
+  const nameOf = (suite) => basename10(suite, ".gd");
+  const selected = [];
+  for (const [index, entry] of entries.entries()) {
+    if (typeof entry !== "string" || entry.trim() === "") {
+      return {
+        ok: false,
+        reason: `tests[${index}] is not a case name: give "test_name" or "suite:test_name".`
+      };
+    }
+    const spelled = entry.trim();
+    const at = spelled.lastIndexOf(":");
+    const suiteNamed = at === -1 || spelled.slice(at).startsWith("://") ? null : spelled.slice(0, at);
+    const test = suiteNamed === null ? spelled : spelled.slice(at + 1);
+    const suitePath = suiteNamed?.startsWith("res://") === true ? suiteNamed : null;
+    const matches = declared.filter((one) => one.test === test && (suiteNamed === null || one.suite === suitePath || nameOf(one.suite) === suiteNamed));
+    if (matches.length === 0) {
+      const said = `No suite under ${asked.join(", ")} has a case ${spelled}`;
+      if (declared.length === 0) {
+        return { ok: false, reason: `${said}: none of them declares a func test_ at the top level.` };
+      }
+      const written = declared.map((one) => `${nameOf(one.suite)}:${one.test}`);
+      const close = nearest(suiteNamed === null ? test : `${nameOf(suiteNamed)}:${test}`, [
+        ...new Set(suiteNamed === null ? declared.map((one) => one.test) : written)
+      ]);
+      return {
+        ok: false,
+        reason: close.length > 0 ? `${said}. The nearest ${close.length === 1 ? "is" : "are"} ${close.join(", ")}.` : `${said}. The cases there are ${written.slice(0, 12).join(", ")}${written.length > 12 ? `, and ${written.length - 12} more` : ""}.`
+      };
+    }
+    for (const one of matches) {
+      selected.push({ entry: spelled, ...one });
+    }
+  }
+  const suites = [...new Set(selected.map((one) => one.suite))];
+  const chosen = new Set(selected.map((one) => `${one.suite}:${one.test}`));
+  const ignore = declared.filter((one) => suites.includes(one.suite) && !chosen.has(`${one.suite}:${one.test}`)).map((one) => `${one.suite}:${one.test}`);
+  return { ok: true, value: { suites, ignore, selected } };
+}
+var init_test_selection = __esm(() => {
+  init_project_scan();
+});
+
 // src/server.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 import {
@@ -45029,18 +45192,18 @@ import {
   closeSync as closeSync3,
   constants,
   copyFileSync,
-  existsSync as existsSync26,
+  existsSync as existsSync27,
   fstatSync,
   mkdirSync as mkdirSync17,
   openSync as openSync4,
   readdirSync as readdirSync15,
-  readFileSync as readFileSync28,
+  readFileSync as readFileSync29,
   readSync as readSync2,
   rmdirSync as rmdirSync2,
   statSync as statSync15,
   writeFileSync as writeFileSync18
 } from "node:fs";
-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 { basename as basename11, dirname as dirname23, extname as extname4, isAbsolute as isAbsolute5, join as join34, 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() {
@@ -45077,15 +45240,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 (!existsSync26(directory)) {
+  if (!existsSync27(directory)) {
     return `${named}'s directory ${dirname23(path)} does not exist; ${what} creates no directories.`;
   }
-  const where = join33(directory, basename10(path));
+  const where = join34(directory, basename11(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) => existsSync26(file));
+  const taken = rule.writes(where).find((file) => existsSync27(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.`;
   }
@@ -45469,6 +45632,16 @@ function endedToStartThis(ended) {
   }
   return ` ${which} was ended to start this one; its output is no longer what editor_output answers about.`;
 }
+function lineBeyondScript(absolutePath, relativePath, line) {
+  const text = readFileSync29(absolutePath, "utf8");
+  const lines = text === "" ? 0 : text.split(`
+`).length - (text.endsWith(`
+`) ? 1 : 0);
+  if (line <= lines) {
+    return null;
+  }
+  return `res://${relativePath} has ${lines} line${lines === 1 ? "" : "s"}, so there is no line ${line} to stop on.`;
+}
 function runtimeVerdict(endpoint, after) {
   if (endpoint !== null) {
     return { listening: true, pid: endpoint.pid, port: endpoint.port };
@@ -45638,7 +45811,7 @@ function notRunNote(notRun, failFast) {
 function exportPresetRefusal(projectPath, preset) {
   let text;
   try {
-    text = readFileSync28(join33(projectPath, "export_presets.cfg"), "utf8");
+    text = readFileSync29(join34(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.`;
   }
@@ -45704,7 +45877,7 @@ function filesIn(folder) {
   try {
     for (const entry of readdirSync15(folder, { withFileTypes: true })) {
       if (entry.isFile()) {
-        found.set(entry.name, statSync15(join33(folder, entry.name)).mtimeMs);
+        found.set(entry.name, statSync15(join34(folder, entry.name)).mtimeMs);
       }
     }
   } catch {}
@@ -45736,7 +45909,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 (!existsSync26(join33(projectPath, "project.godot"))) {
+  if (!existsSync27(join34(projectPath, "project.godot"))) {
     return null;
   }
   const report = inspectProject(projectPath);
@@ -46001,7 +46174,7 @@ function profileFrameFunctions(projectPath) {
   let projectGodot = null;
   if (projectPath !== null) {
     try {
-      projectGodot = readFileSync28(join33(projectPath, "project.godot"), "utf8");
+      projectGodot = readFileSync29(join34(projectPath, "project.godot"), "utf8");
     } catch {}
   }
   return frameFunctionsFor(queuedMessagesOf(projectGodot));
@@ -46025,7 +46198,7 @@ function projectSourceOf(projectPath) {
       let source = null;
       if (inside.ok) {
         try {
-          source = readFileSync28(inside.absolutePath, "utf8");
+          source = readFileSync29(inside.absolutePath, "utf8");
         } catch {}
       }
       read.set(script, source);
@@ -46180,7 +46353,7 @@ function foldedEntriesAnswer(log, floor = "warning") {
 }
 function gdUnitFailsOnScriptErrors(projectPath) {
   try {
-    return settingKeys(readFileSync28(join33(projectPath, "project.godot"), "utf8")).get("gdunit4/report/godot/script_error") !== false;
+    return settingKeys(readFileSync29(join34(projectPath, "project.godot"), "utf8")).get("gdunit4/report/godot/script_error") !== false;
   } catch {
     return true;
   }
@@ -46195,7 +46368,7 @@ function uncaughtNote(uncaught) {
 }
 function elsewhereIn(projectPath, asked) {
   const wanted = asked.replace(/^res:\/\//, "").replace(/\/+$/, "");
-  if (wanted === "" || existsSync26(join33(projectPath, wanted))) {
+  if (wanted === "" || existsSync27(join34(projectPath, wanted))) {
     return "";
   }
   const root = (wanted.split("/")[0] ?? "").toLowerCase();
@@ -46298,7 +46471,7 @@ function isDirectory(path) {
   }
 }
 function scriptsUnder(directory, prefix) {
-  if (existsSync26(join33(directory, ".gdignore"))) {
+  if (existsSync27(join34(directory, ".gdignore"))) {
     return [];
   }
   const found = [];
@@ -46308,7 +46481,7 @@ function scriptsUnder(directory, prefix) {
     }
     const path = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
     if (entry.isDirectory()) {
-      found.push(...scriptsUnder(join33(directory, entry.name), path));
+      found.push(...scriptsUnder(join34(directory, entry.name), path));
     } else if (entry.isFile() && entry.name.endsWith(".gd")) {
       found.push(path);
     }
@@ -46316,11 +46489,11 @@ function scriptsUnder(directory, prefix) {
   return found;
 }
 function mainSceneOf(projectFile) {
-  const scene = parseProjectGodot(readFileSync28(projectFile, "utf8"))["application"]?.["run/main_scene"];
+  const scene = parseProjectGodot(readFileSync29(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "" ? scene : null;
 }
 function editorPlaysHeadless(projectFile) {
-  const runArgs = parseProjectGodot(readFileSync28(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
+  const runArgs = parseProjectGodot(readFileSync29(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
   return typeof runArgs === "string" && /(?:^|\s)--headless(?:\s|$)/.test(runArgs);
 }
 function ownArguments(params) {
@@ -46338,7 +46511,7 @@ function needsItsOwnProcess(asked) {
 class GodotServer {
   stdio = null;
   locator = new GodotLocator;
-  operationsScript = join33(__dirname2, "godot", "operations", "godot_operations.gd");
+  operationsScript = join34(__dirname2, "godot", "operations", "godot_operations.gd");
   godotBridge;
   tools = buildToolDefinitions();
   activeProcess = null;
@@ -46600,14 +46773,14 @@ class GodotServer {
   }
   noteTheStart() {
     const cwd = process.cwd();
-    const mcpJson = join33(cwd, ".mcp.json");
+    const mcpJson = join34(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: existsSync26(mcpJson) ? mcpJson : null
+      mcpJson: existsSync27(mcpJson) ? mcpJson : null
     });
     if (predecessor !== null) {
       writeLifecycle("replaced", { project: this.ownProject, predecessor });
@@ -46748,7 +46921,7 @@ class GodotServer {
         return checked.response;
       }
       const named = args["projectPath"];
-      if (typeof named === "string" && existsSync26(join33(named, "project.godot"))) {
+      if (typeof named === "string" && existsSync27(join34(named, "project.godot"))) {
         this.lastProjectPath = named;
       }
       this.updates.refresh();
@@ -46784,7 +46957,7 @@ class GodotServer {
     let notSaved;
     try {
       savedAt = answer.content.map((item, index) => {
-        const file = join33(directory, item.type === "text" ? `${stem}-${index}.txt` : `${stem}-${index}.${item.mimeType.split("/")[1] ?? "bin"}`);
+        const file = join34(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;
       });
@@ -47011,7 +47184,10 @@ class GodotServer {
     });
     if (missing.length > 0) {
       const where = op !== null ? `${spec.name} ${op}` : spec.name;
-      return { ok: false, response: this.createErrorResponse(`${where} needs ${missing.join(", ")}.`) };
+      const blank = missing.filter((field) => typeof args[field] === "string");
+      const named = missing.map((field) => blank.includes(field) ? `${field}, which was given empty` : field);
+      const joined = named.join(blank.length > 0 ? "; " : ", ");
+      return { ok: false, response: this.createErrorResponse(`${where} needs ${joined}.`) };
     }
     return { ok: true, op };
   }
@@ -47139,6 +47315,12 @@ class GodotServer {
             return await editorOrEngine("create_animation", "writes");
           case "add_track":
             return await editorOrEngine("add_animation_track", "writes");
+          case "set":
+            return await editorOrEngine("set_animation", "writes");
+          case "rename":
+            return await editorOrEngine("rename_animation", "writes");
+          case "remove":
+            return await editorOrEngine("remove_animation", "writes");
           case "add_state":
             return await editorOrEngine("add_animation_state", "writes");
           default:
@@ -47319,6 +47501,15 @@ class GodotServer {
         if (line === undefined) {
           return this.createErrorResponse("line is required: the one-based line to stop on.");
         }
+        if (op === "set") {
+          if (!existsSync27(located.absolutePath)) {
+            return this.missingScript(project.value.path, located.relativePath);
+          }
+          const beyond = lineBeyondScript(located.absolutePath, located.relativePath, line);
+          if (beyond !== null) {
+            return this.createErrorResponse(beyond);
+          }
+        }
         const editor = this.godotBridge.isConnected();
         let answer;
         if (editor) {
@@ -47401,8 +47592,8 @@ class GodotServer {
     if (path === undefined) {
       return { ok: false, response: this.createErrorResponse("projectPath is required.") };
     }
-    const file = join33(path, "project.godot");
-    if (!existsSync26(file)) {
+    const file = join34(path, "project.godot");
+    if (!existsSync27(file)) {
       return {
         ok: false,
         response: this.createErrorResponse(`Not a Godot project: ${path}`, [
@@ -47927,6 +48118,13 @@ class GodotServer {
     const viaEditor = this.editorHasOpen(projectPath);
     const extra = {};
     const statusAsk = resourcePath === undefined ? { includeUpToDate: true } : { resourcePath };
+    let behindElsewhere = [];
+    if (resourcePath !== undefined) {
+      const whole = await this.operation("get_import_status", {}, projectPath);
+      if (whole.ok) {
+        behindElsewhere = importStatuses(whole.payload).filter((one) => one.status !== "up_to_date" && one.status !== "missing_source" && one.status !== "not_imported" && !targets.includes(one.path)).map((one) => one.path);
+      }
+    }
     if (viaEditor) {
       const scan = await this.handleRescanFilesystem({ projectPath, timeoutMs });
       if (scan.isError === true) {
@@ -48008,6 +48206,16 @@ class GodotServer {
       groups.set(key, group);
     }
     const notReimported = [...groups.values()];
+    if (behindElsewhere.length > 0) {
+      const whole = await this.operation("get_import_status", { includeUpToDate: true }, projectPath);
+      if (whole.ok) {
+        const current = new Set(importStatuses(whole.payload).filter((one) => one.status === "up_to_date").map((one) => one.path));
+        const alsoImported = behindElsewhere.filter((path) => current.has(path));
+        if (alsoImported.length > 0) {
+          extra["alsoImported"] = alsoImported;
+        }
+      }
+    }
     return {
       ok: true,
       payload: {
@@ -48102,27 +48310,51 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const application = parseProjectGodot(readFileSync28(project.value.file, "utf8"))["application"] ?? {};
+    const application = parseProjectGodot(readFileSync29(project.value.file, "utf8"))["application"] ?? {};
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
-      name: typeof name === "string" && name !== "" ? name : basename10(project.value.path),
+      name: typeof name === "string" && name !== "" ? name : basename11(project.value.path),
       path: project.value.path,
       mainScene: typeof mainScene === "string" && mainScene !== "" ? mainScene : null,
       godotVersion: await this.godotVersion(engine.value),
       structure: projectStructure(project.value.path)
     };
     const detailed = args["detail"] === "full";
+    const compiledScripts = include.includes("health") || include.includes("validation") ? await this.compiledForProjectInfo(project.value.path) : undefined;
     for (const section of include) {
       const spec = PROJECT_INFO_SECTIONS2[section];
       if (spec === undefined) {
         continue;
       }
-      const outcome = await this.operation(spec.operation, spec.params(args, detailed), project.value.path);
+      const params = {
+        ...spec.params(args, detailed),
+        ...compiledScripts !== undefined && (section === "health" || section === "validation") ? { compiled: compiledScripts } : {}
+      };
+      const outcome = await this.operation(spec.operation, params, project.value.path);
       info[section] = outcome.ok ? { ...outcome.payload, ...engineExtras(outcome) } : { error: outcome.message, ...engineExtras(outcome) };
     }
     return this.jsonTextResponse(info);
   }
+  async compiledForProjectInfo(projectPath) {
+    const scripts = projectFiles(projectPath, [".gd"]).map((script) => `res://${script}`);
+    if (scripts.length === 0) {
+      return { checked: 0, failures: [] };
+    }
+    const checked = await this.compileScripts(projectPath, scripts);
+    if (!checked.ok) {
+      return { not_checked: `no headless engine could compile the scripts: ${checked.message}` };
+    }
+    const failures = checked.payload.scripts.map(asParams);
+    const uncached = uncachedFor(projectPath, failures.map((failure) => (readArray(failure, "errors") ?? []).map((entry) => String(asParams(entry)["message"]))));
+    return {
+      checked: checked.payload.checked.length,
+      failures: failures.map((failure, at) => {
+        const types = uncached[at] ?? [];
+        return types.length === 0 ? failure : { ...failure, note: uncachedForTheEngineNote(projectPath, types) };
+      })
+    };
+  }
   fileTypes(args) {
     const named = readStringArray(args, "fileTypes");
     return named === undefined ? {} : { fileTypes: named };
@@ -48200,7 +48432,7 @@ class GodotServer {
     const exportArgs = [
       "--headless",
       "--log-file",
-      join33(exportLogs, "engine.log"),
+      join34(exportLogs, "engine.log"),
       "--path",
       project.value.path,
       debug ? "--export-debug" : "--export-release",
@@ -48208,7 +48440,7 @@ class GodotServer {
       output.absolutePath
     ];
     this.logDebug(`Exporting: ${engine.value} ${exportArgs.join(" ")}`);
-    const writtenAt = () => existsSync26(output.absolutePath) ? statSync15(output.absolutePath).mtimeMs : null;
+    const writtenAt = () => existsSync27(output.absolutePath) ? statSync15(output.absolutePath).mtimeMs : null;
     const caches = editorCacheDirectory(engine.value);
     const exportOnce = async () => {
       const before = writtenAt();
@@ -48237,7 +48469,7 @@ class GodotServer {
     if (ending.exitSignal === null && ending.exitCode === null) {
       return this.createErrorResponse(`Export could not be run: ${ending.failure ?? "the engine gave no exit status"}`);
     }
-    const beside = writtenBeside(listedBefore, filesIn(folder), basename10(output.absolutePath), dirname23(output.relativePath).replaceAll("\\", "/"));
+    const beside = writtenBeside(listedBefore, filesIn(folder), basename11(output.absolutePath), dirname23(output.relativePath).replaceAll("\\", "/"));
     return exportAnswer(ending, { preset, outputPath: output.relativePath, debug }, before, writtenAt(), beside, docCacheNote);
   }
   reportTestProgress(log) {
@@ -48291,10 +48523,10 @@ class GodotServer {
     if (movie !== null) {
       return this.createErrorResponse(movie);
     }
-    const missing = paths.value.filter((path) => !existsSync26(join33(project.value.path, path.slice("res://".length))));
+    const missing = paths.value.filter((path) => !existsSync27(join34(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 = !existsSync26(join33(project.value.path, runner));
+    const noRunner = !existsSync27(join34(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}` : "";
@@ -48322,6 +48554,10 @@ class GodotServer {
         "Install gdUnit4 under addons/gdUnit4, from https://github.com/godot-gdunit-labs/gdUnit4"
       ]);
     }
+    const selection = selectTests(project.value.path, asked, args["tests"]);
+    if (!selection.ok) {
+      return this.createErrorResponse(selection.reason);
+    }
     const engine = await this.engine();
     if (!engine.ok) {
       return engine.response;
@@ -48352,8 +48588,8 @@ class GodotServer {
       `res://${runner}`,
       "--ignoreHeadlessMode",
       ...readBoolean(args, "failFast") === true ? [] : ["-c"],
-      ...asked.flatMap((path) => ["-a", path]),
-      ...ignored.flatMap((entry) => ["-i", entry]),
+      ...(selection.value?.suites ?? asked).flatMap((path) => ["-a", path]),
+      ...[...ignored, ...selection.value?.ignore ?? []].flatMap((entry) => ["-i", entry]),
       "-rd",
       reports,
       "-rc",
@@ -48410,14 +48646,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 = join33(project.value.path, ".godot", ...ours.split("/"));
+    const reportsDir = join34(project.value.path, ".godot", ...ours.split("/"));
     let report = null;
     let reportProblem = null;
     try {
-      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 written = existsSync27(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(readFileSync28(join33(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync29(join34(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
@@ -48544,10 +48780,14 @@ class GodotServer {
     const uncaughtFolded = foldedRepeats(uncaught.map(aboveTheRunner));
     const listedAsUncaught = new Set(uncaughtFolded.map((entry) => entry.index));
     const notApplied = ignoredYetRan(report, ignored);
+    const testsNotRun = [
+      ...new Set((selection.value?.selected ?? []).filter((one) => !report.suites.some((suite) => (suite.path === one.suite || suite.name === basename11(one.suite, ".gd")) && suite.cases.some((ran) => ran.name === one.test || new RegExp(`^${one.test}\\W`).test(ran.name)))).map((one) => `${basename11(one.suite, ".gd")}:${one.test}`))
+    ];
     return this.jsonTextResponse({
-      passed: !timedOut && exitCode === 0 && nothingRan === null && report.tests > 0 && report.failures === 0 && report.errors === 0 && hookFailures.length === 0 && uncaught.length === 0 && missing.length === 0,
-      verdict,
+      passed: !timedOut && exitCode === 0 && nothingRan === null && report.tests > 0 && report.failures === 0 && report.errors === 0 && hookFailures.length === 0 && uncaught.length === 0 && missing.length === 0 && testsNotRun.length === 0,
+      verdict: testsNotRun.length === 0 ? verdict : `${verdict}; not run: ${testsNotRun.join(", ")}`,
       ...missing.length > 0 ? { missing } : {},
+      ...testsNotRun.length > 0 ? { testsNotRun } : {},
       ...timedOut ? { timedOut, hung, silentForMs } : {},
       exitCode,
       exitSignal: run.exitSignal ?? undefined,
@@ -48570,6 +48810,7 @@ class GodotServer {
       ...scanned,
       note: [
         missingNote,
+        testsNotRun.length > 0 ? `${testsNotRun.join(", ")} ${testsNotRun.length === 1 ? "was" : "were"} asked for and not run, so the run is not called passed: gdUnit4 runs a test_ function only in a script that extends GdUnitTestSuite, and leaves out a suite whose script does not load.` : undefined,
         briefed > 0 ? `${briefed} of the ${failed.length} failing cases, those with the largest reports, are named with their first message only, since their reports would have made the answer too large to deliver; pass one case's suite path to see its reports.` : undefined,
         notApplied.length > 0 ? "An ignore entry named a case that ran all the same: gdUnit4 leaves a case out only as suite_name:test_name, and reads an entry with no colon as a suite name or a piece of a suite path. ignoreNotApplied gives the form for each case that ran." : undefined,
         uncaughtNote(uncaught),
@@ -48612,6 +48853,16 @@ class GodotServer {
       return this.createErrorResponse(scripts.reason);
     }
     if (scripts?.value == null) {
+      const asked = readString(args, "scriptPath");
+      if (project.ok && asked !== undefined) {
+        const location = resolveWithinProject(project.value.path, asked);
+        if (!location.ok) {
+          return this.createErrorResponse(location.reason, PATH_SOLUTIONS);
+        }
+        if (!existsSync27(location.absolutePath)) {
+          return this.missingScript(project.value.path, location.relativePath);
+        }
+      }
       const one = await this.diagnosticsOf(args);
       if ("noLanguageServer" in one) {
         const checked = project.ok ? await this.engineDiagnostics(project.value.path, [readString(args, "scriptPath") ?? ""], one.noLanguageServer) : { refusal: project.response };
@@ -48678,6 +48929,11 @@ class GodotServer {
       ...byEngine === null ? {} : engineChecked(byEngine)
     });
   }
+  missingScript(projectPath, relativePath) {
+    const scripts = projectFiles(projectPath, [".gd"]).map((script) => `res://${script}`);
+    const wanted = `res://${relativePath}`;
+    return this.createErrorResponse(withNearestFiles(`Script file does not exist: ${wanted}`, wanted, scripts));
+  }
   async compileScripts(projectPath, paths) {
     const payload = { checked: [], failed: [], scripts: [] };
     const messages = [];
@@ -48714,21 +48970,28 @@ class GodotServer {
       String(asParams(entry)["path"]),
       asParams(entry)
     ]));
+    const errorsOf = scripts.map((_, at) => readArray(failures.get(named[at] ?? "") ?? {}, "errors") ?? []);
+    const uncachedPer = uncachedFor(projectPath, errorsOf.map((errors) => errors.map((entry) => String(asParams(entry)["message"]))));
     return {
       answers: scripts.map((scriptPath, at) => {
         const failure = failures.get(named[at] ?? "");
-        const diagnostics = (readArray(failure ?? {}, "errors") ?? []).map((entry) => {
+        const diagnostics = (errorsOf[at] ?? []).map((entry) => {
           const { line, message } = asParams(entry);
           return { severity: "error", message, ...typeof line === "number" && line > 0 ? { line } : {} };
         });
         const dependencies = readArray(failure ?? {}, "dependencies_with_errors");
+        const uncached = uncachedPer[at] ?? [];
         return {
           scriptPath,
           clean: diagnostics.length === 0,
           errors: diagnostics.length,
           warnings: null,
           diagnostics,
-          ...dependencies === undefined ? {} : { dependenciesWithErrors: dependencies }
+          ...dependencies === undefined ? {} : { dependenciesWithErrors: dependencies },
+          ...uncached.length === 0 ? {} : {
+            typesMissingFromTheClassCache: uncached.map(({ type, declaredIn }) => ({ type, declaredIn })),
+            staleAnalysis: uncachedForTheEngineNote(projectPath, uncached)
+          }
         };
       })
     };
@@ -48778,11 +49041,11 @@ class GodotServer {
     const cached = cachedClasses(projectPath);
     const sourceOf = (resourcePath) => {
       const contained = resolveWithinProject(projectPath, resourcePath);
-      if (!contained.ok || !existsSync26(contained.absolutePath)) {
+      if (!contained.ok || !existsSync27(contained.absolutePath)) {
         return null;
       }
       try {
-        return readFileSync28(contained.absolutePath, "utf8");
+        return readFileSync29(contained.absolutePath, "utf8");
       } catch {
         return null;
       }
@@ -48872,11 +49135,11 @@ class GodotServer {
   }
   sourceOfClass(projectPath, resourcePath) {
     const contained = resolveWithinProject(projectPath, resourcePath);
-    if (!contained.ok || !existsSync26(contained.absolutePath)) {
+    if (!contained.ok || !existsSync27(contained.absolutePath)) {
       return null;
     }
     try {
-      return readFileSync28(contained.absolutePath, "utf8");
+      return readFileSync29(contained.absolutePath, "utf8");
     } catch {
       return null;
     }
@@ -49033,7 +49296,7 @@ class GodotServer {
       ...Array.isArray(stack) ? {
         stack: stack.map((frame) => ({
           ...frame,
-          ...projectPath !== "" && typeof frame["script"] === "string" && frame["script"].startsWith("res://") ? { path: join33(projectPath, frame["script"].slice("res://".length)) } : {}
+          ...projectPath !== "" && typeof frame["script"] === "string" && frame["script"].startsWith("res://") ? { path: join34(projectPath, frame["script"].slice("res://".length)) } : {}
         }))
       } : {}
     });
@@ -49312,7 +49575,7 @@ class GodotServer {
       return null;
     }
     try {
-      return settingKeys(readFileSync28(join33(projectPath, "project.godot"), "utf8"));
+      return settingKeys(readFileSync29(join34(projectPath, "project.godot"), "utf8"));
     } catch {
       return null;
     }
@@ -49757,7 +50020,7 @@ class GodotServer {
   }
   async runtimeUp(projectPath, before, budget, withArgs) {
     const budgetMs = budget.ms;
-    if (!existsSync26(join33(projectPath, RUNTIME_AUTOLOAD.path))) {
+    if (!existsSync27(join34(projectPath, RUNTIME_AUTOLOAD.path))) {
       return runtimeVerdict(null, {
         addon: false,
         budgetMs,
@@ -50039,7 +50302,7 @@ class GodotServer {
       return 0;
     }
     try {
-      return reportAlreadyInTranscript(readFileSync28(game.transcript), readFileSync28(report));
+      return reportAlreadyInTranscript(readFileSync29(game.transcript), readFileSync29(report));
     } catch (error) {
       this.logDebug(`Could not compare a picked-up run's report with its transcript: ${errorMessage(error)}`);
       return 0;
@@ -50734,7 +50997,7 @@ class GodotServer {
     };
     const going = await this.runStillGoing(run);
     const projectPath = run.projectPath;
-    const projectGone = projectPath !== null && !existsSync26(join33(projectPath, "project.godot"));
+    const projectGone = projectPath !== null && !existsSync27(join34(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"]);
     }
@@ -51081,7 +51344,7 @@ class GodotServer {
       notes.push(endedWithoutACode({
         throughEditor: run.throughEditor,
         announced: announced !== undefined || run.announcedPid !== undefined,
-        couldAnnounce: run.projectPath !== null && existsSync26(join33(run.projectPath, RUNTIME_AUTOLOAD.path)),
+        couldAnnounce: run.projectPath !== null && existsSync27(join34(run.projectPath, RUNTIME_AUTOLOAD.path)),
         endedHere: typeof run.endedHere === "string",
         pickedUp: run.pickedUp === true
       }));
@@ -51710,8 +51973,8 @@ class GodotServer {
     if (!scriptPath.ok) {
       return this.createErrorResponse(scriptPath.reason);
     }
-    if (!existsSync26(scriptPath.absolutePath)) {
-      return this.createErrorResponse(`Script file does not exist: ${scriptPath.absolutePath}`);
+    if (!existsSync27(scriptPath.absolutePath)) {
+      return this.missingScript(projectPath, scriptPath.relativePath);
     }
     const asked = readNonEmptyString(args, "newScriptPath");
     const moveTo = asked === undefined ? null : resolveWithinProject(projectPath, asked);
@@ -52124,7 +52387,7 @@ class GodotServer {
     }
     const escaped = symbol.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const declared = new RegExp(`^\\s*(?:@\\w+(?:\\([^)]*\\))?\\s+)*class_name\\s+${escaped}\\b`, "m");
-    if (declared.test(readFileSync28(scriptPath, "utf8"))) {
+    if (declared.test(readFileSync29(scriptPath, "utf8"))) {
       return null;
     }
     const checked = await this.classesTheEditorCannotSee(args);
@@ -52290,7 +52553,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) || !existsSync26(join33(project, RUNTIME_AUTOLOAD.path)) || !await this.runStillGoing(run)) {
+    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync27(join34(project, RUNTIME_AUTOLOAD.path)) || !await this.runStillGoing(run)) {
       return null;
     }
     const already = runtimesAnnounced().running;
@@ -52384,7 +52647,7 @@ class GodotServer {
       return this.createErrorResponse(staleNote);
     }
     const screenshotDir = expectsScreenshot ? scratchDirectory("runtime-screenshot") : null;
-    const screenshotPath = screenshotDir ? join33(screenshotDir, "capture.png") : null;
+    const screenshotPath = screenshotDir ? join34(screenshotDir, "capture.png") : null;
     const refused = (message) => this.createErrorResponse(message);
     const onGame = {
       pid: choice.endpoint.pid,
@@ -52445,7 +52708,7 @@ class GodotServer {
 
 Ran alongside ${ranWith.join(", ")}. ${ALONGSIDE_NOTE}`}`
           },
-          { type: "image", data: readFileSync28(screenshotPath).toString("base64"), mimeType: "image/png" }
+          { type: "image", data: readFileSync29(screenshotPath).toString("base64"), mimeType: "image/png" }
         ]
       };
     } finally {
@@ -52620,6 +52883,7 @@ var init_server = __esm(() => {
   init_server_version();
   init_setup();
   init_spawn();
+  init_test_selection();
   init_tool_definitions();
   init_tool_reference();
   init_update_check();
@@ -52668,6 +52932,7 @@ var init_server = __esm(() => {
   });
   PROJECT_INFO_SECTIONS2 = dictionary({
     autoloads: { operation: "list_autoloads", params: () => ({}) },
+    input_actions: { operation: "list_input_actions", params: () => ({}) },
     plugins: { operation: "list_plugins", params: () => ({}) },
     export_presets: { operation: "list_export_presets", params: () => ({}) },
     audio_buses: { operation: "get_audio_buses", params: () => ({}) },
@@ -52684,8 +52949,8 @@ var init_server = __esm(() => {
 init_bridge_announce();
 init_errors();
 init_godot_path();
-import { existsSync as existsSync27 } from "node:fs";
-import { join as join34, resolve as resolve8 } from "node:path";
+import { existsSync as existsSync28 } from "node:fs";
+import { join as join35, 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";
@@ -53829,6 +54094,13 @@ declaration and the cache can both be right while the editor stays blind to it.
 its own, which is the measured cure and needs no change to the declaring script; \`editor_launch
 restart\` also does it and costs a restart of the editor.
 
+With no editor open, the headless engine that compiles for \`script_diagnostics\` and for
+\`project_info\`'s health and validation resolves class names only from that cache file. A
+project never opened, as a fresh clone is, has no such file, so every script typed by a project
+class fails there. \`script_diagnostics\` names the class under
+\`typesMissingFromTheClassCache\`, health and validation say so beside the failure, and
+\`project_import refresh_classes\` writes the cache from the declarations on disk.
+
 The scan writes \`.godot/global_script_class_cache.cfg\` from the list the editor is holding, so
 a class it cannot resolve would go out of that file with it. The answer names that loss under
 \`cacheLost\` and rebuilds the cache from the declarations on disk, naming what came back under
@@ -53969,7 +54241,7 @@ class UsageError extends Refusal {
 function projectArgument(at) {
   const named = args.slice(at).find((value) => !value.startsWith("--"));
   const projectPath = resolve8(named ?? ".");
-  if (!existsSync27(join34(projectPath, "project.godot"))) {
+  if (!existsSync28(join35(projectPath, "project.godot"))) {
     throw new UsageError(`Not a Godot project: ${projectPath} holds no project.godot.`);
   }
   return projectPath;
@@ -54014,7 +54286,7 @@ async function registerRuntime(godot, projectPath) {
     return;
   }
   console.log(`${RUNTIME_AUTOLOAD.name} autoload left at ${named}, which this project registers itself`);
-  if (!existsSync27(join34(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
+  if (!existsSync28(join35(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}`);
   }
 }
@@ -54146,7 +54418,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, existsSync27);
+      const directories = skillDirectories(chosen.harnesses, projectPath, existsSync28);
       for (const written of writeSkill(directories, getLocalVersion())) {
         console.log(`skill: ${written.replaced ? "replaced" : "written"} ${written.path}`);
       }
@@ -54260,7 +54532,7 @@ async function upgrade() {
       moved.push(took.from);
     }
   }
-  for (const written of writeSkill(skillDirectories(already, projectPath, existsSync27), version)) {
+  for (const written of writeSkill(skillDirectories(already, projectPath, existsSync28), version)) {
     console.log(`skill: ${written.replaced ? "replaced" : "written"} ${written.path}`);
   }
   console.log(`