gdharness 1.2.35 → 1.2.37

package/build/index.js

@@ -3373,7 +3373,8 @@ import {
   readFileSync as readFileSync24,
   readSync as readSync2,
   rmdirSync as rmdirSync2,
-  statSync as statSync12
+  statSync as statSync12,
+  writeFileSync as writeFileSync16
 } from "node:fs";
 import { basename as basename7, dirname as dirname18, extname as extname4, isAbsolute as isAbsolute4, join as join26, normalize as normalize2, relative as relative5 } from "node:path";
 import { setTimeout as delay5 } from "node:timers/promises";
@@ -32974,6 +32975,7 @@ var AGAIN_AFTER_MS = [250, 500, 1000, 2000, 4000, 8000, 16000];
 var waiting = new Set;
 var atExit = new Set;
 var KINDS = [
+  "answers",
   "desktop",
   "export",
   "import",
@@ -33078,8 +33080,14 @@ function snakeCased(params) {
 }
 function engineExtras(outcome) {
   const after = outcome.afterAnswerMessages ?? [];
+  const before = outcome.beforeOperationMessages ?? [];
   return {
     ...outcome.messages.length > 0 ? { engine_messages: outcome.messages } : {},
+    ...before.length > 0 ? {
+      engine_messages_before_operation: before,
+      engine_messages_before_operation_note: BEFORE_OPERATION_NOTE
+    } : {},
+    ...outcome.beforeOperationOmitted === undefined ? {} : { engine_messages_before_operation_omitted: outcome.beforeOperationOmitted },
     ...outcome.messagesOmitted === undefined ? {} : { engine_messages_omitted: outcome.messagesOmitted },
     ...after.length > 0 ? { engine_messages_after_answer: after, engine_messages_after_answer_note: AFTER_ANSWER_NOTE } : {},
     ...outcome.afterAnswerOmitted === undefined ? {} : { engine_messages_after_answer_omitted: outcome.afterAnswerOmitted },
@@ -33087,8 +33095,11 @@ function engineExtras(outcome) {
   };
 }
 var AFTER_ANSWER_NOTE = "Printed after this operation had written its answer, while the engine ran the project's autoloads and shut down: Godot starts a project's autoloads in every script run and cannot be told not to. An error raised in a project script here is that autoload's own, and none of these changes the answer.";
+var BEFORE_OPERATION_NOTE = "Printed while the engine started the project's autoloads, before this operation ran: an operation that compiles the project's scripts waits for them, because the engine knows an autoload's name only once it is in the tree. An error raised in a project script here is that autoload's own.";
 var OWN_ERROR = "[ERROR] ";
 var ANSWERED = "[gdharness] answered";
+var WAITING = "[gdharness] waiting for the autoloads";
+var BEGUN = "[gdharness] begun";
 var MESSAGES_KEPT = 200;
 var ERRORS_NAMED = 3;
 function problemsIn(log) {
@@ -33229,12 +33240,22 @@ async function runOperation(engine, operation, params, projectPath) {
     discard(paramsDir);
   }
   const everything = ran.log.everything();
-  const answered = everything.findIndex((entry) => entry.source === "stderr" && entry.text === ANSWERED);
-  const problems = problemsAmong(answered === -1 ? everything : everything.slice(0, answered));
+  const marked = (text) => everything.findIndex((entry) => entry.source === "stderr" && entry.text === text);
+  const answered = marked(ANSWERED);
+  const waiting = marked(WAITING);
+  const begun = marked(BEGUN);
+  const ended = answered === -1 ? everything.length : answered;
+  const problems = waiting === -1 ? problemsAmong(everything.slice(0, ended)) : problemsAmong([
+    ...everything.slice(0, waiting),
+    ...begun === -1 ? [] : everything.slice(begun + 1, ended)
+  ]);
+  const startup = waiting === -1 ? [] : problemsAmong(everything.slice(waiting + 1, begun === -1 ? ended : begun));
   const after = answered === -1 ? [] : problemsAmong(everything.slice(answered + 1));
   const afterAnswered = {
     ...after.length === 0 ? {} : { afterAnswerMessages: after.slice(-MESSAGES_KEPT) },
-    ...after.length > MESSAGES_KEPT ? { afterAnswerOmitted: after.length - MESSAGES_KEPT } : {}
+    ...after.length > MESSAGES_KEPT ? { afterAnswerOmitted: after.length - MESSAGES_KEPT } : {},
+    ...startup.length === 0 ? {} : { beforeOperationMessages: startup.slice(-MESSAGES_KEPT) },
+    ...startup.length > MESSAGES_KEPT ? { beforeOperationOmitted: startup.length - MESSAGES_KEPT } : {}
   };
   if (answer.kind === "unreadable") {
     return {
@@ -33245,6 +33266,14 @@ async function runOperation(engine, operation, params, projectPath) {
     };
   }
   if (answer.kind === "none") {
+    if (waiting !== -1 && begun === -1) {
+      return {
+        ok: false,
+        message: `${operation} never ran: the engine ended (${howItEnded(ran)}) while it started the project's ` + `autoloads, which this operation waits for. The last it reported: ${reason(ran.log, startup)}`,
+        ...reported2(problems),
+        ...afterAnswered
+      };
+    }
     const refusals = refusalsIn(ran.log);
     if (refusals.length > 0) {
       const said = new Set(refusals.map((entry) => entry.index));
@@ -33686,6 +33715,31 @@ ${note}`;
     return detail === entry.detail ? entry : { ...entry, detail };
   });
 }
+var MOST_REPORTS_SHOWN = 20;
+var LONGEST_DETAIL = 20000;
+function shortened(detail) {
+  if (detail === null || detail.length <= LONGEST_DETAIL) {
+    return detail;
+  }
+  return `${detail.slice(0, LONGEST_DETAIL)}
+[${detail.length - LONGEST_DETAIL} more characters left out]`;
+}
+function foldedReports(reports) {
+  const first = new Map;
+  for (const report of reports) {
+    const key = JSON.stringify([report.kind, report.message, report.detail]);
+    const seen = first.get(key);
+    if (seen === undefined) {
+      first.set(key, { report, times: 1 });
+    } else {
+      seen.times += 1;
+    }
+  }
+  return [...first.values()].map(({ report, times }) => {
+    const kept = { ...report, detail: shortened(report.detail) };
+    return times === 1 ? kept : { ...kept, times };
+  });
+}
 function failedCases(report, printed) {
   const cases = report.suites.flatMap((suite) => suite.cases.filter((entry) => entry.status === "failed" || entry.status === "error").map((entry) => ({ entry, path: suite.path })));
   const read = withActualsPrinted(cases.flatMap(({ entry }) => entry.reports), printed);
@@ -33693,6 +33747,8 @@ function failedCases(report, printed) {
   return cases.map(({ entry, path }) => {
     const reports = read.slice(next, next + entry.reports.length);
     next += entry.reports.length;
+    const folded = foldedReports(reports);
+    const shown = folded.slice(0, MOST_REPORTS_SHOWN);
     return {
       suite: entry.suite,
       name: entry.name,
@@ -33700,11 +33756,34 @@ function failedCases(report, printed) {
       time: entry.time,
       path,
       message: reports[0]?.message ?? null,
-      detail: reports[0]?.detail ?? null,
-      ...reports.length > 1 ? { reports } : {}
+      detail: shortened(reports[0]?.detail ?? null),
+      ...reports.length > 1 ? { reports: shown, reportCount: reports.length } : {},
+      ...folded.length > shown.length ? { reportsLeftOut: folded.length - shown.length } : {}
     };
   });
 }
+function failedWithin(failed, budget) {
+  const sizes = failed.map((entry) => JSON.stringify(entry).length);
+  const smallestFirst = sizes.map((_, index) => index).sort((a, b) => (sizes[a] ?? 0) - (sizes[b] ?? 0));
+  const whole = new Set;
+  let spent = 0;
+  for (const index of smallestFirst) {
+    const size = sizes[index] ?? 0;
+    if (spent + size > budget) {
+      break;
+    }
+    spent += size;
+    whole.add(index);
+  }
+  const kept = failed.map((entry, index) => {
+    if (whole.has(index)) {
+      return entry;
+    }
+    const { detail: _detail, reports: _reports, reportsLeftOut: _left, ...named } = entry;
+    return { ...named, message: entry.message?.slice(0, 500) ?? null, detail: null };
+  });
+  return { failed: kept, briefed: failed.length - whole.size };
+}
 var MASKED_BRACKET = "[lb]";
 function masked(expected, actual) {
   const allSpelled = (value) => !PRINTED_DICTIONARY.test(value) && value.split("[").length === value.split(MASKED_BRACKET).length;
@@ -34899,6 +34978,8 @@ var SCENE_PATH = {
   type: "string",
   description: 'Scene file inside the project, such as "scenes/main.tscn" or "res://scenes/main.tscn".'
 };
+var WITHOUT_AN_EDITOR = "Through the editor when one serves the project; with none, a headless engine runs the editor's own tool and the answer says so under writtenBy, or readBy for a read. That engine runs every script of the file, where the editor runs only tool scripts, so what a script changes as the file loads or as a property is set is put back before anything is saved, and a file where that cannot be done, such as a scene whose script does not compile, is refused and nothing is written. An editor of the project that is running and has not reached this server is waited for rather than written around.";
+var WHOLE_NUMBERS = 'A whole number of 2^53 or more, such as a 64-bit seed or a resource uid, is written as its digits, {"_type": "int", "value": "9007199254740993"}, the form a read answers with: a JSON number that large can arrive as a neighbour of the one sent, so sent as a number it is refused.';
 var SCRIPT_PATH = {
   type: "string",
   description: 'Script file inside the project, such as "scripts/player.gd".'
@@ -34911,7 +34992,7 @@ var NODE_PATH = {
 };
 var PROPERTIES = {
   type: "object",
-  description: 'Properties to set, keyed by Godot property name. Vectors, colours and the like may be written as {"x": 1, "y": 2} or tagged {"_type": "Vector2", "x": 1, "y": 2}, which is the form a read answers with, so a value read off one node can be written straight to another. A key may also be a colon path into one of the components of a vector, a colour, a rectangle or a transform, as GDScript names them, so one axis is written alone: "position:x", "modulate:a", "region_rect:size:y"; a component the value does not have is refused, naming the ones it has. A property holding a node takes the path to it from the node being set, such as "../Player". Each value is read back once set, and one the engine changed or refused is refused with what it holds.',
+  description: `Properties to set, keyed by Godot property name. Vectors, colours and the like may be written as {"x": 1, "y": 2} or tagged {"_type": "Vector2", "x": 1, "y": 2}, which is the form a read answers with, so a value read off one node can be written straight to another. A key may also be a colon path into one of the components of a vector, a colour, a rectangle or a transform, as GDScript names them, so one axis is written alone: "position:x", "modulate:a", "region_rect:size:y"; a component the value does not have is refused, naming the ones it has. A property holding a node takes the path to it from the node being set, such as "../Player". Each value is read back once set, and one the engine changed or refused is refused with what it holds. ${WHOLE_NUMBERS}`,
   additionalProperties: true
 };
 var XY = {
@@ -34955,7 +35036,10 @@ var SCRIPT_MODIFICATIONS = {
       name: { type: "string" },
       params: { type: "string", description: 'Functions and signals: the parameter list, "delta: float".' },
       returnType: { type: "string", description: "Functions: the return type." },
-      body: { type: "string", description: "Functions: the body." },
+      body: {
+        type: "string",
+        description: "Functions: the body, its lines separated by \\n. Indent shared by every line is taken off and one tab put on, so it can be written indented or not."
+      },
       varType: {
         type: "string",
         description: "Variables and constants: the type annotation; without one, the type the value evaluates to."
@@ -35058,7 +35142,7 @@ var TOOL_SPECS = [
   {
     name: "project_settings",
     title: "Project settings",
-    description: "Reads or writes project.godot: settings, autoloads, the main scene, input actions, plugins and audio buses. A write with an editor open on the project is handed to the editor, which takes the settings the write changed or names from the file (named under editorAdopted), including a setting the file already held, since the editor can hold another value after the file was put back, or reloads the bus layout, so it answers the new values and does not save the old ones back over them. editorNote is an editor that could not take the write, one on an addon from before this, which still holds the old values until editor_launch restart. An enabled plugin's code still loads on the editor's next start. set answers old_value and new_value, with was_new true when project.godot did not set the setting before, and was_default true when what it held was the engine's own default, which old_value then is. add_input_action on an action that exists, one of the engine's ui_ actions included, replaces its events and deadzone, and answers was_new false with what it held under old_events and old_deadzone. A set of the value the setting already holds, in the same type, writes nothing and answers unchanged true and saved false. Every write keeps the sections and keys of project.godot in the order the file had them, so a change touches only its own lines. get answers exists, true for any setting the engine knows, and at_default, true when the value is the engine's own default and so has no line in project.godot. Each setting under prefix carries at_default too, so a family read separates what the project sets from the engine's defaults; it is absent for a setting the engine registers no default for, such as an input action the project added, which only the project can have set.",
+    description: "Reads or writes project.godot: settings, autoloads, the main scene, input actions, plugins and audio buses. A write with an editor open on the project is handed to the editor, which takes the settings the write changed or names from the file (named under editorAdopted), including a setting the file already held, since the editor can hold another value after the file was put back, or reloads the bus layout, so it answers the new values and does not save the old ones back over them. editorNote is an editor that could not take the write, one on an addon from before this, which still holds the old values until editor_launch restart. An enabled plugin's code still loads on the editor's next start. set answers old_value and new_value, with was_new true when project.godot did not set the setting before, and was_default true when what it held was the engine's own default, which old_value then is. add_input_action on an action that exists, one of the engine's ui_ actions included, replaces its events and deadzone, and answers was_new false with what it held under old_events and old_deadzone. A set of the value the setting already holds, in the same type, writes nothing and answers unchanged true and saved false. Every write keeps the sections and keys of project.godot in the order the file had them, so a change moves no other line; the save is the engine's, and like the editor's it writes Godot's header and config/features into a file that lacks them. get answers exists, true for any setting the engine knows, and at_default, true when the value is the engine's own default and so has no line in project.godot. Each setting under prefix carries at_default too, so a family read separates what the project sets from the engine's defaults; it is absent for a setting the engine registers no default for, such as an input action the project added, which only the project can have set.",
     parameters: {
       projectPath: PROJECT_PATH2,
       setting: {
@@ -35215,7 +35299,7 @@ var TOOL_SPECS = [
       direction: {
         type: "string",
         enum: ["forward", "reverse"],
-        description: "forward: what this resource loads, with cycles reported. reverse: every file that refers to it and how, a scene instancing it, a script extending, preloading or loading it, and for a script with a class_name every use of that name. Each reference carries a kind, and two of them are mentions rather than uses: doc is a name inside a ## documentation comment, which renaming would break in the generated docs, and comment is one in ordinary prose, which it would only make stale. summary.in_code is the count with both of those left out, which is the number to read when the question is whether anything still uses this. Default forward."
+        description: "forward: what this resource loads, with cycles reported, a script's dependencies including every script whose class_name it uses, marked by_class with the name. summary.total_dependencies counts each file once however many places load it, and total_references counts the entries in the tree. reverse: every file that refers to it and how, a scene instancing it, a script extending, preloading or loading it, and for a script with a class_name every use of that name. Each reference carries a kind: ext_resource, extends, preload, load or path for a reference by path; setting, plugin, export_preset and import for one in project.godot, a plugin.cfg, export_presets.cfg or an import sidecar; class_name for a use of the declared name, the declaration itself being the script asked about. Two kinds are mentions rather than uses: doc is a name inside a ## documentation comment, which renaming would break in the generated docs, and comment is one in ordinary prose, which it would only make stale. summary.in_code is the count with both of those left out, which is the number to read when the question is whether anything still uses this. Default forward."
       },
       depth: { type: "number", description: "forward: how many levels to follow. Default unlimited." },
       includeBuiltin: {
@@ -35236,24 +35320,32 @@ var TOOL_SPECS = [
     description: "The import pipeline: what needs importing, how a resource is imported, reimports, UIDs, and the global class list the editor and the engine read.",
     parameters: {
       projectPath: PROJECT_PATH2,
-      resourcePath: RESOURCE_PATH,
+      resourcePath: { ...RESOURCE_PATH, ops: ["status", "options", "set_options", "uid", "reimport"] },
       includeUpToDate: {
         type: "boolean",
+        ops: ["status"],
         description: "status: list resources that are current as well. Default false."
       },
       options: {
         type: "object",
+        ops: ["set_options"],
         description: `set_options: import options keyed as the .import file spells them, {"compress/mode": 1}. A dictionary option whose keys are numbers, a font's opentype_features or any option already holding number keys, takes them written as strings of digits, and opentype_features also takes an OpenType tag by its four-letter name: {"opentype_features": {"liga": 0}} turns ligatures off. Both are written as the numbers the engine reads.`,
         additionalProperties: true
       },
       reimport: {
         type: "boolean",
+        ops: ["set_options"],
         description: "set_options: reimport afterwards, answered under reimport as project_import reimport answers. Default true."
       },
-      force: { type: "boolean", description: "reimport: reimport even what is current. Default false." },
+      force: {
+        type: "boolean",
+        ops: ["reimport"],
+        description: "reimport: reimport even what is current. Default false."
+      },
       timeoutMs: {
         type: "integer",
         minimum: 1,
+        ops: ["reimport", "set_options"],
         description: "reimport, set_options: how long to wait for the editor to finish reimporting. Default 300000."
       }
     },
@@ -35331,7 +35423,7 @@ var TOOL_SPECS = [
     name: "project_test",
     title: "Run tests",
     effect: "additive",
-    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. Each entry under failed carries its first report as message and detail, and, when it has more than one, every report under reports in the order the case met them: gdUnit4 goes on past a failed assertion, and a case can fail several and then stop on a runtime error, which makes its status error. failures counts the cases that failed an assertion and errors the cases that hit an error, so such a case counts in both. 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.",
+    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. Each entry under failed carries its first report as message and detail, and, when it has more than one, its reports under reports in the order the case met them: gdUnit4 goes on past a failed assertion, and a case can fail several and then stop on a runtime error, which makes its status error. Identical reports fold into one with times, at most twenty different ones are kept (reportsLeftOut counts the rest), and past about a megabyte the largest cases keep only their first message (failedWithoutDetail). failures counts the cases that failed an assertion and errors the cases that hit an error, so such a case counts in both. 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_PATH2,
       path: {
@@ -35368,7 +35460,7 @@ var TOOL_SPECS = [
   {
     name: "scene_create",
     title: "Create or save a scene",
-    description: "Creates a scene file where none is, saves one, or saves a copy under a new path. A save of a scene open in the editor saves the editor's copy, unsaved changes included. Needs the editor connected.",
+    description: `Creates a scene file where none is, saves one, or saves a copy under a new path. A save of a scene open in the editor saves the editor's copy, unsaved changes included. ${WITHOUT_AN_EDITOR}`,
     parameters: {
       projectPath: PROJECT_PATH2,
       scenePath: SCENE_PATH,
@@ -35413,17 +35505,19 @@ var TOOL_SPECS = [
   {
     name: "scene_node",
     title: "Scene nodes",
-    description: "One node in a scene file: add, read, set, duplicate, reparent or delete it, or paint TileMap cells. Any ClassDB node type can be added, so a NavigationRegion2D, an AnimationTree or a Camera3D is an add with that nodeType and its properties, and another scene is instanced by an add with instancePath. set with name renames a node. A property holding a Resource takes the res:// path of one, so a texture, a material or a theme is a set like any other. A write is refused while the editor holds unsaved changes to the scene, and for a node that belongs to a scene this one instances or inherits. Needs the editor connected.",
+    description: `One node in a scene file: add, read, set, duplicate, reparent or delete it, or paint TileMap cells. Any ClassDB node type can be added, so a NavigationRegion2D, an AnimationTree or a Camera3D is an add with that nodeType and its properties, and another scene is instanced by an add with instancePath. A set with properties {"name": "Boss"} renames a node. A property holding a Resource takes the res:// path of one, so a texture, a material or a theme is a set like any other. A write is refused while the editor holds unsaved changes to the scene, and for a node that belongs to a scene this one instances or inherits. ${WITHOUT_AN_EDITOR}`,
     parameters: {
       projectPath: PROJECT_PATH2,
       scenePath: SCENE_PATH,
-      nodePath: NODE_PATH,
+      nodePath: { ...NODE_PATH, ops: ["get", "set", "duplicate", "reparent", "delete", "set_tilemap_cells"] },
       parentNodePath: {
         type: "string",
+        ops: ["add", "duplicate"],
         description: "add: where the node goes. Default the root. duplicate: where the copy goes."
       },
       nodeType: {
         type: "string",
+        ops: ["add"],
         description: 'add: the node class, such as "CharacterBody2D". Give this or instancePath.'
       },
       instancePath: {
@@ -35431,11 +35525,12 @@ var TOOL_SPECS = [
         ops: ["add"],
         description: `add: a scene to instance as the new node instead of a class, such as "ui/panel.tscn". It is saved as an instance of that file, the way the editor's Instantiate Child Scene saves one, so changes to that scene reach it; properties set its root. A scene that is the target or instances it is refused.`
       },
-      nodeName: { type: "string", description: "add: the new node's name." },
-      properties: PROPERTIES,
-      newName: { type: "string", description: "duplicate: the copy's name." },
+      nodeName: { type: "string", ops: ["add"], description: "add: the new node's name." },
+      properties: { ...PROPERTIES, ops: ["add", "set"] },
+      newName: { type: "string", ops: ["duplicate"], description: "duplicate: the copy's name." },
       newParentPath: {
         type: "string",
+        ops: ["reparent"],
         description: "reparent: the new parent, which may be the one it has, to move it among its siblings."
       },
       index: {
@@ -35446,13 +35541,15 @@ var TOOL_SPECS = [
       },
       includeDefaults: {
         type: "boolean",
+        ops: ["get"],
         description: "get: include properties still at their default. Default false."
       },
       layer: {
         type: "number",
+        ops: ["set_tilemap_cells"],
         description: "set_tilemap_cells: the layer of a TileMap. Default 0. A TileMapLayer is one layer."
       },
-      cells: TILEMAP_CELLS
+      cells: { ...TILEMAP_CELLS, ops: ["set_tilemap_cells"] }
     },
     requires: ["projectPath", "scenePath"],
     operations: {
@@ -35492,16 +35589,32 @@ var TOOL_SPECS = [
   {
     name: "scene_signal",
     title: "Scene signals",
-    description: "Signal connections in a scene file. Each connection answers with its flags as the number and as flagNames; persist is on every connection, since a scene saves no other kind. A connect of a pair already connected says alreadyConnected, with flagsBefore when it changed the flags. Needs the editor connected.",
+    description: `Signal connections in a scene file. Each connection answers with its flags as the number and as flagNames; persist is on every connection, since a scene saves no other kind. A connect of a pair already connected says alreadyConnected, with flagsBefore when it changed the flags. ${WITHOUT_AN_EDITOR}`,
     parameters: {
       projectPath: PROJECT_PATH2,
       scenePath: SCENE_PATH,
-      sourceNodePath: { type: "string", description: "The node that emits." },
-      signalName: { type: "string", description: 'The signal it emits, such as "pressed".' },
-      targetNodePath: { type: "string", description: "The node whose method is called." },
-      methodName: { type: "string", description: "The method on that node, called when it emits." },
-      flags: { type: "number", description: "connect: Object.ConnectFlags, such as 1 for deferred." },
-      nodePath: { type: "string", description: "list: only connections involving this node." }
+      sourceNodePath: { type: "string", ops: ["connect", "disconnect"], description: "The node that emits." },
+      signalName: {
+        type: "string",
+        ops: ["connect", "disconnect"],
+        description: 'The signal it emits, such as "pressed".'
+      },
+      targetNodePath: {
+        type: "string",
+        ops: ["connect", "disconnect"],
+        description: "The node whose method is called."
+      },
+      methodName: {
+        type: "string",
+        ops: ["connect", "disconnect"],
+        description: "The method on that node, called when it emits."
+      },
+      flags: {
+        type: "number",
+        ops: ["connect"],
+        description: "connect: Object.ConnectFlags, such as 1 for deferred."
+      },
+      nodePath: { type: "string", ops: ["list"], description: "list: only connections involving this node." }
     },
     requires: ["projectPath", "scenePath"],
     operations: {
@@ -35626,18 +35739,28 @@ var TOOL_SPECS = [
     parameters: {
       projectPath: PROJECT_PATH2,
       scriptPath: SCRIPT_PATH,
-      className: { type: "string", description: "create: a class_name for the script. Not with content." },
-      extends: { type: "string", description: "create: the base class. Default Node. Not with content." },
+      className: {
+        type: "string",
+        ops: ["create"],
+        description: "create: a class_name for the script. Not with content."
+      },
+      extends: {
+        type: "string",
+        ops: ["create"],
+        description: "create: the base class. Default Node. Not with content."
+      },
       content: {
         type: "string",
+        ops: ["create"],
         description: "create: the whole file, written as given, instead of a template, className and extends."
       },
       template: {
         type: "string",
         enum: ["singleton", "state_machine", "component", "resource"],
+        ops: ["create"],
         description: "create: a starting shape."
       },
-      modifications: SCRIPT_MODIFICATIONS,
+      modifications: { ...SCRIPT_MODIFICATIONS, ops: ["modify"] },
       symbol: {
         type: "string",
         ops: ["rename"],
@@ -35675,16 +35798,19 @@ var TOOL_SPECS = [
       scriptPath: SCRIPT_PATH,
       includeInherited: {
         type: "boolean",
+        ops: ["structure"],
         description: "structure: also list what the script inherits, walking extends through the project's other scripts. Each such member carries inherited_from, the file declaring it, and the answer gains inherits_from, the chain that was walked. A name the script overrides is listed at both its lines rather than once. A native base is not walked, since it declares nothing in a file: editor_classes info answers for those. Default false."
       },
       line: {
         type: "integer",
         minimum: 1,
+        ops: ["completion", "hover"],
         description: "completion, hover: the line, counted from 1 as the editor shows it."
       },
       character: {
         type: "integer",
         minimum: 1,
+        ops: ["completion", "hover"],
         description: "completion, hover: the column, counted from 1 as the editor shows it, with a tab counted as one. symbols gives each name at the line and column hover is asked at."
       }
     },
@@ -35692,7 +35818,7 @@ var TOOL_SPECS = [
     operations: {
       structure: {
         effect: "read",
-        summary: "functions, variables, signals, class_name and extends, read from the file",
+        summary: "functions, variables, signals, class_name and extends, read from the file, and dependencies: the paths it loads or preloads as written, then the scripts declaring each project class_name its code uses, which classes_used names with the class; autoloads_used names each autoload the code uses by its global name, with the autoload's script, which the project loads rather than this script, so it is not under dependencies",
         requires: []
       },
       symbols: {
@@ -35713,7 +35839,7 @@ var TOOL_SPECS = [
     name: "script_diagnostics",
     title: "Script diagnostics",
     effect: "read",
-    description: "Errors and warnings for a script, or for several, from the editor's language server, and whether each is clean. Needs the editor running. Each diagnostic carries its severity (error or warning), its message, and where it is as the editor shows it: line and column counted from 1, and endLine and endColumn just past its end. Diagnostics are checked against the project's own files, and the two that the files disprove are named rather than passed on: a member the class cache's file declares, or a project class it extends does, a method, property, constant, static function or enum member, comes back under contradictedByTheFile with the script declaring it, and so does one a diagnostic names alone as an external class member, read against the class it is looked up on in the line it is on; and a class this project declares that the diagnostic could not resolve comes back under typesTheEditorHasNotLoaded, with inTheClassCache saying whether a launched game would resolve it. staleAnalysis then says what to do, and for both states it is editor_rescan first: it asks the editor already running, starts nothing, and has cleared each in every reproduction measured. Two exceptions are named when they apply. For an enum member, constant or static function of a global class the reload comes first: in the one project that has reproduced a stale enum member, editor_rescan with reloadScript on the declaring script cleared it and a plain rescan did not. And an editor whose last scan wrote the class cache shorter than the file holds a list behind the files and writes it on every scan, so on that editor the rescan loads nothing and staleAnalysis says editor_launch restart instead. What follows differs: for a stale analysed type, editor_rescan with reloadScript recompiles the held copy and editor_launch restart is the last resort that costs a window; for a class missing from the cache, project_import refresh_classes rewrites the cache from disk at the cost of a short headless engine, which matters beside a running bench.",
+    description: "Errors and warnings for a script, or for several, from the editor's language server, and whether each is clean. With no editor of this project open, so no language server of it to ask, a short headless engine compiles the scripts instead and the answer says checkedBy: engine: every error that stops a script compiling, with its line and no column, dependenciesWithErrors naming the other scripts that failed while it loaded, and warnings null, since the engine reports warnings only to an editor. Each diagnostic carries its severity (error or warning), its message, and where it is as the editor shows it: line and column counted from 1, and endLine and endColumn just past its end. Diagnostics are checked against the project's own files, and the two that the files disprove are named rather than passed on: a member the class cache's file declares, or a project class it extends does, a method, property, constant, static function or enum member, comes back under contradictedByTheFile with the script declaring it, and so does one a diagnostic names alone as an external class member, read against the class it is looked up on in the line it is on; and a class this project declares that the diagnostic could not resolve comes back under typesTheEditorHasNotLoaded, with inTheClassCache saying whether a launched game would resolve it. staleAnalysis then says what to do, and for both states it is editor_rescan first: it asks the editor already running, starts nothing, and has cleared each in every reproduction measured. Two exceptions are named when they apply. For an enum member, constant or static function of a global class the reload comes first: in the one project that has reproduced a stale enum member, editor_rescan with reloadScript on the declaring script cleared it and a plain rescan did not. And an editor whose last scan wrote the class cache shorter than the file holds a list behind the files and writes it on every scan, so on that editor the rescan loads nothing and staleAnalysis says editor_launch restart instead. What follows differs: for a stale analysed type, editor_rescan with reloadScript recompiles the held copy and editor_launch restart is the last resort that costs a window; for a class missing from the cache, project_import refresh_classes rewrites the cache from disk at the cost of a short headless engine, which matters beside a running bench.",
     parameters: {
       projectPath: PROJECT_PATH2,
       scriptPath: {
@@ -35727,7 +35853,7 @@ var TOOL_SPECS = [
   {
     name: "resource_edit",
     title: "Edit resources",
-    description: 'Resource files: read one, create any ClassDB resource as .tres, change one, write a shader, build a TileSet, or set a Theme colour or font size. A material is a create with resourceType StandardMaterial3D, ShaderMaterial or CanvasItemMaterial. read answers with the properties the file sets, in the form modify takes, and a Theme lists its items there as "Button/colors/font_color". move takes any file of the project, a script or an image as much as a resource, or a directory, and works from the files, so it needs no editor; one serving the project is brought up to it as after a move in its own FileSystem dock, its open scenes and cached resources named for the new paths and the project settings the move rewrote taken from the file. read needs no editor either: with none serving the project, a headless engine reads the file. The ops that write a resource need the editor connected.',
+    description: 'Resource files: read one, create any ClassDB resource as .tres, change one, write a shader, build a TileSet, or set a Theme colour or font size. A material is a create with resourceType StandardMaterial3D, ShaderMaterial or CanvasItemMaterial. read answers with the properties the file sets, in the form modify takes, and a Theme lists its items there as "Button/colors/font_color". move takes any file of the project, a script or an image as much as a resource, or a directory, and works from the files, so it needs no editor; one serving the project is brought up to it as after a move in its own FileSystem dock, its open scenes and cached resources named for the new paths and the project settings the move rewrote taken from the file. read needs no editor either: with none serving the project, a headless engine reads the file. The ops that write a resource go through the editor when one serves the project; with none, a headless engine runs the tool the editor would and the answer says so under writtenBy. That engine runs the script of the resource, where the editor runs only tool scripts, so what a script changes as the file loads or as a property is set is put back before the save, and a resource where that cannot be done is refused and the file left as it was.',
     parameters: {
       projectPath: PROJECT_PATH2,
       resourcePath: {
@@ -36078,9 +36204,10 @@ var TOOL_SPECS = [
     description: "The engine's ClassDB: find classes, read one in full, or walk an inheritance tree.",
     parameters: {
       projectPath: PROJECT_PATH2,
-      filter: { type: "string", description: "query: a substring of the class name." },
+      filter: { type: "string", ops: ["query"], description: "query: a substring of the class name." },
       category: {
         type: "string",
+        ops: ["query"],
         enum: [
           "node",
           "node2d",
@@ -36097,9 +36224,21 @@ var TOOL_SPECS = [
         ],
         description: "query: limit to one family."
       },
-      instantiableOnly: { type: "boolean", description: "query: leave out abstract classes. Default false." },
-      className: { type: "string", description: "info, inheritance: the class." },
-      includeInherited: { type: "boolean", description: "info: include inherited members. Default false." },
+      instantiableOnly: {
+        type: "boolean",
+        ops: ["query"],
+        description: "query: leave out abstract classes. Default false."
+      },
+      className: {
+        type: "string",
+        ops: ["info", "inheritance"],
+        description: "info, inheritance: the class."
+      },
+      includeInherited: {
+        type: "boolean",
+        ops: ["info"],
+        description: "info: include inherited members. Default false."
+      },
       member: {
         type: "string",
         ops: ["info"],
@@ -36171,7 +36310,7 @@ var TOOL_SPECS = [
       says: {
         type: "string",
         ops: ["find", "accessibility"],
-        description: 'accessibility: only the elements whose name or value says these words, matched as find matches them, with what they hold. find: part of what the node has written on it as drawn, the way the text op reads it, case-insensitively and with a typed space matching any space the game draws (a non-breaking one included), which is how a button is reached by the word on it rather than by a generated path. Its own text, so a row is found by the label in it, and hidden nodes match. A bare word is a contains; write a glob and it is one, matched against the whole of what the node says, the same as namePattern, and a glob that finds nothing says under note how many nodes it would find open at both ends. A label with a line break is matched with the break in the words, and a backslash followed by n counts as one. Alternatives separated by | match when any one of them does, each by these rules ("*won*|*lost*"); write \\| for a bar that is part of the words.'
+        description: 'accessibility: only the elements whose name, value or value_text says these words, matched as find matches them, with what they hold. find: part of what the node has written on it as drawn, the way the text op reads it, case-insensitively and with a typed space matching any space the game draws (a non-breaking one included), which is how a button is reached by the word on it rather than by a generated path. Its own text, so a row is found by the label in it, and hidden nodes match. A bare word is a contains; write a glob and it is one, matched against the whole of what the node says, the same as namePattern, and a glob that finds nothing says under note how many nodes it would find open at both ends. A label with a line break is matched with the break in the words, and a backslash followed by n counts as one. Alternatives separated by | match when any one of them does, each by these rules ("*won*|*lost*"); write \\| for a bar that is part of the words.'
       },
       limit: {
         type: "integer",
@@ -36202,7 +36341,7 @@ var TOOL_SPECS = [
       tree: { effect: "read", summary: "the live scene tree", requires: [] },
       text: {
         effect: "read",
-        summary: "every line of text under nodePath, the values in its fields included, in the order somebody reads the screen, leaving out what is hidden and everything under it. Every line reads as drawn: rich text without its tags, text only as far as it has been typed out, a translation rather than its key, an upper-case label in capitals and a secret field as its mask. Tab titles, menu bar titles, list items, a tree's column titles and rows, and an open menu's items and the titles of its separators read a line each",
+        summary: "every line of text under nodePath, the values in its fields included, in reading order, leaving out what is hidden and everything under it. Every line reads as drawn: rich text without its tags, text only as far as it has been typed out, a translation rather than its key, an upper-case label in capitals and a secret field as its mask. Tab titles, menu bar titles, list items, a tree's column titles and rows, and an open menu's items and the titles of its separators read a line each",
         requires: []
       },
       find: {
@@ -36222,12 +36361,12 @@ var TOOL_SPECS = [
       },
       metrics: {
         effect: "read",
-        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. physics_steps_per_second is the physics steps taken a second over those frames, fewer than physics_ticks_per_second when a frame needs more than max_physics_steps_per_frame or the editor's Game view slows it. 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. memory_static is what the engine allocated on the CPU side, in bytes; render_video_mem_used, render_texture_mem_used and render_buffer_mem_used are what the renderer has on the GPU, in bytes, which memory_static does not count",
+        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, 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. physics_steps_per_second is the physics steps taken a second over those frames, fewer than physics_ticks_per_second when a frame needs more than max_physics_steps_per_frame or the editor's Game view slows it. 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. Memory, object and render counts are read as asked. memory_static is what the engine allocated on the CPU side, in bytes; render_video_mem_used, render_texture_mem_used and render_buffer_mem_used are what the renderer has on the GPU, in bytes, which memory_static does not count",
         requires: []
       },
       accessibility: {
         effect: "read",
-        summary: "what the game tells a screen reader, read through UI Automation as a Windows screen reader reads it, under windows: one tree per window, each element with its role (text for static text, button, check_box, group for a control holding others), name, value, description, placeholder, bounds in the window's pixels, the actions a reader is offered (click, focus, toggle, set_value, select, expand_collapse, scroll_into_view), and focused on the one with the focus. node is the node that made the element; an element a node made as a part of itself has part_of, the node drawn around it that holds its words, or part_of_candidates where several are, and part: announcement marks the text a window announces through. An empty name is read as nothing: static text takes it from accessibility_update_set_value, and _note counts the text elements on screen with none. tooltip is the node's tooltip_text, which a Windows reader is not told. With nothing focused, the engine calls GdharnessRuntime focused. Needs a windowed run on Windows started with engineArgs [\"--accessibility\", \"always\"] or accessibility_support at Always Active, since the engine builds the tree only when asked; reading takes a second or two",
+        summary: `what the game tells a screen reader, read through UI Automation as a Windows screen reader does, under windows: one tree per window, each element with its role (text for static text, button, check_box, group for a control holding others), name, value, value_text (a range's spoken words, such as "75%"), description, placeholder, bounds in the window's pixels, the actions a reader is offered (click, focus, toggle, set_value, select, expand_collapse, scroll_into_view), and focused on the focused one. node is the node that made the element; a part a node made of itself has part_of, the node drawn around it that holds its words, or part_of_candidates where several are, and part: announcement marks the text a window announces through. An empty name reads as nothing: static text takes it from accessibility_update_set_value, and _note counts the text elements on screen with none. tooltip is the node's tooltip_text, which a Windows reader is not told. With nothing focused, the engine calls GdharnessRuntime focused. Needs a windowed Windows run started with engineArgs ["--accessibility", "always"] or accessibility_support at Always Active, since the engine builds the tree only when asked; reading takes a second or two`,
         requires: []
       }
     },
@@ -36236,7 +36375,7 @@ var TOOL_SPECS = [
   {
     name: "runtime_invoke",
     title: "Set or call in the running game",
-    description: "Sets a property or calls a method on a node, or on one of the engine singletons nodePath names, in the running game. Needs the game running with the runtime addon. The answer carries elapsed_usec, how long the call or the write took inside the game, measured around it there: the round trip to the game is a second or more, so timing from outside measures that instead. Errors and warnings the engine reported while a called method ran come back under errors, the first 20, with errors_not_shown counting the rest. A call that takes longer than timeoutMs is not cancelled: the answer is pending: true with a requestId, the call goes on and does everything it was asked, and op result with that requestId collects its reply once it comes.",
+    description: "Sets a property or calls a method on a node, or on one of the engine singletons nodePath names, in the running game. Needs the game running with the runtime addon. The answer carries elapsed_usec, how long the call or the write took inside the game, measured around it there: the round trip to the game is a second or more, so timing from outside measures that instead. Errors the engine reported while a called method ran come back under errors and warnings under warnings, the first 20 of each, with errors_not_shown and warnings_not_shown counting the rest. A call that takes longer than timeoutMs is not cancelled: the answer is pending: true with a requestId, the call goes on and does everything it was asked, and op result with that requestId collects its reply once it comes.",
     parameters: {
       projectPath: RUNNING_PROJECT_PATH,
       pid: RUNNING_PID,
@@ -36253,7 +36392,7 @@ var TOOL_SPECS = [
       value: {
         ops: ["set"],
         blank: true,
-        description: `set: the value, fitted to the property's type. A number the property would have to cut is refused rather than truncated: a fraction into an int, a number other than 0 or 1 into a bool. A vector, colour or the like may be written as its fields, {"x": 140, "y": 300}, or tagged, {"_type": "Vector2", "x": 140, "y": 300}, which is the form a read answers with. "" writes an empty string. A property typed as or holding an object takes a path naming one the game holds, the way call's args do, and holds that instance, or null, which the text null also means, to empty it. One declared as Variant or untyped takes anything, as the engine does: a value of the kind it holds is fitted to it, an int staying an int, and any other is stored as sent, a fraction into one holding an int included. A typed list or map, such as Array[int] or Dictionary[String, int], takes a JSON list or object with each element fitted to its element type, and an element that cannot become one is refused by its index or key, as is an object of another script than the one the list holds, whether or not that script has a class_name.`
+        description: `set: the value, fitted to the property's type. ${WHOLE_NUMBERS} A number the property would have to cut is refused rather than truncated: a fraction into an int, a number other than 0 or 1 into a bool. A vector, colour or the like may be written as its fields, {"x": 140, "y": 300}, or tagged, {"_type": "Vector2", "x": 140, "y": 300}, which is the form a read answers with. "" writes an empty string. A property typed as or holding an object takes a path naming one the game holds, the way call's args do, and holds that instance, or null, which the text null also means, to empty it. One declared as Variant or untyped takes anything, as the engine does: a value of the kind it holds is fitted to it, an int staying an int, and any other is stored as sent, a fraction into one holding an int included. A typed list or map, such as Array[int] or Dictionary[String, int], takes a JSON list or object with each element fitted to its element type, and an element that cannot become one is refused by its index or key, as is an object of another script than the one the list holds, whether or not that script has a class_name.`
       },
       method: {
         type: "string",
@@ -36263,7 +36402,7 @@ var TOOL_SPECS = [
       args: {
         type: "array",
         ops: ["call"],
-        description: `call: the arguments, fitted to the method's parameter types. A number a parameter would have to cut is refused rather than truncated: a fraction for an int, a number other than 0 or 1 for a bool. A vector, colour or the like may be written as its fields, {"x": 140, "y": 300}, or tagged, {"_type": "Vector2", "x": 140, "y": 300}. A parameter typed as an object takes a path naming one the game holds and is handed that instance: a colon path read from nodePath, "_game:run:wares:3", or one starting at a node, "/root/Main/Hud" or "/root/Main:_game:run". A path that reaches no object, or an object of another class than the parameter declares, is refused, and so are too few or too many arguments. The engine names a parameter typed as a script class without class_name by the class the script extends, so an object of that class with another script passes that check and the engine refuses the call: the answer says the method did not run, with the engine's reason. A parameter typed as a list or map, such as Array[int] or Array[Gear], is built from a JSON list or object element by element, objects named by their paths. The method itself takes its arguments here only: brackets on it holding arguments are refused.`
+        description: `call: the arguments, fitted to the method's parameter types. An RID is passed as the {"_type": "RID", "id": ...} a read answers it with, such as a viewport's for RenderingServer's render timing. ${WHOLE_NUMBERS} A number a parameter would have to cut is refused rather than truncated: a fraction for an int, a number other than 0 or 1 for a bool. A vector, colour or the like may be written as its fields, {"x": 140, "y": 300}, or tagged, {"_type": "Vector2", "x": 140, "y": 300}. A parameter typed as an object takes a path naming one the game holds and is handed that instance: a colon path read from nodePath, "_game:run:wares:3", or one starting at a node, "/root/Main/Hud" or "/root/Main:_game:run". A path that reaches no object, or an object of another class than the parameter declares, is refused, and so are too few or too many arguments. The engine names a parameter typed as a script class without class_name by the class the script extends, so an object of that class with another script passes that check and the engine refuses the call: the answer says the method did not run, with the engine's reason. A parameter typed as a list or map, such as Array[int] or Array[Gear], is built from a JSON list or object element by element, objects named by their paths. The method itself takes its arguments here only: brackets on it holding arguments are refused.`
       },
       properties: {
         type: ["boolean", "array"],
@@ -36356,7 +36495,7 @@ var TOOL_SPECS = [
   {
     name: "runtime_input",
     title: "Send input to the game",
-    description: "Input to the running game: a whole click on a Control or a 3D node named by path or on a control named by the words on it, an item chosen out of a menu, typing into whatever has the focus, or a raw action, key, mouse button, mouse motion or drag. All of it works headless, where the window is 64 by 64 and the GUI only takes what is inside it. On gdharness's own desktop, where a windowed run goes, Windows refuses to say where the pointer is: every pointer answer there carries pointer_on_hidden_desktop, and the first of the run pointer_note saying why it matters: get_mouse_position() on the root window, and the mouse positions derived from it, read a meaningless position, while what reads the event itself (the control under it, hover, tooltips, input handlers) gets the injected position. A native window no real pointer has entered gets no hover from Godot, so the runtime supplies it there and the answers say hover_supplied.",
+    description: "Input to the running game: a whole click on a Control or a 3D node named by path or on a control named by the words on it, an item chosen out of a menu, typing into whatever has the focus, or a raw action, key, mouse button, mouse motion or drag. All of it works headless, where the viewport is the project's window size and the GUI only takes what is inside it. On gdharness's own desktop, where a windowed run goes, Windows refuses to say where the pointer is: every pointer answer there carries pointer_on_hidden_desktop, and the first of the run pointer_note saying why it matters: get_mouse_position() on the root window, and the mouse positions derived from it, read a meaningless position, while what reads the event itself (the control under it, hover, tooltips, input handlers) gets the injected position. A native window no real pointer has entered gets no hover from Godot, so the runtime supplies it there and the answers say hover_supplied.",
     answer: 'click: what was under the pointer, and what became of the control: in_tree, removed or freed. Named by says, found says which match it was, and found.pressedOn says "the words" for words in a RichTextLabel pressed where they are drawn, or "the middle of the label" with a note saying why they could not be placed; on a rich label link_pressed says whether the press reached a link, with link_meta giving the meta the label reports clicked, an empty one included. A control scrolled into view first is scrolled each container out from it a frame after the one inside, and scrolled_into_view says whether a scroll value changed. A button in toggle mode, a CheckBox or CheckButton included, answers pressed with before and after, its button_pressed either side of the click: the same value twice is a click the game undid, and after is null when the click freed it. A refusal for a pointer turned off names where mouse_behavior_recursive was set. On a 3D node landed says the interface did not swallow the press: no control under the pointer stopped it, a control letting the pointer pass included, and every viewport on the way out from the room had the pointer over what shows the room. choose: what was chosen, read before the press, which is heard rather than assumed; what became of the control named (in_tree, removed or freed, since a game can rebuild its screen on the pick); and what the button in front of the menu shows now when it is still there. A menu is opened rather than clicked because its items are drawn rather than built, and the item is looked for as the menu stands once open, since a game can fill a menu as it opens. action, key, mouse_click and joypad_button: the event as it was sent, with whole saying whether the press was let go of again, for a key the keycode, physical_keycode and unicode it carried, and for a controller button its number, its name and the device. mouse_motion: the position and the relative movement sent. mouse_drag: from, to, motions sent and relative_total. joypad_motion: the axis by number and name, the value and the device. None of these is aimed at anything, so none says what the event reached: click on a nodePath or says answers what was under the pointer.',
     parameters: {
       projectPath: RUNNING_PROJECT_PATH,
@@ -36553,10 +36692,16 @@ var TOOL_SPECS = [
       },
       nodePath: {
         type: "string",
-        ops: ["signal", "until"],
-        description: "signal, until: the node. Needed for a signal and for a property; for says it defaults to /root, the whole screen."
+        ops: ["signal", "watch", "until"],
+        description: "signal, watch, until: the node. Needed for a signal without a watch, a watch and a property; for says it defaults to /root, the whole screen."
+      },
+      signal: { type: "string", ops: ["signal", "watch"], description: "signal, watch: the signal name." },
+      watch: {
+        type: "integer",
+        minimum: 1,
+        ops: ["signal"],
+        description: "signal: the watch an earlier watch answered, in place of nodePath and signal. Answers at once, with fired_before_wait, when the signal fired after the watch was armed, and otherwise waits for it; times counts how often it fired, and args is what the first carried. The watch goes with the answer."
       },
-      signal: { type: "string", ops: ["signal"], description: "signal: the signal name." },
       property: {
         type: "string",
         ops: ["until"],
@@ -36596,6 +36741,11 @@ var TOOL_SPECS = [
       signal: {
         effect: "read",
         summary: "wait for a signal and answer with what it carried",
+        requires: []
+      },
+      watch: {
+        effect: "read",
+        summary: "start recording a signal and answer at once with a watch; arm it before the call meant to set the signal off, then collect it with signal and the watch. A client can run a call sent beside a wait only after the wait answers, so a wait sent with the call misses it",
         requires: ["nodePath", "signal"]
       },
       until: {
@@ -36981,6 +37131,8 @@ function argumentShape(schema) {
 // src/server.ts
 var UPDATE_NOTICE_EVERY = 500;
 var FEEDBACK_NOTICE_EVERY = 250;
+var FAILED_BUDGET = 1e6;
+var ANSWER_BUDGET = 4000000;
 var __dirname2 = dirname18(fileURLToPath4(import.meta.url));
 var PARENT_ASKED_AFTER_MS = 5000;
 function editorRestartTimeoutMs() {
@@ -37249,6 +37401,12 @@ function endedWithoutACode(run) {
   }
   return `The editor stopped playing this run. ${kept} What it printed is below.`;
 }
+function ourRunEnded(run, now) {
+  const which = `${run.throughEditor ? "played in the editor" : "started"}${run.pid === null ? "" : ` (pid ${run.pid})`}`;
+  const when = run.endedAt === undefined ? "" : ` ${Math.max(0, Math.round((now - run.endedAt) / 1000))}s ago`;
+  const how = run.endedThrough === "close" ? "this server asked it to close" : run.endedThrough === "keeper" ? "this server ended it through the keeper holding it" : run.endedThrough === "signal" ? "this server signalled it" : run.endedThrough === "editor" ? "this server asked the editor to stop it" : run.exitCode !== null ? `it exited by itself with code ${run.exitCode}` : run.exitSignal === null ? "it is no longer running" : `it was ended by ${run.exitSignal}`;
+  return `No game with the runtime addon is running: the game this server ${which} ended${when}, and ${how}. editor_output has what it printed, and editor_run start runs it again.`;
+}
 function stopVerdict(stop) {
   const notClosed = stop.notClosedBecause === undefined ? "" : ` It was asked to close first and was not ended by that: ${stop.notClosedBecause}.`;
   if (!stop.wasRunning) {
@@ -38252,6 +38410,13 @@ function scriptsToDiagnose(projectPath, given) {
   }
   return { ok: true, value: unique };
 }
+function engineChecked(why) {
+  return {
+    checkedBy: "engine",
+    languageServer: why,
+    note: "No editor of this project is open to ask, so a headless engine compiled the scripts the way loading them does. It reports every error that stops a script compiling, at its line and without a column, and no warnings, which the engine tells only an editor: warnings is null rather than 0. editor_launch with hidden: true opens this project's editor without a window, and its language server reports both."
+  };
+}
 var EXTERNAL_MEMBER = 'Could not resolve external class member "';
 function isDirectory(path) {
   try {
@@ -38340,6 +38505,7 @@ class GodotServer {
   inFlight = new Map;
   callsOnGames = new Set;
   callsTaken = 0;
+  answersDirectory;
   clientNoted = null;
   parentCommand = null;
   endNoted = false;
@@ -38738,12 +38904,66 @@ class GodotServer {
       this.inFlight.set(call, { tool: spec.name, op: checked.op ?? "", startedAt: Date.now() });
       try {
         const answer = await withCallSignal(ctx.mcpReq.signal, () => this.answered(spec.name, checked.op ?? "", args), progress);
-        return this.withFeedbackNotice(this.withUpdateNotice(answer));
+        return this.withinTheClientsLimit(spec.name, this.withFeedbackNotice(this.withUpdateNotice(answer)));
       } finally {
         this.inFlight.delete(call);
       }
     });
   }
+  withinTheClientsLimit(tool, answer) {
+    const sizeOf = (item) => item.type === "text" ? Buffer.byteLength(item.text) : item.data.length;
+    const bytes = answer.content.reduce((sum, item) => sum + sizeOf(item), 0);
+    if (bytes <= ANSWER_BUDGET) {
+      return answer;
+    }
+    this.answersDirectory ??= scratchDirectory("answers");
+    const directory = this.answersDirectory;
+    const stem = `${tool}-${Date.now()}`;
+    let savedAt;
+    let notSaved;
+    try {
+      savedAt = answer.content.map((item, index) => {
+        const file = join26(directory, item.type === "text" ? `${stem}-${index}.txt` : `${stem}-${index}.${item.mimeType.split("/")[1] ?? "bin"}`);
+        writeFileSync16(file, item.type === "text" ? item.text : Buffer.from(item.data, "base64"));
+        return file;
+      });
+    } catch (error) {
+      notSaved = errorMessage(error);
+    }
+    const first = answer.content[0];
+    let parsed = null;
+    try {
+      parsed = first?.type === "text" ? JSON.parse(first.text) : null;
+    } catch {}
+    const small = {};
+    const leftOut = [];
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      for (const [key, value] of Object.entries(parsed)) {
+        if (JSON.stringify(value).length <= 2000) {
+          small[key] = value;
+        } else {
+          leftOut.push(key);
+        }
+      }
+    }
+    return {
+      ...answer,
+      content: [
+        {
+          type: "text",
+          text: answerJson({
+            ...small,
+            answerTooLarge: {
+              bytes,
+              savedAt,
+              leftOut: leftOut.length > 0 ? leftOut : undefined,
+              note: savedAt === undefined ? `The answer was ${bytes} bytes, past the ${ANSWER_BUDGET} this server sends in one message (Claude Code closes the connection past 16 MB), and writing it to a file failed: ${notSaved ?? "no reason given"}. The fields of its top level that are short are kept here.` : `The answer was ${bytes} bytes, past the ${ANSWER_BUDGET} this server sends in one message (Claude Code closes the connection past 16 MB), so it was written whole to savedAt; read it from there. The fields of its top level that are short are kept here. The files are removed once this server has stopped.`
+            }
+          })
+        }
+      ]
+    };
+  }
   async answered(tool, op, args) {
     try {
       return await this.dispatch(tool, op, args);
@@ -38995,6 +39215,7 @@ class GodotServer {
       const contained = this.containProjectFiles({ ...arguments_, ...extra });
       return contained.ok ? await this.handleViaBridge(command, contained.value, op === "" ? tool : `${tool} ${op}`) : contained.response;
     };
+    const editorOrEngine = async (command, effect, extra = {}) => await this.editorOrEngine(command, { ...arguments_, ...extra }, `${tool} ${op}`, effect);
     switch (tool) {
       case "project_info":
         return await this.handleProjectInfo(args);
@@ -39007,7 +39228,7 @@ class GodotServer {
       case "project_test":
         return await this.handleRunTests(args);
       case "scene_create":
-        return op === "create" ? await bridge("create_scene") : await bridge("save_scene");
+        return op === "create" ? await editorOrEngine("create_scene", "writes") : await editorOrEngine("save_scene", "writes");
       case "scene_tree":
         return await this.readFromFile(args, "scenePath", "read_scene_tree", (file) => ({
           scenePath: file,
@@ -39017,28 +39238,28 @@ class GodotServer {
       case "scene_node":
         switch (op) {
           case "add":
-            return await bridge("add_node");
+            return await editorOrEngine("add_node", "writes");
           case "get":
-            return await bridge("get_node_properties");
+            return await editorOrEngine("get_node_properties", "reads");
           case "set":
-            return await bridge("set_node_properties");
+            return await editorOrEngine("set_node_properties", "writes");
           case "duplicate":
-            return await bridge("duplicate_node", { parentPath: args["parentNodePath"] });
+            return await editorOrEngine("duplicate_node", "writes", { parentPath: args["parentNodePath"] });
           case "reparent":
-            return await bridge("reparent_node");
+            return await editorOrEngine("reparent_node", "writes");
           case "delete":
-            return await bridge("delete_node");
+            return await editorOrEngine("delete_node", "writes");
           default:
-            return await bridge("set_tilemap_cells", { tilemapNodePath: args["nodePath"] });
+            return await editorOrEngine("set_tilemap_cells", "writes", { tilemapNodePath: args["nodePath"] });
         }
       case "scene_signal":
         switch (op) {
           case "connect":
-            return await bridge("connect_signal");
+            return await editorOrEngine("connect_signal", "writes");
           case "disconnect":
-            return await bridge("disconnect_signal");
+            return await editorOrEngine("disconnect_signal", "writes");
           default:
-            return await bridge("list_connections");
+            return await editorOrEngine("list_connections", "reads");
         }
       case "scene_animation":
         switch (op) {
@@ -39089,17 +39310,17 @@ class GodotServer {
             }), async () => await bridge("read_resource", kept));
           }
           case "create":
-            return await bridge("create_resource");
+            return await editorOrEngine("create_resource", "writes");
           case "modify":
-            return await bridge("modify_resource");
+            return await editorOrEngine("modify_resource", "writes");
           case "create_shader":
-            return await bridge("create_shader", { shaderPath: args["resourcePath"] });
+            return await editorOrEngine("create_shader", "writes", { shaderPath: args["resourcePath"] });
           case "create_tileset":
-            return await bridge("create_tileset", { tilesetPath: args["resourcePath"] });
+            return await editorOrEngine("create_tileset", "writes", { tilesetPath: args["resourcePath"] });
           case "set_theme_color":
-            return await bridge("set_theme_color", { themePath: args["resourcePath"] });
+            return await editorOrEngine("set_theme_color", "writes", { themePath: args["resourcePath"] });
           default:
-            return await bridge("set_theme_font_size", { themePath: args["resourcePath"] });
+            return await editorOrEngine("set_theme_font_size", "writes", { themePath: args["resourcePath"] });
         }
       case "editor_launch":
         if (op === "close") {
@@ -39965,6 +40186,10 @@ class GodotServer {
     if (unknown.length > 0) {
       return this.createErrorResponse(`project_info cannot include ${unknown.join(", ")}. Sections: ${Object.keys(PROJECT_INFO_SECTIONS2).join(", ")}.`);
     }
+    const forValidation = ["preset", "detail"].filter((name) => args[name] !== undefined);
+    if (forValidation.length > 0 && !include.includes("validation")) {
+      return this.createErrorResponse(`${forValidation.join(" and ")} ${forValidation.length === 1 ? "is" : "are"} read only by the validation section, which this call does not include: add "validation" to include, or leave ${forValidation.length === 1 ? "it" : "them"} out.`);
+    }
     const project = this.project(args);
     if (!project.ok) {
       return project.response;
@@ -40349,7 +40574,7 @@ class GodotServer {
         isError: true
       };
     }
-    const failed = failedCases(report, Buffer.concat(console2).toString("utf8"));
+    const { failed, briefed } = failedWithin(failedCases(report, Buffer.concat(console2).toString("utf8")), FAILED_BUDGET);
     const orphans = orphansPrinted(said);
     const leftBehind = new Map(orphans.suites.map((suite) => [suite.path, suite.orphans]));
     const orphansIn = (path) => path === null ? 0 : leftBehind.get(path) ?? 0;
@@ -40389,6 +40614,7 @@ class GodotServer {
       skipped: report.skipped,
       time: report.time,
       failed,
+      failedWithoutDetail: briefed > 0 ? briefed : undefined,
       hookFailures: hookFailures.length > 0 ? hookFailures : undefined,
       uncaughtScriptErrors: uncaughtFolded.length > 0 ? uncaughtFolded : undefined,
       warnings: warnings.length > 0 ? warnings : undefined,
@@ -40400,6 +40626,7 @@ class GodotServer {
       ...scanned,
       note: [
         missingNote,
+        briefed > 0 ? `${briefed} of the ${failed.length} failing cases, those with the largest reports, are named with their first message only, since their reports would have made the answer too large to deliver; pass one case's suite path to see its reports.` : undefined,
         notApplied.length > 0 ? "An ignore entry named a case that ran all the same: gdUnit4 leaves a case out only as suite_name:test_name, and reads an entry with no colon as a suite name or a piece of a suite path. ignoreNotApplied gives the form for each case that ran." : undefined,
         uncaughtNote(uncaught),
         ranAs.startsWith("warnings") && warnings.length === 0 ? "gdUnit4 exits 101 for orphan nodes when nothing failed, and this run printed no count of them: orphan reporting may be off in the project settings." : notRunNote(notRun, readBoolean(args, "failFast") === true)
@@ -40442,6 +40669,10 @@ class GodotServer {
     }
     if (scripts?.value == null) {
       const one = await this.diagnosticsOf(args);
+      if ("noLanguageServer" in one) {
+        const checked = project.ok ? await this.engineDiagnostics(project.value.path, [readString(args, "scriptPath") ?? ""], one.noLanguageServer) : { refusal: project.response };
+        return "refusal" in checked ? checked.refusal : this.jsonTextResponse({ ...checked.answers[0], ...engineChecked(one.noLanguageServer.reason) });
+      }
       return "refusal" in one ? one.refusal : this.jsonTextResponse(this.markedIfStale(one.answer));
     }
     const progress = callProgress();
@@ -40451,12 +40682,31 @@ class GodotServer {
     let errors = 0;
     let warnings = 0;
     let unread = 0;
+    let byEngine = null;
     for (const [at, scriptPath] of scripts.value.entries()) {
       if (cancelled?.aborted === true) {
         return this.createErrorResponse(`Cancelled after ${at} of ${scripts.value.length} scripts.`);
       }
       progress?.(at + 1, `${at + 1} of ${scripts.value.length}: ${scriptPath}`);
       const one = await this.diagnosticsOf({ ...args, scriptPath });
+      if ("noLanguageServer" in one) {
+        const rest = scripts.value.slice(at);
+        progress?.(at + 1, `${rest.length} script(s) left, compiled by a headless engine`);
+        const checked = await this.engineDiagnostics(project.ok ? project.value.path : "", rest, one.noLanguageServer);
+        if ("refusal" in checked) {
+          return checked.refusal;
+        }
+        for (const answer of checked.answers) {
+          errors += Number(answer["errors"]);
+          if (readArray(answer, "diagnostics")?.length === 0) {
+            nothingReported.push(String(answer["scriptPath"]));
+          } else {
+            reported.push(answer);
+          }
+        }
+        byEngine = one.noLanguageServer.reason;
+        break;
+      }
       if ("refusal" in one) {
         if (!one.perScript) {
           return one.refusal;
@@ -40477,14 +40727,74 @@ class GodotServer {
       clean: errors === 0 && unread === 0,
       scriptsChecked: scripts.value.length,
       errors,
-      warnings,
+      warnings: byEngine === null ? warnings : null,
       ...unread > 0 ? { scriptsNotRead: unread } : {},
       scripts: reported,
-      nothingReported
+      nothingReported,
+      ...byEngine === null ? {} : engineChecked(byEngine)
     }));
   }
+  async compileScripts(projectPath, paths) {
+    const payload = { checked: [], failed: [], scripts: [] };
+    const messages = [];
+    let left = [...paths];
+    while (left.length > 0) {
+      const ran = await this.operation("check_scripts", { paths: left }, projectPath);
+      if (!ran.ok) {
+        return { ok: false, message: ran.message };
+      }
+      const checked = (readArray(ran.payload, "checked") ?? []).map(String);
+      if (checked.length === 0) {
+        return { ok: false, message: `check_scripts read none of ${left.length} script(s)` };
+      }
+      payload.checked.push(...checked);
+      payload.failed.push(...(readArray(ran.payload, "failed") ?? []).map(String));
+      payload.scripts.push(...readArray(ran.payload, "scripts") ?? []);
+      messages.push(...ran.messages);
+      left = left.slice(checked.length);
+    }
+    return { ok: true, payload, extras: engineExtras({ messages }) };
+  }
+  async engineDiagnostics(projectPath, scripts, why) {
+    const named = scripts.map((script) => {
+      const contained = resolveWithinProject(projectPath, script);
+      return contained.ok ? `res://${contained.relativePath}` : script;
+    });
+    const checked = await this.compileScripts(projectPath, named);
+    if (!checked.ok) {
+      return {
+        refusal: this.createErrorResponse(`Diagnostics unavailable: ${why.reason.replace(/\.?$/, ".")} No headless engine could compile the scripts instead: ${checked.message}`, why.solutions)
+      };
+    }
+    const failures = new Map((readArray(checked.payload, "scripts") ?? []).map((entry) => [
+      String(asParams(entry)["path"]),
+      asParams(entry)
+    ]));
+    return {
+      answers: scripts.map((scriptPath, at) => {
+        const failure = failures.get(named[at] ?? "");
+        const diagnostics = (readArray(failure ?? {}, "errors") ?? []).map((entry) => {
+          const { line, message } = asParams(entry);
+          return { severity: "error", message, ...typeof line === "number" && line > 0 ? { line } : {} };
+        });
+        const dependencies = readArray(failure ?? {}, "dependencies_with_errors");
+        return {
+          scriptPath,
+          clean: diagnostics.length === 0,
+          errors: diagnostics.length,
+          warnings: null,
+          diagnostics,
+          ...dependencies === undefined ? {} : { dependenciesWithErrors: dependencies }
+        };
+      })
+    };
+  }
   markedIfStale(answer) {
-    return markIfStale(answer, this.godotBridge.getStatus().addonVersion, SERVER_VERSION, this.godotBridge.getStatus().addonDigest, shippedEditorDigest(), this.editorCodeOnDisk());
+    const status = this.godotBridge.getStatus();
+    if (!hasSaidWhoItIs(status)) {
+      return answer;
+    }
+    return markIfStale(answer, status.addonVersion, SERVER_VERSION, status.addonDigest, shippedEditorDigest(), this.editorCodeOnDisk());
   }
   async diagnosticsOf(args) {
     const waited = await this.waitForTheEditorOpenedHere(args, []);
@@ -40494,6 +40804,16 @@ class GodotServer {
     const answer = await this.handleLSP("lsp_get_diagnostics", args);
     const payload = asParams(JSON.parse(answer.content[0]?.text ?? "{}"));
     const refused = this.languageServerRefusal(payload, "Diagnostics");
+    const project = this.project(args);
+    const ownEditor = project.ok && this.editorHasOpen(project.value.path);
+    if (refused !== null && !refused.perScript && payload["stillReading"] !== true && !ownEditor) {
+      return {
+        noLanguageServer: {
+          reason: typeof payload["error"] === "string" ? payload["error"] : JSON.stringify(payload["error"]),
+          solutions: this.languageServerSolutions(payload)
+        }
+      };
+    }
     if (refused !== null) {
       return refused;
     }
@@ -40653,24 +40973,24 @@ class GodotServer {
     if (payload["stillReading"] === true) {
       return { refusal: this.createErrorResponse(`${asked} unavailable: ${reason}`), perScript: false };
     }
-    if (typeof payload["serves"] === "string") {
-      return {
-        refusal: this.createErrorResponse(`${asked} unavailable: ${reason}`, [
-          "editor_status names the editor on the bridge and the port it says it serves",
-          "editor_launch opens this project's own editor, on a language server port of its own",
-          "GDHARNESS_LSP_PORT points this server at the right one"
-        ]),
-        perScript: false
-      };
-    }
     return {
-      refusal: this.createErrorResponse(`${asked} unavailable: ${reason}`, [
-        `Ensure the Godot editor is running with its language server enabled, on port ${this.editorServes("lspPort", "GDHARNESS_LSP_PORT", DEFAULT_LSP_PORT)}`,
-        "GDHARNESS_LSP_PORT points this server at another one"
-      ]),
-      perScript: payload["aboutThisFile"] === true
+      refusal: this.createErrorResponse(`${asked} unavailable: ${reason}`, this.languageServerSolutions(payload)),
+      perScript: typeof payload["serves"] !== "string" && payload["aboutThisFile"] === true
     };
   }
+  languageServerSolutions(payload) {
+    if (typeof payload["serves"] === "string") {
+      return [
+        ...this.godotBridge.getStatus().connected ? ["editor_status names the editor on the bridge and the port it says it serves"] : [],
+        "editor_launch opens this project's own editor, on a language server port of its own",
+        "GDHARNESS_LSP_PORT points this server at the right one"
+      ];
+    }
+    return [
+      `Ensure the Godot editor is running with its language server enabled, on port ${this.editorServes("lspPort", "GDHARNESS_LSP_PORT", DEFAULT_LSP_PORT)}`,
+      "GDHARNESS_LSP_PORT points this server at another one"
+    ];
+  }
   async lsp() {
     const port = this.editorServes("lspPort", "GDHARNESS_LSP_PORT", DEFAULT_LSP_PORT);
     if (this.lspClient !== null && this.lspClient.port !== port) {
@@ -41295,7 +41615,7 @@ class GodotServer {
       return;
     }
     const connected = this.godotBridge.isConnected() ? this.godotBridge.getStatus().editorPid : undefined;
-    const pids = editorsOfProjectIn(tree, projectPath).filter((pid) => pid !== connected);
+    const pids = editorsOfProjectIn(tree, projectPath).filter((pid) => pid !== connected && alive(pid));
     const started = await startTimesOf(pids);
     return pids.map((pid) => {
       const at = started.get(pid) ?? tree.get(pid)?.startedAt;
@@ -43534,6 +43854,45 @@ class GodotServer {
       ...engineExtras(outcome)
     });
   }
+  async editorOrEngine(command, args, askedAs, effect) {
+    const contained = this.containProjectFiles(args);
+    if (!contained.ok) {
+      return contained.response;
+    }
+    const project = this.project(contained.value);
+    if (!project.ok) {
+      return project.response;
+    }
+    const projectPath = project.value.path;
+    const waited = await this.waitForTheEditorOpenedHere(contained.value, []);
+    if (this.editorHasOpen(projectPath)) {
+      return await this.handleViaBridge(command, contained.value, askedAs);
+    }
+    if (effect === "writes") {
+      if (waited !== null) {
+        return waited;
+      }
+      const arriving = await this.editorsNotYetConnected(projectPath);
+      if (arriving !== undefined && arriving.length > 0) {
+        const named = arriving.map((one) => `pid ${one.pid}`).join(", ");
+        return this.createErrorResponse(`${askedAs} was not run: an editor of this project is running (${named}) and has not reached this server, and saving a scene or resource it holds would put back what a write made around it.`, [
+          "editor_status names it under editorsNotYetConnected and says when it has connected; the write then goes through it",
+          `If it never connects it is not reaching this server: end ${arriving.length === 1 ? "that pid" : "those pids"} and ask again`
+        ]);
+      }
+    }
+    const outcome = await this.operation("run_editor_tool", { command, arguments: contained.value }, projectPath);
+    if (!outcome.ok) {
+      return this.answer(outcome);
+    }
+    return this.jsonTextResponse({
+      ...outcome.payload,
+      ...effect === "reads" ? {
+        readBy: "a headless engine, since no editor serves this project; unsaved changes in an editor are not seen"
+      } : { writtenBy: "a headless engine, since no editor serves this project" },
+      ...engineExtras(outcome)
+    });
+  }
   async handleMoveFile(given) {
     const project = this.project(given);
     if (!project.ok) {
@@ -43724,9 +44083,9 @@ class GodotServer {
       ok &&= rebuilt.ok;
     }
     if (changed.length > 0) {
-      const compiled = await this.operation("check_scripts", { paths: [...changed] }, projectPath);
-      report["compiled"] = compiled.ok ? { ...compiled.payload, ...engineExtras(compiled) } : { problem: compiled.message };
-      ok &&= compiled.ok && (readArray(compiled.payload, "failed") ?? []).length === 0;
+      const compiled = await this.compileScripts(projectPath, [...changed]);
+      report["compiled"] = compiled.ok ? { ...compiled.payload, ...compiled.extras } : { problem: compiled.message };
+      ok &&= compiled.ok && compiled.payload.failed.length === 0;
     }
     return { ok, report };
   }
@@ -43992,6 +44351,11 @@ class GodotServer {
     const own = typeof pid === "number" ? undefined : await this.ownGameAmong(announced.running, wanted) ?? await this.ownGameThroughTheTree(announced.running, wanted);
     const choice = chooseRuntime(announced.running, wanted, announced.unspoken, typeof pid === "number" ? pid : own);
     if ("problem" in choice) {
+      const ended = this.activeProcess;
+      const nothingAnnounced = typeof pid !== "number" && announced.unspoken.length === 0 && !announced.running.some((one) => wanted === undefined || isSameDirectory(one.project.path, wanted));
+      if (nothingAnnounced && ended !== null && !stillRunning(ended) && (wanted === undefined || ended.projectPath === null || isSameDirectory(ended.projectPath, wanted))) {
+        return this.createErrorResponse(ourRunEnded({ ...ended, pid: ended.pid ?? ended.announcedPid ?? null }, Date.now()));
+      }
       return this.createErrorResponse(choice.problem);
     }
     const ofProject = announced.running.filter((one) => wanted === undefined || isSameDirectory(one.project.path, wanted));
@@ -44157,7 +44521,18 @@ ${staleNote}`}`
       const waited = patienceForFrames(frames, this.runtimeTimeoutMs());
       return await this.handleRuntimeCommand("wait_frames", { ...whichGame(args), frames }, { tool: "runtime_wait", op, patience: waited });
     }
+    if (op === "watch") {
+      return await this.handleRuntimeCommand("watch_signal", {
+        ...whichGame(args),
+        path: readNonEmptyString(args, "nodePath") ?? "",
+        signal: readString(args, "signal") ?? ""
+      }, { tool: "runtime_wait", op });
+    }
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 5000;
+    const watch = readPositiveNumber(args, "watch");
+    if (op === "signal" && watch === undefined && (readNonEmptyString(args, "nodePath") === undefined || readNonEmptyString(args, "signal") === undefined)) {
+      return this.createErrorResponse("runtime_wait signal needs nodePath and signal, or the watch an earlier runtime_wait watch answered.");
+    }
     const asked = readNonEmptyString(args, "nodePath");
     if (asked === undefined && op === "until" && readNonEmptyString(args, "says") === undefined) {
       return this.createErrorResponse("runtime_wait until needs nodePath to wait for a property: the property belongs to that node.", ["With says instead of property, nodePath can be left out and the whole game is searched"]);
@@ -44168,7 +44543,8 @@ ${staleNote}`}`
       ...whichGame(args),
       path: nodePath,
       signal: readString(args, "signal") ?? "",
-      timeout_ms: timeoutMs
+      timeout_ms: timeoutMs,
+      ...watch === undefined ? {} : { watch }
     }, { tool: "runtime_wait", op, patience }) : await this.handleRuntimeCommand("wait_until", {
       ...whichGame(args),
       path: nodePath,