gdharness 1.0.11 → 1.0.13

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;
   }
@@ -10172,22 +10181,22 @@ import { execFile as execFile5, spawn } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import {
   appendFileSync,
-  closeSync,
-  existsSync as existsSync9,
+  closeSync as closeSync2,
+  existsSync as existsSync10,
   fstatSync,
-  mkdirSync as mkdirSync9,
+  mkdirSync as mkdirSync10,
   mkdtempSync as mkdtempSync2,
-  openSync as openSync2,
-  readdirSync as readdirSync6,
-  readFileSync as readFileSync15,
-  readSync,
+  openSync as openSync3,
+  readdirSync as readdirSync7,
+  readFileSync as readFileSync16,
+  readSync as readSync2,
   rmdirSync,
-  statSync as statSync5
+  statSync as statSync7
 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
-import { basename as basename3, dirname as dirname9, isAbsolute as isAbsolute3, join as join15, normalize as normalize2, relative as relative3 } from "node:path";
+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
@@ -24791,8 +24800,18 @@ function runArguments(options) {
   }
   return args;
 }
-function editorArguments(projectPath, ports) {
-  return ["-e", "--path", projectPath, "--lsp-port", String(ports.lsp), "--dap-port", String(ports.dap)];
+function editorArguments(projectPath, ports, logFile) {
+  return [
+    "-e",
+    "--path",
+    projectPath,
+    "--lsp-port",
+    String(ports.lsp),
+    "--dap-port",
+    String(ports.dap),
+    "--log-file",
+    logFile
+  ];
 }
 var OPENED_BY_A_SERVER = "GDHARNESS_OPENED_BY_A_SERVER";
 function userDataIn(home, variables = process.env) {
@@ -25318,10 +25337,37 @@ async function announcedSince(projectPath, before, waiting = {}) {
 function describe2(endpoint) {
   return `pid ${endpoint.pid} on ${endpoint.address}:${endpoint.port} (${endpoint.project.name || "unnamed"} at ${endpoint.project.path})`;
 }
+function describeWithin(endpoint) {
+  return `pid ${endpoint.pid} on ${endpoint.address}:${endpoint.port}`;
+}
+function theOneProject(endpoints) {
+  if (endpoints.some((endpoint) => endpoint.project.path === "")) {
+    return;
+  }
+  const paths = new Set(endpoints.map((endpoint) => resolve(endpoint.project.path)));
+  const only = [...paths][0];
+  return paths.size === 1 ? only : undefined;
+}
+function severalFrom(project, games) {
+  return `${games.length} games are running from ${project}: ${games.map(describeWithin).join("; ")}. ` + "Pass pid to choose one; projectPath cannot, because every one of them has this one. " + "editor_status lists them under runtimes.";
+}
+function whichHalfIsBehind(unspoken) {
+  const pids = (games) => games.map((game) => `pid ${game.pid}`).join(", ");
+  const ahead = unspoken.filter((game) => game.protocol > RUNTIME_PROTOCOL);
+  const behind = unspoken.filter((game) => game.protocol < RUNTIME_PROTOCOL);
+  if (ahead.length > 0 && behind.length > 0) {
+    return `they are on both sides of it: reconnect this server for ${pids(ahead)}, and reinstall the ` + `addon and restart ${pids(behind)}`;
+  }
+  if (ahead.length > 0) {
+    return "this server is the older half: reconnect it so it spawns the installed version";
+  }
+  return `the addon is the older half: reinstall it and restart ${behind.length === 1 ? "the game" : "those games"}`;
+}
 function tooNew(unspoken) {
   const named = unspoken.map((game) => `pid ${game.pid} speaks ${game.protocol} (${game.project.name || "unnamed"} at ${game.project.path})`).join("; ");
-  const half = unspoken.some((game) => game.protocol > RUNTIME_PROTOCOL) ? "this server is the older half: reconnect it so it spawns the installed version" : "the addon is the older half: reinstall it and restart the game";
-  return `A game is running, in a protocol this server does not speak ${named}. This server speaks ${RUNTIME_PROTOCOL}, so ${half}.`;
+  const count = unspoken.length === 1 ? "A game is running" : `${unspoken.length} games are running`;
+  const spoken = new Set(unspoken.map((game) => game.protocol)).size === 1 ? "a protocol" : "protocols";
+  return `${count}, in ${spoken} this server does not speak: ${named}. This server speaks ${RUNTIME_PROTOCOL}, so ${whichHalfIsBehind(unspoken)}.`;
 }
 function chooseRuntime(endpoints, projectPath, unspoken = [], pid) {
   if (pid !== undefined) {
@@ -25338,8 +25384,16 @@ function chooseRuntime(endpoints, projectPath, unspoken = [], pid) {
     if (tooNewToo !== undefined) {
       return { problem: tooNew([tooNewToo]) };
     }
+    if (endpoints.length > 0) {
+      return {
+        problem: `No running game has pid ${pid}. Running: ${endpoints.map(describe2).join("; ")}. editor_status lists them under runtimes as they come and go.`
+      };
+    }
+    if (unspoken.length > 0) {
+      return { problem: `No game reachable from here has pid ${pid}. ${tooNew(unspoken)}` };
+    }
     return {
-      problem: endpoints.length === 0 ? `No game with the runtime addon is running, so there is none with pid ${pid}. Start one with editor_run, or play the project from the editor with the addon enabled.` : `No running game has pid ${pid}. Running: ${endpoints.map(describe2).join("; ")}. editor_status lists them under runtimes as they come and go.`
+      problem: `No game with the runtime addon is running, so there is none with pid ${pid}. Start one with editor_run, or play the project from the editor with the addon enabled.`
     };
   }
   if (endpoints.length === 0) {
@@ -25371,15 +25425,17 @@ function chooseRuntime(endpoints, projectPath, unspoken = [], pid) {
     if (matching.length === 1 && matching[0]) {
       return { endpoint: matching[0] };
     }
-    return {
-      problem: `Several games are running from ${wanted}: ${matching.map(describe2).join("; ")}. Pass pid to choose one.`
-    };
+    return { problem: severalFrom(wanted, matching) };
   }
   if (endpoints.length === 1 && endpoints[0]) {
     return { endpoint: endpoints[0] };
   }
+  const shared = theOneProject(endpoints);
+  if (shared !== undefined) {
+    return { problem: severalFrom(shared, endpoints) };
+  }
   return {
-    problem: `Several games are running: ${endpoints.map(describe2).join("; ")}. Pass projectPath to choose one, or pid when they are from one project.`
+    problem: `Several games are running: ${endpoints.map(describe2).join("; ")}. Pass pid to choose one, or projectPath when the project you mean is running only one.`
   };
 }
 var nextRequestId = 1;
@@ -25802,6 +25858,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();
 }
@@ -26613,6 +26682,20 @@ function dictionary(entries) {
   return Object.assign(emptyRecord(), entries);
 }
 
+// src/editor-log.ts
+import {
+  closeSync,
+  existsSync as existsSync5,
+  mkdirSync as mkdirSync6,
+  openSync,
+  readFileSync as readFileSync10,
+  readSync,
+  rmSync as rmSync3,
+  statSync as statSync3,
+  writeFileSync as writeFileSync6
+} from "node:fs";
+import { dirname as dirname6, join as join9 } from "node:path";
+
 // src/game-log.ts
 import { StringDecoder } from "node:string_decoder";
 var HEADLINE = /^(USER )?(SCRIPT ERROR|SHADER ERROR|ERROR|WARNING):\s?(.*)$/;
@@ -26699,6 +26782,9 @@ class GameLog {
   count(severity) {
     return this.entries.filter((entry) => entry.severity === severity).length;
   }
+  everything() {
+    return this.entries;
+  }
   select(options) {
     const floor = options.sinceLastCall ? this.seen[options.severity] : 0;
     const wanted = ADMITTED[options.severity];
@@ -26722,6 +26808,221 @@ class GameLog {
   }
 }
 
+// src/editor-log.ts
+function editorLogPath(projectPath) {
+  return join9(projectPath, ".godot", "gdharness-editor.log");
+}
+function editorLogNotePath(projectPath) {
+  return join9(projectPath, ".godot", "gdharness-editor.json");
+}
+function readEditorLogNote(projectPath) {
+  try {
+    const fields = asParams(JSON.parse(readFileSync10(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;
+  } catch {
+    return null;
+  }
+}
+function clearEditorLog(projectPath) {
+  try {
+    const path = editorLogPath(projectPath);
+    mkdirSync6(dirname6(path), { recursive: true });
+    rmSync3(path, { force: true });
+    rmSync3(editorLogNotePath(projectPath), { force: true });
+  } catch {}
+}
+function writeEditorLogNote(projectPath, pid) {
+  try {
+    const path = editorLogNotePath(projectPath);
+    mkdirSync6(dirname6(path), { recursive: true });
+    writeFileSync6(path, JSON.stringify({ pid, startedAt: new Date().toISOString() }, null, 2), "utf8");
+  } catch {}
+}
+function theConsoleWasNotCaptured(why, projectPath) {
+  if (why.kind === "not ours") {
+    return "This editor was not opened by gdharness, so its console was never captured and nothing " + "here has it: an editor prints to a console no plugin can read, and the addon cannot get " + "at it from inside. This is not an editor that printed nothing.";
+  }
+  if (why.kind === "older server") {
+    return `This editor was opened by a gdharness server, but the console beside ${projectPath} belongs ` + `to editor ${why.notedPid ?? "none recorded"} rather than to this one, so it holds an ` + "earlier session and is not offered as this one. A server from before consoles were " + "captured leaves exactly this.";
+  }
+  return "This editor was opened by gdharness and has written nothing to its console file yet, not " + "even the engine version it prints first, so the file is missing rather than empty. An " + "editor that could not open the file for writing leaves this.";
+}
+function editorConsole(projectPath, editorPid, openedByAServer) {
+  if (!openedByAServer) {
+    return { kind: "not ours" };
+  }
+  const noted = readEditorLogNote(projectPath);
+  if (noted === null || editorPid === null || noted.pid !== editorPid) {
+    return { kind: "older server", notedPid: noted?.pid ?? null };
+  }
+  const path = editorLogPath(projectPath);
+  if (!existsSync5(path)) {
+    return { kind: "not written" };
+  }
+  const log = new GameLog;
+  const { text, of } = theFirstOf(path);
+  log.append("transcript", text);
+  log.finish();
+  return { log, path, ...of === undefined ? {} : { readBytes: text.length, of } };
+}
+var MOST_CONSOLE_BYTES = 8 * 1024 * 1024;
+function theFirstOf(path) {
+  const whole = statSync3(path).size;
+  if (whole <= MOST_CONSOLE_BYTES) {
+    return { text: readFileSync10(path, "utf8") };
+  }
+  const handle = openSync(path, "r");
+  try {
+    const buffer = Buffer.alloc(MOST_CONSOLE_BYTES);
+    const read = readSync(handle, buffer, 0, MOST_CONSOLE_BYTES, 0);
+    const decoded = buffer.subarray(0, read).toString("utf8");
+    const lastLine = decoded.lastIndexOf(`
+`);
+    return { text: lastLine === -1 ? decoded : decoded.slice(0, lastLine + 1), of: whole };
+  } finally {
+    closeSync(handle);
+  }
+}
+var NAMED_VALUES = 6;
+var WALK_BACK_LIMIT = 500;
+var SLOTS = [/"[^"]*"/g, /'[^']*'/g, /\b(?:res|user):\/\/\S+/g, /(?<=\.gd|\.tscn|\.cs):\d+(?::\d+)?/g];
+function shapeOf(text) {
+  const values = [];
+  let shape = "";
+  let at = 0;
+  while (at < text.length) {
+    let earliest = null;
+    for (const pattern of SLOTS) {
+      pattern.lastIndex = at;
+      const found = pattern.exec(text);
+      if (found !== null && (earliest === null || found.index < earliest.index || found.index === earliest.index && found[0].length > earliest.value.length)) {
+        earliest = { index: found.index, value: found[0] };
+      }
+    }
+    if (earliest === null) {
+      shape += text.slice(at);
+      break;
+    }
+    if (earliest.value.length === 0) {
+      shape += text.slice(at, at + 1);
+      at += 1;
+      continue;
+    }
+    shape += `${text.slice(at, earliest.index)}…`;
+    values.push(earliest.value);
+    at = earliest.index + earliest.value.length;
+  }
+  return { shape, values };
+}
+function bursts(entries, before) {
+  const shapes = new Map;
+  const shaped = entries.map((entry) => shapeOf(entry.text));
+  for (const [at, entry] of entries.entries()) {
+    const key = `${entry.severity}\x00${shaped[at]?.shape ?? entry.text}`;
+    const group = shapes.get(key) ?? { indices: [], values: [] };
+    group.indices.push(at);
+    group.values.push(shaped[at]?.values ?? []);
+    shapes.set(key, group);
+  }
+  const collapsed = new Set;
+  for (const group of shapes.values()) {
+    if (group.indices.length > 1) {
+      for (const at of group.indices) {
+        collapsed.add(at);
+      }
+    }
+  }
+  const repeated = [];
+  for (const [key, group] of shapes) {
+    const first = group.indices[0];
+    if (group.indices.length < 2 || first === undefined) {
+      continue;
+    }
+    const entry = entries[first];
+    if (entry === undefined) {
+      continue;
+    }
+    repeated.push({
+      shape: key.slice(key.indexOf("\x00") + 1),
+      count: group.indices.length,
+      severity: entry.severity,
+      first: { index: entry.index, text: entry.text },
+      slots: slotsOf(group.values, group.indices.length),
+      before: linesBefore(entries, first, collapsed, before)
+    });
+  }
+  return repeated.sort((one, other) => other.count - one.count);
+}
+function slotsOf(values, count) {
+  const width = Math.max(0, ...values.map((row) => row.length));
+  const distinct = [];
+  for (let at = 0;at < width; at += 1) {
+    distinct.push([...new Set(values.map((row) => row[at]).filter((one) => one !== undefined))]);
+  }
+  const slots = [];
+  for (let at = 0;at < width; at += 1) {
+    const seen = distinct[at] ?? [];
+    const partner = theSlotItMovesWith(values, distinct, at);
+    const paired = partner === undefined ? {} : { movesWith: partner };
+    if (seen.length === count && count > 1) {
+      slots.push({ distinct: seen.length, allDifferent: true, ...paired });
+      continue;
+    }
+    const some = seen.slice(0, NAMED_VALUES);
+    slots.push({
+      distinct: seen.length,
+      some,
+      ...seen.length > some.length ? { more: seen.length - some.length } : {},
+      ...paired
+    });
+  }
+  return slots;
+}
+function theSlotItMovesWith(values, distinct, at) {
+  const mine = distinct[at] ?? [];
+  if (mine.length < 2) {
+    return;
+  }
+  for (let other = 0;other < at; other += 1) {
+    if ((distinct[other] ?? []).length !== mine.length) {
+      continue;
+    }
+    const goesWith = new Map;
+    let oneForOne = true;
+    for (const row of values) {
+      const theirs = row[other];
+      const ours = row[at];
+      if (theirs === undefined || ours === undefined) {
+        oneForOne = false;
+        break;
+      }
+      const already = goesWith.get(theirs);
+      if (already === undefined) {
+        goesWith.set(theirs, ours);
+      } else if (already !== ours) {
+        oneForOne = false;
+        break;
+      }
+    }
+    if (oneForOne) {
+      return other;
+    }
+  }
+  return;
+}
+function linesBefore(entries, at, collapsed, wanted) {
+  const found = [];
+  for (let back = at - 1;back >= 0 && at - back <= WALK_BACK_LIMIT && found.length < wanted; back -= 1) {
+    const entry = entries[back];
+    if (entry !== undefined && !collapsed.has(back)) {
+      found.push(entry.text);
+    }
+  }
+  return found.reverse();
+}
+
 // src/godot-bridge.ts
 import { randomUUID } from "node:crypto";
 import { EventEmitter } from "node:events";
@@ -26900,6 +27201,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,
@@ -27043,6 +27345,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);
@@ -27223,14 +27526,14 @@ function getDefaultBridge(ownProject = null) {
 
 // src/godot-path.ts
 import { execFile as execFile2 } from "node:child_process";
-import { existsSync as existsSync6 } from "node:fs";
+import { existsSync as existsSync7 } from "node:fs";
 import { normalize } from "node:path";
 import { promisify as promisify2 } from "node:util";
 
 // src/detection.ts
-import { existsSync as existsSync5, readdirSync as readdirSync3, statSync as statSync3 } from "node:fs";
+import { existsSync as existsSync6, readdirSync as readdirSync3, statSync as statSync4 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 function resolveHomeDirectory() {
   try {
     return homedir2();
@@ -27239,7 +27542,7 @@ function resolveHomeDirectory() {
   }
 }
 function scanDirectoryForGodotBinaries(directory, platform) {
-  if (!directory || !existsSync5(directory)) {
+  if (!directory || !existsSync6(directory)) {
     return [];
   }
   let entries;
@@ -27254,16 +27557,16 @@ function scanDirectoryForGodotBinaries(directory, platform) {
     if (!pattern.test(name)) {
       continue;
     }
-    const fullPath = join9(directory, name);
+    const fullPath = join10(directory, name);
     try {
-      const stat = statSync3(fullPath);
+      const stat = statSync4(fullPath);
       if (stat.isFile()) {
         matches.push({ name, mtime: stat.mtimeMs });
       }
     } catch {}
   }
   matches.sort((a, b) => b.mtime - a.mtime);
-  return matches.map((m) => join9(directory, m.name));
+  return matches.map((m) => join10(directory, m.name));
 }
 function conventionalPaths(platform, home) {
   const paths = ["godot"];
@@ -27366,7 +27669,7 @@ class GodotLocator {
       return known;
     }
     let reason;
-    if (path !== "godot" && !existsSync6(path)) {
+    if (path !== "godot" && !existsSync7(path)) {
       reason = "does not exist";
     } else {
       try {
@@ -27383,13 +27686,13 @@ class GodotLocator {
 
 // src/headless.ts
 import { execFile as execFile3 } from "node:child_process";
-import { mkdtempSync, writeFileSync as writeFileSync6 } from "node:fs";
+import { mkdtempSync, writeFileSync as writeFileSync7 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 import { promisify as promisify3 } from "node:util";
 
 // src/scratch.ts
-import { rmSync as rmSync3 } from "node:fs";
+import { rmSync as rmSync4 } from "node:fs";
 var SWEPT = { recursive: true, force: true, maxRetries: 20, retryDelay: 250 };
 function discardWith(remove, paths) {
   const left = [];
@@ -27407,7 +27710,7 @@ function discardWith(remove, paths) {
 }
 function discard(...paths) {
   return discardWith((path) => {
-    rmSync3(path, SWEPT);
+    rmSync4(path, SWEPT);
   }, paths);
 }
 
@@ -27451,12 +27754,12 @@ function reason(stdout, stderr) {
   return stdout.trim().split(/\r?\n/).at(-1) ?? "no output at all";
 }
 async function runImport(godotPath, projectPath) {
-  const logDir = mkdtempSync(join10(tmpdir3(), "gdharness-import-"));
+  const logDir = mkdtempSync(join11(tmpdir3(), "gdharness-import-"));
   try {
     const { stderr } = await run3(godotPath, [
       "--headless",
       "--log-file",
-      join10(logDir, "engine.log"),
+      join11(logDir, "engine.log"),
       "--path",
       projectPath,
       "--import"
@@ -27481,13 +27784,13 @@ async function runImport(godotPath, projectPath) {
   }
 }
 async function runOperation(engine, operation, params, projectPath) {
-  const paramsDir = mkdtempSync(join10(tmpdir3(), "gdharness-params-"));
-  const paramsFile = join10(paramsDir, `${operation}.json`);
-  writeFileSync6(paramsFile, JSON.stringify(snakeCased(params)), "utf8");
+  const paramsDir = mkdtempSync(join11(tmpdir3(), "gdharness-params-"));
+  const paramsFile = join11(paramsDir, `${operation}.json`);
+  writeFileSync7(paramsFile, JSON.stringify(snakeCased(params)), "utf8");
   const args = [
     "--headless",
     "--log-file",
-    join10(paramsDir, "engine.log"),
+    join11(paramsDir, "engine.log"),
     "--path",
     projectPath,
     "--script",
@@ -27916,7 +28219,7 @@ function orphansPrinted(printed) {
 import { realpathSync as realpathSync2 } from "node:fs";
 import { readFile, realpath } from "node:fs/promises";
 import { createConnection as createConnection3 } from "node:net";
-import { dirname as dirname6, resolve as resolve3 } from "node:path";
+import { dirname as dirname7, resolve as resolve3 } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 var DEFAULT_LSP_PORT = 6005;
 var DIAGNOSTICS_TIMEOUT_MS = 5000;
@@ -28046,7 +28349,7 @@ class GodotLSPClient {
     if (this.initialized) {
       return;
     }
-    const rootPath = this.rootPath ?? dirname6(resolve3(filePath));
+    const rootPath = this.rootPath ?? dirname7(resolve3(filePath));
     await this.initialize(rootPath);
   }
   async sendRequest(method, params) {
@@ -28482,14 +28785,14 @@ function secondsFromClock(printed) {
 }
 
 // src/project-scan.ts
-import { existsSync as existsSync7, readdirSync as readdirSync4, readFileSync as readFileSync10 } from "node:fs";
-import { join as join11 } from "node:path";
+import { existsSync as existsSync8, readdirSync as readdirSync4, readFileSync as readFileSync11 } from "node:fs";
+import { join as join12 } from "node:path";
 var SKIPPED = new Set(["node_modules"]);
 function skipped(name) {
   return name.startsWith(".") || SKIPPED.has(name);
 }
 function steppedOver(directory) {
-  return existsSync7(join11(directory, ".gdignore"));
+  return existsSync8(join12(directory, ".gdignore"));
 }
 var ASSET_EXTENSIONS = new Set(["png", "jpg", "jpeg", "webp", "svg", "ttf", "otf", "wav", "mp3", "ogg"]);
 function projectStructure(projectPath) {
@@ -28503,7 +28806,7 @@ function projectStructure(projectPath) {
         continue;
       }
       if (entry.isDirectory()) {
-        visit(join11(directory, entry.name));
+        visit(join12(directory, entry.name));
       } else if (entry.isFile()) {
         const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
         if (extension === "tscn") {
@@ -28534,14 +28837,14 @@ function scriptsWithoutUid(projectPath) {
       }
       const spelled = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
       if (entry.isDirectory()) {
-        visit(join11(directory, entry.name), spelled);
+        visit(join12(directory, entry.name), spelled);
         continue;
       }
       if (!entry.isFile()) {
         continue;
       }
       const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
-      if (CARRIES_A_UID.has(extension) && !existsSync7(join11(directory, `${entry.name}.uid`))) {
+      if (CARRIES_A_UID.has(extension) && !existsSync8(join12(directory, `${entry.name}.uid`))) {
         found.push(spelled);
       }
     }
@@ -28576,7 +28879,7 @@ function searchProject(projectPath, options) {
       if (skipped(entry.name)) {
         continue;
       }
-      const entryPath = join11(directory, entry.name);
+      const entryPath = join12(directory, entry.name);
       if (entry.isDirectory()) {
         visit(entryPath);
         continue;
@@ -28587,7 +28890,7 @@ function searchProject(projectPath, options) {
       }
       result.summary.files_searched += 1;
       const matches = [];
-      for (const [index, line] of readFileSync10(entryPath, "utf8").split(`
+      for (const [index, line] of readFileSync11(entryPath, "utf8").split(`
 `).entries()) {
         if (full()) {
           break;
@@ -28610,7 +28913,7 @@ function searchProject(projectPath, options) {
 }
 
 // src/resources.ts
-import { readFileSync as readFileSync11 } from "node:fs";
+import { readFileSync as readFileSync12 } from "node:fs";
 import { extname, resolve as resolve4 } from "node:path";
 var STATIC_RESOURCES = [
   {
@@ -28805,7 +29108,7 @@ function readResourceText(uri, getProjectPath) {
   const parsedUri = parseGodotUri(uri);
   if (parsedUri.kind === "project-info") {
     const projectFilePath = resolveProjectFile(projectPath, "project.godot");
-    const rawProject = readFileSync11(projectFilePath, "utf-8");
+    const rawProject = readFileSync12(projectFilePath, "utf-8");
     const parsedProject = parseProjectGodot(rawProject);
     return {
       mimeType: "application/json",
@@ -28814,7 +29117,7 @@ function readResourceText(uri, getProjectPath) {
   }
   const filePath = resolveProjectFile(projectPath, parsedUri.resourcePath);
   ensureAllowedExtension(parsedUri.kind, filePath);
-  const text = readFileSync11(filePath, "utf-8");
+  const text = readFileSync12(filePath, "utf-8");
   return {
     mimeType: parsedUri.kind === "script" ? "text/x-gdscript" : "text/plain",
     text
@@ -28851,16 +29154,16 @@ function setupResourceHandlers(mcp, getProjectPath) {
 }
 
 // src/restart-note.ts
-import { mkdirSync as mkdirSync6, readFileSync as readFileSync12, rmSync as rmSync4, writeFileSync as writeFileSync7 } from "node:fs";
-import { dirname as dirname7, join as join12 } from "node:path";
+import { mkdirSync as mkdirSync7, readFileSync as readFileSync13, rmSync as rmSync5, writeFileSync as writeFileSync8 } from "node:fs";
+import { dirname as dirname8, join as join13 } from "node:path";
 function restartNotePath(projectPath) {
-  return join12(projectPath, ".godot", "gdharness-restart.json");
+  return join13(projectPath, ".godot", "gdharness-restart.json");
 }
 function noteRestartBegun(note) {
   const path = restartNotePath(note.projectPath);
   try {
-    mkdirSync6(dirname7(path), { recursive: true });
-    writeFileSync7(path, `${JSON.stringify(note, null, 2)}
+    mkdirSync7(dirname8(path), { recursive: true });
+    writeFileSync8(path, `${JSON.stringify(note, null, 2)}
 `, "utf8");
   } catch (error) {
     console.error(`[SERVER] Could not record the restart at ${path}: ${errorMessage(error)}`);
@@ -28868,7 +29171,7 @@ function noteRestartBegun(note) {
 }
 function restartOwed(projectPath) {
   try {
-    const parsed = JSON.parse(readFileSync12(restartNotePath(projectPath), "utf8"));
+    const parsed = JSON.parse(readFileSync13(restartNotePath(projectPath), "utf8"));
     if (typeof parsed !== "object" || parsed === null) {
       return null;
     }
@@ -28883,7 +29186,7 @@ function restartOwed(projectPath) {
 }
 function restartSettled(projectPath) {
   try {
-    rmSync4(restartNotePath(projectPath), { force: true });
+    rmSync5(restartNotePath(projectPath), { force: true });
   } catch (error) {
     console.error(`[SERVER] Could not clear the restart note: ${errorMessage(error)}`);
   }
@@ -28891,36 +29194,36 @@ function restartSettled(projectPath) {
 
 // src/run-record.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { mkdirSync as mkdirSync7, openSync, readdirSync as readdirSync5, readFileSync as readFileSync13, rmSync as rmSync5, statSync as statSync4, writeFileSync as writeFileSync8 } from "node:fs";
-import { basename as basename2, join as join13 } from "node:path";
+import { mkdirSync as mkdirSync8, openSync as openSync2, readdirSync as readdirSync5, readFileSync as readFileSync14, rmSync as rmSync6, statSync as statSync5, writeFileSync as writeFileSync9 } from "node:fs";
+import { basename as basename2, join as join14 } from "node:path";
 function runsDirectory() {
-  return join13(runtimeDirectory(), "runs");
+  return join14(runtimeDirectory(), "runs");
 }
 function recordPath() {
-  return join13(runsDirectory(), "run.json");
+  return join14(runsDirectory(), "run.json");
 }
 function recordPaths() {
-  return runtimeDirectories().map((directory) => join13(directory, "runs", "run.json"));
+  return runtimeDirectories().map((directory) => join14(directory, "runs", "run.json"));
 }
 function openTranscript(startedAt) {
-  mkdirSync7(runsDirectory(), { recursive: true });
-  const path = join13(runsDirectory(), `run-${startedAt}.log`);
-  return { path, fd: openSync(path, "a") };
+  mkdirSync8(runsDirectory(), { recursive: true });
+  const path = join14(runsDirectory(), `run-${startedAt}.log`);
+  return { path, fd: openSync2(path, "a") };
 }
 function writeRunRecord(record) {
-  mkdirSync7(runsDirectory(), { recursive: true });
-  writeFileSync8(recordPath(), JSON.stringify(record, null, 2), "utf8");
+  mkdirSync8(runsDirectory(), { recursive: true });
+  writeFileSync9(recordPath(), JSON.stringify(record, null, 2), "utf8");
 }
 function editorNotePath() {
-  return join13(runsDirectory(), "editor-run.json");
+  return join14(runsDirectory(), "editor-run.json");
 }
 function writeEditorRunNote(note) {
-  mkdirSync7(runsDirectory(), { recursive: true });
-  writeFileSync8(editorNotePath(), JSON.stringify(note, null, 2), "utf8");
+  mkdirSync8(runsDirectory(), { recursive: true });
+  writeFileSync9(editorNotePath(), JSON.stringify(note, null, 2), "utf8");
 }
 function readEditorRunNote() {
   for (const directory of runtimeDirectories()) {
-    const note = editorNoteAt(join13(directory, "runs", "editor-run.json"));
+    const note = editorNoteAt(join14(directory, "runs", "editor-run.json"));
     if (note !== null) {
       return note;
     }
@@ -28930,7 +29233,7 @@ function readEditorRunNote() {
 function editorNoteAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync13(path, "utf8"));
+    parsed = JSON.parse(readFileSync14(path, "utf8"));
   } catch {
     return null;
   }
@@ -28953,7 +29256,7 @@ function recordRunEnded(pid, exitCode) {
     return;
   }
   try {
-    writeFileSync8(path, JSON.stringify({ ...record, exitCode }, null, 2), "utf8");
+    writeFileSync9(path, JSON.stringify({ ...record, exitCode }, null, 2), "utf8");
   } catch {}
 }
 function readRunRecord() {
@@ -28968,7 +29271,7 @@ function readRunRecord() {
 function recordAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync13(path, "utf8"));
+    parsed = JSON.parse(readFileSync14(path, "utf8"));
   } catch {
     return null;
   }
@@ -29013,7 +29316,7 @@ function runningAs(pid) {
     const began = startedAt(pid, null);
     const when = began === null ? {} : { startedAt: began };
     if (process.platform === "linux") {
-      const raw = readFileSync13(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
+      const raw = readFileSync14(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
       return raw === "" ? null : { kind: "commandLine", text: raw, ...when };
     }
     const args = execFileSync2("ps", ["-p", String(pid), "-o", "args="], {
@@ -29142,13 +29445,13 @@ function clearRunRecord(ours = () => true) {
       continue;
     }
     try {
-      rmSync5(path);
+      rmSync6(path);
     } catch {}
   }
 }
 function ageMs(path, now) {
   try {
-    return now - statSync4(path).mtimeMs;
+    return now - statSync5(path).mtimeMs;
   } catch {
     return 0;
   }
@@ -29166,31 +29469,83 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
     if (!entry.startsWith("run-") || !entry.endsWith(".log")) {
       continue;
     }
-    const path = join13(directory, entry);
+    const path = join14(directory, entry);
     if (path === keep || ageMs(path, now) < keepMs) {
       continue;
     }
     try {
-      rmSync5(path);
+      rmSync6(path);
     } catch {}
   }
 }
 
 // src/setup.ts
-import { cpSync, existsSync as existsSync8, mkdirSync as mkdirSync8, readFileSync as readFileSync14, rmSync as rmSync6, writeFileSync as writeFileSync9 } from "node:fs";
-import { dirname as dirname8, join as join14 } from "node:path";
+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 = join14(projectPath, "addons", ADDONS[0], VERSION_MARKER);
-  if (!existsSync8(marker)) {
+  const marker = join15(projectPath, "addons", ADDONS[0], VERSION_MARKER);
+  if (!existsSync9(marker)) {
     return null;
   }
-  const said = readFileSync14(marker, "utf8").trim();
+  const said = readFileSync15(marker, "utf8").trim();
   return said === "" ? null : said;
 }
 
@@ -29211,7 +29566,7 @@ function argumentsOf(spec, op) {
   return Object.keys(spec.parameters).filter((name) => opTakes(spec, op, name));
 }
 function theGamePicked() {
-  return "the game this server started or is playing when it is among those running, named under " + "`answeredBy` where there was a choice; else the only game there is; else a refusal naming " + "every game, which is what a machine running two projects at once gets";
+  return "the game this server started or is playing when it is among those running, named under " + "`answeredBy` where there was a choice; else the only game there is; else a refusal naming " + "every game and which argument tells them apart, `pid` when they are all one project and " + "`projectPath` when they are not";
 }
 var PROJECT_PATH = {
   type: "string",
@@ -29878,7 +30233,7 @@ var TOOL_SPECS = [
   },
   {
     name: "editor_output",
-    description: "What the project started by editor_run has printed, as entries with a severity: the errors and warnings the engine reported, each with where it happened, and everything else as info. For a run the editor plays the reports come from the game itself, through the runtime addon, since the editor's debugger relays what a game prints and not what it reports; a played game without the runtime addon answers here with its prints alone. Answers with the counts and the verdict as well as the entries. heldAt is three answers: null for a run this server knows is not held, running or over, an object for one it knows is held at a breakpoint, whether the adapter said so or the runtime did by accepting a connection and never answering, and absent with heldUnknown beside it for a server that connected to the debugger after the stop and has no runtime to ask, since the adapter reports a stop only to the sessions connected when it happened. A run that has quit still answers here, with running false and its exit code, until the next one starts. A run this server started also answers with transcript, the file both its streams are written to: uncapped, written while the run is going, and the thing to read or tail for a long run rather than the engine's own log, which every engine start rotates away. Read the file for output and this answer for state: endedBy says whether gdharness ended the run, and a transcript that has stopped growing is a run between prints rather than a run that is over. running is asked of the operating system whenever there is a process to ask about, which is every run this server started and every editor-played run whose game announced its runtime. For an editor-played run that never announced, there is no process id here and running is the editor's answer, which can lag: one measured elsewhere reported a game as playing for fifteen seconds after its process had been ended from outside. editor_status names that game under runtimes, which does not depend on the editor answering.",
+    description: "What the project started by editor_run has printed, as entries with a severity: the errors and warnings the engine reported, each with where it happened, and everything else as info. For a run the editor plays the reports come from the game itself, through the runtime addon, since the editor's debugger relays what a game prints and not what it reports; a played game without the runtime addon answers here with its prints alone. Answers with the counts and the verdict as well as the entries. heldAt is three answers: null for a run this server knows is not held, running or over, an object for one it knows is held at a breakpoint, whether the adapter said so or the runtime did by accepting a connection and never answering, and absent with heldUnknown beside it for a server that connected to the debugger after the stop and has no runtime to ask, since the adapter reports a stop only to the sessions connected when it happened. A run that has quit still answers here, with running false and its exit code, until the next one starts. A run this server started also answers with transcript, the file both its streams are written to: uncapped, written while the run is going, and the thing to read or tail for a long run rather than the engine's own log, which every engine start rotates away. Read the file for output and this answer for state: endedBy says whether gdharness ended the run, and a transcript that has stopped growing is a run between prints rather than a run that is over. running is asked of the operating system whenever there is a process to ask about, which is every run this server started and every editor-played run whose game announced its runtime. For an editor-played run that never announced, there is no process id here and running is the editor's answer, which can lag: one measured elsewhere reported a game as playing for fifteen seconds after its process had been ended from outside. editor_status names that game under runtimes, which does not depend on the editor answering. op: \"editor\" answers about the editor itself instead, which is a different log and the only way anything here can read what an editor printed: its console reaches no plugin, so the addon cannot scrape it, and an editor gdharness opened is asked for a log file as it starts. That covers the whole session from the editor's first line, which is where the output worth reading usually is, since the class cache, the plugins and the language server all say what they have to say before any harness has connected. The answer carries the entries in the order they were printed and, beside them under repeated, each message shape several lines share: how many, what varied in each slot of it and how many different values stood there, the first occurrence, and the ordinary lines above the group, found by walking back past the group rather than by counting lines. An editor somebody opened by hand has no console here and is refused saying so rather than answered empty, because an editor that printed nothing and an editor nobody captured are not the same thing.",
     parameters: {
       severity: {
         type: "string",
@@ -29886,10 +30241,12 @@ var TOOL_SPECS = [
         description: "The least severe entry to include. Default info, which is everything."
       },
       sinceLastCall: {
+        ops: ["run"],
         type: "boolean",
         description: "Only entries this has not already answered with at this severity. Default false. Measured per severity floor and not across them, so polling for errors leaves the rest of the output for a later read rather than consuming it, and a read with contains is a search over the whole run and consumes nothing."
       },
       cpu: {
+        ops: ["run"],
         type: "boolean",
         description: "Also answer with cpuSeconds, the processor time the run has used. Default false, because asking costs a subprocess. Worth it when elapsedMs is climbing and nothing is being printed: processor time standing still is a run that has stopped doing anything, rather than one that is slow."
       },
@@ -29900,8 +30257,24 @@ var TOOL_SPECS = [
       limit: {
         type: "number",
         description: "The most entries to answer with, newest kept. Default 200, and omitted says how many matching entries that left out. A run long enough to pass it needs this raised, not just filtered: filtering narrows what counts as matching, and the newest of those is still all one answer carries."
+      },
+      before: {
+        ops: ["editor"],
+        type: "number",
+        description: "How many lines above a repeated group to carry with it, counting only lines that are not themselves part of a group. Default 3. The line that explains a wall of identical errors is the last ordinary line above it, so this walks past the wall rather than a fixed distance back."
       }
     },
+    operations: {
+      run: {
+        summary: "What the game a run is playing has printed, which is everything described above",
+        requires: []
+      },
+      editor: {
+        summary: "What the connected editor itself has printed, from its first line, with repeated messages grouped and the ordinary lines above each group carried with it",
+        requires: []
+      }
+    },
+    defaultOperation: "run",
     requires: []
   },
   {
@@ -30360,7 +30733,7 @@ function buildToolDefinitions() {
 var UPDATE_NOTICE_EVERY = 500;
 var FEEDBACK_NOTICE_EVERY = 250;
 var run5 = promisify5(execFile5);
-var __dirname2 = dirname9(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;
@@ -30473,6 +30846,7 @@ function endedToStartThis(ended) {
   return ` ${which} was ended to start this one; its output is no longer what editor_output answers about.`;
 }
 var LONGEST_BOOT_NOTED_MS = 5 * 60000;
+var MOST_GROUPS = 20;
 function runtimeVerdict(endpoint, after) {
   if (endpoint !== null) {
     return { listening: true, pid: endpoint.pid, port: endpoint.port };
@@ -30647,13 +31021,13 @@ function aboveTheRunner(entry) {
 }
 function elsewhereIn(projectPath, asked) {
   const wanted = asked.replace(/^res:\/\//, "").replace(/\/+$/, "");
-  if (wanted === "" || existsSync9(join15(projectPath, wanted))) {
+  if (wanted === "" || existsSync10(join16(projectPath, wanted))) {
     return "";
   }
   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 "";
   }
@@ -30661,7 +31035,7 @@ function elsewhereIn(projectPath, asked) {
   return near.length === 0 ? "" : ` The project does have ${there}.`;
 }
 function hasMainScene(projectFile) {
-  const scene = parseProjectGodot(readFileSync15(projectFile, "utf8"))["application"]?.["run/main_scene"];
+  const scene = parseProjectGodot(readFileSync16(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "";
 }
 function runtimeAddonAnnouncesEditors(projectPath) {
@@ -30669,13 +31043,13 @@ function runtimeAddonAnnouncesEditors(projectPath) {
     return false;
   }
   try {
-    return readFileSync15(join15(projectPath, RUNTIME_AUTOLOAD.path), "utf8").includes('"editor_pid"');
+    return readFileSync16(join16(projectPath, RUNTIME_AUTOLOAD.path), "utf8").includes('"editor_pid"');
   } catch {
     return false;
   }
 }
 function editorPlaysHeadless(projectFile) {
-  const runArgs = parseProjectGodot(readFileSync15(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
+  const runArgs = parseProjectGodot(readFileSync16(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
   return typeof runArgs === "string" && /(?:^|\s)--headless(?:\s|$)/.test(runArgs);
 }
 function camelCased(params) {
@@ -30694,7 +31068,7 @@ function needsItsOwnProcess(asked) {
 class GodotServer {
   mcp;
   locator = new GodotLocator;
-  operationsScript = join15(__dirname2, "godot", "operations", "godot_operations.gd");
+  operationsScript = join16(__dirname2, "godot", "operations", "godot_operations.gd");
   godotBridge;
   tools = buildToolDefinitions();
   activeProcess = null;
@@ -31359,8 +31733,8 @@ class GodotServer {
     if (path === undefined) {
       return { ok: false, response: this.createErrorResponse("projectPath is required.") };
     }
-    const file = join15(path, "project.godot");
-    if (!existsSync9(file)) {
+    const file = join16(path, "project.godot");
+    if (!existsSync10(file)) {
       return {
         ok: false,
         response: this.createErrorResponse(`Not a Godot project: ${path}`, [
@@ -31628,7 +32002,7 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const application = parseProjectGodot(readFileSync15(project.value.file, "utf8"))["application"] ?? {};
+    const application = parseProjectGodot(readFileSync16(project.value.file, "utf8"))["application"] ?? {};
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
@@ -31689,18 +32063,18 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const folder = dirname9(output.absolutePath);
+    const folder = dirname10(output.absolutePath);
     try {
-      mkdirSync9(folder, { recursive: true });
+      mkdirSync10(folder, { recursive: true });
     } catch (error) {
-      return this.createErrorResponse(`Cannot create ${dirname9(output.relativePath)} to export into: ${errorMessage(error)}`);
+      return this.createErrorResponse(`Cannot create ${dirname10(output.relativePath)} to export into: ${errorMessage(error)}`);
     }
     const debug = readBoolean(args, "debug") ?? false;
-    const exportLogs = mkdtempSync2(join15(tmpdir4(), "gdharness-export-"));
+    const exportLogs = mkdtempSync2(join16(tmpdir4(), "gdharness-export-"));
     const exportArgs = [
       "--headless",
       "--log-file",
-      join15(exportLogs, "engine.log"),
+      join16(exportLogs, "engine.log"),
       "--path",
       project.value.path,
       debug ? "--export-debug" : "--export-release",
@@ -31728,7 +32102,7 @@ class GodotServer {
     log.finish();
     const problems = log.select({ severity: "warning", sinceLastCall: false, limit: 200 });
     const verdict = {
-      exported: exitCode === 0 && log.count("error") === 0 && existsSync9(output.absolutePath),
+      exported: exitCode === 0 && log.count("error") === 0 && existsSync10(output.absolutePath),
       preset,
       outputPath: output.relativePath,
       debug,
@@ -31758,7 +32132,7 @@ class GodotServer {
       return contained.response;
     }
     const runner = "addons/gdUnit4/bin/GdUnitCmdTool.gd";
-    if (!existsSync9(join15(project.value.path, runner))) {
+    if (!existsSync10(join16(project.value.path, runner))) {
       return this.createErrorResponse(`gdUnit4 is not installed in this project: no ${runner}.`, [
         "Install gdUnit4 under addons/gdUnit4, from https://github.com/godot-gdunit-labs/gdUnit4"
       ]);
@@ -31793,7 +32167,7 @@ class GodotServer {
     ];
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 600000;
     this.logDebug(`Running tests: ${engine.value} ${cmdArgs.join(" ")}`);
-    const userData = mkdtempSync2(join15(tmpdir4(), "gdharness-tests-"));
+    const userData = mkdtempSync2(join16(tmpdir4(), "gdharness-tests-"));
     const run = this.spawnGame(engine.value, cmdArgs, userDataIn(userData));
     const hung = await new Promise((resolve) => {
       const timer = setTimeout(() => {
@@ -31809,21 +32183,21 @@ class GodotServer {
         resolve(false);
       });
     });
-    const reportsDir = join15(project.value.path, ".godot", ...ours.split("/"));
+    const reportsDir = join16(project.value.path, ".godot", ...ours.split("/"));
     let report = null;
     let reportProblem = null;
     try {
-      const written = existsSync9(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(readFileSync15(join15(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync16(join16(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
     } finally {
       discard(reportsDir, userData);
       try {
-        rmdirSync(dirname9(reportsDir));
+        rmdirSync(dirname10(reportsDir));
       } catch {}
     }
     const engineEntries = run.log.select({ severity: "warning", sinceLastCall: false, limit: 200 }).entries.map(aboveTheRunner);
@@ -31942,7 +32316,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");
@@ -31955,11 +32329,11 @@ class GodotServer {
     const cached = cachedClasses(projectPath);
     const contradicted = cached === null ? [] : contradictedDiagnostics(messages, cached, (resourcePath) => {
       const contained = resolveWithinProject(projectPath, resourcePath);
-      if (!contained.ok || !existsSync9(contained.absolutePath)) {
+      if (!contained.ok || !existsSync10(contained.absolutePath)) {
         return null;
       }
       try {
-        return readFileSync15(contained.absolutePath, "utf8");
+        return readFileSync16(contained.absolutePath, "utf8");
       } catch {
         return null;
       }
@@ -32009,11 +32383,11 @@ class GodotServer {
   }
   sourceOfClass(projectPath, resourcePath) {
     const contained = resolveWithinProject(projectPath, resourcePath);
-    if (!contained.ok || !existsSync9(contained.absolutePath)) {
+    if (!contained.ok || !existsSync10(contained.absolutePath)) {
       return null;
     }
     try {
-      return readFileSync15(contained.absolutePath, "utf8");
+      return readFileSync16(contained.absolutePath, "utf8");
     } catch {
       return null;
     }
@@ -32129,7 +32503,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,
@@ -32146,7 +32520,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,
@@ -32242,7 +32616,7 @@ class GodotServer {
       return null;
     }
     try {
-      return settingKeys(readFileSync15(join15(projectPath, "project.godot"), "utf8"));
+      return settingKeys(readFileSync16(join16(projectPath, "project.godot"), "utf8"));
     } catch {
       return null;
     }
@@ -32278,8 +32652,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
     });
@@ -32372,7 +32746,8 @@ class GodotServer {
     });
   }
   async openAnEditor(engine, projectPath, ports) {
-    const editor = spawn(engine, editorArguments(projectPath, ports), {
+    clearEditorLog(projectPath);
+    const editor = spawn(engine, editorArguments(projectPath, ports, editorLogPath(projectPath)), {
       stdio: "ignore",
       detached: true,
       env: {
@@ -32383,6 +32758,9 @@ class GodotServer {
         [OPENED_BY_A_SERVER]: "1"
       }
     });
+    if (editor.pid !== undefined) {
+      writeEditorLogNote(projectPath, editor.pid);
+    }
     const started = await new Promise((resolve) => {
       editor.once("spawn", () => {
         resolve(null);
@@ -32489,7 +32867,7 @@ class GodotServer {
   }
   async runtimeUp(projectPath, before, budget, withArgs) {
     const budgetMs = budget.ms;
-    if (!existsSync9(join15(projectPath, RUNTIME_AUTOLOAD.path))) {
+    if (!existsSync10(join16(projectPath, RUNTIME_AUTOLOAD.path))) {
       return runtimeVerdict(null, { addon: false, budgetMs, heldAt: null, running: false, withArgs });
     }
     let asking = null;
@@ -32552,7 +32930,7 @@ class GodotServer {
     }
     let announcedAt;
     try {
-      announcedAt = statSync5(endpoint.file).mtimeMs;
+      announcedAt = statSync7(endpoint.file).mtimeMs;
     } catch {
       return;
     }
@@ -32588,7 +32966,7 @@ class GodotServer {
     }
     const startedAt = Date.now();
     const transcript = openTranscript(startedAt);
-    closeSync(transcript.fd);
+    closeSync2(transcript.fd);
     const playAnswer = asParams(JSON.parse(answer.content[0]?.text ?? "{}"));
     const played = {
       process: null,
@@ -32655,7 +33033,7 @@ class GodotServer {
     }
     let handle;
     try {
-      handle = openSync2(game.errorReport, "r");
+      handle = openSync3(game.errorReport, "r");
     } catch {
       return;
     }
@@ -32666,7 +33044,7 @@ class GodotServer {
         return;
       }
       const buffer = Buffer.alloc(size - from);
-      const read = readSync(handle, buffer, 0, buffer.length, from);
+      const read = readSync2(handle, buffer, 0, buffer.length, from);
       game.errorReportOffset = from + read;
       const reported = buffer.subarray(0, read);
       if (game.transcript !== null) {
@@ -32675,7 +33053,7 @@ class GodotServer {
         game.log.append("stderr", reported);
       }
     } finally {
-      closeSync(handle);
+      closeSync2(handle);
     }
   }
   recordWhatItBrokeOn(game) {
@@ -32769,7 +33147,7 @@ class GodotServer {
         ...env ? { env } : {}
       });
     } finally {
-      closeSync(transcript.fd);
+      closeSync2(transcript.fd);
     }
     child.unref();
     const log = new GameLog;
@@ -32816,7 +33194,7 @@ class GodotServer {
     }
     let handle;
     try {
-      handle = openSync2(game.transcript, "r");
+      handle = openSync3(game.transcript, "r");
     } catch {
       return;
     }
@@ -32826,11 +33204,11 @@ class GodotServer {
         return;
       }
       const buffer = Buffer.alloc(size - game.readOffset);
-      const read = readSync(handle, buffer, 0, buffer.length, game.readOffset);
+      const read = readSync2(handle, buffer, 0, buffer.length, game.readOffset);
       game.readOffset += read;
       game.log.append("transcript", buffer.subarray(0, read));
     } finally {
-      closeSync(handle);
+      closeSync2(handle);
     }
   }
   async pickUpWhatTheEditorIsPlaying() {
@@ -33028,7 +33406,7 @@ class GodotServer {
     }
     const unreadable = this.aRuntimeOfOursIsTooFarOff();
     if (unreadable !== null) {
-      const behind = unreadable.protocol > RUNTIME_PROTOCOL ? "this server is the older half: reconnect it so it spawns the installed version" : "the addon is the older half: reinstall it and restart the game";
+      const behind = whichHalfIsBehind([unreadable]);
       return `A game is running for ${unreadable.project.path}, pid ${unreadable.pid}, announced in protocol` + ` ${unreadable.protocol}, which this server does not speak: it speaks ${RUNTIME_PROTOCOL}, so ${behind}.` + " Until then neither editor_run nor the runtime_* tools can reach it." + " A run started here is a separate process rather than a replacement, so starting one leaves" + " this game running as well.";
     }
     const record = readRunRecord();
@@ -33153,7 +33531,66 @@ class GodotServer {
     }
     return runIsUp(run, said);
   }
+  handleEditorConsole(args) {
+    const status = this.godotBridge.getStatus();
+    const projectPath = status.projectPath ?? this.ownProject ?? undefined;
+    if (projectPath === undefined) {
+      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 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",
+        "editor_output with no op answers about the game a run is playing, which is a different log"
+      ]);
+    }
+    const severity = readString(args, "severity");
+    const selected = console2.log.select({
+      severity: severity === "error" || severity === "warning" ? severity : "info",
+      sinceLastCall: false,
+      contains: readNonEmptyString(args, "contains"),
+      limit: readPositiveNumber(args, "limit") ?? 200
+    });
+    const everything = console2.log.everything();
+    const grouped = bursts(everything, readPositiveNumber(args, "before") ?? 3);
+    const shown = grouped.slice(0, MOST_GROUPS);
+    return this.jsonTextResponse({
+      editorPid: editorPid ?? undefined,
+      projectPath,
+      ...status.connected ? {} : this.launchedEditorIsUp() ? { stillConnecting: true } : { exitedBeforeConnecting: true },
+      capturedIn: console2.path,
+      ...console2.of === undefined ? {} : {
+        readFromTheStart: console2.readBytes,
+        consoleBytes: console2.of,
+        truncatedNote: `This editor's console is ${console2.of} bytes and the first ${console2.readBytes} of them were read, which is the start of the session rather than the end of it. Restart the editor to begin a fresh console.`
+      },
+      lines: everything.length,
+      counts: {
+        error: console2.log.count("error"),
+        warning: console2.log.count("warning"),
+        info: console2.log.count("info")
+      },
+      repeated: shown,
+      moreShapes: grouped.length > shown.length ? grouped.length - shown.length : undefined,
+      entries: forAnswer(selected.entries),
+      omitted: selected.omitted === 0 ? undefined : selected.omitted
+    });
+  }
   async handleGetDebugOutput(args, waitedMs) {
+    if (readString(args, "op") === "editor") {
+      return this.handleEditorConsole(args);
+    }
     await this.pickUpWhatTheEditorIsPlaying();
     const run = this.currentRun();
     if (!run) {
@@ -33430,6 +33867,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) {
@@ -33440,21 +33878,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(" ")
       }
     };
   }
@@ -33530,7 +33977,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)}`);
     }
@@ -33604,8 +34051,8 @@ class GodotServer {
       ]);
     }
     const expectsScreenshot = command === "capture_screenshot" || command === "capture_viewport";
-    const screenshotDir = expectsScreenshot ? mkdtempSync2(join15(tmpdir4(), "gdharness-runtime-screenshot-")) : null;
-    const screenshotPath = screenshotDir ? join15(screenshotDir, "capture.png") : null;
+    const screenshotDir = expectsScreenshot ? mkdtempSync2(join16(tmpdir4(), "gdharness-runtime-screenshot-")) : null;
+    const screenshotPath = screenshotDir ? join16(screenshotDir, "capture.png") : null;
     try {
       const reply = await runtimeRequest(choice.endpoint, command, screenshotPath ? { ...params, output_path: screenshotPath } : params, timeoutMs);
       if (!reply.ok) {
@@ -33629,7 +34076,7 @@ class GodotServer {
             type: "text",
             text: `Screenshot captured: ${dimensions}${chosenAmongSeveral ? ` from pid ${own}, the game this server holds` : ""}`
           },
-          { type: "image", data: readFileSync15(screenshotPath).toString("base64"), mimeType: "image/png" }
+          { type: "image", data: readFileSync16(screenshotPath).toString("base64"), mimeType: "image/png" }
         ]
       };
     } finally {