gdharness 1.0.12 → 1.0.14

package/build/godot/addons/gdharness_editor/bridge_client.gd

@@ -13,6 +13,8 @@ const Read = preload("reading.gd")
 const DEFAULT_URL: String = "ws://127.0.0.1:6505/godot"
 ## Written beside the addon by the install, so it names the version this copy came from.
 const VERSION_MARKER: String = "res://addons/gdharness_editor/.gdharness-version"
+## Written beside it, kept in step with `DIGEST_MARKER` in src/setup.ts.
+const DIGEST_MARKER: String = "res://addons/gdharness_editor/.gdharness-digest"
 ## Written by the server that serves this project, saying where its bridge actually is. Kept in
 ## step with `announcementPath` in src/bridge-announce.ts.
 const ANNOUNCEMENT: String = "res://.godot/gdharness-bridge.json"
@@ -70,6 +72,8 @@ var server_url: String = DEFAULT_URL
 ## What this copy was when it loaded, which is what the editor is running until it is restarted.
 ## See [method _loaded_version] for why it is held rather than read when it is wanted.
 var version_at_load: String = ""
+## The digest of the editor addon code this copy loaded, held for the same reason.
+var digest_at_load: String = ""
 
 var _is_connected: bool = false
 var _reconnect_timer: Timer
@@ -98,6 +102,7 @@ var _connecting_for: float = 0.0
 func _ready() -> void:
 	_project_path = ProjectSettings.globalize_path("res://")
 	version_at_load = _loaded_version()
+	digest_at_load = _loaded_digest()
 	_keep_breakpoints_through_sessions()
 	OS.set_environment(EDITOR_PID_VARIABLE, str(OS.get_process_id()))
 
@@ -290,6 +295,7 @@ func _handle_connect() -> void:
 			"type": "godot_ready",
 			"project_path": _project_path,
 			"addon_version": version_at_load,
+			"addon_digest": digest_at_load,
 			"editor_pid": OS.get_process_id(),
 			"lsp_port": _serves(LSP_ASKED, LSP_SETTING),
 			"dap_port": _serves(DAP_ASKED, DAP_SETTING),
@@ -408,9 +414,19 @@ func _serving(setting: String) -> int:
 ## and `addonIsStale` reporting false over an editor still running the old code, which is exactly
 ## what it exists to catch.
 func _loaded_version() -> String:
-	if not FileAccess.file_exists(VERSION_MARKER):
+	return _read_marker(VERSION_MARKER)
+
+
+## The same for the digest of the editor addon code, which an upgrade that leaves the code alone
+## rewrites unchanged, so the server can tell an editor that needs a restart from one that does not.
+func _loaded_digest() -> String:
+	return _read_marker(DIGEST_MARKER)
+
+
+func _read_marker(path: String) -> String:
+	if not FileAccess.file_exists(path):
 		return ""
-	var file: FileAccess = FileAccess.open(VERSION_MARKER, FileAccess.READ)
+	var file: FileAccess = FileAccess.open(path, FileAccess.READ)
 	if file == null:
 		return ""
 	var text: String = file.get_as_text().strip_edges()

package/build/index.js

@@ -10047,11 +10047,20 @@ var SERVER_VERSION = (() => {
   }
 })();
 var UNVERSIONED = "an addon from before versions were reported";
