gdharness 1.1.62 → 1.2.0

package/build/cli.js

@@ -18413,7 +18413,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, 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 call through super too, while the overridden function's row counts it again: such a row carries selfIncludesSuper, so self times along an override chain overlap. 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",
+          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 call through super too, while the overridden function's row counts it again: such a row carries selfIncludesSuper, so self times along an override chain overlap. The profiler's own cost of timing a call lands in the self time of the function called; with the runtime addon it is measured each run on an empty function, as perCallOverheadUs, and a row with at least half its selfMs in it carries overheadMs, since a small function called often costs that much less without the profiler. 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: []
         }
       },
@@ -42556,16 +42556,39 @@ function signatureParts(signature) {
   return { script: parts.slice(0, -2).join("::"), line: Number.isFinite(line) ? line : 0, function: name };
 }
 function profiledFunctions(totals, limit, sourceOf = () => null) {
-  const rows = rowsOf(totals, sourceOf);
-  const scriptMs = ms(Object.values(totals.functions).reduce((sum, one) => sum + (one.calls > 0 ? one.selfSeconds : 0), 0));
+  const perCallUs = perCallCostOf(totals);
+  const rows = rowsOf(totals, sourceOf).map((row) => withOverhead(row, perCallUs));
+  const scriptMs = ms(Object.entries(totals.functions).reduce((sum, [signature, one]) => sum + (one.calls > 0 && !isCalibration(signature) ? 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,
-    superCallers: rows.filter((row) => row.selfIncludesSuper === true).length
+    superCallers: rows.filter((row) => row.selfIncludesSuper === true).length,
+    perCallUs,
+    overheadDominated: rows.filter((row) => row.overheadMs !== undefined).length
   };
 }
+function isCalibration(signature) {
+  const parts = signatureParts(signature);
+  return parts.script.endsWith(RUNTIME_SCRIPT) && (parts.function === PROFILER_PROBE || parts.function === PROFILER_CALIBRATOR);
+}
+function perCallCostOf(totals) {
+  for (const [signature, sum] of Object.entries(totals.functions)) {
+    const parts = signatureParts(signature);
+    if (parts.script.endsWith(RUNTIME_SCRIPT) && parts.function === PROFILER_PROBE && sum.calls > 0) {
+      return Math.round(sum.selfSeconds / sum.calls * 1e9) / 1000;
+    }
+  }
+  return null;
+}
+function withOverhead(row, perCallUs) {
+  if (perCallUs === null || row.selfMs <= 0) {
+    return row;
+  }
+  const overheadMs = Math.round(row.calls * perCallUs) / 1000;
+  return overheadMs >= row.selfMs / 2 ? { ...row, overheadMs: Math.min(overheadMs, row.selfMs) } : row;
+}
 function rowsOf(totals, sourceOf) {
   const codes = new Map;
   const codeOfScript = (script) => {
@@ -42575,7 +42598,7 @@ function rowsOf(totals, sourceOf) {
     }
     return codes.get(script) ?? null;
   };
-  return Object.entries(totals.functions).filter(([, sum]) => sum.calls > 0).map(([signature, sum]) => {
+  return Object.entries(totals.functions).filter(([signature, sum]) => sum.calls > 0 && !isCalibration(signature)).map(([signature, sum]) => {
     const parts = signatureParts(signature);
     const code = codeOfScript(parts.script);
     return {
@@ -42641,7 +42664,7 @@ 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 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 QUEUE_SETTING = "limits/debugger/max_queued_messages", QUEUE_DEFAULT = 2048, QUEUE_HEADROOM = 512, UNNAMED_PREFIX = "#", ms = (seconds) => Math.round(seconds * 1e6) / 1000, RUNTIME_SCRIPT = "gdharness_runtime/runtime_autoload.gd", PROFILER_PROBE = "_profiler_probe", PROFILER_CALIBRATOR = "_calibrate_the_profiler", CALL_SITES = 40;
 var init_script_profile = __esm(() => {
   init_gdscript_source();
   init_godot_variant();
@@ -43229,6 +43252,24 @@ function foldedScriptErrors(errors) {
 function nonEmpty(lists) {
   return Object.fromEntries(Object.entries(lists).filter(([, list]) => list.length > 0));
 }
+function withoutUidUnder(unminted, paths) {
+  return unminted.map((script) => `res://${script}`).filter((script) => paths.some((path) => script === path || script.startsWith(path.endsWith("/") ? path : `${path}/`)));
+}
+function withUidsMissing(answer, missing) {
+  const content = answer.content.map((part) => ({ ...part }));
+  const last = content.at(-1);
+  try {
+    const parsed = JSON.parse(last?.text ?? "");
+    if (last !== undefined && typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      last.text = answerJson({
+        ...parsed,
+        uidsMissing: missing,
+        uidsNote: `${missing.length === 1 ? "This script has" : "These scripts have"} no .uid sidecar yet: the engine writes one when it imports the project, which a test run does not, so a check that tracks the sidecars fails on ${missing.length === 1 ? "it" : "them"}. project_import refresh_uids writes them.`
+      });
+    }
+  } catch {}
+  return { ...answer, content };
+}
 function withPreviousCut(answer, previous) {
   const content = answer.content.map((part) => ({ ...part }));
   const last = content.at(-1);
@@ -43440,6 +43481,9 @@ function profileAnswer(reading, limit) {
   if (table.superCallers > 0) {
     notes.push(`${table.superCallers === 1 ? "One function calls" : `${table.superCallers} functions call`} through super, marked selfIncludesSuper: the engine takes every other call out of the caller's self time, and not a super call, so ${table.superCallers === 1 ? "its" : "their"} selfMs holds the overridden function's time, which that function's own row counts again. Self time therefore cannot be added along an override chain, and scriptMs counts the time under a super call once more for each level above it.`);
   }
+  if (table.overheadDominated > 0 && table.perCallUs !== null) {
+    notes.push(`The profiler costs about ${table.perCallUs}µs a call in this run, measured on an empty function the runtime addon calls as it goes on, and that time lands in the self time of the function called. ${table.overheadDominated === 1 ? "One function has" : `${table.overheadDominated} functions have`} at least half ${table.overheadDominated === 1 ? "its" : "their"} selfMs in it, under overheadMs: a function that does little and is called often looks expensive here and costs that much less once the profiler is off, so inlining it gains little.`);
+  }
   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.`);
@@ -43452,6 +43496,7 @@ function profileAnswer(reading, limit) {
     frames: totals.frames,
     coveredMs: reading.coveredMs,
     scriptMs: table.scriptMs,
+    perCallOverheadUs: table.perCallUs ?? undefined,
     functionsCounted: table.counted,
     omitted: table.omitted > 0 ? table.omitted : undefined,
     functions: table.functions,
@@ -45181,11 +45226,14 @@ class GodotServer {
     return ticker;
   }
   async handleRunTests(args) {
-    const answer = await this.runTests(args);
+    const ran = await this.runTests(args);
     const project = this.project(args);
     if (!project.ok || callSignal()?.aborted === true) {
-      return answer;
+      return ran;
     }
+    const paths = testPathsIn(project.value.path, args["path"]);
+    const unminted = paths.ok ? withoutUidUnder(scriptsWithoutUid(project.value.path), paths.value) : [];
+    const answer = unminted.length === 0 ? ran : withUidsMissing(ran, unminted);
     const previous = takeCutTestRun(project.value.path);
     return previous === null ? answer : withPreviousCut(answer, previous);
   }

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

@@ -39,6 +39,10 @@ const PROFILE_RECEIVED: String = "gdharness:profile_received"
 ## editor without the gdharness addon, holds every profiled exit this long.
 const PROFILE_CONFIRM_MS: int = 3000
 
+## How many times the empty function is called to measure what the profiler costs per call: enough
+## that the clock's microsecond steps are lost in the sum, and a few milliseconds of one frame.
+const PROFILER_PROBE_CALLS: int = 10000
+
 ## How many calls of `EngineDebugger.line_poll` read the debugger's messages once: it reads them
 ## on every 2048th call and only counts the others.
 const POLLS_PER_READ: int = 2048
@@ -103,6 +107,7 @@ var _commands: Dictionary = {}
 var _loaded_version: String = _read_marker(VERSION_MARKER)
 var _loaded_digest: String = _read_marker(DIGEST_MARKER)
 var _profile_received: bool = false
+var _profiler_calibrated: bool = false
 
 
 func _init() -> void:
@@ -193,6 +198,31 @@ func _send_the_profile() -> void:
 		)
 
 
+## What the script profiler costs per call in this game, measured once each time it is switched on.
+##
+## The profiler times every call it counts, and that bookkeeping lands in the self time of the
+## function called: a function doing almost nothing, called six hundred thousand times, read as a
+## second of its own, and inlining it saved nothing once the profiler was off. So an empty function
+## is called here [constant PROFILER_PROBE_CALLS] times while the profiler watches, under the load
+## the game is under, and the server reads its row as the cost of one call.
+func _calibrate_the_profiler() -> void:
+	var profiling: bool = EngineDebugger.is_active() and EngineDebugger.is_profiling("servers")
+	if not profiling:
+		_profiler_calibrated = false
+		return
+	if _profiler_calibrated:
+		return
+	_profiler_calibrated = true
+	for _call: int in PROFILER_PROBE_CALLS:
+		_profiler_probe()
+
+
+## Does nothing, so its time under the profiler is the profiler's own. Kept in step with
+## `PROFILER_PROBE` in src/script-profile.ts.
+func _profiler_probe() -> void:
+	pass
+
+
 func _on_debugger_message(message: String, _data: Array) -> bool:
 	if PROFILE_CAPTURE + ":" + message == PROFILE_RECEIVED:
 		_profile_received = true
@@ -223,6 +253,7 @@ func _process(_delta: float) -> void:
 	if not _enabled or _server == null:
 		return
 	_queries.note_frame(Time.get_ticks_usec())
+	_calibrate_the_profiler()
 
 	if _server.is_connection_available():
 		var client: StreamPeerTCP = _server.take_connection()

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

@@ -25,6 +25,15 @@ const HEADLESS_VIEWPORT: Vector2 = Vector2(64, 64)
 ## everything that process starts. Kept in step with `DESKTOP_VARIABLE` in src/desktop.ts.
 const DESKTOP_VARIABLE: String = "GDHARNESS_DESKTOP"
 
+## Node.ProcessMode as its names, for a refusal to say which one is in force.
+const PROCESS_MODES: Dictionary[int, String] = {
+	Node.PROCESS_MODE_INHERIT: "INHERIT",
+	Node.PROCESS_MODE_PAUSABLE: "PAUSABLE",
+	Node.PROCESS_MODE_WHEN_PAUSED: "WHEN_PAUSED",
+	Node.PROCESS_MODE_ALWAYS: "ALWAYS",
+	Node.PROCESS_MODE_DISABLED: "DISABLED",
+}
+
 ## Whether this run has had the pointer note in full; the game process is the run.
 static var _pointer_explained: bool = false
 
@@ -556,15 +565,35 @@ func _takes_no_click(control: Control, node_path: String) -> String:
 	if button != null and button.disabled:
 		return "%s is disabled, so clicking it presses nothing" % node_path
 	if not control.can_process():
+		var why: String = _why_it_does_not_process(control, node_path)
+		var over: Node = Targets.drawn_over(control)
+		var cover: String = "" if over == null else "; %s is drawn over it" % over.get_path()
 		if _host.get_tree().paused:
 			return (
-				"the game is paused and %s does not process while it is, so clicking it does nothing"
-				% node_path
+				"the game is paused and %s does not process while it is (%s), so clicking it does nothing%s"
+				% [node_path, why, cover]
 			)
-		return "%s has its processing disabled, so clicking it does nothing" % node_path
+		return "%s does not process (%s), so clicking it does nothing%s" % [node_path, why, cover]
 	return ""
 
 
+## Which node's process_mode keeps [param control] from processing, and what it is. A node set to
+## inherit takes its parent's, so the one deciding can be any node above it: the game turning a
+## whole screen off while a menu shows over it reads, on the button, as a button turned off.
+static func _why_it_does_not_process(control: Control, node_path: String) -> String:
+	var deciding: Node = control
+	while deciding.process_mode == Node.PROCESS_MODE_INHERIT and deciding.get_parent() != null:
+		deciding = deciding.get_parent()
+	# The root inherits from nothing, which processes as pausable.
+	var value: int = deciding.process_mode
+	if value == Node.PROCESS_MODE_INHERIT:
+		value = Node.PROCESS_MODE_PAUSABLE
+	var mode: String = PROCESS_MODES.get(value, str(value))
+	if deciding == control:
+		return "its process_mode is %s" % mode
+	return "%s inherits process_mode %s from %s" % [node_path, mode, deciding.get_path()]
+
+
 ## Why a click at [param control]'s centre would reach nothing, or "" when it would reach it: the
 ## centre outside the viewport it is drawn in, at [param local]; outside the viewport showing that
 ## one on the screen, which [param reached] holds with the centre there; or clipped away by a

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

@@ -370,6 +370,12 @@ static func _pressed_through(control: Control) -> Control:
 	return control
 
 
+## What a pointer at [param target]'s centre would reach instead of it, drawn over it, or null.
+static func drawn_over(target: Control) -> Node:
+	var drawn: Array[Node] = _pointer_takers(target.get_tree().root)
+	return _cover_of(target, drawn, _areas_of(drawn))
+
+
 ## Everything in the tree [param root] heads that a pointer can land on: each control on screen
 ## that does not let the pointer through, and each window embedded in another.
 static func _pointer_takers(root: Node) -> Array[Node]:

package/build/index.js

@@ -33353,16 +33353,42 @@ function signatureParts(signature) {
 }
 var ms = (seconds) => Math.round(seconds * 1e6) / 1000;
 function profiledFunctions(totals, limit, sourceOf = () => null) {
-  const rows = rowsOf(totals, sourceOf);
-  const scriptMs = ms(Object.values(totals.functions).reduce((sum, one) => sum + (one.calls > 0 ? one.selfSeconds : 0), 0));
+  const perCallUs = perCallCostOf(totals);
+  const rows = rowsOf(totals, sourceOf).map((row) => withOverhead(row, perCallUs));
+  const scriptMs = ms(Object.entries(totals.functions).reduce((sum, [signature, one]) => sum + (one.calls > 0 && !isCalibration(signature) ? 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,
-    superCallers: rows.filter((row) => row.selfIncludesSuper === true).length
+    superCallers: rows.filter((row) => row.selfIncludesSuper === true).length,
+    perCallUs,
+    overheadDominated: rows.filter((row) => row.overheadMs !== undefined).length
   };
 }
+var RUNTIME_SCRIPT = "gdharness_runtime/runtime_autoload.gd";
+var PROFILER_PROBE = "_profiler_probe";
+var PROFILER_CALIBRATOR = "_calibrate_the_profiler";
+function isCalibration(signature) {
+  const parts = signatureParts(signature);
+  return parts.script.endsWith(RUNTIME_SCRIPT) && (parts.function === PROFILER_PROBE || parts.function === PROFILER_CALIBRATOR);
+}
+function perCallCostOf(totals) {
+  for (const [signature, sum] of Object.entries(totals.functions)) {
+    const parts = signatureParts(signature);
+    if (parts.script.endsWith(RUNTIME_SCRIPT) && parts.function === PROFILER_PROBE && sum.calls > 0) {
+      return Math.round(sum.selfSeconds / sum.calls * 1e9) / 1000;
+    }
+  }
+  return null;
+}
+function withOverhead(row, perCallUs) {
+  if (perCallUs === null || row.selfMs <= 0) {
+    return row;
+  }
+  const overheadMs = Math.round(row.calls * perCallUs) / 1000;
+  return overheadMs >= row.selfMs / 2 ? { ...row, overheadMs: Math.min(overheadMs, row.selfMs) } : row;
+}
 function rowsOf(totals, sourceOf) {
   const codes = new Map;
   const codeOfScript = (script) => {
@@ -33372,7 +33398,7 @@ function rowsOf(totals, sourceOf) {
     }
     return codes.get(script) ?? null;
   };
-  return Object.entries(totals.functions).filter(([, sum]) => sum.calls > 0).map(([signature, sum]) => {
+  return Object.entries(totals.functions).filter(([signature, sum]) => sum.calls > 0 && !isCalibration(signature)).map(([signature, sum]) => {
     const parts = signatureParts(signature);
     const code = codeOfScript(parts.script);
     return {
@@ -34463,7 +34489,7 @@ var TOOL_SPECS = [
       },
       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, 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 call through super too, while the overridden function's row counts it again: such a row carries selfIncludesSuper, so self times along an override chain overlap. 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",
+        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 call through super too, while the overridden function's row counts it again: such a row carries selfIncludesSuper, so self times along an override chain overlap. The profiler's own cost of timing a call lands in the self time of the function called; with the runtime addon it is measured each run on an empty function, as perCallOverheadUs, and a row with at least half its selfMs in it carries overheadMs, since a small function called often costs that much less without the profiler. 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: []
       }
     },
@@ -35685,6 +35711,24 @@ function foldedScriptErrors(errors) {
 function nonEmpty(lists) {
   return Object.fromEntries(Object.entries(lists).filter(([, list]) => list.length > 0));
 }
+function withoutUidUnder(unminted, paths) {
+  return unminted.map((script) => `res://${script}`).filter((script) => paths.some((path) => script === path || script.startsWith(path.endsWith("/") ? path : `${path}/`)));
+}
+function withUidsMissing(answer, missing) {
+  const content = answer.content.map((part) => ({ ...part }));
+  const last = content.at(-1);
+  try {
+    const parsed = JSON.parse(last?.text ?? "");
+    if (last !== undefined && typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      last.text = answerJson({
+        ...parsed,
+        uidsMissing: missing,
+        uidsNote: `${missing.length === 1 ? "This script has" : "These scripts have"} no .uid sidecar yet: the engine writes one when it imports the project, which a test run does not, so a check that tracks the sidecars fails on ${missing.length === 1 ? "it" : "them"}. project_import refresh_uids writes them.`
+      });
+    }
+  } catch {}
+  return { ...answer, content };
+}
 function withPreviousCut(answer, previous) {
   const content = answer.content.map((part) => ({ ...part }));
   const last = content.at(-1);
@@ -35931,6 +35975,9 @@ function profileAnswer(reading, limit) {
   if (table.superCallers > 0) {
     notes.push(`${table.superCallers === 1 ? "One function calls" : `${table.superCallers} functions call`} through super, marked selfIncludesSuper: the engine takes every other call out of the caller's self time, and not a super call, so ${table.superCallers === 1 ? "its" : "their"} selfMs holds the overridden function's time, which that function's own row counts again. Self time therefore cannot be added along an override chain, and scriptMs counts the time under a super call once more for each level above it.`);
   }
+  if (table.overheadDominated > 0 && table.perCallUs !== null) {
+    notes.push(`The profiler costs about ${table.perCallUs}µs a call in this run, measured on an empty function the runtime addon calls as it goes on, and that time lands in the self time of the function called. ${table.overheadDominated === 1 ? "One function has" : `${table.overheadDominated} functions have`} at least half ${table.overheadDominated === 1 ? "its" : "their"} selfMs in it, under overheadMs: a function that does little and is called often looks expensive here and costs that much less once the profiler is off, so inlining it gains little.`);
+  }
   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.`);
@@ -35943,6 +35990,7 @@ function profileAnswer(reading, limit) {
     frames: totals.frames,
     coveredMs: reading.coveredMs,
     scriptMs: table.scriptMs,
+    perCallOverheadUs: table.perCallUs ?? undefined,
     functionsCounted: table.counted,
     omitted: table.omitted > 0 ? table.omitted : undefined,
     functions: table.functions,
@@ -37675,11 +37723,14 @@ class GodotServer {
     return ticker;
   }
   async handleRunTests(args) {
-    const answer = await this.runTests(args);
+    const ran = await this.runTests(args);
     const project = this.project(args);
     if (!project.ok || callSignal()?.aborted === true) {
-      return answer;
+      return ran;
     }
+    const paths = testPathsIn(project.value.path, args["path"]);
+    const unminted = paths.ok ? withoutUidUnder(scriptsWithoutUid(project.value.path), paths.value) : [];
+    const answer = unminted.length === 0 ? ran : withUidsMissing(ran, unminted);
     const previous = takeCutTestRun(project.value.path);
     return previous === null ? answer : withPreviousCut(answer, previous);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdharness",
-  "version": "1.1.62",
+  "version": "1.2.0",
   "mcpName": "io.github.Aureliolo/gdharness",
   "description": "A harness for driving a Godot 4 project from an agent: editor addons, a runtime bridge into the running game, an MCP server in front of them, and a CLI that installs and diagnoses the Godot side.",
   "type": "module",