gdharness 1.1.19 → 1.1.21

package/build/godot/addons/gdharness_editor/tools/scene_tools.gd

@@ -734,12 +734,17 @@ func _reread_changed_uids(filesystem: EditorFileSystem) -> Dictionary:
 	return {"reread": reread, "duplicated": duplicated}
 
 
-## Every `.uid` under [param directory], skipping what the editor skips: hidden directories and any
-## holding a `.gdignore`.
+## Every `.uid` under [param directory], skipping what the editor skips: hidden directories, any
+## holding a `.gdignore`, and any below the project's own that holds a `project.godot` of its own,
+## which the editor passes over as another project. A nested project's UIDs are never in the editor's
+## table, so without that last one its files would be read again on every rescan, and one holding a
+## copy of an outer file's `.uid` named as a duplicate on disk.
 func _uid_files(directory: String, found: Array[String]) -> void:
 	var listing: DirAccess = DirAccess.open(directory)
 	if listing == null or FileAccess.file_exists(directory.path_join(".gdignore")):
 		return
+	if directory != "res://" and FileAccess.file_exists(directory.path_join("project.godot")):
+		return
 	for child: String in listing.get_directories():
 		if not child.begins_with("."):
 			_uid_files(directory.path_join(child), found)

package/build/godot/addons/gdharness_runtime/runtime_queries.gd

@@ -684,9 +684,11 @@ func set_property(params: Dictionary) -> Dictionary:
 ## A float arrives as 64 bits and most engine properties keep 32: Camera3D.h_offset given -1.1
 ## reads back as -1.10000002384186, so comparing the two exactly took a write of the value already
 ## held for one the engine refused (#780). Rounding both to 32 bits is exact for a 32-bit property.
-## A 64-bit one can take a write this calls the same, and then reads back changed, which the caller
-## checks before calling the write unchanged. Vectors and colours hold 32-bit parts in the value
-## itself, so they already compare at the property's precision.
+## A 64-bit one can take a write this calls the same and read back changed, and the caller calls a
+## write unchanged only when it reads back as it was. What that cannot tell apart is a 64-bit
+## property whose setter ignored a value differing from the held one below 32 bits: it is answered
+## unchanged rather than refused. Vectors and colours hold 32-bit parts in the value itself, so they
+## already compare at the property's precision.
 static func _held_already(given: Variant, held: Variant) -> bool:
 	if not Values.comparable(given, held):
 		return false

package/build/godot/addons/gdharness_runtime/runtime_waits.gd

@@ -145,7 +145,11 @@ func wait_until(params: Dictionary) -> Dictionary:
 	# with null until the time ran out. #772 waited a minute for "null" that way and answered met
 	# false with value null beside it.
 	var declared: int = watched["declared"]
-	if declared == TYPE_OBJECT and wanted is String and str(wanted).strip_edges() == "null":
+	# An untyped slot holding null or an object is read the same way, as set reads it: otherwise the
+	# two ops would disagree about one property, and the wait would run out on the text null.
+	var untyped_object: bool = declared == TYPE_NIL and (current == null or typeof(current) == TYPE_OBJECT)
+	var holds_objects: bool = declared == TYPE_OBJECT or untyped_object
+	if holds_objects and wanted is String and str(wanted).strip_edges() == "null":
 		wanted = null
 	var refused: String = _not_comparable(current, wanted, node_path, property)
 	var never_held: bool = typeof(wanted) != TYPE_NIL and typeof(wanted) != TYPE_OBJECT

package/build/index.js

