gdharness 0.13.39 → 0.13.41

package/build/index.js

@@ -25248,6 +25248,8 @@ class GodotDAPClient {
   halt = null;
   holdKnown = false;
   breakpoints = new Map;
+  inEditor = new Map;
+  onBreakpointsChanged = null;
   constructor(port = portFromEnv("GDHARNESS_DAP_PORT", DEFAULT_DAP_PORT), host = "127.0.0.1") {
     this.port = port;
     this.host = host;
@@ -25337,6 +25339,7 @@ class GodotDAPClient {
     this.attached = false;
     this.halt = null;
     this.holdKnown = false;
+    this.inEditor.clear();
   }
   async ensureConnected() {
     if (!this.connected) {
@@ -25433,6 +25436,31 @@ class GodotDAPClient {
       this.holdKnown = true;
       return;
     }
+    if (eventName === "breakpoint") {
+      const body = event.body;
+      const breakpoint = body?.["breakpoint"];
+      const source = typeof breakpoint === "object" && breakpoint !== null ? breakpoint["source"] : undefined;
+      const path = typeof source === "object" && source !== null ? source["path"] : undefined;
+      const line = typeof breakpoint === "object" && breakpoint !== null ? breakpoint["line"] : undefined;
+      if (typeof path !== "string" || typeof line !== "number") {
+        return;
+      }
+      if (said(body, "reason") === "removed") {
+        this.inEditor.get(path)?.delete(line);
+        const held = this.breakpoints.get(path);
+        if (held?.delete(line) === true) {
+          if (held.size === 0) {
+            this.breakpoints.delete(path);
+          }
+          this.onBreakpointsChanged?.(this.breakpointsHeld());
+        }
+        return;
+      }
+      const known = this.inEditor.get(path) ?? new Set;
+      known.add(line);
+      this.inEditor.set(path, known);
+      return;
+    }
     if (eventName === "terminated" || eventName === "exited") {
       this.attached = false;
       this.halt = null;
@@ -25525,23 +25553,46 @@ class GodotDAPClient {
   async removeBreakpoint(filePath, line) {
     const wanted = new Set(this.breakpoints.get(filePath) ?? []);
     wanted.delete(line);
-    return await this.sendBreakpoints(filePath, wanted);
+    return await this.sendBreakpoints(filePath, wanted, line);
   }
-  async sendBreakpoints(filePath, lines) {
+  async sendBreakpoints(filePath, mine, clearing) {
     await this.ensureConnected();
     await this.initialize();
+    const lines = new Set([...mine, ...this.inEditor.get(filePath) ?? []]);
+    if (clearing !== undefined) {
+      lines.delete(clearing);
+    }
     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) {
+    if (mine.size === 0) {
       this.breakpoints.delete(filePath);
     } else {
-      this.breakpoints.set(filePath, new Set(lines));
+      this.breakpoints.set(filePath, new Set(mine));
+    }
+    if (lines.size === 0) {
+      this.inEditor.delete(filePath);
+    } else {
+      this.inEditor.set(filePath, lines);
     }
     return answer;
   }
+  setBreakpointsSink(sink) {
+    this.onBreakpointsChanged = sink;
+  }
+  breakpointsInEditor() {
+    const theirs = [];
+    for (const [scriptPath, lines] of this.inEditor) {
+      const mine = this.breakpoints.get(scriptPath);
+      const rest = Array.from(lines).filter((line) => !mine?.has(line)).sort((a, b) => a - b);
+      if (rest.length > 0) {
+        theirs.push({ scriptPath, lines: rest });
+      }
+    }
+    return theirs;
+  }
   async reapplyBreakpoints() {
     const applied = [];
     const refused = [];
@@ -25557,6 +25608,9 @@ class GodotDAPClient {
         });
       }
     }
+    if (refused.length > 0) {
+      this.onBreakpointsChanged?.(this.breakpointsHeld());
+    }
     return { applied, refused };
   }
   breakpointsHeld() {
@@ -25759,14 +25813,10 @@ async function handleDAPTool(client, toolName, args) {
     }
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
+    const cure = toolName === "dap_set_breakpoint" || toolName === "dap_remove_breakpoint" ? "Breakpoints need the editor open, not a running game: editor_status says whether one is connected, and the path is the script as the project spells it." : "The debug tools answer for a game the editor is playing: start one with editor_run.";
     return {
       isError: true,
-      content: [
-        {
-          type: "text",
-          text: `DAP tool '${toolName}' failed: ${message}. ` + "The debug tools answer for a game the editor is playing: start one with editor_run."
-        }
-      ]
+      content: [{ type: "text", text: `DAP tool '${toolName}' failed: ${message}. ${cure}` }]
     };
   }
 }
@@ -26071,6 +26121,7 @@ class GodotBridge extends EventEmitter {
       dapPort: this.connectionInfo?.dapPort,
       debugPort: this.connectionInfo?.debugPort,
       openedByAServer: this.connectionInfo?.openedByAServer,
+      syncsBreakpoints: this.connectionInfo?.syncsBreakpoints,
       pendingRequests: this.pendingRequests.size,
       queuedResources: this.resourceQueues.size,
       listeningSince: this.listeningSince ?? undefined
@@ -26213,6 +26264,7 @@ class GodotBridge extends EventEmitter {
           this.connectionInfo.dapPort = servedPort(message.dap_port);
           this.connectionInfo.debugPort = servedPort(message.debug_port);
           this.connectionInfo.openedByAServer = message.opened_by_a_server === true;
+          this.connectionInfo.syncsBreakpoints = typeof message.syncs_breakpoints === "boolean" ? message.syncs_breakpoints : undefined;
           this.log("info", `Godot ready: ${message.project_path}`);
           this.emitBridgeEvent("godot_connected", { projectPath: message.project_path });
         }
@@ -27661,7 +27713,7 @@ async function handleLSPTool(client, toolName, args) {
 import { execFile as execFile3 } from "node:child_process";
 import { promisify as promisify3 } from "node:util";
 var run3 = promisify3(execFile3);
-var ASK_TIMEOUT_MS = 2000;
+var ASK_TIMEOUT_MS = 6000;
 async function cpuSecondsOf(pid) {
   try {
     return process.platform === "win32" ? await askWindows(pid) : await askPosix(pid);
@@ -28218,7 +28270,18 @@ function parseAnnouncement(file, pid) {
   if (protocol !== RUNTIME_PROTOCOL) {
     return { kind: "unspoken", unspoken: { pid, protocol: protocol ?? 0, project: named } };
   }
-  return { kind: "runtime", endpoint: { pid, port, address, project: named, file } };
+  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;
@@ -28297,7 +28360,7 @@ async function announcedSince(projectPath, before, waiting = {}) {
   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);
+    const fresh = discoverRuntimes(directories).find((endpoint) => !before.has(endpoint.pid) && resolve4(endpoint.project.path) === wanted && (waiting.accept?.(endpoint) ?? true));
     if (fresh !== undefined) {
       return fresh;
     }
@@ -28316,7 +28379,25 @@ function tooNew(unspoken) {
   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 = []) {
+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) };
@@ -28347,14 +28428,14 @@ function chooseRuntime(endpoints, projectPath, unspoken = []) {
       return { endpoint: matching[0] };
     }
     return {
-      problem: `Several games are running from ${wanted}: ${matching.map(describe2).join("; ")}. Stop all but one.`
+      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.`
+    problem: `Several games are running: ${endpoints.map(describe2).join("; ")}. Pass projectPath to choose one, or pid when they are from one project.`
   };
 }
 var nextRequestId = 1;
@@ -28765,6 +28846,10 @@ var RUNNING_PROJECT_PATH = {
   type: "string",
   description: "Which game, when more than one is running: the project directory it was started from. Not needed with one game."
 };
+var RUNNING_PID = {
+  type: "number",
+  description: "Which game, when several are running from one project, such as a bench and its workers: its process id, as editor_status lists under runtimes. Not needed with one game per project."
+};
 var SCENE_PATH = {
   type: "string",
   description: 'Scene file inside the project, such as "scenes/main.tscn" or "res://scenes/main.tscn".'
@@ -29431,7 +29516,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. 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.",
+    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. A game the editor played announces the editor under editorPid, and so does whatever that game started for itself; a game some other server started announces none, which is how the two are told apart when both are running from one project. 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: []
   },
@@ -29488,6 +29573,7 @@ var TOOL_SPECS = [
     description: "Questions about the running game: what is written on the screen, the scene tree, the nodes matching a query, where one node is on screen, what one property reads, or the performance metrics. Needs the game running with the runtime addon.",
     parameters: {
       projectPath: RUNNING_PROJECT_PATH,
+      pid: RUNNING_PID,
       nodePath: {
         type: "string",
         ops: ["tree", "text", "find", "rect", "property"],
@@ -29566,6 +29652,7 @@ var TOOL_SPECS = [
     description: "Sets a property or calls a method on a node in the running game. Needs the game running with the runtime addon.",
     parameters: {
       projectPath: RUNNING_PROJECT_PATH,
+      pid: RUNNING_PID,
       nodePath: { type: "string", description: 'Absolute node path, such as "/root/Main/Player".' },
       property: {
         type: "string",
@@ -29605,6 +29692,7 @@ var TOOL_SPECS = [
     description: "A picture of the running game: the whole screen or one viewport, as an image. Needs the game running with a window.",
     parameters: {
       projectPath: RUNNING_PROJECT_PATH,
+      pid: RUNNING_PID,
       viewportPath: {
         type: "string",
         ops: ["viewport"],
@@ -29625,6 +29713,7 @@ var TOOL_SPECS = [
     description: "Input to the running game: a whole click on a Control or a 3D node named by path, an item chosen out of a menu, typing into whatever has the focus, or a raw action, key, mouse button or mouse motion. All of it works headless, where the window is 64 by 64 and the GUI only takes what is inside it.",
     parameters: {
       projectPath: RUNNING_PROJECT_PATH,
+      pid: RUNNING_PID,
       nodePath: {
         type: "string",
         ops: ["click", "choose"],
@@ -29721,6 +29810,7 @@ var TOOL_SPECS = [
     description: "Lets the running game get on with it and answers when something has happened: a number of frames, a signal, a property reaching a value, or words appearing on a screen. Needs the game running with the runtime addon.",
     parameters: {
       projectPath: RUNNING_PROJECT_PATH,
+      pid: RUNNING_PID,
       frames: {
         type: "number",
         ops: ["frames"],
@@ -29756,7 +29846,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. 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.",
+    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, and the breakpoints the user set in the editor's own gutter under setInEditor; setting one here never takes those away, and removing a line here clears it whoever set it. Godot clears every breakpoint in the editor when a debug session opens unless network/debug_adapter/sync_breakpoints is on, which the addon turns on as it loads; an editor running an older addon is said so under breakpointsAtRisk, here and in editor_status.",
     parameters: {
       projectPath: PROJECT_PATH,
       scriptPath: SCRIPT_PATH,
@@ -29858,6 +29948,9 @@ function patienceForFrames(frames, atLeast) {
 function projectSpelling(projectPath, absolutePath) {
   return `res://${relative3(realPathOr(projectPath), realPathOr(absolutePath)).replaceAll("\\", "/")}`;
 }
+function whichGame(args) {
+  return { projectPath: args["projectPath"], pid: args["pid"] };
+}
 function describeHalt(halt) {
   switch (halt.reason) {
     case "breakpoint":
@@ -29893,6 +29986,19 @@ function runIsUp(run, editorSays) {
   }
   return editorSays ?? stillRunning(run);
 }
+function endedPreviousRun(ended) {
+  if (ended === null) {
+    return;
+  }
+  return ended.pid ?? true;
+}
+function endedToStartThis(ended) {
+  if (ended === null) {
+    return "";
+  }
+  const which = ended.pid === null ? "The game the editor was playing" : `The run that was going, pid ${ended.pid},`;
+  return ` ${which} was ended to start this one; its output is no longer what editor_output answers about.`;
+}
 function runtimeVerdict(endpoint, after) {
   if (endpoint !== null) {
     return { listening: true, pid: endpoint.pid, port: endpoint.port };
@@ -30079,6 +30185,16 @@ function hasMainScene(projectFile) {
   const scene = parseProjectGodot(readFileSync13(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "";
 }
+function runtimeAddonAnnouncesEditors(projectPath) {
+  if (projectPath === null) {
+    return false;
+  }
+  try {
+    return readFileSync13(join13(projectPath, RUNTIME_AUTOLOAD.path), "utf8").includes('"editor_pid"');
+  } catch {
+    return false;
+  }
+}
 function editorPlaysHeadless(projectFile) {
   const runArgs = parseProjectGodot(readFileSync13(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
   return typeof runArgs === "string" && /(?:^|\s)--headless(?:\s|$)/.test(runArgs);
@@ -30633,7 +30749,7 @@ class GodotServer {
         switch (op) {
           case "tree":
             return await this.handleRuntimeCommand("get_tree", {
-              projectPath: args["projectPath"],
+              ...whichGame(args),
               root: readNonEmptyString(args, "nodePath") ?? "/root",
               depth: readPositiveNumber(args, "depth") ?? 3,
               include_properties: readBoolean(args, "includeProperties") ?? false
@@ -30642,36 +30758,36 @@ class GodotServer {
             return await this.handleFindRuntimeNodes(args);
           case "text":
             return await this.handleRuntimeCommand("read_text", {
-              projectPath: args["projectPath"],
+              ...whichGame(args),
               root: readNonEmptyString(args, "nodePath") ?? "/root",
               include_hidden: readBoolean(args, "includeHidden") ?? false,
               limit: readPositiveNumber(args, "limit") ?? 500
             });
           case "rect":
             return await this.handleRuntimeCommand("get_rect", {
-              projectPath: args["projectPath"],
+              ...whichGame(args),
               path: readNonEmptyString(args, "nodePath") ?? ""
             });
           case "property":
             return await this.handleRuntimeCommand("get_property", {
-              projectPath: args["projectPath"],
+              ...whichGame(args),
               path: readNonEmptyString(args, "nodePath") ?? "",
               property: readNonEmptyString(args, "property") ?? ""
             });
           default:
             return await this.handleRuntimeCommand("get_metrics", {
-              projectPath: args["projectPath"],
+              ...whichGame(args),
               metrics: readArray(args, "metrics") ?? []
             });
         }
       case "runtime_invoke":
         return op === "set" ? await this.handleRuntimeCommand("set_property", {
-          projectPath: args["projectPath"],
+          ...whichGame(args),
           path: readNonEmptyString(args, "nodePath") ?? "",
           property: readString(args, "property") ?? "",
           value: args["value"]
         }) : await this.handleRuntimeCommand("call_method", {
-          projectPath: args["projectPath"],
+          ...whichGame(args),
           path: readNonEmptyString(args, "nodePath") ?? "",
           method: readString(args, "method") ?? "",
           args: readArray(args, "args") ?? []
@@ -30681,7 +30797,7 @@ class GodotServer {
       case "runtime_input":
         if (op === "click") {
           return await this.handleRuntimeCommand("click", {
-            projectPath: args["projectPath"],
+            ...whichGame(args),
             path: readNonEmptyString(args, "nodePath") ?? "",
             button: readString(args, "button") ?? "left",
             double: readBoolean(args, "doubleClick") ?? false
@@ -30689,7 +30805,7 @@ class GodotServer {
         }
         if (op === "choose") {
           return await this.handleRuntimeCommand("choose", {
-            projectPath: args["projectPath"],
+            ...whichGame(args),
             path: readNonEmptyString(args, "nodePath") ?? "",
             text: readString(args, "text") ?? "",
             ...args["index"] === undefined ? {} : { index: args["index"] }
@@ -30720,7 +30836,9 @@ class GodotServer {
         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."
+          setInEditor: this.breakpointsAsProjectSpells(project.value.path, session.breakpointsInEditor()),
+          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.",
+          ...this.breakpointsAtRisk()
         });
       }
       case "debug_control":
@@ -30794,6 +30912,16 @@ class GodotServer {
         response: this.createErrorResponse("No game is running, so there is no debug session to answer for.", ["Start one with editor_run start, which has the editor play it"])
       };
     }
+    const going = await this.runStillGoing(game);
+    if (!going) {
+      return {
+        ok: false,
+        response: this.createErrorResponse("The last run has already ended, so there is no debug session to answer for.", [
+          "editor_output still reads what it printed, until the next run starts",
+          "editor_run start plays another, which the debugger can hold"
+        ])
+      };
+    }
     if (!game.throughEditor) {
       return {
         ok: false,
@@ -30815,7 +30943,7 @@ class GodotServer {
       };
     }
     if (!this.dap().isStopped()) {
-      const hold = await this.holdOf(game);
+      const hold = await this.holdOf(game, going);
       if (hold.heldAt !== null) {
         if (intent === "move") {
           return { ok: true, value: game };
@@ -31381,6 +31509,12 @@ class GodotServer {
       this.dapClient.setOutputSink((line) => {
         this.writeToTranscript(line);
       });
+      this.dapClient.setBreakpointsSink((held) => {
+        const project = this.godotBridge.getStatus().projectPath ?? this.ownProject;
+        if (project !== null) {
+          writeBreakpointNote(project, held);
+        }
+      });
     }
     return this.dapClient;
   }
@@ -31392,6 +31526,15 @@ class GodotServer {
     }
     return client;
   }
+  breakpointsAtRisk() {
+    const status = this.godotBridge.getStatus();
+    if (!status.connected || status.syncsBreakpoints === true) {
+      return {};
+    }
+    return {
+      breakpointsAtRisk: status.syncsBreakpoints === false ? "This editor clears every breakpoint in its script editor whenever a debug session opens on its adapter, which this server does for its first breakpoint or stack read: network/debug_adapter/sync_breakpoints is off. The installed addon turns it on as it loads, so the editor is running an older one; editor_launch restart puts the installed addon in, or turn the setting on in Editor Settings > Network > Debug Adapter." : "Whether this editor keeps its breakpoints when a debug session opens cannot be told: the addon it is running predates the report. Godot clears them unless network/debug_adapter/sync_breakpoints is on, which the installed addon turns on as it loads; editor_launch restart puts the installed addon in."
+    };
+  }
   breakpointsAsProjectSpells(projectPath, held) {
     return held.map((one) => ({
       scriptPath: projectSpelling(projectPath, one.scriptPath),
@@ -31454,6 +31597,7 @@ class GodotServer {
       ...status.connected ? this.whatTheLaunchedEditorDropped() : {},
       startupError: this.bridgeStartupError,
       staleNote: stale ? addonMismatch(status.addonVersion, SERVER_VERSION) : undefined,
+      ...this.breakpointsAtRisk(),
       retryingBridge: this.bridgeRetry === null ? undefined : true,
       announcedAt: this.announcedAt ?? undefined,
       projectIs: this.projectHasMovedOn() ?? undefined,
@@ -31488,7 +31632,7 @@ class GodotServer {
     const located = await this.locator.find();
     const announced = runtimesAnnounced();
     const pinged = Promise.all(announced.running.map(async (endpoint) => {
-      const held = this.knownHoldOn(endpoint);
+      const held = this.knownHoldOn(endpoint, announced.running);
       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.`
@@ -31497,6 +31641,7 @@ class GodotServer {
         pid: endpoint.pid,
         port: endpoint.port,
         project: endpoint.project,
+        editorPid: endpoint.editorPid,
         reachable: reply.ok,
         problem: reply.ok ? null : reply.message
       };
@@ -31505,9 +31650,14 @@ class GodotServer {
       const playing = await this.editorPlayingState();
       await this.pickUpWhatTheEditorIsPlaying();
       const current = this.currentRun();
-      return { playing, hold: current === null ? {} : await this.holdOf(current) };
+      const active = current === null ? false : await this.runStillGoing(current, playing?.playing ?? null);
+      return {
+        playing,
+        active,
+        hold: current === null ? {} : await this.holdOf(current, active)
+      };
     })();
-    const [games, { playing, hold }] = await Promise.all([pinged, asked]);
+    const [games, { playing, active, hold }] = await Promise.all([pinged, asked]);
     return this.jsonTextResponse({
       editor: {
         ...this.getEditorStatusPayload(),
@@ -31519,7 +31669,7 @@ class GodotServer {
         problem: located.ok ? undefined : GodotLocator.refusal(located).message
       },
       game: {
-        processActive: runIsUp(this.currentRun(), playing === null ? null : playing.playing),
+        processActive: active,
         playingInEditor: playing,
         ...hold,
         runtimeConnected: games.some((game) => game.reachable),
@@ -31732,10 +31882,12 @@ class GodotServer {
     if (op === "check") {
       return await this.checkBoot(engine.value, project.value.path, sceneArgument, args, given.value);
     }
+    await this.pickUpWhatTheEditorIsPlaying();
     let ended = null;
-    if (stillRunning(this.currentRun())) {
+    const before = this.currentRun();
+    if (before !== null && await this.runStillGoing(before)) {
       this.logDebug("Ending the running game before starting another");
-      ended = this.currentRun()?.pid ?? null;
+      ended = { pid: before.pid ?? this.announcedPidOf(before) ?? null };
       await this.endActiveGame("editor_run start, which ends the run that was going before it starts another");
     }
     const alreadyPlaying = new Set(discoverRuntimes().map((endpoint) => endpoint.pid));
@@ -31759,8 +31911,8 @@ class GodotServer {
     const started = this.spawnKeptGame(engine.value, cmdArgs, project.value.path);
     this.activeProcess = started;
     const spawnedInstead = this.godotBridge.isConnected() && editorWouldPlay && given.value.length > 0 ? " The editor cannot be handed arguments for a game it plays, so this one was started " + "here: the debug_* tools answer only for a game the editor is playing." : "";
-    const endedForThis = 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.`;
-    const stranded = wereHereFirst.filter((one) => one.pid !== ended && alive(one.pid));
+    const endedForThis = endedToStartThis(ended);
+    const stranded = wereHereFirst.filter((one) => one.pid !== ended?.pid && alive(one.pid));
     const named = stranded.map((one) => one.protocol === null ? `pid ${one.pid}` : `pid ${one.pid} on protocol ${one.protocol}`).join(", ");
     const alsoRunning = stranded.length === 0 ? "" : ` A game of this project was already running and still is: ${named}. Starting this one did not end it and nothing here can, because this server did not start it. End it yourself, or bring the halves to one version where a protocol is named.`;
     return this.jsonTextResponse({
@@ -31771,23 +31923,39 @@ class GodotServer {
       arguments: cmdArgs,
       transcript: started.transcript,
       refreshedClasses: refreshed.value,
-      endedPreviousRun: ended ?? undefined,
+      endedPreviousRun: endedPreviousRun(ended),
       runtime: await this.runtimeUp(project.value.path, alreadyPlaying, runtimeWaitMs, given.value.length > 0),
       message: `Use editor_output for what it prints and editor_run stop to end it.${spawnedInstead}${endedForThis}${alsoRunning}`
     });
   }
-  async gameIsUp() {
-    const run = this.currentRun();
-    const editorSays = run?.throughEditor === true ? (await this.editorPlayingState())?.playing ?? null : null;
-    return runIsUp(run, editorSays);
-  }
   async runtimeUp(projectPath, before, budgetMs, withArgs) {
     if (!existsSync9(join13(projectPath, RUNTIME_AUTOLOAD.path))) {
       return runtimeVerdict(null, { addon: false, budgetMs, heldAt: null, running: false, withArgs });
     }
+    let asking = null;
+    let editorAskedAt = 0;
+    let editorSaysGoing = true;
     const endpoint = await announcedSince(projectPath, before, {
       budgetMs,
-      giveUp: () => this.dapClient?.isStopped() === true || !stillRunning(this.currentRun())
+      accept: (one) => this.isTheGameOf(this.currentRun(), one, projectPath),
+      giveUp: () => {
+        if (this.dapClient?.isStopped() === true) {
+          return true;
+        }
+        const run = this.currentRun();
+        if (run === null || !run.throughEditor) {
+          return !stillRunning(run);
+        }
+        if (asking === null && Date.now() - editorAskedAt >= RUN_POLL_MS) {
+          editorAskedAt = Date.now();
+          asking = this.runStillGoing(run).then((going) => {
+            editorSaysGoing = going;
+          }).finally(() => {
+            asking = null;
+          });
+        }
+        return !editorSaysGoing;
+      }
     });
     const going = this.currentRun();
     if (endpoint !== null && going?.throughEditor === true && going.announcedPid === undefined) {
@@ -31797,7 +31965,7 @@ class GodotServer {
       addon: true,
       budgetMs,
       heldAt: this.dapClient?.whereItStopped() ?? null,
-      running: await this.gameIsUp(),
+      running: endpoint !== null || going !== null && await this.runStillGoing(going),
       withArgs
     });
   }
@@ -31838,7 +32006,8 @@ class GodotServer {
       startedAt,
       exitCode: null,
       throughEditor: true,
-      brokeOn: null
+      brokeOn: null,
+      announcedBefore: alreadyPlaying
     };
     this.activeProcess = played;
     writeEditorRunNote({ projectPath, transcript: transcript.path, startedAt });
@@ -31849,14 +32018,14 @@ class GodotServer {
       scene: scene === null ? "the main scene" : `res://${scene}`,
       refreshedClasses,
       debugPort: readNumber(asParams(JSON.parse(answer.content[0]?.text ?? "{}")), "debugPort"),
-      endedPreviousRun: ended ?? undefined,
+      endedPreviousRun: endedPreviousRun(ended),
       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.`)
+      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." + endedToStartThis(ended)
     });
   }
   drainEditorOutput(game) {
@@ -32072,15 +32241,40 @@ 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;
+  announcedPidOf(run, announced) {
+    if (!run.throughEditor || run.announcedPid !== undefined) {
+      return run.announcedPid;
+    }
+    const before = run.announcedBefore ?? new Set;
+    const fresh = this.allAnnouncedForOurProject(announced ?? runtimesAnnounced().running).filter((one) => !before.has(one.pid));
+    const candidates = fresh.filter((one) => this.playedByOurEditor(one, run.projectPath));
+    const theOne = candidates.length === 1 ? candidates[0] : undefined;
+    if (theOne !== undefined) {
+      run.announcedPid = theOne.pid;
+    }
+    return run.announcedPid;
+  }
+  playedByOurEditor(endpoint, projectPath) {
+    const editor = this.godotBridge.getStatus().editorPid;
+    if (editor === undefined) {
+      return true;
+    }
+    if (endpoint.editorPid !== undefined) {
+      return endpoint.editorPid === editor;
+    }
+    return !runtimeAddonAnnouncesEditors(projectPath ?? this.ownProject);
+  }
+  isTheGameOf(run, endpoint, projectPath) {
+    if (run === null) {
+      return false;
+    }
+    if (run.throughEditor) {
+      return this.playedByOurEditor(endpoint, projectPath);
+    }
+    const editor = this.godotBridge.getStatus().editorPid;
+    return endpoint.editorPid === undefined || endpoint.editorPid !== editor;
   }
   adoptRecordedRun() {
     const record = readRunRecord();
@@ -32210,12 +32404,25 @@ class GodotServer {
     }
     const budgetMs = readPositiveNumber(args, "timeoutMs") ?? WAIT_FOR_RUN_MS;
     const until = Date.now() + budgetMs;
-    while (stillRunning(run) && Date.now() < until) {
+    while (await this.runStillGoing(run) && Date.now() < until) {
       this.drainEditorOutput(run);
       this.drainTranscript(run);
       await delay3(RUN_POLL_MS);
     }
-    return await this.handleGetDebugOutput(args, stillRunning(run) ? budgetMs : undefined);
+    return await this.handleGetDebugOutput(args, await this.runStillGoing(run) ? budgetMs : undefined);
+  }
+  async runStillGoing(run, editorSays) {
+    if (!run.throughEditor) {
+      return stillRunning(run);
+    }
+    const announced = this.announcedPidOf(run);
+    if (announced !== undefined && !alive(announced)) {
+      return false;
+    }
+    if (announced !== undefined && editorSays === undefined) {
+      return stillRunning(run);
+    }
+    return runIsUp(run, editorSays === undefined ? (await this.editorPlayingState())?.playing ?? null : editorSays);
   }
   async handleGetDebugOutput(args, waitedMs) {
     await this.pickUpWhatTheEditorIsPlaying();
@@ -32225,7 +32432,8 @@ class GodotServer {
     }
     this.drainEditorOutput(run);
     this.drainTranscript(run);
-    if (run.endedUnwatched !== true && !stillRunning(run)) {
+    const going = await this.runStillGoing(run);
+    if (run.endedUnwatched !== true && !going) {
       run.log.finish();
       run.endedUnwatched = run.exitCode === null;
     }
@@ -32236,12 +32444,13 @@ class GodotServer {
       contains: readNonEmptyString(args, "contains"),
       limit: readPositiveNumber(args, "limit") ?? 200
     });
-    const hold = await this.holdOf(run);
+    const hold = await this.holdOf(run, going);
     const wanted = readBoolean(args, "cpu") ?? false;
-    const cpuSeconds = wanted && run.pid !== null && stillRunning(run) ? await cpuSecondsOf(run.pid) : undefined;
+    const processToAsk = run.pid ?? this.announcedPidOf(run) ?? null;
+    const cpuSeconds = wanted && processToAsk !== null && stillRunning(run) ? await cpuSecondsOf(processToAsk) : undefined;
     const notes = [];
     if (wanted && cpuSeconds === undefined && stillRunning(run)) {
-      notes.push(run.pid === null ? "cpu was asked for and there is no process to ask: the editor is playing this run and holds it, so nothing here has its process id. editor_run start without a connected editor, or with args, starts the game here instead and that run answers cpuSeconds." : "cpu was asked for and this platform would not say what the run has used.");
+      notes.push(processToAsk === null ? "cpu was asked for and there is no process to ask: the editor is playing this run and holds it, and the game announced no runtime, so nothing here has its process id. A game with the runtime addon announces one; editor_run start without a connected editor, or with args, starts the game here instead and that run answers cpuSeconds either way." : "cpu was asked for and this platform would not say what the run has used.");
     }
     if (waitedMs !== undefined) {
       notes.push(`The wait of ${waitedMs}ms ran out and the run is still going, so this is what it had printed by then rather than everything it will print. editor_run wait again to keep waiting.`);
@@ -32265,10 +32474,10 @@ class GodotServer {
       notes.push(`Everything this run has printed is in ${run.transcript}, uncapped and still being written. Read it for output, not for whether the run is alive: a transcript that stops growing is a run between prints. running above is asked of the operating system while there is a process to ask about, and for an editor-played run that announced no runtime it is the editor's answer instead, which can lag after the game has gone.`);
     }
     return this.jsonTextResponse({
-      running: stillRunning(run),
+      running: going,
       exitCode: run.exitCode,
       through: run.throughEditor ? "editor" : "gdharness",
-      pid: run.pid,
+      pid: run.pid ?? this.announcedPidOf(run) ?? null,
       errors: run.log.count("error"),
       warnings: run.log.count("warning"),
       clean: run.consoleLost === true ? undefined : run.log.count("error") === 0,
@@ -32294,18 +32503,19 @@ class GodotServer {
     }
     this.drainEditorOutput(stopped);
     this.drainTranscript(stopped);
+    const wasRunning = await this.runStillGoing(stopped);
     this.logDebug("Stopping the running game");
     await this.endActiveGame("editor_run stop");
     return this.jsonTextResponse({
       stopped: true,
       through: stopped.throughEditor ? "editor" : "gdharness",
-      endedPid: stopped.pid,
-      exitedBeforeStop: stopped.exitCode !== null,
+      endedPid: stopped.pid ?? this.announcedPidOf(stopped) ?? null,
+      exitedBeforeStop: stopped.exitCode !== null || !wasRunning,
       exitCode: stopped.exitCode,
       errors: stopped.log.count("error"),
       warnings: stopped.log.count("warning"),
       clean: stopped.log.count("error") === 0,
-      note: stopped.throughEditor ? "The editor was asked to stop the scene it is playing. Anything that game started for itself, with OS.create_process or otherwise, is not the editor's to stop and is still running." : "The process named under endedPid was ended. Anything that game started for itself, with OS.create_process or otherwise, is a separate process and is still running.",
+      note: !wasRunning ? "This run was over before the stop, so nothing was ended here: editor_output has what it printed and how it ended. Anything that game started for itself, with OS.create_process or otherwise, is a separate process and may still be running." : stopped.throughEditor ? "The editor was asked to stop the scene it is playing. Anything that game started for itself, with OS.create_process or otherwise, is not the editor's to stop and is still running." : "The process named under endedPid was ended. Anything that game started for itself, with OS.create_process or otherwise, is a separate process and is still running.",
       entries: forAnswer(stopped.log.select({ severity: "warning", sinceLastCall: false, limit: 200 }).entries)
     });
   }
@@ -32456,27 +32666,27 @@ class GodotServer {
     const override = Number.parseInt(envValue("GDHARNESS_RUNTIME_TIMEOUT_MS") ?? "", 10);
     return Number.isInteger(override) && override > 0 ? override : 1e4;
   }
-  knownHoldOn(endpoint) {
+  knownHoldOn(endpoint, announced) {
     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()) {
+    if (this.announcedPidOf(run, announced) !== endpoint.pid || !session.holdIsKnown()) {
       return null;
     }
     return session.whereItStopped();
   }
-  async holdOf(run) {
-    if (!run.throughEditor || !stillRunning(run)) {
+  async holdOf(run, going) {
+    if (!run.throughEditor || !(going ?? await this.runStillGoing(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();
+    const its = this.announcedPidOf(run);
+    const endpoint = its === undefined ? undefined : runtimesAnnounced().running.find((one) => one.pid === its);
     if (endpoint === undefined) {
       return {
         heldAt: undefined,
@@ -32501,13 +32711,13 @@ class GodotServer {
     return { heldAt: undefined, heldUnknown: true, heldNote: reply.message };
   }
   async handleRuntimeCommand(command, args, timeoutMs = this.runtimeTimeoutMs()) {
-    const { op: _op, projectPath, ...params } = asParams(args);
+    const { op: _op, projectPath, pid, ...params } = asParams(args);
     const announced = runtimesAnnounced();
-    const choice = chooseRuntime(announced.running, typeof projectPath === "string" ? projectPath : this.ownProject ?? undefined, announced.unspoken);
+    const choice = chooseRuntime(announced.running, typeof projectPath === "string" ? projectPath : this.ownProject ?? undefined, announced.unspoken, typeof pid === "number" ? pid : undefined);
     if ("problem" in choice) {
       return this.createErrorResponse(choice.problem);
     }
-    const held = this.knownHoldOn(choice.endpoint);
+    const held = this.knownHoldOn(choice.endpoint, announced.running);
     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",
@@ -32569,7 +32779,7 @@ class GodotServer {
     const includeHidden = readBoolean(args, "includeHidden");
     return await this.handleRuntimeCommand("find_nodes", {
       ...filters,
-      projectPath: args["projectPath"],
+      ...whichGame(args),
       root: readNonEmptyString(args, "nodePath") ?? "/root",
       limit: readPositiveNumber(args, "limit") ?? 100,
       ...property === undefined ? {} : { property },
@@ -32580,18 +32790,18 @@ class GodotServer {
     if (op === "frames") {
       const frames = readPositiveNumber(args, "frames") ?? 1;
       const waited = patienceForFrames(frames, this.runtimeTimeoutMs());
-      return await this.handleRuntimeCommand("wait_frames", { projectPath: args["projectPath"], frames }, waited);
+      return await this.handleRuntimeCommand("wait_frames", { ...whichGame(args), frames }, waited);
     }
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 5000;
     const nodePath = readNonEmptyString(args, "nodePath") ?? "";
     const patience = Math.max(this.runtimeTimeoutMs(), timeoutMs + 5000);
     return op === "signal" ? await this.handleRuntimeCommand("wait_signal", {
-      projectPath: args["projectPath"],
+      ...whichGame(args),
       path: nodePath,
       signal: readString(args, "signal") ?? "",
       timeout_ms: timeoutMs
     }, patience) : await this.handleRuntimeCommand("wait_until", {
-      projectPath: args["projectPath"],
+      ...whichGame(args),
       path: nodePath,
       property: readString(args, "property") ?? "",
       value: args["value"],