gdharness 1.3.1 → 1.3.2

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: {
@@ -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: {
@@ -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" },
@@ -12672,7 +12707,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 +12790,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 +12811,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 +12825,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: {
@@ -13716,7 +13751,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 +39310,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 +39396,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 +44124,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 +45097,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 +45168,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 +45216,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 +45608,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 +45787,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 +45853,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 +45885,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 +46150,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 +46174,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 +46329,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 +46344,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 +46447,7 @@ function isDirectory(path) {
   }
 }
 function scriptsUnder(directory, prefix) {
-  if (existsSync26(join33(directory, ".gdignore"))) {
+  if (existsSync27(join34(directory, ".gdignore"))) {
     return [];
   }
   const found = [];
@@ -46308,7 +46457,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 +46465,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 +46487,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 +46749,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 +46897,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 +46933,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 +47160,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 };
   }
@@ -47319,6 +47471,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 +47562,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}`, [
@@ -48102,27 +48263,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 +48385,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 +48393,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 +48422,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 +48476,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 +48507,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 +48541,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 +48599,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 +48733,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 +48763,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 +48806,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 +48882,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 +48923,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 +48994,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 +49088,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 +49249,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 +49528,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 +49973,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 +50255,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 +50950,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 +51297,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 +51926,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 +52340,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 +52506,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 +52600,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 +52661,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 +52836,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 +52885,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 +52902,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 +54047,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 +54194,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 +54239,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 +54371,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 +54485,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(`