gdharness 1.0.2 → 1.0.4

package/build/cli.js

@@ -16015,7 +16015,7 @@ var init_tool_definitions = __esm(() => {
         runtimeWaitMs: {
           type: "number",
           ops: ["start"],
-          description: "start: how long to wait for the game to announce its runtime before answering. Default 5000. What it waits for is the first frame, so everything the game does before drawing one is inside it, including work the args just asked for: a flag that simulates six years of game time before anything is drawn makes the announcement that late, on a project that announces promptly without it. Raise it for such a run rather than reading runtime listening false as a fault. 0 does not wait at all, which is the one to pass for a scene that announces nothing by construction, such as a bench that prints and quits."
+          description: "start: how long to wait for the game to announce its runtime before answering. Default 5000, or half as long again as the last boot of this project took when that is more, up to 60000: the server notes how long each game took to announce, so a project that boots slowly is waited for from its second start on without being asked to. What it waits for is the first frame, so everything the game does before drawing one is inside it, including work the args just asked for: a flag that simulates six years of game time before anything is drawn makes the announcement that late, on a project that announces promptly without it. Raise it for such a run rather than reading runtime listening false as a fault. 0 does not wait at all, which is the one to pass for a scene that announces nothing by construction, such as a bench that prints and quits."
         },
         frames: {
           type: "number",
@@ -16040,7 +16040,7 @@ var init_tool_definitions = __esm(() => {
           requires: ["projectPath"]
         },
         stop: {
-          summary: "end the run and answer with what it printed last, naming the process ended under endedPid: a game that started processes of its own keeps them unless andChildren says to end those too",
+          summary: "end the run and answer with what it printed last, naming the process ended under endedPid: for a run the editor plays, the number its game announced under, read at the stop rather than remembered, and the operating system hands a freed number to the next process, so it can equal the game before it. A game that started processes of its own keeps them unless andChildren says to end those too",
           requires: []
         },
         check: {
@@ -16155,7 +16155,7 @@ var init_tool_definitions = __esm(() => {
         property: {
           type: "string",
           ops: ["property", "find"],
-          description: 'property: which one to read. find: read this one off every node matched, so a panel of labels is one call rather than one per label. Colons read through what a node holds, "_game:clock:speed", which is where a game keeps what is worth asking about. A number or a key steps into a list or a map, "_game:run:roster:0:traits", which is how the lists a game keeps its state in are walked: a roster, a board, an in-tray. A negative number counts from the end. A step that is not there is named, and says what was there instead.'
+          description: 'property: which one to read. find: read this one off every node matched, so a panel of labels is one call rather than one per label. Colons read through what a node holds, "_game:clock:speed", which is where a game keeps what is worth asking about. A number or a key steps into a list or a map, "_game:run:roster:0:traits", which is how the lists a game keeps its state in are walked: a roster, a board, an in-tray. A negative number counts from the end. A step written as a call, "get_viewport():gui_get_focus_owner()", calls a method that takes no arguments and walks into what it returned, which is how a question only a method answers is read in one call: which control holds the focus in the viewport this one is in. A step that is not there is named, and says what was there instead.'
         },
         depth: { type: "number", ops: ["tree"], description: "tree: levels to descend. Default 3." },
         includeProperties: {
@@ -16236,7 +16236,7 @@ var init_tool_definitions = __esm(() => {
         property: {
           type: "string",
           ops: ["set"],
-          description: 'set: which one to write. Colons write through what a node holds, "_game:run:day", and a number or a key steps into a list or a map on the way, "_game:run:roster:0:name", a negative number counting from the end. The answer reads back off the same holder, so a write a typed container refused shows as an unchanged value.'
+          description: 'set: which one to write. Colons write through what a node holds, "_game:run:day", and a number or a key steps into a list or a map on the way, "_game:run:roster:0:name", a negative number counting from the end, and a step written as a call, "get_viewport():gui_embed_subwindows", walks through what a method taking no arguments returned. The answer reads back off the same holder, so a write a typed container refused shows as an unchanged value.'
         },
         value: {
           ops: ["set"],
@@ -16246,7 +16246,7 @@ var init_tool_definitions = __esm(() => {
         method: {
           type: "string",
           ops: ["call"],
-          description: 'call: which one to call. Colons call through what a node holds, "_game:run:advance", the same way a property is written through them, and a list or a map is stepped into by index or key, "_game:run:roster:0:retire".'
+          description: 'call: which one to call. Colons call through what a node holds, "_game:run:advance", the same way a property is written through them, a list or a map is stepped into by index or key, "_game:run:roster:0:retire", and a step written as a call walks through what a method taking no arguments returned, "get_viewport():gui_get_focus_owner".'
         },
         args: {
           type: "array",
@@ -16306,7 +16306,7 @@ var init_tool_definitions = __esm(() => {
         pressed: {
           type: "boolean",
           ops: ["action", "key", "mouse_click"],
-          description: "action, key: leave it out and the press is a whole one, down and up a frame apart. true holds it down, false lets go of one being held. mouse_click is one raw event, so it is down unless you say false."
+          description: "action, key: leave it out and the press is a whole one, down and up a frame apart. true holds it down, false lets go of one being held. mouse_click is one raw event, so it is down unless you say false; a wheel button down is a whole step, since a wheel is never held."
         },
         strength: { type: "number", ops: ["action"], description: "action: 0 to 1. Default 1." },
         keycode: {
@@ -16384,7 +16384,7 @@ var init_tool_definitions = __esm(() => {
           requires: ["text"]
         },
         mouse_click: {
-          summary: "one mouse button event at a position, carrying the buttons held once it has happened. A drag is a press held with pressed true, motions, and a release with pressed false",
+          summary: "one mouse button event at a position, carrying the buttons held once it has happened. A drag is a press held with pressed true, motions, and a release with pressed false. A wheel button is a whole step, press and release together as a mouse sends one, and the answer says released: a lone wheel press holds the viewport on the control that took it, so every click after it lands there",
           requires: ["x", "y"]
         },
         mouse_motion: {
@@ -16406,7 +16406,11 @@ var init_tool_definitions = __esm(() => {
         },
         nodePath: { type: "string", ops: ["signal", "until"], description: "signal, until: the node." },
         signal: { type: "string", ops: ["signal"], description: "signal: the signal name." },
-        property: { type: "string", ops: ["until"], description: "until: the property name." },
+        property: {
+          type: "string",
+          ops: ["until"],
+          description: 'until: the property name, or a colon path through what the node holds, "_game:run:day", read the way runtime_inspect property reads one, a step written as a call included. Walked again on every frame, so a holder the game replaces while the wait is on is followed.'
+        },
         value: { ops: ["until"], description: "until: the value to wait for, fitted to the property's type." },
         says: {
           type: "string",
@@ -31236,155 +31240,782 @@ var init_stdio2 = __esm(() => {
   init_stdio();
 });
 
-// src/breakpoint-note.ts
-import { mkdirSync as mkdirSync6, readFileSync as readFileSync10, rmSync as rmSync6, writeFileSync as writeFileSync8 } from "node:fs";
-import { dirname as dirname7, isAbsolute as isAbsolute2, join as join12, relative as relative2 } from "node:path";
-function breakpointNotePath(projectPath) {
-  return join12(projectPath, ".godot", "gdharness-breakpoints.json");
+// src/process-children.ts
+import { execFile as execFile4, execFileSync, spawnSync as spawnSync2 } from "node:child_process";
+import { basename as basename2 } from "node:path";
+import { promisify as promisify4 } from "node:util";
+function startTimesOf(pids) {
+  const began = new Map;
+  if (pids.length === 0) {
+    return began;
+  }
+  try {
+    if (process.platform === "win32") {
+      const filter = pids.map((pid) => `ProcessId=${pid}`).join(" OR ");
+      const said = execFileSync("powershell", [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        `Get-CimInstance Win32_Process -Filter "${filter}" | ForEach-Object { "$($_.ProcessId) $(([DateTimeOffset]$_.CreationDate).ToUnixTimeMilliseconds())" }`
+      ], { encoding: "utf8", timeout: ASK_TIMEOUT_MS, windowsHide: true });
+      for (const line of said.split(`
+`)) {
+        const found = /^\s*(\d+)\s+(\d+)\s*$/.exec(line);
+        if (found?.[1] !== undefined && found[2] !== undefined) {
+          began.set(Number(found[1]), Number(found[2]));
+        }
+      }
+      return began;
+    }
+    const said = spawnSync2("ps", ["-p", pids.join(","), "-o", "pid=,lstart="], {
+      encoding: "utf8",
+      timeout: ASK_TIMEOUT_MS,
+      env: { ...process.env, LC_ALL: "C" }
+    }).stdout;
+    for (const line of said.split(`
+`)) {
+      const found = /^\s*(\d+)\s+(.+)$/.exec(line);
+      const at = Date.parse(found?.[2]?.trim() ?? "");
+      if (found?.[1] !== undefined && !Number.isNaN(at)) {
+        began.set(Number(found[1]), at);
+      }
+    }
+  } catch {}
+  return began;
 }
-function writeBreakpointNote(projectPath, held) {
-  const path = breakpointNotePath(projectPath);
-  const root = realPathOr(projectPath);
-  const inside = held.map((one) => ({ scriptPath: realPathOr(one.scriptPath), lines: one.lines })).filter((one) => one.lines.length > 0 && withinProject(root, one.scriptPath));
+async function processTree() {
   try {
-    if (inside.length === 0) {
-      rmSync6(path, { force: true });
-      return;
+    if (process.platform === "win32") {
+      return parseProcessTable(await askWindows(), true);
     }
-    const note = {
-      breakpoints: inside.map((one) => ({
-        script: relative2(root, one.scriptPath).replaceAll("\\", "/"),
-        lines: [...one.lines]
-      }))
-    };
-    mkdirSync6(dirname7(path), { recursive: true });
-    writeFileSync8(path, `${JSON.stringify(note, null, 2)}
-`, "utf8");
-  } catch (error) {
-    console.error(`[SERVER] Could not record the breakpoints at ${path}: ${errorMessage(error)}`);
+    return parseProcessTable(await askPosix());
+  } catch {
+    return;
   }
 }
-function readBreakpointNote(projectPath) {
-  try {
-    const parsed = JSON.parse(readFileSync10(breakpointNotePath(projectPath), "utf8"));
-    if (typeof parsed !== "object" || parsed === null || !Array.isArray(parsed.breakpoints)) {
-      return [];
+function parseProcessTable(printed, started = false) {
+  const tree = new Map;
+  for (const line of printed.split(/\r?\n/)) {
+    const fields = /^\s*(\d+)\s+(\d+)(?:\s+(.*))?$/.exec(line);
+    if (fields === null) {
+      continue;
     }
-    const held = [];
-    for (const entry of parsed.breakpoints) {
-      if (typeof entry !== "object" || entry === null) {
-        continue;
-      }
-      const { script, lines: listed } = entry;
-      if (typeof script !== "string" || isAbsolute2(script) || script.split("/").includes("..")) {
-        continue;
-      }
-      const lines = Array.isArray(listed) ? listed.filter((line) => Number.isInteger(line) && line > 0) : [];
-      if (lines.length > 0) {
-        held.push({ scriptPath: realPathOr(join12(projectPath, script)), lines });
-      }
+    const pid = Number(fields[1]);
+    const parent = Number(fields[2]);
+    const rest = (fields[3] ?? "").trim();
+    if (pid <= 0) {
+      continue;
     }
-    return held;
-  } catch {
-    return [];
+    if (!started) {
+      tree.set(pid, { parent, command: rest });
+      continue;
+    }
+    const timed = /^(\d+)(?:\s+(.*))?$/.exec(rest);
+    if (timed === null) {
+      continue;
+    }
+    const began = Number(timed[1]);
+    tree.set(pid, { parent, command: (timed[2] ?? "").trim(), ...began > 0 ? { startedAt: began } : {} });
   }
+  return tree;
 }
-function withinProject(projectPath, scriptPath) {
-  const rel = relative2(projectPath, scriptPath);
-  return rel !== "" && !rel.startsWith("..") && !isAbsolute2(rel);
+function linked(tree, child, parent) {
+  const from = tree.get(child);
+  const to = tree.get(parent);
+  if (from === undefined || from.parent !== parent) {
+    return false;
+  }
+  if (from.startedAt === undefined || to?.startedAt === undefined) {
+    return true;
+  }
+  return from.startedAt >= to.startedAt;
 }
-var init_breakpoint_note = __esm(() => {
-  init_errors();
-  init_paths();
-});
-
-// src/bridge-announce.ts
-import { mkdirSync as mkdirSync7, readFileSync as readFileSync11, rmSync as rmSync7, writeFileSync as writeFileSync9 } from "node:fs";
-import { dirname as dirname8, join as join13 } from "node:path";
-function announcementPath(projectPath) {
-  return join13(projectPath, ".godot", "gdharness-bridge.json");
+function childrenIn(tree, pid) {
+  const children = [];
+  for (const child of tree.keys()) {
+    if (linked(tree, child, pid)) {
+      children.push(child);
+    }
+  }
+  return children;
 }
-function readAnnouncement(path) {
-  try {
-    const parsed = JSON.parse(readFileSync11(path, "utf8"));
-    if (typeof parsed !== "object" || parsed === null) {
-      return null;
+function descendantsIn(tree, pid) {
+  const found = [];
+  const queue = [pid];
+  const seen = new Set([pid]);
+  while (queue.length > 0) {
+    const next = queue.shift();
+    if (next === undefined) {
+      break;
     }
-    const said = parsed;
-    if (typeof said.port !== "number" || typeof said.pid !== "number") {
-      return null;
+    for (const child of childrenIn(tree, next)) {
+      if (!seen.has(child)) {
+        seen.add(child);
+        found.push(child);
+        queue.push(child);
+      }
     }
-    return said;
-  } catch {
-    return null;
   }
+  return found;
 }
-function announcementIsOurs(path) {
-  return readAnnouncement(path)?.pid === process.pid;
+function ancestorsIn(tree, pid, root) {
+  const chain = [];
+  const seen = new Set([pid]);
+  let child = pid;
+  let parent = tree.get(pid)?.parent;
+  while (parent !== undefined && !seen.has(parent) && linked(tree, child, parent)) {
+    chain.push(parent);
+    if (parent === root) {
+      break;
+    }
+    seen.add(parent);
+    child = parent;
+    parent = tree.get(parent)?.parent;
+  }
+  return chain;
 }
-function announceBridge(projectPath, bridge) {
-  const path = announcementPath(projectPath);
-  try {
-    mkdirSync7(dirname8(path), { recursive: true });
-    const announcement = {
-      protocol: BRIDGE_ANNOUNCE_PROTOCOL,
-      host: bridge.host,
-      port: bridge.port,
-      pid: process.pid,
-      version: bridge.version,
-      startedAt: new Date().toISOString()
-    };
-    writeFileSync9(path, `${JSON.stringify(announcement, null, 2)}
-`, "utf8");
-    return path;
-  } catch (error) {
-    console.error(`[SERVER] Could not announce the editor bridge at ${path}: ${errorMessage(error)}`);
-    return null;
+function readCommandLine(command) {
+  const words = commandWords(command);
+  const executable = words[0] === undefined ? "" : basename2(words[0].replaceAll("\\", "/"));
+  const at = words.indexOf("--path");
+  let projectPath = null;
+  if (at !== -1 && at + 1 < words.length) {
+    const taken = [];
+    for (const word of words.slice(at + 1)) {
+      if (taken.length > 0 && (word.startsWith("-") || /^[a-z]+:\/\//.test(word))) {
+        break;
+      }
+      taken.push(word);
+    }
+    projectPath = taken.join(" ");
   }
+  return {
+    executable,
+    projectPath,
+    editor: words.some((word) => word === "-e" || word === "--editor")
+  };
 }
-function withdrawBridge(path) {
-  if (path === null || !announcementIsOurs(path)) {
-    return;
+function commandWords(command) {
+  const words = [];
+  let word = "";
+  let quoted = false;
+  let started = false;
+  for (const char of command) {
+    if (char === '"') {
+      quoted = !quoted;
+      started = true;
+    } else if (!quoted && /\s/.test(char)) {
+      if (started) {
+        words.push(word);
+        word = "";
+        started = false;
+      }
+    } else {
+      word += char;
+      started = true;
+    }
   }
-  try {
-    rmSync7(path, { force: true });
-  } catch (error) {
-    console.error(`[SERVER] Could not withdraw the editor bridge announcement: ${errorMessage(error)}`);
+  if (started) {
+    words.push(word);
   }
+  return words;
 }
-var BRIDGE_ANNOUNCE_PROTOCOL = 1;
-var init_bridge_announce = __esm(() => {
-  init_errors();
+async function askWindows() {
+  const { stdout } = await run4("powershell.exe", [
+    "-NoProfile",
+    "-NonInteractive",
+    "-Command",
+    'Get-CimInstance Win32_Process | ForEach-Object { $began = 0; if ($_.CreationDate) { $began = ([DateTimeOffset]$_.CreationDate).ToUnixTimeMilliseconds() }; "$($_.ProcessId) $($_.ParentProcessId) $began $($_.CommandLine)" }'
+  ], { timeout: ASK_TIMEOUT_MS, windowsHide: true, maxBuffer: 16 * 1024 * 1024 });
+  return stdout;
+}
+async function askPosix() {
+  const { stdout } = await run4("ps", ["-e", "-o", "pid=,ppid=,args="], {
+    timeout: ASK_TIMEOUT_MS,
+    maxBuffer: 16 * 1024 * 1024
+  });
+  return stdout;
+}
+var run4, ASK_TIMEOUT_MS = 15000;
+var init_process_children = __esm(() => {
+  run4 = promisify4(execFile4);
 });
 
-// src/config-pin.ts
-import { existsSync as existsSync10, readFileSync as readFileSync12 } from "node:fs";
-import { join as join14 } from "node:path";
-function versionsNamedInConfig(projectPath) {
-  const config = join14(projectPath, ".mcp.json");
-  if (!existsSync10(config)) {
-    return [];
+// src/runtime-client.ts
+import { existsSync as existsSync10, readdirSync as readdirSync4, readFileSync as readFileSync10, statSync as statSync3, unlinkSync } from "node:fs";
+import { createConnection } from "node:net";
+import { tmpdir as tmpdir4 } from "node:os";
+import { dirname as dirname7, join as join12, resolve as resolve3 } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+function runtimeDirectory(variables = process.env) {
+  const explicit = envValue("GDHARNESS_RUNTIME_DIR", variables);
+  if (explicit) {
+    return explicit;
   }
-  let text;
-  try {
-    text = readFileSync12(config, "utf8");
-    JSON.parse(text);
-  } catch {
-    return [];
+  const perUser = envValue("XDG_RUNTIME_DIR", variables);
+  return join12(perUser ?? tmpdir4(), "gdharness");
+}
+function runtimeDirectories(variables = process.env) {
+  const candidates = [runtimeDirectory(variables)];
+  const fallbacks = process.platform === "win32" ? [envValue("SystemRoot", variables) ?? envValue("windir", variables) ?? "C:\\Windows"] : ["/tmp", "/var/tmp"];
+  for (const base of fallbacks) {
+    candidates.push(join12(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
   }
-  return [...new Set([...text.matchAll(PINNED)].map((found) => found[1] ?? ""))].filter((version) => version !== "");
+  return [...new Set(candidates.map((path) => resolve3(path)))];
 }
-function configDisagrees(projectPath, serverVersion) {
-  const named = versionsNamedInConfig(projectPath);
-  const others = named.filter((version) => version !== serverVersion);
-  if (others.length === 0) {
-    return null;
+function errorReportOf(pid, directories = runtimeDirectories()) {
+  for (const directory of directories) {
+    const path = join12(directory, `runtime-${pid}.log`);
+    if (existsSync10(path)) {
+      return path;
+    }
   }
-  return `.mcp.json in this project names gdharness@${others.join(" and gdharness@")}, and this server ` + `is ${serverVersion}. Whichever is meant to be right, nothing will change version until the ` + "MCP server is reconnected, and a pin kept anywhere else does not reach this file.";
+  return null;
 }
-var PINNED;
-var init_config_pin = __esm(() => {
-  PINNED = /\bgdharness@(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)\b/g;
+function processAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function parseAnnouncement(file, pid) {
+  let fields;
+  try {
+    fields = asParams(JSON.parse(readFileSync10(file, "utf8")));
+  } catch {
+    return { kind: "rubbish" };
+  }
+  const project = readParams(fields, "project");
+  const port = readNumber(fields, "port");
+  const address = readString(fields, "address");
+  const protocol = readNumber(fields, "protocol");
+  if (readNumber(fields, "pid") !== pid || port === undefined || !Number.isInteger(port) || port < 1 || port > 65535 || address === undefined || project === undefined) {
+    return { kind: "rubbish" };
+  }
+  const named = {
+    name: readString(project, "name") ?? "",
+    path: readString(project, "path") ?? ""
+  };
+  if (protocol !== RUNTIME_PROTOCOL) {
+    return { kind: "unspoken", unspoken: { pid, protocol: protocol ?? 0, project: named } };
+  }
+  const editorPid = readNumber(fields, "editor_pid");
+  return {
+    kind: "runtime",
+    endpoint: {
+      pid,
+      port,
+      address,
+      project: named,
+      file,
+      ...editorPid !== undefined && Number.isInteger(editorPid) && editorPid > 0 ? { editorPid } : {}
+    }
+  };
+}
+function runtimesAnnounced(directories = runtimeDirectories()) {
+  const running = new Map;
+  const unspoken = new Map;
+  for (const directory of directories) {
+    for (const found of announcedIn(directory)) {
+      if (found.kind === "runtime" && !running.has(found.endpoint.pid)) {
+        running.set(found.endpoint.pid, found.endpoint);
+      } else if (found.kind === "unspoken" && !unspoken.has(found.unspoken.pid)) {
+        unspoken.set(found.unspoken.pid, found.unspoken);
+      }
+    }
+  }
+  const newest = (a, b) => b.pid - a.pid;
+  return { running: [...running.values()].sort(newest), unspoken: [...unspoken.values()].sort(newest) };
+}
+function discoverRuntimes(directories = runtimeDirectories()) {
+  return runtimesAnnounced(directories).running;
+}
+function wentAway(file, pid) {
+  let project = "";
+  try {
+    const fields = asParams(JSON.parse(readFileSync10(file, "utf8")));
+    project = readString(readParams(fields, "project") ?? {}, "path") ?? "";
+  } catch {
+    return;
+  }
+  if (project === "") {
+    return;
+  }
+  gone.unshift({ pid, project, noticedAt: Date.now() });
+  gone.length = Math.min(gone.length, GONE_KEPT);
+}
+function announcedAndGone(projectPath) {
+  if (projectPath === undefined) {
+    return [];
+  }
+  const since = Date.now() - GONE_WINDOW_MS;
+  const wanted = resolve3(projectPath);
+  return gone.filter((one) => one.noticedAt >= since && resolve3(one.project) === wanted);
+}
+function strangersAmong(candidates, now, startTimes = startTimesOf) {
+  const toJudge = candidates.filter((one) => {
+    if (now - one.writtenAt < JUDGED_AFTER_MS) {
+      return false;
+    }
+    const known = verdicts.get(one.file);
+    return known === undefined || known.writtenAt !== one.writtenAt || !known.stranger && now - known.judgedAt > CONFIRMED_FOR_MS;
+  });
+  if (toJudge.length > 0) {
+    const began = startTimes(toJudge.map((one) => one.pid));
+    for (const one of toJudge) {
+      const at = began.get(one.pid);
+      const stranger = at !== undefined && at - one.writtenAt > STARTED_AFTER_ANNOUNCING_MS;
+      verdicts.set(one.file, { writtenAt: one.writtenAt, judgedAt: now, stranger });
+    }
+  }
+  return new Set(candidates.filter((one) => verdicts.get(one.file)?.stranger === true).map((one) => one.file));
+}
+function announcedIn(directory) {
+  if (!existsSync10(directory)) {
+    return [];
+  }
+  const found = [];
+  const candidates = [];
+  const entries = [];
+  for (const entry of readdirSync4(directory)) {
+    const report = ERROR_REPORT_PATTERN.exec(entry);
+    if (report) {
+      sweepErrorReport(join12(directory, entry), Number.parseInt(report[1] ?? "", 10));
+      continue;
+    }
+    const match = ANNOUNCEMENT_PATTERN.exec(entry);
+    if (!match) {
+      continue;
+    }
+    const file = join12(directory, entry);
+    const pid = Number.parseInt(match[1] ?? "", 10);
+    const alive = processAlive(pid);
+    entries.push({ file, pid, alive });
+    if (alive) {
+      try {
+        candidates.push({ file, pid, writtenAt: statSync3(file).mtimeMs });
+      } catch {}
+    }
+  }
+  const strangers = strangersAmong(candidates, Date.now());
+  for (const { file, pid, alive } of entries) {
+    const announced = alive && !strangers.has(file) ? parseAnnouncement(file, pid) : { kind: "rubbish" };
+    if (announced.kind === "rubbish") {
+      if (!alive || strangers.has(file)) {
+        wentAway(file, pid);
+      }
+      try {
+        unlinkSync(file);
+      } catch {}
+      verdicts.delete(file);
+      continue;
+    }
+    found.push(announced);
+  }
+  const held = new Set(entries.map((one) => one.file));
+  const here = join12(directory, ".");
+  for (const file of verdicts.keys()) {
+    if (dirname7(file) === here && !held.has(file)) {
+      verdicts.delete(file);
+    }
+  }
+  return found;
+}
+async function announcementEnded(pid, directories = runtimeDirectories()) {
+  const files = directories.map((directory) => join12(directory, `runtime-${pid}.json`)).filter((file) => existsSync10(file));
+  const first = files[0];
+  if (first === undefined) {
+    return;
+  }
+  const until = Date.now() + ENDED_WITHIN_MS;
+  while (processAlive(pid)) {
+    const left = until - Date.now();
+    if (left <= 0) {
+      return;
+    }
+    await delay(Math.min(LOOK_EVERY_MS, left));
+  }
+  wentAway(first, pid);
+  for (const file of files) {
+    try {
+      unlinkSync(file);
+    } catch {}
+    verdicts.delete(file);
+  }
+}
+function sweepErrorReport(path, pid, now = Date.now()) {
+  if (processAlive(pid)) {
+    return;
+  }
+  try {
+    if (now - statSync3(path).mtimeMs >= ERROR_REPORT_KEEP_MS) {
+      unlinkSync(path);
+    }
+  } catch {}
+}
+async function announcedSince(projectPath, before, waiting = {}) {
+  const wanted = resolve3(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) && resolve3(endpoint.project.path) === wanted && (waiting.accept?.(endpoint) ?? true));
+    if (fresh !== undefined) {
+      return fresh;
+    }
+    const left = until - Date.now();
+    if (left <= 0 || waiting.giveUp?.() === true) {
+      return null;
+    }
+    await delay(Math.min(LOOK_EVERY_MS, left));
+  }
+}
+function describe2(endpoint) {
+  return `pid ${endpoint.pid} on ${endpoint.address}:${endpoint.port} (${endpoint.project.name || "unnamed"} at ${endpoint.project.path})`;
+}
+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}.`;
+}
+function chooseRuntime(endpoints, projectPath, unspoken = [], pid) {
+  if (pid !== undefined) {
+    const named = endpoints.find((endpoint) => endpoint.pid === pid);
+    if (named !== undefined) {
+      if (projectPath !== undefined && resolve3(named.project.path) !== resolve3(projectPath)) {
+        return {
+          problem: `The game with pid ${pid} is running ${named.project.path}, not ${resolve3(projectPath)}. Running: ${endpoints.map(describe2).join("; ")}.`
+        };
+      }
+      return { endpoint: named };
+    }
+    const tooNewToo = unspoken.find((game) => game.pid === pid);
+    if (tooNewToo !== undefined) {
+      return { problem: tooNew([tooNewToo]) };
+    }
+    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.`
+    };
+  }
+  if (endpoints.length === 0) {
+    if (unspoken.length > 0) {
+      return { problem: tooNew(unspoken) };
+    }
+    const went = announcedAndGone(projectPath);
+    const first = went[0];
+    if (first !== undefined) {
+      const ago = Math.max(1, Math.round((Date.now() - first.noticedAt) / 1000));
+      const others = went.length - 1;
+      const earlier = others === 0 ? "" : ` ${others} earlier ${others === 1 ? "one" : "ones"} went the same way.`;
+      return {
+        problem: `A game with the runtime addon announced itself and its process is gone: pid ${first.pid}` + `${first.project === "" ? "" : ` for ${first.project}`}, noticed ${ago}s ago.${earlier}` + " It quit or was ended rather than never starting, so editor_output has what it printed" + " on the way, including whatever it broke on. Start another with editor_run once you have read it."
+      };
+    }
+    return {
+      problem: "No game with the runtime addon is running. Start one with editor_run, or play the project from the editor with the addon enabled."
+    };
+  }
+  if (projectPath !== undefined) {
+    const wanted = resolve3(projectPath);
+    const matching = endpoints.filter((endpoint) => resolve3(endpoint.project.path) === wanted);
+    if (matching.length === 0) {
+      return {
+        problem: `No running game is from ${wanted}. Running: ${endpoints.map(describe2).join("; ")}.`
+      };
+    }
+    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.`
+    };
+  }
+  if (endpoints.length === 1 && endpoints[0]) {
+    return { endpoint: endpoints[0] };
+  }
+  return {
+    problem: `Several games are running: ${endpoints.map(describe2).join("; ")}. Pass projectPath to choose one, or pid when they are from one project.`
+  };
+}
+function runtimeRequest(endpoint, command, params, timeoutMs) {
+  const id = nextRequestId++;
+  return new Promise((settle) => {
+    let done = false;
+    let buffered = "";
+    let welcomed = false;
+    const socket = createConnection({ port: endpoint.port, host: endpoint.address });
+    const finish = (reply) => {
+      if (done) {
+        return;
+      }
+      done = true;
+      clearTimeout(timer);
+      socket.destroy();
+      settle(reply);
+    };
+    const timer = setTimeout(() => {
+      finish({
+        ok: false,
+        reason: "busy",
+        message: `The game (${describe2(endpoint)}) accepted the connection but did not answer '${command}' within ${timeoutMs}ms. It may be paused at a breakpoint or stuck in a long frame.`
+      });
+    }, timeoutMs);
+    socket.setEncoding("utf8");
+    socket.on("connect", () => {
+      socket.write(`${JSON.stringify({ id, command, params })}
+`);
+    });
+    socket.on("data", (chunk) => {
+      buffered += chunk;
+      let newline = buffered.indexOf(`
+`);
+      while (newline !== -1 && !done) {
+        const line = buffered.slice(0, newline).trim();
+        buffered = buffered.slice(newline + 1);
+        newline = buffered.indexOf(`
+`);
+        if (line === "") {
+          continue;
+        }
+        let message;
+        try {
+          message = asParams(JSON.parse(line));
+        } catch {
+          continue;
+        }
+        if (!welcomed) {
+          welcomed = true;
+          if (readString(message, "type") === "welcome") {
+            const spoken = readNumber(message, "protocol");
+            if (spoken !== RUNTIME_PROTOCOL) {
+              finish({
+                ok: false,
+                reason: "protocol",
+                message: `The game (${describe2(endpoint)}) speaks runtime protocol ${spoken ?? "unknown"} and this server speaks ${RUNTIME_PROTOCOL}. Reinstall the runtime addon into the project.`
+              });
+              return;
+            }
+            continue;
+          }
+        }
+        if (message["id"] !== id) {
+          continue;
+        }
+        if (readString(message, "type") === "error") {
+          finish({ ok: false, reason: "error", message: readString(message, "message") ?? "unknown error" });
+          return;
+        }
+        finish({ ok: true, payload: message, endpoint });
+      }
+    });
+    socket.on("error", (error) => {
+      finish({
+        ok: false,
+        reason: "refused",
+        message: `The game (${describe2(endpoint)}) is running but nothing answered on its port: ${error.code ?? error.message}. It may still be starting, or be shutting down.`
+      });
+    });
+    socket.on("close", () => {
+      finish({
+        ok: false,
+        reason: "refused",
+        message: `The game (${describe2(endpoint)}) closed the connection before answering '${command}'.`
+      });
+    });
+  });
+}
+var RUNTIME_PROTOCOL = 2, ANNOUNCEMENT_PATTERN, ERROR_REPORT_PATTERN, ERROR_REPORT_KEEP_MS, GONE_WINDOW_MS = 120000, GONE_KEPT = 32, gone, STARTED_AFTER_ANNOUNCING_MS = 2000, CONFIRMED_FOR_MS = 60000, JUDGED_AFTER_MS = 60000, verdicts, ENDED_WITHIN_MS = 3000, LOOK_EVERY_MS = 50, ANNOUNCE_BUDGET_MS = 5000, nextRequestId = 1;
+var init_runtime_client = __esm(() => {
+  init_process_children();
+  ANNOUNCEMENT_PATTERN = /^runtime-(\d+)\.json$/;
+  ERROR_REPORT_PATTERN = /^runtime-(\d+)\.log$/;
+  ERROR_REPORT_KEEP_MS = 60 * 60 * 1000;
+  gone = [];
+  verdicts = new Map;
+});
+
+// src/boot-note.ts
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync11, writeFileSync as writeFileSync8 } from "node:fs";
+import { dirname as dirname8, join as join13 } from "node:path";
+function bootNotePath(projectPath) {
+  return join13(projectPath, ".godot", "gdharness-boot.json");
+}
+function readBootNote(projectPath) {
+  try {
+    const noted = readNumber(asParams(JSON.parse(readFileSync11(bootNotePath(projectPath), "utf8"))), "announcedAfterMs");
+    return noted !== undefined && Number.isFinite(noted) && noted > 0 ? noted : null;
+  } catch {
+    return null;
+  }
+}
+function writeBootNote(projectPath, announcedAfterMs) {
+  try {
+    const path = bootNotePath(projectPath);
+    mkdirSync6(dirname8(path), { recursive: true });
+    writeFileSync8(path, JSON.stringify({ announcedAfterMs: Math.round(announcedAfterMs), at: new Date().toISOString() }, null, 2), "utf8");
+  } catch {}
+}
+function waitSizedTo(lastBootMs, usual = ANNOUNCE_BUDGET_MS) {
+  if (lastBootMs === null) {
+    return usual;
+  }
+  return Math.min(LONGEST_SIZED_WAIT_MS, Math.max(usual, Math.round(lastBootMs * 1.5)));
+}
+var LONGEST_SIZED_WAIT_MS = 60000;
+var init_boot_note = __esm(() => {
+  init_runtime_client();
+});
+
+// src/breakpoint-note.ts
+import { mkdirSync as mkdirSync7, readFileSync as readFileSync12, rmSync as rmSync6, writeFileSync as writeFileSync9 } from "node:fs";
+import { dirname as dirname9, isAbsolute as isAbsolute2, join as join14, relative as relative2 } from "node:path";
+function breakpointNotePath(projectPath) {
+  return join14(projectPath, ".godot", "gdharness-breakpoints.json");
+}
+function writeBreakpointNote(projectPath, held) {
+  const path = breakpointNotePath(projectPath);
+  const root = realPathOr(projectPath);
+  const inside = held.map((one) => ({ scriptPath: realPathOr(one.scriptPath), lines: one.lines })).filter((one) => one.lines.length > 0 && withinProject(root, one.scriptPath));
+  try {
+    if (inside.length === 0) {
+      rmSync6(path, { force: true });
+      return;
+    }
+    const note = {
+      breakpoints: inside.map((one) => ({
+        script: relative2(root, one.scriptPath).replaceAll("\\", "/"),
+        lines: [...one.lines]
+      }))
+    };
+    mkdirSync7(dirname9(path), { recursive: true });
+    writeFileSync9(path, `${JSON.stringify(note, null, 2)}
+`, "utf8");
+  } catch (error) {
+    console.error(`[SERVER] Could not record the breakpoints at ${path}: ${errorMessage(error)}`);
+  }
+}
+function readBreakpointNote(projectPath) {
+  try {
+    const parsed = JSON.parse(readFileSync12(breakpointNotePath(projectPath), "utf8"));
+    if (typeof parsed !== "object" || parsed === null || !Array.isArray(parsed.breakpoints)) {
+      return [];
+    }
+    const held = [];
+    for (const entry of parsed.breakpoints) {
+      if (typeof entry !== "object" || entry === null) {
+        continue;
+      }
+      const { script, lines: listed } = entry;
+      if (typeof script !== "string" || isAbsolute2(script) || script.split("/").includes("..")) {
+        continue;
+      }
+      const lines = Array.isArray(listed) ? listed.filter((line) => Number.isInteger(line) && line > 0) : [];
+      if (lines.length > 0) {
+        held.push({ scriptPath: realPathOr(join14(projectPath, script)), lines });
+      }
+    }
+    return held;
+  } catch {
+    return [];
+  }
+}
+function withinProject(projectPath, scriptPath) {
+  const rel = relative2(projectPath, scriptPath);
+  return rel !== "" && !rel.startsWith("..") && !isAbsolute2(rel);
+}
+var init_breakpoint_note = __esm(() => {
+  init_errors();
+  init_paths();
+});
+
+// src/bridge-announce.ts
+import { mkdirSync as mkdirSync8, readFileSync as readFileSync13, rmSync as rmSync7, writeFileSync as writeFileSync10 } from "node:fs";
+import { dirname as dirname10, join as join15 } from "node:path";
+function announcementPath(projectPath) {
+  return join15(projectPath, ".godot", "gdharness-bridge.json");
+}
+function readAnnouncement(path) {
+  try {
+    const parsed = JSON.parse(readFileSync13(path, "utf8"));
+    if (typeof parsed !== "object" || parsed === null) {
+      return null;
+    }
+    const said = parsed;
+    if (typeof said.port !== "number" || typeof said.pid !== "number") {
+      return null;
+    }
+    return said;
+  } catch {
+    return null;
+  }
+}
+function announcementIsOurs(path) {
+  return readAnnouncement(path)?.pid === process.pid;
+}
+function announceBridge(projectPath, bridge) {
+  const path = announcementPath(projectPath);
+  try {
+    mkdirSync8(dirname10(path), { recursive: true });
+    const announcement = {
+      protocol: BRIDGE_ANNOUNCE_PROTOCOL,
+      host: bridge.host,
+      port: bridge.port,
+      pid: process.pid,
+      version: bridge.version,
+      startedAt: new Date().toISOString()
+    };
+    writeFileSync10(path, `${JSON.stringify(announcement, null, 2)}
+`, "utf8");
+    return path;
+  } catch (error) {
+    console.error(`[SERVER] Could not announce the editor bridge at ${path}: ${errorMessage(error)}`);
+    return null;
+  }
+}
+function withdrawBridge(path) {
+  if (path === null || !announcementIsOurs(path)) {
+    return;
+  }
+  try {
+    rmSync7(path, { force: true });
+  } catch (error) {
+    console.error(`[SERVER] Could not withdraw the editor bridge announcement: ${errorMessage(error)}`);
+  }
+}
+var BRIDGE_ANNOUNCE_PROTOCOL = 1;
+var init_bridge_announce = __esm(() => {
+  init_errors();
+});
+
+// src/config-pin.ts
+import { existsSync as existsSync11, readFileSync as readFileSync14 } from "node:fs";
+import { join as join16 } from "node:path";
+function versionsNamedInConfig(projectPath) {
+  const config = join16(projectPath, ".mcp.json");
+  if (!existsSync11(config)) {
+    return [];
+  }
+  let text;
+  try {
+    text = readFileSync14(config, "utf8");
+    JSON.parse(text);
+  } catch {
+    return [];
+  }
+  return [...new Set([...text.matchAll(PINNED)].map((found) => found[1] ?? ""))].filter((version) => version !== "");
+}
+function configDisagrees(projectPath, serverVersion) {
+  const named = versionsNamedInConfig(projectPath);
+  const others = named.filter((version) => version !== serverVersion);
+  if (others.length === 0) {
+    return null;
+  }
+  return `.mcp.json in this project names gdharness@${others.join(" and gdharness@")}, and this server ` + `is ${serverVersion}. Whichever is meant to be right, nothing will change version until the ` + "MCP server is reconnected, and a pin kept anywhere else does not reach this file.";
+}
+var PINNED;
+var init_config_pin = __esm(() => {
+  PINNED = /\bgdharness@(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)\b/g;
 });
 
 // src/framing.ts
@@ -31514,8 +32145,8 @@ var init_ports = __esm(() => {
 });
 
 // src/dap_client.ts
-import { createConnection } from "node:net";
-import { setTimeout as delay } from "node:timers/promises";
+import { createConnection as createConnection2 } from "node:net";
+import { setTimeout as delay2 } from "node:timers/promises";
 function said(body, field) {
   const value = body?.[field];
   return typeof value === "string" ? value : "";
@@ -31550,7 +32181,7 @@ class GodotDAPClient {
       return;
     }
     await new Promise((resolve, reject) => {
-      const socket = createConnection({ host: this.host, port: this.port });
+      const socket = createConnection2({ host: this.host, port: this.port });
       this.socket = socket;
       const connectTimeout = setTimeout(() => {
         socket.destroy();
@@ -31959,7 +32590,7 @@ class GodotDAPClient {
           return answered;
         }
       } catch {}
-      await delay(200);
+      await delay2(200);
     }
     return [];
   }
@@ -31980,7 +32611,7 @@ class GodotDAPClient {
           break;
         }
       } catch {}
-      await delay(200);
+      await delay2(200);
     }
     const named = [];
     for (const scope of scopes) {
@@ -35496,10 +36127,10 @@ var init_godot_bridge = __esm(() => {
 });
 
 // src/godot-path.ts
-import { execFile as execFile4 } from "node:child_process";
-import { existsSync as existsSync11 } from "node:fs";
+import { execFile as execFile5 } from "node:child_process";
+import { existsSync as existsSync12 } from "node:fs";
 import { normalize as normalize2 } from "node:path";
-import { promisify as promisify4 } from "node:util";
+import { promisify as promisify5 } from "node:util";
 
 class GodotLocator2 {
   answered = new Map;
@@ -35552,11 +36183,11 @@ class GodotLocator2 {
       return known;
     }
     let reason;
-    if (path !== "godot" && !existsSync11(path)) {
+    if (path !== "godot" && !existsSync12(path)) {
       reason = "does not exist";
     } else {
       try {
-        await run4(path, ["--version"]);
+        await run5(path, ["--version"]);
         reason = null;
       } catch (error) {
         reason = `does not answer --version: ${errorMessage(error)}`;
@@ -35566,11 +36197,11 @@ class GodotLocator2 {
     return reason;
   }
 }
-var run4;
+var run5;
 var init_godot_path = __esm(() => {
   init_detection();
   init_errors();
-  run4 = promisify4(execFile4);
+  run5 = promisify5(execFile5);
 });
 
 // src/issues.ts
@@ -35927,8 +36558,8 @@ var init_junit = __esm(() => {
 // src/lsp_client.ts
 import { realpathSync as realpathSync2 } from "node:fs";
 import { readFile, realpath } from "node:fs/promises";
-import { createConnection as createConnection2 } from "node:net";
-import { dirname as dirname9, resolve as resolve3 } from "node:path";
+import { createConnection as createConnection3 } from "node:net";
+import { dirname as dirname11, resolve as resolve4 } from "node:path";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
 function diagnosticsKey(uri) {
   let decoded;
@@ -35974,7 +36605,7 @@ class GodotLSPClient {
     }
     this.connectPromise = new Promise((resolveConnect, rejectConnect) => {
       let settled = false;
-      const socket = createConnection2({ port: this.port, host: this.host }, () => {
+      const socket = createConnection3({ port: this.port, host: this.host }, () => {
         this.socket = socket;
         this.connected = true;
         this.reader = new FrameReader;
@@ -36056,7 +36687,7 @@ class GodotLSPClient {
     if (this.initialized) {
       return;
     }
-    const rootPath = this.rootPath ?? dirname9(resolve3(filePath));
+    const rootPath = this.rootPath ?? dirname11(resolve4(filePath));
     await this.initialize(rootPath);
   }
   async sendRequest(method, params) {
@@ -36194,7 +36825,7 @@ class GodotLSPClient {
     });
   }
   toFileUri(filePath) {
-    return pathToFileURL(resolve3(filePath)).href;
+    return pathToFileURL(resolve4(filePath)).href;
   }
   syncDocument(filePath, content) {
     const uri = this.toFileUri(filePath);
@@ -36235,7 +36866,7 @@ class GodotLSPClient {
   }
   async initialize(rootPath) {
     await this.ensureConnected();
-    const resolvedRootPath = resolve3(rootPath);
+    const resolvedRootPath = resolve4(rootPath);
     const rootUri = pathToFileURL(resolvedRootPath).href;
     const result = await this.sendRequest("initialize", {
       processId: process.pid,
@@ -36378,7 +37009,7 @@ function normalizeLSPError(error, port) {
   return String(error);
 }
 async function resolveLSPPaths(projectPathValue, scriptPathValue) {
-  const requestedProjectPath = resolve3(projectPathValue);
+  const requestedProjectPath = resolve4(projectPathValue);
   let projectPath;
   try {
     projectPath = await realpath(requestedProjectPath);
@@ -36432,169 +37063,33 @@ async function handleLSPTool(client, toolName, args) {
         return asToolResponse({ completions });
       }
       case "lsp_get_hover": {
-        const line = Number(parsedArgs["line"]);
-        const character = Number(parsedArgs["character"]);
-        if (!Number.isFinite(line) || !Number.isFinite(character)) {
-          throw new Refusal2("Arguments line and character must be numbers.");
-        }
-        const hover = await client.getHover(scriptPath, content, line, character);
-        return asToolResponse({ hover });
-      }
-      case "lsp_get_symbols": {
-        const symbols = await client.getDocumentSymbols(scriptPath, content);
-        return asToolResponse({ symbols });
-      }
-      default:
-        return asToolResponse({ error: `Unknown LSP tool: ${toolName}` });
-    }
-  } catch (error) {
-    return asToolResponse({
-      error: normalizeLSPError(error, client.port)
-    });
-  }
-}
-var DEFAULT_LSP_PORT = 6005, DIAGNOSTICS_TIMEOUT_MS = 5000;
-var init_lsp_client = __esm(() => {
-  init_errors();
-  init_framing();
-  init_paths();
-  init_ports();
-});
-
-// src/process-children.ts
-import { execFile as execFile5 } from "node:child_process";
-import { basename as basename2 } from "node:path";
-import { promisify as promisify5 } from "node:util";
-async function processTree() {
-  try {
-    const printed = process.platform === "win32" ? await askWindows() : await askPosix();
-    return parseProcessTable(printed);
-  } catch {
-    return;
-  }
-}
-function parseProcessTable(printed) {
-  const tree = new Map;
-  for (const line of printed.split(/\r?\n/)) {
-    const fields = /^\s*(\d+)\s+(\d+)(?:\s+(.*))?$/.exec(line);
-    if (fields === null) {
-      continue;
-    }
-    const pid = Number(fields[1]);
-    const parent = Number(fields[2]);
-    if (pid > 0) {
-      tree.set(pid, { parent, command: (fields[3] ?? "").trim() });
-    }
-  }
-  return tree;
-}
-function childrenIn(tree, pid) {
-  const children = [];
-  for (const [child, listed] of tree) {
-    if (listed.parent === pid) {
-      children.push(child);
-    }
-  }
-  return children;
-}
-function descendantsIn(tree, pid) {
-  const found = [];
-  const queue = [pid];
-  const seen = new Set([pid]);
-  while (queue.length > 0) {
-    const next = queue.shift();
-    if (next === undefined) {
-      break;
-    }
-    for (const child of childrenIn(tree, next)) {
-      if (!seen.has(child)) {
-        seen.add(child);
-        found.push(child);
-        queue.push(child);
-      }
-    }
-  }
-  return found;
-}
-function ancestorsIn(tree, pid, root) {
-  const chain = [];
-  const seen = new Set([pid]);
-  let parent = tree.get(pid)?.parent;
-  while (parent !== undefined && !seen.has(parent)) {
-    chain.push(parent);
-    if (parent === root) {
-      break;
-    }
-    seen.add(parent);
-    parent = tree.get(parent)?.parent;
-  }
-  return chain;
-}
-function readCommandLine(command) {
-  const words = commandWords(command);
-  const executable = words[0] === undefined ? "" : basename2(words[0].replaceAll("\\", "/"));
-  const at = words.indexOf("--path");
-  let projectPath = null;
-  if (at !== -1 && at + 1 < words.length) {
-    const taken = [];
-    for (const word of words.slice(at + 1)) {
-      if (taken.length > 0 && (word.startsWith("-") || /^[a-z]+:\/\//.test(word))) {
-        break;
+        const line = Number(parsedArgs["line"]);
+        const character = Number(parsedArgs["character"]);
+        if (!Number.isFinite(line) || !Number.isFinite(character)) {
+          throw new Refusal2("Arguments line and character must be numbers.");
+        }
+        const hover = await client.getHover(scriptPath, content, line, character);
+        return asToolResponse({ hover });
       }
-      taken.push(word);
-    }
-    projectPath = taken.join(" ");
-  }
-  return {
-    executable,
-    projectPath,
-    editor: words.some((word) => word === "-e" || word === "--editor")
-  };
-}
-function commandWords(command) {
-  const words = [];
-  let word = "";
-  let quoted = false;
-  let started = false;
-  for (const char of command) {
-    if (char === '"') {
-      quoted = !quoted;
-      started = true;
-    } else if (!quoted && /\s/.test(char)) {
-      if (started) {
-        words.push(word);
-        word = "";
-        started = false;
+      case "lsp_get_symbols": {
+        const symbols = await client.getDocumentSymbols(scriptPath, content);
+        return asToolResponse({ symbols });
       }
-    } else {
-      word += char;
-      started = true;
+      default:
+        return asToolResponse({ error: `Unknown LSP tool: ${toolName}` });
     }
+  } catch (error) {
+    return asToolResponse({
+      error: normalizeLSPError(error, client.port)
+    });
   }
-  if (started) {
-    words.push(word);
-  }
-  return words;
-}
-async function askWindows() {
-  const { stdout } = await run5("powershell.exe", [
-    "-NoProfile",
-    "-NonInteractive",
-    "-Command",
-    'Get-CimInstance Win32_Process | ForEach-Object { "$($_.ProcessId) $($_.ParentProcessId) $($_.CommandLine)" }'
-  ], { timeout: ASK_TIMEOUT_MS, windowsHide: true, maxBuffer: 16 * 1024 * 1024 });
-  return stdout;
-}
-async function askPosix() {
-  const { stdout } = await run5("ps", ["-e", "-o", "pid=,ppid=,args="], {
-    timeout: ASK_TIMEOUT_MS,
-    maxBuffer: 16 * 1024 * 1024
-  });
-  return stdout;
 }
-var run5, ASK_TIMEOUT_MS = 15000;
-var init_process_children = __esm(() => {
-  run5 = promisify5(execFile5);
+var DEFAULT_LSP_PORT = 6005, DIAGNOSTICS_TIMEOUT_MS = 5000;
+var init_lsp_client = __esm(() => {
+  init_errors();
+  init_framing();
+  init_paths();
+  init_ports();
 });
 
 // src/process-time.ts
@@ -36637,13 +37132,13 @@ var init_process_time = __esm(() => {
 });
 
 // src/project-scan.ts
-import { existsSync as existsSync12, readdirSync as readdirSync4, readFileSync as readFileSync13 } from "node:fs";
-import { join as join15 } from "node:path";
+import { existsSync as existsSync13, readdirSync as readdirSync5, readFileSync as readFileSync15 } from "node:fs";
+import { join as join17 } from "node:path";
 function skipped(name) {
   return name.startsWith(".") || SKIPPED.has(name);
 }
 function steppedOver(directory) {
-  return existsSync12(join15(directory, ".gdignore"));
+  return existsSync13(join17(directory, ".gdignore"));
 }
 function projectStructure(projectPath) {
   const structure = { scenes: 0, scripts: 0, assets: 0, other: 0 };
@@ -36651,12 +37146,12 @@ function projectStructure(projectPath) {
     if (steppedOver(directory)) {
       return;
     }
-    for (const entry of readdirSync4(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync5(directory, { withFileTypes: true })) {
       if (skipped(entry.name)) {
         continue;
       }
       if (entry.isDirectory()) {
-        visit(join15(directory, entry.name));
+        visit(join17(directory, entry.name));
       } else if (entry.isFile()) {
         const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
         if (extension === "tscn") {
@@ -36680,20 +37175,20 @@ function scriptsWithoutUid(projectPath) {
     if (steppedOver(directory)) {
       return;
     }
-    for (const entry of readdirSync4(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync5(directory, { withFileTypes: true })) {
       if (skipped(entry.name)) {
         continue;
       }
       const spelled = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
       if (entry.isDirectory()) {
-        visit(join15(directory, entry.name), spelled);
+        visit(join17(directory, entry.name), spelled);
         continue;
       }
       if (!entry.isFile()) {
         continue;
       }
       const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
-      if (CARRIES_A_UID.has(extension) && !existsSync12(join15(directory, `${entry.name}.uid`))) {
+      if (CARRIES_A_UID.has(extension) && !existsSync13(join17(directory, `${entry.name}.uid`))) {
         found.push(spelled);
       }
     }
@@ -36721,459 +37216,126 @@ function searchProject(projectPath, options) {
     if (steppedOver(directory)) {
       return;
     }
-    for (const entry of readdirSync4(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync5(directory, { withFileTypes: true })) {
       if (full()) {
         return;
       }
       if (skipped(entry.name)) {
         continue;
       }
-      const entryPath = join15(directory, entry.name);
+      const entryPath = join17(directory, entry.name);
       if (entry.isDirectory()) {
         visit(entryPath);
         continue;
       }
-      const extension = entry.name.includes(".") ? entry.name.split(".").pop()?.toLowerCase() ?? "" : "";
-      if (!entry.isFile() || !extensions.has(extension)) {
-        continue;
-      }
-      result.summary.files_searched += 1;
-      const matches = [];
-      for (const [index, line] of readFileSync13(entryPath, "utf8").split(`
-`).entries()) {
-        if (full()) {
-          break;
-        }
-        const match = regex ? regex.exec(line)?.[0] : (options.caseSensitive ? line : line.toLowerCase()).includes(needle) ? options.query : "";
-        if (match) {
-          matches.push({ line: index + 1, content: line.trim(), match });
-          result.summary.total_matches += 1;
-        }
-      }
-      if (matches.length > 0) {
-        const relativePath = entryPath.slice(projectPath.length + 1).replace(/\\/g, "/");
-        result.results.push({ file: `res://${relativePath}`, matches });
-        result.summary.files_with_matches += 1;
-      }
-    }
-  };
-  visit(projectPath);
-  return result;
-}
-var SKIPPED, ASSET_EXTENSIONS, CARRIES_A_UID;
-var init_project_scan = __esm(() => {
-  SKIPPED = new Set(["node_modules"]);
-  ASSET_EXTENSIONS = new Set(["png", "jpg", "jpeg", "webp", "svg", "ttf", "otf", "wav", "mp3", "ogg"]);
-  CARRIES_A_UID = new Set(["gd", "shader", "gdshader"]);
-});
-
-// src/restart-note.ts
-import { mkdirSync as mkdirSync8, readFileSync as readFileSync14, rmSync as rmSync8, writeFileSync as writeFileSync10 } from "node:fs";
-import { dirname as dirname10, join as join16 } from "node:path";
-function restartNotePath(projectPath) {
-  return join16(projectPath, ".godot", "gdharness-restart.json");
-}
-function noteRestartBegun(note) {
-  const path = restartNotePath(note.projectPath);
-  try {
-    mkdirSync8(dirname10(path), { recursive: true });
-    writeFileSync10(path, `${JSON.stringify(note, null, 2)}
-`, "utf8");
-  } catch (error) {
-    console.error(`[SERVER] Could not record the restart at ${path}: ${errorMessage(error)}`);
-  }
-}
-function restartOwed(projectPath) {
-  try {
-    const parsed = JSON.parse(readFileSync14(restartNotePath(projectPath), "utf8"));
-    if (typeof parsed !== "object" || parsed === null) {
-      return null;
-    }
-    const said = parsed;
-    if (typeof said.quitAt !== "string" || typeof said.byPid !== "number" || typeof said.ports !== "object") {
-      return null;
-    }
-    return said;
-  } catch {
-    return null;
-  }
-}
-function restartSettled(projectPath) {
-  try {
-    rmSync8(restartNotePath(projectPath), { force: true });
-  } catch (error) {
-    console.error(`[SERVER] Could not clear the restart note: ${errorMessage(error)}`);
-  }
-}
-var init_restart_note = __esm(() => {
-  init_errors();
-});
-
-// src/runtime-client.ts
-import { existsSync as existsSync13, readdirSync as readdirSync5, readFileSync as readFileSync15, statSync as statSync3, unlinkSync } from "node:fs";
-import { createConnection as createConnection3 } from "node:net";
-import { tmpdir as tmpdir4 } from "node:os";
-import { join as join17, resolve as resolve4 } from "node:path";
-import { setTimeout as delay2 } from "node:timers/promises";
-function runtimeDirectory(variables = process.env) {
-  const explicit = envValue("GDHARNESS_RUNTIME_DIR", variables);
-  if (explicit) {
-    return explicit;
-  }
-  const perUser = envValue("XDG_RUNTIME_DIR", variables);
-  return join17(perUser ?? tmpdir4(), "gdharness");
-}
-function runtimeDirectories(variables = process.env) {
-  const candidates = [runtimeDirectory(variables)];
-  const fallbacks = process.platform === "win32" ? [envValue("SystemRoot", variables) ?? envValue("windir", variables) ?? "C:\\Windows"] : ["/tmp", "/var/tmp"];
-  for (const base of fallbacks) {
-    candidates.push(join17(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
-  }
-  return [...new Set(candidates.map((path) => resolve4(path)))];
-}
-function errorReportOf(pid, directories = runtimeDirectories()) {
-  for (const directory of directories) {
-    const path = join17(directory, `runtime-${pid}.log`);
-    if (existsSync13(path)) {
-      return path;
-    }
-  }
-  return null;
-}
-function processAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return error.code === "EPERM";
-  }
-}
-function parseAnnouncement(file, pid) {
-  let fields;
-  try {
-    fields = asParams(JSON.parse(readFileSync15(file, "utf8")));
-  } catch {
-    return { kind: "rubbish" };
-  }
-  const project = readParams(fields, "project");
-  const port = readNumber(fields, "port");
-  const address = readString(fields, "address");
-  const protocol = readNumber(fields, "protocol");
-  if (readNumber(fields, "pid") !== pid || port === undefined || !Number.isInteger(port) || port < 1 || port > 65535 || address === undefined || project === undefined) {
-    return { kind: "rubbish" };
-  }
-  const named = {
-    name: readString(project, "name") ?? "",
-    path: readString(project, "path") ?? ""
-  };
-  if (protocol !== RUNTIME_PROTOCOL) {
-    return { kind: "unspoken", unspoken: { pid, protocol: protocol ?? 0, project: named } };
-  }
-  const editorPid = readNumber(fields, "editor_pid");
-  return {
-    kind: "runtime",
-    endpoint: {
-      pid,
-      port,
-      address,
-      project: named,
-      file,
-      ...editorPid !== undefined && Number.isInteger(editorPid) && editorPid > 0 ? { editorPid } : {}
-    }
-  };
-}
-function runtimesAnnounced(directories = runtimeDirectories()) {
-  const running = new Map;
-  const unspoken = new Map;
-  for (const directory of directories) {
-    for (const found of announcedIn(directory)) {
-      if (found.kind === "runtime" && !running.has(found.endpoint.pid)) {
-        running.set(found.endpoint.pid, found.endpoint);
-      } else if (found.kind === "unspoken" && !unspoken.has(found.unspoken.pid)) {
-        unspoken.set(found.unspoken.pid, found.unspoken);
-      }
-    }
-  }
-  const newest = (a, b) => b.pid - a.pid;
-  return { running: [...running.values()].sort(newest), unspoken: [...unspoken.values()].sort(newest) };
-}
-function discoverRuntimes(directories = runtimeDirectories()) {
-  return runtimesAnnounced(directories).running;
-}
-function wentAway(file, pid) {
-  let project = "";
-  try {
-    const fields = asParams(JSON.parse(readFileSync15(file, "utf8")));
-    project = readString(readParams(fields, "project") ?? {}, "path") ?? "";
-  } catch {
-    return;
-  }
-  if (project === "") {
-    return;
-  }
-  gone.unshift({ pid, project, noticedAt: Date.now() });
-  gone.length = Math.min(gone.length, GONE_KEPT);
-}
-function announcedAndGone(projectPath) {
-  if (projectPath === undefined) {
-    return [];
-  }
-  const since = Date.now() - GONE_WINDOW_MS;
-  const wanted = resolve4(projectPath);
-  return gone.filter((one) => one.noticedAt >= since && resolve4(one.project) === wanted);
-}
-function announcedIn(directory) {
-  if (!existsSync13(directory)) {
-    return [];
-  }
-  const found = [];
-  for (const entry of readdirSync5(directory)) {
-    const report = ERROR_REPORT_PATTERN.exec(entry);
-    if (report) {
-      sweepErrorReport(join17(directory, entry), Number.parseInt(report[1] ?? "", 10));
-      continue;
-    }
-    const match = ANNOUNCEMENT_PATTERN.exec(entry);
-    if (!match) {
-      continue;
-    }
-    const file = join17(directory, entry);
-    const pid = Number.parseInt(match[1] ?? "", 10);
-    const alive = processAlive(pid);
-    const announced = alive ? parseAnnouncement(file, pid) : { kind: "rubbish" };
-    if (announced.kind === "rubbish") {
-      if (!alive) {
-        wentAway(file, pid);
+      const extension = entry.name.includes(".") ? entry.name.split(".").pop()?.toLowerCase() ?? "" : "";
+      if (!entry.isFile() || !extensions.has(extension)) {
+        continue;
+      }
+      result.summary.files_searched += 1;
+      const matches = [];
+      for (const [index, line] of readFileSync15(entryPath, "utf8").split(`
+`).entries()) {
+        if (full()) {
+          break;
+        }
+        const match = regex ? regex.exec(line)?.[0] : (options.caseSensitive ? line : line.toLowerCase()).includes(needle) ? options.query : "";
+        if (match) {
+          matches.push({ line: index + 1, content: line.trim(), match });
+          result.summary.total_matches += 1;
+        }
+      }
+      if (matches.length > 0) {
+        const relativePath = entryPath.slice(projectPath.length + 1).replace(/\\/g, "/");
+        result.results.push({ file: `res://${relativePath}`, matches });
+        result.summary.files_with_matches += 1;
       }
-      try {
-        unlinkSync(file);
-      } catch {}
-      continue;
     }
-    found.push(announced);
-  }
-  return found;
+  };
+  visit(projectPath);
+  return result;
 }
-function sweepErrorReport(path, pid, now = Date.now()) {
-  if (processAlive(pid)) {
-    return;
-  }
+var SKIPPED, ASSET_EXTENSIONS, CARRIES_A_UID;
+var init_project_scan = __esm(() => {
+  SKIPPED = new Set(["node_modules"]);
+  ASSET_EXTENSIONS = new Set(["png", "jpg", "jpeg", "webp", "svg", "ttf", "otf", "wav", "mp3", "ogg"]);
+  CARRIES_A_UID = new Set(["gd", "shader", "gdshader"]);
+});
+
+// src/restart-note.ts
+import { mkdirSync as mkdirSync9, readFileSync as readFileSync16, rmSync as rmSync8, writeFileSync as writeFileSync11 } from "node:fs";
+import { dirname as dirname12, join as join18 } from "node:path";
+function restartNotePath(projectPath) {
+  return join18(projectPath, ".godot", "gdharness-restart.json");
+}
+function noteRestartBegun(note) {
+  const path = restartNotePath(note.projectPath);
   try {
-    if (now - statSync3(path).mtimeMs >= ERROR_REPORT_KEEP_MS) {
-      unlinkSync(path);
-    }
-  } catch {}
+    mkdirSync9(dirname12(path), { recursive: true });
+    writeFileSync11(path, `${JSON.stringify(note, null, 2)}
+`, "utf8");
+  } catch (error) {
+    console.error(`[SERVER] Could not record the restart at ${path}: ${errorMessage(error)}`);
+  }
 }
-async function announcedSince(projectPath, before, waiting = {}) {
-  const wanted = resolve4(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) && resolve4(endpoint.project.path) === wanted && (waiting.accept?.(endpoint) ?? true));
-    if (fresh !== undefined) {
-      return fresh;
+function restartOwed(projectPath) {
+  try {
+    const parsed = JSON.parse(readFileSync16(restartNotePath(projectPath), "utf8"));
+    if (typeof parsed !== "object" || parsed === null) {
+      return null;
     }
-    const left = until - Date.now();
-    if (left <= 0 || waiting.giveUp?.() === true) {
+    const said = parsed;
+    if (typeof said.quitAt !== "string" || typeof said.byPid !== "number" || typeof said.ports !== "object") {
       return null;
     }
-    await delay2(Math.min(LOOK_EVERY_MS, left));
+    return said;
+  } catch {
+    return null;
   }
 }
-function describe2(endpoint) {
-  return `pid ${endpoint.pid} on ${endpoint.address}:${endpoint.port} (${endpoint.project.name || "unnamed"} at ${endpoint.project.path})`;
-}
-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}.`;
-}
-function chooseRuntime(endpoints, projectPath, unspoken = [], pid) {
-  if (pid !== undefined) {
-    const named = endpoints.find((endpoint) => endpoint.pid === pid);
-    if (named !== undefined) {
-      if (projectPath !== undefined && resolve4(named.project.path) !== resolve4(projectPath)) {
-        return {
-          problem: `The game with pid ${pid} is running ${named.project.path}, not ${resolve4(projectPath)}. Running: ${endpoints.map(describe2).join("; ")}.`
-        };
-      }
-      return { endpoint: named };
-    }
-    const tooNewToo = unspoken.find((game) => game.pid === pid);
-    if (tooNewToo !== undefined) {
-      return { problem: tooNew([tooNewToo]) };
-    }
-    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.`
-    };
-  }
-  if (endpoints.length === 0) {
-    if (unspoken.length > 0) {
-      return { problem: tooNew(unspoken) };
-    }
-    const went = announcedAndGone(projectPath);
-    const first = went[0];
-    if (first !== undefined) {
-      const ago = Math.max(1, Math.round((Date.now() - first.noticedAt) / 1000));
-      const others = went.length - 1;
-      const earlier = others === 0 ? "" : ` ${others} earlier ${others === 1 ? "one" : "ones"} went the same way.`;
-      return {
-        problem: `A game with the runtime addon announced itself and its process is gone: pid ${first.pid}` + `${first.project === "" ? "" : ` for ${first.project}`}, noticed ${ago}s ago.${earlier}` + " It quit or was ended rather than never starting, so editor_output has what it printed" + " on the way, including whatever it broke on. Start another with editor_run once you have read it."
-      };
-    }
-    return {
-      problem: "No game with the runtime addon is running. Start one with editor_run, or play the project from the editor with the addon enabled."
-    };
-  }
-  if (projectPath !== undefined) {
-    const wanted = resolve4(projectPath);
-    const matching = endpoints.filter((endpoint) => resolve4(endpoint.project.path) === wanted);
-    if (matching.length === 0) {
-      return {
-        problem: `No running game is from ${wanted}. Running: ${endpoints.map(describe2).join("; ")}.`
-      };
-    }
-    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.`
-    };
-  }
-  if (endpoints.length === 1 && endpoints[0]) {
-    return { endpoint: endpoints[0] };
+function restartSettled(projectPath) {
+  try {
+    rmSync8(restartNotePath(projectPath), { force: true });
+  } catch (error) {
+    console.error(`[SERVER] Could not clear the restart note: ${errorMessage(error)}`);
   }
-  return {
-    problem: `Several games are running: ${endpoints.map(describe2).join("; ")}. Pass projectPath to choose one, or pid when they are from one project.`
-  };
-}
-function runtimeRequest(endpoint, command, params, timeoutMs) {
-  const id = nextRequestId++;
-  return new Promise((settle) => {
-    let done = false;
-    let buffered = "";
-    let welcomed = false;
-    const socket = createConnection3({ port: endpoint.port, host: endpoint.address });
-    const finish = (reply) => {
-      if (done) {
-        return;
-      }
-      done = true;
-      clearTimeout(timer);
-      socket.destroy();
-      settle(reply);
-    };
-    const timer = setTimeout(() => {
-      finish({
-        ok: false,
-        reason: "busy",
-        message: `The game (${describe2(endpoint)}) accepted the connection but did not answer '${command}' within ${timeoutMs}ms. It may be paused at a breakpoint or stuck in a long frame.`
-      });
-    }, timeoutMs);
-    socket.setEncoding("utf8");
-    socket.on("connect", () => {
-      socket.write(`${JSON.stringify({ id, command, params })}
-`);
-    });
-    socket.on("data", (chunk) => {
-      buffered += chunk;
-      let newline = buffered.indexOf(`
-`);
-      while (newline !== -1 && !done) {
-        const line = buffered.slice(0, newline).trim();
-        buffered = buffered.slice(newline + 1);
-        newline = buffered.indexOf(`
-`);
-        if (line === "") {
-          continue;
-        }
-        let message;
-        try {
-          message = asParams(JSON.parse(line));
-        } catch {
-          continue;
-        }
-        if (!welcomed) {
-          welcomed = true;
-          if (readString(message, "type") === "welcome") {
-            const spoken = readNumber(message, "protocol");
-            if (spoken !== RUNTIME_PROTOCOL) {
-              finish({
-                ok: false,
-                reason: "protocol",
-                message: `The game (${describe2(endpoint)}) speaks runtime protocol ${spoken ?? "unknown"} and this server speaks ${RUNTIME_PROTOCOL}. Reinstall the runtime addon into the project.`
-              });
-              return;
-            }
-            continue;
-          }
-        }
-        if (message["id"] !== id) {
-          continue;
-        }
-        if (readString(message, "type") === "error") {
-          finish({ ok: false, reason: "error", message: readString(message, "message") ?? "unknown error" });
-          return;
-        }
-        finish({ ok: true, payload: message, endpoint });
-      }
-    });
-    socket.on("error", (error) => {
-      finish({
-        ok: false,
-        reason: "refused",
-        message: `The game (${describe2(endpoint)}) is running but nothing answered on its port: ${error.code ?? error.message}. It may still be starting, or be shutting down.`
-      });
-    });
-    socket.on("close", () => {
-      finish({
-        ok: false,
-        reason: "refused",
-        message: `The game (${describe2(endpoint)}) closed the connection before answering '${command}'.`
-      });
-    });
-  });
 }
-var RUNTIME_PROTOCOL = 2, ANNOUNCEMENT_PATTERN, ERROR_REPORT_PATTERN, ERROR_REPORT_KEEP_MS, GONE_WINDOW_MS = 120000, GONE_KEPT = 32, gone, LOOK_EVERY_MS = 50, ANNOUNCE_BUDGET_MS = 5000, nextRequestId = 1;
-var init_runtime_client = __esm(() => {
-  ANNOUNCEMENT_PATTERN = /^runtime-(\d+)\.json$/;
-  ERROR_REPORT_PATTERN = /^runtime-(\d+)\.log$/;
-  ERROR_REPORT_KEEP_MS = 60 * 60 * 1000;
-  gone = [];
+var init_restart_note = __esm(() => {
+  init_errors();
 });
 
 // src/run-record.ts
-import { execFileSync } from "node:child_process";
-import { mkdirSync as mkdirSync9, openSync, readdirSync as readdirSync6, readFileSync as readFileSync16, rmSync as rmSync9, statSync as statSync4, writeFileSync as writeFileSync11 } from "node:fs";
-import { basename as basename3, join as join18 } from "node:path";
+import { execFileSync as execFileSync2 } from "node:child_process";
+import { mkdirSync as mkdirSync10, openSync, readdirSync as readdirSync6, readFileSync as readFileSync17, rmSync as rmSync9, statSync as statSync4, writeFileSync as writeFileSync12 } from "node:fs";
+import { basename as basename3, join as join19 } from "node:path";
 function runsDirectory() {
-  return join18(runtimeDirectory(), "runs");
+  return join19(runtimeDirectory(), "runs");
 }
 function recordPath() {
-  return join18(runsDirectory(), "run.json");
+  return join19(runsDirectory(), "run.json");
 }
 function recordPaths() {
-  return runtimeDirectories().map((directory) => join18(directory, "runs", "run.json"));
+  return runtimeDirectories().map((directory) => join19(directory, "runs", "run.json"));
 }
 function openTranscript(startedAt) {
-  mkdirSync9(runsDirectory(), { recursive: true });
-  const path = join18(runsDirectory(), `run-${startedAt}.log`);
+  mkdirSync10(runsDirectory(), { recursive: true });
+  const path = join19(runsDirectory(), `run-${startedAt}.log`);
   return { path, fd: openSync(path, "a") };
 }
 function writeRunRecord(record) {
-  mkdirSync9(runsDirectory(), { recursive: true });
-  writeFileSync11(recordPath(), JSON.stringify(record, null, 2), "utf8");
+  mkdirSync10(runsDirectory(), { recursive: true });
+  writeFileSync12(recordPath(), JSON.stringify(record, null, 2), "utf8");
 }
 function editorNotePath() {
-  return join18(runsDirectory(), "editor-run.json");
+  return join19(runsDirectory(), "editor-run.json");
 }
 function writeEditorRunNote(note) {
-  mkdirSync9(runsDirectory(), { recursive: true });
-  writeFileSync11(editorNotePath(), JSON.stringify(note, null, 2), "utf8");
+  mkdirSync10(runsDirectory(), { recursive: true });
+  writeFileSync12(editorNotePath(), JSON.stringify(note, null, 2), "utf8");
 }
 function readEditorRunNote() {
   for (const directory of runtimeDirectories()) {
-    const note = editorNoteAt(join18(directory, "runs", "editor-run.json"));
+    const note = editorNoteAt(join19(directory, "runs", "editor-run.json"));
     if (note !== null) {
       return note;
     }
@@ -37183,7 +37345,7 @@ function readEditorRunNote() {
 function editorNoteAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync16(path, "utf8"));
+    parsed = JSON.parse(readFileSync17(path, "utf8"));
   } catch {
     return null;
   }
@@ -37206,7 +37368,7 @@ function recordRunEnded(pid, exitCode) {
     return;
   }
   try {
-    writeFileSync11(path, JSON.stringify({ ...record, exitCode }, null, 2), "utf8");
+    writeFileSync12(path, JSON.stringify({ ...record, exitCode }, null, 2), "utf8");
   } catch {}
 }
 function readRunRecord() {
@@ -37221,7 +37383,7 @@ function readRunRecord() {
 function recordAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync16(path, "utf8"));
+    parsed = JSON.parse(readFileSync17(path, "utf8"));
   } catch {
     return null;
   }
@@ -37266,10 +37428,10 @@ function runningAs(pid) {
     const began = startedAt(pid, null);
     const when = began === null ? {} : { startedAt: began };
     if (process.platform === "linux") {
-      const raw = readFileSync16(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
+      const raw = readFileSync17(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
       return raw === "" ? null : { kind: "commandLine", text: raw, ...when };
     }
-    const args = execFileSync("ps", ["-p", String(pid), "-o", "args="], {
+    const args = execFileSync2("ps", ["-p", String(pid), "-o", "args="], {
       encoding: "utf8",
       timeout: 15000
     }).trim();
@@ -37281,20 +37443,14 @@ function runningAs(pid) {
 function listeningPid(port) {
   try {
     if (process.platform === "win32") {
-      const said = execFileSync("powershell", [
-        "-NoProfile",
-        "-NonInteractive",
-        "-Command",
-        `(Get-NetTCPConnection -State Listen -LocalPort ${port} -ErrorAction SilentlyContinue | Select-Object -First 1).OwningProcess`
-      ], { encoding: "utf8", timeout: 15000 }).trim();
-      return /^\d+$/.test(said) ? Number(said) : null;
+      return listeningPidInNetstat(execFileSync2("netstat", ["-ano"], { encoding: "utf8", timeout: 15000 }), port);
     }
     for (const [command, args, pattern] of [
       ["lsof", ["-nP", `-iTCP:${port}`, "-sTCP:LISTEN", "-t"], /^(\d+)/],
       ["ss", ["-ltnpH", `sport = :${port}`], /pid=(\d+)/]
     ]) {
       try {
-        const said = execFileSync(command, [...args], { encoding: "utf8", timeout: 15000 }).trim();
+        const said = execFileSync2(command, [...args], { encoding: "utf8", timeout: 15000 }).trim();
         const found = pattern.exec(said);
         if (found?.[1] !== undefined) {
           return Number(found[1]);
@@ -37306,9 +37462,22 @@ function listeningPid(port) {
     return null;
   }
 }
+function listeningPidInNetstat(printed, port) {
+  for (const line of printed.split(/\r?\n/)) {
+    const fields = /^\s*TCP\s+(\S+)\s+\S+\s+LISTENING\s+(\d+)\s*$/i.exec(line);
+    if (fields === null) {
+      continue;
+    }
+    const local = fields[1] ?? "";
+    if (Number(local.slice(local.lastIndexOf(":") + 1)) === port) {
+      return Number(fields[2]);
+    }
+  }
+  return null;
+}
 function windowsCommandLine(pid) {
   try {
-    const answer = execFileSync("powershell", [
+    const answer = execFileSync2("powershell", [
       "-NoProfile",
       "-NonInteractive",
       "-Command",
@@ -37326,7 +37495,7 @@ function startedAt(pid, windowsAnswer) {
     return Number.isNaN(when) ? null : when;
   }
   try {
-    const said = execFileSync("ps", ["-p", String(pid), "-o", "lstart="], {
+    const said = execFileSync2("ps", ["-p", String(pid), "-o", "lstart="], {
       encoding: "utf8",
       timeout: 15000
     }).trim();
@@ -37338,7 +37507,7 @@ function startedAt(pid, windowsAnswer) {
 }
 function windowsImage(pid) {
   try {
-    const csv = execFileSync("tasklist", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], {
+    const csv = execFileSync2("tasklist", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], {
       encoding: "utf8",
       timeout: 15000,
       windowsHide: true
@@ -37410,7 +37579,7 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
     if (!entry.startsWith("run-") || !entry.endsWith(".log")) {
       continue;
     }
-    const path = join18(directory, entry);
+    const path = join19(directory, entry);
     if (path === keep || ageMs(path, now) < keepMs) {
       continue;
     }
@@ -37433,15 +37602,16 @@ import {
   closeSync,
   existsSync as existsSync14,
   fstatSync,
-  mkdirSync as mkdirSync10,
+  mkdirSync as mkdirSync11,
   mkdtempSync as mkdtempSync3,
   openSync as openSync2,
   readdirSync as readdirSync7,
-  readFileSync as readFileSync17,
-  readSync
+  readFileSync as readFileSync18,
+  readSync,
+  statSync as statSync5
 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
-import { basename as basename4, dirname as dirname11, join as join19, normalize as normalize3, relative as relative3 } from "node:path";
+import { basename as basename4, dirname as dirname13, join as join20, normalize as normalize3, relative as relative3 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 import { promisify as promisify7 } from "node:util";
@@ -37564,10 +37734,11 @@ function runtimeVerdict(endpoint, after) {
     };
   }
   const state = after.playingSeen === false ? "the editor has not yet reported the game as playing, which a restarted editor does not until its scan is over" : "the game is still running";
+  const sized = after.sizedToMs === undefined ? "" : `, half as long again as the ${after.sizedToMs}ms its last game took,`;
   return {
     listening: false,
     mayYetAnnounce: after.running,
-    note: after.running ? `nothing announced itself within ${after.budgetMs}ms and ${state}, so it may announce a moment from now: editor_status says whether it has, and editor_run start takes runtimeWaitMs to wait longer than this${after.withArgs ? ", which a run carrying its own arguments may well need, since whatever they ask the game to do before its first frame is inside this wait" : ""}` : `nothing announced itself within ${after.budgetMs}ms and the game is no longer running, so nothing is going to: editor_output has what it printed on the way down`,
+    note: after.running ? `nothing announced itself within ${after.budgetMs}ms${sized} and ${state}, so it may announce a moment from now: editor_status says whether it has, and editor_run start takes runtimeWaitMs to wait longer than this${after.withArgs ? ", which a run carrying its own arguments may well need, since whatever they ask the game to do before its first frame is inside this wait" : ""}` : `nothing announced itself within ${after.budgetMs}ms${sized} and the game is no longer running, so nothing is going to: editor_output has what it printed on the way down`,
     heldAt: null
   };
 }
@@ -37672,7 +37843,7 @@ function aboveTheRunner(entry) {
 }
 function elsewhereIn(projectPath, asked) {
   const wanted = asked.replace(/^res:\/\//, "").replace(/\/+$/, "");
-  if (wanted === "" || existsSync14(join19(projectPath, wanted))) {
+  if (wanted === "" || existsSync14(join20(projectPath, wanted))) {
     return "";
   }
   const root = (wanted.split("/")[0] ?? "").toLowerCase();
@@ -37686,7 +37857,7 @@ function elsewhereIn(projectPath, asked) {
   return near.length === 0 ? "" : ` The project does have ${there}.`;
 }
 function hasMainScene(projectFile) {
-  const scene = parseProjectGodot(readFileSync17(projectFile, "utf8"))["application"]?.["run/main_scene"];
+  const scene = parseProjectGodot(readFileSync18(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "";
 }
 function runtimeAddonAnnouncesEditors(projectPath) {
@@ -37694,13 +37865,13 @@ function runtimeAddonAnnouncesEditors(projectPath) {
     return false;
   }
   try {
-    return readFileSync17(join19(projectPath, RUNTIME_AUTOLOAD2.path), "utf8").includes('"editor_pid"');
+    return readFileSync18(join20(projectPath, RUNTIME_AUTOLOAD2.path), "utf8").includes('"editor_pid"');
   } catch {
     return false;
   }
 }
 function editorPlaysHeadless(projectFile) {
-  const runArgs = parseProjectGodot(readFileSync17(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
+  const runArgs = parseProjectGodot(readFileSync18(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
   return typeof runArgs === "string" && /(?:^|\s)--headless(?:\s|$)/.test(runArgs);
 }
 function camelCased(params) {
@@ -37716,7 +37887,7 @@ function camelCased(params) {
 class GodotServer {
   mcp;
   locator = new GodotLocator2;
-  operationsScript = join19(__dirname2, "godot", "operations", "godot_operations.gd");
+  operationsScript = join20(__dirname2, "godot", "operations", "godot_operations.gd");
   godotBridge;
   tools = buildToolDefinitions();
   activeProcess = null;
@@ -38374,7 +38545,7 @@ class GodotServer {
     if (path === undefined) {
       return { ok: false, response: this.createErrorResponse("projectPath is required.") };
     }
-    const file = join19(path, "project.godot");
+    const file = join20(path, "project.godot");
     if (!existsSync14(file)) {
       return {
         ok: false,
@@ -38598,7 +38769,7 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const application = parseProjectGodot(readFileSync17(project.value.file, "utf8"))["application"] ?? {};
+    const application = parseProjectGodot(readFileSync18(project.value.file, "utf8"))["application"] ?? {};
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
@@ -38659,18 +38830,18 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const folder = dirname11(output.absolutePath);
+    const folder = dirname13(output.absolutePath);
     try {
-      mkdirSync10(folder, { recursive: true });
+      mkdirSync11(folder, { recursive: true });
     } catch (error) {
-      return this.createErrorResponse(`Cannot create ${dirname11(output.relativePath)} to export into: ${errorMessage(error)}`);
+      return this.createErrorResponse(`Cannot create ${dirname13(output.relativePath)} to export into: ${errorMessage(error)}`);
     }
     const debug = readBoolean(args, "debug") ?? false;
-    const exportLogs = mkdtempSync3(join19(tmpdir5(), "gdharness-export-"));
+    const exportLogs = mkdtempSync3(join20(tmpdir5(), "gdharness-export-"));
     const exportArgs = [
       "--headless",
       "--log-file",
-      join19(exportLogs, "engine.log"),
+      join20(exportLogs, "engine.log"),
       "--path",
       project.value.path,
       debug ? "--export-debug" : "--export-release",
@@ -38728,7 +38899,7 @@ class GodotServer {
       return contained.response;
     }
     const runner = "addons/gdUnit4/bin/GdUnitCmdTool.gd";
-    if (!existsSync14(join19(project.value.path, runner))) {
+    if (!existsSync14(join20(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"
       ]);
@@ -38763,7 +38934,7 @@ class GodotServer {
     ];
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 600000;
     this.logDebug(`Running tests: ${engine.value} ${cmdArgs.join(" ")}`);
-    const userData = mkdtempSync3(join19(tmpdir5(), "gdharness-tests-"));
+    const userData = mkdtempSync3(join20(tmpdir5(), "gdharness-tests-"));
     const run = this.spawnGame(engine.value, cmdArgs, userDataIn(userData));
     const hung = await new Promise((resolve) => {
       const timer = setTimeout(() => {
@@ -38779,14 +38950,14 @@ class GodotServer {
         resolve(false);
       });
     });
-    const reportsDir = join19(project.value.path, ".godot", ...ours.split("/"));
+    const reportsDir = join20(project.value.path, ".godot", ...ours.split("/"));
     let report = null;
     let reportProblem = null;
     try {
       const written = existsSync14(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(readFileSync17(join19(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync18(join20(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
@@ -38926,7 +39097,7 @@ class GodotServer {
         return null;
       }
       try {
-        return readFileSync17(contained.absolutePath, "utf8");
+        return readFileSync18(contained.absolutePath, "utf8");
       } catch {
         return null;
       }
@@ -38968,7 +39139,7 @@ class GodotServer {
       return null;
     }
     try {
-      return readFileSync17(contained.absolutePath, "utf8");
+      return readFileSync18(contained.absolutePath, "utf8");
     } catch {
       return null;
     }
@@ -39117,11 +39288,14 @@ class GodotServer {
       return null;
     }
     try {
-      const answer = await Promise.race([
-        this.godotBridge.invokeTool("playing_status", {}),
-        delay3(PLAYING_STATUS_MS).then(() => null)
-      ]);
+      const askedAt = Date.now();
+      const asked = this.godotBridge.invokeTool("playing_status", {});
+      const answer = await Promise.race([asked, delay3(PLAYING_STATUS_MS).then(() => null)]);
       if (answer === null) {
+        this.logDebug(`playing_status did not answer within ${PLAYING_STATUS_MS}ms`);
+        asked.then(() => {
+          this.logDebug(`playing_status answered after ${Date.now() - askedAt}ms`);
+        }).catch(() => {});
         return null;
       }
       return {
@@ -39194,7 +39368,7 @@ class GodotServer {
       return null;
     }
     try {
-      return settingKeys(readFileSync17(join19(projectPath, "project.godot"), "utf8"));
+      return settingKeys(readFileSync18(join20(projectPath, "project.godot"), "utf8"));
     } catch {
       return null;
     }
@@ -39401,7 +39575,7 @@ class GodotServer {
       platform: process.platform,
       variables: process.env
     });
-    const runtimeWaitMs = readNonNegativeNumber(args, "runtimeWaitMs") ?? ANNOUNCE_BUDGET_MS;
+    const runtimeWaitMs = this.announceBudget(args, project.value.path);
     const editorWouldPlay = !headless || editorPlaysHeadless(project.value.file);
     if (this.godotBridge.isConnected() && editorWouldPlay && given.value.length === 0) {
       return await this.playThroughEditor(sceneArgument, refreshed.value, project.value.path, alreadyPlaying, runtimeWaitMs, ended);
@@ -39434,13 +39608,17 @@ class GodotServer {
       message: `Use editor_output for what it prints and editor_run stop to end it.${spawnedInstead}${endedForThis}${alsoRunning}`
     });
   }
-  async runtimeUp(projectPath, before, budgetMs, withArgs) {
-    if (!existsSync14(join19(projectPath, RUNTIME_AUTOLOAD2.path))) {
+  async runtimeUp(projectPath, before, budget, withArgs) {
+    const budgetMs = budget.ms;
+    if (!existsSync14(join20(projectPath, RUNTIME_AUTOLOAD2.path))) {
       return runtimeVerdict(null, { addon: false, budgetMs, heldAt: null, running: false, withArgs });
     }
     let asking = null;
     let editorAskedAt = 0;
     let editorSaysGoing = true;
+    let editorAsks = 0;
+    const waitBegan = Date.now();
+    const lastSaid = () => editorSaysGoing ? "playing" : "not playing";
     const endpoint = await announcedSince(projectPath, before, {
       budgetMs,
       accept: (one) => this.isTheGameOf(this.currentRun(), one, projectPath),
@@ -39454,6 +39632,7 @@ class GodotServer {
         }
         if (asking === null && Date.now() - editorAskedAt >= RUN_POLL_MS) {
           editorAskedAt = Date.now();
+          editorAsks += 1;
           asking = this.runStillGoing(run).then((going) => {
             editorSaysGoing = going;
           }).finally(() => {
@@ -39463,19 +39642,46 @@ class GodotServer {
         return !editorSaysGoing;
       }
     });
+    this.logDebug(`announce wait ended after ${Date.now() - waitBegan}ms: ${endpoint === null ? "nothing announced" : `pid ${endpoint.pid} announced`}, editor asked ${editorAsks} times, last said ${lastSaid()}`);
     const going = this.currentRun();
     if (endpoint !== null && going !== null && going.announcedPid === undefined) {
       going.announcedPid = endpoint.pid;
+      this.noteBootOf(going, endpoint);
     }
     return runtimeVerdict(endpoint, {
       addon: true,
       budgetMs,
+      ...budget.sizedToMs === undefined ? {} : { sizedToMs: budget.sizedToMs },
       heldAt: this.dapClient?.whereItStopped() ?? null,
       running: endpoint !== null || going !== null && await this.runStillGoing(going),
       withArgs,
       ...going?.throughEditor === true ? { playingSeen: going.seenPlaying === true } : {}
     });
   }
+  announceBudget(args, projectPath) {
+    const asked = readNonNegativeNumber(args, "runtimeWaitMs");
+    if (asked !== undefined) {
+      return { ms: asked };
+    }
+    const lastBoot = readBootNote(projectPath);
+    const ms = waitSizedTo(lastBoot);
+    return lastBoot !== null && ms > ANNOUNCE_BUDGET_MS ? { ms, sizedToMs: lastBoot } : { ms };
+  }
+  noteBootOf(run, endpoint) {
+    if (run.projectPath === null) {
+      return;
+    }
+    let announcedAt;
+    try {
+      announcedAt = statSync5(endpoint.file).mtimeMs;
+    } catch {
+      return;
+    }
+    const took = announcedAt - run.startedAt;
+    if (took > 0 && took <= LONGEST_BOOT_NOTED_MS) {
+      writeBootNote(run.projectPath, took);
+    }
+  }
   async playThroughEditor(scene, refreshedClasses, projectPath, alreadyPlaying, runtimeWaitMs, ended) {
     const log = new GameLog;
     try {
@@ -39805,6 +40011,7 @@ class GodotServer {
     const theOne = candidates.length === 1 ? candidates[0] : undefined;
     if (theOne !== undefined) {
       run.announcedPid = theOne.pid;
+      this.noteBootOf(run, theOne);
     }
     return run.announcedPid;
   }
@@ -40139,11 +40346,19 @@ class GodotServer {
     this.drainEditorOutput(stopped);
     this.drainTranscript(stopped);
     const wasRunning = await this.runStillGoing(stopped);
-    const endedPid = stopped.pid ?? this.announcedPidOf(stopped) ?? null;
+    const announcedPid = this.announcedPidOf(stopped) ?? null;
+    const endedPid = stopped.pid ?? announcedPid;
     const children = readBoolean(args, "andChildren") === true && wasRunning ? await this.whatTheRunStarted(stopped) : null;
     this.logDebug("Stopping the running game");
     await this.endActiveGame("editor_run stop");
     const ended = children === null ? null : endChildrenAmong(children);
+    if (wasRunning) {
+      for (const pid of new Set([endedPid, announcedPid])) {
+        if (pid !== null) {
+          await announcementEnded(pid);
+        }
+      }
+    }
     return this.jsonTextResponse({
       stopped: true,
       through: stopped.throughEditor ? "editor" : "gdharness",
@@ -40465,8 +40680,8 @@ class GodotServer {
       ]);
     }
     const expectsScreenshot = command === "capture_screenshot" || command === "capture_viewport";
-    const screenshotDir = expectsScreenshot ? mkdtempSync3(join19(tmpdir5(), "gdharness-runtime-screenshot-")) : null;
-    const screenshotPath = screenshotDir ? join19(screenshotDir, "capture.png") : null;
+    const screenshotDir = expectsScreenshot ? mkdtempSync3(join20(tmpdir5(), "gdharness-runtime-screenshot-")) : null;
+    const screenshotPath = screenshotDir ? join20(screenshotDir, "capture.png") : null;
     try {
       const reply = await runtimeRequest(choice.endpoint, command, screenshotPath ? { ...params, output_path: screenshotPath } : params, timeoutMs);
       if (!reply.ok) {
@@ -40490,7 +40705,7 @@ class GodotServer {
             type: "text",
             text: `Screenshot captured: ${dimensions}${chosenAmongSeveral ? ` from pid ${own}, the game this server holds` : ""}`
           },
-          { type: "image", data: readFileSync17(screenshotPath).toString("base64"), mimeType: "image/png" }
+          { type: "image", data: readFileSync18(screenshotPath).toString("base64"), mimeType: "image/png" }
         ]
       };
     } finally {
@@ -40557,11 +40772,12 @@ async function runGodotServer() {
   const server = new GodotServer;
   await server.run();
 }
-var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run7, __dirname2, EDITOR_RESTART_TIMEOUT_MS = 90000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, PLAY_STARTS_WITHIN_MS = 30000, CONSOLE_WRAPPER, VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, CACHE_WRITE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/";
+var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run7, __dirname2, EDITOR_RESTART_TIMEOUT_MS = 90000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, PLAY_STARTS_WITHIN_MS = 30000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, CACHE_WRITE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/";
 var init_server3 = __esm(() => {
   init_mcp();
   init_stdio2();
   init_types();
+  init_boot_note();
   init_breakpoint_note();
   init_bridge_announce();
   init_class_cache();
@@ -40591,8 +40807,9 @@ var init_server3 = __esm(() => {
   init_tool_definitions();
   init_update_check();
   run7 = promisify7(execFile7);
-  __dirname2 = dirname11(fileURLToPath4(import.meta.url));
+  __dirname2 = dirname13(fileURLToPath4(import.meta.url));
   CONSOLE_WRAPPER = /_console(\.exe)?$/i;
+  LONGEST_BOOT_NOTED_MS = 5 * 60000;
   VALUE_NAMES = {
     string: "a string",
     number: "a number",
@@ -40631,7 +40848,7 @@ var init_server3 = __esm(() => {
 
 // src/cli.ts
 import { existsSync as existsSync15 } from "fs";
-import { join as join20, resolve as resolve5 } from "path";
+import { join as join21, resolve as resolve5 } from "path";
 
 // src/errors.ts
 class Refusal extends Error {
@@ -42142,6 +42359,7 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
 | Where a control is, and whether it is visible | \`runtime_inspect\` \`find\`, \`rect\` |
 | What a property reads right now, on a node whose path you already hold | \`runtime_inspect\` \`property\`, \`runtime_invoke\` |
 | What a property on an object a node holds reads | the same two, with colons: \`_game:clock:speed\` |
+| Which control holds the focus, or anything only a method answers | the same path with a step written as a call, \`get_viewport():gui_get_focus_owner\`, which calls a method taking no arguments and walks into what it returned |
 | Press a button | \`runtime_input click\`, which says what was under the pointer |
 | Press the next thing after a click that changed screen | \`runtime_wait until\` with \`says\` and a word the new screen shows, then the click. A click sent straight after a screen change lands on a control the new screen is about to free, answers \`landed: true\`, and does nothing; a frame count is a number nobody can pick correctly across a cold start and a warm one, and waiting for the words answered in about 130ms where twenty frames had not been enough |
 | Fill in a field | \`runtime_input click\` on it, then \`runtime_input text\` with \`replace\`; a submitted field has to be clicked again |
@@ -42335,7 +42553,7 @@ class UsageError extends Refusal {
 function projectArgument(at) {
   const named = args.slice(at).find((value) => !value.startsWith("--"));
   const projectPath = resolve5(named ?? ".");
-  if (!existsSync15(join20(projectPath, "project.godot"))) {
+  if (!existsSync15(join21(projectPath, "project.godot"))) {
     throw new UsageError(`Not a Godot project: ${projectPath} holds no project.godot.`);
   }
   return projectPath;
@@ -42374,7 +42592,7 @@ async function registerRuntime(godot, projectPath) {
     return;
   }
   console.log(`${RUNTIME_AUTOLOAD.name} autoload left at ${named}, which this project registers itself`);
-  if (!existsSync15(join20(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
+  if (!existsSync15(join21(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
     console.log(`  that file is not in this project, so it boots with a missing script: restore it, or point the entry at res://${RUNTIME_AUTOLOAD.path}`);
   }
 }