-function addonMismatch(addonVersion, serverVersion) {
-  if (addonVersion === serverVersion) {
+function editorIsStale(addonVersion, serverVersion, addonDigest, shippedDigest) {
+  if (addonDigest !== undefined && addonDigest !== "" && shippedDigest !== undefined) {
+    return addonDigest !== shippedDigest;
+  }
+  return addonVersion !== serverVersion;
+}
+function addonMismatch(addonVersion, serverVersion, addonDigest, shippedDigest) {
+  if (!editorIsStale(addonVersion, serverVersion, addonDigest, shippedDigest)) {
     return;
   }
   const reported = addonVersion ?? "";
+  if (reported === serverVersion) {
+    return `The editor is running a different build of the ${reported} addon from the one this server ships. Restart it with editor_launch restart to pick this one up.`;
+  }
   const editor = reported === "" ? UNVERSIONED : `the ${reported} addon`;
   const both = `The editor is running ${editor} while this server ships ${serverVersion}.`;
   if (reported !== "" && isNewer(reported, serverVersion)) {
@@ -10059,8 +10068,8 @@ function addonMismatch(addonVersion, serverVersion) {
   }
   return `${both} Restart it with editor_launch restart to pick the new one up.`;
 }
-function markIfStale(answer, addonVersion, serverVersion) {
-  const staleNote = addonMismatch(addonVersion, serverVersion);
+function markIfStale(answer, addonVersion, serverVersion, addonDigest, shippedDigest) {
+  const staleNote = addonMismatch(addonVersion, serverVersion, addonDigest, shippedDigest);
   if (staleNote === undefined || typeof answer !== "object" || answer === null || Array.isArray(answer)) {
     return answer;
   }
@@ -10178,16 +10187,16 @@ import {
   mkdirSync as mkdirSync10,
   mkdtempSync as mkdtempSync2,
   openSync as openSync3,
-  readdirSync as readdirSync6,
+  readdirSync as readdirSync7,
   readFileSync as readFileSync16,
   readSync as readSync2,
   rmdirSync,
-  statSync as statSync6
+  statSync as statSync7
 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
 import { basename as basename3, dirname as dirname10, isAbsolute as isAbsolute3, join as join16, normalize as normalize2, relative as relative3 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { promisify as promisify5 } from "node:util";
 
 // node_modules/zod/v3/helpers/util.js
@@ -24761,7 +24770,7 @@ import { dirname as dirname2, join as join3 } from "node:path";
 import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync3, statSync, unlinkSync } from "node:fs";
 import { createConnection } from "node:net";
 import { tmpdir as tmpdir2 } from "node:os";
-import { dirname, join as join2, resolve } from "node:path";
+import { dirname, join as join2, resolve as resolve2 } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 
 // src/launch.ts
@@ -24828,6 +24837,65 @@ function environmentFor(options, variables = process.env) {
 }
 var SAVES_NOT_MOVED_NOTE = "On macOS the engine reads user:// off HOME and ignores the variables that move it elsewhere, measured on Godot 4.7.2, so this run wrote its saves where the player keeps theirs. A suite that saves a game has written into the same folder as the copy being played, and one that tidies up after itself may have removed real saves.";
 
+// src/paths.ts
+import { realpathSync } from "node:fs";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+var RESOURCE_SCHEME = "res://";
+var OTHER_SCHEME = /^[a-zA-Z][a-zA-Z\d+.-]+:\/\//;
+function realPathOr(path) {
+  try {
+    return realpathSync.native(path);
+  } catch {
+    return path;
+  }
+}
+function isSameDirectory(onePath, otherPath) {
+  return relative(realPathOr(resolve(onePath)), realPathOr(resolve(otherPath))) === "";
+}
+function isWithinRoot(rootPath, candidatePath) {
+  const step = relative(resolve(rootPath), resolve(candidatePath));
+  return step !== ".." && !step.startsWith(`..${sep}`) && !isAbsolute(step);
+}
+function resolveWithinProject(projectPath, candidatePath) {
+  const trimmed = candidatePath.trim();
+  if (trimmed === "") {
+    return { ok: false, reason: "Path is empty." };
+  }
+  if (trimmed.includes("\x00")) {
+    return { ok: false, reason: "Path contains a null byte." };
+  }
+  const withoutScheme = trimmed.startsWith(RESOURCE_SCHEME) ? trimmed.slice(RESOURCE_SCHEME.length) : trimmed;
+  const scheme = OTHER_SCHEME.exec(withoutScheme);
+  if (scheme) {
+    return {
+      ok: false,
+      reason: `Path '${trimmed}' uses the '${scheme[0]}' scheme, which names somewhere other than this project.`
+    };
+  }
+  if (withoutScheme.startsWith("/") || withoutScheme.startsWith("\\") || isAbsolute(withoutScheme)) {
+    return {
+      ok: false,
+      reason: `Path '${trimmed}' is absolute; give a path inside the project, such as 'scenes/main.tscn'.`
+    };
+  }
+  if (withoutScheme.includes(":")) {
+    return {
+      ok: false,
+      reason: `Path '${trimmed}' contains ':', which no file inside a project is named with.`
+    };
+  }
+  const root = resolve(projectPath);
+  const absolutePath = resolve(root, withoutScheme);
+  if (!isWithinRoot(root, absolutePath)) {
+    return { ok: false, reason: `Path '${trimmed}' resolves outside the project directory.` };
+  }
+  const relativePath = relative(root, absolutePath).split(sep).join("/");
+  if (relativePath === "") {
+    return { ok: false, reason: `Path '${trimmed}' is the project directory itself, not a file in it.` };
+  }
+  return { ok: true, absolutePath, relativePath };
+}
+
 // src/process-children.ts
 import { execFile, execFileSync, spawnSync } from "node:child_process";
 import { basename } from "node:path";
@@ -25101,7 +25169,7 @@ function runtimeDirectories(variables = process.env) {
   for (const base of fallbacks) {
     candidates.push(join2(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
   }
-  return [...new Set(candidates.map((path) => resolve(path)))];
+  return [...new Set(candidates.map((path) => resolve2(path)))];
 }
 var ERROR_REPORT_PATTERN = /^runtime-(\d+)\.log$/;
 function errorReportOf(pid, directories = runtimeDirectories()) {
@@ -25196,8 +25264,7 @@ function announcedAndGone(projectPath) {
     return [];
   }
   const since = Date.now() - GONE_WINDOW_MS;
-  const wanted = resolve(projectPath);
-  return gone.filter((one) => one.noticedAt >= since && resolve(one.project) === wanted);
+  return gone.filter((one) => one.noticedAt >= since && isSameDirectory(one.project, projectPath));
 }
 var STARTED_AFTER_ANNOUNCING_MS = 2000;
 var CONFIRMED_FOR_MS = 60000;
@@ -25310,11 +25377,10 @@ function sweepErrorReport(path, pid, now = Date.now()) {
 var LOOK_EVERY_MS = 50;
 var ANNOUNCE_BUDGET_MS = 5000;
 async function announcedSince(projectPath, before, waiting = {}) {
-  const wanted = resolve(projectPath);
   const directories = waiting.directories ?? runtimeDirectories();
   const until = Date.now() + Math.max(waiting.budgetMs ?? ANNOUNCE_BUDGET_MS, 0);
   for (;; ) {
-    const fresh = discoverRuntimes(directories).find((endpoint) => !before.has(endpoint.pid) && resolve(endpoint.project.path) === wanted && (waiting.accept?.(endpoint) ?? true));
+    const fresh = discoverRuntimes(directories).find((endpoint) => !before.has(endpoint.pid) && isSameDirectory(endpoint.project.path, projectPath) && (waiting.accept?.(endpoint) ?? true));
     if (fresh !== undefined) {
       return fresh;
     }
@@ -25335,7 +25401,7 @@ function theOneProject(endpoints) {
   if (endpoints.some((endpoint) => endpoint.project.path === "")) {
     return;
   }
-  const paths = new Set(endpoints.map((endpoint) => resolve(endpoint.project.path)));
+  const paths = new Set(endpoints.map((endpoint) => realPathOr(resolve2(endpoint.project.path))));
   const only = [...paths][0];
   return paths.size === 1 ? only : undefined;
 }
@@ -25364,9 +25430,9 @@ function chooseRuntime(endpoints, projectPath, unspoken = [], pid) {
   if (pid !== undefined) {
     const named = endpoints.find((endpoint) => endpoint.pid === pid);
     if (named !== undefined) {
-      if (projectPath !== undefined && resolve(named.project.path) !== resolve(projectPath)) {
+      if (projectPath !== undefined && !isSameDirectory(named.project.path, projectPath)) {
         return {
-          problem: `The game with pid ${pid} is running ${named.project.path}, not ${resolve(projectPath)}. Running: ${endpoints.map(describe2).join("; ")}.`
+          problem: `The game with pid ${pid} is running ${named.project.path}, not ${resolve2(projectPath)}. Running: ${endpoints.map(describe2).join("; ")}.`
         };
       }
       return { endpoint: named };
@@ -25406,8 +25472,8 @@ function chooseRuntime(endpoints, projectPath, unspoken = [], pid) {
     };
   }
   if (projectPath !== undefined) {
-    const wanted = resolve(projectPath);
-    const matching = endpoints.filter((endpoint) => resolve(endpoint.project.path) === wanted);
+    const wanted = resolve2(projectPath);
+    const matching = endpoints.filter((endpoint) => isSameDirectory(endpoint.project.path, wanted));
     if (matching.length === 0) {
       return {
         problem: `No running game is from ${wanted}. Running: ${endpoints.map(describe2).join("; ")}.`
@@ -25551,67 +25617,6 @@ function waitSizedTo(lastBootMs, usual = ANNOUNCE_BUDGET_MS) {
 // src/breakpoint-note.ts
 import { mkdirSync as mkdirSync3, readFileSync as readFileSync5, rmSync, writeFileSync as writeFileSync3 } from "node:fs";
 import { dirname as dirname3, isAbsolute as isAbsolute2, join as join4, relative as relative2 } from "node:path";
-
-// src/paths.ts
-import { realpathSync } from "node:fs";
-import { isAbsolute, relative, resolve as resolve2, sep } from "node:path";
-var RESOURCE_SCHEME = "res://";
-var OTHER_SCHEME = /^[a-zA-Z][a-zA-Z\d+.-]+:\/\//;
-function realPathOr(path) {
-  try {
-    return realpathSync.native(path);
-  } catch {
-    return path;
-  }
-}
-function isSameDirectory(onePath, otherPath) {
-  return relative(realPathOr(resolve2(onePath)), realPathOr(resolve2(otherPath))) === "";
-}
-function isWithinRoot(rootPath, candidatePath) {
-  const step = relative(resolve2(rootPath), resolve2(candidatePath));
-  return step !== ".." && !step.startsWith(`..${sep}`) && !isAbsolute(step);
-}
-function resolveWithinProject(projectPath, candidatePath) {
-  const trimmed = candidatePath.trim();
-  if (trimmed === "") {
-    return { ok: false, reason: "Path is empty." };
-  }
-  if (trimmed.includes("\x00")) {
-    return { ok: false, reason: "Path contains a null byte." };
-  }
-  const withoutScheme = trimmed.startsWith(RESOURCE_SCHEME) ? trimmed.slice(RESOURCE_SCHEME.length) : trimmed;
-  const scheme = OTHER_SCHEME.exec(withoutScheme);
-  if (scheme) {
-    return {
-      ok: false,
-      reason: `Path '${trimmed}' uses the '${scheme[0]}' scheme, which names somewhere other than this project.`
-    };
-  }
-  if (withoutScheme.startsWith("/") || withoutScheme.startsWith("\\") || isAbsolute(withoutScheme)) {
-    return {
-      ok: false,
-      reason: `Path '${trimmed}' is absolute; give a path inside the project, such as 'scenes/main.tscn'.`
-    };
-  }
-  if (withoutScheme.includes(":")) {
-    return {
-      ok: false,
-      reason: `Path '${trimmed}' contains ':', which no file inside a project is named with.`
-    };
-  }
-  const root = resolve2(projectPath);
-  const absolutePath = resolve2(root, withoutScheme);
-  if (!isWithinRoot(root, absolutePath)) {
-    return { ok: false, reason: `Path '${trimmed}' resolves outside the project directory.` };
-  }
-  const relativePath = relative(root, absolutePath).split(sep).join("/");
-  if (relativePath === "") {
-    return { ok: false, reason: `Path '${trimmed}' is the project directory itself, not a file in it.` };
-  }
-  return { ok: true, absolutePath, relativePath };
-}
-
-// src/breakpoint-note.ts
 function breakpointNotePath(projectPath) {
   return join4(projectPath, ".godot", "gdharness-breakpoints.json");
 }
@@ -25849,6 +25854,19 @@ function cacheWrittenAt(projectPath) {
     return null;
   }
 }
+function declaredSince(projectPath, paths, names, since) {
+  return names.filter((name) => {
+    const path = paths.get(name);
+    if (path === undefined || !path.startsWith("res://")) {
+      return false;
+    }
+    try {
+      return statSync2(join6(projectPath, path.slice("res://".length))).mtimeMs > since;
+    } catch {
+      return false;
+    }
+  });
+}
 function cachedAtMissingPaths(cached, projectPath) {
   return [...cached].filter(([, path]) => path.startsWith("res://") && !existsSync3(join6(projectPath, path.slice("res://".length)))).map(([name]) => name).sort();
 }
@@ -27179,6 +27197,7 @@ class GodotBridge extends EventEmitter {
       connectedAt: this.connectionInfo?.connectedAt,
       lastPongAt: this.connectionInfo?.lastPongAt,
       addonVersion: this.connectionInfo?.addonVersion,
+      addonDigest: this.connectionInfo?.addonDigest,
       editorPid: this.connectionInfo?.editorPid,
       lspPort: this.connectionInfo?.lspPort,
       dapPort: this.connectionInfo?.dapPort,
@@ -27322,6 +27341,7 @@ class GodotBridge extends EventEmitter {
           }
           this.connectionInfo.projectPath = message.project_path;
           this.connectionInfo.addonVersion = message.addon_version ?? "";
+          this.connectionInfo.addonDigest = message.addon_digest;
           this.connectionInfo.editorPid = message.editor_pid;
           this.connectionInfo.lspPort = servedPort(message.lsp_port);
           this.connectionInfo.dapPort = servedPort(message.dap_port);
@@ -29456,14 +29476,66 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
 }
 
 // src/setup.ts
-import { cpSync, existsSync as existsSync9, mkdirSync as mkdirSync9, readFileSync as readFileSync15, rmSync as rmSync7, writeFileSync as writeFileSync10 } from "node:fs";
+import { createHash as createHash3 } from "node:crypto";
+import {
+  cpSync,
+  existsSync as existsSync9,
+  mkdirSync as mkdirSync9,
+  readdirSync as readdirSync6,
+  readFileSync as readFileSync15,
+  rmSync as rmSync7,
+  statSync as statSync6,
+  writeFileSync as writeFileSync10
+} from "node:fs";
 import { dirname as dirname9, join as join15 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 var ADDONS = ["gdharness_editor", "gdharness_runtime", "auto_reload"];
+var EDITOR_PLUGINS = ["gdharness_editor", "auto_reload"];
 var RUNTIME_AUTOLOAD = {
   name: "GdharnessRuntime",
   path: "addons/gdharness_runtime/runtime_autoload.gd"
 };
 var VERSION_MARKER = ".gdharness-version";
+var DIGEST_MARKER = ".gdharness-digest";
+function editorAddonDigest(from = shippedAddonsDirectory()) {
+  const hash = createHash3("sha256");
+  const walk = (directory, relative) => {
+    for (const name of readdirSync6(directory).sort()) {
+      if (name === VERSION_MARKER || name === DIGEST_MARKER) {
+        continue;
+      }
+      const path = join15(directory, name);
+      const inside = `${relative}/${name}`;
+      if (statSync6(path).isDirectory()) {
+        walk(path, inside);
+      } else {
+        hash.update(`${inside}
+`);
+        hash.update(readFileSync15(path));
+        hash.update(`
+`);
+      }
+    }
+  };
+  for (const name of EDITOR_PLUGINS) {
+    walk(join15(from, name), name);
+  }
+  return hash.digest("hex");
+}
+var shippedDigest;
+function shippedEditorDigest() {
+  if (shippedDigest === undefined) {
+    try {
+      shippedDigest = editorAddonDigest();
+    } catch {
+      shippedDigest = null;
+    }
+  }
+  return shippedDigest ?? undefined;
+}
+function shippedAddonsDirectory() {
+  return join15(dirname9(fileURLToPath2(import.meta.url)), "godot", "addons");
+}
 function installedAddonVersion(projectPath) {
   const marker = join15(projectPath, "addons", ADDONS[0], VERSION_MARKER);
   if (!existsSync9(marker)) {
@@ -30657,7 +30729,7 @@ function buildToolDefinitions() {
 var UPDATE_NOTICE_EVERY = 500;
 var FEEDBACK_NOTICE_EVERY = 250;
 var run5 = promisify5(execFile5);
-var __dirname2 = dirname10(fileURLToPath2(import.meta.url));
+var __dirname2 = dirname10(fileURLToPath3(import.meta.url));
 var EDITOR_RESTART_TIMEOUT_MS = 90000;
 var HOLD_PING_MS = 2000;
 var SLOWEST_FRAME_RATE = 20;
@@ -30951,7 +31023,7 @@ function elsewhereIn(projectPath, asked) {
   const root = (wanted.split("/")[0] ?? "").toLowerCase();
   let near = [];
   try {
-    near = readdirSync6(projectPath, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.toLowerCase() !== root).map((entry) => entry.name).filter((name) => name.toLowerCase().startsWith("test") || root.startsWith(name.toLowerCase()));
+    near = readdirSync7(projectPath, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.toLowerCase() !== root).map((entry) => entry.name).filter((name) => name.toLowerCase().startsWith("test") || root.startsWith(name.toLowerCase()));
   } catch {
     return "";
   }
@@ -32111,7 +32183,7 @@ class GodotServer {
     let report = null;
     let reportProblem = null;
     try {
-      const written = existsSync10(reportsDir) ? readdirSync6(reportsDir).filter((name) => name.startsWith("report_")).sort((a, b) => Number(a.slice("report_".length)) - Number(b.slice("report_".length))) : [];
+      const written = existsSync10(reportsDir) ? readdirSync7(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(readFileSync16(join16(reportsDir, newest, "results.xml"), "utf8"));
@@ -32240,7 +32312,7 @@ class GodotServer {
       warnings: diagnostics.length - errors,
       diagnostics,
       ...disagrees
-    }, this.godotBridge.getStatus().addonVersion, SERVER_VERSION));
+    }, this.godotBridge.getStatus().addonVersion, SERVER_VERSION, this.godotBridge.getStatus().addonDigest, shippedEditorDigest()));
   }
   whereTheFileDisagrees(diagnostics, args) {
     const messages = diagnostics.map((entry) => asParams(entry)["message"]).filter((message) => typeof message === "string");
@@ -32427,7 +32499,7 @@ class GodotServer {
   getEditorStatusPayload() {
     const status = this.godotBridge.getStatus();
     const isPortConflict = this.bridgeStartupError?.includes("EADDRINUSE") ?? false;
-    const stale = status.connected && status.addonVersion !== SERVER_VERSION;
+    const stale = status.connected && editorIsStale(status.addonVersion, SERVER_VERSION, status.addonDigest, shippedEditorDigest());
     const unfinished = this.restartLeftUnfinished(status.connected);
     return {
       ...status,
@@ -32444,7 +32516,7 @@ class GodotServer {
       awaitingLaunchedEditor: status.connected || !this.launchedEditorIsUp() ? undefined : this.launchedEditor?.pid ?? undefined,
       ...status.connected ? this.whatTheLaunchedEditorDropped() : {},
       startupError: this.bridgeStartupError,
-      staleNote: stale ? addonMismatch(status.addonVersion, SERVER_VERSION) : undefined,
+      staleNote: stale ? addonMismatch(status.addonVersion, SERVER_VERSION, status.addonDigest, shippedEditorDigest()) : undefined,
       ...this.breakpointsAtRisk(),
       retryingBridge: this.bridgeRetry === null ? undefined : true,
       announcedAt: this.announcedAt ?? undefined,
@@ -32576,8 +32648,8 @@ class GodotServer {
       editorPid: now.editorPid,
       addonVersion: now.addonVersion,
       serverVersion: SERVER_VERSION,
-      addonIsStale: now.addonVersion !== SERVER_VERSION,
-      staleNote: addonMismatch(now.addonVersion, SERVER_VERSION),
+      addonIsStale: editorIsStale(now.addonVersion, SERVER_VERSION, now.addonDigest, shippedEditorDigest()),
+      staleNote: addonMismatch(now.addonVersion, SERVER_VERSION, now.addonDigest, shippedEditorDigest()),
       ...this.whatTheEditorDropped(settingsBefore, after),
       tookMs: Date.now() - began
     });
@@ -32854,7 +32926,7 @@ class GodotServer {
     }
     let announcedAt;
     try {
-      announcedAt = statSync6(endpoint.file).mtimeMs;
+      announcedAt = statSync7(endpoint.file).mtimeMs;
     } catch {
       return;
     }
@@ -33464,7 +33536,15 @@ class GodotServer {
         "editor_launch opens one, and an editor opened here has its console captured"
       ]);
     }
-    const console2 = editorConsole(projectPath, status.editorPid ?? null, status.openedByAServer === true);
+    const launched = status.connected ? null : this.launchedEditor?.pid ?? null;
+    if (!status.connected && launched === null) {
+      return this.createErrorResponse("No editor is connected, so there is no console to read.", [
+        "editor_status says whether one is connected and whether it may yet be",
+        "editor_launch opens one, and an editor opened here has its console captured"
+      ]);
+    }
+    const editorPid = status.connected ? status.editorPid ?? null : launched;
+    const console2 = editorConsole(projectPath, editorPid, status.connected ? status.openedByAServer === true : true);
     if ("kind" in console2) {
       return this.createErrorResponse(theConsoleWasNotCaptured(console2, projectPath), [
         "editor_launch restart replaces this editor with one whose console is captured",
@@ -33482,8 +33562,9 @@ class GodotServer {
     const grouped = bursts(everything, readPositiveNumber(args, "before") ?? 3);
     const shown = grouped.slice(0, MOST_GROUPS);
     return this.jsonTextResponse({
-      editorPid: status.editorPid,
+      editorPid: editorPid ?? undefined,
       projectPath,
+      ...status.connected ? {} : this.launchedEditorIsUp() ? { stillConnecting: true } : { exitedBeforeConnecting: true },
       capturedIn: console2.path,
       ...console2.of === undefined ? {} : {
         readFromTheStart: console2.readBytes,
@@ -33782,6 +33863,7 @@ class GodotServer {
   }
   async rebuildClassCache(projectPath) {
     const before = cachedClasses(projectPath);
+    const writtenBefore = cacheWrittenAt(projectPath);
     const noted = readClassNote(projectPath);
     const rebuilt = await this.operation("refresh_class_cache", {}, projectPath);
     if (!rebuilt.ok) {
@@ -33792,21 +33874,30 @@ class GodotServer {
       return rebuilt;
     }
     const lost = noted === null || before === null ? [] : noted.rebuiltWith.filter((name) => !before.has(name) && after.has(name)).sort();
-    const seenLosing = lost.length > 0 && this.godotBridge.isConnected();
+    const cameBack = writtenBefore === null ? [] : declaredSince(projectPath, after, lost, writtenBefore);
+    const droppedByTheEditor = lost.filter((name) => !cameBack.includes(name));
+    const seenLosing = droppedByTheEditor.length > 0 && this.godotBridge.isConnected();
     writeClassNote(projectPath, {
       rebuiltWith: [...after.keys()].sort(),
       ...seenLosing ? { shortListEditorPid: this.godotBridge.getStatus().editorPid ?? null } : noted?.shortListEditorPid === undefined ? {} : { shortListEditorPid: noted.shortListEditorPid }
     });
-    if (!seenLosing) {
+    const notes = [];
+    if (seenLosing) {
+      const them = droppedByTheEditor.length === 1 ? "it" : "them";
+      notes.push(`The cache held ${droppedByTheEditor.join(", ")} after the last rebuild and not when this one began, so the editor holding this project wrote it without ${them} in between: it holds a list shorter than the files and writes that list on every save and scan, and each rebuild puts ${them} back. editor_launch restart is what ends it.`);
+    }
+    if (cameBack.length > 0) {
+      notes.push(`${cameBack.join(", ")} left the cache while ${cameBack.length === 1 ? "its script was" : "their scripts were"} gone: the script${cameBack.length === 1 ? " is" : "s are"} newer than the cache the editor last wrote, so it listed what was on disk then. editor_rescan picks ${cameBack.length === 1 ? "it" : "them"} up.`);
+    }
+    if (notes.length === 0) {
       return rebuilt;
     }
-    const them = lost.length === 1 ? "it" : "them";
     return {
       ...rebuilt,
       payload: {
         ...rebuilt.payload,
         lostSinceLastRebuild: lost,
-        note: `The cache held ${lost.join(", ")} after the last rebuild and not when this one began, so the editor holding this project wrote it without ${them} in between: it holds a list shorter than the files and writes that list on every save and scan, and each rebuild puts ${them} back. editor_launch restart is what ends it.`
+        note: notes.join(" ")
       }
     };
   }
@@ -33882,7 +33973,7 @@ class GodotServer {
       ]);
     }
     try {
-      return this.jsonTextResponse(markIfStale(await this.godotBridge.invokeTool(toolName, args), this.godotBridge.getStatus().addonVersion, SERVER_VERSION));
+      return this.jsonTextResponse(markIfStale(await this.godotBridge.invokeTool(toolName, args), this.godotBridge.getStatus().addonVersion, SERVER_VERSION, this.godotBridge.getStatus().addonDigest, shippedEditorDigest()));
     } catch (error) {
       return this.createErrorResponse(`The editor answered ${toolName} with an error: ${errorMessage(error)}`);
     }
@@ -33935,8 +34026,59 @@ class GodotServer {
     }
     return { heldAt: undefined, heldUnknown: true, heldNote: reply.message };
   }
+  async ownRunOnItsWay(projectPath, budgetMs) {
+    const run = this.currentRun();
+    const project = projectPath ?? run?.projectPath ?? null;
+    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync10(join16(project, RUNTIME_AUTOLOAD.path)) || !await this.runStillGoing(run)) {
+      return null;
+    }
+    const already = runtimesAnnounced().running;
+    const announcedSinceTheStart = (one) => {
+      if (run.announcedBefore !== undefined) {
+        return !run.announcedBefore.has(one.pid);
+      }
+      try {
+        return statSync7(one.file).mtimeMs >= run.startedAt;
+      } catch {
+        return false;
+      }
+    };
+    if (already.some((one) => announcedSinceTheStart(one) && this.isTheGameOf(run, one, project))) {
+      return null;
+    }
+    const which = run.throughEditor ? "the game the editor is playing for it" : `pid ${run.pid ?? "unknown"}`;
+    const comingUpUntil = run.startedAt + waitSizedTo(readBootNote(project)) + budgetMs;
+    const remaining = comingUpUntil - Date.now();
+    if (remaining <= 0) {
+      const seconds = Math.round((Date.now() - run.startedAt) / 1000);
+      return `The game this server started (${which}) has been running for ${seconds}s and has not announced its runtime, so there is nothing to talk to. A game that keeps the runtime off, as a project's own loader can for some scenes, never announces; editor_output says what it has printed.`;
+    }
+    const endpoint = await announcedSince(project, new Set(already.map((one) => one.pid)), {
+      budgetMs: Math.min(budgetMs, remaining),
+      accept: (one) => this.isTheGameOf(this.currentRun(), one, project),
+      giveUp: () => this.currentRun() !== run || this.dapClient?.isStopped() === true || !stillRunning(run)
+    });
+    if (endpoint !== null) {
+      const tiedMeanwhile = () => run.announcedPid !== undefined;
+      if (!tiedMeanwhile()) {
+        this.tie(run, endpoint);
+      }
+      return null;
+    }
+    if (this.currentRun() !== run || !await this.runStillGoing(run)) {
+      return null;
+    }
+    return `The game this server started (${which}) is still coming up and has not announced its runtime after a wait of ${Math.min(budgetMs, remaining)}ms, so there is nothing to talk to yet. It is still running: ask again in a moment rather than starting another.`;
+  }
   async handleRuntimeCommand(command, args, timeoutMs = this.runtimeTimeoutMs()) {
     const { op: _op, projectPath, pid, ...params } = asParams(args);
+    const waited = typeof pid === "number" ? null : await this.ownRunOnItsWay(typeof projectPath === "string" ? projectPath : this.ownProject, timeoutMs);
+    if (waited !== null) {
+      return this.createErrorResponse(waited, [
+        "editor_status lists it under runtimes once it has announced",
+        "editor_output says what it has printed so far"
+      ]);
+    }
     const announced = runtimesAnnounced();
     const wanted = typeof projectPath === "string" ? projectPath : this.ownProject ?? undefined;
     const own = typeof pid === "number" ? undefined : this.ownGameAmong(announced.running, wanted) ?? await this.ownGameThroughTheTree(announced.running, wanted);

package/package.json

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