gdharness 1.2.14 → 1.2.16

package/build/index.js

@@ -3807,6 +3807,18 @@ function prefixIssues(path, issues) {
 function unwrapMessage(message) {
   return typeof message === "string" ? message : message?.message;
 }
+function sizeCaps(defChecks) {
+  const caps = [];
+  for (const ch of defChecks ?? []) {
+    const d = ch._zod.def;
+    if (!/_(length|size)$|_equals$/.test(d.check))
+      break;
+    const max = d.maximum ?? d.length ?? d.size;
+    if (max >= 0)
+      caps.push([max, ch]);
+  }
+  return caps;
+}
 function attachSchema(issues, start, inst) {
   var _a;
   for (let i = start;i < issues.length; i++) {
@@ -4808,7 +4820,7 @@ ${content.join(`
 var version = {
   major: 4,
   minor: 6,
-  patch: 5
+  patch: 7
 };
 
 // node_modules/zod/v4/core/schemas.js
@@ -5381,6 +5393,29 @@ var $ZodNever = /* @__PURE__ */ $constructor("$ZodNever", (inst, def) => {
     return payload;
   };
 });
+function capSize(inst, size) {
+  const caps = sizeCaps(inst._zod.def.checks);
+  if (!caps.length)
+    return;
+  const cap = Math.min(...caps.map((c) => c[0]));
+  const parse = inst._zod.parse;
+  inst._zod.parse = (payload, ctx) => {
+    const n = size(payload.value);
+    if (n > cap && !ctx?.skipChecks && ctx?.direction !== "backward") {
+      for (const [max, ch] of sizeCaps(inst._zod.def.checks)) {
+        if (n > max && ch._zod.def.when(payload)) {
+          const start = payload.issues.length;
+          ch._zod.check(payload);
+          payload.issues[start].continue = false;
+          attachSchema(payload.issues, start, inst);
+          return payload;
+        }
+      }
+    }
+    return parse(payload, ctx);
+  };
+}
+var arraySize = (input) => Array.isArray(input) ? input.length : -1;
 function handleArrayResult(result, final, index) {
   if (result.issues.length) {
     final.issues.push(...prefixIssues(index, result.issues));
@@ -5424,6 +5459,7 @@ var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
     }
     return payload;
   };
+  capSize(inst, arraySize);
 });
 function handlePropertyResult(result, final, key, input, optin, optout) {
   const isPresent = key in input;
@@ -28316,10 +28352,58 @@ function editorConsole(projectPath, editorPid, openedByAServer) {
   }
   const log = new GameLog;
   const { text, of } = theFirstOf(path);
-  log.append("transcript", text);
+  log.append("transcript", foldProgress(text));
   log.finish();
   return { log, path, ...of === undefined ? {} : { readBytes: text.length, of } };
 }
+var PROGRESS_STEP = /^\[\s*(\d+)% \] (\S+) \| (.*)$/;
+var PROGRESS_DONE = /^\[ DONE \] (\S+)\s*$/;
+function foldProgress(text) {
+  const out = [];
+  const open = new Map;
+  for (const raw of text.split(`
+`)) {
+    const line = raw.replace(/\r$/, "").replace(COLOUR_CODE, "");
+    const step = PROGRESS_STEP.exec(line);
+    if (step !== null) {
+      const [, percent = "", name = "", said = ""] = step;
+      const started = /^Started (.*)$/.exec(said);
+      if (started !== null) {
+        const task = { name, label: started[1] ?? "", percent, done: false };
+        open.set(name, task);
+        out.push(task);
+        continue;
+      }
+      const task = open.get(name);
+      if (task !== undefined) {
+        task.percent = percent;
+        if (said.trim() !== "") {
+          task.last = said.trim();
+        }
+        continue;
+      }
+    }
+    const finished = PROGRESS_DONE.exec(line);
+    const task = finished === null ? undefined : open.get(finished[1] ?? "");
+    if (task !== undefined) {
+      task.done = true;
+      open.delete(task.name);
+      continue;
+    }
+    out.push(raw);
+  }
+  return out.map((entry) => {
+    if (typeof entry === "string") {
+      return entry;
+    }
+    if (entry.done) {
+      return `[ DONE ] ${entry.name} | ${entry.label}`;
+    }
+    const last = entry.last === undefined ? "" : `, and the last step it named was "${entry.last}"`;
+    return `[ ${entry.percent}% ] ${entry.name} | ${entry.label}, which has not finished${last}`;
+  }).join(`
+`);
+}
 var MOST_CONSOLE_BYTES = 8 * 1024 * 1024;
 function theFirstOf(path) {
   const whole = statSync3(path).size;
@@ -28579,6 +28663,12 @@ function theEditorHasComeBack(status, startedAt) {
 function hasSaidWhoItIs(status) {
   return status.connected && status.addonVersion !== undefined;
 }
+function withoutTrailingSeparator(path) {
+  if (path.length <= 1 || !/[\\/]$/.test(path) || /^[A-Za-z]:[\\/]$/.test(path)) {
+    return path;
+  }
+  return path.slice(0, -1);
+}
 function anEditorIsStillComing(listeningSince, launchedEditorIsAlive, now = Date.now()) {
   return mayYetConnect(listeningSince, now) || launchedEditorIsAlive;
 }
@@ -28879,7 +28969,7 @@ class GodotBridge extends EventEmitter {
             this.elsewhereUnlessOneShot(message.project_path, message.editor_pid, message.opened_by_a_server === true);
             return;
           }
-          this.connectionInfo.projectPath = message.project_path;
+          this.connectionInfo.projectPath = withoutTrailingSeparator(message.project_path);
           this.connectionInfo.addonVersion = message.addon_version ?? "";
           this.connectionInfo.addonDigest = message.addon_digest;
           this.connectionInfo.editorPid = message.editor_pid;
@@ -29628,9 +29718,11 @@ var HEADLESS_OPERATIONS = dictionary({
     remove_autoload: "remove_autoload",
     set_main_scene: "set_main_scene",
     add_input_action: "add_input_action",
+    remove_input_action: "remove_input_action",
     enable_plugin: "enable_plugin",
     disable_plugin: "disable_plugin",
     add_audio_bus: "create_audio_bus",
+    remove_audio_bus: "remove_audio_bus",
     set_audio_bus_effect: "set_audio_bus_effect",
     set_audio_bus_volume: "set_audio_bus_volume"
   }),
@@ -30847,6 +30939,29 @@ function shownSymbol(entry) {
     ...children.length > 0 ? { children: children.map(shownSymbol) } : {}
   };
 }
+var MOST_COMPLETIONS = 100;
+function typedBefore(content, line, character) {
+  const text = content.split(/\r?\n/)[line] ?? "";
+  return /[\p{L}\p{N}_]*$/u.exec(text.slice(0, character))?.[0] ?? "";
+}
+function narrowedCompletions(completions, typed) {
+  const wanted = typed.toLowerCase();
+  const matching = wanted === "" ? completions : completions.filter((entry) => {
+    const record = asRecord(entry);
+    const name = typeof record["filterText"] === "string" ? record["filterText"] : record["label"];
+    return typeof name === "string" && name.toLowerCase().startsWith(wanted);
+  });
+  const shown = matching.slice(0, MOST_COMPLETIONS);
+  return {
+    ...typed === "" ? {} : { typed },
+    completions: shown.map(shownCompletion),
+    total: matching.length,
+    ...matching.length > shown.length ? {
+      omitted: matching.length - shown.length,
+      note: `${matching.length - shown.length} more are offered here than one answer carries; ask at a position after more of the name to narrow them.`
+    } : {}
+  };
+}
 function shownCompletion(entry) {
   const { data: _request, kind, ...rest } = asRecord(entry);
   return { ...rest, kind: named(kind, COMPLETION_KINDS) };
@@ -30917,7 +31032,7 @@ async function handleLSPTool(client, toolName, args) {
       case "lsp_get_completions": {
         const { line, character } = protocolPosition(parsedArgs);
         const completions = await client.getCompletions(scriptPath, content, line, character);
-        return asToolResponse({ completions: completions.map(shownCompletion) });
+        return asToolResponse(narrowedCompletions(completions, typedBefore(content, line, character)));
       }
       case "lsp_get_hover": {
         const { line, character } = protocolPosition(parsedArgs);
@@ -31087,9 +31202,16 @@ var SKIPPED = new Set(["node_modules"]);
 function skipped(name) {
   return name.startsWith(".") || SKIPPED.has(name);
 }
+var VERSION_MARKER = ".gdharness-version";
 function steppedOver(directory) {
+  return gdignored(directory) || installedByUs(directory);
+}
+function gdignored(directory) {
   return existsSync13(join16(directory, ".gdignore"));
 }
+function installedByUs(directory) {
+  return existsSync13(join16(directory, VERSION_MARKER));
+}
 var SCENE_EXTENSIONS = new Set(["tscn", "scn"]);
 var ASSET_EXTENSIONS = new Set([
   "png",
@@ -31245,7 +31367,10 @@ function projectTexts(projectPath) {
 function ignoredTexts(projectPath) {
   const found = [];
   const visit = (directory, prefix, ignored) => {
-    const under = ignored || steppedOver(directory);
+    if (installedByUs(directory)) {
+      return;
+    }
+    const under = ignored || gdignored(directory);
     for (const entry of readdirSync5(directory, { withFileTypes: true })) {
       if (skipped(entry.name)) {
         continue;
@@ -31348,7 +31473,11 @@ var PROMPT_SPECS = [
       }
     ],
     steps: [
-      { tool: "editor_status", passes: [], why: "see whether an editor is connected and its addon matches" },
+      {
+        tool: "editor_status",
+        passes: [],
+        why: "see whether an editor is connected and its addon matches; without one the run is a game of its own, not a fault"
+      },
       { tool: "editor_run", op: "start", passes: ["projectPath", "scene"], why: "start the run" },
       {
         tool: "editor_run",
@@ -31366,7 +31495,11 @@ var PROMPT_SPECS = [
     description: "Check the editor connection, the project health report, export validation and the import state.",
     arguments: [PROJECT_PATH],
     steps: [
-      { tool: "editor_status", passes: [], why: "see whether an editor is connected and its addon matches" },
+      {
+        tool: "editor_status",
+        passes: [],
+        why: "see whether an editor is connected and, if one is, whether its addon matches; no editor is no fault in the project, so leave it out of what is wrong"
+      },
       {
         tool: "project_info",
         passes: ["projectPath"],
@@ -33895,10 +34028,14 @@ 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.",
+    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. 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.",
     parameters: {
       projectPath: PROJECT_PATH2,
-      setting: { type: "string", description: 'Setting path, such as "display/window/size/viewport_width".' },
+      setting: {
+        type: "string",
+        ops: ["get", "set"],
+        description: 'Setting path, such as "display/window/size/viewport_width".'
+      },
       from: {
         type: "string",
         enum: ["disk", "editor"],
@@ -33912,40 +34049,66 @@ var TOOL_SPECS = [
       },
       value: {
         blank: true,
+        ops: ["set"],
         description: 'The value to write. Engine types may be tagged, {"_type": "Vector2", "x": 1, "y": 2}, and infinity as {"_type": "float", "value": "inf"}, the form a read answers with. "" writes an empty string.'
       },
-      name: { type: "string", description: "Autoload name." },
-      path: { type: "string", description: "Autoload script or scene inside the project." },
+      name: { type: "string", ops: ["add_autoload", "remove_autoload"], description: "Autoload name." },
+      path: {
+        type: "string",
+        ops: ["add_autoload"],
+        description: "Autoload script or scene inside the project."
+      },
       enabled: {
         type: "boolean",
-        description: "Autoloads: Godot 4 loads every autoload in the list, so false is refused. Use global: false to keep the name out of the global scope, or remove_autoload to stop it loading."
+        ops: ["add_autoload", "set_audio_bus_effect"],
+        description: "add_autoload: Godot 4 loads every autoload in the list, so false is refused. Use global: false to keep the name out of the global scope, or remove_autoload to stop it loading. set_audio_bus_effect: whether the effect is on. Default true."
       },
       global: {
         type: "boolean",
+        ops: ["add_autoload"],
         description: `Autoloads: make the name a global variable, the * in project.godot and the editor's "Global Variable" column. Default true. The autoload loads either way.`
       },
-      scenePath: SCENE_PATH,
-      actionName: { type: "string", description: 'Input action name, such as "jump".' },
-      events: INPUT_EVENTS,
+      scenePath: { ...SCENE_PATH, ops: ["set_main_scene"] },
+      actionName: {
+        type: "string",
+        ops: ["add_input_action", "remove_input_action"],
+        description: 'Input action name, such as "jump".'
+      },
+      events: { ...INPUT_EVENTS, ops: ["add_input_action"] },
       deadzone: {
         type: "number",
+        ops: ["add_input_action"],
         minimum: 0,
         maximum: 1,
         description: "Input actions: analogue deadzone, 0 to 1. Default 0.5."
       },
-      pluginName: { type: "string", description: "Folder name under addons/." },
-      busName: { type: "string", description: "Audio bus name." },
+      pluginName: {
+        type: "string",
+        ops: ["enable_plugin", "disable_plugin"],
+        description: "Folder name under addons/."
+      },
+      busName: { type: "string", ops: ["add_audio_bus", "remove_audio_bus"], description: "Audio bus name." },
       parentBusIndex: {
         type: "number",
+        ops: ["add_audio_bus"],
         description: "Audio buses: the bus to send to. Default 0, Master. The new bus goes right after it, so every later bus moves one along, and the answer lists them all."
       },
-      busIndex: { type: "number", description: "Audio bus index." },
+      busIndex: {
+        type: "number",
+        ops: ["set_audio_bus_effect", "set_audio_bus_volume"],
+        description: "Audio bus index."
+      },
       effectIndex: {
         type: "number",
+        ops: ["set_audio_bus_effect"],
         description: "Slot on the bus for the effect: the effect there is replaced, and one past the last adds one. Any other slot is refused."
       },
-      effectType: { type: "string", description: 'Effect class, such as "AudioEffectReverb".' },
-      volumeDb: { type: "number", description: "Bus volume in decibels." }
+      effectType: {
+        type: "string",
+        ops: ["set_audio_bus_effect"],
+        description: 'Effect class, such as "AudioEffectReverb".'
+      },
+      volumeDb: { type: "number", ops: ["set_audio_bus_volume"], description: "Bus volume in decibels." }
     },
     requires: ["projectPath"],
     operations: {
@@ -33967,9 +34130,19 @@ var TOOL_SPECS = [
         summary: "register an input action and its events",
         requires: ["actionName", "events"]
       },
+      remove_input_action: {
+        effect: "destructive",
+        summary: "remove an input action the project defines",
+        requires: ["actionName"]
+      },
       enable_plugin: { effect: "destructive", summary: "enable an addon", requires: ["pluginName"] },
       disable_plugin: { effect: "destructive", summary: "disable an addon", requires: ["pluginName"] },
       add_audio_bus: { effect: "additive", summary: "add an audio bus", requires: ["busName"] },
+      remove_audio_bus: {
+        effect: "destructive",
+        summary: "remove an audio bus, sending what sent to it on to where it sent",
+        requires: ["busName"]
+      },
       set_audio_bus_effect: {
         effect: "destructive",
         summary: "put an effect in a slot on a bus",
@@ -33986,7 +34159,7 @@ var TOOL_SPECS = [
     name: "project_search",
     title: "Search the project",
     effect: "read",
-    description: "Searches text or a regular expression across project files and returns file paths with line numbers. What the engine steps over is not searched: directories spelled with a dot, node_modules, and any directory holding a .gdignore. A vendored engine or an export directory is therefore absent from the results rather than matching the code you are looking for in a copy nobody runs.",
+    description: "Searches text or a regular expression across project files and returns file paths with line numbers. What the engine steps over is not searched: directories spelled with a dot, node_modules, and any directory holding a .gdignore. A vendored engine or an export directory is therefore absent from the results rather than matching the code you are looking for in a copy nobody runs. The addons gdharness installed are not searched either, since nobody on the project wrote them.",
     parameters: {
       projectPath: PROJECT_PATH2,
       query: { type: "string", description: "The text or pattern to find." },
@@ -34148,8 +34321,18 @@ var TOOL_SPECS = [
     parameters: {
       projectPath: PROJECT_PATH2,
       scenePath: SCENE_PATH,
-      rootNodeType: { type: "string", description: "create: the root node class. Default Node." },
-      newPath: { type: "string", description: "save_as: where the copy goes." }
+      rootNodeType: {
+        type: "string",
+        ops: ["create"],
+        description: "create: the root node class. Default Node."
+      },
+      rootNodeName: {
+        type: "string",
+        ops: ["create"],
+        description: "create: the root node name. Default the class name, as the editor names a new root."
+      },
+      script: { type: "string", ops: ["create"], description: "create: a script to attach to the root." },
+      newPath: { type: "string", ops: ["save_as"], description: "save_as: where the copy goes." }
     },
     requires: ["projectPath", "scenePath"],
     operations: {
@@ -34229,7 +34412,7 @@ var TOOL_SPECS = [
   {
     name: "scene_signal",
     title: "Scene signals",
-    description: "Signal connections in a scene file. 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. Needs the editor connected.",
     parameters: {
       projectPath: PROJECT_PATH2,
       scenePath: SCENE_PATH,
@@ -34258,43 +34441,78 @@ var TOOL_SPECS = [
   {
     name: "scene_animation",
     title: "Animations",
-    description: "Animations in an AnimationPlayer and states in an AnimationTree state machine. Needs the editor connected.",
+    description: "Animations in an AnimationPlayer and states in an AnimationTree state machine. read answers with every track of an animation in the shape add_track takes, so a track read off one animation can be added to another. Needs the editor connected.",
     parameters: {
       projectPath: PROJECT_PATH2,
       scenePath: SCENE_PATH,
-      playerNodePath: { type: "string", description: "The AnimationPlayer node." },
+      playerNodePath: {
+        type: "string",
+        ops: ["read", "create", "add_track"],
+        description: "The AnimationPlayer node."
+      },
       animationName: {
         type: "string",
-        description: "The animation in the player. add_state: the one that state plays."
+        ops: ["read", "create", "add_track", "add_state"],
+        description: "The animation in the player. read: the one to answer with whole; without it, read lists them. add_state: the one that state plays."
       },
-      length: { type: "number", description: "create: seconds. Default 1." },
+      length: { type: "number", ops: ["create"], description: "create: seconds. Default 1." },
       loopMode: {
         type: "string",
+        ops: ["create"],
         enum: ["none", "linear", "pingpong"],
         description: "create: default none."
       },
-      step: { type: "number", description: "create: keyframe snap in seconds. Default 0.1." },
-      track: ANIMATION_TRACK,
-      animTreePath: { type: "string", description: "The AnimationTree node." },
-      stateName: { type: "string", description: "add_state: the state to add." },
+      step: {
+        type: "number",
+        ops: ["create"],
+        description: "create: keyframe snap in seconds. Default 0.1."
+      },
+      track: { ...ANIMATION_TRACK, ops: ["add_track"] },
+      animTreePath: {
+        type: "string",
+        ops: ["read_states", "add_state", "connect_states"],
+        description: "The AnimationTree node."
+      },
+      stateName: { type: "string", ops: ["add_state"], description: "add_state: the state to add." },
       stateMachinePath: {
         type: "string",
-        description: "add_state: a nested state machine. Default the root."
+        ops: ["read_states", "add_state", "connect_states"],
+        description: "A nested state machine, by the names of the states that lead to it. Default the root."
+      },
+      fromState: {
+        type: "string",
+        ops: ["connect_states"],
+        description: "connect_states: the state the transition leaves."
+      },
+      toState: {
+        type: "string",
+        ops: ["connect_states"],
+        description: "connect_states: the state it arrives at."
       },
-      fromState: { type: "string", description: "connect_states: the state the transition leaves." },
-      toState: { type: "string", description: "connect_states: the state it arrives at." },
       transitionType: {
         type: "string",
+        ops: ["connect_states"],
         enum: ["immediate", "sync", "at_end"],
         description: "connect_states: default immediate."
       },
       advanceCondition: {
         type: "string",
+        ops: ["connect_states"],
         description: "connect_states: the condition parameter that advances."
       }
     },
     requires: ["projectPath", "scenePath"],
     operations: {
+      read: {
+        effect: "read",
+        summary: "the animations of an AnimationPlayer, or one with its tracks",
+        requires: ["playerNodePath"]
+      },
+      read_states: {
+        effect: "read",
+        summary: "the states and transitions of an AnimationTree state machine",
+        requires: ["animTreePath"]
+      },
       create: {
         effect: "additive",
         summary: "a new animation in an AnimationPlayer",
@@ -34398,7 +34616,11 @@ var TOOL_SPECS = [
         summary: "document symbols from the language server, each with its kind, the line and column of its name, and the lastLine of its declaration",
         requires: []
       },
-      completion: { effect: "read", summary: "completions at a position", requires: ["line", "character"] },
+      completion: {
+        effect: "read",
+        summary: "completions at a position, narrowed to the part of a name written before it, at most 100",
+        requires: ["line", "character"]
+      },
       hover: { effect: "read", summary: "hover text at a position", requires: ["line", "character"] }
     },
     defaultOperation: "structure"
@@ -34421,34 +34643,59 @@ var TOOL_SPECS = [
   {
     name: "resource_edit",
     title: "Edit resources",
-    description: "Resource files: 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. Needs 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". Needs the editor connected.',
     parameters: {
       projectPath: PROJECT_PATH2,
       resourcePath: RESOURCE_PATH,
       resourceType: {
         type: "string",
+        ops: ["create"],
         description: 'create: the resource class, such as "PhysicsMaterial" or "StandardMaterial3D".'
       },
-      properties: PROPERTIES,
-      script: { type: "string", description: "create: a script to attach, for custom resources." },
+      properties: { ...PROPERTIES, ops: ["create", "modify"] },
+      script: {
+        type: "string",
+        ops: ["create"],
+        description: "create: a script to attach, for custom resources."
+      },
+      includeDefaults: {
+        type: "boolean",
+        ops: ["read"],
+        description: "read: include properties still at their default. Default false."
+      },
       shaderType: {
         type: "string",
+        ops: ["create_shader"],
         enum: ["canvas_item", "spatial", "particles", "sky", "fog"],
         description: "create_shader."
       },
       code: {
         type: "string",
+        ops: ["create_shader"],
         description: "create_shader: the shader source. Default: a minimal shader of that type."
       },
-      sources: TILESET_SOURCES,
-      controlType: { type: "string", description: 'Theme ops: the Control class, such as "Button".' },
-      colorName: { type: "string", description: 'set_theme_color: such as "font_color".' },
-      color: COLOUR2,
-      fontSizeName: { type: "string", description: 'set_theme_font_size: such as "font_size".' },
-      size: { type: "number", description: "set_theme_font_size: pixels." }
+      sources: { ...TILESET_SOURCES, ops: ["create_tileset"] },
+      controlType: {
+        type: "string",
+        ops: ["set_theme_color", "set_theme_font_size"],
+        description: 'Theme ops: the Control class, such as "Button".'
+      },
+      colorName: {
+        type: "string",
+        ops: ["set_theme_color"],
+        description: 'set_theme_color: such as "font_color".'
+      },
+      color: { ...COLOUR2, ops: ["set_theme_color"] },
+      fontSizeName: {
+        type: "string",
+        ops: ["set_theme_font_size"],
+        description: 'set_theme_font_size: such as "font_size".'
+      },
+      size: { type: "number", ops: ["set_theme_font_size"], description: "set_theme_font_size: pixels." }
     },
     requires: ["projectPath", "resourcePath"],
     operations: {
+      read: { effect: "read", summary: "the properties a resource file sets", requires: [] },
       create: { effect: "destructive", summary: "a new resource of any class", requires: ["resourceType"] },
       modify: {
         effect: "destructive",
@@ -34475,8 +34722,8 @@ var TOOL_SPECS = [
   },
   {
     name: "editor_launch",
-    title: "Open or restart the editor",
-    description: "Opens the Godot editor on a project, or restarts the one already connected. open refuses while an editor of the project is already running and has not reached this server, naming its pid, rather than putting a second on the project. The editor is an ordinary visible one on the desktop in use, and on Windows it is shown without being activated, so opening or reopening it does not take the keyboard from whatever the user is typing in. hidden: true opens it headless instead and, on Windows, on a desktop of its own, where the games it plays go too; a hidden editor serves the bridge, the language server and the debug adapter as a visible one does. A game a visible editor plays opens as a window on the desktop in use. An editor goes on serving the addon it read at startup, so restart is what puts a gdharness upgrade into effect, and nothing else here restarts one; it saves open scenes on the way out and answers with the version that came back. An editor a server opened is started again by the server, visible unless hidden: true is passed again, once the old one has gone: it waits 90 seconds for that, or GDHARNESS_EDITOR_RESTART_TIMEOUT_MS, and an old editor still running after it is not replaced, since the new one would find its ports held. One opened by hand restarts itself, which only one with a window can do, because the engine hands back none of the arguments it was started with. editor_status says which editor is connected and whether it is holding an old addon. Opening a project is a save and so is closing one, which is the part that is not obvious from outside: the editor imports the project on open and writes project.godot back, and Godot writes only what differs from its own defaults, so a key named deliberately at its default value is dropped either way. A restart says which under settingsDropped in its own answer because it waits for the editor to return. An open cannot, since it answers as soon as the process exists and the save happens during the import minutes later, so editor_status carries that reading once the editor has connected. Nothing else will say a key went until something depends on one. A restart of an editor this server opened is a quit and then a launch, and this server can be ended between them, usually by the reconnect the restart was being taken for: the editor is gone and nothing replaces it. That is written down before the quit, so the next server says so under restartInterrupted in editor_status rather than waiting for an editor that is not coming, and open finishes it, saying so under finishesRestart. An open is refused when the editor it would start could never reach this server: a project other than the one this server serves, whose editor dials that project's own server; a project without the gdharness editor addon installed and enabled; and a project whose editor a restart is already bringing back.",
+    title: "Open, restart or close the editor",
+    description: "Opens the Godot editor on a project, or restarts or closes the one already connected. close saves open scenes, quits the editor and waits for its process to go, which is the only way to end a hidden one short of killing it; settingsDropped in its answer says what that save took out of project.godot. open refuses while an editor of the project is already running and has not reached this server, naming its pid, rather than putting a second on the project. The editor is an ordinary visible one on the desktop in use, and on Windows it is shown without being activated, so opening or reopening it does not take the keyboard from whatever the user is typing in. hidden: true opens it headless instead and, on Windows, on a desktop of its own, where the games it plays go too; a hidden editor serves the bridge, the language server and the debug adapter as a visible one does. A game a visible editor plays opens as a window on the desktop in use. An editor goes on serving the addon it read at startup, so restart is what puts a gdharness upgrade into effect, and nothing else here restarts one; it saves open scenes on the way out and answers with the version that came back. An editor a server opened is started again by the server, visible unless hidden: true is passed again, once the old one has gone: it waits 90 seconds for that, or GDHARNESS_EDITOR_RESTART_TIMEOUT_MS, and an old editor still running after it is not replaced, since the new one would find its ports held. One opened by hand restarts itself, which only one with a window can do, because the engine hands back none of the arguments it was started with. editor_status says which editor is connected and whether it is holding an old addon. Opening a project is a save and so is closing one, which is the part that is not obvious from outside: the editor imports the project on open and writes project.godot back, and Godot writes only what differs from its own defaults, so a key named deliberately at its default value is dropped either way. A restart says which under settingsDropped in its own answer because it waits for the editor to return. An open cannot, since it answers as soon as the process exists and the save happens during the import minutes later, so editor_status carries that reading once the editor has connected. Nothing else will say a key went until something depends on one. A restart of an editor this server opened is a quit and then a launch, and this server can be ended between them, usually by the reconnect the restart was being taken for: the editor is gone and nothing replaces it. That is written down before the quit, so the next server says so under restartInterrupted in editor_status rather than waiting for an editor that is not coming, and open finishes it, saying so under finishesRestart. An open is refused when the editor it would start could never reach this server: a project other than the one this server serves, whose editor dials that project's own server; a project without the gdharness editor addon installed and enabled; and a project whose editor a restart is already bringing back.",
     parameters: {
       projectPath: { ...PROJECT_PATH2, ops: ["open"] },
       hidden: {
@@ -34492,6 +34739,11 @@ var TOOL_SPECS = [
         effect: "destructive",
         summary: "restart the connected editor and wait for it",
         requires: []
+      },
+      close: {
+        effect: "destructive",
+        summary: "save and quit the connected editor, and wait for it to go",
+        requires: []
       }
     },
     defaultOperation: "open"
@@ -34617,7 +34869,7 @@ var TOOL_SPECS = [
   {
     name: "editor_output",
     title: "Game and editor output",
-    description: "What the project started by editor_run has printed, as entries with a severity: the errors and warnings the engine reported, each with where it happened, and everything else as info. For a run the editor plays the reports come from the game itself, through the runtime addon, since the editor's debugger relays what a game prints and not what it reports; a played game without the runtime addon answers here with its prints alone, with errorsUnread true and no clean, since what it raised reaches nothing here. Answers with the counts and the verdict as well as the entries. heldAt is three answers: null for a run this server knows is not held, running or over, an object for one it knows is held at a breakpoint, whether the adapter said so or the runtime did by accepting a connection and never answering, and absent with heldUnknown beside it for a server that connected to the debugger after the stop and has no runtime to ask, since the adapter reports a stop only to the sessions connected when it happened. A run that has quit still answers here, with running false and its exit code, until the next one starts; a run ended by a signal has no exit code, and exitSignal names the signal instead. A run this server started also answers with transcript, the file both its streams are written to: uncapped, written while the run is going, and the thing to read or tail for a long run rather than the engine's own log, which every engine start rotates away. Read the file for output and this answer for state: endedBy says whether gdharness ended the run, and a transcript that has stopped growing is a run between prints rather than a run that is over. running is asked of the operating system whenever there is a process to ask about, which is every run this server started and every editor-played run whose game announced its runtime. For an editor-played run that never announced, there is no process id here and running is the editor's answer, which can lag: one measured elsewhere reported a game as playing for fifteen seconds after its process had been ended from outside. editor_status names that game under runtimes, which does not depend on the editor answering. op: \"editor\" answers about the editor itself instead, which is a different log and the only way anything here can read what an editor printed: its console reaches no plugin, so the addon cannot scrape it, and an editor gdharness opened is asked for a log file as it starts. That covers the whole session from the editor's first line, which is where the output worth reading usually is, since the class cache, the plugins and the language server all say what they have to say before any harness has connected. The answer carries the entries in the order they were printed and, beside them under repeated, each message shape several lines share: how many, what varied in each slot of it and how many different values stood there, the first occurrence, and the ordinary lines above the group, found by walking back past the group rather than by counting lines. An editor somebody opened by hand has no console here and is refused saying so rather than answered empty, because an editor that printed nothing and an editor nobody captured are not the same thing. startedAt is when the run began and elapsedMs how long it has been going; for a run that is over, endedAt is when it ended and elapsedMs how long it ran, and both are left out when nobody saw the end, as for a game closed in the editor or a run picked up from a note written before ends were recorded.",
+    description: "What the project started by editor_run has printed, as entries with a severity: the errors and warnings the engine reported, each with where it happened, and everything else as info. For a run the editor plays the reports come from the game itself, through the runtime addon, since the editor's debugger relays what a game prints and not what it reports; a played game without the runtime addon answers here with its prints alone, with errorsUnread true and no clean, since what it raised reaches nothing here. Answers with the counts and the verdict as well as the entries: clean is true when no error was reported, and warnings, counted beside it, do not make it false. heldAt is three answers: null for a run this server knows is not held, running or over, an object for one it knows is held at a breakpoint, whether the adapter said so or the runtime did by accepting a connection and never answering, and absent with heldUnknown beside it for a server that connected to the debugger after the stop and has no runtime to ask, since the adapter reports a stop only to the sessions connected when it happened. A run that has quit still answers here, with running false and its exit code, until the next one starts; a run ended by a signal has no exit code, and exitSignal names the signal instead. A run this server started also answers with transcript, the file both its streams are written to: uncapped, written while the run is going, and the thing to read or tail for a long run rather than the engine's own log, which every engine start rotates away. Read the file for output and this answer for state: endedBy says whether gdharness ended the run, and a transcript that has stopped growing is a run between prints rather than a run that is over. running is asked of the operating system whenever there is a process to ask about, which is every run this server started and every editor-played run whose game announced its runtime. For an editor-played run that never announced, there is no process id here and running is the editor's answer, which can lag: one measured elsewhere reported a game as playing for fifteen seconds after its process had been ended from outside. editor_status names that game under runtimes, which does not depend on the editor answering. op: \"editor\" answers about the editor itself instead, which is a different log and the only way anything here can read what an editor printed: its console reaches no plugin, so the addon cannot scrape it, and an editor gdharness opened is asked for a log file as it starts. That covers the whole session from the editor's first line, which is where the output worth reading usually is, since the class cache, the plugins and the language server all say what they have to say before any harness has connected. The answer carries the entries in the order they were printed and, beside them under repeated, each message shape several lines share: how many, what varied in each slot of it and how many different values stood there, the first occurrence, and the ordinary lines above the group, found by walking back past the group rather than by counting lines. An editor somebody opened by hand has no console here and is refused saying so rather than answered empty, because an editor that printed nothing and an editor nobody captured are not the same thing. startedAt is when the run began and elapsedMs how long it has been going; for a run that is over, endedAt is when it ended and elapsedMs how long it ran, and both are left out when nobody saw the end, as for a game closed in the editor or a run picked up from a note written before ends were recorded.",
     parameters: {
       severity: {
         type: "string",
@@ -34658,7 +34910,7 @@ var TOOL_SPECS = [
       },
       editor: {
         effect: "read",
-        summary: "What the connected editor itself has printed, from its first line, with repeated messages grouped and the ordinary lines above each group carried with it",
+        summary: "What the connected editor itself has printed, from its first line, with repeated messages grouped and the ordinary lines above each group carried with it. The engine's progress bars are one line per task, saying how far an unfinished one got",
         requires: []
       }
     },
@@ -35311,7 +35563,6 @@ var RUNTIME_AUTOLOAD = {
   name: "GdharnessRuntime",
   path: "addons/gdharness_runtime/runtime_autoload.gd"
 };
-var VERSION_MARKER = ".gdharness-version";
 var DIGEST_MARKER = ".gdharness-digest";
 var RUNTIME_ADDON = "gdharness_runtime";
 function editorAddonDigest(from = shippedAddonsDirectory()) {
@@ -36061,6 +36312,7 @@ var SCAN_SETTLED_MS = 500;
 var REIMPORT_TIMEOUT_MS = 300000;
 var AUDIO_BUS_OPS = new Set([
   "add_audio_bus",
+  "remove_audio_bus",
   "set_audio_bus_effect",
   "set_audio_bus_volume"
 ]);
@@ -36082,6 +36334,7 @@ function settingsNamedBy(op, args) {
     case "set_main_scene":
       return ["application/run/main_scene"];
     case "add_input_action":
+    case "remove_input_action":
       return text("actionName") === "" ? [] : [`input/${text("actionName")}`];
     case "enable_plugin":
     case "disable_plugin":
@@ -36680,6 +36933,7 @@ class GodotServer {
   launchedEditor = null;
   launchedFrom = null;
   launchedDropped = null;
+  closedHere = null;
   ownProject;
   announcedAt = null;
   handingOverFrom = null;
@@ -36689,6 +36943,7 @@ class GodotServer {
     this.godotBridge = getDefaultBridge(this.ownProject);
     this.godotBridge.identifyEditorsWith(oneShotOptionOf);
     this.godotBridge.on("godot_connected", () => {
+      this.closedHere = null;
       this.settleTheLaunchReading();
     });
     this.setupShutdownHandlers();
@@ -37282,6 +37537,10 @@ class GodotServer {
         }
       case "scene_animation":
         switch (op) {
+          case "read":
+            return await bridge("read_animations");
+          case "read_states":
+            return await bridge("read_animation_states");
           case "create":
             return await bridge("create_animation");
           case "add_track":
@@ -37306,6 +37565,8 @@ class GodotServer {
         return await this.handleScriptDiagnostics(args);
       case "resource_edit":
         switch (op) {
+          case "read":
+            return await bridge("read_resource");
           case "create":
             return await bridge("create_resource");
           case "modify":
@@ -37320,6 +37581,9 @@ class GodotServer {
             return await bridge("set_theme_font_size", { themePath: args["resourcePath"] });
         }
       case "editor_launch":
+        if (op === "close") {
+          return await this.handleCloseEditor();
+        }
         return op === "restart" ? await this.handleRestartEditor(args) : await this.handleLaunchEditor(args);
       case "editor_run":
         if (op === "stop") {
@@ -38217,21 +38481,31 @@ class GodotServer {
     }
     const missing = paths.value.filter((path) => !existsSync17(join22(project.value.path, path.slice("res://".length))));
     const asked = paths.value.filter((path) => !missing.includes(path));
+    const runner = "addons/gdUnit4/bin/GdUnitCmdTool.gd";
+    const noRunner = !existsSync17(join22(project.value.path, runner));
     if (asked.length === 0) {
       const verdict = `nothing at ${missing.join(" and ")}`;
+      const andNoRunner = noRunner ? `, and gdUnit4 is not installed in this project: no ${runner}` : "";
       return {
         content: [
           {
             type: "text",
-            text: `No tests ran: ${verdict}.${elsewhereIn(project.value.path, missing[0] ?? "")}`
+            text: `No tests ran: ${verdict}${andNoRunner}.${elsewhereIn(project.value.path, missing[0] ?? "")}`
           },
-          { type: "text", text: answerJson({ passed: false, verdict, tests: 0 }) }
+          {
+            type: "text",
+            text: answerJson({
+              passed: false,
+              verdict,
+              tests: 0,
+              ...noRunner ? { gdUnit4Installed: false } : {}
+            })
+          }
         ],
         isError: true
       };
     }
-    const runner = "addons/gdUnit4/bin/GdUnitCmdTool.gd";
-    if (!existsSync17(join22(project.value.path, runner))) {
+    if (noRunner) {
       return this.createErrorResponse(`gdUnit4 is not installed in this project: no ${runner}.`, [
         "Install gdUnit4 under addons/gdUnit4, from https://github.com/godot-gdunit-labs/gdUnit4"
       ]);
@@ -38814,8 +39088,12 @@ class GodotServer {
       addonIsStale: greeted ? stale : undefined,
       greeting: status.connected && !greeted ? "The editor has connected and has not yet said who it is: its project, pid, addon version and ports arrive with its greeting a moment after the socket opens, later while it imports. Ask again for them." : undefined,
       bridgeAvailable: this.bridgeStartupError === null && status.port !== null,
-      mayYetConnect: status.connected ? undefined : arriving.length > 0 ? true : unfinished !== null ? unfinished.underway : anEditorIsStillComing(status.listeningSince, launchedIsUp),
+      mayYetConnect: status.connected ? undefined : arriving.length > 0 ? true : unfinished !== null ? unfinished.underway : this.closedHere !== null ? false : anEditorIsStillComing(status.listeningSince, launchedIsUp),
       editorsNotYetConnected: arriving.length > 0 ? arriving : undefined,
+      closedHere: status.connected || arriving.length > 0 || this.closedHere === null ? undefined : {
+        ...this.closedHere,
+        note: "This server closed the editor on request, so nothing is coming until editor_launch open starts one."
+      },
       restartInterrupted: unfinished === null || unfinished.underway || arriving.length > 0 ? undefined : {
         quitEditorPid: unfinished.note.editorPid,
         quitAt: unfinished.note.quitAt,
@@ -39060,6 +39338,42 @@ class GodotServer {
       tookMs: Date.now() - began
     });
   }
+  async handleCloseEditor() {
+    const before = this.godotBridge.getStatus();
+    if (!before.connected) {
+      return this.createErrorResponse("No editor is connected, so there is nothing to close.", [
+        "editor_status says whether the bridge is up and what has reached it"
+      ]);
+    }
+    if (!hasSaidWhoItIs(before) || before.editorPid === undefined) {
+      return this.createErrorResponse(`The editor has connected and has not said who it is within ${greetingWaitMs() / 1000}s, so there is no process to wait on once it is asked to go.`, ["editor_status says when it has, under greeting while it has not", "Then ask for the close again"]);
+    }
+    const pid = before.editorPid;
+    const settingsBefore = this.settingKeysOf(before.projectPath);
+    const asked = await this.handleViaBridge("quit_editor", {});
+    if (asked.isError === true) {
+      return asked;
+    }
+    const began = Date.now();
+    const gone = await this.waitForBridge(() => !alive(pid), began + editorRestartTimeoutMs());
+    if (!gone) {
+      return this.createErrorResponse(`The editor saved and was asked to go, and pid ${pid} is still running after ${editorRestartTimeoutMs() / 1000}s.`, [
+        "It may be asking what to do about unsaved changes, or a script may be holding up its exit",
+        "editor_status says whether it is still connected"
+      ]);
+    }
+    this.closedHere = { editorPid: pid, at: new Date().toISOString() };
+    if (this.launchedEditor?.pid === pid) {
+      this.launchedEditor = null;
+    }
+    return this.jsonTextResponse({
+      closed: true,
+      editorPid: pid,
+      projectPath: before.projectPath,
+      ...this.whatTheEditorDropped(settingsBefore, this.settingKeysOf(before.projectPath)),
+      tookMs: Date.now() - began
+    });
+  }
   settleTheLaunchReading() {
     const watched = this.launchedFrom;
     const status = this.godotBridge.getStatus();
@@ -39231,6 +39545,7 @@ class GodotServer {
       pid: launched.pid,
       startedAt: (await startTimesOf([launched.pid])).get(launched.pid) ?? null
     };
+    this.closedHere = null;
     return { pid: launched.pid, error: null };
   }
   async portsForAnEditor() {
@@ -39476,7 +39791,7 @@ class GodotServer {
         frameFunctions: profileFrameFunctions(projectPath)
       });
       if (armed.isError === true) {
-        return this.profilerRefusal(armed);
+        return armed;
       }
     }
     const answer = await this.handleViaBridge("play_scene", scene === null ? {} : { scenePath: `res://${scene}` });
@@ -40326,7 +40641,7 @@ class GodotServer {
   async profileOfThePlayedGame(going, projectPath, fromProject, limit) {
     const read = await this.handleViaBridge("profile_read", {});
     if (read.isError === true) {
-      return this.profilerRefusal(read);
+      return read;
     }
     const held = asParams(JSON.parse(read.content[0]?.text ?? "{}"));
     if (readBoolean(held, "profiled") !== true && readBoolean(held, "armed") !== true) {
@@ -40339,7 +40654,7 @@ class GodotServer {
         frameFunctions: profileFrameFunctions(projectPath)
       });
       if (started.isError === true) {
-        return this.profilerRefusal(started);
+        return started;
       }
       if (readBoolean(asParams(JSON.parse(started.content[0]?.text ?? "{}")), "started") !== true) {
         return this.createErrorResponse("The editor says it is playing and has no debugger session for the game, so there is nothing to switch the profiler on in yet.", ["Ask again in a moment, once the game is up"]);
@@ -40395,13 +40710,6 @@ class GodotServer {
     }
     return false;
   }
-  profilerRefusal(refused) {
-    const said = refused.content[0]?.text ?? "";
-    return said.includes("Unknown tool: profile_") ? this.createErrorResponse("The editor's gdharness addon is older than the profiler, so it cannot profile the game it plays.", [
-      "editor_launch restart loads the addon this server installed",
-      "editor_status says which addon the editor holds"
-    ]) : refused;
-  }
   async handleWaitForRun(args) {
     await this.pickUpWhatTheEditorIsPlaying();
     const run = await this.currentRun();
@@ -41365,7 +41673,13 @@ class GodotServer {
     try {
       return this.jsonTextResponse(markIfStale(await this.godotBridge.invokeTool(toolName, args), this.godotBridge.getStatus().addonVersion, SERVER_VERSION, this.godotBridge.getStatus().addonDigest, shippedEditorDigest(), this.editorCodeOnDisk()));
     } catch (error) {
-      return this.createErrorResponse(`The editor answered ${toolName} with an error: ${errorMessage(error)}`);
+      const message = errorMessage(error);
+      if (message.includes(`Unknown tool: ${toolName}`)) {
+        const status = this.godotBridge.getStatus();
+        const remedy = addonMismatch(status.addonVersion, SERVER_VERSION, status.addonDigest, shippedEditorDigest(), this.editorCodeOnDisk());
+        return this.createErrorResponse(`The editor's gdharness addon is older than this ${SERVER_VERSION} server and has no ${toolName}, so it cannot answer this call. ${remedy ?? "Restart it with editor_launch restart to load the addon the project holds."}`, ["editor_status says which addon the editor holds"]);
+      }
+      return this.createErrorResponse(`The editor answered ${toolName} with an error: ${message}`);
     }
   }
   runtimeTimeoutMs() {