gdharness 1.1.57 → 1.1.59

package/build/cli.js

@@ -9155,6 +9155,44 @@ ${line.text}`;
   const { body } = parseBody(null, null, 0, 0, 0);
   return { className, body };
 }
+function indentOf(text) {
+  return /^[ \t]*/.exec(text)?.[0].length ?? 0;
+}
+function enclosingFunction(source, line, code = codeOf(source)) {
+  const lines = code.split(`
+`);
+  const at = lines[line - 1];
+  if (at === undefined) {
+    return null;
+  }
+  const own = FUNC_LINE.exec(at);
+  if (own?.[1] !== undefined) {
+    return own[1];
+  }
+  let indent = indentOf(at);
+  for (let index = line - 2;index >= 0 && indent > 0; index -= 1) {
+    const text = lines[index] ?? "";
+    if (text.trim() === "" || indentOf(text) >= indent) {
+      continue;
+    }
+    indent = indentOf(text);
+    const declared = FUNC_LINE.exec(text);
+    if (declared?.[1] !== undefined) {
+      return declared[1];
+    }
+  }
+  return null;
+}
+function callSitesOf(source, name) {
+  const regions = regionsOf(source);
+  const code = codeOf(source, regions);
+  const lines = new Lines(source);
+  return occurrencesOf(source, name, regions).filter((one) => one.kind === "code" && one.declaredAs === null).map((one) => {
+    const line = lines.positionOf(one.offset).line + 1;
+    const after = code.slice(one.offset + name.length).trimStart();
+    return { line, within: enclosingFunction(source, line, code), called: after.startsWith("(") };
+  });
+}
 function collectEnumValues(text, from, into) {
   const close = text.indexOf("}");
   const inside = text.slice(1, close === -1 ? text.length : close);
@@ -9170,7 +9208,7 @@ function collectEnumValues(text, from, into) {
 function isIdentifier(name) {
   return new RegExp(`^${NAME}$`, "u").test(name) && !KEYWORDS.has(name);
 }
-var IDENTIFIER_START, IDENTIFIER_PART, DECLARING, NAME = "[\\p{L}_][\\p{L}\\p{N}_]*", ANNOTATIONS = "(?:@[\\p{L}_][\\p{L}\\p{N}_]*(?:\\([^)]*\\))?\\s+)*", DECLARATION_LINE, CLASS_NAME_LINE, EXTENDS_LINE, EXTENDS_CLAUSE, KEYWORDS;
+var IDENTIFIER_START, IDENTIFIER_PART, DECLARING, NAME = "[\\p{L}_][\\p{L}\\p{N}_]*", ANNOTATIONS = "(?:@[\\p{L}_][\\p{L}\\p{N}_]*(?:\\([^)]*\\))?\\s+)*", DECLARATION_LINE, CLASS_NAME_LINE, EXTENDS_LINE, EXTENDS_CLAUSE, FUNC_LINE, KEYWORDS;
 var init_gdscript_source = __esm(() => {
   IDENTIFIER_START = /[\p{L}_]/u;
   IDENTIFIER_PART = /[\p{L}\p{N}_]/u;
@@ -9179,6 +9217,7 @@ var init_gdscript_source = __esm(() => {
   CLASS_NAME_LINE = new RegExp(`^${ANNOTATIONS}class_name\\s+(${NAME})`, "u");
   EXTENDS_LINE = new RegExp(`^${ANNOTATIONS}(?:class_name\\s+${NAME}\\s+)?extends\\s`, "u");
   EXTENDS_CLAUSE = /\bextends(?=\s)/u;
+  FUNC_LINE = new RegExp(`^[ \\t]*${ANNOTATIONS}(?:static\\s+)?func\\s+(${NAME})\\s*\\(`, "u");
   KEYWORDS = new Set([
     "and",
     "as",
@@ -18138,7 +18177,12 @@ var init_tool_definitions = __esm(() => {
         profile: {
           type: "boolean",
           ops: ["start"],
-          description: "start: profile the run's GDScript with the engine's own script profiler from its start, for editor_run profile to answer which functions took the time. A run this server starts dials the process that keeps it as its debugger, on loopback, with breakpoints and error breaks skipped so it never stops to wait; a game the editor plays is profiled through the editor's debugger session. Needs an engine built with debugging, which the editor binary is and a release export template is not. Default false."
+          description: "start: profile the run's GDScript with the engine's own script profiler from its start, for editor_run profile to answer which functions took the time. A run this server starts dials the process that keeps it as its debugger, on loopback, with breakpoints and error breaks skipped so it never stops to wait; a game the editor plays is profiled through the editor's debugger session. Needs an engine built with debugging, which the editor binary is and a release export template is not. The start answers profile.on and, under profile.totals, how the numbers will arrive. Default false."
+        },
+        callersOf: {
+          type: "string",
+          ops: ["profile"],
+          description: "profile: also answer, under callers, where the project's scripts name this function in code: its name, or Class.name for the functions of one class. Each place has its script, line, the named function it is written in (within), whether the function is called there or passed on as a Callable (called), and the profile's calls, self and total milliseconds for the function it is in, those taking the most time first, forty at most. Found by name in the source, since the engine's profiler records nothing about who made a call, so a method of the same name on another class is listed too and a call made through a string is not."
         },
         limit: {
           type: "integer",
@@ -18174,7 +18218,7 @@ var init_tool_definitions = __esm(() => {
         },
         wait: { summary: "wait for the run to end, then answer as editor_output does", requires: [] },
         profile: {
-          summary: "where the run spends its time by GDScript function, while it runs or after it ended: per function its script, the function (Class.name when the script declares a class_name), the line its body's first statement is on, calls, and self and total milliseconds, sorted by self time, with functionsCounted, scriptMs (the self time of them all) and coveredMs. complete is true when the engine's own totals arrived, which it sends only when the profiler is switched off: the runtime addon does that as a game quits, so a scene that does its work in _ready and quits is covered whole; otherwise the answer is the frames summed so far and the note says what that misses. Self time counts a call into the engine's own methods as the caller's, and a function the profiler started inside is left out, since its time would be counted from the engine's start. A run started with profile: true is profiled from its start. A game the editor plays that was not is profiled from the moment this is asked, and the answer says so; a run this server started without it is refused, since its debugger is fixed as it starts",
+          summary: "where the run spends its time by GDScript function, while it runs or after it ended: per function its script, the function (Class.name when the script declares a class_name), the line its body's first statement is on, for a lambda the named function it is written in (within), calls, and self and total milliseconds, sorted by self time, with functionsCounted, scriptMs (the self time of them all) and coveredMs. complete is true when the engine's own totals arrived, which it sends only when the profiler is switched off: the runtime addon does that as a game quits, so a scene that does its work in _ready and quits is covered whole; otherwise the answer is the frames summed so far and the note says what that misses. Self time counts a call into the engine's own methods as the caller's, and a function the profiler started inside is left out, since its time would be counted from the engine's start. The milliseconds are time passed while the function ran, not processor time given to it, so they grow when other processes compete for the processor: compare two profiles taken under the same load. A run started with profile: true is profiled from its start. A game the editor plays that was not is profiled from the moment this is asked, and the answer says so; a run this server started without it is refused, since its debugger is fixed as it starts",
           requires: []
         }
       },
@@ -18392,7 +18436,10 @@ var init_tool_definitions = __esm(() => {
           summary: "what one property reads on a node, or through the objects it holds, refusing a name nothing along the way has",
           requires: ["nodePath", "property"]
         },
-        metrics: { summary: "frame time, memory, draw calls and the rest", requires: [] }
+        metrics: {
+          summary: "frame time, memory, draw calls and the rest. frame_time is the mean wall time of a frame over the last frames_timed frames (up to 120, timed by the game itself, physics and the wait for the display included), frame_time_max the slowest of them, both in seconds and null before a frame has passed; vsync says whether a frame waits for the display, and max_fps is the game's frame-rate cap, 0 for none. fps, process_time_max and physics_time are the engine's monitors, which it sets once a second: the frames counted in the last second, and the slowest process and physics step in it, so they trail a change by up to a second and the last two are a worst case rather than the frame. The memory, object and render counts are read as asked",
+          requires: []
+        }
       },
       defaultOperation: "tree"
     },
@@ -42261,6 +42308,13 @@ function readProfileFile(path) {
     return null;
   }
 }
+function frameFunctionsFor(queued) {
+  return Math.max(64, queued - QUEUE_HEADROOM);
+}
+function queuedMessagesOf(projectGodot) {
+  const set = projectGodot === null ? undefined : parseProjectGodot(projectGodot)["network"]?.[QUEUE_SETTING];
+  return typeof set === "number" && Number.isInteger(set) && set > 0 ? set : QUEUE_DEFAULT;
+}
 function signatureParts(signature) {
   const parts = signature.split("::");
   if (parts.length < 3) {
@@ -42270,8 +42324,18 @@ function signatureParts(signature) {
   const line = Number(parts.at(-2));
   return { script: parts.slice(0, -2).join("::"), line: Number.isFinite(line) ? line : 0, function: name };
 }
-function profiledFunctions(totals, limit) {
-  const rows = Object.entries(totals.functions).filter(([, sum]) => sum.calls > 0).map(([signature, sum]) => {
+function profiledFunctions(totals, limit, sourceOf = () => null) {
+  const rows = rowsOf(totals);
+  const scriptMs = ms(Object.values(totals.functions).reduce((sum, one) => sum + (one.calls > 0 ? one.selfSeconds : 0), 0));
+  return {
+    functions: rows.slice(0, limit).map((row) => placedLambda(row, sourceOf)),
+    omitted: Math.max(0, rows.length - limit),
+    scriptMs,
+    counted: rows.length
+  };
+}
+function rowsOf(totals) {
+  return Object.entries(totals.functions).filter(([, sum]) => sum.calls > 0).map(([signature, sum]) => {
     const parts = signatureParts(signature);
     return {
       script: parts.script,
@@ -42282,17 +42346,41 @@ function profiledFunctions(totals, limit) {
       totalMs: ms(sum.totalSeconds)
     };
   }).sort((a, b) => b.selfMs - a.selfMs || b.totalMs - a.totalMs || a.function.localeCompare(b.function));
-  const scriptMs = ms(Object.values(totals.functions).reduce((sum, one) => sum + (one.calls > 0 ? one.selfSeconds : 0), 0));
-  return {
-    functions: rows.slice(0, limit),
-    omitted: Math.max(0, rows.length - limit),
-    scriptMs,
-    counted: rows.length
-  };
 }
-var ms = (seconds) => Math.round(seconds * 1e6) / 1000;
+function bareName(fn) {
+  return fn.slice(fn.lastIndexOf(".") + 1);
+}
+function placedLambda(row, sourceOf) {
+  if (!row.function.endsWith("(lambda)")) {
+    return row;
+  }
+  const source = sourceOf(row.script);
+  const within = source === null ? null : enclosingFunction(source, row.line);
+  return within === null ? row : { ...row, within };
+}
+function callersOf(totals, name, scripts) {
+  const rows = rowsOf(totals);
+  const bare = bareName(name);
+  const target = rows.filter((row) => name.includes(".") ? row.function === name : bareName(row.function) === bare);
+  const sites = [];
+  for (const [script, source] of scripts) {
+    for (const site of callSitesOf(source, bare)) {
+      const within = site.within === null ? undefined : rows.find((row) => row.script === script && bareName(row.function) === site.within);
+      sites.push({
+        script,
+        ...site,
+        ...within === undefined ? {} : { withinCalls: within.calls, withinSelfMs: within.selfMs, withinTotalMs: within.totalMs }
+      });
+    }
+  }
+  sites.sort((a, b) => (b.withinTotalMs ?? -1) - (a.withinTotalMs ?? -1) || a.script.localeCompare(b.script) || a.line - b.line);
+  return { target, sites: sites.slice(0, CALL_SITES), omitted: Math.max(0, sites.length - CALL_SITES) };
+}
+var QUEUE_SETTING = "limits/debugger/max_queued_messages", QUEUE_DEFAULT = 2048, QUEUE_HEADROOM = 512, UNNAMED_PREFIX = "#", ms = (seconds) => Math.round(seconds * 1e6) / 1000, CALL_SITES = 40;
 var init_script_profile = __esm(() => {
+  init_gdscript_source();
   init_godot_variant();
+  init_resources();
 });
 
 // src/server.ts
@@ -42425,13 +42513,19 @@ function playOf(answer) {
   const editorPid = readNumber(answer, "editorPid");
   return play === undefined || editorPid === undefined ? null : { play, editorPid };
 }
-function runIsUp(run, editorSays, now = Date.now()) {
+function playedSince(run, playing) {
+  return run.throughEditor && run.play !== undefined && playing !== null && (playing.play !== run.play.play || playing.editorPid !== run.play.editorPid);
+}
+function runIsUp(run, editorSays, editorPlay = null, now = Date.now()) {
   if (run?.throughEditor !== true) {
     return stillRunning(run);
   }
   if (typeof run.endedHere === "string") {
     return false;
   }
+  if (playedSince(run, editorPlay)) {
+    return false;
+  }
   if (run.announcedPid !== undefined && !alive(run.announcedPid)) {
     return false;
   }
@@ -42975,6 +43069,63 @@ function aboveTheRunner(entry) {
     ]
   };
 }
+function runtimeAddonRegistered(projectPath) {
+  const registered = inspectProject(projectPath);
+  return registered.runtimeAutoloadPath !== null || registered.runtimeLoaderAutoload !== null;
+}
+function profileOnStart(profiled, through, runtimeAddon) {
+  if (!profiled) {
+    return;
+  }
+  const debuggerOf = through === "editor" ? "the editor's debugger session" : "the process that keeps the run";
+  return {
+    on: true,
+    totals: `On from the game's start, through ${debuggerOf}. editor_run profile answers at any time: each frame is added as it ends, so a scene still inside a long _ready shows nothing until that returns, and the engine's own totals replace the sum when the game quits` + (runtimeAddon ? "." : ", which takes the runtime addon: without it the frames that arrived before the exit are what is kept.")
+  };
+}
+function profileFrameFunctions(projectPath) {
+  let projectGodot = null;
+  if (projectPath !== null) {
+    try {
+      projectGodot = readFileSync23(join26(projectPath, "project.godot"), "utf8");
+    } catch {}
+  }
+  return frameFunctionsFor(queuedMessagesOf(projectGodot));
+}
+function playedCap(held) {
+  const frameFunctions = readPositiveNumber(held, "frameFunctions");
+  if (frameFunctions === undefined) {
+    return {};
+  }
+  return {
+    frameFunctions,
+    cappedFrames: readNonNegativeNumber(held, "cappedFrames") ?? 0,
+    totalCapped: readBoolean(held, "totalCapped") === true
+  };
+}
+function projectSourceOf(projectPath) {
+  const read = new Map;
+  return (script) => {
+    if (!read.has(script)) {
+      const inside = resolveWithinProject(projectPath, script);
+      let source = null;
+      if (inside.ok) {
+        try {
+          source = readFileSync23(inside.absolutePath, "utf8");
+        } catch {}
+      }
+      read.set(script, source);
+    }
+    return read.get(script) ?? null;
+  };
+}
+function projectScripts(projectPath) {
+  const scripts = [];
+  eachScript(projectPath, (script, source) => {
+    scripts.push([script, source]);
+  });
+  return scripts;
+}
 function profileAnswer(reading, limit) {
   const { totals } = reading;
   if (totals === null) {
@@ -42986,16 +43137,19 @@ function profileAnswer(reading, limit) {
       note: reading.running ? "The game has not connected to the profiler yet: it dials its debugger once, as it starts, before any script runs. Ask again in a moment." : "The game never connected to the profiler, so nothing was measured. A game dials its debugger once, as it starts, and an engine built without debugging (a release export template) refuses to: profiling needs the editor binary or a debug template."
     };
   }
-  const table = profiledFunctions(totals, limit);
+  const table = profiledFunctions(totals, limit, reading.sourceOf);
   const notes = [];
   const addonNote = reading.runtimeAddon ? "" : " This project has no gdharness runtime addon, which switches the profiler off as the game quits so the engine sends its totals: setup installs it.";
-  if (totals.complete) {} else if (reading.running) {
+  if (totals.complete) {} else if (reading.running && totals.frames === 0) {
+    notes.push(`The profiler is on and the game has not finished its first frame yet: a frame is sent as it ends, so a scene doing its work in _ready shows nothing until that returns, and the engine's own totals arrive when the game quits.${addonNote}`);
+  } else if (reading.running) {
     notes.push(`The run is still going, so these are the ${totals.frames === 1 ? "one frame" : `${totals.frames} frames`} summed so far${reading.through === "gdharness" ? ", written at most half a second behind" : ""}.`);
   } else if (totals.frames === 0) {
     notes.push(`The game connected and ended before a frame of the profile reached ${reading.through === "editor" ? "the editor" : "this server"}: the engine sends its totals only when the profiler is switched off, and stops sending as it exits without emptying what it has queued.${addonNote}`);
   } else {
     notes.push(`These are the ${totals.frames === 1 ? "one frame" : `${totals.frames} frames`} that arrived, summed, without the engine's own totals, so what the game did after the last of them is not in it: the engine sends its totals only when the profiler is switched off, and stops sending as it exits without emptying what it has queued.${addonNote}`);
   }
