gdharness 1.1.58 → 1.1.59

package/build/cli.js

@@ -18436,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"
     },
@@ -42305,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) {
@@ -42366,10 +42376,11 @@ function callersOf(totals, name, scripts) {
   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 ms = (seconds) => Math.round(seconds * 1e6) / 1000, CALL_SITES = 40;
+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
@@ -43072,6 +43083,26 @@ function profileOnStart(profiled, through, runtimeAddon) {
     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) => {
@@ -43118,6 +43149,7 @@ function profileAnswer(reading, limit) {
   } 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.`);
   }
@@ -43136,6 +43168,22 @@ function profileAnswer(reading, limit) {
     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 {
@@ -46082,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);
       }
@@ -46865,7 +46916,7 @@ class GodotServer {
       ...callersName === undefined ? {} : { callersOf: { name: callersName, scripts: () => projectScripts(projectPath) } }
     };
     if (run.throughEditor) {
-      return await this.profileOfThePlayedGame(going, fromProject, 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;
@@ -46887,7 +46938,7 @@ class GodotServer {
       ...fromProject
     }, limit));
   }
-  async profileOfThePlayedGame(going, fromProject, limit) {
+  async profileOfThePlayedGame(going, projectPath, fromProject, limit) {
     const read = await this.handleViaBridge("profile_read", {});
     if (read.isError === true) {
       return this.profilerRefusal(read);
@@ -46899,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);
       }
@@ -46922,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 [

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

@@ -12,9 +12,10 @@ extends Node
 
 const Read = preload("../reading.gd")
 
-## The engine sends only the top so many functions a frame and clamps nothing on the game's side.
-## Its own buffer's default, so no frame is cut short of what was called.
-const FRAME_FUNCTIONS: int = 16384
+## The most functions a frame may carry when the server does not say. The engine names a function
+## once, as it first appears, and the game's debugger queue drops those messages past its size, so
+## the server keeps this below the queue the project sets; this is that for the engine's default.
+const FRAME_FUNCTIONS: int = 1536
 const DEBUGGER_CLASS: String = "ScriptEditorDebugger"
 
 
@@ -44,6 +45,10 @@ var _started_msec: int = 0
 var _last_frame_msec: int = -1
 var _frames: int = 0
 var _complete: bool = false
+var _frame_functions: int = FRAME_FUNCTIONS
+## Frames that carried as many functions as were asked for, and whether the totals did.
+var _capped_frames: int = 0
+var _total_capped: bool = false
 var _names: Dictionary[int, String] = {}
 ## Per signature: calls, self seconds, total seconds.
 var _totals: Dictionary[String, PackedFloat64Array] = {}
@@ -81,6 +86,8 @@ func profile_start(args: Dictionary) -> Dictionary:
 			),
 		}
 	_reset()
+	var asked: int = Read.as_int(args.get("frameFunctions", FRAME_FUNCTIONS))
+	_frame_functions = asked if asked > 0 else FRAME_FUNCTIONS
 	if Read.as_bool(args.get("arm", false)):
 		_armed = true
 		return {"ok": true, "started": false, "armed": true, "session": -1}
@@ -104,6 +111,9 @@ func profile_read(_args: Dictionary) -> Dictionary:
 		"playing": EditorInterface.is_playing_scene(),
 		"frames": _frames,
 		"complete": _complete,
+		"frameFunctions": _frame_functions,
+		"cappedFrames": _capped_frames,
+		"totalCapped": _total_capped,
 		"coveredMs": _last_frame_msec - _started_msec if _last_frame_msec >= 0 else 0,
 		"functions": functions,
 	}
@@ -114,6 +124,8 @@ func _reset() -> void:
 	_session = -1
 	_frames = 0
 	_complete = false
+	_capped_frames = 0
+	_total_capped = false
 	_last_frame_msec = -1
 	_names.clear()
 	_totals.clear()
@@ -133,7 +145,7 @@ func _switch_on(session_id: int) -> void:
 	_session = session_id
 	_started_msec = Time.get_ticks_msec()
 	var session: EditorDebuggerSession = _sessions.get_session(session_id)
-	session.toggle_profiler("servers", true, [FRAME_FUNCTIONS, false])
+	session.toggle_profiler("servers", true, [_frame_functions, false])
 
 
 ## A play that was asked to be profiled is switched on as it starts. Any other play drops what is
@@ -170,37 +182,42 @@ func _on_debug_data(message: String, data: Array, session_id: int) -> void:
 	if message == "servers:function_signature" and data.size() >= 2:
 		_names[Read.as_int(data[1])] = str(data[0])
 	elif message == "servers:profile_frame":
-		if _add(data, _totals):
+		var carried: int = _add(data, _totals)
+		if carried >= 0:
 			_frames += 1
+			_capped_frames += 1 if carried >= _frame_functions else 0
 			_last_frame_msec = Time.get_ticks_msec()
 	elif message == "servers:profile_total":
 		# The engine's own count since the profiler started, so it replaces the frames' sum.
 		var whole: Dictionary[String, PackedFloat64Array] = {}
-		if _add(data, whole):
+		var carried: int = _add(data, whole)
+		if carried >= 0:
 			_totals = whole
 			_complete = true
+			_total_capped = carried >= _frame_functions
 			_last_frame_msec = Time.get_ticks_msec()
 
 
 ## Adds one frame's functions into [param into], reading past the servers' section to reach them:
 ## six frame times, the server count, each server's name and field count and fields, then five
-## numbers per function.
-func _add(data: Array, into: Dictionary[String, PackedFloat64Array]) -> bool:
+## numbers per function. Answers how many functions it carried, or -1 for a frame it cannot read.
+func _add(data: Array, into: Dictionary[String, PackedFloat64Array]) -> int:
 	var at: int = 6
 	if data.size() <= at:
-		return false
+		return -1
 	var servers: int = Read.as_int(data[at])
 	at += 1
 	for _server: int in servers:
 		if data.size() <= at + 1:
-			return false
+			return -1
 		at += 2 + Read.as_int(data[at + 1])
 	if data.size() <= at:
-		return false
+		return -1
 	var values: int = Read.as_int(data[at])
 	at += 1
 	if values % 5 != 0 or data.size() < at + values:
-		return false
+		return -1
+	var carried: int = 0
 	for index: int in range(at, at + values, 5):
 		var id: int = Read.as_int(data[index])
 		var signature: String = _names[id] if _names.has(id) else "#%d" % id
@@ -211,4 +228,5 @@ func _add(data: Array, into: Dictionary[String, PackedFloat64Array]) -> bool:
 		sum[1] += Read.as_float(data[index + 2])
 		sum[2] += Read.as_float(data[index + 3])
 		into[signature] = sum
-	return true
+		carried += 1
+	return carried

package/build/godot/addons/gdharness_runtime/runtime_autoload.gd

@@ -172,6 +172,7 @@ func _report_errors() -> void:
 func _process(_delta: float) -> void:
 	if not _enabled or _server == null:
 		return
+	_queries.note_frame(Time.get_ticks_usec())
 
 	if _server.is_connection_available():
 		var client: StreamPeerTCP = _server.take_connection()

package/build/godot/addons/gdharness_runtime/runtime_queries.gd

@@ -28,8 +28,14 @@ const READ_LIMIT: int = 500
 ## and said nothing, and a caller told to raise a number that stays put concludes the screen moved.
 const LIMIT_CEILING: int = 5000
 
+## How many frames the frame time is the mean of: two seconds at sixty frames a second.
+const FRAMES_TIMED: int = 120
+
 var _host: Node
 var _values: Values
+## How long each of the last frames took, oldest first, in microseconds, as the game timed them.
+var _frame_usec: PackedInt64Array = PackedInt64Array()
+var _last_frame_usec: int = 0
 
 
 ## The host is the autoload, which is how the tree is reached: it is not in one when the
@@ -649,12 +655,60 @@ func get_property(params: Dictionary) -> Dictionary:
 	}
 
 
+## Called by the autoload once a frame, whatever else it does that frame, with the time it was called.
+##
+## The engine's own monitors do not follow the frame: TIME_PROCESS and the frame rate are set once a
+## second, the first to the slowest process step of that second, so a game whose frames took 16.7ms
+## read 45ms for a second at a time, and a change to the game showed only on the next second's
+## worst frame. The time between two of these calls is the frame as it passed, physics and the wait
+## for the display included.
+func note_frame(now_usec: int) -> void:
+	if _last_frame_usec > 0:
+		var _grew: bool = _frame_usec.push_back(now_usec - _last_frame_usec)
+		if _frame_usec.size() > FRAMES_TIMED:
+			_frame_usec.remove_at(0)
+	_last_frame_usec = now_usec
+
+
+## Whether the frame waits for the display, which sets its floor: a game with vsync on cannot
+## finish a frame sooner than the display refreshes, however little it does.
+static func _vsync() -> String:
+	if DisplayServer.get_name() == "headless":
+		return "none, headless"
+	match DisplayServer.window_get_vsync_mode():
+		DisplayServer.VSYNC_DISABLED:
+			return "disabled"
+		DisplayServer.VSYNC_ADAPTIVE:
+			return "adaptive"
+		DisplayServer.VSYNC_MAILBOX:
+			return "mailbox"
+		_:
+			return "enabled"
+
+
 func get_metrics(params: Dictionary) -> Dictionary:
 	var metrics: Array = params.get("metrics", [])
+	var timed: int = _frame_usec.size()
+	var total_usec: int = 0
+	var slowest_usec: int = 0
+	for one: int in _frame_usec:
+		total_usec += one
+		slowest_usec = maxi(slowest_usec, one)
+	# Null rather than zero before a frame has been timed: no frame took no time.
+	var frame_time: Variant = null
+	var frame_time_max: Variant = null
+	if timed > 0:
+		frame_time = float(total_usec) / timed / 1000000.0
+		frame_time_max = slowest_usec / 1000000.0
 	var all: Dictionary = {
 		"fps": Engine.get_frames_per_second(),
-		"frame_time": Performance.get_monitor(Performance.TIME_PROCESS),
+		"frame_time": frame_time,
+		"frame_time_max": frame_time_max,
+		"frames_timed": timed,
+		"process_time_max": Performance.get_monitor(Performance.TIME_PROCESS),
 		"physics_time": Performance.get_monitor(Performance.TIME_PHYSICS_PROCESS),
+		"vsync": _vsync(),
+		"max_fps": Engine.max_fps,
 		"memory_static": Performance.get_monitor(Performance.MEMORY_STATIC),
 		"memory_static_max": Performance.get_monitor(Performance.MEMORY_STATIC_MAX),
 		"object_count": Performance.get_monitor(Performance.OBJECT_COUNT),

package/build/index.js

@@ -33101,6 +33101,17 @@ function readProfileFile(path) {
     return null;
   }
 }
+var QUEUE_SETTING = "limits/debugger/max_queued_messages";
+var QUEUE_DEFAULT = 2048;
+var QUEUE_HEADROOM = 512;
+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;
+}
+var UNNAMED_PREFIX = "#";
 function signatureParts(signature) {
   const parts = signature.split("::");
   if (parts.length < 3) {
@@ -34406,7 +34417,10 @@ var TOOL_SPECS = [
         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"
   },
@@ -35562,6 +35576,26 @@ function profileOnStart(profiled, through, runtimeAddon) {
   };
 }
 var PROFILER_ON_MS = 3000;
+function profileFrameFunctions(projectPath) {
+  let projectGodot = null;
+  if (projectPath !== null) {
+    try {
+      projectGodot = readFileSync21(join22(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
+  };
+}
 var 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.";
 function projectSourceOf(projectPath) {
   const read = new Map;
@@ -35609,6 +35643,7 @@ function profileAnswer(reading, limit) {
   } 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.`);
   }
@@ -35627,6 +35662,22 @@ function profileAnswer(reading, limit) {
     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 {
@@ -38576,7 +38627,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);
       }
@@ -39359,7 +39413,7 @@ class GodotServer {
       ...callersName === undefined ? {} : { callersOf: { name: callersName, scripts: () => projectScripts(projectPath) } }
     };
     if (run.throughEditor) {
-      return await this.profileOfThePlayedGame(going, fromProject, 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;
@@ -39381,7 +39435,7 @@ class GodotServer {
       ...fromProject
     }, limit));
   }
-  async profileOfThePlayedGame(going, fromProject, limit) {
+  async profileOfThePlayedGame(going, projectPath, fromProject, limit) {
     const read = await this.handleViaBridge("profile_read", {});
     if (read.isError === true) {
       return this.profilerRefusal(read);
@@ -39393,7 +39447,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);
       }
@@ -39416,6 +39472,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 [