gdharness 0.12.17 → 0.13.0

package/build/cli.js

@@ -7187,6 +7187,9 @@ function announced(line) {
   }
   return { severity: match[2] === "WARNING" ? "warning" : "error", text: match[3] ?? "" };
 }
+function forAnswer(entries) {
+  return entries.map((entry) => entry.detail.length === 0 ? { index: entry.index, severity: entry.severity, source: entry.source, text: entry.text } : entry);
+}
 
 class GameLog {
   entries = [];
@@ -15037,6 +15040,11 @@ function readPositiveNumber(params, key) {
   const number = typeof value === "string" && value.trim() !== "" ? Number(value) : value;
   return typeof number === "number" && Number.isFinite(number) && number > 0 ? number : undefined;
 }
+function readNonNegativeNumber(params, key) {
+  const value = params[key];
+  const number = typeof value === "string" && value.trim() !== "" ? Number(value) : value;
+  return typeof number === "number" && Number.isFinite(number) && number >= 0 ? number : undefined;
+}
 function readBoolean(params, key) {
   const value = params[key];
   if (typeof value === "boolean") {
@@ -15291,6 +15299,11 @@ var init_tool_definitions = __esm(() => {
       parameters: {
         projectPath: PROJECT_PATH,
         setting: { type: "string", description: 'Setting path, such as "display/window/size/viewport_width".' },
+        prefix: {
+          type: "string",
+          ops: ["get"],
+          description: 'get: answer with every setting whose name starts with this, and the type the engine registers for each, instead of one setting by name. "debug/gdscript/warnings/" answers the whole family. The type matters: a family of levels can hold a setting that is a bool, and writing a level over it looks like it worked.'
+        },
         value: {
           blank: true,
           description: 'The value to write. Engine types may be tagged, {"_type": "Vector2", "x": 1, "y": 2}. "" writes an empty string.'
@@ -15312,7 +15325,7 @@ var init_tool_definitions = __esm(() => {
       },
       requires: ["projectPath"],
       operations: {
-        get: { summary: "read one setting", requires: ["setting"] },
+        get: { summary: "read one setting, or every setting under prefix", requires: [] },
         set: { summary: "write one setting", requires: ["setting", "value"] },
         add_autoload: { summary: "register an autoload singleton", requires: ["name", "path"] },
         remove_autoload: { summary: "unregister an autoload", requires: ["name"] },
@@ -15719,7 +15732,7 @@ var init_tool_definitions = __esm(() => {
         runtimeWaitMs: {
           type: "number",
           ops: ["start"],
-          description: "start: how long to wait for the game to announce its runtime before answering. Default 5000. Worth raising for a project that takes longer than that to reach its first frame, which is what leaves runtime listening false on a game whose runtime arrives a moment later."
+          description: "start: how long to wait for the game to announce its runtime before answering. Default 5000. Worth raising for a project that takes longer than that to reach its first frame, which is what leaves runtime listening false on a game whose runtime arrives a moment later. 0 does not wait at all, which is the one to pass for a scene that announces nothing by construction, such as a bench that prints and quits."
         },
         frames: {
           type: "number",
@@ -15728,15 +15741,16 @@ var init_tool_definitions = __esm(() => {
         },
         timeoutMs: {
           type: "number",
-          ops: ["check"],
-          description: "check: how long to give the boot before it is called hung. Default 60000."
+          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."
         }
       },
       requires: ["projectPath"],
       operations: {
         start: { summary: "run the project until it quits or is stopped", requires: [] },
         stop: { summary: "end the run and answer with what it printed last", requires: [] },
-        check: { summary: "boot headless, quit after a few frames, and report the verdict", requires: [] }
+        check: { summary: "boot headless, quit after a few frames, and report the verdict", requires: [] },
+        wait: { summary: "wait for the run to end, then answer as editor_output does", requires: [] }
       },
       defaultOperation: "start"
     },
@@ -15753,6 +15767,10 @@ var init_tool_definitions = __esm(() => {
           type: "boolean",
           description: "Only entries printed since the previous editor_output. Default false."
         },
+        cpu: {
+          type: "boolean",
+          description: "Also answer with cpuSeconds, the processor time the run has used. Default false, because asking costs a subprocess. Worth it when elapsedMs is climbing and nothing is being printed: processor time standing still is a run that has stopped doing anything, rather than one that is slow."
+        },
         contains: {
           type: "string",
           description: "Only entries mentioning this text, matched against everything the run has printed rather than against the entries this answer would otherwise carry: a line is found however much was printed after it."
@@ -16132,6 +16150,43 @@ var init_tool_definitions = __esm(() => {
   SPECS_BY_NAME = dictionary(Object.fromEntries(TOOL_SPECS.map((spec) => [spec.name, spec])));
 });
 
+// src/headless-operations.ts
+var HEADLESS_OPERATIONS;
+var init_headless_operations = __esm(() => {
+  HEADLESS_OPERATIONS = dictionary({
+    project_settings: dictionary({
+      get: "get_project_setting",
+      set: "set_project_setting",
+      add_autoload: "add_autoload",
+      remove_autoload: "remove_autoload",
+      set_main_scene: "set_main_scene",
+      add_input_action: "add_input_action",
+      enable_plugin: "enable_plugin",
+      disable_plugin: "disable_plugin",
+      add_audio_bus: "create_audio_bus",
+      set_audio_bus_effect: "set_audio_bus_effect",
+      set_audio_bus_volume: "set_audio_bus_volume"
+    }),
+    project_import: dictionary({
+      status: "get_import_status",
+      options: "get_import_options",
+      set_options: "set_import_options",
+      reimport: "reimport_resource",
+      uid: "get_uid",
+      refresh_uids: "resave_resources",
+      refresh_classes: "refresh_class_cache"
+    }),
+    project_export: dictionary({ list: "list_export_presets" }),
+    script_edit: dictionary({ create: "create_script", modify: "modify_script" }),
+    script_info: dictionary({ structure: "get_script_info" }),
+    editor_classes: dictionary({
+      query: "query_classes",
+      info: "query_class_info",
+      inheritance: "inspect_inheritance"
+    })
+  });
+});
+
 // node_modules/zod/v3/helpers/util.js
 var util, objectUtil, ZodParsedType, getParsedType = (data) => {
   const t = typeof data;
@@ -35800,6 +35855,45 @@ var init_lsp_client = __esm(() => {
   init_ports();
 });
 
+// src/process-time.ts
+import { execFile as execFile5 } from "node:child_process";
+import { promisify as promisify5 } from "node:util";
+async function cpuSecondsOf(pid) {
+  try {
+    return process.platform === "win32" ? await askWindows(pid) : await askPosix(pid);
+  } catch {
+    return;
+  }
+}
+async function askWindows(pid) {
+  const { stdout } = await run5("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", `(Get-Process -Id ${pid}).CPU`], { timeout: ASK_TIMEOUT_MS, windowsHide: true });
+  const seconds = Number(stdout.trim().replace(",", "."));
+  return Number.isFinite(seconds) ? seconds : undefined;
+}
+async function askPosix(pid) {
+  const { stdout } = await run5("ps", ["-o", "time=", "-p", String(pid)], { timeout: ASK_TIMEOUT_MS });
+  return secondsFromClock(stdout.trim());
+}
+function secondsFromClock(printed) {
+  if (printed === "") {
+    return;
+  }
+  const dashed = printed.includes("-");
+  const days = dashed ? printed.slice(0, printed.indexOf("-")) : null;
+  const clock = dashed ? printed.slice(printed.indexOf("-") + 1) : printed;
+  const parts = clock.split(":").map((part) => Number(part));
+  if (parts.length === 0 || parts.some((part) => !Number.isFinite(part))) {
+    return;
+  }
+  const seconds = parts.reduce((total, part) => total * 60 + part, 0);
+  const extra = days === null ? 0 : Number(days) * 86400;
+  return Number.isFinite(extra) ? seconds + extra : undefined;
+}
+var run5, ASK_TIMEOUT_MS = 2000;
+var init_process_time = __esm(() => {
+  run5 = promisify5(execFile5);
+});
+
 // src/project-scan.ts
 import { existsSync as existsSync10, readdirSync as readdirSync4, readFileSync as readFileSync10 } from "node:fs";
 import { join as join12 } from "node:path";
@@ -36355,7 +36449,7 @@ var init_setup = __esm(() => {
 });
 
 // src/server.ts
-import { execFile as execFile5, spawn } from "node:child_process";
+import { execFile as execFile6, spawn } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import {
   closeSync,
@@ -36374,7 +36468,7 @@ import { tmpdir as tmpdir5 } from "node:os";
 import { basename as basename3, dirname as dirname9, join as join16, normalize as normalize3 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
-import { promisify as promisify5 } from "node:util";
+import { promisify as promisify6 } from "node:util";
 function patienceForFrames(frames, atLeast) {
   return Math.max(atLeast, frames / SLOWEST_FRAME_RATE * 1000 + atLeast);
 }
@@ -37003,9 +37097,15 @@ class GodotServer {
       case "editor_launch":
         return op === "restart" ? await this.handleRestartEditor() : await this.handleLaunchEditor(args);
       case "editor_run":
-        return op === "stop" ? await this.handleStopProject() : await this.handleRunProject(args, op);
+        if (op === "stop") {
+          return await this.handleStopProject();
+        }
+        if (op === "wait") {
+          return await this.handleWaitForRun(args);
+        }
+        return await this.handleRunProject(args, op);
       case "editor_output":
-        return this.handleGetDebugOutput(args);
+        return await this.handleGetDebugOutput(args);
       case "editor_status":
         return await this.handleEditorStatus();
       case "editor_rescan":
@@ -37376,7 +37476,7 @@ class GodotServer {
     const log = new GameLog;
     let exitCode = 0;
     try {
-      const { stdout, stderr } = await run5(engine.value, exportArgs, { timeout: 300000 });
+      const { stdout, stderr } = await run6(engine.value, exportArgs, { timeout: 300000 });
       log.append("stdout", stdout);
       log.append("stderr", stderr);
     } catch (error) {
@@ -37400,7 +37500,7 @@ class GodotServer {
       exitCode,
       errors: log.count("error"),
       warnings: log.count("warning"),
-      entries: problems.entries
+      entries: forAnswer(problems.entries)
     };
     if (!verdict.exported) {
       return {
@@ -37517,7 +37617,7 @@ class GodotServer {
               exitCode,
               hung,
               arguments: cmdArgs,
-              entries: printed.slice(0, 60)
+              entries: forAnswer(printed.slice(0, 60))
             }, null, 2)
           }
         ],
@@ -37571,7 +37671,7 @@ class GodotServer {
   }
   async godotVersion(godotPath) {
     try {
-      const { stdout } = await run5(godotPath, ["--version"], { timeout: 1e4 });
+      const { stdout } = await run6(godotPath, ["--version"], { timeout: 1e4 });
       return stdout.trim();
     } catch (error) {
       this.logDebug(`Godot did not answer --version: ${errorMessage(error)}`);
@@ -37866,7 +37966,7 @@ class GodotServer {
       platform: process.platform,
       variables: process.env
     });
-    const runtimeWaitMs = readPositiveNumber(args, "runtimeWaitMs") ?? ANNOUNCE_BUDGET_MS;
+    const runtimeWaitMs = readNonNegativeNumber(args, "runtimeWaitMs") ?? ANNOUNCE_BUDGET_MS;
     const editorWouldPlay = !headless || editorPlaysHeadless(project.value.file);
     if (this.godotBridge.isConnected() && editorWouldPlay && given.value.length === 0) {
       return await this.playThroughEditor(sceneArgument, refreshed.value, project.value.path, alreadyPlaying, runtimeWaitMs, ended);
@@ -38188,10 +38288,24 @@ class GodotServer {
       frames,
       errors,
       warnings,
-      entries: boot.log.select({ severity: "warning", sinceLastCall: false, limit: 200 }).entries
+      entries: forAnswer(boot.log.select({ severity: "warning", sinceLastCall: false, limit: 200 }).entries)
     });
   }
-  handleGetDebugOutput(args) {
+  async handleWaitForRun(args) {
+    const run = this.currentRun();
+    if (!run) {
+      return this.createErrorResponse(this.nothingOfOursIsRunning());
+    }
+    const budgetMs = readPositiveNumber(args, "timeoutMs") ?? WAIT_FOR_RUN_MS;
+    const until = Date.now() + budgetMs;
+    while (stillRunning(run) && Date.now() < until) {
+      this.drainEditorOutput(run);
+      this.drainTranscript(run);
+      await delay3(RUN_POLL_MS);
+    }
+    return await this.handleGetDebugOutput(args, stillRunning(run) ? budgetMs : undefined);
+  }
+  async handleGetDebugOutput(args, waitedMs) {
     const run = this.currentRun();
     if (!run) {
       return this.createErrorResponse(this.nothingOfOursIsRunning());
@@ -38210,14 +38324,19 @@ class GodotServer {
       limit: readPositiveNumber(args, "limit") ?? 200
     });
     const halt = run.throughEditor ? this.dapClient?.whereItStopped() ?? null : null;
+    const wanted = readBoolean(args, "cpu") ?? false;
+    const cpuSeconds = wanted && run.pid !== null && stillRunning(run) ? await cpuSecondsOf(run.pid) : undefined;
     const notes = [];
+    if (waitedMs !== undefined) {
+      notes.push(`The wait of ${waitedMs}ms ran out and the run is still going, so this is what it had printed by then rather than everything it will print. editor_run wait again to keep waiting.`);
+    }
     if (run.endedUnwatched === true) {
       notes.push("This run outlived the server that started it and is over now, so its exit code was never collected. Everything it printed is below, read back from its transcript.");
     }
     if (typeof run.endedHere === "string") {
       notes.push(`This run was ended here, by ${run.endedHere}.`);
     } else if (!stillRunning(run) && !run.throughEditor && run.exitCode !== null) {
-      notes.push("Nothing here ended this run: it stopped on its own or something outside this server stopped it.");
+      notes.push(run.exitCode === 0 ? "This run quit on its own, cleanly: exit code 0." : "Nothing here ended this run: it stopped on its own or something outside this server stopped it.");
     }
     if (run.transcript !== null && selected.omitted > 0) {
       notes.push(`Everything this run has printed is in ${run.transcript}, uncapped and still being written. Read it for output, not for whether the run is alive: running above is asked of the operating system, and a transcript that stops growing is a run between prints.`);
@@ -38235,9 +38354,12 @@ class GodotServer {
       endedBy: stillRunning(run) ? undefined : run.endedHere ?? null,
       project: !run.throughEditor && run.process === null ? run.projectPath ?? undefined : undefined,
       transcript: run.transcript ?? undefined,
+      startedAt: new Date(run.startedAt).toISOString(),
+      elapsedMs: Date.now() - run.startedAt,
+      cpuSeconds,
       note: notes.length > 0 ? notes.join(" ") : undefined,
       omitted: selected.omitted,
-      entries: selected.entries
+      entries: forAnswer(selected.entries)
     });
   }
   async handleStopProject() {
@@ -38257,7 +38379,7 @@ class GodotServer {
       errors: stopped.log.count("error"),
       warnings: stopped.log.count("warning"),
       clean: stopped.log.count("error") === 0,
-      entries: stopped.log.select({ severity: "warning", sinceLastCall: false, limit: 200 }).entries
+      entries: forAnswer(stopped.log.select({ severity: "warning", sinceLastCall: false, limit: 200 }).entries)
     });
   }
   async handleRescanFilesystem(args) {
@@ -38442,7 +38564,7 @@ async function runGodotServer() {
   const server = new GodotServer;
   await server.run();
 }
-var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run5, __dirname2, EDITOR_RESTART_TIMEOUT_MS = 90000, SLOWEST_FRAME_RATE = 20, VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, HEADLESS_OPERATIONS, PROJECT_INFO_SECTIONS, RUNNER_DIRECTORY = "addons/gdUnit4/";
+var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run6, __dirname2, EDITOR_RESTART_TIMEOUT_MS = 90000, SLOWEST_FRAME_RATE = 20, VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS, RUNNER_DIRECTORY = "addons/gdUnit4/";
 var init_server3 = __esm(() => {
   init_mcp();
   init_stdio2();
@@ -38455,11 +38577,13 @@ var init_server3 = __esm(() => {
   init_godot_bridge();
   init_godot_path();
   init_headless();
+  init_headless_operations();
   init_issues();
   init_junit();
   init_lsp_client();
   init_paths();
   init_ports();
+  init_process_time();
   init_project_scan();
   init_resources();
   init_run_record();
@@ -38468,7 +38592,7 @@ var init_server3 = __esm(() => {
   init_setup();
   init_tool_definitions();
   init_update_check();
-  run5 = promisify5(execFile5);
+  run6 = promisify6(execFile6);
   __dirname2 = dirname9(fileURLToPath4(import.meta.url));
   VALUE_NAMES = {
     string: "a string",
@@ -38480,44 +38604,19 @@ var init_server3 = __esm(() => {
     'Give the path relative to the project, such as "scenes/main.tscn" or "res://scenes/main.tscn"',
     "Point projectPath at the project the file belongs to"
   ];
-  PROJECT_FILE_ARGUMENTS = ["scenePath", "scriptPath", "resourcePath", "newPath", "path", "script"];
+  PROJECT_FILE_ARGUMENTS = [
+    "scenePath",
+    "scriptPath",
+    "resourcePath",
+    "newPath",
+    "path",
+    "script"
+  ];
   DEBUG_STATE_CALLS = dictionary({
     stack: "dap_get_stack_trace",
     output: "dap_get_output",
     variables: "dap_get_variables"
   });
-  HEADLESS_OPERATIONS = dictionary({
-    project_settings: dictionary({
-      get: "get_project_setting",
-      set: "set_project_setting",
-      add_autoload: "add_autoload",
-      remove_autoload: "remove_autoload",
-      set_main_scene: "set_main_scene",
-      add_input_action: "add_input_action",
-      enable_plugin: "enable_plugin",
-      disable_plugin: "disable_plugin",
-      add_audio_bus: "create_audio_bus",
-      set_audio_bus_effect: "set_audio_bus_effect",
-      set_audio_bus_volume: "set_audio_bus_volume"
-    }),
-    project_import: dictionary({
-      status: "get_import_status",
-      options: "get_import_options",
-      set_options: "set_import_options",
-      reimport: "reimport_resource",
-      uid: "get_uid",
-      refresh_uids: "resave_resources",
-      refresh_classes: "refresh_class_cache"
-    }),
-    project_export: dictionary({ list: "list_export_presets" }),
-    script_edit: dictionary({ create: "create_script", modify: "modify_script" }),
-    script_info: dictionary({ structure: "get_script_info" }),
-    editor_classes: dictionary({
-      query: "query_classes",
-      info: "query_class_info",
-      inheritance: "inspect_inheritance"
-    })
-  });
   PROJECT_INFO_SECTIONS = dictionary({
     autoloads: { operation: "list_autoloads", params: () => ({}) },
     plugins: { operation: "list_plugins", params: () => ({}) },
@@ -39840,6 +39939,7 @@ import { existsSync as existsSync8, mkdirSync as mkdirSync4, readdirSync as read
 import { basename, dirname as dirname4, join as join9 } from "node:path";
 
 // src/tool-reference.ts
+init_headless_operations();
 init_tool_definitions();
 function namedType(declared) {
   if (typeof declared === "string") {
@@ -39850,6 +39950,22 @@ function namedType(declared) {
   }
   return "any";
 }
+function headlessSection() {
+  const byTool = Object.entries(HEADLESS_OPERATIONS).map(([tool, ops]) => `\`${tool}\` (${Object.keys(ops).join(", ")})`).sort();
+  return [
+    "## What a gate can call",
+    "",
+    "These answer from a short-lived headless engine: no editor window, no port, no running game,",
+    "and nothing left behind. They are the only calls worth putting in a push gate, because every",
+    "other tool needs an editor somebody has open or a game somebody is running.",
+    "",
+    ...byTool.map((line) => `- ${line}`),
+    "",
+    "Everything else needs the editor (`editor_*`, `debug_*`, `scene_*`, `resource_*`) or a running",
+    "game (`runtime_*`).",
+    ""
+  ];
+}
 function renderToolsMarkdown() {
   const lines = [
     "# Tools",
@@ -39860,7 +39976,8 @@ function renderToolsMarkdown() {
     "Every call takes `projectPath`, except the `runtime_*` and `debug_*` tools, where it picks",
     "between running games. Answers are read from the engine after the change, not echoed from the",
     "request. Engine stderr comes back under `engine_messages`.",
-    ""
+    "",
+    ...headlessSection()
   ];
   for (const tool of TOOL_SPECS) {
     lines.push(`## ${tool.name}`, "", tool.description, "");
@@ -39951,7 +40068,8 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
 | Answer a dialog | \`runtime_input click\` on its button, or \`key\` Escape to dismiss it: an [AcceptDialog] reads that key itself and never asks the InputMap, so \`ui_cancel\` leaves it standing |
 | Press a bound key | \`runtime_input action\` or \`key\`, a whole press unless you hold it |
 | Where a 3D node is on screen | \`runtime_inspect\` \`rect\`, rather than unprojecting by hand |
-| Wait for something | \`runtime_wait\`, never a sleep; \`until\` with \`says\` for a panel that rebuilds its own labels |
+| Wait for something in a running game | \`runtime_wait\`, never a sleep; \`until\` with \`says\` for a panel that rebuilds its own labels |
+| 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 |
 | A picture, for a person who asked to see one | \`runtime_capture\` |
 
 These need the runtime autoload, which \`gdharness setup\` registers. \`runtime_capture\` needs a

package/build/godot/addons/auto_reload/auto_reload.gd

@@ -16,7 +16,12 @@ var _watched_files: Dictionary = {}
 func _enter_tree() -> void:
 	_timer = Timer.new()
 	_timer.wait_time = CHECK_INTERVAL_SECONDS
-	_timer.timeout.connect(_check_for_changes)
+	# int rather than Error: Signal.connect answers with a plain int, where Object.connect answers
+	# with the enum, and a project holding int_as_enum_without_cast at error level refuses the
+	# assignment that conflates them.
+	var watching: int = _timer.timeout.connect(_check_for_changes)
+	if watching != OK:
+		push_error("gdharness: could not start watching for changes on disk")
 	add_child(_timer)
 	_timer.start()
 	_update_watched_files()
@@ -79,7 +84,9 @@ func _check_for_changes() -> void:
 
 func _reload_script(path: String) -> void:
 	print("[gdharness] Script changed on disk, reloading: ", path)
-	ResourceLoader.load(path, "", ResourceLoader.CACHE_MODE_REPLACE)
+	var reloaded: Resource = ResourceLoader.load(path, "", ResourceLoader.CACHE_MODE_REPLACE)
+	if reloaded == null:
+		push_error("gdharness: could not reload " + path + " from disk")
 
 
 func _reload_scene(path: String) -> void:

package/build/godot/addons/gdharness_editor/bridge_client.gd

@@ -8,6 +8,8 @@ signal connected
 signal disconnected
 signal tool_requested(request_id: String, tool_name: String, args: Dictionary)
 
+const Read = preload("reading.gd")
+
 const DEFAULT_URL: String = "ws://127.0.0.1:6505/godot"
 ## Written beside the addon by the install, so it names the version this copy came from.
 const VERSION_MARKER: String = "res://addons/gdharness_editor/.gdharness-version"
@@ -88,7 +90,9 @@ func _ready() -> void:
 
 	_reconnect_timer = Timer.new()
 	_reconnect_timer.one_shot = true
-	_reconnect_timer.timeout.connect(_on_reconnect_timer)
+	var waiting: int = _reconnect_timer.timeout.connect(_on_reconnect_timer)
+	if waiting != OK:
+		push_error("gdharness: could not arm the reconnect timer")
 	add_child(_reconnect_timer)
 
 	set_process(true)
@@ -227,9 +231,9 @@ func announced_url() -> String:
 		return ""
 
 	var announcement: Dictionary = said
-	if int(announcement.get("protocol", 0)) != ANNOUNCE_PROTOCOL:
+	if Read.as_int(announcement.get("protocol", 0)) != ANNOUNCE_PROTOCOL:
 		return ""
-	var port: int = int(announcement.get("port", 0))
+	var port: int = Read.as_int(announcement.get("port", 0))
 	if port < 1 or port > 65535:
 		return ""
 	var host: String = str(announcement.get("host", "127.0.0.1"))
@@ -332,7 +336,7 @@ func _serving(setting: String) -> int:
 	var settings: EditorSettings = EditorInterface.get_editor_settings()
 	if settings == null or not settings.has_setting(setting):
 		return 0
-	return int(settings.get_setting(setting))
+	return Read.as_int(settings.get_setting(setting))
 
 
 ## The version marker beside this addon, or "" when the copy was not installed by gdharness.
@@ -434,7 +438,9 @@ func send_tool_result(request_id: String, success: bool, result: Variant = null,
 
 func _send_message(message: Dictionary) -> void:
 	if socket.get_ready_state() == WebSocketPeer.STATE_OPEN:
-		socket.send_text(JSON.stringify(message))
+		var sent: Error = socket.send_text(JSON.stringify(message))
+		if sent != OK:
+			push_error("gdharness: could not send to the server: " + error_string(sent))
 
 
 func is_connected_to_server() -> bool:

package/build/godot/addons/gdharness_editor/plugin.gd

@@ -23,9 +23,9 @@ func _enter_tree() -> void:
 	add_child(_tool_executor)
 	_tool_executor.set_editor_plugin(self)
 
-	_client.connected.connect(_on_connected)
-	_client.disconnected.connect(_on_disconnected)
-	_client.tool_requested.connect(_on_tool_requested)
+	_listen(_client.connected, _on_connected)
+	_listen(_client.disconnected, _on_disconnected)
+	_listen(_client.tool_requested, _on_tool_requested)
 
 	_setup_status_indicator()
 	_client.connect_to_server()
@@ -53,6 +53,18 @@ func _exit_tree() -> void:
 		_status_label = null
 
 
+# A failed connect is a mistake in this plugin rather than anything the editor did, so it goes to
+# the error stream instead of being dropped: a project holding return_value_discarded at error level
+# refuses to compile a script that throws the answer away.
+func _listen(source: Signal, handler: Callable) -> void:
+	# int rather than Error: Signal.connect answers with a plain int, where Object.connect answers
+	# with the enum, and a project holding int_as_enum_without_cast at error level refuses the
+	# assignment that conflates them.
+	var joined: int = source.connect(handler)
+	if joined != OK:
+		push_error("gdharness: could not listen to " + source.get_name())
+
+
 func _setup_status_indicator() -> void:
 	_status_label = Label.new()
 	_status_label.text = "gdharness: connecting"
@@ -82,7 +94,8 @@ func _on_tool_requested(request_id: String, tool_name: String, args: Dictionary)
 
 	if success:
 		var payload: Dictionary = result.duplicate(true)
-		payload.erase("ok")
+		if not payload.erase("ok"):
+			push_error("gdharness: a tool answered ok without an ok field to remove")
 		_client.send_tool_result(request_id, true, payload, "")
 	else:
 		_client.send_tool_result(request_id, false, null, str(result.get("error", "Unknown error")))

package/build/godot/addons/gdharness_editor/reading.gd

@@ -0,0 +1,64 @@
+extends RefCounted
+
+# A value out of a request that arrived as JSON, as the type the caller wants.
+#
+# `int(value)`, `float(value)` and `bool(value)` take a Variant, and a project holding
+# `unsafe_call_argument` at error level will not compile a script that hands one over. The
+# conversion is the same; what changes is that the type is established first, on a typed local, and
+# the conversion happens from that.
+#
+# A copy rather than a preload of the one beside the operations, because an addon is installed as a
+# directory and has to hold everything it uses. Reaching into the runtime addon instead would tie an
+# editor tool to a directory that ships inside exported games.
+#
+# `fallback` answers a value that is there and is null, which is a caller sending JSON null where a
+# number was expected. Absent keys never reach here: the callers pass their own default to
+# `Dictionary.get`, so what arrives is that default.
+
+
+static func as_int(value: Variant, fallback: int = 0) -> int:
+	if value is int:
+		var already: int = value
+		return already
+	if value is float:
+		var real: float = value
+		return int(real)
+	if value is bool:
+		var flag: bool = value
+		return 1 if flag else 0
+	if value is String:
+		var text: String = value
+		return text.to_int()
+	return fallback
+
+
+static func as_float(value: Variant, fallback: float = 0.0) -> float:
+	if value is float:
+		var already: float = value
+		return already
+	if value is int:
+		var whole: int = value
+		return float(whole)
+	if value is bool:
+		var flag: bool = value
+		return 1.0 if flag else 0.0
+	if value is String:
+		var text: String = value
+		return text.to_float()
+	return fallback
+
+
+static func as_bool(value: Variant, fallback: bool = false) -> bool:
+	if value is bool:
+		var already: bool = value
+		return already
+	if value is int:
+		var whole: int = value
+		return whole != 0
+	if value is float:
+		var real: float = value
+		return not is_zero_approx(real)
+	if value is String:
+		var text: String = value
+		return not text.is_empty()
+	return fallback

package/build/godot/addons/gdharness_editor/reading.gd.uid

@@ -0,0 +1 @@
+uid://xl0fokpr7xfd