@@ -26153,32 +26153,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(`
@@ -26221,21 +26222,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 });
     }
   }
@@ -26274,7 +26276,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));
@@ -26284,9 +26287,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) {
@@ -28146,14 +28149,34 @@ class GodotLocator {
 
 // src/headless.ts
 import { execFile as execFile3 } from "node:child_process";
-import { writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join12 } from "node:path";
+import { writeFileSync as writeFileSync8 } from "node:fs";
+import { join as join13 } from "node:path";
 import { promisify as promisify3 } from "node:util";
 
+// src/reimport.ts
+import { createHash as createHash2 } from "node:crypto";
+import { existsSync as existsSync8, readFileSync as readFileSync11, rmSync as rmSync4, statSync as statSync5, utimesSync, writeFileSync as writeFileSync7 } from "node:fs";
+import { basename as basename2, join as join11 } from "node:path";
+function forceNextImport(projectPath, resourcePath) {
+  const relative = resourcePath.replace(/^res:\/\//, "");
+  const sidecar = join11(projectPath, `${relative}.import`);
+  if (!existsSync8(sidecar)) {
+    return;
+  }
+  const { atime, mtimeMs } = statSync5(sidecar);
+  writeFileSync7(sidecar, readFileSync11(sidecar, "utf8").replace(/^valid=false\r?\n/m, ""));
+  utimesSync(sidecar, atime, new Date(mtimeMs + 2000));
+  rmSync4(importRecord(projectPath, resourcePath), { force: true });
+}
+function importRecord(projectPath, resourcePath) {
+  const digest = createHash2("md5").update(resourcePath).digest("hex");
+  return join11(projectPath, ".godot", "imported", `${basename2(resourcePath)}-${digest}.md5`);
+}
+
 // src/scratch.ts
-import { existsSync as existsSync8, mkdtempSync, readdirSync as readdirSync4, rmSync as rmSync4 } from "node:fs";
+import { existsSync as existsSync9, mkdtempSync, readdirSync as readdirSync4, rmSync as rmSync5 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 import process7 from "node:process";
 var SWEPT = { recursive: true, force: true };
 var AGAIN_AFTER_MS = [250, 500, 1000, 2000, 4000, 8000, 16000];
@@ -28168,7 +28191,7 @@ var KINDS = [
   "tests"
 ];
 function scratchDirectory(kind) {
-  return mkdtempSync(join11(tmpdir3(), `gdharness-${kind}-${process7.pid}-`));
+  return mkdtempSync(join12(tmpdir3(), `gdharness-${kind}-${process7.pid}-`));
 }
 function sweepAbandonedScratch(directory = tmpdir3()) {
   let entries;
@@ -28184,7 +28207,7 @@ function sweepAbandonedScratch(directory = tmpdir3()) {
       continue;
     }
     try {
-      remove(join11(directory, entry));
+      remove(join12(directory, entry));
     } catch {}
   }
 }
@@ -28210,7 +28233,7 @@ function discard(...paths) {
   return left;
 }
 function remove(path) {
-  rmSync4(path, SWEPT);
+  rmSync5(path, SWEPT);
 }
 function tryAgain(path, attempt) {
   if (attempt === 0) {
@@ -28222,7 +28245,7 @@ function tryAgain(path, attempt) {
     lastTryOnExit();
   }
   const after = AGAIN_AFTER_MS[attempt];
-  if (after === undefined || !existsSync8(path)) {
+  if (after === undefined || !existsSync9(path)) {
     waiting.delete(path);
     if (after === undefined) {
       atExit.add(path);
@@ -28302,21 +28325,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", join12(logDir, "engine.log"), "--path", projectPath, "--import"], { signal: callSignal() });
+    const { stderr } = await run3(godotPath, ["--headless", "--log-file", join13(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) {
@@ -28338,12 +28376,12 @@ async function importOnce(godotPath, projectPath) {
 }
 async function runOperation(engine, operation, params, projectPath) {
   const paramsDir = scratchDirectory("params");
-  const paramsFile = join12(paramsDir, `${operation}.json`);
-  writeFileSync7(paramsFile, JSON.stringify(snakeCased(params)), "utf8");
+  const paramsFile = join13(paramsDir, `${operation}.json`);
+  writeFileSync8(paramsFile, JSON.stringify(snakeCased(params)), "utf8");
   const args = [
     "--headless",
     "--log-file",
-    join12(paramsDir, "engine.log"),
+    join13(paramsDir, "engine.log"),
     "--path",
     projectPath,
     "--script",
@@ -29399,14 +29437,14 @@ function secondsFromClock(printed) {
 }
 
 // src/project-scan.ts
-import { existsSync as existsSync9, readdirSync as readdirSync5, readFileSync as readFileSync11 } from "node:fs";
-import { join as join13 } from "node:path";
+import { existsSync as existsSync10, readdirSync as readdirSync5, readFileSync as readFileSync12 } from "node:fs";
+import { join as join14 } from "node:path";
 var SKIPPED = new Set(["node_modules"]);
 function skipped(name) {
   return name.startsWith(".") || SKIPPED.has(name);
 }
 function steppedOver(directory) {
-  return existsSync9(join13(directory, ".gdignore"));
+  return existsSync10(join14(directory, ".gdignore"));
 }
 var ASSET_EXTENSIONS = new Set(["png", "jpg", "jpeg", "webp", "svg", "ttf", "otf", "wav", "mp3", "ogg"]);
 function projectStructure(projectPath) {
@@ -29420,7 +29458,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 (extension === "tscn") {
@@ -29451,14 +29489,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) && !existsSync9(join13(directory, `${entry.name}.uid`))) {
+      if (CARRIES_A_UID.has(extension) && !existsSync10(join14(directory, `${entry.name}.uid`))) {
         found.push(spelled);
       }
     }
@@ -29493,7 +29531,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;
@@ -29504,7 +29542,7 @@ function searchProject(projectPath, options) {
       }
       result.summary.files_searched += 1;
       const matches = [];
-      for (const [index, line] of readFileSync11(entryPath, "utf8").split(`
+      for (const [index, line] of readFileSync12(entryPath, "utf8").split(`
 `).entries()) {
         if (full()) {
           break;
@@ -29526,26 +29564,6 @@ function searchProject(projectPath, options) {
   return result;
 }
 
-// src/reimport.ts
-import { createHash as createHash2 } from "node:crypto";
-import { existsSync as existsSync10, readFileSync as readFileSync12, rmSync as rmSync5, statSync as statSync5, utimesSync, writeFileSync as writeFileSync8 } from "node:fs";
-import { basename as basename2, join as join14 } from "node:path";
-function forceNextImport(projectPath, resourcePath) {
-  const relative = resourcePath.replace(/^res:\/\//, "");
-  const sidecar = join14(projectPath, `${relative}.import`);
-  if (!existsSync10(sidecar)) {
-    return;
-  }
-  const { atime, mtimeMs } = statSync5(sidecar);
-  writeFileSync8(sidecar, readFileSync12(sidecar, "utf8").replace(/^valid=false\r?\n/m, ""));
-  utimesSync(sidecar, atime, new Date(mtimeMs + 2000));
-  rmSync5(importRecord(projectPath, resourcePath), { force: true });
-}
-function importRecord(projectPath, resourcePath) {
-  const digest = createHash2("md5").update(resourcePath).digest("hex");
-  return join14(projectPath, ".godot", "imported", `${basename2(resourcePath)}-${digest}.md5`);
-}
-
 // src/resources.ts
 import { readFileSync as readFileSync13 } from "node:fs";
 import { extname, resolve as resolve4 } from "node:path";
@@ -31411,7 +31429,7 @@ var TOOL_SPECS = [
       },
       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",
@@ -33110,7 +33128,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));
   }
@@ -33255,19 +33273,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);
@@ -33758,7 +33773,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;
@@ -33798,9 +33813,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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdharness",
-  "version": "1.1.19",
+  "version": "1.1.21",
   "mcpName": "io.github.Aureliolo/gdharness",
   "description": "A harness for driving a Godot 4 project from an agent: editor addons, a runtime bridge into the running game, an MCP server in front of them, and a CLI that installs and diagnoses the Godot side.",
   "type": "module",