gdharness 1.1.19 → 1.1.21

package/build/cli.js

@@ -7850,6 +7850,27 @@ var init_game_log = __esm(() => {
   };
 });
 
+// src/reimport.ts
+import { createHash } from "node:crypto";
+import { existsSync as existsSync5, readFileSync as readFileSync3, rmSync as rmSync3, statSync as statSync2, utimesSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { basename as basename2, join as join5 } from "node:path";
+function forceNextImport(projectPath, resourcePath) {
+  const relative = resourcePath.replace(/^res:\/\//, "");
+  const sidecar = join5(projectPath, `${relative}.import`);
+  if (!existsSync5(sidecar)) {
+    return;
+  }
+  const { atime, mtimeMs } = statSync2(sidecar);
+  writeFileSync3(sidecar, readFileSync3(sidecar, "utf8").replace(/^valid=false\r?\n/m, ""));
+  utimesSync(sidecar, atime, new Date(mtimeMs + 2000));
+  rmSync3(importRecord(projectPath, resourcePath), { force: true });
+}
+function importRecord(projectPath, resourcePath) {
+  const digest = createHash("md5").update(resourcePath).digest("hex");
+  return join5(projectPath, ".godot", "imported", `${basename2(resourcePath)}-${digest}.md5`);
+}
+var init_reimport = () => {};
+
 // src/alive.ts
 import process5 from "node:process";
 function alive(pid) {
@@ -7866,12 +7887,12 @@ function alive(pid) {
 var init_alive = () => {};
 
 // src/scratch.ts
-import { existsSync as existsSync5, mkdtempSync, readdirSync as readdirSync2, rmSync as rmSync3 } from "node:fs";
+import { existsSync as existsSync6, mkdtempSync, readdirSync as readdirSync2, rmSync as rmSync4 } from "node:fs";
 import { tmpdir } from "node:os";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 import process6 from "node:process";
 function scratchDirectory(kind) {
-  return mkdtempSync(join5(tmpdir(), `gdharness-${kind}-${process6.pid}-`));
+  return mkdtempSync(join6(tmpdir(), `gdharness-${kind}-${process6.pid}-`));
 }
 function sweepAbandonedScratch(directory = tmpdir()) {
   let entries;
@@ -7887,7 +7908,7 @@ function sweepAbandonedScratch(directory = tmpdir()) {
       continue;
     }
     try {
-      remove(join5(directory, entry));
+      remove(join6(directory, entry));
     } catch {}
   }
 }
@@ -7913,7 +7934,7 @@ function discard(...paths) {
   return left;
 }
 function remove(path) {
-  rmSync3(path, SWEPT);
+  rmSync4(path, SWEPT);
 }
 function tryAgain(path, attempt) {
   if (attempt === 0) {
@@ -7925,7 +7946,7 @@ function tryAgain(path, attempt) {
     lastTryOnExit();
   }
   const after = AGAIN_AFTER_MS[attempt];
-  if (after === undefined || !existsSync5(path)) {
+  if (after === undefined || !existsSync6(path)) {
     waiting.delete(path);
     if (after === undefined) {
       atExit.add(path);
@@ -7973,8 +7994,8 @@ var init_scratch = __esm(() => {
 
 // src/headless.ts
 import { execFile as execFile3 } from "node:child_process";
-import { writeFileSync as writeFileSync3 } from "node:fs";
-import { join as join6 } from "node:path";
+import { writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join7 } from "node:path";
 import { promisify as promisify3 } from "node:util";
 function snakeCased(params) {
   const result = emptyRecord();
@@ -8023,21 +8044,36 @@ function librariesNotCopied(messages) {
   }
   return [...found];
 }
-function extensionRetryNote(libraries) {
-  return `The first import could not load ${libraries.join(" and ")}: on Windows an engine running as the editor ` + "loads a GDExtension from a ~ copy beside the library, and the editor open on this project holds its own " + "copy there, so the first engine started beside it cannot make one. That failed attempt moves the " + "editor's copy aside, so the import was run again and loaded the extension, and the messages are from " + "that second run. The editor's copy is left beside the library as a ~RF….TMP file, which can be deleted " + "once the editor has exited.";
+function extensionRetryNote(libraries, stillNotLoaded = []) {
+  const second = stillNotLoaded.length === 0 ? "so the import was run again and loaded the extension, and the messages are from that second run." : `so the import was run again, and it still could not load ${stillNotLoaded.join(" and ")}: this answer is from an import without ${stillNotLoaded.length === 1 ? "it" : "them"}, and its messages say what the engine hit.`;
+  return `The first import could not load ${libraries.join(" and ")}: on Windows an engine running as the editor ` + "loads a GDExtension from a ~ copy beside the library, and the editor open on this project holds its own " + "copy there, so the first engine started beside it cannot make one. That failed attempt moves the " + `editor's copy aside, ${second} The editor's copy is left beside the library as a ~RF….TMP file, which ` + "can be deleted once the editor has exited.";
 }
-async function runImport(godotPath, projectPath, once = importOnce) {
-  const first = await once(godotPath, projectPath);
+async function runImport(godotPath, projectPath, options = {}) {
+  const once = options.once ?? importOnce;
+  const pass = () => {
+    for (const target of options.forcing ?? []) {
+      forceNextImport(projectPath, target);
+    }
+    return once(godotPath, projectPath);
+  };
+  const first = await pass();
   const collided = librariesNotCopied(first.messages);
   if (collided.length === 0) {
     return first;
   }
-  return { ...await once(godotPath, projectPath), librariesRetried: collided };
+  const second = await pass();
+  const still = librariesNotCopied(second.messages);
+  return {
+    ...second,
+    librariesRetried: collided,
+    ...still.length === 0 ? {} : { librariesNotLoaded: still },
+    extensionNote: extensionRetryNote(collided, still)
+  };
 }
 async function importOnce(godotPath, projectPath) {
   const logDir = scratchDirectory("import");
   try {
-    const { stderr } = await run3(godotPath, ["--headless", "--log-file", join6(logDir, "engine.log"), "--path", projectPath, "--import"], { signal: callSignal() });
+    const { stderr } = await run3(godotPath, ["--headless", "--log-file", join7(logDir, "engine.log"), "--path", projectPath, "--import"], { signal: callSignal() });
     return { ok: true, messages: problems(stderr) };
   } catch (error) {
     if (error instanceof Error && "stdout" in error && "stderr" in error) {
@@ -8059,12 +8095,12 @@ async function importOnce(godotPath, projectPath) {
 }
 async function runOperation(engine, operation, params, projectPath) {
   const paramsDir = scratchDirectory("params");
-  const paramsFile = join6(paramsDir, `${operation}.json`);
-  writeFileSync3(paramsFile, JSON.stringify(snakeCased(params)), "utf8");
+  const paramsFile = join7(paramsDir, `${operation}.json`);
+  writeFileSync4(paramsFile, JSON.stringify(snakeCased(params)), "utf8");
   const args = [
     "--headless",
     "--log-file",
-    join6(paramsDir, "engine.log"),
+    join7(paramsDir, "engine.log"),
     "--path",
     projectPath,
     "--script",
@@ -8108,14 +8144,15 @@ var run3;
 var init_headless = __esm(() => {
   init_call_signal();
   init_game_log();
+  init_reimport();
   init_scratch();
   run3 = promisify3(execFile3);
 });
 
 // src/update-check.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync5 } from "node:fs";
 import { homedir as homedir3, tmpdir as tmpdir2 } from "node:os";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 function packageUrl(root) {
   return `${root.replace(/\/+$/, "")}/gdharness/latest`;
 }
@@ -8137,28 +8174,28 @@ function cacheDirectory(environment) {
   };
   const home = set("HOME") ?? homedir3();
   if (process.platform === "win32") {
-    return join7(set("LOCALAPPDATA") ?? home, "gdharness");
+    return join8(set("LOCALAPPDATA") ?? home, "gdharness");
   }
   if (process.platform === "darwin") {
-    return join7(home, "Library", "Caches", "gdharness");
+    return join8(home, "Library", "Caches", "gdharness");
   }
-  return join7(set("XDG_CACHE_HOME") ?? join7(home, ".cache"), "gdharness");
+  return join8(set("XDG_CACHE_HOME") ?? join8(home, ".cache"), "gdharness");
 }
 function cacheFile(environment = process.env) {
   try {
     const directory = cacheDirectory(environment);
     mkdirSync3(directory, { recursive: true, mode: 448 });
-    return join7(directory, "update-check.json");
+    return join8(directory, "update-check.json");
   } catch {
-    return join7(tmpdir2(), "gdharness-update-check.json");
+    return join8(tmpdir2(), "gdharness-update-check.json");
   }
 }
 function readCache(path) {
   try {
-    if (!existsSync6(path)) {
+    if (!existsSync7(path)) {
       return null;
     }
-    const parsed = JSON.parse(readFileSync3(path, "utf8"));
+    const parsed = JSON.parse(readFileSync4(path, "utf8"));
     if (typeof parsed !== "object" || parsed === null) {
       return null;
     }
@@ -8175,7 +8212,7 @@ function readCache(path) {
 }
 function writeCache(path, entry) {
   try {
-    writeFileSync4(path, JSON.stringify(entry), { encoding: "utf8", mode: 384 });
+    writeFileSync5(path, JSON.stringify(entry), { encoding: "utf8", mode: 384 });
   } catch {}
 }
 function parts(version) {
@@ -8306,7 +8343,7 @@ var init_update_check = __esm(() => {
 });
 
 // src/server-version.ts
-import { readFileSync as readFileSync4 } from "node:fs";
+import { readFileSync as readFileSync5 } from "node:fs";
 function editorIsStale(addonVersion, serverVersion, addonDigest, shippedDigest) {
   if (addonDigest !== undefined && addonDigest !== "" && shippedDigest !== undefined) {
     return addonDigest !== shippedDigest;
@@ -8348,7 +8385,7 @@ var init_server_version = __esm(() => {
   GODOT_DEBUG_MODE_DEFAULT = process.env["GODOT_DEBUG"] === "true" || DEBUG_MODE;
   SERVER_VERSION = (() => {
     try {
-      const pkg = JSON.parse(readFileSync4(new URL("../package.json", import.meta.url), "utf8"));
+      const pkg = JSON.parse(readFileSync5(new URL("../package.json", import.meta.url), "utf8"));
       return typeof pkg.version === "string" ? pkg.version : "0.0.0";
     } catch {
       return "0.0.0";
@@ -8357,7 +8394,7 @@ var init_server_version = __esm(() => {
 });
 
 // src/issues.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 import process7 from "node:process";
 function feedbackNotice(every) {
   return JSON.stringify({
@@ -8376,7 +8413,7 @@ function runtime() {
 function defectSignature(where, message) {
   const normalised = `${where}
 ${message}`.toLowerCase().replaceAll("\\", "/").replaceAll(/(?:[a-z]:)?(?:\/+[\w.-]+){2,}/gu, "<path>").replaceAll(/\d+/gu, "0");
-  return createHash("sha256").update(normalised).digest("hex").slice(0, 8);
+  return createHash2("sha256").update(normalised).digest("hex").slice(0, 8);
 }
 function facts(where, message, godotVersion) {
   return [
@@ -8482,8 +8519,8 @@ var init_issues = __esm(() => {
 });
 
 // src/class-cache.ts
-import { existsSync as existsSync7, readdirSync as readdirSync3, readFileSync as readFileSync5, statSync as statSync2 } from "node:fs";
-import { join as join8 } from "node:path";
+import { existsSync as existsSync8, readdirSync as readdirSync3, readFileSync as readFileSync6, statSync as statSync3 } from "node:fs";
+import { join as join9 } from "node:path";
 function declaredClasses(projectPath) {
   const declared = new Map;
   eachScript(projectPath, (script, source) => {
@@ -8496,18 +8533,18 @@ function declaredClasses(projectPath) {
 }
 function eachScript(projectPath, each) {
   const visit = (directory, prefix) => {
-    if (existsSync7(join8(directory, ".gdignore"))) {
+    if (existsSync8(join9(directory, ".gdignore"))) {
       return;
     }
     for (const entry of readdirSync3(directory, { withFileTypes: true })) {
       if (entry.name.startsWith(".")) {
         continue;
       }
-      const path = join8(directory, entry.name);
+      const path = join9(directory, entry.name);
       if (entry.isDirectory()) {
         visit(path, `${prefix}${entry.name}/`);
       } else if (entry.isFile() && entry.name.endsWith(".gd")) {
-        each(`res://${prefix}${entry.name}`, readFileSync5(path, "utf8"));
+        each(`res://${prefix}${entry.name}`, readFileSync6(path, "utf8"));
       }
     }
   };
@@ -8556,12 +8593,12 @@ function codeOf(source) {
   return code;
 }
 function cachedClasses(projectPath) {
-  const cache = join8(projectPath, ".godot", "global_script_class_cache.cfg");
-  if (!existsSync7(cache)) {
+  const cache = join9(projectPath, ".godot", "global_script_class_cache.cfg");
+  if (!existsSync8(cache)) {
     return null;
   }
   const listed = new Map;
-  const text = readFileSync5(cache, "utf8");
+  const text = readFileSync6(cache, "utf8");
   for (const entry of text.matchAll(/"class":\s*&"([^"]+)"[\s\S]*?"path":\s*"([^"]+)"/g)) {
     listed.set(entry[1] ?? "", entry[2] ?? "");
   }
@@ -8604,32 +8641,33 @@ function missingMemberIn(message) {
   if (called !== null) {
     return { kind: "static method", member: called[1] ?? "", type: called[2] ?? "" };
   }
-  const inBase = /Cannot find member "([A-Za-z_]\w*)" in base "([A-Za-z_]\w*)((?:\.[A-Za-z_]\w*)*)"/.exec(message);
+  const inBase = /Cannot find member "([A-Za-z_]\w*)" in base "([A-Za-z_]\w*)(?:\.([A-Za-z_]\w*))?"/.exec(message);
   if (inBase === null) {
     return null;
   }
   const member = inBase[1] ?? "";
   const type = inBase[2] ?? "";
-  const within = (inBase[3] ?? "").split(".").filter((part) => part !== "");
-  const enumName = within.at(-1);
+  const enumName = inBase[3];
   return enumName === undefined ? { kind: "member", member, type } : { kind: "enum member", member, type, enum: enumName };
 }
 function declaresMember(source, missing) {
   const name = missing.member.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const top = String.raw`^(?:@\w+(?:\([^)]*\))?\s+)*`;
+  const declared = (kinds) => new RegExp(String.raw`${top}(?:${kinds})\s+${name}\b`, "m").test(source);
   if (missing.kind === "method") {
-    return new RegExp(String.raw`^\s*(?:static\s+)?func\s+${name}\s*\(`, "m").test(source);
+    return new RegExp(String.raw`${top}(?:static\s+)?func\s+${name}\s*\(`, "m").test(source);
   }
   if (missing.kind === "static method") {
-    return new RegExp(String.raw`^\s*static\s+func\s+${name}\s*\(`, "m").test(source);
+    return new RegExp(String.raw`${top}static\s+func\s+${name}\s*\(`, "m").test(source);
   }
   if (missing.kind === "enum member") {
     return enumValues(source, missing.enum ?? "").includes(missing.member);
   }
-  const kinds = missing.kind === "property" ? "var|const|enum|class|signal|func" : "var|const|enum|class|signal";
-  return new RegExp(String.raw`^\s*(?:static\s+)?(?:@\w+(?:\([^)]*\))?\s+)*(?:${kinds})\s+${name}\b`, "m").test(source) || enumValues(source, null).includes(missing.member);
+  const kinds = missing.kind === "property" ? String.raw`(?:static\s+)?(?:var|func)|const|enum|class|signal` : String.raw`static\s+(?:var|func)|const|enum|class`;
+  return declared(kinds) || enumValues(source, null).includes(missing.member);
 }
 function enumValues(source, named) {
-  const opening = named === null ? /^\s*enum\s*\{([^}]*)\}/gm : new RegExp(String.raw`^\s*enum\s+${named.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\s*\{([^}]*)\}`, "gm");
+  const opening = named === null ? /^enum\s*\{([^}]*)\}/gm : new RegExp(String.raw`^enum\s+${named.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\s*\{([^}]*)\}`, "gm");
   const values = [];
   for (const [, body] of source.matchAll(opening)) {
     const uncommented = (body ?? "").split(`
@@ -8672,21 +8710,22 @@ function classesNamedIn(source, known) {
   return [...named].sort();
 }
 function contradictedDiagnostics(messages, classes, sourceOf) {
+  const keyOf = (missing) => [missing.type, missing.enum ?? "", missing.member].join(".");
+  const denials = messages.map((message) => missingMemberIn(message)).filter((missing) => missing !== null);
+  const calledOnTheClass = new Set(denials.filter((missing) => missing.kind === "static method").map((missing) => keyOf(missing)));
   const read = new Map;
   const found = new Map;
-  for (const message of messages) {
-    const missing = missingMemberIn(message);
-    const declaredIn = missing === null ? undefined : classes.get(missing.type);
-    if (missing === null || declaredIn === undefined) {
+  for (const missing of denials) {
+    const declaredIn = classes.get(missing.type);
+    const key = keyOf(missing);
+    if (declaredIn === undefined || missing.kind === "method" && calledOnTheClass.has(key)) {
       continue;
     }
     if (!read.has(declaredIn)) {
       read.set(declaredIn, sourceOf(declaredIn));
     }
     const source = read.get(declaredIn) ?? null;
-    const key = [missing.type, missing.enum ?? "", missing.member].join(".");
-    const already = found.get(key);
-    if (source !== null && declaresMember(source, missing) && already?.kind !== "static method") {
+    if (source !== null && declaresMember(source, missing)) {
       found.set(key, { ...missing, declaredIn });
     }
   }
@@ -8725,7 +8764,8 @@ function classRemedy(entries) {
   }
   const declaring = declaringScripts(entries);
   const reload = declaring.length === 1 ? `editor_rescan with reloadScript set to ${declaring[0]}` : `editor_rescan with reloadScript, a call each for ${declaring.join(" and ")} since it takes one script,`;
-  return `For ${entries.map(written).join(", ")}, run ${reload} first. In the one project that has ` + "reproduced a stale enum member, twice, the reload cleared it at once both times, and the one " + "plain editor_rescan tried left the diagnostic standing.";
+  const oneAtATime = declaring.length === 1 ? "" : " Take them one at a time: a rescan that brings in a class also reloads every script naming it and lists them under dependentsReloaded, so a script listed there needs no call of its own.";
+  return `For ${entries.map(written).join(", ")}, run ${reload} first.${oneAtATime} In the one project ` + "that has reproduced a stale enum member, three times, the reload cleared it at once each time, " + "and the one plain editor_rescan tried left the diagnostic standing.";
 }
 function failedReloadNote(failed) {
   const missing = (before, after) => before.filter((name) => !after.includes(name));
@@ -8735,9 +8775,9 @@ function failedReloadNote(failed) {
   ];
   const unchanged = lost.length === 0 && missing(failed.heldAfter, failed.heldBefore).length === 0 && missing(failed.constantsAfter, failed.constantsBefore).length === 0;
   const answered = failed.codeName === "" ? `error ${failed.code}` : `error ${failed.code}, ${failed.codeName}`;
-  const copy = unchanged ? "The copy the editor holds is as it was, with the members under heldBeforeReload and heldConstantsBeforeReload." : `The copy the editor holds changed even so${lost.length === 0 ? "" : `, and has lost ${lost.join(", ")}`}: anything diagnosed against it now is answered from what is left, and reloading it once it compiles rebuilds it.`;
+  const copy = unchanged ? "Nothing was reloaded: the copy the editor holds is as it was, with the members under heldBeforeReload and heldConstantsBeforeReload." : `The copy the editor holds changed even so${lost.length === 0 ? "" : `, and has lost ${lost.join(", ")}`}: anything diagnosed against it now is answered from what is left, and reloading it once it compiles rebuilds it.`;
   const order = failed.names.length === 0 ? "" : ` If they deny a member of ${failed.names.join(" or ")} that its file declares, the editor's copy of that class is behind: reload that class first with reloadScript and then this script, the order that cleared it in the one project that has met this.`;
-  return `${failed.script} did not compile, so nothing was reloaded: Godot answered ${answered}. ${copy} ` + `script_diagnostics on it gives the errors.${order}`;
+  return `${failed.script} did not compile: Godot answered ${answered}. ${copy} ` + `script_diagnostics on it gives the errors.${order}`;
 }
 function uncachedClassNote(types) {
   if (types.length === 0) {
@@ -8747,9 +8787,9 @@ function uncachedClassNote(types) {
   return `${types.join(", ")} ${one ? "is declared" : "are declared"} in this project and missing from ` + `.godot/global_script_class_cache.cfg, so a game launched now would not resolve ${one ? "it" : "them"} ` + "either. Try editor_rescan first: it asks the editor already running and starts nothing, and it " + "cleared this in 314ms in a second project with a 31-worker fan-out still importing. It is not " + "always enough, because a file another engine has already imported reads as settled and the " + "walk does not look inside it. project_import refresh_classes rewrites the cache from the " + "declarations on disk and does reach that case, at the cost of a short headless engine, which " + "is worth knowing when something else is already running against this project.";
 }
 function cacheWrittenAt(projectPath) {
-  const cache = join8(projectPath, ".godot", "global_script_class_cache.cfg");
+  const cache = join9(projectPath, ".godot", "global_script_class_cache.cfg");
   try {
-    return statSync2(cache).mtimeMs;
+    return statSync3(cache).mtimeMs;
   } catch {
     return null;
   }
@@ -8761,14 +8801,14 @@ function declaredSince(projectPath, paths, names, since) {
       return false;
     }
     try {
-      return statSync2(join8(projectPath, path.slice("res://".length))).mtimeMs > since;
+      return statSync3(join9(projectPath, path.slice("res://".length))).mtimeMs > since;
     } catch {
       return false;
     }
   });
 }
 function cachedAtMissingPaths(cached, projectPath) {
-  return [...cached].filter(([, path]) => path.startsWith("res://") && !existsSync7(join8(projectPath, path.slice("res://".length)))).map(([name]) => name).sort();
+  return [...cached].filter(([, path]) => path.startsWith("res://") && !existsSync8(join9(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);
@@ -15955,7 +15995,7 @@ var init_paths = __esm(() => {
 });
 
 // src/resources.ts
-import { readFileSync as readFileSync6 } from "node:fs";
+import { readFileSync as readFileSync7 } from "node:fs";
 import { extname, resolve as resolve2 } from "node:path";
 function ensureProjectPath(getProjectPath) {
   const projectPath = getProjectPath();
@@ -16121,7 +16161,7 @@ function readResourceText(uri, getProjectPath) {
   const parsedUri = parseGodotUri(uri);
   if (parsedUri.kind === "project-info") {
     const projectFilePath = resolveProjectFile(projectPath, "project.godot");
-    const rawProject = readFileSync6(projectFilePath, "utf-8");
+    const rawProject = readFileSync7(projectFilePath, "utf-8");
     const parsedProject = parseProjectGodot(rawProject);
     return {
       mimeType: "application/json",
@@ -16130,7 +16170,7 @@ function readResourceText(uri, getProjectPath) {
   }
   const filePath = resolveProjectFile(projectPath, parsedUri.resourcePath);
   ensureAllowedExtension(parsedUri.kind, filePath);
-  const text = readFileSync6(filePath, "utf-8");
+  const text = readFileSync7(filePath, "utf-8");
   return {
     mimeType: parsedUri.kind === "script" ? "text/x-gdscript" : "text/plain",
     text
@@ -16259,42 +16299,42 @@ function readParams(params, key) {
 
 // src/setup.ts
 import { spawnSync } from "node:child_process";
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 import {
   cpSync,
-  existsSync as existsSync8,
+  existsSync as existsSync9,
   mkdirSync as mkdirSync4,
   readdirSync as readdirSync4,
-  readFileSync as readFileSync7,
+  readFileSync as readFileSync8,
   rmdirSync,
-  rmSync as rmSync4,
-  statSync as statSync3,
-  writeFileSync as writeFileSync5
+  rmSync as rmSync5,
+  statSync as statSync4,
+  writeFileSync as writeFileSync6
 } from "node:fs";
-import { dirname as dirname4, join as join9 } from "node:path";
+import { dirname as dirname4, join as join10 } from "node:path";
 import { fileURLToPath } from "node:url";
 function editorAddonDigest(from = shippedAddonsDirectory()) {
-  const hash = createHash2("sha256");
+  const hash = createHash3("sha256");
   const walk = (directory, relative) => {
     for (const name of readdirSync4(directory).sort()) {
       if (name === VERSION_MARKER || name === DIGEST_MARKER) {
         continue;
       }
-      const path = join9(directory, name);
+      const path = join10(directory, name);
       const inside = `${relative}/${name}`;
-      if (statSync3(path).isDirectory()) {
+      if (statSync4(path).isDirectory()) {
         walk(path, inside);
       } else {
         hash.update(`${inside}
 `);
-        hash.update(readFileSync7(path));
+        hash.update(readFileSync8(path));
         hash.update(`
 `);
       }
     }
   };
   for (const name of EDITOR_PLUGINS) {
-    walk(join9(from, name), name);
+    walk(join10(from, name), name);
   }
   return hash.digest("hex");
 }
@@ -16309,58 +16349,58 @@ function shippedEditorDigest() {
   return shippedDigest ?? undefined;
 }
 function installedEditorDigest(projectPath) {
-  const marker = join9(projectPath, "addons", ADDONS[0], DIGEST_MARKER);
-  if (!existsSync8(marker)) {
+  const marker = join10(projectPath, "addons", ADDONS[0], DIGEST_MARKER);
+  if (!existsSync9(marker)) {
     return null;
   }
-  const said = readFileSync7(marker, "utf8").trim();
+  const said = readFileSync8(marker, "utf8").trim();
   return said === "" ? null : said;
 }
 function shippedAddonsDirectory() {
-  return join9(dirname4(fileURLToPath(import.meta.url)), "godot", "addons");
+  return join10(dirname4(fileURLToPath(import.meta.url)), "godot", "addons");
 }
 function shippedOperationsScript() {
-  return join9(dirname4(fileURLToPath(import.meta.url)), "godot", "operations", "godot_operations.gd");
+  return join10(dirname4(fileURLToPath(import.meta.url)), "godot", "operations", "godot_operations.gd");
 }
 function installAddons(projectPath, from = shippedAddonsDirectory()) {
   const installed = [];
   for (const name of ADDONS) {
-    const source = join9(from, name);
-    if (!existsSync8(join9(source, name === "gdharness_runtime" ? "runtime_autoload.gd" : "plugin.cfg"))) {
+    const source = join10(from, name);
+    if (!existsSync9(join10(source, name === "gdharness_runtime" ? "runtime_autoload.gd" : "plugin.cfg"))) {
       throw new Error(`The package holds no ${name} addon at ${source}.`);
     }
-    const target = join9(projectPath, "addons", name);
-    const replaced = existsSync8(target);
-    rmSync4(target, { recursive: true, force: true });
+    const target = join10(projectPath, "addons", name);
+    const replaced = existsSync9(target);
+    rmSync5(target, { recursive: true, force: true });
     mkdirSync4(dirname4(target), { recursive: true });
     cpSync(source, target, { recursive: true });
-    writeFileSync5(join9(target, VERSION_MARKER), `${SERVER_VERSION}
+    writeFileSync6(join10(target, VERSION_MARKER), `${SERVER_VERSION}
 `);
     installed.push({ name, path: target, replaced });
   }
-  writeFileSync5(join9(projectPath, "addons", ADDONS[0], DIGEST_MARKER), `${editorAddonDigest(from)}
+  writeFileSync6(join10(projectPath, "addons", ADDONS[0], DIGEST_MARKER), `${editorAddonDigest(from)}
 `);
   return installed;
 }
 function installedAddonVersion(projectPath) {
-  const marker = join9(projectPath, "addons", ADDONS[0], VERSION_MARKER);
-  if (!existsSync8(marker)) {
+  const marker = join10(projectPath, "addons", ADDONS[0], VERSION_MARKER);
+  if (!existsSync9(marker)) {
     return null;
   }
-  const said = readFileSync7(marker, "utf8").trim();
+  const said = readFileSync8(marker, "utf8").trim();
   return said === "" ? null : said;
 }
 function removeAddons(projectPath) {
   const removed = [];
   for (const name of ADDONS) {
-    const target = join9(projectPath, "addons", name);
-    if (existsSync8(target)) {
-      rmSync4(target, { recursive: true, force: true });
+    const target = join10(projectPath, "addons", name);
+    if (existsSync9(target)) {
+      rmSync5(target, { recursive: true, force: true });
       removed.push(target);
     }
   }
-  const addons = join9(projectPath, "addons");
-  if (removed.length > 0 && existsSync8(addons) && readdirSync4(addons).length === 0) {
+  const addons = join10(projectPath, "addons");
+  if (removed.length > 0 && existsSync9(addons) && readdirSync4(addons).length === 0) {
     rmdirSync(addons);
     removed.push(addons);
   }
@@ -16394,7 +16434,7 @@ function loaderAmong(projectPath, named) {
     }
     let source = null;
     try {
-      source = readFileSync7(join9(projectPath, path), "utf8");
+      source = readFileSync8(join10(projectPath, path), "utf8");
     } catch {}
     if (source?.includes(RUNTIME_AUTOLOAD.path)) {
       return { name: entry, path, exists: true };
@@ -16436,10 +16476,10 @@ function enabledPlugins(settings) {
 function inspectProject(projectPath) {
   const problems = [];
   const addons = ADDONS.map((name) => {
-    const directory = join9(projectPath, "addons", name);
-    const marker = join9(directory, VERSION_MARKER);
-    const installed = existsSync8(directory);
-    const version = existsSync8(marker) ? readFileSync7(marker, "utf8").trim() : null;
+    const directory = join10(projectPath, "addons", name);
+    const marker = join10(directory, VERSION_MARKER);
+    const installed = existsSync9(directory);
+    const version = existsSync9(marker) ? readFileSync8(marker, "utf8").trim() : null;
     const current = version === SERVER_VERSION;
     if (!installed) {
       problems.push(`addons/${name} is not installed; run gdharness setup`);
@@ -16448,7 +16488,7 @@ function inspectProject(projectPath) {
     }
     return { name, installed, version, current };
   });
-  const settings = parseProjectGodot(readFileSync7(join9(projectPath, "project.godot"), "utf8"));
+  const settings = parseProjectGodot(readFileSync8(join10(projectPath, "project.godot"), "utf8"));
   const pluginsEnabled = enabledPlugins(settings);
   for (const name of EDITOR_PLUGINS) {
     if (!pluginsEnabled.includes(name)) {
@@ -16464,7 +16504,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 (!existsSync8(join9(projectPath, path))) {
+    if (!existsSync9(join10(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`);
       }
@@ -17754,7 +17794,7 @@ var init_tool_definitions = __esm(() => {
         },
         value: {
           ops: ["until"],
-          description: "until: the value to wait for, fitted to the property's type. On a property declared to hold an object, null, which the text null also means; any other value is refused, since the property can never hold it."
+          description: "until: the value to wait for, fitted to the property's type. 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."
         },
         says: {
           type: "string",
@@ -32586,10 +32626,10 @@ var init_stdio2 = __esm(() => {
 });
 
 // src/runtime-client.ts
-import { existsSync as existsSync10, readdirSync as readdirSync6, readFileSync as readFileSync9, statSync as statSync4, unlinkSync } from "node:fs";
+import { existsSync as existsSync11, readdirSync as readdirSync6, readFileSync as readFileSync10, statSync as statSync5, unlinkSync } from "node:fs";
 import { createConnection } from "node:net";
 import { tmpdir as tmpdir3 } from "node:os";
-import { dirname as dirname7, join as join12, resolve as resolve3 } from "node:path";
+import { dirname as dirname7, join as join13, resolve as resolve3 } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 function runtimeDirectory(variables = process.env) {
   const explicit = envValue("GDHARNESS_RUNTIME_DIR", variables);
@@ -32597,20 +32637,20 @@ function runtimeDirectory(variables = process.env) {
     return explicit;
   }
   const perUser = envValue("XDG_RUNTIME_DIR", variables);
-  return join12(perUser ?? tmpdir3(), "gdharness");
+  return join13(perUser ?? tmpdir3(), "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(join12(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
+    candidates.push(join13(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
   }
   return [...new Set(candidates.map((path) => resolve3(path)))];
 }
 function errorReportOf(pid, directories = runtimeDirectories()) {
   for (const directory of directories) {
-    const path = join12(directory, `runtime-${pid}.log`);
-    if (existsSync10(path)) {
+    const path = join13(directory, `runtime-${pid}.log`);
+    if (existsSync11(path)) {
       return path;
     }
   }
@@ -32641,7 +32681,7 @@ function reportAlreadyInTranscript(transcript, report) {
 function parseAnnouncement(file, pid) {
   let fields;
   try {
-    fields = asParams(JSON.parse(readFileSync9(file, "utf8")));
+    fields = asParams(JSON.parse(readFileSync10(file, "utf8")));
   } catch {
     return { kind: "rubbish" };
   }
@@ -32658,7 +32698,7 @@ function parseAnnouncement(file, pid) {
   };
   let announcedAt;
   try {
-    announcedAt = statSync4(file).mtimeMs;
+    announcedAt = statSync5(file).mtimeMs;
   } catch {}
   const when = announcedAt === undefined ? {} : { announcedAt };
   if (protocol !== RUNTIME_PROTOCOL) {
@@ -32699,7 +32739,7 @@ function discoverRuntimes(directories = runtimeDirectories()) {
 function wentAway(file, pid) {
   let project = "";
   try {
-    const fields = asParams(JSON.parse(readFileSync9(file, "utf8")));
+    const fields = asParams(JSON.parse(readFileSync10(file, "utf8")));
     project = readString(readParams(fields, "project") ?? {}, "path") ?? "";
   } catch {
     return;
@@ -32742,7 +32782,7 @@ function strangersAmong(candidates, now, startTimes = startTimesOf) {
   }).map((one) => one.file));
 }
 function announcedIn(directory) {
-  if (!existsSync10(directory)) {
+  if (!existsSync11(directory)) {
     return [];
   }
   const found = [];
@@ -32751,20 +32791,20 @@ function announcedIn(directory) {
   for (const entry of readdirSync6(directory)) {
     const report = ERROR_REPORT_PATTERN.exec(entry);
     if (report) {
-      sweepErrorReport(join12(directory, entry), Number.parseInt(report[1] ?? "", 10));
+      sweepErrorReport(join13(directory, entry), Number.parseInt(report[1] ?? "", 10));
       continue;
     }
     const match = ANNOUNCEMENT_PATTERN.exec(entry);
     if (!match) {
       continue;
     }
-    const file = join12(directory, entry);
+    const file = join13(directory, entry);
     const pid = Number.parseInt(match[1] ?? "", 10);
     const running = alive(pid);
     entries.push({ file, pid, running });
     if (running) {
       try {
-        candidates.push({ file, pid, writtenAt: statSync4(file).mtimeMs });
+        candidates.push({ file, pid, writtenAt: statSync5(file).mtimeMs });
       } catch {}
     }
   }
@@ -32786,7 +32826,7 @@ function announcedIn(directory) {
     found.push(announced);
   }
   const held = new Set(entries.map((one) => one.file));
-  const here = join12(directory, ".");
+  const here = join13(directory, ".");
   for (const file of verdicts.keys()) {
     if (dirname7(file) === here && !held.has(file)) {
       verdicts.delete(file);
@@ -32795,7 +32835,7 @@ function announcedIn(directory) {
   return found;
 }
 async function announcementEnded(pid, directories = runtimeDirectories()) {
-  const files = directories.map((directory) => join12(directory, `runtime-${pid}.json`)).filter((file) => existsSync10(file));
+  const files = directories.map((directory) => join13(directory, `runtime-${pid}.json`)).filter((file) => existsSync11(file));
   const first = files[0];
   if (first === undefined) {
     return;
@@ -32821,7 +32861,7 @@ function sweepErrorReport(path, pid, now = Date.now()) {
     return;
   }
   try {
-    if (now - statSync4(path).mtimeMs >= ERROR_REPORT_KEEP_MS) {
+    if (now - statSync5(path).mtimeMs >= ERROR_REPORT_KEEP_MS) {
       unlinkSync(path);
     }
   } catch {}
@@ -33095,14 +33135,14 @@ var init_runtime_client = __esm(() => {
 });
 
 // src/boot-note.ts
-import { mkdirSync as mkdirSync6, readFileSync as readFileSync10, writeFileSync as writeFileSync7 } from "node:fs";
-import { dirname as dirname8, join as join13 } from "node:path";
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync11, writeFileSync as writeFileSync8 } from "node:fs";
+import { dirname as dirname8, join as join14 } from "node:path";
 function bootNotePath(projectPath) {
-  return join13(projectPath, ".godot", "gdharness-boot.json");
+  return join14(projectPath, ".godot", "gdharness-boot.json");
 }
 function readBootNote(projectPath) {
   try {
-    const noted = readNumber(asParams(JSON.parse(readFileSync10(bootNotePath(projectPath), "utf8"))), "announcedAfterMs");
+    const noted = readNumber(asParams(JSON.parse(readFileSync11(bootNotePath(projectPath), "utf8"))), "announcedAfterMs");
     return noted !== undefined && Number.isFinite(noted) && noted > 0 ? noted : null;
   } catch {
     return null;
@@ -33112,7 +33152,7 @@ function writeBootNote(projectPath, announcedAfterMs) {
   try {
     const path = bootNotePath(projectPath);
     mkdirSync6(dirname8(path), { recursive: true });
-    writeFileSync7(path, JSON.stringify({ announcedAfterMs: Math.round(announcedAfterMs), at: new Date().toISOString() }, null, 2), "utf8");
+    writeFileSync8(path, JSON.stringify({ announcedAfterMs: Math.round(announcedAfterMs), at: new Date().toISOString() }, null, 2), "utf8");
   } catch {}
 }
 function halfAsLongAgain(lastBootMs) {
@@ -33130,10 +33170,10 @@ var init_boot_note = __esm(() => {
 });
 
 // src/breakpoint-note.ts
-import { mkdirSync as mkdirSync7, readFileSync as readFileSync11, rmSync as rmSync6, writeFileSync as writeFileSync8 } from "node:fs";
-import { dirname as dirname9, isAbsolute as isAbsolute2, join as join14, relative as relative2 } from "node:path";
+import { mkdirSync as mkdirSync7, readFileSync as readFileSync12, rmSync as rmSync7, writeFileSync as writeFileSync9 } from "node:fs";
+import { dirname as dirname9, isAbsolute as isAbsolute2, join as join15, relative as relative2 } from "node:path";
 function breakpointNotePath(projectPath) {
-  return join14(projectPath, ".godot", "gdharness-breakpoints.json");
+  return join15(projectPath, ".godot", "gdharness-breakpoints.json");
 }
 function writeBreakpointNote(projectPath, held) {
   const path = breakpointNotePath(projectPath);
@@ -33141,7 +33181,7 @@ function writeBreakpointNote(projectPath, held) {
   const inside = held.map((one) => ({ scriptPath: realPathOr(one.scriptPath), lines: one.lines })).filter((one) => one.lines.length > 0 && withinProject(root, one.scriptPath));
   try {
     if (inside.length === 0) {
-      rmSync6(path, { force: true });
+      rmSync7(path, { force: true });
       return;
     }
     const note = {
@@ -33151,7 +33191,7 @@ function writeBreakpointNote(projectPath, held) {
       }))
     };
     mkdirSync7(dirname9(path), { recursive: true });
-    writeFileSync8(path, `${JSON.stringify(note, null, 2)}
+    writeFileSync9(path, `${JSON.stringify(note, null, 2)}
 `, "utf8");
   } catch (error) {
     console.error(`[SERVER] Could not record the breakpoints at ${path}: ${errorMessage(error)}`);
@@ -33159,7 +33199,7 @@ function writeBreakpointNote(projectPath, held) {
 }
 function readBreakpointNote(projectPath) {
   try {
-    const parsed = JSON.parse(readFileSync11(breakpointNotePath(projectPath), "utf8"));
+    const parsed = JSON.parse(readFileSync12(breakpointNotePath(projectPath), "utf8"));
     if (typeof parsed !== "object" || parsed === null || !Array.isArray(parsed.breakpoints)) {
       return [];
     }
@@ -33174,7 +33214,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(join14(projectPath, script)), lines });
+        held.push({ scriptPath: realPathOr(join15(projectPath, script)), lines });
       }
     }
     return held;
@@ -33192,14 +33232,14 @@ var init_breakpoint_note = __esm(() => {
 });
 
 // src/class-note.ts
-import { mkdirSync as mkdirSync8, readFileSync as readFileSync12, writeFileSync as writeFileSync9 } from "node:fs";
-import { dirname as dirname10, join as join15 } from "node:path";
+import { mkdirSync as mkdirSync8, readFileSync as readFileSync13, writeFileSync as writeFileSync10 } from "node:fs";
+import { dirname as dirname10, join as join16 } from "node:path";
 function classNotePath(projectPath) {
-  return join15(projectPath, ".godot", "gdharness-classes.json");
+  return join16(projectPath, ".godot", "gdharness-classes.json");
 }
 function readClassNote(projectPath) {
   try {
-    const fields = asParams(JSON.parse(readFileSync12(classNotePath(projectPath), "utf8")));
+    const fields = asParams(JSON.parse(readFileSync13(classNotePath(projectPath), "utf8")));
     const rebuiltWith = readArray(fields, "rebuiltWith");
     if (rebuiltWith === undefined || !rebuiltWith.every((name) => typeof name === "string")) {
       return null;
@@ -33217,23 +33257,23 @@ function writeClassNote(projectPath, note) {
   try {
     const path = classNotePath(projectPath);
     mkdirSync8(dirname10(path), { recursive: true });
-    writeFileSync9(path, `${JSON.stringify(note, null, 2)}
+    writeFileSync10(path, `${JSON.stringify(note, null, 2)}
 `, "utf8");
   } catch {}
 }
 var init_class_note = () => {};
 
 // src/config-pin.ts
-import { existsSync as existsSync11, readFileSync as readFileSync13 } from "node:fs";
-import { join as join16 } from "node:path";
+import { existsSync as existsSync12, readFileSync as readFileSync14 } from "node:fs";
+import { join as join17 } from "node:path";
 function versionsNamedInConfig(projectPath) {
-  const config = join16(projectPath, ".mcp.json");
-  if (!existsSync11(config)) {
+  const config = join17(projectPath, ".mcp.json");
+  if (!existsSync12(config)) {
     return [];
   }
   let text;
   try {
-    text = readFileSync13(config, "utf8");
+    text = readFileSync14(config, "utf8");
     JSON.parse(text);
   } catch {
     return [];
@@ -33993,25 +34033,25 @@ var init_desktop = () => {};
 // src/editor-log.ts
 import {
   closeSync,
-  existsSync as existsSync12,
+  existsSync as existsSync13,
   mkdirSync as mkdirSync9,
   openSync,
-  readFileSync as readFileSync14,
+  readFileSync as readFileSync15,
   readSync,
-  rmSync as rmSync7,
-  statSync as statSync5,
-  writeFileSync as writeFileSync10
+  rmSync as rmSync8,
+  statSync as statSync6,
+  writeFileSync as writeFileSync11
 } from "node:fs";
-import { dirname as dirname11, join as join17 } from "node:path";
+import { dirname as dirname11, join as join18 } from "node:path";
 function editorLogPath(projectPath) {
-  return join17(projectPath, ".godot", "gdharness-editor.log");
+  return join18(projectPath, ".godot", "gdharness-editor.log");
 }
 function editorLogNotePath(projectPath) {
-  return join17(projectPath, ".godot", "gdharness-editor.json");
+  return join18(projectPath, ".godot", "gdharness-editor.json");
 }
 function readEditorLogNote(projectPath) {
   try {
-    const fields = asParams(JSON.parse(readFileSync14(editorLogNotePath(projectPath), "utf8")));
+    const fields = asParams(JSON.parse(readFileSync15(editorLogNotePath(projectPath), "utf8")));
     const pid = readNumber(fields, "pid");
     const startedAt = readString(fields, "startedAt");
     return pid !== undefined && Number.isInteger(pid) && pid > 0 && startedAt !== undefined ? { pid, startedAt } : null;
@@ -34023,15 +34063,15 @@ function clearEditorLog(projectPath) {
   try {
     const path = editorLogPath(projectPath);
     mkdirSync9(dirname11(path), { recursive: true });
-    rmSync7(path, { force: true });
-    rmSync7(editorLogNotePath(projectPath), { force: true });
+    rmSync8(path, { force: true });
+    rmSync8(editorLogNotePath(projectPath), { force: true });
   } catch {}
 }
 function writeEditorLogNote(projectPath, pid) {
   try {
     const path = editorLogNotePath(projectPath);
     mkdirSync9(dirname11(path), { recursive: true });
-    writeFileSync10(path, JSON.stringify({ pid, startedAt: new Date().toISOString() }, null, 2), "utf8");
+    writeFileSync11(path, JSON.stringify({ pid, startedAt: new Date().toISOString() }, null, 2), "utf8");
   } catch {}
 }
 function theConsoleWasNotCaptured(why, projectPath) {
@@ -34052,7 +34092,7 @@ function editorConsole(projectPath, editorPid, openedByAServer) {
     return { kind: "older server", notedPid: noted?.pid ?? null };
   }
   const path = editorLogPath(projectPath);
-  if (!existsSync12(path)) {
+  if (!existsSync13(path)) {
     return { kind: "not written" };
   }
   const log = new GameLog;
@@ -34062,9 +34102,9 @@ function editorConsole(projectPath, editorPid, openedByAServer) {
   return { log, path, ...of === undefined ? {} : { readBytes: text.length, of } };
 }
 function theFirstOf(path) {
-  const whole = statSync5(path).size;
+  const whole = statSync6(path).size;
   if (whole <= MOST_CONSOLE_BYTES) {
-    return { text: readFileSync14(path, "utf8") };
+    return { text: readFileSync15(path, "utf8") };
   }
   const handle = openSync(path, "r");
   try {
@@ -38589,13 +38629,13 @@ var init_process_time = __esm(() => {
 });
 
 // src/project-scan.ts
-import { existsSync as existsSync13, readdirSync as readdirSync7, readFileSync as readFileSync15 } from "node:fs";
-import { join as join18 } from "node:path";
+import { existsSync as existsSync14, readdirSync as readdirSync7, readFileSync as readFileSync16 } from "node:fs";
+import { join as join19 } from "node:path";
 function skipped(name) {
   return name.startsWith(".") || SKIPPED.has(name);
 }
 function steppedOver(directory) {
-  return existsSync13(join18(directory, ".gdignore"));
+  return existsSync14(join19(directory, ".gdignore"));
 }
 function projectStructure(projectPath) {
   const structure = { scenes: 0, scripts: 0, assets: 0, other: 0 };
@@ -38608,7 +38648,7 @@ function projectStructure(projectPath) {
         continue;
       }
       if (entry.isDirectory()) {
-        visit(join18(directory, entry.name));
+        visit(join19(directory, entry.name));
       } else if (entry.isFile()) {
         const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
         if (extension === "tscn") {
@@ -38638,14 +38678,14 @@ function scriptsWithoutUid(projectPath) {
       }
       const spelled = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
       if (entry.isDirectory()) {
-        visit(join18(directory, entry.name), spelled);
+        visit(join19(directory, entry.name), spelled);
         continue;
       }
       if (!entry.isFile()) {
         continue;
       }
       const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
-      if (CARRIES_A_UID.has(extension) && !existsSync13(join18(directory, `${entry.name}.uid`))) {
+      if (CARRIES_A_UID.has(extension) && !existsSync14(join19(directory, `${entry.name}.uid`))) {
         found.push(spelled);
       }
     }
@@ -38680,7 +38720,7 @@ function searchProject(projectPath, options) {
       if (skipped(entry.name)) {
         continue;
       }
-      const entryPath = join18(directory, entry.name);
+      const entryPath = join19(directory, entry.name);
       if (entry.isDirectory()) {
         visit(entryPath);
         continue;
@@ -38691,7 +38731,7 @@ function searchProject(projectPath, options) {
       }
       result.summary.files_searched += 1;
       const matches = [];
-      for (const [index, line] of readFileSync15(entryPath, "utf8").split(`
+      for (const [index, line] of readFileSync16(entryPath, "utf8").split(`
 `).entries()) {
         if (full()) {
           break;
@@ -38719,27 +38759,6 @@ var init_project_scan = __esm(() => {
   CARRIES_A_UID = new Set(["gd", "shader", "gdshader"]);
 });
 
-// src/reimport.ts
-import { createHash as createHash3 } from "node:crypto";
-import { existsSync as existsSync14, readFileSync as readFileSync16, rmSync as rmSync8, statSync as statSync6, utimesSync, writeFileSync as writeFileSync11 } from "node:fs";
-import { basename as basename3, join as join19 } from "node:path";
-function forceNextImport(projectPath, resourcePath) {
-  const relative = resourcePath.replace(/^res:\/\//, "");
-  const sidecar = join19(projectPath, `${relative}.import`);
-  if (!existsSync14(sidecar)) {
-    return;
-  }
-  const { atime, mtimeMs } = statSync6(sidecar);
-  writeFileSync11(sidecar, readFileSync16(sidecar, "utf8").replace(/^valid=false\r?\n/m, ""));
-  utimesSync(sidecar, atime, new Date(mtimeMs + 2000));
-  rmSync8(importRecord(projectPath, resourcePath), { force: true });
-}
-function importRecord(projectPath, resourcePath) {
-  const digest = createHash3("md5").update(resourcePath).digest("hex");
-  return join19(projectPath, ".godot", "imported", `${basename3(resourcePath)}-${digest}.md5`);
-}
-var init_reimport = () => {};
-
 // src/restart-note.ts
 import { mkdirSync as mkdirSync10, readFileSync as readFileSync17, rmSync as rmSync9, writeFileSync as writeFileSync12 } from "node:fs";
 import { dirname as dirname13, join as join20 } from "node:path";
@@ -40650,7 +40669,7 @@ class GodotServer {
         uidsCreated: given,
         stillWithoutUid: after,
         note: uidsLeftNote(after.length),
-        ...imported.librariesRetried === undefined ? {} : { extensionNote: extensionRetryNote(imported.librariesRetried) }
+        ...imported.extensionNote === undefined ? {} : { extensionNote: imported.extensionNote }
       }
     }, scanned));
   }
@@ -40795,19 +40814,16 @@ class GodotServer {
       if (!engine.ok) {
         return { ok: false, response: engine.response };
       }
-      for (const target of targets) {
-        forceNextImport(projectPath, target);
-      }
       const scanned = await this.untilTheEditorsScanIsWritten(projectPath);
-      const imported = await runImport(engine.value, projectPath);
+      const imported = await runImport(engine.value, projectPath, { forcing: targets });
       if (!imported.ok) {
         return { ok: false, response: this.answer(withScanWait(imported, scanned)) };
       }
       if (imported.messages.length > 0) {
         extra["engine_messages"] = imported.messages;
       }
-      if (imported.librariesRetried !== undefined) {
-        extra["extensionNote"] = extensionRetryNote(imported.librariesRetried);
+      if (imported.extensionNote !== undefined) {
+        extra["extensionNote"] = imported.extensionNote;
       }
     }
     const after = await this.operation("get_import_status", resourcePath === undefined ? { includeUpToDate: true } : { resourcePath }, projectPath);
@@ -41298,7 +41314,7 @@ class GodotServer {
     const notes = [];
     if (contradicted.length > 0) {
       const dependsOn = new Set;
-      for (const one of contradicted) {
+      for (const one of contradicted.filter((entry) => entry.kind === "method" || entry.kind === "property")) {
         const source = cached === null ? null : this.sourceOfClass(projectPath, one.declaredIn);
         if (source === null || cached === null) {
           continue;
@@ -41338,9 +41354,10 @@ class GodotServer {
     });
   }
   classesAScriptNames(projectPath, scriptPath) {
-    const source = this.sourceOfClass(projectPath, scriptPath);
+    const resourcePath = scriptPath.startsWith("res://") ? scriptPath : `res://${scriptPath.replace(/^\/+/, "")}`;
+    const source = this.sourceOfClass(projectPath, resourcePath);
     const known = cachedClasses(projectPath) ?? declaredClasses(projectPath);
-    return source === null ? [] : classesNamedIn(source, known).filter((name) => known.get(name) !== scriptPath);
+    return source === null ? [] : classesNamedIn(source, known).filter((name) => known.get(name) !== resourcePath);
   }
   sourceOfClass(projectPath, resourcePath) {
     const contained = resolveWithinProject(projectPath, resourcePath);
@@ -43626,7 +43643,6 @@ var init_server3 = __esm(() => {
   init_process_children();
   init_process_time();
   init_project_scan();
-  init_reimport();
   init_resources();
   init_restart_note();
   init_run_record();
@@ -44586,8 +44602,8 @@ init_setup();
 // src/skill.ts
 init_setup();
 init_tool_definitions();
-import { existsSync as existsSync9, mkdirSync as mkdirSync5, readdirSync as readdirSync5, rmSync as rmSync5, writeFileSync as writeFileSync6 } from "node:fs";
-import { basename as basename2, dirname as dirname5, join as join10 } from "node:path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync5, readdirSync as readdirSync5, rmSync as rmSync6, writeFileSync as writeFileSync7 } from "node:fs";
+import { basename as basename3, dirname as dirname5, join as join11 } from "node:path";
 
 // src/tool-reference.ts
 init_headless_operations();
@@ -44683,7 +44699,7 @@ function renderToolsMarkdown() {
 
 // src/skill.ts
 var SKILL_NAME = "gdharness";
-var SHARED_SKILLS = join10(".agents", "skills");
+var SHARED_SKILLS = join11(".agents", "skills");
 function skillMarkdown(version) {
   return `---
 name: ${SKILL_NAME}
@@ -44874,27 +44890,27 @@ whatever the engine said on stderr comes back under \`engine_messages\`.
 function skillFiles(version) {
   return new Map([
     ["SKILL.md", skillMarkdown(version)],
-    [join10("references", "tools.md"), renderToolsMarkdown()]
+    [join11("references", "tools.md"), renderToolsMarkdown()]
   ]);
 }
 function skillDirectories(harnesses, projectPath, exists) {
-  const directories = [join10(projectPath, SHARED_SKILLS, SKILL_NAME)];
+  const directories = [join11(projectPath, SHARED_SKILLS, SKILL_NAME)];
   for (const harness of harnesses) {
     if (harness.skills === undefined) {
       continue;
     }
-    const own = join10(projectPath, harness.skills.dir);
-    if ((!harness.skills.shared || exists(own)) && !directories.includes(join10(own, SKILL_NAME))) {
-      directories.push(join10(own, SKILL_NAME));
+    const own = join11(projectPath, harness.skills.dir);
+    if ((!harness.skills.shared || exists(own)) && !directories.includes(join11(own, SKILL_NAME))) {
+      directories.push(join11(own, SKILL_NAME));
     }
   }
   return directories;
 }
 function everySkillDirectory(projectPath, harnesses) {
-  const directories = new Set([join10(projectPath, SHARED_SKILLS, SKILL_NAME)]);
+  const directories = new Set([join11(projectPath, SHARED_SKILLS, SKILL_NAME)]);
   for (const harness of harnesses) {
     if (harness.skills !== undefined) {
-      directories.add(join10(projectPath, harness.skills.dir, SKILL_NAME));
+      directories.add(join11(projectPath, harness.skills.dir, SKILL_NAME));
     }
   }
   return [...directories];
@@ -44902,8 +44918,8 @@ function everySkillDirectory(projectPath, harnesses) {
 function removeSkill(directories, projectPath) {
   const removed = [];
   for (const directory of directories) {
-    if (existsSync9(directory)) {
-      rmSync5(directory, { recursive: true, force: true });
+    if (existsSync10(directory)) {
+      rmSync6(directory, { recursive: true, force: true });
       pruneEmpty(dirname5(directory), projectPath);
       removed.push(directory);
     }
@@ -44911,43 +44927,43 @@ function removeSkill(directories, projectPath) {
   return removed;
 }
 function pruneEmpty(directory, projectPath) {
-  const shared = join10(projectPath, ".agents");
+  const shared = join11(projectPath, ".agents");
   let path = directory;
-  while (path !== projectPath && (basename2(path) === "skills" || path === shared)) {
+  while (path !== projectPath && (basename3(path) === "skills" || path === shared)) {
     if (readdirSync5(path).length > 0) {
       return;
     }
-    rmSync5(path, { recursive: true, force: true });
+    rmSync6(path, { recursive: true, force: true });
     path = dirname5(path);
   }
 }
 function writeSkill(directories, version) {
   const files = skillFiles(version);
   return directories.map((directory) => {
-    const replaced = existsSync9(directory);
-    rmSync5(directory, { recursive: true, force: true });
+    const replaced = existsSync10(directory);
+    rmSync6(directory, { recursive: true, force: true });
     for (const [name, contents] of files) {
-      const path = join10(directory, name);
+      const path = join11(directory, name);
       mkdirSync5(dirname5(path), { recursive: true });
-      writeFileSync6(path, contents, "utf8");
+      writeFileSync7(path, contents, "utf8");
     }
     return { path: directory, replaced };
   });
 }
 
 // src/version.ts
-import { readFileSync as readFileSync8 } from "node:fs";
-import { dirname as dirname6, join as join11 } from "node:path";
+import { readFileSync as readFileSync9 } from "node:fs";
+import { dirname as dirname6, join as join12 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function getLocalVersion() {
   const currentDirectory = dirname6(fileURLToPath2(import.meta.url));
   const packageCandidates = [
-    join11(currentDirectory, "..", "package.json"),
-    join11(currentDirectory, "..", "..", "package.json")
+    join12(currentDirectory, "..", "package.json"),
+    join12(currentDirectory, "..", "..", "package.json")
   ];
   for (const packagePath of packageCandidates) {
     try {
-      const value = JSON.parse(readFileSync8(packagePath, "utf-8"));
+      const value = JSON.parse(readFileSync9(packagePath, "utf-8"));
       if (typeof value === "object" && value !== null && "name" in value && value.name === "gdharness" && "version" in value && typeof value.version === "string") {
         return value.version;
       }