gdharness 1.3.53 → 1.3.54

package/build/cli.js

@@ -14312,16 +14312,76 @@ function importedIntoTheProject(projectPath, resPaths) {
 function onDisk(projectPath, resPath) {
   return join13(projectPath, resPath.slice("res://".length));
 }
-function behind(projectPath, resPath, sidecar) {
+function importedSidecarMd5s(projectPath) {
+  const found = new Map;
+  const editor = join13(projectPath, ".godot", "editor");
+  let newest = -1;
+  try {
+    for (const name of readdirSync8(editor)) {
+      const version = /^filesystem_cache(\d+)$/.exec(name)?.[1];
+      if (version !== undefined) {
+        newest = Math.max(newest, Number(version));
+      }
+    }
+  } catch {
+    return found;
+  }
+  if (newest < 0) {
+    return found;
+  }
+  let text;
+  try {
+    text = readFileSync11(join13(editor, `filesystem_cache${newest}`), "utf8");
+  } catch {
+    return found;
+  }
+  let directory = "res://";
+  for (const line of text.split(/\r?\n/).slice(1).map((one) => one.trim())) {
+    if (line === "") {
+      continue;
+    }
+    const fields = line.split("::");
+    if (line.startsWith("::")) {
+      if (fields.length === 3) {
+        directory = fields[1] ?? directory;
+      }
+      continue;
+    }
+    const slices = fields.length < 9 ? [] : (fields[7] ?? "").split("<>");
+    const md5 = slices[5];
+    if (slices.length >= 7 && md5 !== undefined && md5 !== "") {
+      found.set(`${directory}${directory.endsWith("/") ? "" : "/"}${fields[0]}`, md5);
+    }
+  }
+  return found;
+}
+function behind(projectPath, resPath, sidecarFile, sidecar, importedFrom) {
+  const imported = importedFrom.get(resPath);
+  if (imported !== undefined && md5Of(sidecarFile) !== imported) {
+    return "its import file changed after it was imported, as setting an option does";
+  }
   const remap = sectionOf(sidecar, "remap");
   const importer = unquoted(remap.get("importer"));
   if (importer === "keep" || importer === "skip") {
     return null;
   }
-  const outputs = listed2(sectionOf(sidecar, "deps").get("dest_files"));
+  const deps = sectionOf(sidecar, "deps");
+  const outputs = listed2(deps.get("dest_files"));
+  if (remap.get("valid") !== "false") {
+    if (!remap.has("uid")) {
+      return "its import file has no uid, which the import writes";
+    }
+    if (outputs.length === 0 && ![...remap.keys()].some((key) => key.startsWith("path"))) {
+      return "its import file names no imported output, as one written before the engine imports from it does";
+    }
+  }
   if (outputs.some((output) => !existsSync11(onDisk(projectPath, output)))) {
     return "its imported output is not on disk";
   }
+  const source = unquoted(deps.get("source_file"));
+  if (source !== "" && source !== resPath) {
+    return `its import file was written for ${source}`;
+  }
   const name = resPath.slice(resPath.lastIndexOf("/") + 1);
   const record = join13(projectPath, ".godot", "imported", `${name}-${createHash2("md5").update(resPath, "utf8").digest("hex")}.md5`);
   let recorded = "";
@@ -14338,6 +14398,7 @@ function behind(projectPath, resPath, sidecar) {
 }
 function staleImports(projectPath) {
   const stale = [];
+  const importedFrom = importedSidecarMd5s(projectPath);
   const visit = (directory, resDirectory) => {
     if (existsSync11(join13(directory, ".gdignore")) || existsSync11(join13(directory, VERSION_MARKER))) {
       return;
@@ -14366,13 +14427,14 @@ function staleImports(projectPath) {
         if (!names.has(entry.name.slice(0, -".import".length))) {
           continue;
         }
+        const sidecarFile = join13(directory, entry.name);
         let sidecar;
         try {
-          sidecar = readFileSync11(join13(directory, entry.name), "utf8");
+          sidecar = readFileSync11(sidecarFile, "utf8");
         } catch {
           continue;
         }
-        const reason = behind(projectPath, source, sidecar);
+        const reason = behind(projectPath, source, sidecarFile, sidecar, importedFrom);
         if (reason !== null) {
           stale.push({ path: source, reason });
         }
@@ -60197,6 +60259,7 @@ init_import_freshness();
 init_launch();
 init_library_copies();
 init_log_read();
+init_reimport();
 init_setup();
 import {
   copyFileSync,
@@ -61146,7 +61209,8 @@ async function importProject(launch) {
     console.log(`Wrote .godot/extension_list.cfg naming ${named(seeded)}, so the import loads them.`);
   }
   const cached = cachedClasses(launch.projectPath);
-  if ((seeded === null || seeded.length === 0) && cached !== null && staleAgainst(cached, launch.projectPath).length === 0 && staleImports(launch.projectPath).length === 0) {
+  const stale = staleImports(launch.projectPath);
+  if ((seeded === null || seeded.length === 0) && cached !== null && staleAgainst(cached, launch.projectPath).length === 0 && stale.length === 0) {
     console.log("The import was skipped: every imported file and the class cache are current.");
     return null;
   }
@@ -61156,6 +61220,9 @@ async function importProject(launch) {
   const lock = await launch.slots.take();
   try {
     freeLibraryCopies(launch.projectPath);
+    for (const one of stale) {
+      forceNextImport(launch.projectPath, one.path);
+    }
     const ended = await watchedEngine(launch, lock, ["--headless", "--audio-driver", "Dummy", "--path", launch.projectPath, "--import"], directory, log, launch.silenceFloorSeconds);
     if (ended.ended !== null || ended.code !== 0) {
       return `${ended.ended ?? `the engine exited ${exitNamed(ended.code ?? 0)}`}; everything it printed is in ${launch.logs.named(log)}`;

package/build/godot/operations/import_pipeline.gd

@@ -574,10 +574,21 @@ static func _import_staleness(resource_path: String, sidecar: ConfigFile) -> Dic
 	if not sidecar.has_section_key("remap", "uid"):
 		return _stale("its import file has no uid, which the import writes")
 
+	# A tool that writes a sidecar for the engine to import from leaves out what the import writes,
+	# and every load of the resource then fails. The engine's scan without its cache takes such a
+	# sidecar as imported while the record of the last import still matches the source.
+	var outputs: Array[String] = _outputs_of(sidecar)
+	if outputs.is_empty() and not _names_a_path(sidecar):
+		return _stale(
+			(
+				"its import file names no imported output, as one written before the engine "
+				+ "imports from it does"
+			)
+		)
+
 	# The sidecar alone does not say the import is there: deleting the outputs under
 	# .godot/imported is the ordinary way to force one, and a resource whose output is gone was
 	# answered as current, which is what a reimport is then skipped on.
-	var outputs: Array[String] = _outputs_of(sidecar)
 	var missing: Array[String] = []
 	for output: String in outputs:
 		if not FileAccess.file_exists(output):
@@ -786,6 +797,17 @@ static func _outputs_of(sidecar: ConfigFile) -> Array[String]:
 	return outputs
 
 
+## Whether [param sidecar]'s remap names where a load finds the import, as [code]path[/code] or a
+## [code]path.<feature>[/code] key.
+static func _names_a_path(sidecar: ConfigFile) -> bool:
+	if not sidecar.has_section("remap"):
+		return false
+	for key: String in sidecar.get_section_keys("remap"):
+		if key.begins_with("path"):
+			return true
+	return false
+
+
 ## The image files a glTF scene refers to by path, resolved against the scene's own directory.
 ## Embedded images and every other scene format answer nothing.
 static func _images_of(scene_path: String) -> Array[String]:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdharness",
-  "version": "1.3.53",
+  "version": "1.3.54",
   "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",