gdharness 0.13.38 → 0.13.39

package/build/index.js

@@ -10175,15 +10175,15 @@ import {
   closeSync,
   existsSync as existsSync9,
   fstatSync,
-  mkdirSync as mkdirSync6,
+  mkdirSync as mkdirSync7,
   mkdtempSync as mkdtempSync2,
   openSync as openSync2,
   readdirSync as readdirSync6,
-  readFileSync as readFileSync12,
+  readFileSync as readFileSync13,
   readSync
 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
-import { basename as basename2, dirname as dirname5, join as join12, normalize as normalize2 } from "node:path";
+import { basename as basename2, dirname as dirname6, join as join13, normalize as normalize2, relative as relative3 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { promisify as promisify4 } from "node:util";
@@ -24751,16 +24751,135 @@ class StdioServerTransport {
   }
 }
 
-// src/bridge-announce.ts
+// src/breakpoint-note.ts
 import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname, join as join2 } from "node:path";
+import { dirname, isAbsolute as isAbsolute2, join as join2, relative as relative2 } from "node:path";
+
+// src/paths.ts
+import { realpathSync } from "node:fs";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+var RESOURCE_SCHEME = "res://";
+var OTHER_SCHEME = /^[a-zA-Z][a-zA-Z\d+.-]+:\/\//;
+function realPathOr(path) {
+  try {
+    return realpathSync.native(path);
+  } catch {
+    return path;
+  }
+}
+function isSameDirectory(onePath, otherPath) {
+  return relative(realPathOr(resolve(onePath)), realPathOr(resolve(otherPath))) === "";
+}
+function isWithinRoot(rootPath, candidatePath) {
+  const step = relative(resolve(rootPath), resolve(candidatePath));
+  return step !== ".." && !step.startsWith(`..${sep}`) && !isAbsolute(step);
+}
+function resolveWithinProject(projectPath, candidatePath) {
+  const trimmed = candidatePath.trim();
+  if (trimmed === "") {
+    return { ok: false, reason: "Path is empty." };
+  }
+  if (trimmed.includes("\x00")) {
+    return { ok: false, reason: "Path contains a null byte." };
+  }
+  const withoutScheme = trimmed.startsWith(RESOURCE_SCHEME) ? trimmed.slice(RESOURCE_SCHEME.length) : trimmed;
+  const scheme = OTHER_SCHEME.exec(withoutScheme);
+  if (scheme) {
+    return {
+      ok: false,
+      reason: `Path '${trimmed}' uses the '${scheme[0]}' scheme, which names somewhere other than this project.`
+    };
+  }
+  if (withoutScheme.startsWith("/") || withoutScheme.startsWith("\\") || isAbsolute(withoutScheme)) {
+    return {
+      ok: false,
+      reason: `Path '${trimmed}' is absolute; give a path inside the project, such as 'scenes/main.tscn'.`
+    };
+  }
+  if (withoutScheme.includes(":")) {
+    return {
+      ok: false,
+      reason: `Path '${trimmed}' contains ':', which no file inside a project is named with.`
+    };
+  }
+  const root = resolve(projectPath);
+  const absolutePath = resolve(root, withoutScheme);
+  if (!isWithinRoot(root, absolutePath)) {
+    return { ok: false, reason: `Path '${trimmed}' resolves outside the project directory.` };
+  }
+  const relativePath = relative(root, absolutePath).split(sep).join("/");
+  if (relativePath === "") {
+    return { ok: false, reason: `Path '${trimmed}' is the project directory itself, not a file in it.` };
+  }
+  return { ok: true, absolutePath, relativePath };
+}
+
+// src/breakpoint-note.ts
+function breakpointNotePath(projectPath) {
+  return join2(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) {
+      rmSync(path, { force: true });
+      return;
+    }
+    const note = {
+      breakpoints: inside.map((one) => ({
+        script: relative2(root, one.scriptPath).replaceAll("\\", "/"),
+        lines: [...one.lines]
+      }))
+    };
+    mkdirSync2(dirname(path), { recursive: true });
+    writeFileSync2(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(readFileSync3(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(join2(projectPath, script)), lines });
+      }
+    }
+    return held;
+  } catch {
+    return [];
+  }
+}
+function withinProject(projectPath, scriptPath) {
+  const rel = relative2(projectPath, scriptPath);
+  return rel !== "" && !rel.startsWith("..") && !isAbsolute2(rel);
+}
+
+// src/bridge-announce.ts
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync4, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname2, join as join3 } from "node:path";
 function announcementPath(projectPath) {
-  return join2(projectPath, ".godot", "gdharness-bridge.json");
+  return join3(projectPath, ".godot", "gdharness-bridge.json");
 }
 var BRIDGE_ANNOUNCE_PROTOCOL = 1;
 function readAnnouncement(path) {
   try {
-    const parsed = JSON.parse(readFileSync3(path, "utf8"));
+    const parsed = JSON.parse(readFileSync4(path, "utf8"));
     if (typeof parsed !== "object" || parsed === null) {
       return null;
     }
@@ -24779,7 +24898,7 @@ function announcementIsOurs(path) {
 function announceBridge(projectPath, bridge) {
   const path = announcementPath(projectPath);
   try {
-    mkdirSync2(dirname(path), { recursive: true });
+    mkdirSync3(dirname2(path), { recursive: true });
     const announcement = {
       protocol: BRIDGE_ANNOUNCE_PROTOCOL,
       host: bridge.host,
@@ -24788,7 +24907,7 @@ function announceBridge(projectPath, bridge) {
       version: bridge.version,
       startedAt: new Date().toISOString()
     };
-    writeFileSync2(path, `${JSON.stringify(announcement, null, 2)}
+    writeFileSync3(path, `${JSON.stringify(announcement, null, 2)}
 `, "utf8");
     return path;
   } catch (error) {
@@ -24801,31 +24920,31 @@ function withdrawBridge(path) {
     return;
   }
   try {
-    rmSync(path, { force: true });
+    rmSync2(path, { force: true });
   } catch (error) {
     console.error(`[SERVER] Could not withdraw the editor bridge announcement: ${errorMessage(error)}`);
   }
 }
 
 // src/class-cache.ts
-import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync4, statSync } from "node:fs";
-import { join as join3 } from "node:path";
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync5, statSync } from "node:fs";
+import { join as join4 } from "node:path";
 var DECLARATION = /^(?:@[a-z_]+(?:\([^)\n]*\))?\s+)*class_name\s+([A-Za-z_][A-Za-z0-9_]*)/m;
 function declaredClasses(projectPath) {
   const declared = new Map;
   const visit = (directory, prefix) => {
-    if (existsSync2(join3(directory, ".gdignore"))) {
+    if (existsSync2(join4(directory, ".gdignore"))) {
       return;
     }
     for (const entry of readdirSync(directory, { withFileTypes: true })) {
       if (entry.name.startsWith(".")) {
         continue;
       }
-      const path = join3(directory, entry.name);
+      const path = join4(directory, entry.name);
       if (entry.isDirectory()) {
         visit(path, `${prefix}${entry.name}/`);
       } else if (entry.isFile() && entry.name.endsWith(".gd")) {
-        const found = DECLARATION.exec(readFileSync4(path, "utf8"));
+        const found = DECLARATION.exec(readFileSync5(path, "utf8"));
         if (found?.[1]) {
           declared.set(found[1], `res://${prefix}${entry.name}`);
         }
@@ -24836,12 +24955,12 @@ function declaredClasses(projectPath) {
   return declared;
 }
 function cachedClasses(projectPath) {
-  const cache = join3(projectPath, ".godot", "global_script_class_cache.cfg");
+  const cache = join4(projectPath, ".godot", "global_script_class_cache.cfg");
   if (!existsSync2(cache)) {
     return null;
   }
   const listed = new Map;
-  const text = readFileSync4(cache, "utf8");
+  const text = readFileSync5(cache, "utf8");
   for (const entry of text.matchAll(/"class":\s*&"([^"]+)"[\s\S]*?"path":\s*"([^"]+)"/g)) {
     listed.set(entry[1] ?? "", entry[2] ?? "");
   }
@@ -24926,7 +25045,7 @@ function uncachedClassNote(types) {
   return `${types.join(", ")} ${one ? "is declared" : "are declared"} in this project and missing from ` + `.godot/global_script_class_cache.cfg, so a game launched now would not resolve ${one ? "it" : "them"} ` + "either. Try editor_rescan first: it asks the editor already running and starts nothing, and it " + "cleared this in 314ms in a second project with a 31-worker fan-out still importing. It is not " + "always enough, because a file another engine has already imported reads as settled and the " + "walk does not look inside it. project_import refresh_classes rewrites the cache from the " + "declarations on disk and does reach that case, at the cost of a short headless engine, which " + "is worth knowing when something else is already running against this project.";
 }
 function cacheWrittenAt(projectPath) {
-  const cache = join3(projectPath, ".godot", "global_script_class_cache.cfg");
+  const cache = join4(projectPath, ".godot", "global_script_class_cache.cfg");
   try {
     return statSync(cache).mtimeMs;
   } catch {
@@ -24950,17 +25069,17 @@ function unseenByEditor(projectPath, editorHolds) {
 }
 
 // src/config-pin.ts
-import { existsSync as existsSync3, readFileSync as readFileSync5 } from "node:fs";
-import { join as join4 } from "node:path";
+import { existsSync as existsSync3, readFileSync as readFileSync6 } from "node:fs";
+import { join as join5 } from "node:path";
 var PINNED = /\bgdharness@(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)\b/g;
 function versionsNamedInConfig(projectPath) {
-  const config = join4(projectPath, ".mcp.json");
+  const config = join5(projectPath, ".mcp.json");
   if (!existsSync3(config)) {
     return [];
   }
   let text;
   try {
-    text = readFileSync5(config, "utf8");
+    text = readFileSync6(config, "utf8");
     JSON.parse(text);
   } catch {
     return [];
@@ -25127,6 +25246,7 @@ class GodotDAPClient {
   attached = false;
   lastThreadId = 1;
   halt = null;
+  holdKnown = false;
   breakpoints = new Map;
   constructor(port = portFromEnv("GDHARNESS_DAP_PORT", DEFAULT_DAP_PORT), host = "127.0.0.1") {
     this.port = port;
@@ -25172,11 +25292,7 @@ class GodotDAPClient {
           this.failPendingRequests(error);
         });
         socket.on("close", () => {
-          this.connected = false;
-          this.initialized = false;
-          this.attached = false;
-          this.halt = null;
-          this.socket = null;
+          this.forgetConnection();
           this.failPendingRequests(new Error("DAP connection closed"));
         });
         resolve();
@@ -25192,10 +25308,7 @@ class GodotDAPClient {
   }
   async abandon() {
     if (!this.socket) {
-      this.connected = false;
-      this.initialized = false;
-      this.attached = false;
-      this.halt = null;
+      this.forgetConnection();
       return;
     }
     await new Promise((resolve) => {
@@ -25215,11 +25328,15 @@ class GodotDAPClient {
         resolve();
       }, 500);
     });
+    this.forgetConnection();
+  }
+  forgetConnection() {
     this.socket = null;
     this.connected = false;
     this.initialized = false;
     this.attached = false;
     this.halt = null;
+    this.holdKnown = false;
   }
   async ensureConnected() {
     if (!this.connected) {
@@ -25308,6 +25425,12 @@ class GodotDAPClient {
         description: said(body, "description"),
         text: said(body, "text")
       };
+      this.holdKnown = true;
+      return;
+    }
+    if (eventName === "continued") {
+      this.halt = null;
+      this.holdKnown = true;
       return;
     }
     if (eventName === "terminated" || eventName === "exited") {
@@ -25346,6 +25469,43 @@ class GodotDAPClient {
     await this.sendRequest("attach", {});
     await this.sendRequest("configurationDone", {});
     this.attached = true;
+    if (!this.holdKnown) {
+      await this.learnWhetherHeld();
+    }
+  }
+  async learnWhetherHeld() {
+    try {
+      const threads = await this.sendRequest("threads");
+      const listed = threads["threads"];
+      const first = Array.isArray(listed) ? listed[0]?.["id"] : undefined;
+      if (typeof first !== "number") {
+        return;
+      }
+      this.lastThreadId = first;
+      const response = await this.sendRequest("stackTrace", { threadId: first, startFrame: 0, levels: 1 });
+      if (this.holdKnown) {
+        return;
+      }
+      const frames = response["stackFrames"];
+      if (Array.isArray(frames) && frames.length > 0) {
+        this.halt = {
+          reason: "attached",
+          description: "held when this session attached; the stop that held it was reported to an earlier one",
+          text: ""
+        };
+        this.holdKnown = true;
+      }
+    } catch {}
+  }
+  holdIsKnown() {
+    return this.holdKnown;
+  }
+  learnedRunning() {
+    if (this.holdKnown) {
+      return;
+    }
+    this.halt = null;
+    this.holdKnown = true;
   }
   setOutputSink(sink) {
     this.onOutput = sink;
@@ -25358,38 +25518,70 @@ class GodotDAPClient {
     return lines;
   }
   async setBreakpoint(filePath, line) {
-    await this.ensureConnected();
-    await this.initialize();
-    const fileBreakpoints = this.breakpoints.get(filePath) ?? new Set;
-    fileBreakpoints.add(line);
-    this.breakpoints.set(filePath, fileBreakpoints);
-    const lines = Array.from(fileBreakpoints).sort((a, b) => a - b);
-    return await this.sendRequest("setBreakpoints", {
-      source: { path: filePath },
-      breakpoints: lines.map((breakpointLine) => ({ line: breakpointLine }))
-    });
+    const wanted = new Set(this.breakpoints.get(filePath) ?? []);
+    wanted.add(line);
+    return await this.sendBreakpoints(filePath, wanted);
   }
   async removeBreakpoint(filePath, line) {
+    const wanted = new Set(this.breakpoints.get(filePath) ?? []);
+    wanted.delete(line);
+    return await this.sendBreakpoints(filePath, wanted);
+  }
+  async sendBreakpoints(filePath, lines) {
     await this.ensureConnected();
     await this.initialize();
-    const fileBreakpoints = this.breakpoints.get(filePath) ?? new Set;
-    fileBreakpoints.delete(line);
-    if (fileBreakpoints.size === 0) {
+    const sorted = Array.from(lines).sort((a, b) => a - b);
+    const answer = await this.sendRequest("setBreakpoints", {
+      source: { path: filePath },
+      breakpoints: sorted.map((breakpointLine) => ({ line: breakpointLine }))
+    });
+    if (lines.size === 0) {
       this.breakpoints.delete(filePath);
     } else {
-      this.breakpoints.set(filePath, fileBreakpoints);
+      this.breakpoints.set(filePath, new Set(lines));
+    }
+    return answer;
+  }
+  async reapplyBreakpoints() {
+    const applied = [];
+    const refused = [];
+    for (const [filePath, lines] of Array.from(this.breakpoints)) {
+      try {
+        await this.sendBreakpoints(filePath, lines);
+        applied.push({ scriptPath: filePath, lines: Array.from(lines).sort((a, b) => a - b) });
+      } catch (error) {
+        this.breakpoints.delete(filePath);
+        refused.push({
+          scriptPath: filePath,
+          reason: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    return { applied, refused };
+  }
+  breakpointsHeld() {
+    return Array.from(this.breakpoints, ([scriptPath, lines]) => ({
+      scriptPath,
+      lines: Array.from(lines).sort((a, b) => a - b)
+    }));
+  }
+  holdBreakpoints(held) {
+    for (const { scriptPath, lines } of held) {
+      const fileBreakpoints = this.breakpoints.get(scriptPath) ?? new Set;
+      for (const line of lines) {
+        fileBreakpoints.add(line);
+      }
+      if (fileBreakpoints.size > 0) {
+        this.breakpoints.set(scriptPath, fileBreakpoints);
+      }
     }
-    const remaining = Array.from(fileBreakpoints).sort((a, b) => a - b);
-    return await this.sendRequest("setBreakpoints", {
-      source: { path: filePath },
-      breakpoints: remaining.map((breakpointLine) => ({ line: breakpointLine }))
-    });
   }
   async continue(threadId) {
     await this.attach();
     const resolvedThreadId = await this.resolveThreadId(threadId);
     await this.sendRequest("continue", { threadId: resolvedThreadId });
     this.halt = null;
+    this.holdKnown = true;
   }
   async stepOver(threadId) {
     await this.attach();
@@ -25488,11 +25680,7 @@ class GodotDAPClient {
   }
   failOversizedStream(detail) {
     const socket = this.socket;
-    this.socket = null;
-    this.connected = false;
-    this.initialized = false;
-    this.attached = false;
-    this.halt = null;
+    this.forgetConnection();
     this.reader = new FrameReader;
     socket?.destroy();
     this.failPendingRequests(new Error(`Godot DAP ${detail}. The connection was dropped.`));
@@ -25715,65 +25903,6 @@ var import_subprotocol = __toESM(require_subprotocol(), 1);
 var import_websocket = __toESM(require_websocket(), 1);
 var import_websocket_server = __toESM(require_websocket_server(), 1);
 
-// src/paths.ts
-import { realpathSync } from "node:fs";
-import { isAbsolute, relative, resolve, sep } from "node:path";
-var RESOURCE_SCHEME = "res://";
-var OTHER_SCHEME = /^[a-zA-Z][a-zA-Z\d+.-]+:\/\//;
-function realPathOr(path) {
-  try {
-    return realpathSync.native(path);
-  } catch {
-    return path;
-  }
-}
-function isSameDirectory(onePath, otherPath) {
-  return relative(realPathOr(resolve(onePath)), realPathOr(resolve(otherPath))) === "";
-}
-function isWithinRoot(rootPath, candidatePath) {
-  const step = relative(resolve(rootPath), resolve(candidatePath));
-  return step !== ".." && !step.startsWith(`..${sep}`) && !isAbsolute(step);
-}
-function resolveWithinProject(projectPath, candidatePath) {
-  const trimmed = candidatePath.trim();
-  if (trimmed === "") {
-    return { ok: false, reason: "Path is empty." };
-  }
-  if (trimmed.includes("\x00")) {
-    return { ok: false, reason: "Path contains a null byte." };
-  }
-  const withoutScheme = trimmed.startsWith(RESOURCE_SCHEME) ? trimmed.slice(RESOURCE_SCHEME.length) : trimmed;
-  const scheme = OTHER_SCHEME.exec(withoutScheme);
-  if (scheme) {
-    return {
-      ok: false,
-      reason: `Path '${trimmed}' uses the '${scheme[0]}' scheme, which names somewhere other than this project.`
-    };
-  }
-  if (withoutScheme.startsWith("/") || withoutScheme.startsWith("\\") || isAbsolute(withoutScheme)) {
-    return {
-      ok: false,
-      reason: `Path '${trimmed}' is absolute; give a path inside the project, such as 'scenes/main.tscn'.`
-    };
-  }
-  if (withoutScheme.includes(":")) {
-    return {
-      ok: false,
-      reason: `Path '${trimmed}' contains ':', which no file inside a project is named with.`
-    };
-  }
-  const root = resolve(projectPath);
-  const absolutePath = resolve(root, withoutScheme);
-  if (!isWithinRoot(root, absolutePath)) {
-    return { ok: false, reason: `Path '${trimmed}' resolves outside the project directory.` };
-  }
-  const relativePath = relative(root, absolutePath).split(sep).join("/");
-  if (relativePath === "") {
-    return { ok: false, reason: `Path '${trimmed}' is the project directory itself, not a file in it.` };
-  }
-  return { ok: true, absolutePath, relativePath };
-}
-
 // src/godot-bridge.ts
 var DEFAULT_PORT = 6505;
 var DEFAULT_HOST = "127.0.0.1";
@@ -26265,7 +26394,7 @@ import { promisify } from "node:util";
 // src/detection.ts
 import { existsSync as existsSync4, readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 function resolveHomeDirectory() {
   try {
     return homedir2();
@@ -26289,7 +26418,7 @@ function scanDirectoryForGodotBinaries(directory, platform) {
     if (!pattern.test(name)) {
       continue;
     }
-    const fullPath = join5(directory, name);
+    const fullPath = join6(directory, name);
     try {
       const stat = statSync2(fullPath);
       if (stat.isFile()) {
@@ -26298,7 +26427,7 @@ function scanDirectoryForGodotBinaries(directory, platform) {
     } catch {}
   }
   matches.sort((a, b) => b.mtime - a.mtime);
-  return matches.map((m) => join5(directory, m.name));
+  return matches.map((m) => join6(directory, m.name));
 }
 function conventionalPaths(platform, home) {
   const paths = ["godot"];
@@ -26467,13 +26596,13 @@ class GodotLocator {
 
 // src/headless.ts
 import { execFile as execFile2 } from "node:child_process";
-import { mkdtempSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { mkdtempSync, writeFileSync as writeFileSync4 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 import { promisify as promisify2 } from "node:util";
 
 // src/scratch.ts
-import { rmSync as rmSync2 } from "node:fs";
+import { rmSync as rmSync3 } from "node:fs";
 var SWEPT = { recursive: true, force: true, maxRetries: 20, retryDelay: 250 };
 function discardWith(remove, paths) {
   const left = [];
@@ -26491,7 +26620,7 @@ function discardWith(remove, paths) {
 }
 function discard(...paths) {
   return discardWith((path) => {
-    rmSync2(path, SWEPT);
+    rmSync3(path, SWEPT);
   }, paths);
 }
 
@@ -26535,12 +26664,12 @@ function reason(stdout, stderr) {
   return stdout.trim().split(/\r?\n/).at(-1) ?? "no output at all";
 }
 async function runImport(godotPath, projectPath) {
-  const logDir = mkdtempSync(join6(tmpdir2(), "gdharness-import-"));
+  const logDir = mkdtempSync(join7(tmpdir2(), "gdharness-import-"));
   try {
     const { stderr } = await run2(godotPath, [
       "--headless",
       "--log-file",
-      join6(logDir, "engine.log"),
+      join7(logDir, "engine.log"),
       "--path",
       projectPath,
       "--import"
@@ -26565,13 +26694,13 @@ async function runImport(godotPath, projectPath) {
   }
 }
 async function runOperation(engine, operation, params, projectPath) {
-  const paramsDir = mkdtempSync(join6(tmpdir2(), "gdharness-params-"));
-  const paramsFile = join6(paramsDir, `${operation}.json`);
-  writeFileSync3(paramsFile, JSON.stringify(snakeCased(params)), "utf8");
+  const paramsDir = mkdtempSync(join7(tmpdir2(), "gdharness-params-"));
+  const paramsFile = join7(paramsDir, `${operation}.json`);
+  writeFileSync4(paramsFile, JSON.stringify(snakeCased(params)), "utf8");
   const args = [
     "--headless",
     "--log-file",
-    join6(paramsDir, "engine.log"),
+    join7(paramsDir, "engine.log"),
     "--path",
     projectPath,
     "--script",
@@ -27000,7 +27129,7 @@ function orphansPrinted(printed) {
 import { realpathSync as realpathSync2 } from "node:fs";
 import { readFile, realpath } from "node:fs/promises";
 import { createConnection as createConnection2 } from "node:net";
-import { dirname as dirname2, resolve as resolve2 } from "node:path";
+import { dirname as dirname3, resolve as resolve2 } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 var DEFAULT_LSP_PORT = 6005;
 var DIAGNOSTICS_TIMEOUT_MS = 5000;
@@ -27130,7 +27259,7 @@ class GodotLSPClient {
     if (this.initialized) {
       return;
     }
-    const rootPath = this.rootPath ?? dirname2(resolve2(filePath));
+    const rootPath = this.rootPath ?? dirname3(resolve2(filePath));
     await this.initialize(rootPath);
   }
   async sendRequest(method, params) {
@@ -27566,14 +27695,14 @@ function secondsFromClock(printed) {
 }
 
 // src/project-scan.ts
-import { existsSync as existsSync6, readdirSync as readdirSync3, readFileSync as readFileSync6 } from "node:fs";
-import { join as join7 } from "node:path";
+import { existsSync as existsSync6, readdirSync as readdirSync3, readFileSync as readFileSync7 } from "node:fs";
+import { join as join8 } from "node:path";
 var SKIPPED = new Set(["node_modules"]);
 function skipped(name) {
   return name.startsWith(".") || SKIPPED.has(name);
 }
 function steppedOver(directory) {
-  return existsSync6(join7(directory, ".gdignore"));
+  return existsSync6(join8(directory, ".gdignore"));
 }
 var ASSET_EXTENSIONS = new Set(["png", "jpg", "jpeg", "webp", "svg", "ttf", "otf", "wav", "mp3", "ogg"]);
 function projectStructure(projectPath) {
@@ -27587,7 +27716,7 @@ function projectStructure(projectPath) {
         continue;
       }
       if (entry.isDirectory()) {
-        visit(join7(directory, entry.name));
+        visit(join8(directory, entry.name));
       } else if (entry.isFile()) {
         const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
         if (extension === "tscn") {
@@ -27618,14 +27747,14 @@ function scriptsWithoutUid(projectPath) {
       }
       const spelled = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
       if (entry.isDirectory()) {
-        visit(join7(directory, entry.name), spelled);
+        visit(join8(directory, entry.name), spelled);
         continue;
       }
       if (!entry.isFile()) {
         continue;
       }
       const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
-      if (CARRIES_A_UID.has(extension) && !existsSync6(join7(directory, `${entry.name}.uid`))) {
+      if (CARRIES_A_UID.has(extension) && !existsSync6(join8(directory, `${entry.name}.uid`))) {
         found.push(spelled);
       }
     }
@@ -27660,7 +27789,7 @@ function searchProject(projectPath, options) {
       if (skipped(entry.name)) {
         continue;
       }
-      const entryPath = join7(directory, entry.name);
+      const entryPath = join8(directory, entry.name);
       if (entry.isDirectory()) {
         visit(entryPath);
         continue;
@@ -27671,7 +27800,7 @@ function searchProject(projectPath, options) {
       }
       result.summary.files_searched += 1;
       const matches = [];
-      for (const [index, line] of readFileSync6(entryPath, "utf8").split(`
+      for (const [index, line] of readFileSync7(entryPath, "utf8").split(`
 `).entries()) {
         if (full()) {
           break;
@@ -27694,7 +27823,7 @@ function searchProject(projectPath, options) {
 }
 
 // src/resources.ts
-import { readFileSync as readFileSync7 } from "node:fs";
+import { readFileSync as readFileSync8 } from "node:fs";
 import { extname, resolve as resolve3 } from "node:path";
 var STATIC_RESOURCES = [
   {
@@ -27889,7 +28018,7 @@ function readResourceText(uri, getProjectPath) {
   const parsedUri = parseGodotUri(uri);
   if (parsedUri.kind === "project-info") {
     const projectFilePath = resolveProjectFile(projectPath, "project.godot");
-    const rawProject = readFileSync7(projectFilePath, "utf-8");
+    const rawProject = readFileSync8(projectFilePath, "utf-8");
     const parsedProject = parseProjectGodot(rawProject);
     return {
       mimeType: "application/json",
@@ -27898,7 +28027,7 @@ function readResourceText(uri, getProjectPath) {
   }
   const filePath = resolveProjectFile(projectPath, parsedUri.resourcePath);
   ensureAllowedExtension(parsedUri.kind, filePath);
-  const text = readFileSync7(filePath, "utf-8");
+  const text = readFileSync8(filePath, "utf-8");
   return {
     mimeType: parsedUri.kind === "script" ? "text/x-gdscript" : "text/plain",
     text
@@ -27935,16 +28064,16 @@ function setupResourceHandlers(mcp, getProjectPath) {
 }
 
 // src/restart-note.ts
-import { mkdirSync as mkdirSync3, readFileSync as readFileSync8, rmSync as rmSync3, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname3, join as join8 } from "node:path";
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync9, rmSync as rmSync4, writeFileSync as writeFileSync5 } from "node:fs";
+import { dirname as dirname4, join as join9 } from "node:path";
 function restartNotePath(projectPath) {
-  return join8(projectPath, ".godot", "gdharness-restart.json");
+  return join9(projectPath, ".godot", "gdharness-restart.json");
 }
 function noteRestartBegun(note) {
   const path = restartNotePath(note.projectPath);
   try {
-    mkdirSync3(dirname3(path), { recursive: true });
-    writeFileSync4(path, `${JSON.stringify(note, null, 2)}
+    mkdirSync4(dirname4(path), { recursive: true });
+    writeFileSync5(path, `${JSON.stringify(note, null, 2)}
 `, "utf8");
   } catch (error) {
     console.error(`[SERVER] Could not record the restart at ${path}: ${errorMessage(error)}`);
@@ -27952,7 +28081,7 @@ function noteRestartBegun(note) {
 }
 function restartOwed(projectPath) {
   try {
-    const parsed = JSON.parse(readFileSync8(restartNotePath(projectPath), "utf8"));
+    const parsed = JSON.parse(readFileSync9(restartNotePath(projectPath), "utf8"));
     if (typeof parsed !== "object" || parsed === null) {
       return null;
     }
@@ -27967,7 +28096,7 @@ function restartOwed(projectPath) {
 }
 function restartSettled(projectPath) {
   try {
-    rmSync3(restartNotePath(projectPath), { force: true });
+    rmSync4(restartNotePath(projectPath), { force: true });
   } catch (error) {
     console.error(`[SERVER] Could not clear the restart note: ${errorMessage(error)}`);
   }
@@ -27975,14 +28104,14 @@ function restartSettled(projectPath) {
 
 // src/run-record.ts
 import { execFileSync } from "node:child_process";
-import { mkdirSync as mkdirSync4, openSync, readdirSync as readdirSync5, readFileSync as readFileSync10, rmSync as rmSync4, statSync as statSync3, writeFileSync as writeFileSync5 } from "node:fs";
-import { basename, join as join10 } from "node:path";
+import { mkdirSync as mkdirSync5, openSync, readdirSync as readdirSync5, readFileSync as readFileSync11, rmSync as rmSync5, statSync as statSync3, writeFileSync as writeFileSync6 } from "node:fs";
+import { basename, join as join11 } from "node:path";
 
 // src/runtime-client.ts
-import { existsSync as existsSync7, readdirSync as readdirSync4, readFileSync as readFileSync9, unlinkSync } from "node:fs";
+import { existsSync as existsSync7, readdirSync as readdirSync4, readFileSync as readFileSync10, unlinkSync } from "node:fs";
 import { createConnection as createConnection3 } from "node:net";
 import { tmpdir as tmpdir3 } from "node:os";
-import { join as join9, resolve as resolve4 } from "node:path";
+import { join as join10, resolve as resolve4 } from "node:path";
 import { setTimeout as delay2 } from "node:timers/promises";
 
 // src/tool-args.ts
@@ -28050,13 +28179,13 @@ function runtimeDirectory(variables = process.env) {
     return explicit;
   }
   const perUser = envValue("XDG_RUNTIME_DIR", variables);
-  return join9(perUser ?? tmpdir3(), "gdharness");
+  return join10(perUser ?? tmpdir3(), "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(join9(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
+    candidates.push(join10(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
   }
   return [...new Set(candidates.map((path) => resolve4(path)))];
 }
@@ -28071,7 +28200,7 @@ function processAlive(pid) {
 function parseAnnouncement(file, pid) {
   let fields;
   try {
-    fields = asParams(JSON.parse(readFileSync9(file, "utf8")));
+    fields = asParams(JSON.parse(readFileSync10(file, "utf8")));
   } catch {
     return { kind: "rubbish" };
   }
@@ -28115,7 +28244,7 @@ var gone = [];
 function wentAway(file, pid) {
   let project = "";
   try {
-    const fields = asParams(JSON.parse(readFileSync9(file, "utf8")));
+    const fields = asParams(JSON.parse(readFileSync10(file, "utf8")));
     project = readString(readParams(fields, "project") ?? {}, "path") ?? "";
   } catch {
     return;
@@ -28144,7 +28273,7 @@ function announcedIn(directory) {
     if (!match) {
       continue;
     }
-    const file = join9(directory, entry);
+    const file = join10(directory, entry);
     const pid = Number.parseInt(match[1] ?? "", 10);
     const alive = processAlive(pid);
     const announced = alive ? parseAnnouncement(file, pid) : { kind: "rubbish" };
@@ -28319,33 +28448,33 @@ function runtimeRequest(endpoint, command, params, timeoutMs) {
 
 // src/run-record.ts
 function runsDirectory() {
-  return join10(runtimeDirectory(), "runs");
+  return join11(runtimeDirectory(), "runs");
 }
 function recordPath() {
-  return join10(runsDirectory(), "run.json");
+  return join11(runsDirectory(), "run.json");
 }
 function recordPaths() {
-  return runtimeDirectories().map((directory) => join10(directory, "runs", "run.json"));
+  return runtimeDirectories().map((directory) => join11(directory, "runs", "run.json"));
 }
 function openTranscript(startedAt) {
-  mkdirSync4(runsDirectory(), { recursive: true });
-  const path = join10(runsDirectory(), `run-${startedAt}.log`);
+  mkdirSync5(runsDirectory(), { recursive: true });
+  const path = join11(runsDirectory(), `run-${startedAt}.log`);
   return { path, fd: openSync(path, "a") };
 }
 function writeRunRecord(record) {
-  mkdirSync4(runsDirectory(), { recursive: true });
-  writeFileSync5(recordPath(), JSON.stringify(record, null, 2), "utf8");
+  mkdirSync5(runsDirectory(), { recursive: true });
+  writeFileSync6(recordPath(), JSON.stringify(record, null, 2), "utf8");
 }
 function editorNotePath() {
-  return join10(runsDirectory(), "editor-run.json");
+  return join11(runsDirectory(), "editor-run.json");
 }
 function writeEditorRunNote(note) {
-  mkdirSync4(runsDirectory(), { recursive: true });
-  writeFileSync5(editorNotePath(), JSON.stringify(note, null, 2), "utf8");
+  mkdirSync5(runsDirectory(), { recursive: true });
+  writeFileSync6(editorNotePath(), JSON.stringify(note, null, 2), "utf8");
 }
 function readEditorRunNote() {
   for (const directory of runtimeDirectories()) {
-    const note = editorNoteAt(join10(directory, "runs", "editor-run.json"));
+    const note = editorNoteAt(join11(directory, "runs", "editor-run.json"));
     if (note !== null) {
       return note;
     }
@@ -28355,7 +28484,7 @@ function readEditorRunNote() {
 function editorNoteAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync10(path, "utf8"));
+    parsed = JSON.parse(readFileSync11(path, "utf8"));
   } catch {
     return null;
   }
@@ -28378,7 +28507,7 @@ function recordRunEnded(pid, exitCode) {
     return;
   }
   try {
-    writeFileSync5(path, JSON.stringify({ ...record, exitCode }, null, 2), "utf8");
+    writeFileSync6(path, JSON.stringify({ ...record, exitCode }, null, 2), "utf8");
   } catch {}
 }
 function readRunRecord() {
@@ -28393,7 +28522,7 @@ function readRunRecord() {
 function recordAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync10(path, "utf8"));
+    parsed = JSON.parse(readFileSync11(path, "utf8"));
   } catch {
     return null;
   }
@@ -28438,7 +28567,7 @@ function runningAs(pid) {
     const began = startedAt(pid, null);
     const when = began === null ? {} : { startedAt: began };
     if (process.platform === "linux") {
-      const raw = readFileSync10(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
+      const raw = readFileSync11(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
       return raw === "" ? null : { kind: "commandLine", text: raw, ...when };
     }
     const args = execFileSync("ps", ["-p", String(pid), "-o", "args="], {
@@ -28560,7 +28689,7 @@ function clearRunRecord(ours = () => true) {
       continue;
     }
     try {
-      rmSync4(path);
+      rmSync5(path);
     } catch {}
   }
 }
@@ -28584,19 +28713,19 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
     if (!entry.startsWith("run-") || !entry.endsWith(".log")) {
       continue;
     }
-    const path = join10(directory, entry);
+    const path = join11(directory, entry);
     if (path === keep || ageMs(path, now) < keepMs) {
       continue;
     }
     try {
-      rmSync4(path);
+      rmSync5(path);
     } catch {}
   }
 }
 
 // src/setup.ts
-import { cpSync, existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync11, rmSync as rmSync5, writeFileSync as writeFileSync6 } from "node:fs";
-import { dirname as dirname4, join as join11 } from "node:path";
+import { cpSync, existsSync as existsSync8, mkdirSync as mkdirSync6, readFileSync as readFileSync12, rmSync as rmSync6, writeFileSync as writeFileSync7 } from "node:fs";
+import { dirname as dirname5, join as join12 } from "node:path";
 var ADDONS = ["gdharness_editor", "gdharness_runtime", "auto_reload"];
 var RUNTIME_AUTOLOAD = {
   name: "GdharnessRuntime",
@@ -28604,11 +28733,11 @@ var RUNTIME_AUTOLOAD = {
 };
 var VERSION_MARKER = ".gdharness-version";
 function installedAddonVersion(projectPath) {
-  const marker = join11(projectPath, "addons", ADDONS[0], VERSION_MARKER);
+  const marker = join12(projectPath, "addons", ADDONS[0], VERSION_MARKER);
   if (!existsSync8(marker)) {
     return null;
   }
-  const said = readFileSync11(marker, "utf8").trim();
+  const said = readFileSync12(marker, "utf8").trim();
   return said === "" ? null : said;
 }
 
@@ -29274,7 +29403,7 @@ var TOOL_SPECS = [
   },
   {
     name: "editor_output",
-    description: "What the project started by editor_run has printed, as entries with a severity: the errors and warnings the engine reported, each with where it happened, and everything else as info. Answers with the counts and the verdict as well as the entries. A run that has quit still answers here, with running false and its exit code, until the next one starts. A run this server started also answers with transcript, the file both its streams are written to: uncapped, written while the run is going, and the thing to read or tail for a long run rather than the engine's own log, which every engine start rotates away. Read the file for output and this answer for state: endedBy says whether gdharness ended the run, and a transcript that has stopped growing is a run between prints rather than a run that is over. running is asked of the operating system whenever there is a process to ask about, which is every run this server started and every editor-played run whose game announced its runtime. For an editor-played run that never announced, there is no process id here and running is the editor's answer, which can lag: one measured elsewhere reported a game as playing for fifteen seconds after its process had been ended from outside. editor_status names that game under runtimes, which does not depend on the editor answering.",
+    description: "What the project started by editor_run has printed, as entries with a severity: the errors and warnings the engine reported, each with where it happened, and everything else as info. Answers with the counts and the verdict as well as the entries. heldAt is three answers: null for a run this server knows is not held, running or over, an object for one it knows is held at a breakpoint, whether the adapter said so or the runtime did by accepting a connection and never answering, and absent with heldUnknown beside it for a server that connected to the debugger after the stop and has no runtime to ask, since the adapter reports a stop only to the sessions connected when it happened. A run that has quit still answers here, with running false and its exit code, until the next one starts. A run this server started also answers with transcript, the file both its streams are written to: uncapped, written while the run is going, and the thing to read or tail for a long run rather than the engine's own log, which every engine start rotates away. Read the file for output and this answer for state: endedBy says whether gdharness ended the run, and a transcript that has stopped growing is a run between prints rather than a run that is over. running is asked of the operating system whenever there is a process to ask about, which is every run this server started and every editor-played run whose game announced its runtime. For an editor-played run that never announced, there is no process id here and running is the editor's answer, which can lag: one measured elsewhere reported a game as playing for fifteen seconds after its process had been ended from outside. editor_status names that game under runtimes, which does not depend on the editor answering.",
     parameters: {
       severity: {
         type: "string",
@@ -29302,7 +29431,7 @@ var TOOL_SPECS = [
   },
   {
     name: "editor_status",
-    description: 'Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and whether a game with the runtime addon is reachable. playingInEditor is null when the editor was not asked or did not answer, which is not the same as a no: with no editor connected there is nobody to ask, and an editor that does not serve the question is given a moment and then left. A game can be playing while this is null, so read it as unanswered rather than as nothing playing, and use processActive and runtimes, which come from elsewhere and do not depend on the editor answering. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means "not reached yet" as often as it means "no editor". True is worth waiting out; false is an editor that is not there. False beside restartInterrupted is one that an editor_launch restart on a previous server asked to quit, where the launch half never ran because that server was ended in between, usually by the reconnect the restart was taken for; editor_launch open finishes it. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. settingsDropped appears here once when the editor this server opened saved project.godot on its way in, which is the same reading editor_launch restart makes in its own answer. A game that has announced itself in a protocol this server does not speak is listed under unreadable rather than left out, with the protocol it speaks and whether the server or the addon is the older half. This happens during an upgrade that moves the runtime protocol, which most do not: installing replaces the addon on disk as soon as the pin moves, while a server that is already running stays on the version it started with, so the two speak different protocols until the server is reconnected. Those games are real and running, but no tool here can reach them until the halves match, so runtimes stays empty and runtimeConnected stays false. An upgrade that leaves the protocol alone opens no such window and this list stays empty through it.',
+    description: "Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and whether a game with the runtime addon is reachable. playingInEditor is null when the editor was not asked or did not answer, which is not the same as a no: with no editor connected there is nobody to ask, and an editor that does not serve the question is given a moment and then left. A game can be playing while this is null, so read it as unanswered rather than as nothing playing, and use processActive and runtimes, which come from elsewhere and do not depend on the editor answering. Each game under runtimes is pinged with a short wait, so one held at a breakpoint is listed as unreachable rather than making this call wait out the runtime timeout; for the run this server is reporting on, heldAt says whether that is what it is, with the same three answers editor_output gives. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means \"not reached yet\" as often as it means \"no editor\". True is worth waiting out; false is an editor that is not there. False beside restartInterrupted is one that an editor_launch restart on a previous server asked to quit, where the launch half never ran because that server was ended in between, usually by the reconnect the restart was taken for; editor_launch open finishes it. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. settingsDropped appears here once when the editor this server opened saved project.godot on its way in, which is the same reading editor_launch restart makes in its own answer. A game that has announced itself in a protocol this server does not speak is listed under unreadable rather than left out, with the protocol it speaks and whether the server or the addon is the older half. This happens during an upgrade that moves the runtime protocol, which most do not: installing replaces the addon on disk as soon as the pin moves, while a server that is already running stays on the version it started with, so the two speak different protocols until the server is reconnected. Those games are real and running, but no tool here can reach them until the halves match, so runtimes stays empty and runtimeConnected stays false. An upgrade that leaves the protocol alone opens no such window and this list stays empty through it.",
     parameters: {},
     requires: []
   },
@@ -29627,7 +29756,7 @@ var TOOL_SPECS = [
   },
   {
     name: "debug_breakpoint",
-    description: "Sets or removes a breakpoint through the editor's debug adapter. Needs the editor, not a running game: set them first, then editor_run, and the game stops where you asked.",
+    description: "Sets or removes a breakpoint through the editor's debug adapter. Needs the editor, not a running game: set them first, then editor_run, and the game stops where you asked. The editor keeps a breakpoint set this way for one play, so every breakpoint this server holds is sent again before each play editor_run starts, and the start answer lists them under breakpoints. The set is also kept in the project, for the server that comes after a reconnect: a breakpoint stays until it is removed here, whichever server set it. Every answer lists the whole set under held.",
     parameters: {
       projectPath: PROJECT_PATH,
       scriptPath: SCRIPT_PATH,
@@ -29652,7 +29781,7 @@ var TOOL_SPECS = [
   },
   {
     name: "debug_state",
-    description: "Where the debugged game is stopped: the stack trace, what is in scope at a frame with the values, or the debug adapter's console output so far.",
+    description: "Where the debugged game is stopped: the stack trace, what is in scope at a frame with the values, or the debug adapter's console output so far. A stop is reported by the editor's adapter only to the sessions connected when it happened, so a server that connected afterwards, which is every server after a reconnect, is shown a thread and no frames about a game still sitting at its breakpoint. That server asks the runtime instead: a held game accepts a connection and never answers, and the refusal then says held rather than running, and that the stack cannot be read from here. debug_control continue lets it go, and the next stop is one this session is told about, with its stack.",
     parameters: {
       frameId: {
         type: "number",
@@ -29719,12 +29848,30 @@ function buildToolDefinitions() {
 var UPDATE_NOTICE_EVERY = 500;
 var FEEDBACK_NOTICE_EVERY = 250;
 var run4 = promisify4(execFile4);
-var __dirname2 = dirname5(fileURLToPath2(import.meta.url));
+var __dirname2 = dirname6(fileURLToPath2(import.meta.url));
 var EDITOR_RESTART_TIMEOUT_MS = 90000;
+var HOLD_PING_MS = 2000;
 var SLOWEST_FRAME_RATE = 20;
 function patienceForFrames(frames, atLeast) {
   return Math.max(atLeast, frames / SLOWEST_FRAME_RATE * 1000 + atLeast);
 }
+function projectSpelling(projectPath, absolutePath) {
+  return `res://${relative3(realPathOr(projectPath), realPathOr(absolutePath)).replaceAll("\\", "/")}`;
+}
+function describeHalt(halt) {
+  switch (halt.reason) {
+    case "breakpoint":
+      return "at a breakpoint";
+    case "step":
+      return "after a step";
+    case "exception":
+      return halt.text === "" ? "on an error" : `on an error: ${halt.text}`;
+    case "attached":
+      return "held when this session attached";
+    default:
+      return `stopped with reason "${halt.reason}"`;
+  }
+}
 function stillRunning(run) {
   if (run?.exitCode !== null || run.endedUnwatched === true) {
     return false;
@@ -29915,7 +30062,7 @@ function aboveTheRunner(entry) {
 }
 function elsewhereIn(projectPath, asked) {
   const wanted = asked.replace(/^res:\/\//, "").replace(/\/+$/, "");
-  if (wanted === "" || existsSync9(join12(projectPath, wanted))) {
+  if (wanted === "" || existsSync9(join13(projectPath, wanted))) {
     return "";
   }
   const root = (wanted.split("/")[0] ?? "").toLowerCase();
@@ -29929,11 +30076,11 @@ function elsewhereIn(projectPath, asked) {
   return near.length === 0 ? "" : ` The project does have ${there}.`;
 }
 function hasMainScene(projectFile) {
-  const scene = parseProjectGodot(readFileSync12(projectFile, "utf8"))["application"]?.["run/main_scene"];
+  const scene = parseProjectGodot(readFileSync13(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "";
 }
 function editorPlaysHeadless(projectFile) {
-  const runArgs = parseProjectGodot(readFileSync12(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
+  const runArgs = parseProjectGodot(readFileSync13(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
   return typeof runArgs === "string" && /(?:^|\s)--headless(?:\s|$)/.test(runArgs);
 }
 function camelCased(params) {
@@ -29949,7 +30096,7 @@ function camelCased(params) {
 class GodotServer {
   mcp;
   locator = new GodotLocator;
-  operationsScript = join12(__dirname2, "godot", "operations", "godot_operations.gd");
+  operationsScript = join13(__dirname2, "godot", "operations", "godot_operations.gd");
   godotBridge;
   tools = buildToolDefinitions();
   activeProcess = null;
@@ -29961,6 +30108,7 @@ class GodotServer {
   lastGodotVersion = null;
   lspClient = null;
   dapClient = null;
+  breakpointsSeededOn = null;
   bridgeStartupError = null;
   bridgeRetry = null;
   successorWatch = null;
@@ -30559,17 +30707,28 @@ class GodotServer {
         if (!located.ok) {
           return this.createErrorResponse(located.reason, PATH_SOLUTIONS);
         }
-        return await this.handleDAP(op === "set" ? "dap_set_breakpoint" : "dap_remove_breakpoint", {
+        const session = this.dapHoldingBreakpointsOf(project.value.path);
+        const answered = await this.handleDAP(op === "set" ? "dap_set_breakpoint" : "dap_remove_breakpoint", {
           ...args,
           scriptPath: realPathOr(located.absolutePath)
         });
+        if (answered.isError === true) {
+          return answered;
+        }
+        const held = session.breakpointsHeld();
+        writeBreakpointNote(project.value.path, held);
+        return this.jsonTextResponse({
+          ...asParams(JSON.parse(answered.content[0]?.text ?? "{}")),
+          held: this.breakpointsAsProjectSpells(project.value.path, held),
+          note: "The editor keeps a breakpoint set this way for one play. Every breakpoint held here is sent again before each play editor_run starts, and kept in the project for the server after a reconnect."
+        });
       }
       case "debug_control":
       case "debug_state": {
         if (tool === "debug_state" && op === "output") {
           return await this.handleDAP("dap_get_output", args);
         }
-        const held = await this.debuggedGame();
+        const held = await this.debuggedGame(tool === "debug_control" ? "move" : "read");
         if (!held.ok) {
           return held.response;
         }
@@ -30592,7 +30751,7 @@ class GodotServer {
     if (path === undefined) {
       return { ok: false, response: this.createErrorResponse("projectPath is required.") };
     }
-    const file = join12(path, "project.godot");
+    const file = join13(path, "project.godot");
     if (!existsSync9(file)) {
       return {
         ok: false,
@@ -30618,7 +30777,7 @@ class GodotServer {
     }
     return { ok: true, value: given };
   }
-  async debuggedGame() {
+  async debuggedGame(intent) {
     const game = this.activeProcess;
     if (game !== null && game.exitCode !== null) {
       return {
@@ -30656,6 +30815,19 @@ class GodotServer {
       };
     }
     if (!this.dap().isStopped()) {
+      const hold = await this.holdOf(game);
+      if (hold.heldAt !== null) {
+        if (intent === "move") {
+          return { ok: true, value: game };
+        }
+        return {
+          ok: false,
+          response: this.createErrorResponse(hold.heldAt === undefined ? `Whether the game is held cannot be told from here, so there is no stack to read. ${hold.heldNote ?? ""}` : `The game is held, and this server cannot read its stack: ${hold.heldAt.description}.`, [
+            "debug_control continue lets a held game go, and the next stop is one this session is told about",
+            "editor_output says what it printed on the way to where it is"
+          ])
+        };
+      }
       return {
         ok: false,
         response: this.createErrorResponse("The game is running, not stopped, so it has no stack and no scope to read.", [
@@ -30793,7 +30965,7 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const application = parseProjectGodot(readFileSync12(project.value.file, "utf8"))["application"] ?? {};
+    const application = parseProjectGodot(readFileSync13(project.value.file, "utf8"))["application"] ?? {};
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
@@ -30854,18 +31026,18 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const folder = dirname5(output.absolutePath);
+    const folder = dirname6(output.absolutePath);
     try {
-      mkdirSync6(folder, { recursive: true });
+      mkdirSync7(folder, { recursive: true });
     } catch (error) {
-      return this.createErrorResponse(`Cannot create ${dirname5(output.relativePath)} to export into: ${errorMessage(error)}`);
+      return this.createErrorResponse(`Cannot create ${dirname6(output.relativePath)} to export into: ${errorMessage(error)}`);
     }
     const debug = readBoolean(args, "debug") ?? false;
-    const exportLogs = mkdtempSync2(join12(tmpdir4(), "gdharness-export-"));
+    const exportLogs = mkdtempSync2(join13(tmpdir4(), "gdharness-export-"));
     const exportArgs = [
       "--headless",
       "--log-file",
-      join12(exportLogs, "engine.log"),
+      join13(exportLogs, "engine.log"),
       "--path",
       project.value.path,
       debug ? "--export-debug" : "--export-release",
@@ -30923,7 +31095,7 @@ class GodotServer {
       return contained.response;
     }
     const runner = "addons/gdUnit4/bin/GdUnitCmdTool.gd";
-    if (!existsSync9(join12(project.value.path, runner))) {
+    if (!existsSync9(join13(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"
       ]);
@@ -30958,7 +31130,7 @@ class GodotServer {
     ];
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 600000;
     this.logDebug(`Running tests: ${engine.value} ${cmdArgs.join(" ")}`);
-    const userData = mkdtempSync2(join12(tmpdir4(), "gdharness-tests-"));
+    const userData = mkdtempSync2(join13(tmpdir4(), "gdharness-tests-"));
     const run = this.spawnGame(engine.value, cmdArgs, userDataIn(userData));
     const hung = await new Promise((resolve) => {
       const timer = setTimeout(() => {
@@ -30974,14 +31146,14 @@ class GodotServer {
         resolve(false);
       });
     });
-    const reportsDir = join12(project.value.path, ".godot", ...ours.split("/"));
+    const reportsDir = join13(project.value.path, ".godot", ...ours.split("/"));
     let report = null;
     let reportProblem = null;
     try {
       const written = existsSync9(reportsDir) ? readdirSync6(reportsDir).filter((name) => name.startsWith("report_")).sort((a, b) => Number(a.slice("report_".length)) - Number(b.slice("report_".length))) : [];
       const newest = written.at(-1);
       if (newest !== undefined) {
-        report = parseJUnit(readFileSync12(join12(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync13(join13(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
@@ -31121,7 +31293,7 @@ class GodotServer {
         return null;
       }
       try {
-        return readFileSync12(contained.absolutePath, "utf8");
+        return readFileSync13(contained.absolutePath, "utf8");
       } catch {
         return null;
       }
@@ -31163,7 +31335,7 @@ class GodotServer {
       return null;
     }
     try {
-      return readFileSync12(contained.absolutePath, "utf8");
+      return readFileSync13(contained.absolutePath, "utf8");
     } catch {
       return null;
     }
@@ -31212,6 +31384,20 @@ class GodotServer {
     }
     return this.dapClient;
   }
+  dapHoldingBreakpointsOf(projectPath) {
+    const client = this.dap();
+    if (this.breakpointsSeededOn !== client) {
+      client.holdBreakpoints(readBreakpointNote(projectPath));
+      this.breakpointsSeededOn = client;
+    }
+    return client;
+  }
+  breakpointsAsProjectSpells(projectPath, held) {
+    return held.map((one) => ({
+      scriptPath: projectSpelling(projectPath, one.scriptPath),
+      lines: one.lines
+    }));
+  }
   writeToTranscript(line) {
     const run = this.activeProcess;
     if (run?.throughEditor !== true || run.transcript === null) {
@@ -31301,8 +31487,12 @@ class GodotServer {
   async handleEditorStatus() {
     const located = await this.locator.find();
     const announced = runtimesAnnounced();
-    const games = await Promise.all(announced.running.map(async (endpoint) => {
-      const reply = await runtimeRequest(endpoint, "ping", {}, this.runtimeTimeoutMs());
+    const pinged = Promise.all(announced.running.map(async (endpoint) => {
+      const held = this.knownHoldOn(endpoint);
+      const reply = held === null ? await runtimeRequest(endpoint, "ping", {}, HOLD_PING_MS) : {
+        ok: false,
+        message: `The game is held by the editor's debugger, ${describeHalt(held)}, and answers no runtime call while it is. debug_control continue lets it go.`
+      };
       return {
         pid: endpoint.pid,
         port: endpoint.port,
@@ -31311,8 +31501,13 @@ class GodotServer {
         problem: reply.ok ? null : reply.message
       };
     }));
-    const playing = await this.editorPlayingState();
-    await this.pickUpWhatTheEditorIsPlaying();
+    const asked = (async () => {
+      const playing = await this.editorPlayingState();
+      await this.pickUpWhatTheEditorIsPlaying();
+      const current = this.currentRun();
+      return { playing, hold: current === null ? {} : await this.holdOf(current) };
+    })();
+    const [games, { playing, hold }] = await Promise.all([pinged, asked]);
     return this.jsonTextResponse({
       editor: {
         ...this.getEditorStatusPayload(),
@@ -31326,6 +31521,7 @@ class GodotServer {
       game: {
         processActive: runIsUp(this.currentRun(), playing === null ? null : playing.playing),
         playingInEditor: playing,
+        ...hold,
         runtimeConnected: games.some((game) => game.reachable),
         runtimes: games,
         unreadable: announced.unspoken.map((game) => ({
@@ -31343,7 +31539,7 @@ class GodotServer {
       return null;
     }
     try {
-      return settingKeys(readFileSync12(join12(projectPath, "project.godot"), "utf8"));
+      return settingKeys(readFileSync13(join13(projectPath, "project.godot"), "utf8"));
     } catch {
       return null;
     }
@@ -31586,7 +31782,7 @@ class GodotServer {
     return runIsUp(run, editorSays);
   }
   async runtimeUp(projectPath, before, budgetMs, withArgs) {
-    if (!existsSync9(join12(projectPath, RUNTIME_AUTOLOAD.path))) {
+    if (!existsSync9(join13(projectPath, RUNTIME_AUTOLOAD.path))) {
       return runtimeVerdict(null, { addon: false, budgetMs, heldAt: null, running: false, withArgs });
     }
     const endpoint = await announcedSince(projectPath, before, {
@@ -31624,6 +31820,7 @@ class GodotServer {
         "Closing the other editor, or moving its debug adapter port in its editor settings, frees this one"
       ]);
     }
+    const breakpoints = await this.dapHoldingBreakpointsOf(projectPath).reapplyBreakpoints();
     const answer = await this.handleViaBridge("play_scene", scene === null ? {} : { scenePath: `res://${scene}` });
     if (answer.isError === true) {
       return answer;
@@ -31653,6 +31850,11 @@ class GodotServer {
       refreshedClasses,
       debugPort: readNumber(asParams(JSON.parse(answer.content[0]?.text ?? "{}")), "debugPort"),
       endedPreviousRun: ended ?? undefined,
+      breakpoints: breakpoints.applied.length === 0 ? undefined : this.breakpointsAsProjectSpells(projectPath, breakpoints.applied),
+      breakpointsRefused: breakpoints.refused.length === 0 ? undefined : breakpoints.refused.map((one) => ({
+        scriptPath: projectSpelling(projectPath, one.scriptPath),
+        reason: one.reason
+      })),
       runtime: await this.runtimeUp(projectPath, alreadyPlaying, runtimeWaitMs, false),
       message: "The editor is playing it, so its debugger holds it: the debug_* tools can reach it, " + "editor_output reads its console through the debug adapter, and editor_run stop ends it." + (ended === null ? "" : ` The run that was going, pid ${ended}, was ended to start this one; its output is no longer what editor_output answers about.`)
     });
@@ -31850,7 +32052,7 @@ class GodotServer {
       return;
     }
     try {
-      await this.dap().connect();
+      await this.dap().attach();
     } catch (error) {
       this.logDebug(`Picked up an editor-played run without its adapter: ${errorMessage(error)}`);
     }
@@ -31870,8 +32072,16 @@ class GodotServer {
       brokeOn: null,
       pickedUpPlaying: true
     };
+    const announced = this.theOneAnnouncedForOurProject();
+    if (announced !== undefined) {
+      picked.announcedPid = announced.pid;
+    }
     this.activeProcess = picked;
   }
+  theOneAnnouncedForOurProject() {
+    const ofProject = this.allAnnouncedForOurProject(runtimesAnnounced().running);
+    return ofProject.length === 1 ? ofProject[0] : undefined;
+  }
   adoptRecordedRun() {
     const record = readRunRecord();
     if (record === null || !this.couldBeOurs(record.projectPath)) {
@@ -32026,7 +32236,7 @@ class GodotServer {
       contains: readNonEmptyString(args, "contains"),
       limit: readPositiveNumber(args, "limit") ?? 200
     });
-    const halt = run.throughEditor ? this.dapClient?.whereItStopped() ?? null : null;
+    const hold = await this.holdOf(run);
     const wanted = readBoolean(args, "cpu") ?? false;
     const cpuSeconds = wanted && run.pid !== null && stillRunning(run) ? await cpuSecondsOf(run.pid) : undefined;
     const notes = [];
@@ -32063,7 +32273,7 @@ class GodotServer {
       warnings: run.log.count("warning"),
       clean: run.consoleLost === true ? undefined : run.log.count("error") === 0,
       consoleLost: run.consoleLost === true ? true : undefined,
-      heldAt: halt,
+      ...hold,
       endedUnwatched: run.endedUnwatched === true ? true : undefined,
       endedBy: stillRunning(run) ? undefined : run.endedHere ?? null,
       project: !run.throughEditor && run.process === null ? run.projectPath ?? undefined : undefined,
@@ -32246,6 +32456,50 @@ class GodotServer {
     const override = Number.parseInt(envValue("GDHARNESS_RUNTIME_TIMEOUT_MS") ?? "", 10);
     return Number.isInteger(override) && override > 0 ? override : 1e4;
   }
+  knownHoldOn(endpoint) {
+    const run = this.activeProcess;
+    const session = this.dapClient;
+    if (run === null || !run.throughEditor || !stillRunning(run) || session === null) {
+      return null;
+    }
+    const its = run.announcedPid ?? this.theOneAnnouncedForOurProject()?.pid;
+    if (its !== endpoint.pid || !session.holdIsKnown()) {
+      return null;
+    }
+    return session.whereItStopped();
+  }
+  async holdOf(run) {
+    if (!run.throughEditor || !stillRunning(run)) {
+      return { heldAt: null };
+    }
+    const session = this.dapClient;
+    if (session?.holdIsKnown()) {
+      return { heldAt: session.whereItStopped() };
+    }
+    const endpoint = run.announcedPid !== undefined ? runtimesAnnounced().running.find((one) => one.pid === run.announcedPid) : this.theOneAnnouncedForOurProject();
+    if (endpoint === undefined) {
+      return {
+        heldAt: undefined,
+        heldUnknown: true,
+        heldNote: "Whether this run is held at a breakpoint cannot be told from here: this server connected to the debugger after any stop, the adapter reports a stop only to the sessions connected when it happened, and the run has announced no runtime to ask instead. A game that draws nothing and answers nothing is held; debug_control continue lets a held game go."
+      };
+    }
+    const reply = await runtimeRequest(endpoint, "ping", {}, HOLD_PING_MS);
+    if (reply.ok) {
+      session?.learnedRunning();
+      return { heldAt: session?.whereItStopped() ?? null };
+    }
+    if (reply.reason === "busy") {
+      return {
+        heldAt: {
+          reason: "unanswered",
+          description: `the game accepted a runtime connection and did not answer a ping within ${HOLD_PING_MS}ms, which is what a game held at a breakpoint does, and what one stuck in a long frame does. This server connected to the debugger after the stop, so the adapter will not show it the stack; debug_control continue lets a held game go`,
+          text: ""
+        }
+      };
+    }
+    return { heldAt: undefined, heldUnknown: true, heldNote: reply.message };
+  }
   async handleRuntimeCommand(command, args, timeoutMs = this.runtimeTimeoutMs()) {
     const { op: _op, projectPath, ...params } = asParams(args);
     const announced = runtimesAnnounced();
@@ -32253,9 +32507,17 @@ class GodotServer {
     if ("problem" in choice) {
       return this.createErrorResponse(choice.problem);
     }
+    const held = this.knownHoldOn(choice.endpoint);
+    if (held !== null) {
+      return this.createErrorResponse(`The game (pid ${choice.endpoint.pid}) is held by the editor's debugger, ${describeHalt(held)}, and answers no runtime call while it is.`, [
+        "debug_control continue lets it go, after which this call answers",
+        "debug_state stack reads where it is held, and debug_state scopes what it is holding there",
+        "editor_output says heldAt for the run, and editor_run stop ends it"
+      ]);
+    }
     const expectsScreenshot = command === "capture_screenshot" || command === "capture_viewport";
-    const screenshotDir = expectsScreenshot ? mkdtempSync2(join12(tmpdir4(), "gdharness-runtime-screenshot-")) : null;
-    const screenshotPath = screenshotDir ? join12(screenshotDir, "capture.png") : null;
+    const screenshotDir = expectsScreenshot ? mkdtempSync2(join13(tmpdir4(), "gdharness-runtime-screenshot-")) : null;
+    const screenshotPath = screenshotDir ? join13(screenshotDir, "capture.png") : null;
     try {
       const reply = await runtimeRequest(choice.endpoint, command, screenshotPath ? { ...params, output_path: screenshotPath } : params, timeoutMs);
       if (!reply.ok) {
@@ -32276,7 +32538,7 @@ class GodotServer {
       return {
         content: [
           { type: "text", text: `Screenshot captured: ${dimensions}` },
-          { type: "image", data: readFileSync12(screenshotPath).toString("base64"), mimeType: "image/png" }
+          { type: "image", data: readFileSync13(screenshotPath).toString("base64"), mimeType: "image/png" }
         ]
       };
     } finally {