gdharness 1.3.4 → 1.3.5

package/build/cli.js

@@ -7836,16 +7836,25 @@ var require_public_api = __commonJS(function(exports) {
 
 // src/paths.ts
 import { realpathSync, statSync as statSync2 } from "node:fs";
-import { isAbsolute, relative, resolve, sep } from "node:path";
-function realPathOr(path) {
-  try {
-    return realpathSync.native(path);
-  } catch {
-    return path;
+import { basename as basename2, dirname as dirname2, isAbsolute, join as join3, relative, resolve, sep } from "node:path";
+function realAsFarAsItExists(path) {
+  const missing = [];
+  let at = path;
+  for (;; ) {
+    try {
+      return join3(realpathSync.native(at), ...missing);
+    } catch {
+      const parent = dirname2(at);
+      if (parent === at) {
+        return path;
+      }
+      missing.unshift(basename2(at));
+      at = parent;
+    }
   }
 }
 function isSameDirectory(onePath, otherPath) {
-  return relative(realPathOr(resolve(onePath)), realPathOr(resolve(otherPath))) === "";
+  return relative(realAsFarAsItExists(resolve(onePath)), realAsFarAsItExists(resolve(otherPath))) === "";
 }
 function isWithinRoot(rootPath, candidatePath) {
   const step = relative(resolve(rootPath), resolve(candidatePath));
@@ -7880,9 +7889,11 @@ function resolveWithinProject(projectPath, candidatePath, options = {}) {
     };
   }
   if (withoutScheme.startsWith("/") || withoutScheme.startsWith("\\") || isAbsolute(withoutScheme)) {
+    const tail = withoutScheme.split(/[\\/]+/).filter((step) => step !== "" && !step.endsWith(":"));
+    const example = tail.slice(-2).join("/") || "scenes/main.tscn";
     return {
       ok: false,
-      reason: `Path '${trimmed}' is absolute and outside the project; give a path inside it, such as 'scenes/main.tscn'.`
+      reason: `Path '${trimmed}' is absolute and outside the project; give a path inside it, such as '${example}'.`
     };
   }
   const kept = keptInside(trimmed);
@@ -7922,7 +7933,7 @@ function exportedBuild(projectPath, candidatePath) {
       reason: `There is no ${found.relativePath} in the project to start: export the build first, with project_export run.`
     };
   }
-  if (!isWithinRoot(realPathOr(projectPath), real)) {
+  if (!isWithinRoot(realAsFarAsItExists(projectPath), real)) {
     return {
       ok: false,
       reason: `${found.relativePath} leads outside the project, to ${real}, so it is not started.`
@@ -7941,7 +7952,7 @@ var init_paths = __esm(() => {
 
 // src/runner.ts
 import { existsSync as existsSync3 } from "node:fs";
-import { dirname as dirname2, join as join3 } from "node:path";
+import { dirname as dirname3, join as join4 } from "node:path";
 import process3 from "node:process";
 function currentRunner() {
   const versions = process3.versions;
@@ -7962,7 +7973,7 @@ function spawnFor(runner, version, execPath = process3.execPath) {
   return { command: alongside(execPath, "npx") ?? "npx", args: ["-y", spec] };
 }
 function alongside(execPath, name) {
-  const runner = join3(dirname2(execPath), process3.platform === "win32" ? `${name}.cmd` : name);
+  const runner = join4(dirname3(execPath), process3.platform === "win32" ? `${name}.cmd` : name);
   return existsSync3(runner) ? runner : undefined;
 }
 var init_runner = () => {};
@@ -8303,25 +8314,25 @@ var init_engine_run = __esm(() => {
 // src/doc-cache.ts
 import { existsSync as existsSync5, readdirSync as readdirSync3, statSync as statSync4 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { basename as basename3, dirname as dirname4, isAbsolute as isAbsolute2, join as join5 } from "node:path";
+import { basename as basename4, dirname as dirname5, isAbsolute as isAbsolute2, join as join6 } from "node:path";
 import process5 from "node:process";
 function editorCacheDirectory(godotPath, platform = process5.platform, env = process5.env, home = homedir3()) {
-  const beside = dirname4(godotPath);
-  const bundle = platform === "darwin" && basename3(beside) === "MacOS" && basename3(dirname4(beside)) === "Contents" ? dirname4(dirname4(dirname4(beside))) : null;
+  const beside = dirname5(godotPath);
+  const bundle = platform === "darwin" && basename4(beside) === "MacOS" && basename4(dirname5(beside)) === "Contents" ? dirname5(dirname5(dirname5(beside))) : null;
   for (const folder of bundle === null ? [beside] : [beside, bundle]) {
-    if (existsSync5(join5(folder, "._sc_")) || existsSync5(join5(folder, "_sc_"))) {
-      return join5(folder, "editor_data", "cache");
+    if (existsSync5(join6(folder, "._sc_")) || existsSync5(join6(folder, "_sc_"))) {
+      return join6(folder, "editor_data", "cache");
     }
   }
   if (platform === "win32") {
     const set = (name) => env[name] === "" ? undefined : env[name];
-    return join5(set("LOCALAPPDATA") ?? set("TEMP") ?? join5(home, "AppData", "Local"), "Godot");
+    return join6(set("LOCALAPPDATA") ?? set("TEMP") ?? join6(home, "AppData", "Local"), "Godot");
   }
   if (platform === "darwin") {
-    return join5(home, "Library", "Caches", "Godot");
+    return join6(home, "Library", "Caches", "Godot");
   }
   const xdg = env["XDG_CACHE_HOME"];
-  return join5(xdg !== undefined && isAbsolute2(xdg) ? xdg : join5(home, ".cache"), "godot");
+  return join6(xdg !== undefined && isAbsolute2(xdg) ? xdg : join6(home, ".cache"), "godot");
 }
 function docCachesWritten(directory) {
   const written = new Map;
@@ -8333,7 +8344,7 @@ function docCachesWritten(directory) {
   }
   for (const name of names.filter((one) => CACHE_FILE.test(one))) {
     try {
-      written.set(join5(directory, name), statSync4(join5(directory, name)).mtimeMs);
+      written.set(join6(directory, name), statSync4(join6(directory, name)).mtimeMs);
     } catch {}
   }
   return written;
@@ -8358,7 +8369,7 @@ var init_doc_cache = __esm(() => {
 
 // src/library-copies.ts
 import { existsSync as existsSync6, readdirSync as readdirSync4, readFileSync as readFileSync3, renameSync, unlinkSync } from "node:fs";
-import { basename as basename4, dirname as dirname5, isAbsolute as isAbsolute3, join as join6 } from "node:path";
+import { basename as basename5, dirname as dirname6, isAbsolute as isAbsolute3, join as join7 } from "node:path";
 function freeLibraryCopies(projectPath, platform = process.platform) {
   const setAside = [];
   const swept = [];
@@ -8366,12 +8377,12 @@ function freeLibraryCopies(projectPath, platform = process.platform) {
     return { setAside, swept };
   }
   for (const library of windowsLibraries(projectPath)) {
-    const folder = dirname5(library);
-    const copy = `~${basename4(library)}`;
-    if (existsSync6(join6(folder, copy))) {
-      const aside = join6(folder, `${copy}.aside-${process.pid}-${Date.now()}`);
+    const folder = dirname6(library);
+    const copy = `~${basename5(library)}`;
+    if (existsSync6(join7(folder, copy))) {
+      const aside = join7(folder, `${copy}.aside-${process.pid}-${Date.now()}`);
       try {
-        renameSync(join6(folder, copy), aside);
+        renameSync(join7(folder, copy), aside);
         setAside.push(aside);
       } catch {}
     }
@@ -8384,8 +8395,8 @@ function freeLibraryCopies(projectPath, platform = process.platform) {
     for (const name of names) {
       if (name.length > copy.length && name.toLowerCase().startsWith(copy.toLowerCase())) {
         try {
-          unlinkSync(join6(folder, name));
-          swept.push(join6(folder, name));
+          unlinkSync(join7(folder, name));
+          swept.push(join7(folder, name));
         } catch {}
       }
     }
@@ -8393,7 +8404,7 @@ function freeLibraryCopies(projectPath, platform = process.platform) {
   return { setAside, swept };
 }
 function windowsLibraries(projectPath) {
-  const listed = readOrNull(join6(projectPath, ".godot", "extension_list.cfg"));
+  const listed = readOrNull(join7(projectPath, ".godot", "extension_list.cfg"));
   if (listed === null) {
     return [];
   }
@@ -8412,7 +8423,7 @@ function windowsLibraries(projectPath) {
         continue;
       }
       const named = inLibraries ? /^\s*windows[\w.]*\s*=\s*"([^"]+)"/.exec(row)?.[1] : undefined;
-      const library = named === undefined ? null : resolveResource(projectPath, dirname5(manifest), named);
+      const library = named === undefined ? null : resolveResource(projectPath, dirname6(manifest), named);
       if (library !== null) {
         libraries.add(library);
       }
@@ -8425,9 +8436,9 @@ function resolveResource(projectPath, relativeTo, path) {
     return null;
   }
   if (path.startsWith("res://")) {
-    return join6(projectPath, path.slice("res://".length));
+    return join7(projectPath, path.slice("res://".length));
   }
-  return isAbsolute3(path) ? path : join6(relativeTo, path);
+  return isAbsolute3(path) ? path : join7(relativeTo, path);
 }
 function readOrNull(path) {
   try {
@@ -8441,10 +8452,10 @@ var init_library_copies = () => {};
 // src/reimport.ts
 import { createHash } from "node:crypto";
 import { existsSync as existsSync7, readFileSync as readFileSync4, rmSync as rmSync3, statSync as statSync5, utimesSync, writeFileSync as writeFileSync3 } from "node:fs";
-import { basename as basename5, join as join7 } from "node:path";
+import { basename as basename6, join as join8 } from "node:path";
 function forceNextImport(projectPath, resourcePath) {
   const relative = resourcePath.replace(/^res:\/\//, "");
-  const sidecar = join7(projectPath, `${relative}.import`);
+  const sidecar = join8(projectPath, `${relative}.import`);
   if (!existsSync7(sidecar)) {
     return;
   }
@@ -8455,7 +8466,7 @@ function forceNextImport(projectPath, resourcePath) {
 }
 function importRecord(projectPath, resourcePath) {
   const digest = createHash("md5").update(resourcePath).digest("hex");
-  return join7(projectPath, ".godot", "imported", `${basename5(resourcePath)}-${digest}.md5`);
+  return join8(projectPath, ".godot", "imported", `${basename6(resourcePath)}-${digest}.md5`);
 }
 var init_reimport = () => {};
 
@@ -8477,10 +8488,10 @@ var init_alive = () => {};
 // src/scratch.ts
 import { existsSync as existsSync8, mkdtempSync, readdirSync as readdirSync5, rmSync as rmSync4 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 import process7 from "node:process";
 function scratchDirectory(kind) {
-  return mkdtempSync(join8(tmpdir2(), `gdharness-${kind}-${process7.pid}-`));
+  return mkdtempSync(join9(tmpdir2(), `gdharness-${kind}-${process7.pid}-`));
 }
 function sweepAbandonedScratch(directory = tmpdir2()) {
   let entries;
@@ -8496,7 +8507,7 @@ function sweepAbandonedScratch(directory = tmpdir2()) {
       continue;
     }
     try {
-      remove(join8(directory, entry));
+      remove(join9(directory, entry));
     } catch {}
   }
 }
@@ -9081,7 +9092,7 @@ var init_junit = __esm(() => {
 });
 
 // src/script-origins.ts
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 function unresolvedClassIn(message) {
   return UNRESOLVED.exec(message)?.[1] ?? null;
 }
@@ -9143,7 +9154,7 @@ function checkWithEngine(godotPath, projectPath) {
       const ran = await runEngine(godotPath, [
         "--headless",
         "--log-file",
-        join9(logDir, "engine.log"),
+        join10(logDir, "engine.log"),
         "--path",
         projectPath,
         "--check-only",
@@ -9189,8 +9200,8 @@ var init_script_origins = __esm(() => {
 });
 
 // src/headless.ts
-import { existsSync as existsSync9, readFileSync as readFileSync5, realpathSync as realpathSync2, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname6, join as join10 } from "node:path";
+import { existsSync as existsSync9, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "node:fs";
+import { dirname as dirname7, join as join11 } from "node:path";
 function snakeCased(params) {
   const result = emptyRecord();
   for (const [key, value] of Object.entries(params)) {
@@ -9271,19 +9282,12 @@ function refusalsIn(log) {
 }
 function scriptFault(problems, script) {
   const spelled = (path) => `(${path.replaceAll("\\", "/").toLowerCase()}/`;
-  const directories = [...new Set([spelled(dirname6(script)), spelled(resolvedOr(dirname6(script)))])];
+  const directories = [...new Set([spelled(dirname7(script)), spelled(realAsFarAsItExists(dirname7(script)))])];
   return problems.find((entry) => {
     const at = entry.detail.find((line) => line.startsWith("at: "))?.replaceAll("\\", "/").toLowerCase();
     return entry.severity === "error" && at !== undefined && directories.some((directory) => at.includes(directory));
   });
 }
-function resolvedOr(path) {
-  try {
-    return realpathSync2.native(path);
-  } catch {
-    return path;
-  }
-}
 function librariesNotCopied(messages) {
   const found = new Set;
   for (const entry of messages) {
@@ -9335,7 +9339,7 @@ async function importOnce(godotPath, projectPath) {
     ran = await runEngine(godotPath, [
       "--headless",
       "--log-file",
-      join10(logDir, "engine.log"),
+      join11(logDir, "engine.log"),
       "--path",
       projectPath,
       "--import"
@@ -9357,13 +9361,13 @@ async function importOnce(godotPath, projectPath) {
 }
 async function runOperation(engine, operation, params, projectPath) {
   const paramsDir = scratchDirectory("params");
-  const paramsFile = join10(paramsDir, `${operation}.json`);
-  const answerFile = join10(paramsDir, "answer.json");
+  const paramsFile = join11(paramsDir, `${operation}.json`);
+  const answerFile = join11(paramsDir, "answer.json");
   writeFileSync4(paramsFile, JSON.stringify(snakeCased(params)), "utf8");
   const args = [
     "--headless",
     "--log-file",
-    join10(paramsDir, "engine.log"),
+    join11(paramsDir, "engine.log"),
     "--path",
     projectPath,
     "--script",
@@ -9470,6 +9474,7 @@ var init_headless = __esm(() => {
   init_doc_cache();
   init_engine_run();
   init_library_copies();
+  init_paths();
   init_reimport();
   init_scratch();
   init_script_origins();
@@ -9478,7 +9483,7 @@ var init_headless = __esm(() => {
 // src/update-check.ts
 import { existsSync as existsSync10, mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "node:fs";
 import { homedir as homedir4, tmpdir as tmpdir3 } from "node:os";
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 function packageUrl(root) {
   return `${root.replace(/\/+$/, "")}/gdharness/latest`;
 }
@@ -9500,20 +9505,20 @@ function cacheDirectory(environment) {
   };
   const home = set("HOME") ?? homedir4();
   if (process.platform === "win32") {
-    return join11(set("LOCALAPPDATA") ?? home, "gdharness");
+    return join12(set("LOCALAPPDATA") ?? home, "gdharness");
   }
   if (process.platform === "darwin") {
-    return join11(home, "Library", "Caches", "gdharness");
+    return join12(home, "Library", "Caches", "gdharness");
   }
-  return join11(set("XDG_CACHE_HOME") ?? join11(home, ".cache"), "gdharness");
+  return join12(set("XDG_CACHE_HOME") ?? join12(home, ".cache"), "gdharness");
 }
 function cacheFile(environment = process.env) {
   try {
     const directory = cacheDirectory(environment);
     mkdirSync3(directory, { recursive: true, mode: 448 });
-    return join11(directory, "update-check.json");
+    return join12(directory, "update-check.json");
   } catch {
-    return join11(tmpdir3(), "gdharness-update-check.json");
+    return join12(tmpdir3(), "gdharness-update-check.json");
   }
 }
 function readCache(path) {
@@ -10514,7 +10519,7 @@ var init_gdscript_source = __esm(() => {
 
 // src/class-cache.ts
 import { existsSync as existsSync11, readdirSync as readdirSync6, readFileSync as readFileSync8, statSync as statSync6 } from "node:fs";
-import { join as join12, posix } from "node:path";
+import { join as join13, posix } from "node:path";
 function isToolScript(source) {
   return TOOL.test(codeOf(source));
 }
@@ -10530,14 +10535,14 @@ function declaredClasses(projectPath) {
 }
 function eachScript(projectPath, each) {
   const visit = (directory, prefix) => {
-    if (existsSync11(join12(directory, ".gdignore"))) {
+    if (existsSync11(join13(directory, ".gdignore"))) {
       return;
     }
     for (const entry of readdirSync6(directory, { withFileTypes: true })) {
       if (entry.name.startsWith(".")) {
         continue;
       }
-      const path = join12(directory, entry.name);
+      const path = join13(directory, entry.name);
       if (entry.isDirectory()) {
         visit(path, `${prefix}${entry.name}/`);
       } else if (entry.isFile() && entry.name.endsWith(".gd")) {
@@ -10563,7 +10568,7 @@ function scriptsNaming(projectPath, classes) {
   return naming.sort((a, b) => a.script.localeCompare(b.script));
 }
 function cachedClasses(projectPath) {
-  const cache = join12(projectPath, ".godot", "global_script_class_cache.cfg");
+  const cache = join13(projectPath, ".godot", "global_script_class_cache.cfg");
   if (!existsSync11(cache)) {
     return null;
   }
@@ -10574,6 +10579,22 @@ function cachedClasses(projectPath) {
   }
   return listed;
 }
+function addonOf(path) {
+  return /^res:\/\/addons\/([^/]+)\//.exec(path)?.[1];
+}
+function withAddonPathsCounted(paths) {
+  const own = [];
+  const inAddons = {};
+  for (const path of paths) {
+    const addon = addonOf(path);
+    if (addon === undefined) {
+      own.push(path);
+    } else {
+      inAddons[addon] = (inAddons[addon] ?? 0) + 1;
+    }
+  }
+  return { own, inAddons };
+}
 function withAddonClassesCounted(rebuilt, listed) {
   const counted = { ...rebuilt };
   for (const key of ["added", "changed"]) {
@@ -10584,7 +10605,7 @@ function withAddonClassesCounted(rebuilt, listed) {
     const own = [];
     const perAddon = {};
     for (const name of names) {
-      const addon = /^res:\/\/addons\/([^/]+)\//.exec(listed.get(String(name)) ?? "")?.[1];
+      const addon = addonOf(listed.get(String(name)) ?? "");
       if (addon === undefined) {
         own.push(name);
       } else {
@@ -10845,12 +10866,12 @@ function uncachedForTheEngineNote(projectPath, types) {
   }
   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 cacheExists = existsSync11(join13(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");
+  const cache = join13(projectPath, ".godot", "global_script_class_cache.cfg");
   try {
     return statSync6(cache).mtimeMs;
   } catch {
@@ -10864,14 +10885,14 @@ function declaredSince(projectPath, paths, names, since) {
       return false;
     }
     try {
-      return statSync6(join12(projectPath, path.slice("res://".length))).mtimeMs > since;
+      return statSync6(join13(projectPath, path.slice("res://".length))).mtimeMs > since;
     } catch {
       return false;
     }
   });
 }
 function cachedAtMissingPaths(cached, projectPath) {
-  return [...cached].filter(([, path]) => path.startsWith("res://") && !existsSync11(join12(projectPath, path.slice("res://".length)))).map(([name]) => name).sort();
+  return [...cached].filter(([, path]) => path.startsWith("res://") && !existsSync11(join13(projectPath, path.slice("res://".length)))).map(([name]) => name).sort();
 }
 function staleAgainst(cached, projectPath) {
   return [...declaredClasses(projectPath)].filter(([name, path]) => cached.get(name) !== path).map(([name]) => name);
@@ -10897,7 +10918,7 @@ var init_class_cache = __esm(() => {
 
 // src/project-scan.ts
 import { existsSync as existsSync12, readdirSync as readdirSync7, readFileSync as readFileSync9 } from "node:fs";
-import { extname, join as join13 } from "node:path";
+import { extname, join as join14 } from "node:path";
 function skipped(name) {
   return name.startsWith(".") || SKIPPED.has(name);
 }
@@ -10905,10 +10926,10 @@ function steppedOver(directory) {
   return gdignored(directory) || installedByUs(directory);
 }
 function gdignored(directory) {
-  return existsSync12(join13(directory, ".gdignore"));
+  return existsSync12(join14(directory, ".gdignore"));
 }
 function installedByUs(directory) {
-  return existsSync12(join13(directory, VERSION_MARKER));
+  return existsSync12(join14(directory, VERSION_MARKER));
 }
 function projectStructure(projectPath) {
   const structure = { scenes: 0, scripts: 0, assets: 0, other: 0 };
@@ -10921,7 +10942,7 @@ function projectStructure(projectPath) {
         continue;
       }
       if (entry.isDirectory()) {
-        visit(join13(directory, entry.name));
+        visit(join14(directory, entry.name));
       } else if (entry.isFile()) {
         const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
         if (SCENE_EXTENSIONS.has(extension)) {
@@ -10951,7 +10972,7 @@ function projectFiles(projectPath, extensions) {
       }
       const spelled = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
       if (entry.isDirectory()) {
-        visit(join13(directory, entry.name), spelled);
+        visit(join14(directory, entry.name), spelled);
       } else if (entry.isFile() && extensions.includes(extname(entry.name).toLowerCase())) {
         found.push(spelled);
       }
@@ -10972,14 +10993,14 @@ function scriptsWithoutUid(projectPath) {
       }
       const spelled = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
       if (entry.isDirectory()) {
-        visit(join13(directory, entry.name), spelled);
+        visit(join14(directory, entry.name), spelled);
         continue;
       }
       if (!entry.isFile()) {
         continue;
       }
       const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
-      if (CARRIES_A_UID.has(extension) && !existsSync12(join13(directory, `${entry.name}.uid`))) {
+      if (CARRIES_A_UID.has(extension) && !existsSync12(join14(directory, `${entry.name}.uid`))) {
         found.push(spelled);
       }
     }
@@ -10990,7 +11011,7 @@ function scriptsWithoutUid(projectPath) {
 function pathsInUidCache(projectPath) {
   let data;
   try {
-    data = readFileSync9(join13(projectPath, ".godot", "uid_cache.bin"));
+    data = readFileSync9(join14(projectPath, ".godot", "uid_cache.bin"));
   } catch {
     return null;
   }
@@ -11028,7 +11049,7 @@ function projectTexts(projectPath) {
       if (skipped(entry.name)) {
         continue;
       }
-      const absolute = join13(directory, entry.name);
+      const absolute = join14(directory, entry.name);
       const spelled = `${prefix}${entry.name}`;
       if (entry.isDirectory()) {
         visit(absolute, `${spelled}/`);
@@ -11058,7 +11079,7 @@ function ignoredTexts(projectPath) {
       if (skipped(entry.name)) {
         continue;
       }
-      const absolute = join13(directory, entry.name);
+      const absolute = join14(directory, entry.name);
       const spelled = `${prefix}${entry.name}`;
       if (entry.isDirectory()) {
         visit(absolute, `${spelled}/`, under);
@@ -11088,6 +11109,14 @@ function plainMatch(line, needle, caseSensitive) {
   }
   return [lowered.length === line.length ? line.slice(at, at + needle.length) : needle];
 }
+function compiledQuery(query, caseSensitive) {
+  try {
+    return new RegExp(query, caseSensitive ? "" : "i");
+  } catch (error) {
+    const why = errorMessage(error).split(": ").at(-1) ?? "";
+    throw new Error(`'${query}' is not a regular expression: ${why.charAt(0).toLowerCase()}${why.slice(1)}. With regex true, a character such as ( ) [ ] { } . * + ? | ^ $ or \\ stands for itself only after a backslash, as in \\(; or leave regex out to search for the text as written.`);
+  }
+}
 function searchProject(projectPath, options) {
   const extensions = options.fileTypes === undefined ? null : new Set(options.fileTypes.map((ext) => ext.replace(/^\./, "").toLowerCase()).filter(Boolean));
   const result = {
@@ -11095,7 +11124,7 @@ function searchProject(projectPath, options) {
     results: [],
     summary: { files_searched: 0, files_with_matches: 0, total_matches: 0, truncated: false }
   };
-  const regex = options.regex ? new RegExp(options.query, options.caseSensitive ? "" : "i") : null;
+  const regex = options.regex ? compiledQuery(options.query, options.caseSensitive) : null;
   const needle = options.caseSensitive ? options.query : options.query.toLowerCase();
   const full = () => result.summary.truncated;
   const visit = (directory) => {
@@ -11109,7 +11138,7 @@ function searchProject(projectPath, options) {
       if (skipped(entry.name)) {
         continue;
       }
-      const entryPath = join13(directory, entry.name);
+      const entryPath = join14(directory, entry.name);
       if (entry.isDirectory()) {
         visit(entryPath);
         continue;
@@ -11148,6 +11177,7 @@ function searchProject(projectPath, options) {
 }
 var SKIPPED, VERSION_MARKER = ".gdharness-version", SCENE_EXTENSIONS, ASSET_EXTENSIONS, CARRIES_A_UID, BINARY_EXTENSIONS;
 var init_project_scan = __esm(() => {
+  init_errors();
   SKIPPED = new Set(["node_modules"]);
   SCENE_EXTENSIONS = new Set(["tscn", "scn"]);
   ASSET_EXTENSIONS = new Set([
@@ -11205,7 +11235,7 @@ var init_answer_json = __esm(() => {
 });
 
 // src/resources.ts
-import { readFileSync as readFileSync10, realpathSync as realpathSync3 } from "node:fs";
+import { readFileSync as readFileSync10, realpathSync as realpathSync2 } from "node:fs";
 import { extname as extname2, resolve as resolve3 } from "node:path";
 function ensureProjectPath(getProjectPath) {
   const projectPath = getProjectPath();
@@ -11228,13 +11258,13 @@ function resolveProjectFile(projectPath, resourcePath) {
   }
   let root;
   try {
-    root = realpathSync3.native(projectPath);
+    root = realpathSync2.native(projectPath);
   } catch {
     throw new Refusal(`The project directory ${projectPath} is not there.`);
   }
   let real;
   try {
-    real = realpathSync3.native(contained.absolutePath);
+    real = realpathSync2.native(contained.absolutePath);
   } catch {
     throw new Refusal(`No file at ${resourcePath} in the project.`);
   }
@@ -11563,7 +11593,7 @@ import {
   statSync as statSync7,
   writeFileSync as writeFileSync6
 } from "node:fs";
-import { dirname as dirname7, join as join14 } from "node:path";
+import { dirname as dirname8, join as join15 } from "node:path";
 import { fileURLToPath } from "node:url";
 function editorAddonDigest(from = shippedAddonsDirectory()) {
   return addonsDigest(EDITOR_PLUGINS, from);
@@ -11578,7 +11608,7 @@ function addonsDigest(names, from) {
       if (name === VERSION_MARKER || name === DIGEST_MARKER) {
         continue;
       }
-      const path = join14(directory, name);
+      const path = join15(directory, name);
       const inside = `${relative}/${name}`;
       if (statSync7(path).isDirectory()) {
         walk(path, inside);
@@ -11592,7 +11622,7 @@ function addonsDigest(names, from) {
     }
   };
   for (const name of names) {
-    walk(join14(from, name), name);
+    walk(join15(from, name), name);
   }
   return hash.digest("hex");
 }
@@ -11611,7 +11641,7 @@ function installedRuntimeDigest(projectPath) {
   return digestMarker(projectPath, RUNTIME_ADDON);
 }
 function digestMarker(projectPath, addon) {
-  const marker = join14(projectPath, "addons", addon, DIGEST_MARKER);
+  const marker = join15(projectPath, "addons", addon, DIGEST_MARKER);
   if (!existsSync13(marker)) {
     return null;
   }
@@ -11619,35 +11649,35 @@ function digestMarker(projectPath, addon) {
   return said === "" ? null : said;
 }
 function shippedAddonsDirectory() {
-  return join14(dirname7(fileURLToPath(import.meta.url)), "godot", "addons");
+  return join15(dirname8(fileURLToPath(import.meta.url)), "godot", "addons");
 }
 function shippedOperationsScript() {
-  return join14(dirname7(fileURLToPath(import.meta.url)), "godot", "operations", "godot_operations.gd");
+  return join15(dirname8(fileURLToPath(import.meta.url)), "godot", "operations", "godot_operations.gd");
 }
 function installAddons(projectPath, from = shippedAddonsDirectory()) {
   const installed = [];
   for (const name of ADDONS) {
-    const source = join14(from, name);
-    if (!existsSync13(join14(source, name === RUNTIME_ADDON ? "runtime_autoload.gd" : "plugin.cfg"))) {
+    const source = join15(from, name);
+    if (!existsSync13(join15(source, name === RUNTIME_ADDON ? "runtime_autoload.gd" : "plugin.cfg"))) {
       throw new Error(`The package holds no ${name} addon at ${source}.`);
     }
-    const target = join14(projectPath, "addons", name);
+    const target = join15(projectPath, "addons", name);
     const replaced = existsSync13(target);
     rmSync5(target, { recursive: true, force: true });
-    mkdirSync4(dirname7(target), { recursive: true });
+    mkdirSync4(dirname8(target), { recursive: true });
     cpSync(source, target, { recursive: true });
-    writeFileSync6(join14(target, VERSION_MARKER), `${SERVER_VERSION}
+    writeFileSync6(join15(target, VERSION_MARKER), `${SERVER_VERSION}
 `);
     installed.push({ name, path: target, replaced });
   }
-  writeFileSync6(join14(projectPath, "addons", ADDONS[0], DIGEST_MARKER), `${editorAddonDigest(from)}
+  writeFileSync6(join15(projectPath, "addons", ADDONS[0], DIGEST_MARKER), `${editorAddonDigest(from)}
 `);
-  writeFileSync6(join14(projectPath, "addons", RUNTIME_ADDON, DIGEST_MARKER), `${runtimeAddonDigest(from)}
+  writeFileSync6(join15(projectPath, "addons", RUNTIME_ADDON, DIGEST_MARKER), `${runtimeAddonDigest(from)}
 `);
   return installed;
 }
 function installedAddonVersion(projectPath) {
-  const marker = join14(projectPath, "addons", ADDONS[0], VERSION_MARKER);
+  const marker = join15(projectPath, "addons", ADDONS[0], VERSION_MARKER);
   if (!existsSync13(marker)) {
     return null;
   }
@@ -11657,13 +11687,13 @@ function installedAddonVersion(projectPath) {
 function removeAddons(projectPath) {
   const removed = [];
   for (const name of ADDONS) {
-    const target = join14(projectPath, "addons", name);
+    const target = join15(projectPath, "addons", name);
     if (existsSync13(target)) {
       rmSync5(target, { recursive: true, force: true });
       removed.push(target);
     }
   }
-  const addons = join14(projectPath, "addons");
+  const addons = join15(projectPath, "addons");
   if (removed.length > 0 && existsSync13(addons) && readdirSync8(addons).length === 0) {
     rmdirSync(addons);
     removed.push(addons);
@@ -11698,7 +11728,7 @@ function loaderAmong(projectPath, named) {
     }
     let source = null;
     try {
-      source = readFileSync11(join14(projectPath, path), "utf8");
+      source = readFileSync11(join15(projectPath, path), "utf8");
     } catch {}
     if (source?.includes(RUNTIME_AUTOLOAD.path)) {
       return { name: entry, path, exists: true };
@@ -11740,8 +11770,8 @@ function enabledPlugins(settings) {
 function inspectProject(projectPath) {
   const problems = [];
   const addons = ADDONS.map((name) => {
-    const directory = join14(projectPath, "addons", name);
-    const marker = join14(directory, VERSION_MARKER);
+    const directory = join15(projectPath, "addons", name);
+    const marker = join15(directory, VERSION_MARKER);
     const installed = existsSync13(directory);
     const version = existsSync13(marker) ? readFileSync11(marker, "utf8").trim() : null;
     const current = version === SERVER_VERSION;
@@ -11752,7 +11782,7 @@ function inspectProject(projectPath) {
     }
     return { name, installed, version, current };
   });
-  const settings = parseProjectGodot(readFileSync11(join14(projectPath, "project.godot"), "utf8"));
+  const settings = parseProjectGodot(readFileSync11(join15(projectPath, "project.godot"), "utf8"));
   const pluginsEnabled = enabledPlugins(settings);
   for (const name of EDITOR_PLUGINS) {
     if (!pluginsEnabled.includes(name)) {
@@ -11768,7 +11798,7 @@ function inspectProject(projectPath) {
   const tracked = trackedByGit(projectPath, [...named.values()]);
   const addonMissing = (path) => addons.some((addon) => !addon.installed && path.startsWith(`addons/${addon.name}/`));
   for (const [name, path] of named) {
-    if (!existsSync13(join14(projectPath, path))) {
+    if (!existsSync13(join15(projectPath, path))) {
       if (!addonMissing(path)) {
         problems.push(`the ${name} autoload names res://${path}, which is not in this project, so it boots with a missing script; restore that file, or point the autoload at one that is here`);
       }
@@ -11916,7 +11946,7 @@ function annotationsOf(spec) {
     openWorldHint: false
   };
 }
-var PROJECT_INFO_SECTIONS, PROJECT_PATH, RUNNING_PROJECT_PATH, RUNNING_PID, SCENE_PATH, WITHOUT_AN_EDITOR = "Through the editor when one serves the project; with none, a headless engine runs the editor's own tool and the answer says so under writtenBy, or readBy for a read. That engine runs every script of the file, where the editor runs only tool scripts, so what a script changes as the file loads or as a property is set is put back before anything is saved, and a file where that cannot be done, such as a scene whose script does not compile, is refused and nothing is written. Each file the written one refers to is named by its uid, as the editor names it, except a file the project's uid cache has no uid for yet (one made since the project was last scanned), which is named by path and listed under namedByPath with the call that scans it. An editor of the project that is running and has not reached this server is waited for rather than written around.", IMPORTED_FIRST = "importedFirst names the files whose import was behind them on disk, such as a picture changed since it was imported or one never imported, which were imported before the run through project_import reimport, so the run reads them as they are now; it is left out when every import was current. notImportedFirst lists, as project_import reimport does, any it could not import, and importNote says that the run reads those as they were. The import gives every script without a .uid sidecar one, as the editor's scan does, and uidsWrittenFirst names those scripts. importTookMs is how long the import took; it is outside the run's own time limit, so a call that imported can take that much longer than the limit it was given.", WHOLE_NUMBERS = 'A whole number of 2^53 or more, such as a 64-bit seed or a resource uid, is written as its digits, {"_type": "int", "value": "9007199254740993"}, the form a read answers with: a JSON number that large can arrive as a neighbour of the one sent, so sent as a number it is refused.', SCRIPT_PATH, RESOURCE_FILE = 'File inside the project, such as "sprites/hero.png" or "materials/steel.tres".', RESOURCE_PATH, NODE_PATH, PROPERTIES, XY, ANIMATION_TRACK, SCRIPT_MODIFICATIONS, INPUT_EVENTS, TILESET_SOURCES, TILEMAP_CELLS, COLOUR2, TOOL_SPECS, SPECS_BY_NAME;
+var PROJECT_INFO_SECTIONS, PROJECT_PATH, RUNNING_PROJECT_PATH, RUNNING_PID, SCENE_PATH, WITHOUT_AN_EDITOR = "Through the editor when one serves the project; with none, a headless engine runs the editor's own tool and the answer says so under writtenBy, or readBy for a read. That engine runs every script of the file, where the editor runs only tool scripts, so what a script changes as the file loads or as a property is set is put back before anything is saved, and a file where that cannot be done, such as a scene whose script does not compile, is refused and nothing is written. Each file the written one refers to is named by its uid, as the editor names it, except a file the project's uid cache has no uid for yet (one made since the project was last scanned), which is named by path and listed under namedByPath with the call that scans it. An editor of the project that is running and has not reached this server is waited for rather than written around.", IMPORTED_FIRST = "importedFirst names the files whose import was behind them on disk, such as a picture changed since it was imported or one never imported, which were imported before the run through project_import reimport, so the run reads them as they are now; it is left out when every import was current. notImportedFirst lists, as project_import reimport does, any it could not import, and importNote says that the run reads those as they were. The import gives every script without a .uid sidecar one, as the editor's scan does, writing it beside the script in the project, and uidsWrittenFirst names those scripts. The files inside an addon are counted per addon rather than named, under importedInAddons and uidsWrittenInAddons. importTookMs is how long the import took; it is outside the run's own time limit, so a call that imported can take that much longer than the limit it was given.", WHOLE_NUMBERS = 'A whole number of 2^53 or more, such as a 64-bit seed or a resource uid, is written as its digits, {"_type": "int", "value": "9007199254740993"}, the form a read answers with: a JSON number that large can arrive as a neighbour of the one sent, so sent as a number it is refused.', SCRIPT_PATH, RESOURCE_FILE = 'File inside the project, such as "sprites/hero.png" or "materials/steel.tres".', RESOURCE_PATH, NODE_PATH, PROPERTIES, XY, ANIMATION_TRACK, SCRIPT_MODIFICATIONS, INPUT_EVENTS, TILESET_SOURCES, TILEMAP_CELLS, COLOUR2, TOOL_SPECS, SPECS_BY_NAME;
 var init_tool_definitions = __esm(() => {
   init_launch();
   PROJECT_INFO_SECTIONS = [
@@ -12420,7 +12450,7 @@ var init_tool_definitions = __esm(() => {
         timeoutMs: {
           type: "integer",
           minimum: 1,
-          description: "How long the run may take before it is killed. Default 600000. A run killed at the limit answers timedOut and silentForMs, how long it had printed nothing; it is called hung only when that was half the limit, or thirty seconds of a longer one, and otherwise it was still running and wants a longer timeoutMs or a narrower path, unless it ended repeating one script error, which the verdict names instead. A run whose autoload did not compile is stopped as soon as the engine says so, and names the script that did not under scriptErrors."
+          description: "How long the run may take before it is killed, counted from the engine starting it: the class rebuild and any import before it are outside the limit, and tookMs counts them. Default 600000. A run killed at the limit answers timedOut and silentForMs, how long it had printed nothing; it is called hung only when that was half the limit, or thirty seconds of a longer one, and otherwise it was still running and wants a longer timeoutMs or a narrower path, unless it ended repeating one script error, which the verdict names instead. A run whose autoload did not compile is stopped as soon as the engine says so, and names the script that did not under scriptErrors."
         },
         printed: {
           type: "string",
@@ -13219,7 +13249,7 @@ var init_tool_definitions = __esm(() => {
       title: "Editor status",
       effect: "read",
       description: "Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and which games with the runtime addon are reachable, of this project and of every other on the machine. Read connected with mayYetConnect: the editor dials this server and backs off between tries, so for the first half-minute after a server starts false means not reached yet as often as no editor; mayYetConnect true is worth waiting out, false is final, and editorCannotConnect, restartInterrupted, restartUnderway, closedHere and editorsNotYetConnected say why. An editor that has connected and not yet greeted reports nothing about itself, and every other call made in that window waits up to ten seconds for it to settle. playingInEditor null means unanswered rather than nothing playing: processActive and runtimes do not depend on the editor answering. game.run names the run editor_output and editor_run stop answer for, and stays named after it ends. addonIsStale, on a connected editor and on each running game (absent with neither), says it runs addon code other than what this server ships, and staleNote says which half moves: the project, by a gdharness upgrade it spells out to run in a shell, the editor by a restart, or this server by a reconnect. A false editor.lspListening or editor.dapListening comes with serversNote, and editor_launch restart binds the port again. editor.scan says whether the editor is scanning, which editor_run waits out before starting a game. A game announced in a protocol this server does not speak is listed under unreadable, during an upgrade that moves the protocol, until the halves match.",
-      answer: "projectIs, when present, is the gdharness version of the addons in the project, which differs from this server's (project_info says which of the two to move), and configIs, when present, the version the project's MCP config starts, which differs from this server's, so the next connection runs that one. server names this server: its pid, its version, and lifecycleLog, the file every gdharness server of the user appends a line to when it starts, when its client first names itself, when it replaces another server of its project, and when it ends, with why it ended (the client closing its end as stdin:end, a signal by name, superseded with the successor's pid, an uncaught exception or rejection with its stack, or the exit code) and the calls it was answering then. The parent's command line follows on its own line a few seconds after the start. A server killed without warning writes no ended line, and on Windows every kill is that, so a started line with no ended line after it is a server something killed. " + "runtimeConnected counts the games of the project this server serves, and runtimes lists every game on the machine with ofThisProject saying which is which, since a game of another project is reached only by naming its projectPath. playingInEditor is null when the editor was not asked or did not answer, which is not the same as a no: with no editor connected there is nobody to ask, and an editor that does not serve the question is given a moment and then left. A game can be playing while this is null, so read it as unanswered rather than as nothing playing, and use processActive and runtimes, which come from elsewhere and do not depend on the editor answering. Its play says which play the editor is on: play.play counts the plays that editor has started since it opened, whoever started them, and play.editorPid is the editor, so two reads with different pairs are two plays even when both say playing. game.run names the run processActive is about, the one editor_output and editor_run stop answer for: its pid, its project, and adopted true when this server read it back from another server rather than starting it. It stays named after the run ends, beside processActive false, so editor_output can still read what that run printed; null when there is no run at all. startedAt says when it began, and endedAt when it ended, wherever something saw the end: a run adopted from a note another server wrote can have ended hours before this server started. editor.lspListening and editor.dapListening say whether anything accepts connections on the ports the editor names, lspPort and dapPort: Godot binds each once, as the editor starts, and reports a failure only in the log panel of the editor itself, so a false comes with serversNote, and editor_launch restart binds it again. editor.scan says whether the editor is scanning or importing and how many milliseconds ago its last scan finished (finishedMsAgo), or is null when it did not answer: the editor rewrites the class cache just after a scan, and editor_run waits that out before starting a game, saying so under waitedForEditorScanMs. Each game under runtimes is pinged with a short wait, so one held at a breakpoint is listed as unreachable rather than making this call wait out the runtime timeout; for the run this server is reporting on, heldAt says whether that is what it is, with the same three answers editor_output gives. A game the editor played announces the editor under editorPid, and so does whatever that game started for itself; a game some other server started announces none, which is how the two are told apart when both are running from one project. Each game also says which runtime addon it loaded, under addonVersion (null when it cannot say); addonIsStale is true when that code is not what this server ships, and staleNote says whether the project needs the gdharness upgrade command, spelled out to run in a shell, the game a restart, or this server a reconnect. A second checkout of a project, such as a git worktree, carries addons of its own and is where this shows. A runtime_* call to such a game is refused with the staleNote and not sent. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means \"not reached yet\" as often as it means \"no editor\". True is worth waiting out; false is an editor that is not there. False beside editorCannotConnect is a project without the gdharness editor addon installed or enabled, where no editor can ever dial in, however young the server or whichever editor is open; its remedies say how to install or enable it. False beside restartInterrupted is one that an editor_launch restart on a previous server asked to quit, where the launch half never ran because that server was ended in between, usually by the reconnect the restart was taken for; editor_launch open finishes it. True beside restartUnderway is a restart still in progress, its server alive and within the wait for the old editor to go: the editor is coming, and opening another would put two on one project. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. Any editor of this project running and not yet connected, whoever opened it, makes it true as well and is named under editorsNotYetConnected with its pid and start time, so a restart a reconnect interrupted after its launch is not read as nothing being there. settingsDropped appears here once when the editor this server opened saved project.godot on its way in and took a key out of it, which is the same reading editor_launch restart makes in its own answer. A game that has announced itself in a protocol this server does not speak is listed under unreadable rather than left out, with the protocol it speaks and whether the server or the addon is the older half. This happens during an upgrade that moves the runtime protocol, which most do not: installing replaces the addon on disk as soon as the pin moves, while a server that is already running stays on the version it started with, so the two speak different protocols until the server is reconnected. Those games are real and running, but no tool here can reach them until the halves match, so runtimes stays empty and runtimeConnected stays false. An upgrade that leaves the protocol alone opens no such window and this list stays empty through it. addonIsStale is decided by the code of the editor addons rather than their version, so an editor started before an upgrade that left that code alone reports the older addonVersion, is not stale, and addonNote says so: it needs no restart. A stale editor is asked nothing but to quit: every other call to it is refused with staleNote, which names editor_launch restart, the upgrade command or a reconnect. port is the one the editor bridge is on; when that is not the one this server was configured with, portWanted names the configured one and portNote says why it moved and, when it was the server this one replaced, which pid kept it. A server replacing another of its project that holds the configured port waits for it to stand down and takes the port over, which takes a few seconds; bridgeHandover says so while it waits, and it moves only if that server has not let go within the wait. An editor that has connected and not yet greeted, which lasts a frame and longer while it imports, reports nothing about itself: greeting says so, addonIsStale is absent rather than guessed, and a restart asked then waits for the greeting to learn who opened it. startedByAnEditor is an editor another editor started, by Godot's own restart or the project manager, which has none of the arguments a server gave the one before it; startedByAnEditorNote says what that costs. An engine run that loads the editor addon to do one job and quit, such as a gate's godot --headless --import, an export or a script, is not taken as the editor: a process that greets without a server's mark has its command line read first, and while that is read identifying is true and connected false; one started with such an option is turned away, and turnedAway names the last one, its pid and the option. Every other call made while an editor is arriving, before its greeting or while it is looked up, waits up to ten seconds for it to settle rather than acting on connected as it reads in that window. serverVersion is the gdharness version of this server. bridgeAvailable says the editor bridge is listening; when it failed to start, startupError gives the error, and retryingBridge is true while this server tries again. announcedAt is the file where this server told editors of its project which port to dial. connectedAt is when the editor connected, and lastPongAt when it last answered this server's keep-alive ping. addonDigest is a hash of the editor addon's code, which addonIsStale compares with what this server ships. debugPort is the port of the editor's remote debugger, the one games it plays connect to. openedByAServer says a gdharness server started this editor, and syncsBreakpoints that it keeps its breakpoints when a debug session opens, which Godot otherwise clears. pendingRequests counts the requests sent to the editor and not yet answered, and queuedResources the files with writes waiting behind another write to the same file.",
+      answer: "projectIs, when present, is the gdharness version of the addons in the project, which differs from this server's (project_info says which of the two to move), and configIs, when present, the version the project's MCP config starts, which differs from this server's, so the next connection runs that one. server names this server: its pid, its version, and lifecycleLog, the file every gdharness server of the user appends a line to when it starts, when its client first names itself, when it replaces another server of its project, and when it ends, with why it ended (the client closing its end as stdin:end, a signal by name, superseded with the successor's pid, an uncaught exception or rejection with its stack, or the exit code) and the calls it was answering then. The parent's command line follows on its own line a few seconds after the start. A server killed without warning writes no ended line, and on Windows every kill is that, so a started line with no ended line after it is a server something killed. " + "runtimeConnected counts the games of the project this server serves, and runtimes lists every game on the machine with ofThisProject saying which is which, since a game of another project is reached only by naming its projectPath. playingInEditor is null when the editor was not asked or did not answer, which is not the same as a no: with no editor connected there is nobody to ask, and an editor that does not serve the question is given a moment and then left. A game can be playing while this is null, so read it as unanswered rather than as nothing playing, and use processActive and runtimes, which come from elsewhere and do not depend on the editor answering. Its play says which play the editor is on: play.play counts the plays that editor has started since it opened, whoever started them, and play.editorPid is the editor, so two reads with different pairs are two plays even when both say playing. game.run names the run processActive is about, the one editor_output and editor_run stop answer for: its pid, its project, and adopted true when this server read it back from another server rather than starting it. It stays named after the run ends, beside processActive false, so editor_output can still read what that run printed; null when there is no run at all. startedAt says when it began, and endedAt when it ended, wherever something saw the end: a run adopted from a note another server wrote can have ended hours before this server started. editor.lspListening and editor.dapListening say whether anything accepts connections on the ports the editor names, lspPort and dapPort: Godot binds each once, as the editor starts, and reports a failure only in the log panel of the editor itself, so a false comes with serversNote, and editor_launch restart binds it again. editor.scan says whether the editor is scanning or importing and how many milliseconds ago its last scan finished (finishedMsAgo), or is null when it did not answer: the editor rewrites the class cache just after a scan, and editor_run waits that out before starting a game, saying so under waitedForEditorScanMs. Each game under runtimes is pinged with a short wait, so one held at a breakpoint is listed as unreachable rather than making this call wait out the runtime timeout; for the run this server is reporting on, heldAt says whether that is what it is, with the same three answers editor_output gives. A game the editor played announces the editor under editorPid, and so does whatever that game started for itself; a game some other server started announces none, which is how the two are told apart when both are running from one project. Each game also says which runtime addon it loaded, under addonVersion (null when it cannot say); addonIsStale is true when that code is not what this server ships, and staleNote says whether the project needs the gdharness upgrade command, spelled out to run in a shell, the game a restart, or this server a reconnect. A second checkout of a project, such as a git worktree, carries addons of its own and is where this shows. A runtime_* call to such a game is refused with the staleNote and not sent. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means \"not reached yet\" as often as it means \"no editor\". True is worth waiting out; false is an editor that is not there. False beside editorCannotConnect is a project without the gdharness editor addon installed or enabled, where no editor can ever dial in, however young the server or whichever editor is open; its remedies say how to install or enable it. False beside restartInterrupted is one that an editor_launch restart on a previous server asked to quit, where the launch half never ran because that server was ended in between, usually by the reconnect the restart was taken for; editor_launch open finishes it. True beside restartUnderway is a restart still in progress, its server alive and within the wait for the old editor to go: the editor is coming, and opening another would put two on one project. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. Any editor of this project running and not yet connected, whoever opened it, makes it true as well and is named under editorsNotYetConnected with its pid and start time, so a restart a reconnect interrupted after its launch is not read as nothing being there. settingsDropped appears here once when the editor this server opened saved project.godot on its way in and took a key out of it, which is the same reading editor_launch restart makes in its own answer. A game that has announced itself in a protocol this server does not speak is listed under unreadable rather than left out, with the protocol it speaks and whether the server or the addon is the older half. This happens during an upgrade that moves the runtime protocol, which most do not: installing replaces the addon on disk as soon as the pin moves, while a server that is already running stays on the version it started with, so the two speak different protocols until the server is reconnected. Those games are real and running, but no tool here can reach them until the halves match, so runtimes stays empty and runtimeConnected stays false. An upgrade that leaves the protocol alone opens no such window and this list stays empty through it. addonIsStale is decided by the code of the editor addons rather than their version, so an editor started before an upgrade that left that code alone reports the older addonVersion, is not stale, and addonNote says so: it needs no restart. A stale editor is asked nothing but to quit: every other call to it is refused with staleNote, which names editor_launch restart, the upgrade command or a reconnect. port is the one the editor bridge is on; when that is not the one this server was configured with, portWanted names the configured one and portNote says why it moved and, when it was the server this one replaced, which pid kept it. A server replacing another of its project that holds the configured port waits for it to stand down and takes the port over, which takes a few seconds; bridgeHandover says so while it waits, and it moves only if that server has not let go within the wait. An editor that has connected and not yet greeted, which lasts a frame and longer while it imports, reports nothing about itself: greeting says so, addonIsStale is absent rather than guessed, and a restart asked then waits for the greeting to learn who opened it. startedByAnEditor is an editor another editor started, by Godot's own restart or the project manager, which has none of the arguments a server gave the one before it; startedByAnEditorNote says what that costs. An engine run that loads the editor addon to do one job and quit, such as a gate's godot --headless --import, an export or a script, is not taken as the editor: a process that greets without a server's mark has its command line read first, and from the socket opening until its greeting and that read are done, identifying is true and connected false; one started with such an option is turned away, and turnedAway names the last one, its pid and the option. Every other call made while an editor is arriving, before its greeting or while it is looked up, waits up to ten seconds for it to settle rather than acting on connected as it reads in that window. serverVersion is the gdharness version of this server. bridgeAvailable says the editor bridge is listening; when it failed to start, startupError gives the error, and retryingBridge is true while this server tries again. announcedAt is the file where this server told editors of its project which port to dial. connectedAt is when the editor connected, and lastPongAt when it last answered this server's keep-alive ping. addonDigest is a hash of the editor addon's code, which addonIsStale compares with what this server ships. debugPort is the port of the editor's remote debugger, the one games it plays connect to. openedByAServer says a gdharness server started this editor, and syncsBreakpoints that it keeps its breakpoints when a debug session opens, which Godot otherwise clears. pendingRequests counts the requests sent to the editor and not yet answered, and queuedResources the files with writes waiting behind another write to the same file.",
       parameters: {},
       requires: []
     },
@@ -13241,7 +13271,7 @@ var init_tool_definitions = __esm(() => {
         },
         listMembers: {
           type: "boolean",
-          description: "With reloadScript: also answer the whole member lists, heldBeforeReload and reloadedMethods for the methods, heldConstantsBeforeReload and reloadedConstants for the constants. Default false: a script holding hundreds of constants answers hundreds of lines twice to say what one reload added."
+          description: "With reloadScript: also answer the whole member lists, heldBeforeReload and reloadedMethods for the methods, heldConstantsBeforeReload and reloadedConstants for the constants, each with what the script inherits from the scripts it extends. Default false: a script holding hundreds of constants answers hundreds of lines twice to say what one reload added."
         }
       },
       requires: ["projectPath"]
@@ -13285,7 +13315,7 @@ var init_tool_definitions = __esm(() => {
         includeInherited: {
           type: "boolean",
           ops: ["info"],
-          description: "info: include inherited members. Default false."
+          description: "info: also name every member the class inherits, under inherited: one entry per ancestor, nearest first, with the names of the methods, properties, signals and enums it declares. The class's own members stay in full; member reads any inherited one in full. Default false."
         },
         member: {
           type: "string",
@@ -13423,7 +13453,7 @@ var init_tool_definitions = __esm(() => {
     {
       name: "runtime_invoke",
       title: "Set or call in the running game",
-      description: "Sets a property or calls a method on a node, or on one of the engine singletons nodePath names, in the running game. Needs the game running with the runtime addon. The answer carries elapsed_usec, how long the call or the write took inside the game, measured around it there: the round trip to the game is a second or more, so timing from outside measures that instead. Errors the engine reported while a called method ran come back under errors and warnings under warnings, the first 20 of each, with errors_not_shown and warnings_not_shown counting the rest. A call that takes longer than timeoutMs is not cancelled: the answer is pending: true with a requestId, the call goes on and does everything it was asked, and op result with that requestId collects its reply once it comes.",
+      description: "Sets a property or calls a method on a node, or on one of the engine singletons nodePath names, in the running game. Needs the game running with the runtime addon. The answer carries elapsed_usec, how long the call or the write took inside the game, measured around it there: the round trip to the game is a second or more, so timing from outside measures that instead. A method that awaits is answered with the value it returns once it ends, and awaited true; elapsed_usec then runs to its end, and one that outlasts timeout is collected with op result. Errors the engine reported while a called method ran come back under errors and warnings under warnings, the first 20 of each, with errors_not_shown and warnings_not_shown counting the rest. A call that takes longer than timeoutMs is not cancelled: the answer is pending: true with a requestId, the call goes on and does everything it was asked, and op result with that requestId collects its reply once it comes.",
       parameters: {
         projectPath: RUNNING_PROJECT_PATH,
         pid: RUNNING_PID,
@@ -13440,7 +13470,7 @@ var init_tool_definitions = __esm(() => {
         value: {
           ops: ["set"],
           blank: true,
-          description: `set: the value, fitted to the property's type. ${WHOLE_NUMBERS} A number the property would have to cut is refused rather than truncated: a fraction into an int, a number other than 0 or 1 into a bool. A vector, colour or the like may be written as its fields, {"x": 140, "y": 300}, or tagged, {"_type": "Vector2", "x": 140, "y": 300}, which is the form a read answers with, and one carrying a field its type has not, such as a z for a Vector2, is refused naming it. A colour may also be given as its html code, "#ff8000" or "#ff800080". "" writes an empty string. A property typed as or holding an object takes a path naming one the game holds, the way call's args do, and holds that instance, or null, which the text null also means, to empty it. One declared as Variant or untyped takes anything, as the engine does: a value of the kind it holds is fitted to it, an int staying an int, and any other is stored as sent, a fraction into one holding an int included. A typed list or map, such as Array[int] or Dictionary[String, int], takes a JSON list or object with each element fitted to its element type, and an element that cannot become one is refused by its index or key, as is an object of another script than the one the list holds, whether or not that script has a class_name.`
+          description: `set: the value, fitted to the property's type. ${WHOLE_NUMBERS} A number the property would have to cut is refused rather than truncated: a fraction into an int, a number other than 0 or 1 into a bool. A vector, colour or the like may be written as its fields, {"x": 140, "y": 300}, or tagged, {"_type": "Vector2", "x": 140, "y": 300}, which is the form a read answers with, and one carrying a field its type has not, such as a z for a Vector2, is refused naming it. A colour may also be given as its html code, "#ff8000" or "#ff800080". Text is written as sent: the JSON string "" writes an empty string, and quote marks inside the string are written into the text. An enum property takes the name of a value as well as its number, as the script or the inspector spells it, and a name none of its values has is refused listing them. A number past the range a property is exported with, or one none of its enum values has, is written, as the engine writes it, and the answer says so under outside_declared. A property typed as or holding an object takes a path naming one the game holds, the way call's args do, and holds that instance, or null, which the text null also means, to empty it. One declared as Variant or untyped takes anything, as the engine does: a value of the kind it holds is fitted to it, an int staying an int, and any other is stored as sent, a fraction into one holding an int included. A typed list or map, such as Array[int] or Dictionary[String, int], takes a JSON list or object with each element fitted to its element type, and an element that cannot become one is refused by its index or key, as is an object of another script than the one the list holds, whether or not that script has a class_name.`
         },
         method: {
           type: "string",
@@ -13544,7 +13574,7 @@ var init_tool_definitions = __esm(() => {
       name: "runtime_input",
       title: "Send input to the game",
       description: "Input to the running game: a whole click on a Control or a 3D node named by path or on a control named by the words on it, an item chosen out of a menu, typing into whatever has the focus, or a raw action, key, mouse button, mouse motion or drag. All of it works headless, where the viewport is the project's window size and the GUI only takes what is inside it. On gdharness's own desktop, where a windowed run goes, Windows refuses to say where the pointer is: every pointer answer there carries pointer_on_hidden_desktop, and the first of the run pointer_note saying why it matters: get_mouse_position() on the root window, and the mouse positions derived from it, read a meaningless position, while what reads the event itself (the control under it, hover, tooltips, input handlers) gets the injected position. A native window no real pointer has entered gets no hover from Godot, so the runtime supplies it there and the answers say hover_supplied.",
-      answer: `click: what was under the pointer, and what became of the control: in_tree, removed or freed. Named by says, found says which match it was, its index being the index argument that presses the same match again, found.item names the tab, list entry, tree row or menu bar title pressed (kind; index, the item's own number in its control, which is not found.index; says; and for a row the column of the cell saying the words), and found.pressedOn says "the words" for words in a RichTextLabel pressed where they are drawn, or "the middle of the label" with a note saying why they could not be placed; on a rich label link_pressed says whether the press reached a link, with link_meta giving the meta the label reports clicked, an empty one included. A control scrolled into view first is scrolled each container out from it a frame after the one inside, and scrolled_into_view says whether a scroll value changed. A button in toggle mode, a CheckBox or CheckButton included, answers pressed with before and after, its button_pressed either side of the click: the same value twice is a click the game undid, and after is null when the click freed it. A refusal for a pointer turned off names where mouse_behavior_recursive was set. On a 3D node landed says the interface did not swallow the press: no control under the pointer stopped it, a control letting the pointer pass included, and every viewport on the way out from the room had the pointer over what shows the room. choose: what was chosen, read before the press, which is heard rather than assumed; what became of the control named (in_tree, removed or freed, since a game can rebuild its screen on the pick); and what the button in front of the menu shows now when it is still there. A menu is opened rather than clicked because its items are drawn rather than built, and the item is looked for as the menu stands once open, since a game can fill a menu as it opens. action, key, mouse_click and joypad_button: the event as it was sent, with whole saying whether the press was let go of again, for a key the keycode, physical_keycode and unicode it carried, and for a controller button its number, its name and the device. mouse_motion: the position and the relative movement sent. mouse_drag: from, to, motions sent and relative_total. joypad_motion: the axis by number and name, the value and the device. None of these is aimed at anything, so none says what the event reached: click on a nodePath or says answers what was under the pointer.`,
+      answer: `click: what was under the pointer, and what became of the control: in_tree, removed or freed. Named by says, found says which match it was, its index being the index argument that presses the same match again, found.item names the tab, list entry, tree row or menu bar title pressed (kind; index, the item's own number in its control, which is not found.index; says; and for a row the column of the cell saying the words), and found.pressedOn says "the words" for words in a RichTextLabel pressed where they are drawn, or "the middle of the label" with a note saying why they could not be placed; on a rich label link_pressed says whether the press reached a link, with link_meta giving the meta the label reports clicked, an empty one included. A control scrolled into view first is scrolled each container out from it a frame after the one inside, and scrolled_into_view says whether a scroll value changed. A button in toggle mode, a CheckBox or CheckButton included, answers pressed with before and after, its button_pressed either side of the click: the same value twice is a click the game undid, and after is null when the click freed it. A refusal for a pointer turned off names where mouse_behavior_recursive was set. On a 3D node landed says the interface did not swallow the press: no control under the pointer stopped it, a control letting the pointer pass included, and every viewport on the way out from the room had the pointer over what shows the room. choose: what was chosen, read before the press, which is heard rather than assumed; what became of the control named (in_tree, removed or freed, since a game can rebuild its screen on the pick); and what the button in front of the menu shows now when it is still there. A menu is opened rather than clicked because its items are drawn rather than built, and the item is looked for as the menu stands once open, since a game can fill a menu as it opens. action, key, mouse_click and joypad_button: the event as it was sent, with whole saying whether the press was let go of again and pressed whether it is left held down (true only after pressed true), for a key the keycode, physical_keycode and unicode it carried, and for a controller button its number, its name and the device. mouse_motion: the position and the relative movement sent. mouse_drag: from, to, motions sent and relative_total. joypad_motion: the axis by number and name, the value and the device. None of these is aimed at anything, so none says what the event reached: click on a nodePath or says answers what was under the pointer. A mouse_click, mouse_motion or mouse_drag with a point outside the window's viewport says so under outside_viewport, with the viewport's rectangle, since no control there receives it.`,
       parameters: {
         projectPath: RUNNING_PROJECT_PATH,
         pid: RUNNING_PID,
@@ -13757,7 +13787,7 @@ var init_tool_definitions = __esm(() => {
         },
         value: {
           ops: ["until"],
-          description: "until: the value to wait for, fitted to the property's type and compared at the precision the property keeps, so -1.1 meets a 32-bit float holding -1.10000002. A value the property would have to cut is refused: a fraction on a whole number, a number other than 0 or 1 on a bool. On a property holding an object, whether declared to or untyped and holding one or null, the text null means null. One declared to hold an object refuses any value other than null, since it can never hold it."
+          description: "until: the value to wait for, fitted to the property's type and compared at the precision the property keeps, so -1.1 meets a 32-bit float holding -1.10000002. A value the property would have to cut is refused: a fraction on a whole number, a number other than 0 or 1 on a bool. An enum property is waited for by the name of a value as well as its number, as set takes it. On a property holding an object, whether declared to or untyped and holding one or null, the text null means null. One declared to hold an object refuses any value other than null, since it can never hold it."
         },
         compare: {
           type: "string",
@@ -13806,16 +13836,21 @@ var init_tool_definitions = __esm(() => {
     {
       name: "debug_breakpoint",
       title: "Breakpoints",
-      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.",
+      description: "Sets, removes or lists breakpoints. 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 line, and with no editor connected answers removed false, saying why, when none was held there. 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,
-        line: { type: "integer", minimum: 1, description: "One-based line." }
+        scriptPath: { ...SCRIPT_PATH, ops: ["set", "remove"] },
+        line: { type: "integer", minimum: 1, ops: ["set", "remove"], description: "One-based line." }
       },
-      requires: ["projectPath", "scriptPath", "line"],
+      requires: ["projectPath"],
       operations: {
-        set: { effect: "additive", summary: "set a breakpoint", requires: [] },
-        remove: { effect: "destructive", summary: "remove a breakpoint", requires: [] }
+        set: { effect: "additive", summary: "set a breakpoint", requires: ["scriptPath", "line"] },
+        remove: { effect: "destructive", summary: "remove a breakpoint", requires: ["scriptPath", "line"] },
+        list: {
+          effect: "read",
+          summary: "the breakpoints held here under held, and with the editor connected the ones set in its gutter under setInEditor",
+          requires: []
+        }
       }
     },
     {
@@ -35636,12 +35671,12 @@ var init_stdio = __esm(() => {
 
 // src/autoload-failure.ts
 import { existsSync as existsSync15, readFileSync as readFileSync13 } from "node:fs";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 function scriptsAutoloaded(projectPath) {
   const scripts = new Map;
   let settings;
   try {
-    settings = parseProjectGodot(readFileSync13(join17(projectPath, "project.godot"), "utf8"));
+    settings = parseProjectGodot(readFileSync13(join18(projectPath, "project.godot"), "utf8"));
   } catch {
     return scripts;
   }
@@ -35650,7 +35685,7 @@ function scriptsAutoloaded(projectPath) {
       scripts.set(`res://${path}`, name);
       continue;
     }
-    const scene = join17(projectPath, path);
+    const scene = join18(projectPath, path);
     if (!existsSync15(scene)) {
       continue;
     }
@@ -35677,7 +35712,7 @@ var init_autoload_failure = __esm(() => {
 import { existsSync as existsSync16, readdirSync as readdirSync10, readFileSync as readFileSync14, statSync as statSync8, unlinkSync as unlinkSync2 } from "node:fs";
 import { createConnection } from "node:net";
 import { tmpdir as tmpdir4 } from "node:os";
-import { dirname as dirname10, join as join18, resolve as resolve4 } from "node:path";
+import { dirname as dirname11, join as join19, resolve as resolve4 } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 function runtimeDirectory(variables = process.env) {
   const explicit = envValue("GDHARNESS_RUNTIME_DIR", variables);
@@ -35685,19 +35720,19 @@ function runtimeDirectory(variables = process.env) {
     return explicit;
   }
   const perUser = envValue("XDG_RUNTIME_DIR", variables);
-  return join18(perUser ?? tmpdir4(), "gdharness");
+  return join19(perUser ?? tmpdir4(), "gdharness");
 }
 function runtimeDirectories(variables = process.env) {
   const candidates = [runtimeDirectory(variables)];
   const fallbacks = process.platform === "win32" ? [envValue("SystemRoot", variables) ?? envValue("windir", variables) ?? "C:\\Windows"] : ["/tmp", "/var/tmp"];
   for (const base of fallbacks) {
-    candidates.push(join18(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
+    candidates.push(join19(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
   }
   return [...new Set(candidates.map((path) => resolve4(path)))];
 }
 function errorReportOf(pid, directories = runtimeDirectories()) {
   for (const directory of directories) {
-    const path = join18(directory, `runtime-${pid}.log`);
+    const path = join19(directory, `runtime-${pid}.log`);
     if (existsSync16(path)) {
       return path;
     }
@@ -35851,14 +35886,14 @@ function announcedIn(directory) {
   for (const entry of readdirSync10(directory)) {
     const report = ERROR_REPORT_PATTERN.exec(entry);
     if (report) {
-      sweepErrorReport(join18(directory, entry), Number.parseInt(report[1] ?? "", 10));
+      sweepErrorReport(join19(directory, entry), Number.parseInt(report[1] ?? "", 10));
       continue;
     }
     const match = ANNOUNCEMENT_PATTERN.exec(entry);
     if (!match) {
       continue;
     }
-    const file = join18(directory, entry);
+    const file = join19(directory, entry);
     const pid = Number.parseInt(match[1] ?? "", 10);
     const running = alive(pid);
     entries.push({ file, pid, running });
@@ -35886,16 +35921,16 @@ function announcedIn(directory) {
     found.push(announced);
   }
   const held = new Set(entries.map((one) => one.file));
-  const here = join18(directory, ".");
+  const here = join19(directory, ".");
   for (const file of verdicts.keys()) {
-    if (dirname10(file) === here && !held.has(file)) {
+    if (dirname11(file) === here && !held.has(file)) {
       verdicts.delete(file);
     }
   }
   return found;
 }
 async function announcementEnded(pid, directories = runtimeDirectories()) {
-  const files = directories.map((directory) => join18(directory, `runtime-${pid}.json`)).filter((file) => existsSync16(file));
+  const files = directories.map((directory) => join19(directory, `runtime-${pid}.json`)).filter((file) => existsSync16(file));
   const first = files[0];
   if (first === undefined) {
     return;
@@ -35951,7 +35986,7 @@ function theOneProject(endpoints) {
   if (endpoints.some((endpoint) => endpoint.project.path === "")) {
     return;
   }
-  const paths = new Set(endpoints.map((endpoint) => realPathOr(resolve4(endpoint.project.path))));
+  const paths = new Set(endpoints.map((endpoint) => realAsFarAsItExists(resolve4(endpoint.project.path))));
   const only = [...paths][0];
   return paths.size === 1 ? only : undefined;
 }
@@ -36315,9 +36350,9 @@ var init_runtime_client = __esm(() => {
 
 // src/boot-note.ts
 import { mkdirSync as mkdirSync6, readFileSync as readFileSync15, writeFileSync as writeFileSync8 } from "node:fs";
-import { dirname as dirname11, join as join19 } from "node:path";
+import { dirname as dirname12, join as join20 } from "node:path";
 function bootNotePath(projectPath) {
-  return join19(projectPath, ".godot", "gdharness-boot.json");
+  return join20(projectPath, ".godot", "gdharness-boot.json");
 }
 function readScenes(projectPath) {
   try {
@@ -36337,7 +36372,7 @@ function readBootNote(projectPath, scene) {
 function writeBootNote(projectPath, scene, announcedAfterMs) {
   try {
     const path = bootNotePath(projectPath);
-    mkdirSync6(dirname11(path), { recursive: true });
+    mkdirSync6(dirname12(path), { recursive: true });
     const scenes = {
       ...readScenes(projectPath),
       [scene]: {
@@ -36364,14 +36399,14 @@ var init_boot_note = __esm(() => {
 
 // src/breakpoint-note.ts
 import { mkdirSync as mkdirSync7, readFileSync as readFileSync16, rmSync as rmSync7, writeFileSync as writeFileSync9 } from "node:fs";
-import { dirname as dirname12, isAbsolute as isAbsolute4, join as join20, relative as relative3 } from "node:path";
+import { dirname as dirname13, isAbsolute as isAbsolute4, join as join21, relative as relative3 } from "node:path";
 function breakpointNotePath(projectPath) {
-  return join20(projectPath, ".godot", "gdharness-breakpoints.json");
+  return join21(projectPath, ".godot", "gdharness-breakpoints.json");
 }
 function writeBreakpointNote(projectPath, held) {
   const path = breakpointNotePath(projectPath);
-  const root = realPathOr(projectPath);
-  const inside = held.map((one) => ({ scriptPath: realPathOr(one.scriptPath), lines: one.lines })).filter((one) => one.lines.length > 0 && withinProject(root, one.scriptPath));
+  const root = realAsFarAsItExists(projectPath);
+  const inside = held.map((one) => ({ scriptPath: realAsFarAsItExists(one.scriptPath), lines: one.lines })).filter((one) => one.lines.length > 0 && withinProject(root, one.scriptPath));
   try {
     if (inside.length === 0) {
       rmSync7(path, { force: true });
@@ -36383,7 +36418,7 @@ function writeBreakpointNote(projectPath, held) {
         lines: [...one.lines]
       }))
     };
-    mkdirSync7(dirname12(path), { recursive: true });
+    mkdirSync7(dirname13(path), { recursive: true });
     writeFileSync9(path, `${JSON.stringify(note, null, 2)}
 `, "utf8");
   } catch (error) {
@@ -36407,7 +36442,7 @@ function readBreakpointNote(projectPath) {
       }
       const lines = Array.isArray(listed) ? listed.filter((line) => Number.isInteger(line) && line > 0) : [];
       if (lines.length > 0) {
-        held.push({ scriptPath: realPathOr(join20(projectPath, script)), lines });
+        held.push({ scriptPath: realAsFarAsItExists(join21(projectPath, script)), lines });
       }
     }
     return held;
@@ -36457,9 +36492,9 @@ var init_whole_file = __esm(() => {
 
 // src/class-note.ts
 import { mkdirSync as mkdirSync8, readFileSync as readFileSync17 } from "node:fs";
-import { dirname as dirname13, join as join21 } from "node:path";
+import { dirname as dirname14, join as join22 } from "node:path";
 function classNotePath(projectPath) {
-  return join21(projectPath, ".godot", "gdharness-classes.json");
+  return join22(projectPath, ".godot", "gdharness-classes.json");
 }
 function readClassNote(projectPath) {
   try {
@@ -36493,7 +36528,7 @@ function unfinishedScanIn(value) {
 function writeClassNote(projectPath, note) {
   const path = classNotePath(projectPath);
   try {
-    mkdirSync8(dirname13(path), { recursive: true });
+    mkdirSync8(dirname14(path), { recursive: true });
   } catch {
     return;
   }
@@ -36506,9 +36541,9 @@ var init_class_note = __esm(() => {
 
 // src/config-pin.ts
 import { existsSync as existsSync17, readFileSync as readFileSync18 } from "node:fs";
-import { join as join22 } from "node:path";
+import { join as join23 } from "node:path";
 function versionsNamedInConfig(projectPath) {
-  const config = join22(projectPath, ".mcp.json");
+  const config = join23(projectPath, ".mcp.json");
   if (!existsSync17(config)) {
     return [];
   }
@@ -36536,14 +36571,14 @@ var init_config_pin = __esm(() => {
 
 // src/cut-test-run.ts
 import { existsSync as existsSync18, mkdirSync as mkdirSync9, readFileSync as readFileSync19, rmSync as rmSync9, writeFileSync as writeFileSync11 } from "node:fs";
-import { dirname as dirname14, join as join23 } from "node:path";
+import { dirname as dirname15, join as join24 } from "node:path";
 function keptAt(projectPath) {
-  return join23(projectPath, ".godot", "gdharness-reports", "cut-run.json");
+  return join24(projectPath, ".godot", "gdharness-reports", "cut-run.json");
 }
 function keepCutTestRun(projectPath, run) {
   const path = keptAt(projectPath);
   try {
-    mkdirSync9(dirname14(path), { recursive: true });
+    mkdirSync9(dirname15(path), { recursive: true });
     writeFileSync11(path, `${JSON.stringify(run, null, 2)}
 `, "utf8");
   } catch {}
@@ -37134,13 +37169,14 @@ class GodotDAPClient {
     const key = fileKey(scriptPath);
     const lines = this.breakpoints.get(key);
     if (lines === undefined) {
-      return;
+      return false;
     }
-    lines.delete(line);
+    const held = lines.delete(line);
     if (lines.size === 0) {
       this.breakpoints.delete(key);
       this.spelled.delete(key);
     }
+    return held;
   }
   holdBreakpoints(held) {
     for (const { scriptPath, lines } of held) {
@@ -37377,10 +37413,10 @@ import {
   writeSync
 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
-import { join as join24 } from "node:path";
+import { join as join25 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 function helperAssembly(directory = tmpdir5()) {
-  return join24(directory, `gdharness-desktop-${DIGEST}.dll`);
+  return join25(directory, `gdharness-desktop-${DIGEST}.dll`);
 }
 async function ensureHelperCompiled(directory = tmpdir5(), budgetMs = HELPER_COMPILE_MS, wait = true) {
   const assembly = helperAssembly(directory);
@@ -37420,8 +37456,8 @@ async function ensureHelperCompiled(directory = tmpdir5(), budgetMs = HELPER_COM
   return `the desktop helper was not compiled within ${String(budgetMs)} ms`;
 }
 async function compileHelper(directory, assembly, budgetMs) {
-  const scratch = mkdtempSync2(join24(directory, "gdharness-desktop-source-"));
-  const source = join24(scratch, "helper.cs");
+  const scratch = mkdtempSync2(join25(directory, "gdharness-desktop-source-"));
+  const source = join25(scratch, "helper.cs");
   writeFileSync12(source, SOURCE, "utf8");
   const literal = (path) => `'${path.replaceAll("'", "''")}'`;
   const script = [
@@ -37635,12 +37671,12 @@ import {
   statSync as statSync10,
   writeFileSync as writeFileSync13
 } from "node:fs";
-import { dirname as dirname15, join as join25 } from "node:path";
+import { dirname as dirname16, join as join26 } from "node:path";
 function editorLogPath(projectPath) {
-  return join25(projectPath, ".godot", "gdharness-editor.log");
+  return join26(projectPath, ".godot", "gdharness-editor.log");
 }
 function editorLogNotePath(projectPath) {
-  return join25(projectPath, ".godot", "gdharness-editor.json");
+  return join26(projectPath, ".godot", "gdharness-editor.json");
 }
 function readEditorLogNote(projectPath) {
   try {
@@ -37655,7 +37691,7 @@ function readEditorLogNote(projectPath) {
 function clearEditorLog(projectPath) {
   try {
     const path = editorLogPath(projectPath);
-    mkdirSync10(dirname15(path), { recursive: true });
+    mkdirSync10(dirname16(path), { recursive: true });
     rmSync11(path, { force: true });
     rmSync11(editorLogNotePath(projectPath), { force: true });
   } catch {}
@@ -37663,7 +37699,7 @@ function clearEditorLog(projectPath) {
 function writeEditorLogNote(projectPath, pid) {
   try {
     const path = editorLogNotePath(projectPath);
-    mkdirSync10(dirname15(path), { recursive: true });
+    mkdirSync10(dirname16(path), { recursive: true });
     writeFileSync13(path, JSON.stringify({ pid, startedAt: new Date().toISOString() }, null, 2), "utf8");
   } catch {}
 }
@@ -37905,7 +37941,7 @@ var init_editor_log = __esm(() => {
 
 // src/rename.ts
 import { existsSync as existsSync21, mkdirSync as mkdirSync11, readFileSync as readFileSync22, renameSync as renameSync3, unlinkSync as unlinkSync3, writeFileSync as writeFileSync14 } from "node:fs";
-import { dirname as dirname16, posix as posix2 } from "node:path";
+import { dirname as dirname17, posix as posix2 } from "node:path";
 
 class Script {
   path;
@@ -38620,7 +38656,7 @@ function applyRewrites(rewrites) {
   const done = [];
   try {
     for (const rewrite of rewrites) {
-      mkdirSync11(dirname16(rewrite.writeTo), { recursive: true });
+      mkdirSync11(dirname17(rewrite.writeTo), { recursive: true });
       const staging = `${rewrite.writeTo}.gdharness-rename`;
       writeFileSync14(staging, rewrite.after, "utf8");
       renameSync3(staging, rewrite.writeTo);
@@ -38673,10 +38709,10 @@ var init_rename = __esm(() => {
 });
 
 // src/lsp_client.ts
-import { existsSync as existsSync22, realpathSync as realpathSync4 } from "node:fs";
+import { existsSync as existsSync22, realpathSync as realpathSync3 } from "node:fs";
 import { readFile, realpath } from "node:fs/promises";
 import { createConnection as createConnection3 } from "node:net";
-import { dirname as dirname17, join as join26, resolve as resolve5 } from "node:path";
+import { dirname as dirname18, join as join27, resolve as resolve5 } from "node:path";
 import { setTimeout as delay4 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
 function initializeTimeoutMs() {
@@ -38694,7 +38730,7 @@ function diagnosticsKey(uri) {
     return decoded;
   }
   try {
-    return realpathSync4.native(fileURLToPath3(decoded)).toLowerCase();
+    return realpathSync3.native(fileURLToPath3(decoded)).toLowerCase();
   } catch {
     return decoded.toLowerCase();
   }
@@ -38838,7 +38874,7 @@ class GodotLSPClient {
     if (this.initialized) {
       return;
     }
-    const rootPath = this.rootPath ?? dirname17(resolve5(filePath));
+    const rootPath = this.rootPath ?? dirname18(resolve5(filePath));
     await this.initialize(rootPath);
   }
   async sendRequest(method, params, timeoutMs = this.timeouts.requestMs) {
@@ -39354,7 +39390,7 @@ async function resolveLSPPaths(projectPathValue, scriptPathValue) {
   } catch {
     throw new ArgumentRefusal(`Project path does not exist: ${requestedProjectPath}`);
   }
-  if (!existsSync22(join26(projectPath, "project.godot"))) {
+  if (!existsSync22(join27(projectPath, "project.godot"))) {
     throw new ArgumentRefusal(`Not a Godot project: ${projectPath}. Point projectPath at the directory holding project.godot.`);
   }
   const contained = resolveWithinProject(projectPath, scriptPathValue);
@@ -39514,8 +39550,8 @@ var init_lsp_client = __esm(() => {
 });
 
 // src/rename-symbol.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync12, readdirSync as readdirSync11, realpathSync as realpathSync5, rmSync as rmSync12, writeFileSync as writeFileSync15 } from "node:fs";
-import { basename as basename7, dirname as dirname18, join as join27, relative as relative4, resolve as resolve6 } from "node:path";
+import { existsSync as existsSync23, mkdirSync as mkdirSync12, readdirSync as readdirSync11, realpathSync as realpathSync4, rmSync as rmSync12, writeFileSync as writeFileSync15 } from "node:fs";
+import { basename as basename8, dirname as dirname19, join as join28, relative as relative4, resolve as resolve6 } from "node:path";
 function resourcePathOf(projectPath, absolute) {
   const inside = relative4(onDiskSpelling(projectPath), onDiskSpelling(absolute));
   if (inside === "" || inside.startsWith("..") || /^[A-Za-z]:/.test(inside)) {
@@ -39528,13 +39564,13 @@ function onDiskSpelling(path) {
   let at = resolve6(path);
   for (;; ) {
     try {
-      return join27(realpathSync5.native(at), ...missing.reverse());
+      return join28(realpathSync4.native(at), ...missing.reverse());
     } catch {
-      const parent = dirname18(at);
+      const parent = dirname19(at);
       if (parent === at) {
         return resolve6(path);
       }
-      missing.push(basename7(at));
+      missing.push(basename8(at));
       at = parent;
     }
   }
@@ -39957,15 +39993,15 @@ ${mention.kind}`;
   };
 }
 function writeLeftAloneDetail(projectPath, symbol, detail) {
-  const directory = join27(projectPath, ".godot", "gdharness-renames");
+  const directory = join28(projectPath, ".godot", "gdharness-renames");
   mkdirSync12(directory, { recursive: true });
   detailWrites += 1;
-  const path = join27(directory, `${String(Date.now())}-${String(detailWrites).padStart(6, "0")}-${String(process.pid)}-${symbol}.json`);
+  const path = join28(directory, `${String(Date.now())}-${String(detailWrites).padStart(6, "0")}-${String(process.pid)}-${symbol}.json`);
   writeFileSync15(path, `${JSON.stringify(detail, null, 2)}
 `, "utf8");
   const kept = readdirSync11(directory).filter((name) => name.endsWith(".json")).sort().reverse();
   for (const old of kept.slice(10)) {
-    rmSync12(join27(directory, old), { force: true });
+    rmSync12(join28(directory, old), { force: true });
   }
   return path;
 }
@@ -40014,10 +40050,10 @@ import {
   statSync as statSync11,
   writeFileSync as writeFileSync16
 } from "node:fs";
-import { basename as basename8, dirname as dirname19, extname as extname3, join as join28, relative as relative5 } from "node:path";
+import { basename as basename9, dirname as dirname20, extname as extname3, join as join29, relative as relative5 } from "node:path";
 function filesUnder(directory) {
   return readdirSync12(directory, { withFileTypes: true }).flatMap((entry) => {
-    const path = join28(directory, entry.name);
+    const path = join29(directory, entry.name);
     return entry.isDirectory() ? filesUnder(path) : [path];
   });
 }
@@ -40038,8 +40074,8 @@ function unseenByTheEngine(projectPath, path) {
       return `${path} is under ${step}, and the engine passes over every directory whose name starts with a dot`;
     }
     if (at < steps.length - 1) {
-      directory = join28(directory, step);
-      if (existsSync24(join28(directory, ".gdignore"))) {
+      directory = join29(directory, step);
+      if (existsSync24(join29(directory, ".gdignore"))) {
         return `${path} is under a directory holding a .gdignore, which the engine does not load`;
       }
     }
@@ -40051,12 +40087,12 @@ function installedAddonOf(projectPath, path) {
   if (steps[0] !== "addons" || steps[1] === undefined) {
     return null;
   }
-  return existsSync24(join28(projectPath, "addons", steps[1], VERSION_MARKER)) ? `res://addons/${steps[1]}` : null;
+  return existsSync24(join29(projectPath, "addons", steps[1], VERSION_MARKER)) ? `res://addons/${steps[1]}` : null;
 }
 function binaryResources(projectPath) {
   const found = [];
   const visit = (directory, prefix) => {
-    if (existsSync24(join28(directory, ".gdignore"))) {
+    if (existsSync24(join29(directory, ".gdignore"))) {
       return;
     }
     for (const entry of readdirSync12(directory, { withFileTypes: true })) {
@@ -40065,7 +40101,7 @@ function binaryResources(projectPath) {
       }
       const path = `${prefix}${entry.name}`;
       if (entry.isDirectory()) {
-        visit(join28(directory, entry.name), `${path}/`);
+        visit(join29(directory, entry.name), `${path}/`);
       } else if (/\.(scn|res)$/i.test(entry.name)) {
         found.push(path);
       }
@@ -40075,7 +40111,7 @@ function binaryResources(projectPath) {
   return found;
 }
 function targetPathOf(projectPath, absolute) {
-  const inside = relative5(onDiskSpelling(projectPath), join28(onDiskSpelling(dirname19(absolute)), basename8(absolute)));
+  const inside = relative5(onDiskSpelling(projectPath), join29(onDiskSpelling(dirname20(absolute)), basename9(absolute)));
   if (inside === "" || inside.startsWith("..") || /^[A-Za-z]:/.test(inside)) {
     return null;
   }
@@ -40130,7 +40166,7 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
     return { ok: false, reason: `${unseen}, so nothing there could load what was moved.` };
   }
   if (!isDirectory) {
-    const owner = SIDECARS.map((sidecar) => from.endsWith(sidecar) ? from.slice(0, -sidecar.length) : null).find((path) => path !== null && existsSync24(join28(projectPath, path.slice("res://".length))));
+    const owner = SIDECARS.map((sidecar) => from.endsWith(sidecar) ? from.slice(0, -sidecar.length) : null).find((path) => path !== null && existsSync24(join29(projectPath, path.slice("res://".length))));
     if (owner !== undefined && owner !== null) {
       return { ok: false, reason: `${from} belongs to ${owner} and moves with it: move ${owner} instead.` };
     }
@@ -40164,12 +40200,12 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
     scripts,
     moves,
     named: [from],
-    exists: (path) => existsSync24(join28(projectPath, path.slice("res://".length)))
+    exists: (path) => existsSync24(join29(projectPath, path.slice("res://".length)))
   }, { edits: [], mentions: [] });
   plan = mentionIgnored(plan, ignoredTexts(projectPath), null, [from]);
   const binaries = [];
   for (const path of binaryResources(projectPath)) {
-    const bytes = readFileSync23(join28(projectPath, path.slice("res://".length)));
+    const bytes = readFileSync23(join29(projectPath, path.slice("res://".length)));
     const names = [...moves.keys()].find((moving) => bytes.includes(moving));
     if (names !== undefined) {
       binaries.push({
@@ -40188,7 +40224,7 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
   }));
   const left = leftAloneReport(mentions);
   const rewrites = rewritesOf(plan, texts, null);
-  const absoluteOf = (path) => join28(projectPath, path.slice("res://".length));
+  const absoluteOf = (path) => join29(projectPath, path.slice("res://".length));
   const rewritten = new Map(rewrites.map((rewrite) => [rewrite.path, rewrite]));
   const moved = [...moves].map(([source, target]) => {
     const rewrite = rewritten.get(source);
@@ -40247,7 +40283,7 @@ function applyFileMove(outcome) {
   }
   const undo = [];
   const rename = (source, target) => {
-    mkdirSync13(dirname19(target), { recursive: true });
+    mkdirSync13(dirname20(target), { recursive: true });
     renameSync4(source, target);
     undo.push(() => {
       renameSync4(target, source);
@@ -43256,10 +43292,7 @@ function mayYetConnect(listeningSince, now = Date.now()) {
   return listeningSince === undefined || now - listeningSince.getTime() < CONNECT_WINDOW_MS;
 }
 function theEditorHasComeBack(status, startedAt) {
-  return hasSaidWhoItIs(status) && (status.connectedAt?.getTime() ?? 0) > startedAt;
-}
-function hasSaidWhoItIs(status) {
-  return status.connected && status.addonVersion !== undefined;
+  return status.connected && (status.connectedAt?.getTime() ?? 0) > startedAt;
 }
 function withoutTrailingSeparator(path) {
   if (path.length <= 1 || !/[\\/]$/.test(path) || /^[A-Za-z]:[\\/]$/.test(path)) {
@@ -43449,7 +43482,8 @@ var init_godot_bridge = __esm(() => {
       this.log("info", "WebSocket bridge stopped");
     }
     isConnected() {
-      return this.socket?.readyState === import_websocket.default.OPEN && this.connectionInfo?.identifying !== true;
+      const info = this.connectionInfo;
+      return this.socket?.readyState === import_websocket.default.OPEN && info?.greeted === true && info.identifying !== true;
     }
     isArriving() {
       const info = this.connectionInfo;
@@ -43459,7 +43493,7 @@ var init_godot_bridge = __esm(() => {
       return [...this.pendingRequests.values()].filter((pending) => pending.counted).map((pending) => ({ tool: pending.toolName, startedAt: pending.startedAt })).sort((a, b) => a.startedAt - b.startedAt);
     }
     getStatus() {
-      const identifying = this.connectionInfo?.identifying === true;
+      const identifying = this.isArriving();
       const editor = identifying ? null : this.connectionInfo;
       return {
         host: this.host,
@@ -43731,7 +43765,7 @@ var init_godot_bridge = __esm(() => {
     startKeepalive() {
       this.stopKeepalive();
       this.pingInterval = setInterval(() => {
-        if (!this.isConnected()) {
+        if (this.socket?.readyState !== import_websocket.default.OPEN) {
           return;
         }
         try {
@@ -43741,6 +43775,7 @@ var init_godot_bridge = __esm(() => {
           this.log("warn", `Failed to send ping: ${errorMessage(error)}`);
         }
       }, KEEPALIVE_INTERVAL_MS);
+      this.pingInterval.unref();
     }
     stopKeepalive() {
       if (!this.pingInterval) {
@@ -43912,7 +43947,7 @@ var init_godot_bridge = __esm(() => {
 // src/import-freshness.ts
 import { createHash as createHash5 } from "node:crypto";
 import { existsSync as existsSync25, readdirSync as readdirSync13, readFileSync as readFileSync24, statSync as statSync12 } from "node:fs";
-import { join as join29 } from "node:path";
+import { join as join30 } from "node:path";
 function md5Of(file) {
   let stats;
   try {
@@ -43956,7 +43991,7 @@ function listed2(value) {
   return [...(value ?? "").matchAll(/"((?:[^"\\]|\\.)*)"/g)].map((match) => match[1] ?? "");
 }
 function onDisk(projectPath, resPath) {
-  return join29(projectPath, resPath.slice("res://".length));
+  return join30(projectPath, resPath.slice("res://".length));
 }
 function behind(projectPath, resPath, sidecar) {
   const remap = sectionOf(sidecar, "remap");
@@ -43969,7 +44004,7 @@ function behind(projectPath, resPath, sidecar) {
     return "its imported output is not on disk";
   }
   const name = resPath.slice(resPath.lastIndexOf("/") + 1);
-  const record = join29(projectPath, ".godot", "imported", `${name}-${createHash5("md5").update(resPath, "utf8").digest("hex")}.md5`);
+  const record = join30(projectPath, ".godot", "imported", `${name}-${createHash5("md5").update(resPath, "utf8").digest("hex")}.md5`);
   let recorded = "";
   try {
     recorded = /^source_md5="([0-9a-f]*)"/m.exec(readFileSync24(record, "utf8"))?.[1] ?? "";
@@ -43985,7 +44020,7 @@ function behind(projectPath, resPath, sidecar) {
 function staleImports(projectPath) {
   const stale = [];
   const visit = (directory, resDirectory) => {
-    if (existsSync25(join29(directory, ".gdignore")) || existsSync25(join29(directory, VERSION_MARKER))) {
+    if (existsSync25(join30(directory, ".gdignore")) || existsSync25(join30(directory, VERSION_MARKER))) {
       return;
     }
     let entries;
@@ -44001,7 +44036,7 @@ function staleImports(projectPath) {
       }
       const resPath = `${resDirectory}${entry.name}`;
       if (entry.isDirectory()) {
-        visit(join29(directory, entry.name), `${resPath}/`);
+        visit(join30(directory, entry.name), `${resPath}/`);
         continue;
       }
       if (!entry.isFile()) {
@@ -44014,7 +44049,7 @@ function staleImports(projectPath) {
         }
         let sidecar;
         try {
-          sidecar = readFileSync24(join29(directory, entry.name), "utf8");
+          sidecar = readFileSync24(join30(directory, entry.name), "utf8");
         } catch {
           continue;
         }
@@ -44135,15 +44170,15 @@ var init_keeper_channel = () => {};
 
 // src/lifecycle-log.ts
 import { appendFileSync, mkdirSync as mkdirSync14, renameSync as renameSync5, statSync as statSync13 } from "node:fs";
-import { dirname as dirname20, join as join30 } from "node:path";
+import { dirname as dirname21, join as join31 } from "node:path";
 import process11 from "node:process";
 function lifecycleLogPath() {
-  return join30(runtimeDirectory(), "servers.log");
+  return join31(runtimeDirectory(), "servers.log");
 }
 function writeLifecycle(event, fields = {}) {
   const path = lifecycleLogPath();
   try {
-    mkdirSync14(dirname20(path), { recursive: true });
+    mkdirSync14(dirname21(path), { recursive: true });
     if ((statSync13(path, { throwIfNoEntry: false })?.size ?? 0) > LIFECYCLE_LOG_LIMIT) {
       try {
         renameSync5(path, `${path}.1`);
@@ -44499,14 +44534,14 @@ var init_prompts = __esm(() => {
 
 // src/restart-note.ts
 import { mkdirSync as mkdirSync15, readFileSync as readFileSync25, rmSync as rmSync13, writeFileSync as writeFileSync17 } from "node:fs";
-import { dirname as dirname21, join as join31 } from "node:path";
+import { dirname as dirname22, join as join32 } from "node:path";
 function restartNotePath(projectPath) {
-  return join31(projectPath, ".godot", "gdharness-restart.json");
+  return join32(projectPath, ".godot", "gdharness-restart.json");
 }
 function noteRestartBegun(note) {
   const path = restartNotePath(note.projectPath);
   try {
-    mkdirSync15(dirname21(path), { recursive: true });
+    mkdirSync15(dirname22(path), { recursive: true });
     writeFileSync17(path, `${JSON.stringify(note, null, 2)}
 `, "utf8");
   } catch (error) {
@@ -44541,26 +44576,10 @@ var init_restart_note = __esm(() => {
 
 // src/run-record.ts
 import { createHash as createHash6 } from "node:crypto";
-import { mkdirSync as mkdirSync16, openSync as openSync3, readdirSync as readdirSync14, readFileSync as readFileSync26, realpathSync as realpathSync6, rmSync as rmSync14, statSync as statSync14 } from "node:fs";
-import { basename as basename9, dirname as dirname22, join as join32, resolve as resolve7 } from "node:path";
+import { mkdirSync as mkdirSync16, openSync as openSync3, readdirSync as readdirSync14, readFileSync as readFileSync26, rmSync as rmSync14, statSync as statSync14 } from "node:fs";
+import { basename as basename10, join as join33, resolve as resolve7 } from "node:path";
 function runsDirectory() {
-  return join32(runtimeDirectory(), "runs");
-}
-function realAsFarAsItExists(path) {
-  const missing = [];
-  let at = path;
-  for (;; ) {
-    try {
-      return join32(realpathSync6.native(at), ...missing);
-    } catch {
-      const parent = dirname22(at);
-      if (parent === at) {
-        return path;
-      }
-      missing.unshift(basename9(at));
-      at = parent;
-    }
-  }
+  return join33(runtimeDirectory(), "runs");
 }
 function projectKey(projectPath) {
   const real = realAsFarAsItExists(resolve7(projectPath)).replace(/[\\/]+$/, "");
@@ -44568,10 +44587,10 @@ function projectKey(projectPath) {
   return createHash6("sha256").update(folded.replaceAll("\\", "/")).digest("hex").slice(0, 16);
 }
 function runRecordPath(projectPath, directory = runtimeDirectory()) {
-  return join32(directory, "runs", `note-${projectKey(projectPath)}.json`);
+  return join33(directory, "runs", `note-${projectKey(projectPath)}.json`);
 }
 function latestRunPath(servedBy, directory = runtimeDirectory()) {
-  return join32(directory, "runs", `latest-${projectKey(servedBy)}.json`);
+  return join33(directory, "runs", `latest-${projectKey(servedBy)}.json`);
 }
 function writeLatestRun(servedBy, latest) {
   try {
@@ -44596,20 +44615,20 @@ function readLatestRun(servedBy, directory = runtimeDirectory()) {
 }
 function openTranscript(startedAt) {
   mkdirSync16(runsDirectory(), { recursive: true });
-  const path = join32(runsDirectory(), `run-${startedAt}.log`);
+  const path = join33(runsDirectory(), `run-${startedAt}.log`);
   return { path, fd: openSync3(path, "a") };
 }
 function profilePath(startedAt) {
-  return join32(runsDirectory(), `run-${startedAt}.profile.json`);
+  return join33(runsDirectory(), `run-${startedAt}.profile.json`);
 }
 function profileMarkPath(startedAt) {
-  return join32(runsDirectory(), `run-${startedAt}.profile-mark.json`);
+  return join33(runsDirectory(), `run-${startedAt}.profile-mark.json`);
 }
 function noteIsAbout(note, playing) {
   return note.play !== undefined && playing !== null && note.play.play === playing.play && note.play.editorPid === playing.editorPid;
 }
 function editorNotePath(projectPath, directory = runtimeDirectory()) {
-  return join32(directory, "runs", `editor-${projectKey(projectPath)}.json`);
+  return join33(directory, "runs", `editor-${projectKey(projectPath)}.json`);
 }
 function writeEditorRunNote(note) {
   mkdirSync16(runsDirectory(), { recursive: true });
@@ -44662,13 +44681,13 @@ function everyRunRecord() {
   for (const directory of runtimeDirectories()) {
     let entries;
     try {
-      entries = readdirSync14(join32(directory, "runs"));
+      entries = readdirSync14(join33(directory, "runs"));
     } catch {
       continue;
     }
     for (const entry of entries) {
       if (entry.startsWith("note-") && entry.endsWith(".json")) {
-        const record = recordAt(join32(directory, "runs", entry));
+        const record = recordAt(join33(directory, "runs", entry));
         if (record !== null) {
           found.push(record);
         }
@@ -44843,7 +44862,7 @@ function whyNotTheRun(record, running, needed) {
   if (after > SAME_RUN_WINDOW_MS) {
     return `that process started ${Math.round(after / 1000)} seconds after the run had`;
   }
-  const engine = basename9(record.command);
+  const engine = basename10(record.command);
   const said = process.platform === "win32" ? running.text.toLowerCase() : running.text;
   const wanted = process.platform === "win32" ? engine.toLowerCase() : engine;
   if (!said.includes(wanted)) {
@@ -44906,7 +44925,7 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
     if (!transcript && !entry.endsWith(".partial")) {
       continue;
     }
-    const path = join32(directory, entry);
+    const path = join33(directory, entry);
     if (kept.has(path) || ageMs(path, now) < keepMs) {
       continue;
     }
@@ -45155,15 +45174,15 @@ var init_server_instructions = __esm(() => {
 
 // src/test-selection.ts
 import { existsSync as existsSync26, readFileSync as readFileSync28 } from "node:fs";
-import { basename as basename10, join as join33 } from "node:path";
+import { basename as basename11, join as join34 } from "node:path";
 function casesIn(projectPath, suite) {
-  const text = readFileSync28(join33(projectPath, suite.slice("res://".length)), "utf8");
+  const text = readFileSync28(join34(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}/`))))
+    ...new Set(asked.flatMap((path) => path.endsWith(".gd") ? existsSync26(join34(projectPath, path.slice("res://".length))) ? [path] : [] : scripts.filter((script) => script.startsWith(`${path}/`))))
   ];
 }
 function selectTests(projectPath, asked, given) {
@@ -45175,7 +45194,7 @@ function selectTests(projectPath, asked, given) {
     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 nameOf = (suite) => basename11(suite, ".gd");
   const selected = [];
   for (const [index, entry] of entries.entries()) {
     if (typeof entry !== "string" || entry.trim() === "") {
@@ -45235,7 +45254,7 @@ import {
   statSync as statSync15,
   writeFileSync as writeFileSync18
 } from "node:fs";
-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 { basename as basename12, dirname as dirname23, extname as extname4, isAbsolute as isAbsolute5, join as join35, 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() {
@@ -45271,12 +45290,12 @@ function writtenFileRefusal(path, rule) {
   if (!rule.extensions.includes(extname4(path).toLowerCase())) {
     return `${named} ${path} does not end in ${rule.extensions.join(" or ")}, which is what ${what} is.`;
   }
-  const directory = realPathOr(dirname23(path));
+  const directory = realAsFarAsItExists(dirname23(path));
   if (!existsSync27(directory)) {
     return `${named}'s directory ${dirname23(path)} does not exist; ${what} creates no directories.`;
   }
-  const where = join34(directory, basename11(path));
-  const inside = rule.projects.find((project) => project !== "" && isWithinRoot(realPathOr(project), where));
+  const where = join35(directory, basename12(path));
+  const inside = rule.projects.find((project) => project !== "" && isWithinRoot(realAsFarAsItExists(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.`;
   }
@@ -45366,7 +45385,7 @@ function keptGameRequest(tool, op, args) {
   }
 }
 function projectSpelling(projectPath, absolutePath) {
-  return `res://${relative6(realPathOr(projectPath), realPathOr(absolutePath)).replaceAll("\\", "/")}`;
+  return `res://${relative6(realAsFarAsItExists(projectPath), realAsFarAsItExists(absolutePath)).replaceAll("\\", "/")}`;
 }
 function whichGame(args) {
   return { projectPath: args["projectPath"], pid: args["pid"] };
@@ -45825,10 +45844,14 @@ function importedFirstAnswer(importedFirst) {
   if (importedFirst === undefined) {
     return {};
   }
+  const imported = withAddonPathsCounted(importedFirst.imported);
+  const uids = withAddonPathsCounted(importedFirst.uidsWritten);
   return {
-    ...importedFirst.imported.length === 0 ? {} : { importedFirst: importedFirst.imported },
+    ...imported.own.length === 0 ? {} : { importedFirst: imported.own },
+    ...Object.keys(imported.inAddons).length === 0 ? {} : { importedInAddons: imported.inAddons },
     ...importedFirst.notImported.length === 0 ? {} : { notImportedFirst: importedFirst.notImported },
-    ...importedFirst.uidsWritten.length === 0 ? {} : { uidsWrittenFirst: importedFirst.uidsWritten },
+    ...uids.own.length === 0 ? {} : { uidsWrittenFirst: uids.own },
+    ...Object.keys(uids.inAddons).length === 0 ? {} : { uidsWrittenInAddons: uids.inAddons },
     importTookMs: importedFirst.tookMs,
     ...importedFirst.note === undefined ? {} : { importNote: importedFirst.note }
   };
@@ -45861,7 +45884,7 @@ function notRunNote(notRun, failFast) {
 function exportPresetRefusal(projectPath, preset) {
   let text;
   try {
-    text = readFileSync29(join34(projectPath, "export_presets.cfg"), "utf8");
+    text = readFileSync29(join35(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.`;
   }
@@ -45927,7 +45950,7 @@ function filesIn(folder) {
   try {
     for (const entry of readdirSync15(folder, { withFileTypes: true })) {
       if (entry.isFile()) {
-        found.set(entry.name, statSync15(join34(folder, entry.name)).mtimeMs);
+        found.set(entry.name, statSync15(join35(folder, entry.name)).mtimeMs);
       }
     }
   } catch {}
@@ -45959,7 +45982,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 (!existsSync27(join34(projectPath, "project.godot"))) {
+  if (!existsSync27(join35(projectPath, "project.godot"))) {
     return null;
   }
   const report = inspectProject(projectPath);
@@ -46224,7 +46247,7 @@ function profileFrameFunctions(projectPath) {
   let projectGodot = null;
   if (projectPath !== null) {
     try {
-      projectGodot = readFileSync29(join34(projectPath, "project.godot"), "utf8");
+      projectGodot = readFileSync29(join35(projectPath, "project.godot"), "utf8");
     } catch {}
   }
   return frameFunctionsFor(queuedMessagesOf(projectGodot));
@@ -46403,7 +46426,7 @@ function foldedEntriesAnswer(log, floor = "warning") {
 }
 function gdUnitFailsOnScriptErrors(projectPath) {
   try {
-    return settingKeys(readFileSync29(join34(projectPath, "project.godot"), "utf8")).get("gdunit4/report/godot/script_error") !== false;
+    return settingKeys(readFileSync29(join35(projectPath, "project.godot"), "utf8")).get("gdunit4/report/godot/script_error") !== false;
   } catch {
     return true;
   }
@@ -46418,7 +46441,7 @@ function uncaughtNote(uncaught) {
 }
 function elsewhereIn(projectPath, asked) {
   const wanted = asked.replace(/^res:\/\//, "").replace(/\/+$/, "");
-  if (wanted === "" || existsSync27(join34(projectPath, wanted))) {
+  if (wanted === "" || existsSync27(join35(projectPath, wanted))) {
     return "";
   }
   const root = (wanted.split("/")[0] ?? "").toLowerCase();
@@ -46521,7 +46544,7 @@ function isDirectory(path) {
   }
 }
 function scriptsUnder(directory, prefix) {
-  if (existsSync27(join34(directory, ".gdignore"))) {
+  if (existsSync27(join35(directory, ".gdignore"))) {
     return [];
   }
   const found = [];
@@ -46531,7 +46554,7 @@ function scriptsUnder(directory, prefix) {
     }
     const path = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
     if (entry.isDirectory()) {
-      found.push(...scriptsUnder(join34(directory, entry.name), path));
+      found.push(...scriptsUnder(join35(directory, entry.name), path));
     } else if (entry.isFile() && entry.name.endsWith(".gd")) {
       found.push(path);
     }
@@ -46561,7 +46584,7 @@ function needsItsOwnProcess(asked) {
 class GodotServer {
   stdio = null;
   locator = new GodotLocator;
-  operationsScript = join34(__dirname2, "godot", "operations", "godot_operations.gd");
+  operationsScript = join35(__dirname2, "godot", "operations", "godot_operations.gd");
   godotBridge;
   tools = buildToolDefinitions();
   activeProcess = null;
@@ -46823,7 +46846,7 @@ class GodotServer {
   }
   noteTheStart() {
     const cwd = process.cwd();
-    const mcpJson = join34(cwd, ".mcp.json");
+    const mcpJson = join35(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", {
@@ -46971,7 +46994,7 @@ class GodotServer {
         return checked.response;
       }
       const named = args["projectPath"];
-      if (typeof named === "string" && existsSync27(join34(named, "project.godot"))) {
+      if (typeof named === "string" && existsSync27(join35(named, "project.godot"))) {
         this.lastProjectPath = named;
       }
       this.updates.refresh();
@@ -47007,7 +47030,7 @@ class GodotServer {
     let notSaved;
     try {
       savedAt = answer.content.map((item, index) => {
-        const file = join34(directory, item.type === "text" ? `${stem}-${index}.txt` : `${stem}-${index}.${item.mimeType.split("/")[1] ?? "bin"}`);
+        const file = join35(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;
       });
@@ -47286,6 +47309,14 @@ class GodotServer {
       if (headless === "modify_script") {
         return await this.handleModifyScript(answerable);
       }
+      if (tool === "editor_classes") {
+        const project = this.project(answerable);
+        if (!project.ok) {
+          return project.response;
+        }
+        const projectClasses = Object.fromEntries(declaredClasses(project.value.path));
+        return await this.headless(headless, { ...answerable, projectClasses });
+      }
       if (headless !== "refresh_class_cache") {
         return await this.headless(headless, answerable);
       }
@@ -47541,12 +47572,23 @@ class GodotServer {
         if (!project.ok) {
           return project.response;
         }
+        if (op === "list") {
+          const session = this.dapHoldingBreakpointsOf(project.value.path);
+          const editor = this.godotBridge.isConnected();
+          return this.jsonTextResponse({
+            held: this.breakpointsAsProjectSpells(project.value.path, session.breakpointsHeld()),
+            ...editor ? {
+              setInEditor: this.breakpointsAsProjectSpells(project.value.path, session.breakpointsInEditor()),
+              ...this.breakpointsAtRisk()
+            } : {}
+          });
+        }
         const located = resolveWithinProject(project.value.path, readString(args, "scriptPath") ?? "");
         if (!located.ok) {
           return this.createErrorResponse(located.reason, PATH_SOLUTIONS);
         }
         const session = this.dapHoldingBreakpointsOf(project.value.path);
-        const scriptPath = realPathOr(located.absolutePath);
+        const scriptPath = realAsFarAsItExists(located.absolutePath);
         const line = readPositiveNumber(args, "line");
         if (line === undefined) {
           return this.createErrorResponse("line is required: the one-based line to stop on.");
@@ -47574,10 +47616,13 @@ class GodotServer {
         } else {
           if (op === "set") {
             session.holdBreakpoints([{ scriptPath, lines: [line] }]);
+            answer = { set: true };
           } else {
-            session.forgetBreakpoint(scriptPath, line);
+            answer = session.forgetBreakpoint(scriptPath, line) ? { removed: true } : {
+              removed: false,
+              why: `No breakpoint was held on line ${line} of res://${located.relativePath}, so there was nothing to remove; held lists the ones that are.`
+            };
           }
-          answer = { [op === "set" ? "set" : "removed"]: true };
         }
         const held = session.breakpointsHeld();
         writeBreakpointNote(project.value.path, held);
@@ -47599,7 +47644,7 @@ class GodotServer {
           } : {
             runningGame: `Told to the running game (pid ${kept?.pid ?? "?"}), which this server started.`
           },
-          note: editor ? "The editor keeps a breakpoint set this way for one play. Every breakpoint held here is sent again before each play editor_run starts, handed to every game this server starts itself, and kept in the project for the server after a reconnect." : "No editor is connected, so the set under held is kept here: every game this server starts is handed it as it starts, an editor that connects is sent it before its first play, and it is kept in the project for the server after a reconnect.",
+          note: editor ? "The editor keeps a breakpoint set this way for one play. Every breakpoint held here is sent again before each play editor_run starts, handed to every game this server starts itself, and kept in the project for the server after a reconnect." : "No editor is connected, so the breakpoints under held are kept here: every game this server starts is handed them as it starts, an editor that connects is sent them before its first play, and they are kept in the project for the server after a reconnect.",
           ...editor ? this.breakpointsAtRisk() : {}
         });
       }
@@ -47642,7 +47687,7 @@ class GodotServer {
     if (path === undefined) {
       return { ok: false, response: this.createErrorResponse("projectPath is required.") };
     }
-    const file = join34(path, "project.godot");
+    const file = join35(path, "project.godot");
     if (!existsSync27(file)) {
       return {
         ok: false,
@@ -48348,7 +48393,7 @@ class GodotServer {
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
-      name: typeof name === "string" && name !== "" ? name : basename11(project.value.path),
+      name: typeof name === "string" && name !== "" ? name : basename12(project.value.path),
       path: project.value.path,
       mainScene: typeof mainScene === "string" && mainScene !== "" ? mainScene : null,
       godotVersion: await this.godotVersion(engine.value),
@@ -48466,7 +48511,7 @@ class GodotServer {
     const exportArgs = [
       "--headless",
       "--log-file",
-      join34(exportLogs, "engine.log"),
+      join35(exportLogs, "engine.log"),
       "--path",
       project.value.path,
       debug ? "--export-debug" : "--export-release",
@@ -48503,7 +48548,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), basename11(output.absolutePath), dirname23(output.relativePath).replaceAll("\\", "/"));
+    const beside = writtenBeside(listedBefore, filesIn(folder), basename12(output.absolutePath), dirname23(output.relativePath).replaceAll("\\", "/"));
     return exportAnswer(ending, { preset, outputPath: output.relativePath, debug }, before, writtenAt(), beside, docCacheNote);
   }
   reportTestProgress(log) {
@@ -48557,10 +48602,10 @@ class GodotServer {
     if (movie !== null) {
       return this.createErrorResponse(movie);
     }
-    const missing = paths.value.filter((path) => !existsSync27(join34(project.value.path, path.slice("res://".length))));
+    const missing = paths.value.filter((path) => !existsSync27(join35(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 = !existsSync27(join34(project.value.path, runner));
+    const noRunner = !existsSync27(join35(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}` : "";
@@ -48680,14 +48725,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 = join34(project.value.path, ".godot", ...ours.split("/"));
+    const reportsDir = join35(project.value.path, ".godot", ...ours.split("/"));
     let report = null;
     let reportProblem = null;
     try {
       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(readFileSync29(join34(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync29(join35(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
@@ -48815,7 +48860,7 @@ class GodotServer {
     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}`))
+      ...new Set((selection.value?.selected ?? []).filter((one) => !report.suites.some((suite) => (suite.path === one.suite || suite.name === basename12(one.suite, ".gd")) && suite.cases.some((ran) => ran.name === one.test || new RegExp(`^${one.test}\\W`).test(ran.name)))).map((one) => `${basename12(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 && testsNotRun.length === 0,
@@ -49330,7 +49375,7 @@ class GodotServer {
       ...Array.isArray(stack) ? {
         stack: stack.map((frame) => ({
           ...frame,
-          ...projectPath !== "" && typeof frame["script"] === "string" && frame["script"].startsWith("res://") ? { path: join34(projectPath, frame["script"].slice("res://".length)) } : {}
+          ...projectPath !== "" && typeof frame["script"] === "string" && frame["script"].startsWith("res://") ? { path: join35(projectPath, frame["script"].slice("res://".length)) } : {}
         }))
       } : {}
     });
@@ -49393,7 +49438,7 @@ class GodotServer {
     const launchedIsUp = !status.connected && launchedWasUp;
     const arriving = status.connected ? [] : arrivingFound;
     const isPortConflict = this.bridgeStartupError?.includes("EADDRINUSE") ?? false;
-    const greeted = hasSaidWhoItIs(status);
+    const greeted = status.connected;
     const staleNote = this.godotBridge.anotherRelease();
     const unfinished = this.restartLeftUnfinished(status.connected);
     const cannotConnect = status.connected || this.ownProject === null ? null : editorAddonMissing(this.ownProject);
@@ -49401,7 +49446,7 @@ class GodotServer {
       ...status,
       serverVersion: SERVER_VERSION,
       addonIsStale: greeted ? staleNote !== undefined : undefined,
-      greeting: status.connected && !greeted ? "The editor has connected and has not yet said who it is: its project, pid, addon version and ports arrive with its greeting a moment after the socket opens, later while it imports. Ask again for them." : undefined,
+      greeting: status.identifying === true ? "An editor has opened the bridge and has not yet said who it is: its project, pid, addon version and ports arrive with its greeting a moment after the socket opens, later while it imports, and one nobody's server opened is served once its command line has been read. Ask again for them." : undefined,
       bridgeAvailable: this.bridgeStartupError === null && status.port !== null,
       mayYetConnect: status.connected ? undefined : cannotConnect !== null ? false : arriving.length > 0 ? true : unfinished !== null ? unfinished.underway : this.closedHere !== null ? false : anEditorIsStillComing(status.listeningSince, launchedIsUp),
       editorsNotYetConnected: arriving.length > 0 ? arriving : undefined,
@@ -49609,21 +49654,21 @@ class GodotServer {
       return null;
     }
     try {
-      return settingKeys(readFileSync29(join34(projectPath, "project.godot"), "utf8"));
+      return settingKeys(readFileSync29(join35(projectPath, "project.godot"), "utf8"));
     } catch {
       return null;
     }
   }
   async handleRestartEditor(args) {
     const before = this.godotBridge.getStatus();
-    if (!before.connected) {
+    if (!before.connected && before.identifying !== true) {
       return this.createErrorResponse("No editor is connected, so there is nothing to restart.", [
         "editor_launch opens one on a project",
         "editor_status says whether the bridge is up and what has reached it"
       ]);
     }
-    if (!hasSaidWhoItIs(before)) {
-      return this.createErrorResponse(`The editor has connected and has not said who it is within ${greetingWaitMs() / 1000}s, so whether this server or the editor itself restarts it cannot be told.`, ["editor_status says when it has, under greeting while it has not", "Then ask for the restart again"]);
+    if (!before.connected) {
+      return this.createErrorResponse(`An editor has opened the bridge and has not said who it is within ${greetingWaitMs() / 1000}s, so whether this server or the editor itself restarts it cannot be told.`, ["editor_status says when it has, under greeting while it has not", "Then ask for the restart again"]);
     }
     const mine = before.openedByAServer === true && before.projectPath !== undefined;
     if (!mine && args["hidden"] === true) {
@@ -49665,7 +49710,7 @@ class GodotServer {
   }
   async handleCloseEditor() {
     const before = this.godotBridge.getStatus();
-    if (!before.connected) {
+    if (!before.connected && before.identifying !== true) {
       const launched = this.launchedEditor;
       if (launched !== null && await this.launchedEditorIsUp() && !this.godotBridge.isConnected()) {
         return await this.stopTheLaunchedEditor(launched);
@@ -49674,8 +49719,8 @@ class GodotServer {
         "editor_status says whether the bridge is up and what has reached it"
       ]);
     }
-    if (!hasSaidWhoItIs(before) || before.editorPid === undefined) {
-      return this.createErrorResponse(`The editor has connected and has not said who it is within ${greetingWaitMs() / 1000}s, so there is no process to wait on once it is asked to go.`, ["editor_status says when it has, under greeting while it has not", "Then ask for the close again"]);
+    if (!before.connected || before.editorPid === undefined) {
+      return this.createErrorResponse(`An editor has opened the bridge and has not said who it is within ${greetingWaitMs() / 1000}s, so there is no process to wait on once it is asked to go.`, ["editor_status says when it has, under greeting while it has not", "Then ask for the close again"]);
     }
     const pid = before.editorPid;
     const settingsBefore = this.settingKeysOf(before.projectPath);
@@ -49731,7 +49776,7 @@ class GodotServer {
   settleTheLaunchReading() {
     const watched = this.launchedFrom;
     const status = this.godotBridge.getStatus();
-    if (watched === null || !hasSaidWhoItIs(status)) {
+    if (watched === null || !status.connected) {
       return;
     }
     this.launchedFrom = null;
@@ -50051,7 +50096,7 @@ class GodotServer {
   }
   async runtimeUp(projectPath, before, budget, withArgs) {
     const budgetMs = budget.ms;
-    if (!existsSync27(join34(projectPath, RUNTIME_AUTOLOAD.path))) {
+    if (!existsSync27(join35(projectPath, RUNTIME_AUTOLOAD.path))) {
       return runtimeVerdict(null, {
         addon: false,
         budgetMs,
@@ -51028,7 +51073,7 @@ class GodotServer {
     };
     const going = await this.runStillGoing(run);
     const projectPath = run.projectPath;
-    const projectGone = projectPath !== null && !existsSync27(join34(projectPath, "project.godot"));
+    const projectGone = projectPath !== null && !existsSync27(join35(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"]);
     }
@@ -51253,10 +51298,10 @@ class GodotServer {
   }
   async handleEditorConsole(args) {
     const status = this.godotBridge.getStatus();
-    const greeted = hasSaidWhoItIs(status);
+    const greeted = status.connected;
     const launched = greeted ? null : this.launchedEditor?.pid ?? null;
-    if (!greeted && launched === null && status.connected) {
-      return this.createErrorResponse("The editor has connected and has not yet said who it is, so whose console to read cannot be told yet.", ["Ask again in a moment; editor_status shows greeting until it has"]);
+    if (launched === null && status.identifying === true) {
+      return this.createErrorResponse("An editor has opened the bridge and has not yet said who it is, so whose console to read cannot be told yet.", ["Ask again in a moment; editor_status shows greeting until it has"]);
     }
     const projectPath = status.projectPath ?? this.launchedEditor?.projectPath ?? this.ownProject ?? undefined;
     const elsewhere = this.anotherProjectNamed(args, projectPath);
@@ -51375,7 +51420,7 @@ class GodotServer {
       notes.push(endedWithoutACode({
         throughEditor: run.throughEditor,
         announced: announced !== undefined || run.announcedPid !== undefined,
-        couldAnnounce: run.projectPath !== null && existsSync27(join34(run.projectPath, RUNTIME_AUTOLOAD.path)),
+        couldAnnounce: run.projectPath !== null && existsSync27(join35(run.projectPath, RUNTIME_AUTOLOAD.path)),
         endedHere: typeof run.endedHere === "string",
         pickedUp: run.pickedUp === true
       }));
@@ -52465,7 +52510,7 @@ class GodotServer {
     const launched = this.launchedEditor;
     if (launched !== null && await this.launchedEditorIsUp()) {
       const began = Date.now();
-      await this.waitForBridge(() => hasSaidWhoItIs(this.godotBridge.getStatus()) || !alive(launched.pid), began + editorRestartTimeoutMs());
+      await this.waitForBridge(() => this.godotBridge.isConnected() || !alive(launched.pid), began + editorRestartTimeoutMs());
       if (this.godotBridge.isConnected()) {
         return null;
       }
@@ -52584,7 +52629,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) || !existsSync27(join34(project, RUNTIME_AUTOLOAD.path)) || !await this.runStillGoing(run)) {
+    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync27(join35(project, RUNTIME_AUTOLOAD.path)) || !await this.runStillGoing(run)) {
       return null;
     }
     const already = runtimesAnnounced().running;
@@ -52678,7 +52723,7 @@ class GodotServer {
       return this.createErrorResponse(staleNote);
     }
     const screenshotDir = expectsScreenshot ? scratchDirectory("runtime-screenshot") : null;
-    const screenshotPath = screenshotDir ? join34(screenshotDir, "capture.png") : null;
+    const screenshotPath = screenshotDir ? join35(screenshotDir, "capture.png") : null;
     const refused = (message) => this.createErrorResponse(message);
     const onGame = {
       pid: choice.endpoint.pid,
@@ -52981,12 +53026,12 @@ init_bridge_announce();
 init_errors();
 init_godot_path();
 import { existsSync as existsSync28 } from "node:fs";
-import { join as join35, resolve as resolve8 } from "node:path";
+import { join as join36, 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";
 import { homedir as homedir2 } from "node:os";
-import { basename as basename2, dirname as dirname3, join as join4, relative as relative2, resolve as resolve2 } from "node:path";
+import { basename as basename3, dirname as dirname4, join as join5, relative as relative2, resolve as resolve2 } from "node:path";
 import process4 from "node:process";
 
 // node_modules/yaml/dist/index.js
@@ -53160,7 +53205,7 @@ var HARNESSES = [
     shape: "plain",
     home: ".claude",
     marker: ".claude",
-    skills: { dir: join4(".claude", "skills"), shared: false }
+    skills: { dir: join5(".claude", "skills"), shared: false }
   },
   {
     id: "copilot-cli",
@@ -53170,7 +53215,7 @@ var HARNESSES = [
     container: "mcpServers",
     shape: "plain",
     home: ".copilot",
-    skills: { dir: join4(".github", "skills"), shared: true },
+    skills: { dir: join5(".github", "skills"), shared: true },
     manual: "Trust the folder when Copilot CLI first asks, or it reads no config here."
   },
   {
@@ -53196,22 +53241,22 @@ var HARNESSES = [
     id: "cursor",
     name: "Cursor",
     scope: "project",
-    file: join4(".cursor", "mcp.json"),
+    file: join5(".cursor", "mcp.json"),
     container: "mcpServers",
     shape: "plain",
     home: ".cursor",
-    skills: { dir: join4(".cursor", "skills"), shared: true },
+    skills: { dir: join5(".cursor", "skills"), shared: true },
     manual: "Cursor asks before each tool call by default, and the server can be toggled off."
   },
   {
     id: "vscode",
     name: "VS Code",
     scope: "project",
-    file: join4(".vscode", "mcp.json"),
+    file: join5(".vscode", "mcp.json"),
     container: "servers",
     shape: "typed",
     home: ".vscode",
-    skills: { dir: join4(".github", "skills"), shared: true },
+    skills: { dir: join5(".github", "skills"), shared: true },
     manual: "VS Code asks you to trust a server the first time it starts one."
   },
   {
@@ -53221,45 +53266,45 @@ var HARNESSES = [
     file: "opencode.json",
     container: "mcp",
     shape: "opencode",
-    home: join4(".config", "opencode"),
+    home: join5(".config", "opencode"),
     marker: ".opencode",
-    skills: { dir: join4(".opencode", "skills"), shared: true }
+    skills: { dir: join5(".opencode", "skills"), shared: true }
   },
   {
     id: "junie",
     name: "Junie",
     scope: "project",
-    file: join4(".junie", "mcp", "mcp.json"),
+    file: join5(".junie", "mcp", "mcp.json"),
     container: "mcpServers",
     shape: "plain",
     home: ".junie",
-    skills: { dir: join4(".junie", "skills"), shared: true }
+    skills: { dir: join5(".junie", "skills"), shared: true }
   },
   {
     id: "kiro",
     name: "Kiro",
     scope: "project",
-    file: join4(".kiro", "settings", "mcp.json"),
+    file: join5(".kiro", "settings", "mcp.json"),
     container: "mcpServers",
     shape: "plain",
     home: ".kiro",
-    skills: { dir: join4(".kiro", "skills"), shared: false }
+    skills: { dir: join5(".kiro", "skills"), shared: false }
   },
   {
     id: "gemini",
     name: "Gemini CLI",
     scope: "project",
-    file: join4(".gemini", "settings.json"),
+    file: join5(".gemini", "settings.json"),
     container: "mcpServers",
     shape: "plain",
     home: ".gemini",
-    skills: { dir: join4(".gemini", "skills"), shared: true }
+    skills: { dir: join5(".gemini", "skills"), shared: true }
   },
   {
     id: "roo",
     name: "Roo Code",
     scope: "project",
-    file: join4(".roo", "mcp.json"),
+    file: join5(".roo", "mcp.json"),
     container: "mcpServers",
     shape: "plain"
   },
@@ -53267,7 +53312,7 @@ var HARNESSES = [
     id: "kilo",
     name: "Kilo Code",
     scope: "project",
-    file: join4(".kilocode", "mcp.json"),
+    file: join5(".kilocode", "mcp.json"),
     container: "mcpServers",
     shape: "plain"
   },
@@ -53275,16 +53320,16 @@ var HARNESSES = [
     id: "amazon-q",
     name: "Amazon Q Developer CLI",
     scope: "project",
-    file: join4(".amazonq", "mcp.json"),
+    file: join5(".amazonq", "mcp.json"),
     container: "mcpServers",
     shape: "plain",
-    home: join4(".aws", "amazonq")
+    home: join5(".aws", "amazonq")
   },
   {
     id: "zed",
     name: "Zed",
     scope: "project",
-    file: join4(".zed", "settings.json"),
+    file: join5(".zed", "settings.json"),
     container: "context_servers",
     shape: "plain"
   },
@@ -53292,16 +53337,16 @@ var HARNESSES = [
     id: "amp",
     name: "Amp",
     scope: "project",
-    file: join4(".amp", "settings.json"),
+    file: join5(".amp", "settings.json"),
     container: "amp.mcpServers",
     shape: "plain",
-    home: join4(".config", "amp")
+    home: join5(".config", "amp")
   },
   {
     id: "warp",
     name: "Warp",
     scope: "project",
-    file: join4(".warp", ".mcp.json"),
+    file: join5(".warp", ".mcp.json"),
     container: "mcpServers",
     shape: "plain",
     home: ".warp",
@@ -53311,7 +53356,7 @@ var HARNESSES = [
     id: "trae",
     name: "Trae",
     scope: "project",
-    file: join4(".trae", "mcp.json"),
+    file: join5(".trae", "mcp.json"),
     container: "mcpServers",
     shape: "plain",
     home: ".trae"
@@ -53320,7 +53365,7 @@ var HARNESSES = [
     id: "factory",
     name: "Factory Droid",
     scope: "project",
-    file: join4(".factory", "mcp.json"),
+    file: join5(".factory", "mcp.json"),
     container: "mcpServers",
     shape: "typed",
     home: ".factory"
@@ -53329,7 +53374,7 @@ var HARNESSES = [
     id: "tabnine",
     name: "Tabnine",
     scope: "project",
-    file: join4(".tabnine", "mcp_servers.json"),
+    file: join5(".tabnine", "mcp_servers.json"),
     container: "mcpServers",
     shape: "plain",
     home: ".tabnine"
@@ -53346,7 +53391,7 @@ var HARNESSES = [
     id: "pi",
     name: "pi",
     scope: "project",
-    file: join4(".pi", "mcp.json"),
+    file: join5(".pi", "mcp.json"),
     container: "mcpServers",
     shape: "plain",
     home: ".pi"
@@ -53355,7 +53400,7 @@ var HARNESSES = [
     id: "mistral-vibe",
     name: "Mistral Vibe",
     scope: "project",
-    file: join4(".vibe", "config.toml"),
+    file: join5(".vibe", "config.toml"),
     container: "mcp_servers",
     shape: "plain",
     toml: {
@@ -53411,7 +53456,7 @@ var HARNESSES = [
     id: "codex",
     name: "Codex CLI",
     scope: "home",
-    file: join4(".codex", "config.toml"),
+    file: join5(".codex", "config.toml"),
     container: "mcp_servers",
     shape: "plain",
     manual: "Codex reads its config at startup, so restart it.",
@@ -53430,20 +53475,20 @@ var HARNESSES = [
     id: "cline",
     name: "Cline",
     scope: "home",
-    file: join4(".cline", "data", "settings", "cline_mcp_settings.json"),
+    file: join5(".cline", "data", "settings", "cline_mcp_settings.json"),
     container: "mcpServers",
     shape: "plain",
     marker: ".cline",
-    skills: { dir: join4(".cline", "skills"), shared: false }
+    skills: { dir: join5(".cline", "skills"), shared: false }
   },
   {
     id: "goose",
     name: "Goose",
     scope: "home",
     file: {
-      win32: { appData: join4("Block", "goose", "config", "config.yaml") },
-      darwin: join4(".config", "goose", "config.yaml"),
-      linux: join4(".config", "goose", "config.yaml")
+      win32: { appData: join5("Block", "goose", "config", "config.yaml") },
+      darwin: join5(".config", "goose", "config.yaml"),
+      linux: join5(".config", "goose", "config.yaml")
     },
     container: "extensions",
     shape: "plain",
@@ -53464,19 +53509,19 @@ var HARNESSES = [
     id: "windsurf",
     name: "Windsurf",
     scope: "home",
-    file: join4(".codeium", "windsurf", "mcp_config.json"),
+    file: join5(".codeium", "windsurf", "mcp_config.json"),
     container: "mcpServers",
     shape: "plain",
-    skills: { dir: join4(".windsurf", "skills"), shared: true }
+    skills: { dir: join5(".windsurf", "skills"), shared: true }
   },
   {
     id: "hermes",
     name: "Hermes",
     scope: "home",
-    file: join4(".hermes", "config.yaml"),
+    file: join5(".hermes", "config.yaml"),
     container: "mcp_servers",
     shape: "plain",
-    skills: { dir: join4(".hermes", "skills"), shared: true },
+    skills: { dir: join5(".hermes", "skills"), shared: true },
     yaml: {
       path: ["mcp_servers", SERVER_KEY],
       entry: (launch) => ({
@@ -53491,7 +53536,7 @@ var HARNESSES = [
     id: "openclaw",
     name: "OpenClaw",
     scope: "home",
-    file: join4(".openclaw", "openclaw.json"),
+    file: join5(".openclaw", "openclaw.json"),
     container: "mcpServers",
     shape: "plain"
   },
@@ -53500,9 +53545,9 @@ var HARNESSES = [
     name: "Claude Desktop",
     scope: "home",
     file: {
-      win32: { appData: join4("Claude", "claude_desktop_config.json") },
-      darwin: join4("Library", "Application Support", "Claude", "claude_desktop_config.json"),
-      linux: join4(".config", "Claude", "claude_desktop_config.json")
+      win32: { appData: join5("Claude", "claude_desktop_config.json") },
+      darwin: join5("Library", "Application Support", "Claude", "claude_desktop_config.json"),
+      linux: join5(".config", "Claude", "claude_desktop_config.json")
     },
     container: "mcpServers",
     shape: "plain"
@@ -53511,7 +53556,7 @@ var HARNESSES = [
     id: "zeroclaw",
     name: "ZeroClaw",
     scope: "home",
-    file: join4(".zeroclaw", "config.toml"),
+    file: join5(".zeroclaw", "config.toml"),
     container: "mcp.servers",
     shape: "plain",
     toml: {
@@ -53532,7 +53577,7 @@ var HARNESSES = [
     id: "deepcode",
     name: "Deep Code",
     scope: "home",
-    file: join4(".deepcode", "settings.json"),
+    file: join5(".deepcode", "settings.json"),
     container: "mcpServers",
     shape: "plain"
   },
@@ -53540,7 +53585,7 @@ var HARNESSES = [
     id: "nanobot",
     name: "nanobot",
     scope: "home",
-    file: join4(".nanobot", "config.json"),
+    file: join5(".nanobot", "config.json"),
     container: "mcpServers",
     shape: "plain",
     snippet: (launch) => jsonSnippet(launch, "mcpServers", "plain")
@@ -53549,17 +53594,17 @@ var HARNESSES = [
     id: "autohand",
     name: "Autohand",
     scope: "home",
-    file: join4(".autohand", "config.json"),
+    file: join5(".autohand", "config.json"),
     container: "mcpServers",
     shape: "plain",
     snippet: (launch) => jsonSnippet(launch, "mcpServers", "plain")
   }
 ];
 function appDataRoot() {
-  return process4.env["APPDATA"] ?? join4(homedir2(), "AppData", "Roaming");
+  return process4.env["APPDATA"] ?? join5(homedir2(), "AppData", "Roaming");
 }
 function homePath(path) {
-  return typeof path === "string" ? join4(homedir2(), path) : join4(appDataRoot(), path.appData);
+  return typeof path === "string" ? join5(homedir2(), path) : join5(appDataRoot(), path.appData);
 }
 function fileFor(harness, platform = process4.platform) {
   if (typeof harness.file === "string") {
@@ -53570,7 +53615,7 @@ function fileFor(harness, platform = process4.platform) {
 function configPath(harness, projectPath) {
   const file = fileFor(harness);
   if (harness.scope === "project") {
-    return join4(projectPath, file);
+    return join5(projectPath, file);
   }
   return homePath(file);
 }
@@ -53629,11 +53674,11 @@ function present(harness, projectPath) {
     return true;
   }
   const root = harness.scope === "project" ? projectPath : homedir2();
-  const own = dirname3(path);
+  const own = dirname4(path);
   if (own !== root && existsSync4(own)) {
     return true;
   }
-  return harness.marker !== undefined && existsSync4(join4(root, harness.marker));
+  return harness.marker !== undefined && existsSync4(join5(root, harness.marker));
 }
 function candidates(projectPath) {
   const found = [];
@@ -53646,7 +53691,7 @@ function candidates(projectPath) {
     }
     if (present(harness, projectPath)) {
       found.push({ harness, reason: "configured" });
-    } else if (harness.home !== undefined && existsSync4(join4(homedir2(), harness.home))) {
+    } else if (harness.home !== undefined && existsSync4(join5(homedir2(), harness.home))) {
       found.push({ harness, reason: "installed" });
     }
   }
@@ -53704,14 +53749,14 @@ function recordedEnginePath(projectPath) {
 }
 function mainCheckoutOf(projectPath) {
   let top = resolve2(projectPath);
-  while (!existsSync4(join4(top, ".git"))) {
-    const up = dirname3(top);
+  while (!existsSync4(join5(top, ".git"))) {
+    const up = dirname4(top);
     if (up === top) {
       return null;
     }
     top = up;
   }
-  const marker = join4(top, ".git");
+  const marker = join5(top, ".git");
   if (!statSync3(marker).isFile()) {
     return null;
   }
@@ -53720,39 +53765,39 @@ function mainCheckoutOf(projectPath) {
     return null;
   }
   const entry = resolve2(top, pointer);
-  const commonFile = join4(entry, "commondir");
+  const commonFile = join5(entry, "commondir");
   if (!existsSync4(commonFile)) {
     return null;
   }
   const common = resolve2(entry, readFileSync2(commonFile, "utf8").trim());
-  if (basename2(common) !== ".git") {
+  if (basename3(common) !== ".git") {
     return null;
   }
-  const main = join4(dirname3(common), relative2(top, resolve2(projectPath)));
-  return isSameDirectory(main, projectPath) || !existsSync4(join4(main, "project.godot")) ? null : main;
+  const main = join5(dirname4(common), relative2(top, resolve2(projectPath)));
+  return isSameDirectory(main, projectPath) || !existsSync4(join5(main, "project.godot")) ? null : main;
 }
 function worktreeCheckoutsOf(projectPath) {
   let top = resolve2(projectPath);
-  while (!existsSync4(join4(top, ".git"))) {
-    const up = dirname3(top);
+  while (!existsSync4(join5(top, ".git"))) {
+    const up = dirname4(top);
     if (up === top) {
       return [];
     }
     top = up;
   }
-  const listed = join4(top, ".git", "worktrees");
-  if (!statSync3(join4(top, ".git")).isDirectory() || !existsSync4(listed)) {
+  const listed = join5(top, ".git", "worktrees");
+  if (!statSync3(join5(top, ".git")).isDirectory() || !existsSync4(listed)) {
     return [];
   }
   const below = relative2(top, resolve2(projectPath));
   return readdirSync2(listed).flatMap((name) => {
-    const pointer = join4(listed, name, "gitdir");
+    const pointer = join5(listed, name, "gitdir");
     if (!existsSync4(pointer)) {
       return [];
     }
-    const checkout = dirname3(resolve2(listed, name, readFileSync2(pointer, "utf8").trim()));
-    const project = join4(checkout, below);
-    return existsSync4(join4(project, "project.godot")) ? [project] : [];
+    const checkout = dirname4(resolve2(listed, name, readFileSync2(pointer, "utf8").trim()));
+    const project = join5(checkout, below);
+    return existsSync4(join5(project, "project.godot")) ? [project] : [];
   });
 }
 function entryEnvironment(harness, projectPath) {
@@ -53894,7 +53939,7 @@ function connect(harness, projectPath, launch) {
   return was === undefined || was === now ? written : { ...written, wasLaunchedBy: was };
 }
 function put(harness, path, contents, already) {
-  mkdirSync2(dirname3(path), { recursive: true });
+  mkdirSync2(dirname4(path), { recursive: true });
   writeFileSync2(path, contents, "utf8");
   return { harness, path, action: already ? "replaced" : "written" };
 }
@@ -53947,9 +53992,9 @@ init_setup();
 init_tool_definitions();
 init_tool_reference();
 import { existsSync as existsSync14, mkdirSync as mkdirSync5, readdirSync as readdirSync9, rmSync as rmSync6, writeFileSync as writeFileSync7 } from "node:fs";
-import { basename as basename6, dirname as dirname8, join as join15 } from "node:path";
+import { basename as basename7, dirname as dirname9, join as join16 } from "node:path";
 var SKILL_NAME = "gdharness";
-var SHARED_SKILLS = join15(".agents", "skills");
+var SHARED_SKILLS = join16(".agents", "skills");
 function skillMarkdown(version) {
   return `---
 name: ${SKILL_NAME}
@@ -54181,27 +54226,27 @@ what they report while starting comes back under \`engine_messages_before_operat
 function skillFiles(version) {
   return new Map([
     ["SKILL.md", skillMarkdown(version)],
-    [join15("references", "tools.md"), renderToolsMarkdown()]
+    [join16("references", "tools.md"), renderToolsMarkdown()]
   ]);
 }
 function skillDirectories(harnesses, projectPath, exists) {
-  const directories = [join15(projectPath, SHARED_SKILLS, SKILL_NAME)];
+  const directories = [join16(projectPath, SHARED_SKILLS, SKILL_NAME)];
   for (const harness of harnesses) {
     if (harness.skills === undefined) {
       continue;
     }
-    const own = join15(projectPath, harness.skills.dir);
-    if ((!harness.skills.shared || exists(own)) && !directories.includes(join15(own, SKILL_NAME))) {
-      directories.push(join15(own, SKILL_NAME));
+    const own = join16(projectPath, harness.skills.dir);
+    if ((!harness.skills.shared || exists(own)) && !directories.includes(join16(own, SKILL_NAME))) {
+      directories.push(join16(own, SKILL_NAME));
     }
   }
   return directories;
 }
 function everySkillDirectory(projectPath, harnesses) {
-  const directories = new Set([join15(projectPath, SHARED_SKILLS, SKILL_NAME)]);
+  const directories = new Set([join16(projectPath, SHARED_SKILLS, SKILL_NAME)]);
   for (const harness of harnesses) {
     if (harness.skills !== undefined) {
-      directories.add(join15(projectPath, harness.skills.dir, SKILL_NAME));
+      directories.add(join16(projectPath, harness.skills.dir, SKILL_NAME));
     }
   }
   return [...directories];
@@ -54211,21 +54256,21 @@ function removeSkill(directories, projectPath) {
   for (const directory of directories) {
     if (existsSync14(directory)) {
       rmSync6(directory, { recursive: true, force: true });
-      pruneEmpty(dirname8(directory), projectPath);
+      pruneEmpty(dirname9(directory), projectPath);
       removed.push(directory);
     }
   }
   return removed;
 }
 function pruneEmpty(directory, projectPath) {
-  const shared = join15(projectPath, ".agents");
+  const shared = join16(projectPath, ".agents");
   let path = directory;
-  while (path !== projectPath && (basename6(path) === "skills" || path === shared)) {
+  while (path !== projectPath && (basename7(path) === "skills" || path === shared)) {
     if (readdirSync9(path).length > 0) {
       return;
     }
     rmSync6(path, { recursive: true, force: true });
-    path = dirname8(path);
+    path = dirname9(path);
   }
 }
 function writeSkill(directories, version) {
@@ -54234,8 +54279,8 @@ function writeSkill(directories, version) {
     const replaced = existsSync14(directory);
     rmSync6(directory, { recursive: true, force: true });
     for (const [name, contents] of files) {
-      const path = join15(directory, name);
-      mkdirSync5(dirname8(path), { recursive: true });
+      const path = join16(directory, name);
+      mkdirSync5(dirname9(path), { recursive: true });
       writeFileSync7(path, contents, "utf8");
     }
     return { path: directory, replaced };
@@ -54244,13 +54289,13 @@ function writeSkill(directories, version) {
 
 // src/version.ts
 import { readFileSync as readFileSync12 } from "node:fs";
-import { dirname as dirname9, join as join16 } from "node:path";
+import { dirname as dirname10, join as join17 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function getLocalVersion() {
-  const currentDirectory = dirname9(fileURLToPath2(import.meta.url));
+  const currentDirectory = dirname10(fileURLToPath2(import.meta.url));
   const packageCandidates = [
-    join16(currentDirectory, "..", "package.json"),
-    join16(currentDirectory, "..", "..", "package.json")
+    join17(currentDirectory, "..", "package.json"),
+    join17(currentDirectory, "..", "..", "package.json")
   ];
   for (const packagePath of packageCandidates) {
     try {
@@ -54272,7 +54317,7 @@ class UsageError extends Refusal {
 function projectArgument(at) {
   const named = args.slice(at).find((value) => !value.startsWith("--"));
   const projectPath = resolve8(named ?? ".");
-  if (!existsSync28(join35(projectPath, "project.godot"))) {
+  if (!existsSync28(join36(projectPath, "project.godot"))) {
     throw new UsageError(`Not a Godot project: ${projectPath} holds no project.godot.`);
   }
   return projectPath;
@@ -54317,7 +54362,7 @@ async function registerRuntime(godot, projectPath) {
     return;
   }
   console.log(`${RUNTIME_AUTOLOAD.name} autoload left at ${named}, which this project registers itself`);
-  if (!existsSync28(join35(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
+  if (!existsSync28(join36(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}`);
   }
 }