gdharness 1.1.56 → 1.1.57

package/build/cli.js

@@ -7851,30 +7851,66 @@ function reported(entry) {
 }
 function framesCollapsed(detail) {
   const out = [];
-  let pending;
-  for (const line of detail) {
-    const match = FRAME.exec(line);
-    const number = match?.[1];
-    const frame = match?.[2];
-    if (frame !== undefined && pending?.frame === frame && Number(number) === Number(pending.last) + 1) {
-      pending.last = String(number);
+  let at = 0;
+  while (at < detail.length) {
+    const frames = consecutiveFrames(detail, at);
+    if (frames.length === 0) {
+      out.push(detail[at] ?? "");
+      at += 1;
       continue;
     }
-    if (pending !== undefined) {
-      out.push(writtenRun(pending));
-    }
-    pending = number === undefined || frame === undefined ? undefined : { first: number, last: number, frame };
-    if (pending === undefined) {
-      out.push(line);
+    let index = 0;
+    while (index < frames.length) {
+      const cycle = repeatedCycle(frames, index);
+      const first = frames[index];
+      if (cycle === null || first === undefined) {
+        out.push(`[${first?.number ?? ""}] ${first?.frame ?? ""}`);
+        index += 1;
+        continue;
+      }
+      const last = frames[index + cycle.period * cycle.times - 1];
+      const span = `[${first.number}-${last?.number ?? first.number}]`;
+      if (cycle.period === 1) {
+        out.push(`${span} ${first.frame}`);
+      } else {
+        out.push(`${span} these ${cycle.period} frames, ${cycle.times} times over:`);
+        for (const frame of frames.slice(index, index + cycle.period)) {
+          out.push(`  ${frame.frame}`);
+        }
+      }
+      index += cycle.period * cycle.times;
     }
-  }
-  if (pending !== undefined) {
-    out.push(writtenRun(pending));
+    at += frames.length;
   }
   return out;
 }
-function writtenRun(run) {
-  return run.first === run.last ? `[${run.first}] ${run.frame}` : `[${run.first}-${run.last}] ${run.frame}`;
+function consecutiveFrames(detail, at) {
+  const frames = [];
+  for (const line of detail.slice(at)) {
+    const match = FRAME.exec(line);
+    const number = Number(match?.[1]);
+    const frame = match?.[2];
+    const before = frames.at(-1);
+    if (frame === undefined || !Number.isInteger(number) || before !== undefined && number !== before.number + 1) {
+      break;
+    }
+    frames.push({ number, frame });
+  }
+  return frames;
+}
+function repeatedCycle(frames, from) {
+  let best = null;
+  for (let period = 1;period <= LONGEST_CYCLE && from + 2 * period <= frames.length; period += 1) {
+    let length = period;
+    while (from + length < frames.length && frames[from + length]?.frame === frames[from + length - period]?.frame) {
+      length += 1;
+    }
+    const times = Math.floor(length / period);
+    if (times >= 2 && (best === null || period * times > best.period * best.times)) {
+      best = { period, times };
+    }
+  }
+  return best;
 }
 function foldedRepeats(entries) {
   const first = new Map;
@@ -7998,7 +8034,7 @@ function answersTo(entry, severity, contains) {
   const needle = contains.toLowerCase();
   return [entry.text, ...entry.detail].some((line) => line.toLowerCase().includes(needle));
 }
-var HEADLINE, COLOUR_CODE, STREAMS, ADMITTED, FRAME;
+var HEADLINE, COLOUR_CODE, STREAMS, ADMITTED, FRAME, LONGEST_CYCLE = 64;
 var init_game_log = __esm(() => {
   HEADLINE = /^(USER )?(SCRIPT ERROR|SHADER ERROR|ERROR|WARNING):\s?(.*)$/;
   COLOUR_CODE = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
@@ -17707,7 +17743,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "project_test",
-      description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Suites where everything passed are counted rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines; identical engine messages come back once under engineEntries, with times saying how often they were printed, and engineErrors counts every one. The class list is rebuilt first, so a suite written a moment ago is found, and the rebuild's answer is under classes, with the classes each addon declares counted under addedInAddons and changedInAddons rather than named: a class it puts back that the cache had after the last rebuild is named under classes.lostSinceLastRebuild, which is the editor writing its shorter list over the file on every save until restarted. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. On macOS the engine reads user:// off HOME and the run writes where the player keeps theirs, which the answer says under savesNote rather than leaving to be found in a save list. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. A script that does not load stops gdUnit4 before any suite runs: its errors come back in full under scriptErrors, and the scripts that failed only because one they depend on did are listed by path under failedThroughDependency. When they failed on a class whose own script has a parser error, which gdUnit4 never names, that script is checked by the engine and its error comes first under scriptErrors, with the class it declares under declares, and the errors a script has only because that class did not resolve, which the engine reads as Variant, are kept apart under followFromUnresolved. A client that sends a progress token is told as each suite finishes, and at least every twenty seconds through a long one, so an idle limit does not end a long tier. A run that ends without a report, at its timeout or otherwise, names the suites it finished under suitesFinished, the failing ones with their failed cases under suitesFailing, and the one it was in under suiteRunning. When a client cuts a run off, that is kept in the project and the next project_test there carries it under previousRunCut. A run where nothing failed but nodes were left in the tree comes back under warnings, with the count per suite: gdUnit4 decides its verdict on those and keeps them out of its report, so they are read off what it printed. A run whose every case passed is still not called passed when it printed a script error that no case failed on: gdUnit4 fails a case on the script errors its logger sees, and it cannot see a stack overflow, so the cases pass on whatever the faulted calls returned. Those errors come back under uncaughtScriptErrors. One raised inside assert_error(...).is_runtime_error is the test's own and does not count, and none count when the project turns off gdUnit4's report/godot/script_error setting. Needs gdUnit4 under addons/gdUnit4.",
+      description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Suites where everything passed are counted rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines; identical engine messages come back once under engineEntries, with times saying how often they were printed, and engineErrors counts every one. The class list is rebuilt first, so a suite written a moment ago is found, and the rebuild's answer is under classes, with the classes each addon declares counted under addedInAddons and changedInAddons rather than named: a class it puts back that the cache had after the last rebuild is named under classes.lostSinceLastRebuild, which is the editor writing its shorter list over the file on every save until restarted. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. On macOS the engine reads user:// off HOME and the run writes where the player keeps theirs, which the answer says under savesNote rather than leaving to be found in a save list. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. A script that does not load stops gdUnit4 before any suite runs: its errors come back in full under scriptErrors, and the scripts that failed only because one they depend on did are listed by path under failedThroughDependency. When they failed on a class whose own script has a parser error, which gdUnit4 never names, that script is checked by the engine and its error comes first under scriptErrors, with the class it declares under declares, and the errors a script has only because that class did not resolve, which the engine reads as Variant, are kept apart under followFromUnresolved. A client that sends a progress token is told as each suite finishes, and at least every twenty seconds through a long one, so an idle limit does not end a long tier. A run that ends without a report, at its timeout or otherwise, names the suites it finished under suitesFinished, the failing ones with their failed cases under suitesFailing, and the one it was in under suiteRunning. When a client cuts a run off, that is kept in the project and the next project_test there carries it under previousRunCut. A run where nothing failed but nodes were left in the tree comes back under warnings, with the count per suite: gdUnit4 decides its verdict on those and keeps them out of its report, so they are read off what it printed. A run whose every case passed is still not called passed when it printed a script error that no case failed on: gdUnit4 fails a case on the script errors its logger sees, and it cannot see a stack overflow, so the cases pass on whatever the faulted calls returned. Those errors come back under uncaughtScriptErrors, and under engineEntries by index with detailUnder rather than with their backtrace a second time; a backtrace that repeats, as a recursion's does, has each repeated frame or cycle of frames written once with the frames it covers and how many times. One raised inside assert_error(...).is_runtime_error is the test's own and does not count, and none count when the project turns off gdUnit4's report/godot/script_error setting. Needs gdUnit4 under addons/gdUnit4.",
       parameters: {
         projectPath: PROJECT_PATH,
         path: {
@@ -18099,6 +18135,17 @@ var init_tool_definitions = __esm(() => {
           ops: ["check", "wait"],
           description: "check: how long to give the boot before it is called hung. Default 60000. wait: how long to wait for the run to end before answering anyway. Default 600000."
         },
+        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."
+        },
+        limit: {
+          type: "integer",
+          minimum: 1,
+          ops: ["profile"],
+          description: "profile: how many functions to answer with, those with the most self time. Default 30."
+        },
         andChildren: {
           type: "boolean",
           ops: ["stop"],
@@ -18125,7 +18172,11 @@ var init_tool_definitions = __esm(() => {
           summary: "boot headless, quit after a few frames, and report the verdict",
           requires: ["projectPath"]
         },
-        wait: { summary: "wait for the run to end, then answer as editor_output does", requires: [] }
+        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",
+          requires: []
+        }
       },
       defaultOperation: "start"
     },
@@ -18608,7 +18659,7 @@ var init_tool_definitions = __esm(() => {
         says: {
           type: "string",
           ops: ["until"],
-          description: 'until: wait for these words to appear anywhere under nodePath, or anywhere in the game when no nodePath is given, instead of for a property, which is how a panel that rebuilds its labels is waited on at all: the labels are named afresh each redraw and the panel is what stays put. Matched the way runtime_inspect find matches says: case-insensitive, a plain word anywhere in the text, a pattern with * or ? a glob over the whole of it, and alternatives separated by | met by whichever appears first ("*won*|*lost*"); on a node the player can see unless includeHidden says otherwise; a label with a line break is matched with the break in the words, and a backslash followed by n counts as one. Instead of, not as well as: a call carrying this and a property is refused, because they ask about different things and answering one of them silently is how a caller watches a screen believing they are watching a property. It looks every frame while a look is cheap and less often on a screen large enough for a look to cost a real share of a frame, so the game keeps its speed; the answer counts the frames the wait spanned and the looks it took.'
+          description: 'until: wait for these words to appear anywhere under nodePath, or anywhere in the game when no nodePath is given, instead of for a property, which is how a panel that rebuilds its labels is waited on at all: the labels are named afresh each redraw and the panel is what stays put. Matched the way runtime_inspect find matches says: case-insensitive, a plain word anywhere in the text, a pattern with * or ? a glob over the whole of it, and alternatives separated by | met by whichever appears first ("*won*|*lost*"); on a node the player can see unless includeHidden says otherwise; a label with a line break is matched with the break in the words, and a backslash followed by n counts as one. Instead of, not as well as: a call carrying this and a property is refused, because they ask about different things and answering one of them silently is how a caller watches a screen believing they are watching a property. It looks every frame while a look is cheap and less often on a screen large enough for a look to cost a real share of a frame, so the game keeps its speed; the answer counts the frames the wait spanned and the looks it took, and says under looking_ms how long the looks took between them.'
         },
         includeHidden: {
           type: "boolean",
@@ -41767,6 +41818,9 @@ function openTranscript(startedAt) {
   const path = join24(runsDirectory(), `run-${startedAt}.log`);
   return { path, fd: openSync2(path, "a") };
 }
+function profilePath(startedAt) {
+  return join24(runsDirectory(), `run-${startedAt}.profile.json`);
+}
 function noteIsAbout(note, playing) {
   return note.play !== undefined && playing !== null && note.play.play === playing.play && note.play.editorPid === playing.editorPid;
 }
@@ -41866,6 +41920,7 @@ function recordAt(path) {
     projectPath: typeof fields["projectPath"] === "string" ? fields["projectPath"] : "",
     ...typeof fields["servedBy"] === "string" && fields["servedBy"] !== "" ? { servedBy: fields["servedBy"] } : {},
     ...typeof fields["keeper"] === "string" && fields["keeper"] !== "" ? { keeper: fields["keeper"] } : {},
+    ...typeof fields["profile"] === "string" && fields["profile"] !== "" ? { profile: fields["profile"] } : {},
     arguments: Array.isArray(args) ? args.filter((value) => typeof value === "string") : [],
     ...typeof fields["command"] === "string" ? { command: fields["command"] } : {},
     ...typeof fields["exitCode"] === "number" ? { exitCode: fields["exitCode"] } : {},
@@ -42058,7 +42113,10 @@ function ageMs(path, now) {
 }
 function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
   const directory = runsDirectory();
-  const kept = new Set(everyRunRecord().map((record) => record.transcript));
+  const kept = new Set(everyRunRecord().flatMap((record) => [
+    record.transcript,
+    ...record.profile === undefined ? [] : [record.profile]
+  ]));
   let entries;
   try {
     entries = readdirSync9(directory);
@@ -42066,7 +42124,7 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
     return;
   }
   for (const entry of entries) {
-    if (!entry.startsWith("run-") || !entry.endsWith(".log")) {
+    if (!entry.startsWith("run-") || !(entry.endsWith(".log") || entry.endsWith(".profile.json"))) {
       continue;
     }
     const path = join24(directory, entry);
@@ -42186,6 +42244,57 @@ var init_script_origins = __esm(() => {
   RELOADED_AT = /GDScript::reload \((res:\/\/.+):(\d+)\)$/;
 });
 
+// src/godot-variant.ts
+var FLAG_64, MOST_MESSAGE_BYTES;
+var init_godot_variant = __esm(() => {
+  FLAG_64 = 1 << 16;
+  MOST_MESSAGE_BYTES = (8 << 20) + 4;
+});
+
+// src/script-profile.ts
+import { readFileSync as readFileSync22, renameSync as renameSync2, writeFileSync as writeFileSync17 } from "node:fs";
+function readProfileFile(path) {
+  try {
+    const parsed = JSON.parse(readFileSync22(path, "utf8"));
+    return typeof parsed === "object" && typeof parsed.connected === "boolean" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function signatureParts(signature) {
+  const parts = signature.split("::");
+  if (parts.length < 3) {
+    return { script: "", line: 0, function: signature };
+  }
+  const name = parts.at(-1) ?? "";
+  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]) => {
+    const parts = signatureParts(signature);
+    return {
+      script: parts.script,
+      function: parts.function,
+      line: parts.line,
+      calls: sum.calls,
+      selfMs: ms(sum.selfSeconds),
+      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;
+var init_script_profile = __esm(() => {
+  init_godot_variant();
+});
+
 // src/server.ts
 import { execFile as execFile5, spawn as spawn4 } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
@@ -42199,7 +42308,7 @@ import {
   mkdirSync as mkdirSync15,
   openSync as openSync3,
   readdirSync as readdirSync10,
-  readFileSync as readFileSync22,
+  readFileSync as readFileSync23,
   readSync as readSync2,
   rmdirSync as rmdirSync2,
   statSync as statSync9
@@ -42866,6 +42975,44 @@ function aboveTheRunner(entry) {
     ]
   };
 }
+function profileAnswer(reading, limit) {
+  const { totals } = reading;
+  if (totals === null) {
+    return {
+      through: reading.through,
+      running: reading.running,
+      connected: false,
+      functions: [],
+      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 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) {
+    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}`);
+  }
+  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.`);
+  }
+  return {
+    through: reading.through,
+    running: reading.running,
+    connected: true,
+    complete: totals.complete,
+    frames: totals.frames,
+    coveredMs: reading.coveredMs,
+    scriptMs: table.scriptMs,
+    functionsCounted: table.counted,
+    omitted: table.omitted > 0 ? table.omitted : undefined,
+    functions: table.functions,
+    note: notes.length > 0 ? notes.join(" ") : undefined
+  };
+}
 function foldedEntriesAnswer(log) {
   const problems = log.selectFolded({
     severity: "warning",
@@ -42879,7 +43026,7 @@ function foldedEntriesAnswer(log) {
 }
 function gdUnitFailsOnScriptErrors(projectPath) {
   try {
-    return settingKeys(readFileSync22(join26(projectPath, "project.godot"), "utf8")).get("gdunit4/report/godot/script_error") !== false;
+    return settingKeys(readFileSync23(join26(projectPath, "project.godot"), "utf8")).get("gdunit4/report/godot/script_error") !== false;
   } catch {
     return true;
   }
@@ -43008,7 +43155,7 @@ function scriptsUnder(directory, prefix) {
   return found;
 }
 function hasMainScene(projectFile) {
-  const scene = parseProjectGodot(readFileSync22(projectFile, "utf8"))["application"]?.["run/main_scene"];
+  const scene = parseProjectGodot(readFileSync23(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "";
 }
 function runtimeAddonAnnouncesEditors(projectPath) {
@@ -43016,13 +43163,13 @@ function runtimeAddonAnnouncesEditors(projectPath) {
     return false;
   }
   try {
-    return readFileSync22(join26(projectPath, RUNTIME_AUTOLOAD.path), "utf8").includes('"editor_pid"');
+    return readFileSync23(join26(projectPath, RUNTIME_AUTOLOAD.path), "utf8").includes('"editor_pid"');
   } catch {
     return false;
   }
 }
 function editorPlaysHeadless(projectFile) {
-  const runArgs = parseProjectGodot(readFileSync22(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
+  const runArgs = parseProjectGodot(readFileSync23(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
   return typeof runArgs === "string" && /(?:^|\s)--headless(?:\s|$)/.test(runArgs);
 }
 function camelCased(params) {
@@ -43695,6 +43842,9 @@ class GodotServer {
         if (op === "wait") {
           return await this.handleWaitForRun(args);
         }
+        if (op === "profile") {
+          return await this.handleRunProfile(args);
+        }
         return await this.handleRunProject(args, op);
       case "editor_output":
         return await this.handleGetDebugOutput(args);
@@ -44448,7 +44598,7 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const application = parseProjectGodot(readFileSync22(project.value.file, "utf8"))["application"] ?? {};
+    const application = parseProjectGodot(readFileSync23(project.value.file, "utf8"))["application"] ?? {};
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
@@ -44666,7 +44816,7 @@ class GodotServer {
       const written = existsSync20(reportsDir) ? readdirSync10(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(readFileSync22(join26(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync23(join26(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
@@ -44785,6 +44935,8 @@ class GodotServer {
       ];
     });
     const notRun = report.suites.reduce((sum, suite) => sum + Math.max(0, suite.discovered - suite.tests), 0);
+    const uncaughtFolded = foldedRepeats(uncaught.map(aboveTheRunner));
+    const listedAsUncaught = new Set(uncaughtFolded.map((entry) => entry.index));
     return this.jsonTextResponse({
       passed: !timedOut && exitCode === 0 && nothingRan === null && report.tests > 0 && report.failures === 0 && report.errors === 0 && hookFailures.length === 0 && uncaught.length === 0 && missing.length === 0,
       verdict,
@@ -44799,7 +44951,7 @@ class GodotServer {
       time: report.time,
       failed,
       hookFailures: hookFailures.length > 0 ? hookFailures : undefined,
-      uncaughtScriptErrors: uncaught.length > 0 ? foldedRepeats(uncaught.map(aboveTheRunner)) : undefined,
+      uncaughtScriptErrors: uncaughtFolded.length > 0 ? uncaughtFolded : undefined,
       warnings: warnings.length > 0 ? warnings : undefined,
       orphans: orphans.total > 0 ? orphans.total : undefined,
       notRun: notRun > 0 ? notRun : undefined,
@@ -44826,7 +44978,7 @@ class GodotServer {
       suitesPassed: report.suites.length - unclean.length,
       engineErrors: run.log.count("error"),
       engineWarnings: run.log.count("warning"),
-      engineEntries: engineEntriesShown,
+      engineEntries: engineEntriesShown.map((entry) => listedAsUncaught.has(entry.index) ? { ...entry, detail: undefined, detailUnder: "uncaughtScriptErrors" } : entry),
       engineEntriesOmitted: engineEntries.length > engineEntriesShown.length ? engineEntries.length - engineEntriesShown.length : undefined,
       classes: withAddonClassesCounted(classes.payload, cachedClasses(project.value.path) ?? new Map)
     });
@@ -44950,7 +45102,7 @@ class GodotServer {
         return null;
       }
       try {
-        return readFileSync22(contained.absolutePath, "utf8");
+        return readFileSync23(contained.absolutePath, "utf8");
       } catch {
         return null;
       }
@@ -45019,7 +45171,7 @@ class GodotServer {
       return null;
     }
     try {
-      return readFileSync22(contained.absolutePath, "utf8");
+      return readFileSync23(contained.absolutePath, "utf8");
     } catch {
       return null;
     }
@@ -45338,7 +45490,7 @@ class GodotServer {
       return null;
     }
     try {
-      return settingKeys(readFileSync22(join26(projectPath, "project.godot"), "utf8"));
+      return settingKeys(readFileSync23(join26(projectPath, "project.godot"), "utf8"));
     } catch {
       return null;
     }
@@ -45639,8 +45791,9 @@ class GodotServer {
     const runtimeWaitMs = this.announceBudget(args, project.value.path);
     const editorWouldPlay = !headless || editorPlaysHeadless(project.value.file);
     const silent = resolveSilent(args["silent"], process.env) && !headless;
+    const profiled = readBoolean(args, "profile") === true;
     if (this.godotBridge.isConnected() && editorWouldPlay && given.value.length === 0 && !needsItsOwnProcess(asked.value) && !silent) {
-      return await this.playThroughEditor(sceneArgument, refreshed.value, scanned, project.value.path, alreadyPlaying, runtimeWaitMs, ended);
+      return await this.playThroughEditor(sceneArgument, refreshed.value, scanned, project.value.path, alreadyPlaying, runtimeWaitMs, ended, profiled);
     }
     const cmdArgs = runArguments({
       projectPath: project.value.path,
@@ -45650,7 +45803,7 @@ class GodotServer {
       silent
     });
     this.logDebug(`Running Godot project: ${engine.value} ${cmdArgs.join(" ")}`);
-    const started = await this.launchKeptGame(engine.value, cmdArgs, project.value.path, needsItsOwnProcess(asked.value) ? environmentFor({ ...asked.value, runtimeDirectory: runtimeDirectory() }) : undefined, headless || args["visible"] === true ? undefined : HIDDEN_DESKTOP);
+    const started = await this.launchKeptGame(engine.value, cmdArgs, project.value.path, needsItsOwnProcess(asked.value) ? environmentFor({ ...asked.value, runtimeDirectory: runtimeDirectory() }) : undefined, headless || args["visible"] === true ? undefined : HIDDEN_DESKTOP, profiled);
     if ("error" in started) {
       return this.createErrorResponse(`The game could not be started: ${started.error}`, [
         "editor_status says which Godot this server runs and whether it answers"
@@ -45770,7 +45923,7 @@ class GodotServer {
       writeBootNote(run.projectPath, took);
     }
   }
-  async playThroughEditor(scene, refreshedClasses, scanned, projectPath, alreadyPlaying, runtimeWaitMs, ended) {
+  async playThroughEditor(scene, refreshedClasses, scanned, projectPath, alreadyPlaying, runtimeWaitMs, ended, profiled) {
     const log = new GameLog;
     const connectingFrom = Date.now();
     try {
@@ -45794,6 +45947,12 @@ class GodotServer {
     const sendingFrom = Date.now();
     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 });
+      if (armed.isError === true) {
+        return this.profilerRefusal(armed);
+      }
+    }
     const answer = await this.handleViaBridge("play_scene", scene === null ? {} : { scenePath: `res://${scene}` });
     if (answer.isError === true) {
       return answer;
@@ -45940,7 +46099,7 @@ class GodotServer {
       return 0;
     }
     try {
-      return reportAlreadyInTranscript(readFileSync22(game.transcript), readFileSync22(report));
+      return reportAlreadyInTranscript(readFileSync23(game.transcript), readFileSync23(report));
     } catch (error) {
       this.logDebug(`Could not compare a picked-up run's report with its transcript: ${errorMessage(error)}`);
       return 0;
@@ -46144,7 +46303,7 @@ class GodotServer {
     });
     return Object.assign(started, { settled });
   }
-  async launchKeptGame(godotPath, cmdArgs, projectPath, env, desktop) {
+  async launchKeptGame(godotPath, cmdArgs, projectPath, env, desktop, profiled = false) {
     const startedAt = Date.now();
     const transcript = openTranscript(startedAt);
     closeSync2(transcript.fd);
@@ -46152,7 +46311,13 @@ class GodotServer {
       command: godotPath,
       args: cmdArgs,
       ...env === undefined ? {} : { env },
-      run: { transcript: transcript.path, startedAt, projectPath, ...this.servedBy() },
+      run: {
+        transcript: transcript.path,
+        startedAt,
+        projectPath,
+        ...this.servedBy(),
+        ...profiled ? { profile: profilePath(startedAt) } : {}
+      },
       ...desktop === undefined ? {} : { desktop }
     });
     if ("error" in launched) {
@@ -46539,6 +46704,115 @@ class GodotServer {
       ...foldedEntriesAnswer(boot.log)
     });
   }
+  async handleRunProfile(args) {
+    await this.pickUpWhatTheEditorIsPlaying();
+    const run = await this.currentRun();
+    if (!run) {
+      return this.createErrorResponse(this.nothingOfOursIsRunning());
+    }
+    const limit = readPositiveNumber(args, "limit") ?? PROFILE_FUNCTIONS;
+    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);
+    if (run.throughEditor) {
+      return await this.profileOfThePlayedGame(going, runtimeAddon, limit);
+    }
+    const record = run.projectPath === null ? null : readRunRecord(run.projectPath);
+    const path = record !== null && record.pid === run.pid ? record.profile : undefined;
+    if (path === undefined) {
+      return this.createErrorResponse("This run was started without profile: true, and a game this server starts can be profiled only from its start: its debugger is whatever it dials as it starts, once.", ["editor_run start with profile: true starts the run again with the profiler on"]);
+    }
+    const file = readProfileFile(path);
+    if (file === null) {
+      return this.createErrorResponse(`The run's profile at ${path} could not be read.`, [
+        "editor_run start with profile: true starts the run again with the profiler on"
+      ]);
+    }
+    const totals = file.connected ? file : null;
+    return this.jsonTextResponse(profileAnswer({
+      through: "gdharness",
+      running: going,
+      totals,
+      coveredMs: totals?.lastFrameAt == null ? 0 : totals.lastFrameAt - totals.startedAt,
+      runtimeAddon
+    }, limit));
+  }
+  async profileOfThePlayedGame(going, runtimeAddon, limit) {
+    const read = await this.handleViaBridge("profile_read", {});
+    if (read.isError === true) {
+      return this.profilerRefusal(read);
+    }
+    const held = asParams(JSON.parse(read.content[0]?.text ?? "{}"));
+    if (readBoolean(held, "profiled") !== true && readBoolean(held, "armed") !== true) {
+      if (!going) {
+        return this.createErrorResponse("The game the editor played was not profiled, and it is over.", [
+          "editor_run start with profile: true plays it again with the profiler on from its start"
+        ]);
+      }
+      const started = await this.handleViaBridge("profile_start", {});
+      if (started.isError === true) {
+        return this.profilerRefusal(started);
+      }
+      if (readBoolean(asParams(JSON.parse(started.content[0]?.text ?? "{}")), "started") !== true) {
+        return this.createErrorResponse("The editor says it is playing and has no debugger session for the game, so there is nothing to switch the profiler on in yet.", ["Ask again in a moment, once the game is up"]);
+      }
+      const on = await this.firstProfiledFrame();
+      return this.jsonTextResponse({
+        through: "editor",
+        running: true,
+        started: true,
+        functions: [],
+        note: on ? "The profiler was switched on now, for the game the editor is playing, and its first frame has arrived, so it covers what the game does from here on. Ask again for the functions; editor_run start with profile: true covers a game from its start." : `The profiler was switched on for the game the editor is playing, and no frame of it had arrived ${PROFILER_ON_MS}ms later: what the game does before the first one is not counted. Ask again for the functions; editor_run start with profile: true covers a game from its start.`
+      });
+    }
+    const functions = asParams(held["functions"]);
+    const totals = readBoolean(held, "profiled") === true ? {
+      startedAt: 0,
+      lastFrameAt: null,
+      frames: readNonNegativeNumber(held, "frames") ?? 0,
+      complete: readBoolean(held, "complete") === true,
+      unreadable: 0,
+      functions: Object.fromEntries(Object.entries(functions).map(([signature, sum]) => {
+        const [calls, self, total] = Array.isArray(sum) ? sum : [];
+        return [
+          signature,
+          {
+            calls: Number(calls ?? 0),
+            selfSeconds: Number(self ?? 0),
+            totalSeconds: Number(total ?? 0)
+          }
+        ];
+      }))
+    } : null;
+    return this.jsonTextResponse(profileAnswer({
+      through: "editor",
+      running: going,
+      totals,
+      coveredMs: readNonNegativeNumber(held, "coveredMs") ?? 0,
+      runtimeAddon
+    }, limit));
+  }
+  async firstProfiledFrame() {
+    const deadline = Date.now() + PROFILER_ON_MS;
+    while (Date.now() < deadline) {
+      const read = await this.handleViaBridge("profile_read", {});
+      if (read.isError !== true) {
+        const held = asParams(JSON.parse(read.content[0]?.text ?? "{}"));
+        if ((readNonNegativeNumber(held, "frames") ?? 0) > 0) {
+          return true;
+        }
+      }
+      await delay4(100);
+    }
+    return false;
+  }
+  profilerRefusal(refused) {
+    const said = refused.content[0]?.text ?? "";
+    return said.includes("Unknown tool: profile_") ? this.createErrorResponse("The editor's gdharness addon is older than the profiler, so it cannot profile the game it plays.", [
+      "editor_launch restart loads the addon this server installed",
+      "editor_status says which addon the editor holds"
+    ]) : refused;
+  }
   async handleWaitForRun(args) {
     await this.pickUpWhatTheEditorIsPlaying();
     const run = await this.currentRun();
@@ -47683,7 +47957,7 @@ ${staleNote}`);
 
 ${staleNote}`}`
           },
-          { type: "image", data: readFileSync22(screenshotPath).toString("base64"), mimeType: "image/png" }
+          { type: "image", data: readFileSync23(screenshotPath).toString("base64"), mimeType: "image/png" }
         ]
       };
     } finally {
@@ -47784,7 +48058,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/", 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, MOST_ENGINE_ENTRIES = 200, ERROR_ASSERT = "GdUnitGodotErrorAssertImpl.gd", EXTERNAL_MEMBER = 'Could not resolve external class member "';
 var init_server3 = __esm(() => {
   init_mcp();
   init_stdio2();
@@ -47827,6 +48101,7 @@ var init_server3 = __esm(() => {
   init_runtime_client();
   init_scratch();
   init_script_origins();
+  init_script_profile();
   init_server_version();
   init_setup();
   init_tool_definitions();
@@ -48914,6 +49189,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 |
 | 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 |