+  notes.push(...cappedNotes(totals));
   if (totals.unreadable > 0) {
     notes.push(`${totals.unreadable} message${totals.unreadable === 1 ? "" : "s"} from the game could not be read, so the totals have that many gaps.`);
   }
@@ -43010,9 +43164,36 @@ function profileAnswer(reading, limit) {
     functionsCounted: table.counted,
     omitted: table.omitted > 0 ? table.omitted : undefined,
     functions: table.functions,
+    callers: reading.callersOf === undefined ? undefined : callersAnswer(totals, reading.callersOf),
     note: notes.length > 0 ? notes.join(" ") : undefined
   };
 }
+function cappedNotes(totals) {
+  const notes = [];
+  const most = totals.frameFunctions;
+  const why = `${most} is kept below the game's debugger queue (network/limits/debugger/max_queued_messages), which drops the message naming a function when one frame names more than it holds, and a function whose name is dropped is never named afterwards.`;
+  if (most !== undefined && totals.complete && totals.totalCapped === true) {
+    notes.push(`The engine's totals carried the most functions the profiler asks for, ${most}, so the functions with the least time are not in them: ${why}`);
+  } else if (most !== undefined && !totals.complete && (totals.cappedFrames ?? 0) > 0) {
+    const capped = totals.cappedFrames ?? 0;
+    notes.push(`${capped === totals.frames ? capped === 1 ? "The one frame" : `All ${capped} frames` : `${capped} of the ${totals.frames} frames`} carried the most functions the profiler asks for in one, ${most}, so the functions with the least time in ${capped === 1 ? "it" : "them"} are not counted there: ${why}`);
+  }
+  const unnamed = Object.entries(totals.functions).filter(([name, sum]) => name.startsWith(UNNAMED_PREFIX) && sum.calls > 0).length;
+  if (unnamed > 0) {
+    notes.push(`${unnamed === 1 ? "One function" : `${unnamed} functions`} arrived without ${unnamed === 1 ? "its name" : "their names"}, shown as ${UNNAMED_PREFIX} and the number the engine gave ${unnamed === 1 ? "it" : "them"}: the engine names a function once, as it first appears, and the game's debugger queue was full when that message was sent. They are script functions of the game; which ones cannot be recovered from this profile.`);
+  }
+  return notes;
+}
+function callersAnswer(totals, asked) {
+  const found = callersOf(totals, asked.name, asked.scripts());
+  return {
+    of: asked.name,
+    rows: found.target,
+    sites: found.sites,
+    omitted: found.omitted > 0 ? found.omitted : undefined,
+    note: found.sites.length === 0 ? `No script in the project names ${asked.name} in code, outside its declaration: a call made through a string, such as call("name"), is not found by name.` : found.target.length === 0 ? `${CALLERS_FOUND_BY_NAME} The profile counts no call of ${asked.name}, so these places are where it would be called from.` : CALLERS_FOUND_BY_NAME
+  };
+}
 function foldedEntriesAnswer(log) {
   const problems = log.selectFolded({
     severity: "warning",
@@ -43586,7 +43767,7 @@ class GodotServer {
     return this.saying(answer, {
       update_available: {
         ...notice,
-        what_to_do: "Tell the user a newer gdharness is out, with what changed. Run the upgrade command " + "only with their agreement: a yes now, or a standing instruction of theirs, such as " + "their CLAUDE.md, to upgrade on every release. Without either, offer it and wait, since " + "it replaces the addons in their project. Afterwards the MCP server has to be " + "reconnected and the editor restarted with editor_launch restart."
+        what_to_do: "Tell the user a newer gdharness is out, with what changed. Run the upgrade command " + "only with their agreement: a yes now, or a standing instruction of theirs, such as one " + "in their AGENTS.md or CLAUDE.md, to upgrade on every release. Without either, offer it " + "and wait, since it replaces the addons in their project. Afterwards the MCP server has " + "to be reconnected and the editor restarted with editor_launch restart."
       }
     });
   }
@@ -45822,6 +46003,7 @@ class GodotServer {
       pid: started.pid,
       arguments: cmdArgs,
       transcript: started.transcript,
+      profile: profileOnStart(profiled, "gdharness", runtimeAddonRegistered(project.value.path)),
       refreshedClasses: refreshed.value,
       ...scanWaitAnswer(scanned),
       savesNote: asked.value.savesIn !== undefined && savesStayPut() ? SAVES_NOT_MOVED_NOTE : undefined,
@@ -45948,7 +46130,10 @@ class GodotServer {
     const breakpoints = await this.dapHoldingBreakpointsOf(projectPath).reapplyBreakpoints();
     this.logDebug(`Breakpoints were sent again after ${Date.now() - sendingFrom}ms`);
     if (profiled) {
-      const armed = await this.handleViaBridge("profile_start", { arm: true });
+      const armed = await this.handleViaBridge("profile_start", {
+        arm: true,
+        frameFunctions: profileFrameFunctions(projectPath)
+      });
       if (armed.isError === true) {
         return this.profilerRefusal(armed);
       }
@@ -45961,6 +46146,7 @@ class GodotServer {
     const transcript = openTranscript(startedAt);
     closeSync2(transcript.fd);
     const playAnswer = asParams(JSON.parse(answer.content[0]?.text ?? "{}"));
+    const which = playOf(playAnswer);
     const played = {
       pid: null,
       log,
@@ -45973,11 +46159,11 @@ class GodotServer {
       throughEditor: true,
       brokeOn: null,
       announcedBefore: alreadyPlaying,
-      seenPlaying: readBoolean(playAnswer, "playing") === true
+      seenPlaying: readBoolean(playAnswer, "playing") === true,
+      ...which === null ? {} : { play: which }
     };
     this.activeProcess = played;
     this.watchThePlayedConsole();
-    const which = playOf(playAnswer);
     writeEditorRunNote({
       projectPath,
       transcript: transcript.path,
@@ -45989,6 +46175,7 @@ class GodotServer {
       started: true,
       through: "editor",
       scene: scene === null ? "the main scene" : `res://${scene}`,
+      profile: profileOnStart(profiled, "editor", runtimeAddonRegistered(projectPath)),
       refreshedClasses,
       ...scanWaitAnswer(scanned),
       debugPort: readNumber(playAnswer, "debugPort"),
@@ -46371,9 +46558,14 @@ class GodotServer {
       return;
     }
     const going = this.activeProcess;
-    const givesWay = going !== null && !stillRunning(going) && typeof going.endedHere === "string";
+    const asked = going?.throughEditor === true && going.play !== undefined ? await this.editorPlayingState() : null;
+    const superseded = going !== null && asked !== null && playedSince(going, asked.play);
+    if (superseded && stillRunning(going)) {
+      going.endedUnwatched = true;
+    }
+    const givesWay = going !== null && (superseded || !stillRunning(going) && typeof going.endedHere === "string");
     if (going !== null && !givesWay) {
-      if (going.throughEditor && going.consoleLost === true && (await this.editorPlayingState())?.playing) {
+      if (going.throughEditor && going.consoleLost === true && (asked ?? await this.editorPlayingState())?.playing) {
         try {
           await this.dap().connect();
           going.log.append("stdout", `[gdharness] the debug adapter was reconnected here
@@ -46384,7 +46576,7 @@ class GodotServer {
       }
       return;
     }
-    const playing = await this.editorPlayingState();
+    const playing = asked ?? await this.editorPlayingState();
     if (playing?.playing !== true) {
       return;
     }
@@ -46407,7 +46599,8 @@ class GodotServer {
       exitSignal: null,
       throughEditor: true,
       brokeOn: null,
-      pickedUpPlaying: true
+      pickedUpPlaying: true,
+      ...playing.play === null ? {} : { play: playing.play }
     };
     this.activeProcess = picked;
     this.watchThePlayedConsole();
@@ -46711,11 +46904,19 @@ class GodotServer {
       return this.createErrorResponse(this.nothingOfOursIsRunning());
     }
     const limit = readPositiveNumber(args, "limit") ?? PROFILE_FUNCTIONS;
+    const callersName = readString(args, "callersOf");
+    if (callersName !== undefined && !callersName.split(".").every(isIdentifier)) {
+      return this.createErrorResponse(`callersOf takes a function's name, or Class.name for the functions of one class, and ${JSON.stringify(callersName)} is neither.`, ["editor_run profile names each function as it answers; pass one of those"]);
+    }
     const going = await this.runStillGoing(run);
-    const registered = run.projectPath === null ? null : inspectProject(run.projectPath);
-    const runtimeAddon = registered !== null && (registered.runtimeAutoloadPath !== null || registered.runtimeLoaderAutoload !== null);
+    const projectPath = run.projectPath;
+    const fromProject = projectPath === null ? { runtimeAddon: false } : {
+      runtimeAddon: runtimeAddonRegistered(projectPath),
+      sourceOf: projectSourceOf(projectPath),
+      ...callersName === undefined ? {} : { callersOf: { name: callersName, scripts: () => projectScripts(projectPath) } }
+    };
     if (run.throughEditor) {
-      return await this.profileOfThePlayedGame(going, runtimeAddon, limit);
+      return await this.profileOfThePlayedGame(going, projectPath, fromProject, limit);
     }
     const record = run.projectPath === null ? null : readRunRecord(run.projectPath);
     const path = record !== null && record.pid === run.pid ? record.profile : undefined;
@@ -46734,10 +46935,10 @@ class GodotServer {
       running: going,
       totals,
       coveredMs: totals?.lastFrameAt == null ? 0 : totals.lastFrameAt - totals.startedAt,
-      runtimeAddon
+      ...fromProject
     }, limit));
   }
-  async profileOfThePlayedGame(going, runtimeAddon, limit) {
+  async profileOfThePlayedGame(going, projectPath, fromProject, limit) {
     const read = await this.handleViaBridge("profile_read", {});
     if (read.isError === true) {
       return this.profilerRefusal(read);
@@ -46749,7 +46950,9 @@ class GodotServer {
           "editor_run start with profile: true plays it again with the profiler on from its start"
         ]);
       }
-      const started = await this.handleViaBridge("profile_start", {});
+      const started = await this.handleViaBridge("profile_start", {
+        frameFunctions: profileFrameFunctions(projectPath)
+      });
       if (started.isError === true) {
         return this.profilerRefusal(started);
       }
@@ -46772,6 +46975,7 @@ class GodotServer {
       frames: readNonNegativeNumber(held, "frames") ?? 0,
       complete: readBoolean(held, "complete") === true,
       unreadable: 0,
+      ...playedCap(held),
       functions: Object.fromEntries(Object.entries(functions).map(([signature, sum]) => {
         const [calls, self, total] = Array.isArray(sum) ? sum : [];
         return [
@@ -46789,7 +46993,7 @@ class GodotServer {
       running: going,
       totals,
       coveredMs: readNonNegativeNumber(held, "coveredMs") ?? 0,
-      runtimeAddon
+      ...fromProject
     }, limit));
   }
   async firstProfiledFrame() {
@@ -46848,11 +47052,13 @@ class GodotServer {
     if (announced !== undefined && editorSays === undefined) {
       return stillRunning(run);
     }
-    const said = editorSays === undefined ? (await this.editorPlayingState())?.playing ?? null : editorSays;
-    if (said === true) {
+    const state = editorSays === undefined ? await this.editorPlayingState() : undefined;
+    const said = state === undefined ? editorSays ?? null : state?.playing ?? null;
+    const play = state?.play ?? null;
+    if (said === true && !playedSince(run, play)) {
       run.seenPlaying = true;
     }
-    return runIsUp(run, said);
+    return runIsUp(run, said, play);
   }
   async untilTheExitIsRecorded(run) {
     const until = Date.now() + EXIT_REPORTED_WITHIN_MS;
@@ -48058,7 +48264,7 @@ async function runGodotServer() {
   const server = new GodotServer;
   await server.run();
 }
-var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run4, __dirname2, GREETING_WAIT_MS = 1e4, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, PLAY_STARTS_WITHIN_MS = 30000, STOP_WAIT_MS = 1e4, KEEPER_ANSWER_MS = 15000, EXIT_REPORTED_WITHIN_MS = 2000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, MOST_GROUPS = 20, VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, CONSOLE_WATCH_MS = 250, BOUNDARY_WAIT_MS = 2000, HANDOVER_MS, HANDOVER_POLL_MS = 250, CACHE_WRITE_MS = 2000, SCAN_WAIT_MS = 30000, STREAMS_GRACE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, SCAN_SETTLED_MS = 500, REIMPORT_TIMEOUT_MS = 300000, AUDIO_BUS_OPS, STALLED_AFTER_MS = 30000, TEST_HEARTBEAT_MS = 20000, DEPENDED_FAILED = "Failed to compile depended scripts", WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/", PROFILE_FUNCTIONS = 30, PROFILER_ON_MS = 3000, MOST_ENGINE_ENTRIES = 200, ERROR_ASSERT = "GdUnitGodotErrorAssertImpl.gd", EXTERNAL_MEMBER = 'Could not resolve external class member "';
+var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run4, __dirname2, GREETING_WAIT_MS = 1e4, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, PLAY_STARTS_WITHIN_MS = 30000, STOP_WAIT_MS = 1e4, KEEPER_ANSWER_MS = 15000, EXIT_REPORTED_WITHIN_MS = 2000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, MOST_GROUPS = 20, VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, CONSOLE_WATCH_MS = 250, BOUNDARY_WAIT_MS = 2000, HANDOVER_MS, HANDOVER_POLL_MS = 250, CACHE_WRITE_MS = 2000, SCAN_WAIT_MS = 30000, STREAMS_GRACE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, SCAN_SETTLED_MS = 500, REIMPORT_TIMEOUT_MS = 300000, AUDIO_BUS_OPS, STALLED_AFTER_MS = 30000, TEST_HEARTBEAT_MS = 20000, DEPENDED_FAILED = "Failed to compile depended scripts", WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/", PROFILE_FUNCTIONS = 30, PROFILER_ON_MS = 3000, CALLERS_FOUND_BY_NAME = "Found by name in the project's scripts, since the engine's profiler counts calls and time per function and records nothing about who made them: a method of the same name on another class is listed too. Each place carries the profile's numbers for the function it is written in.", MOST_ENGINE_ENTRIES = 200, ERROR_ASSERT = "GdUnitGodotErrorAssertImpl.gd", EXTERNAL_MEMBER = 'Could not resolve external class member "';
 var init_server3 = __esm(() => {
   init_mcp();
   init_stdio2();
@@ -48079,6 +48285,7 @@ var init_server3 = __esm(() => {
   init_engine_run();
   init_errors();
   init_game_log();
+  init_gdscript_source();
   init_godot_bridge();
   init_godot_path();
   init_headless();
@@ -49189,7 +49396,7 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
 | What every label on a screen says | \`runtime_inspect tree\` with \`properties\` naming \`text\`, which reads it off every node that has one; \`includeProperties\` is every stored property of every node and ran to seventy-six thousand characters for one row |
 | Whether this engine has a method or property, and what it takes | \`editor_classes info\` with \`member\`, which answers that one member and which class declares it rather than the whole class |
 | Wait for a run to finish | \`editor_run wait\`, never a sleep or a shell loop on the pid: it answers as \`editor_output\` does, once the run is over |
-| Find which GDScript makes a run slow | \`editor_run start\` with \`profile\` set, then \`editor_run profile\`: the engine's own script profiler, per function with calls and self and total milliseconds, by self time, never \`Time.get_ticks_usec()\` laps edited into the game. A scene that does its work in \`_ready\` and quits is covered whole when the runtime autoload is registered, and a game the editor is already playing is profiled from the moment it is asked |
+| Find which GDScript makes a run slow | \`editor_run start\` with \`profile\` set, then \`editor_run profile\`: the engine's own script profiler, per function with calls and self and total milliseconds, by self time, never \`Time.get_ticks_usec()\` laps edited into the game. A scene that does its work in \`_ready\` and quits is covered whole when the runtime autoload is registered, and a game the editor is already playing is profiled from the moment it is asked. \`callersOf\` names where the project's scripts call one function, each place with its function's numbers, since the engine records no callers |
 | End a bench and the workers it opened | \`editor_run stop\` with \`andChildren\`, never a process listing by scene name: it ends every process under the run's, to any depth, that is a game of the project, announced as one or the project's engine run with \`--path\` on it, names them under \`endedChildren\` with what identified each, and leaves and names any other |
 | End a game of the project that no server is holding | \`editor_run stop\` with its \`pid\` from \`editor_status\` \`runtimes\`, never a process kill by hand: it is ended only when it announced itself for the project and its command line is the project's engine run |
 | Play a game without touching the player's saves | \`editor_run start\` with \`savesIn\`, a directory for this run's \`user://\`: the editor plays with its own environment, so a run given one is started by the server, and the answer says under \`savesNote\` when the platform ignores it |

package/build/godot/addons/gdharness_editor/tools/play_tools.gd

@@ -127,7 +127,10 @@ func stop_playing(_args: Dictionary) -> Dictionary:
 	var was_playing: bool = EditorInterface.is_playing_scene()
 	if was_playing:
 		EditorInterface.stop_playing_scene()
-	return {"ok": true, "wasPlaying": was_playing, "playing": EditorInterface.is_playing_scene()}
+	# Known over now rather than at the next frame's look: a play somebody else starts before that
+	# look would otherwise be read as this one still going, and given its number and its console.
+	_was_playing = EditorInterface.is_playing_scene()
+	return {"ok": true, "wasPlaying": was_playing, "playing": _was_playing}
 
 
 ## Restarts the editor, which is how a replaced addon is picked up.