gdharness 1.2.33 → 1.2.35

package/build/cli.js

@@ -7847,6 +7847,11 @@ function isWithinRoot(rootPath, candidatePath) {
   const step = relative(resolve(rootPath), resolve(candidatePath));
   return step !== ".." && !step.startsWith(`..${sep}`) && !isAbsolute(step);
 }
+function keptInside(given) {
+  const at = given.indexOf("::");
+  const inner = at === -1 ? "" : given.slice(at + 2);
+  return KEPT_ID.test(inner) ? { file: given.slice(0, at), inner } : { file: given, inner: undefined };
+}
 function resolveWithinProject(projectPath, candidatePath, options = {}) {
   const trimmed = candidatePath.trim();
   if (trimmed === "") {
@@ -7875,6 +7880,13 @@ function resolveWithinProject(projectPath, candidatePath, options = {}) {
       reason: `Path '${trimmed}' is absolute; give a path inside the project, such as 'scenes/main.tscn'.`
     };
   }
+  const kept = keptInside(trimmed);
+  if (kept.inner !== undefined) {
+    return {
+      ok: false,
+      reason: `Path '${trimmed}' names the resource ${kept.inner} kept inside ${kept.file}, not a file. resource_edit read reads one by that path; this argument takes a file.`
+    };
+  }
   if (withoutScheme.includes(":")) {
     return {
       ok: false,
@@ -7917,9 +7929,10 @@ function exportedBuild(projectPath, candidatePath) {
   }
   return { ok: true, absolutePath: real, relativePath: found.relativePath };
 }
-var RESOURCE_SCHEME = "res://", OTHER_SCHEME;
+var RESOURCE_SCHEME = "res://", OTHER_SCHEME, KEPT_ID;
 var init_paths = __esm(() => {
   OTHER_SCHEME = /^[a-zA-Z][a-zA-Z\d+.-]+:\/\//;
+  KEPT_ID = /^[A-Za-z0-9_]+$/;
 });
 
 // src/runner.ts
@@ -8128,9 +8141,14 @@ class GameLog {
     const owner = this.lastHeadline[source];
     if (owner !== null && /^\s/.test(line)) {
       owner.detail.push(line.trim());
+      owner.continues = false;
       return;
     }
     const headline = announced(line);
+    if (owner?.continues === true && headline === null) {
+      owner.detail.push(line.trim());
+      return;
+    }
     const detail = [];
     const entry = {
       index: this.entries.length,
@@ -8143,7 +8161,7 @@ class GameLog {
     if (headline?.byScript === true) {
       this.byScript.add(entry.index);
     }
-    this.lastHeadline[source] = headline ? { detail } : null;
+    this.lastHeadline[source] = headline ? { detail, continues: source === "stderr" && headline.text.endsWith(":") } : null;
   }
   raisedByScript(entry) {
     return this.byScript.has(entry.index);
@@ -11308,7 +11326,7 @@ var init_tool_definitions = __esm(() => {
     {
       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. 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 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.",
       parameters: {
         projectPath: PROJECT_PATH,
         setting: {
@@ -11406,8 +11424,8 @@ var init_tool_definitions = __esm(() => {
           requires: ["scenePath"]
         },
         add_input_action: {
-          effect: "additive",
-          summary: "register an input action and its events",
+          effect: "destructive",
+          summary: "register an input action and its events, or rebind one that exists",
           requires: ["actionName", "events"]
         },
         remove_input_action: {
@@ -11545,20 +11563,36 @@ var init_tool_definitions = __esm(() => {
     {
       name: "project_export",
       title: "Export",
-      description: "Export presets and exports.",
+      description: "Export presets and exports. add_preset writes a preset to export_presets.cfg with the keys the editor's Project > Export writes for a new one, every platform option left at its default, and makes it the platform's runnable preset when the platform has none. It answers where this engine's export templates belong and whether the preset's platform has them, since an export needs them; list says the same for every preset. An editor open on the project does not see a preset added this way until it restarts. run names, as alsoWritten, what else the export wrote beside its output, such as the .pck a Windows or Linux build cannot start without.",
       parameters: {
         projectPath: PROJECT_PATH,
-        preset: { type: "string", description: "Preset name from export_presets.cfg." },
+        preset: {
+          type: "string",
+          ops: ["run", "add_preset"],
+          description: "Preset name from export_presets.cfg. add_preset: the name of the new one."
+        },
+        platform: {
+          type: "string",
+          ops: ["add_preset"],
+          enum: ["Windows Desktop", "Linux", "macOS", "Android", "iOS", "Web"],
+          description: "add_preset: the platform the preset exports for."
+        },
         outputPath: {
           type: "string",
-          description: `Where the export is written, inside the project. The directory is created if it is not there: Godot's command-line exporter refuses a missing one with "The given export path doesn't exist", which reads as a wrong path in the preset.`
+          ops: ["run", "add_preset"],
+          description: `Where the export is written, inside the project. The directory is created if it is not there: Godot's command-line exporter refuses a missing one with "The given export path doesn't exist", which reads as a wrong path in the preset. add_preset: the path the preset exports to from the editor, optional.`
         },
-        debug: { type: "boolean", description: "run: a debug export. Default false." }
+        debug: { type: "boolean", ops: ["run"], description: "run: a debug export. Default false." }
       },
       requires: ["projectPath"],
       operations: {
         list: { effect: "read", summary: "the presets in export_presets.cfg", requires: [] },
-        run: { effect: "destructive", summary: "export with a preset", requires: ["preset", "outputPath"] }
+        run: { effect: "destructive", summary: "export with a preset", requires: ["preset", "outputPath"] },
+        add_preset: {
+          effect: "additive",
+          summary: "add an export preset to export_presets.cfg",
+          requires: ["preset", "platform"]
+        }
       }
     },
     {
@@ -11755,7 +11789,7 @@ var init_tool_definitions = __esm(() => {
     {
       name: "scene_animation",
       title: "Animations",
-      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.",
+      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. read and read_states need no editor: one serving the project answers and says whether it holds unsaved changes to the scene, and with none a headless engine reads the file without running the scene's scripts. The ops that write need the editor connected.",
       parameters: {
         projectPath: PROJECT_PATH,
         scenePath: SCENE_PATH,
@@ -11787,7 +11821,11 @@ var init_tool_definitions = __esm(() => {
           ops: ["read_states", "add_state", "connect_states"],
           description: "The AnimationTree node."
         },
-        stateName: { type: "string", ops: ["add_state"], description: "add_state: the state to add." },
+        stateName: {
+          type: "string",
+          ops: ["add_state"],
+          description: "add_state: the state to add. It goes right of the rightmost state in the editor's graph, answered under position."
+        },
         stateMachinePath: {
           type: "string",
           ops: ["read_states", "add_state", "connect_states"],
@@ -11962,7 +12000,7 @@ var init_tool_definitions = __esm(() => {
         projectPath: PROJECT_PATH,
         resourcePath: {
           ...RESOURCE_PATH,
-          description: `${RESOURCE_FILE} move: a directory too.`
+          description: `${RESOURCE_FILE} move: a directory too. read: also a resource kept inside a scene or resource file, by the path a read answers a property holding it with, such as "res://hero.tscn::Animation_jump".`
         },
         resourceType: {
           type: "string",
@@ -12929,7 +12967,7 @@ var init_headless_operations = __esm(() => {
       uid: "get_uid",
       refresh_classes: "refresh_class_cache"
     }),
-    project_export: dictionary({ list: "list_export_presets" }),
+    project_export: dictionary({ list: "list_export_presets", add_preset: "add_export_preset" }),
     script_edit: dictionary({ create: "create_script", modify: "modify_script" }),
     script_info: dictionary({ structure: "get_script_info" }),
     editor_classes: dictionary({
@@ -44875,7 +44913,7 @@ function exportPresetRefusal(projectPath, preset) {
   try {
     text = readFileSync26(join30(projectPath, "export_presets.cfg"), "utf8");
   } catch {
-    return `This project has no export_presets.cfg, so it has no preset '${preset}' to export with. The editor writes the file when a preset is added in Project > Export.`;
+    return `This project has no export_presets.cfg, so it has no preset '${preset}' to export with. project_export add_preset writes one, as the editor's Project > Export does.`;
   }
   const names = [];
   let inPreset = false;
@@ -44893,9 +44931,9 @@ function exportPresetRefusal(projectPath, preset) {
   if (names.includes(preset)) {
     return null;
   }
-  return names.length === 0 ? `export_presets.cfg names no preset, so there is no '${preset}' to export with. The editor adds one in Project > Export.` : `This project has no export preset named '${preset}'. Its presets are ${names.map((name) => `'${name}'`).join(", ")}.`;
+  return names.length === 0 ? `export_presets.cfg names no preset, so there is no '${preset}' to export with. project_export add_preset adds one.` : `This project has no export preset named '${preset}'. Its presets are ${names.map((name) => `'${name}'`).join(", ")}.`;
 }
-function exportAnswer(ending, asked, before, after) {
+function exportAnswer(ending, asked, before, after, beside = []) {
   const { log } = ending;
   const written = after !== null && after !== before;
   const notCopied = librariesNotCopied(log.all);
@@ -44907,6 +44945,7 @@ function exportAnswer(ending, asked, before, after) {
     failure: ending.failure ?? undefined,
     errors: log.count("error"),
     warnings: log.count("warning"),
+    ...beside.length === 0 ? {} : { alsoWritten: beside },
     ...notCopied.length === 0 ? {} : {
       librariesNotLoaded: notCopied,
       extensionNote: `The export could not load ${notCopied.join(" and ")}: on Windows an engine running as the editor, which an export is, loads a GDExtension from a ~ copy beside the library, and another engine on this project held that copy: it could not be moved aside before the export, or another engine made a new one in between. Export again once that engine has loaded or exited.`
@@ -44929,6 +44968,20 @@ function exportAnswer(ending, asked, before, after) {
     isError: true
   };
 }
+function writtenBeside(before, after, output, within) {
+  return [...after].filter(([name, at]) => name !== output && before.get(name) !== at).map(([name]) => within === "." ? name : `${within}/${name}`).sort();
+}
+function filesIn(folder) {
+  const found = new Map;
+  try {
+    for (const entry of readdirSync13(folder, { withFileTypes: true })) {
+      if (entry.isFile()) {
+        found.set(entry.name, statSync13(join30(folder, entry.name)).mtimeMs);
+      }
+    }
+  } catch {}
+  return found;
+}
 function scanWaitAnswer(scanned, started = "game") {
   if (scanned.waitedMs === 0) {
     return {};
@@ -46163,6 +46216,9 @@ class GodotServer {
     if (tool === "project_import" && op === "set_options") {
       return await this.handleSetImportOptions(args);
     }
+    if (tool === "project_export" && op === "add_preset") {
+      return await this.handleAddExportPreset(args);
+    }
     const headless = HEADLESS_OPERATIONS[tool]?.[op];
     if (headless !== undefined) {
       const { from: asked, ...answerable } = args;
@@ -46220,7 +46276,11 @@ class GodotServer {
       case "scene_create":
         return op === "create" ? await bridge("create_scene") : await bridge("save_scene");
       case "scene_tree":
-        return await this.readFromFile(args, "scenePath", "read_scene_tree", async () => await bridge("list_scene_nodes"));
+        return await this.readFromFile(args, "scenePath", "read_scene_tree", (file) => ({
+          scenePath: file,
+          depth: readNumber(args, "depth") ?? -1,
+          includeProperties: readBoolean(args, "includeProperties") ?? false
+        }), async () => await bridge("list_scene_nodes"));
       case "scene_node":
         switch (op) {
           case "add":
@@ -46250,9 +46310,17 @@ class GodotServer {
       case "scene_animation":
         switch (op) {
           case "read":
-            return await bridge("read_animations");
+            return await this.readFromFile(args, "scenePath", "read_animations", (file) => ({
+              scenePath: file,
+              playerNodePath: readNonEmptyString(args, "playerNodePath") ?? ".",
+              animationName: readString(args, "animationName") ?? ""
+            }), async () => await bridge("read_animations"));
           case "read_states":
-            return await bridge("read_animation_states");
+            return await this.readFromFile(args, "scenePath", "read_animation_states", (file) => ({
+              scenePath: file,
+              animTreePath: readString(args, "animTreePath") ?? "",
+              stateMachinePath: readString(args, "stateMachinePath") ?? ""
+            }), async () => await bridge("read_animation_states"));
           case "create":
             return await bridge("create_animation");
           case "add_track":
@@ -46279,8 +46347,14 @@ class GodotServer {
         switch (op) {
           case "move":
             return await this.handleMoveFile(args);
-          case "read":
-            return await this.readFromFile(args, "resourcePath", "read_resource", async () => await bridge("read_resource"));
+          case "read": {
+            const { file, inner } = keptInside(readString(args, "resourcePath") ?? "");
+            const kept = inner === undefined ? {} : { resourcePath: file, subResource: inner };
+            return await this.readFromFile({ ...args, ...kept }, "resourcePath", "read_resource", (found) => ({
+              resourcePath: inner === undefined ? found : `${found}::${inner}`,
+              includeDefaults: readBoolean(args, "includeDefaults") ?? false
+            }), async () => await bridge("read_resource", kept));
+          }
           case "create":
             return await bridge("create_resource");
           case "modify":
@@ -47208,6 +47282,30 @@ class GodotServer {
       return this.createErrorResponse(`Search failed: ${errorMessage(error)}`);
     }
   }
+  async handleAddExportPreset(args) {
+    const project = this.project(args);
+    if (!project.ok) {
+      return project.response;
+    }
+    const given = readNonEmptyString(args, "outputPath");
+    const output = given === undefined ? null : resolveWithinProject(project.value.path, given);
+    if (output !== null && !output.ok) {
+      return this.createErrorResponse(output.reason, OUTPUT_PATH_SOLUTIONS);
+    }
+    const outcome = await this.operation("add_export_preset", {
+      preset: readString(args, "preset") ?? "",
+      platform: readString(args, "platform") ?? "",
+      outputPath: output?.relativePath ?? ""
+    }, project.value.path);
+    if (!outcome.ok || !this.editorHasOpen(project.value.path)) {
+      return this.answer(outcome);
+    }
+    return this.jsonTextResponse({
+      ...outcome.payload,
+      editorNote: "The editor open on this project read export_presets.cfg when it started and does not list this preset, and saving presets in its Export dialog writes its own list over the file. editor_launch restart loads the file; an export through project_export run reads the file and needs no restart.",
+      ...engineExtras(outcome)
+    });
+  }
   async handleExportProject(args) {
     const project = this.project(args);
     if (!project.ok) {
@@ -47216,11 +47314,14 @@ class GodotServer {
     const preset = readNonEmptyString(args, "preset") ?? "";
     const output = resolveWithinProject(project.value.path, readString(args, "outputPath") ?? "");
     if (!output.ok) {
-      return this.createErrorResponse(output.reason, PATH_SOLUTIONS);
+      return this.createErrorResponse(output.reason, OUTPUT_PATH_SOLUTIONS);
     }
     const noPreset = exportPresetRefusal(project.value.path, preset);
     if (noPreset !== null) {
-      return this.createErrorResponse(noPreset, ["project_export list reads the presets the project has"]);
+      return this.createErrorResponse(noPreset, [
+        "project_export list reads the presets the project has",
+        "project_export add_preset adds one"
+      ]);
     }
     const engine = await this.engine();
     if (!engine.ok) {
@@ -47247,6 +47348,7 @@ class GodotServer {
     this.logDebug(`Exporting: ${engine.value} ${exportArgs.join(" ")}`);
     const writtenAt = () => existsSync23(output.absolutePath) ? statSync13(output.absolutePath).mtimeMs : null;
     const before = writtenAt();
+    const listedBefore = filesIn(folder);
     const freed = freeLibraryCopies(project.value.path);
     if (freed.setAside.length > 0 || freed.swept.length > 0) {
       this.logDebug(`Before the export: set aside ${freed.setAside.join(", ")}; swept ${freed.swept.join(", ")}`);
@@ -47260,7 +47362,8 @@ class GodotServer {
     if (ending.exitSignal === null && ending.exitCode === null) {
       return this.createErrorResponse(`Export could not be run: ${ending.failure ?? "the engine gave no exit status"}`);
     }
-    return exportAnswer(ending, { preset, outputPath: output.relativePath, debug }, before, writtenAt());
+    const beside = writtenBeside(listedBefore, filesIn(folder), basename9(output.absolutePath), dirname22(output.relativePath).replaceAll("\\", "/"));
+    return exportAnswer(ending, { preset, outputPath: output.relativePath, debug }, before, writtenAt(), beside);
   }
   reportTestProgress(log) {
     const progress = callProgress();
@@ -50670,7 +50773,7 @@ class GodotServer {
       ...leftChanged === undefined ? {} : { note: leftChanged }
     });
   }
-  async readFromFile(args, pathKey, operation, throughTheEditor) {
+  async readFromFile(args, pathKey, operation, paramsFor, throughTheEditor) {
     const project = this.project(args);
     if (!project.ok) {
       return project.response;
@@ -50688,12 +50791,7 @@ class GodotServer {
     if (file === null) {
       return this.createErrorResponse(`${pathKey} must name a file inside the project.`);
     }
-    const params = operation === "read_scene_tree" ? {
-      scenePath: file,
-      depth: readNumber(args, "depth") ?? -1,
-      includeProperties: readBoolean(args, "includeProperties") ?? false
-    } : { resourcePath: file, includeDefaults: readBoolean(args, "includeDefaults") ?? false };
-    const outcome = await this.operation(operation, params, projectPath);
+    const outcome = await this.operation(operation, paramsFor(file), projectPath);
     if (!outcome.ok) {
       return this.answer(outcome);
     }
@@ -51355,7 +51453,7 @@ async function runGodotServer() {
   const server = new GodotServer;
   await server.run();
 }
-var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, __dirname2, PARENT_ASKED_AFTER_MS = 5000, EDITOR_SERVERS_START_MS = 20000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, ALONGSIDE_NOTE = "Another call on this game was running while this one was: calls sent together run together and are answered as each finishes, so this answer is not from after the other. Send a call meant to come after another once that one has answered.", OWN_DEBUGGER = " Its debugger is the keeper holding it rather than the editor, so the debug_* tools answer for it all the same: breakpoints stop it, and debug_control pause breaks into it wherever it is, which the editor offers no way to do.", PLAY_STARTS_WITHIN_MS = 30000, KEEPER_ANSWER_MS = 15000, KEEPER_DEBUG_MS, EXIT_REPORTED_WITHIN_MS = 2000, CLOSE_ASK_MS = 3000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, PROFILE_SEND_MS = 5000, MOST_GROUPS = 20, RUNTIME_LISTENING_LINE = "[gdharness] runtime listening on ", VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, CONSOLE_WATCH_MS = 250, BOUNDARY_WAIT_MS = 2000, HANDOVER_MS, HANDOVER_POLL_MS = 250, CACHE_WRITE_MS = 2000, STREAMS_GRACE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, SCAN_SETTLED_MS = 500, REIMPORT_TIMEOUT_MS = 300000, OPS_ELSEWHERE, AUDIO_BUS_OPS, STALLED_AFTER_MS = 30000, TEST_HEARTBEAT_MS = 20000, DEPENDED_FAILED = "Failed to compile depended scripts", WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/", PROFILE_FUNCTIONS = 30, PROFILER_ON_MS = 3000, PROPERTY_PLACES = "It is a property, so each place says whether it writes it (access write), which runs its set block, or reads it (access read), which runs its get block: withinCalls on a read says nothing of the set block, nor on a write of the get block unless the write is a compound one such as +=. Inside the property's own blocks its name is the value stored, which the engine reads and writes without running them, so those lines are not listed.", CALLERS_FOUND_BY_NAME = "Found by name in the project's scripts, since the engine's profiler counts calls and time per function and records nothing about who made them: a method of the same name on another class is listed too, unless one class was asked about and it is called through another class by name or through a variable declared as one. Each place carries the profile's numbers for the function it is written in.", MOST_ENGINE_ENTRIES = 200, ERROR_ASSERT = "GdUnitGodotErrorAssertImpl.gd", EXTERNAL_MEMBER = 'Could not resolve external class member "', STATIC_LIST_HINT;
+var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, __dirname2, PARENT_ASKED_AFTER_MS = 5000, EDITOR_SERVERS_START_MS = 20000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, ALONGSIDE_NOTE = "Another call on this game was running while this one was: calls sent together run together and are answered as each finishes, so this answer is not from after the other. Send a call meant to come after another once that one has answered.", OWN_DEBUGGER = " Its debugger is the keeper holding it rather than the editor, so the debug_* tools answer for it all the same: breakpoints stop it, and debug_control pause breaks into it wherever it is, which the editor offers no way to do.", PLAY_STARTS_WITHIN_MS = 30000, KEEPER_ANSWER_MS = 15000, KEEPER_DEBUG_MS, EXIT_REPORTED_WITHIN_MS = 2000, CLOSE_ASK_MS = 3000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, PROFILE_SEND_MS = 5000, MOST_GROUPS = 20, RUNTIME_LISTENING_LINE = "[gdharness] runtime listening on ", VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, CONSOLE_WATCH_MS = 250, BOUNDARY_WAIT_MS = 2000, HANDOVER_MS, HANDOVER_POLL_MS = 250, CACHE_WRITE_MS = 2000, STREAMS_GRACE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, SCAN_SETTLED_MS = 500, REIMPORT_TIMEOUT_MS = 300000, OPS_ELSEWHERE, AUDIO_BUS_OPS, STALLED_AFTER_MS = 30000, TEST_HEARTBEAT_MS = 20000, DEPENDED_FAILED = "Failed to compile depended scripts", WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, OUTPUT_PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/", PROFILE_FUNCTIONS = 30, PROFILER_ON_MS = 3000, PROPERTY_PLACES = "It is a property, so each place says whether it writes it (access write), which runs its set block, or reads it (access read), which runs its get block: withinCalls on a read says nothing of the set block, nor on a write of the get block unless the write is a compound one such as +=. Inside the property's own blocks its name is the value stored, which the engine reads and writes without running them, so those lines are not listed.", CALLERS_FOUND_BY_NAME = "Found by name in the project's scripts, since the engine's profiler counts calls and time per function and records nothing about who made them: a method of the same name on another class is listed too, unless one class was asked about and it is called through another class by name or through a variable declared as one. Each place carries the profile's numbers for the function it is written in.", MOST_ENGINE_ENTRIES = 200, ERROR_ASSERT = "GdUnitGodotErrorAssertImpl.gd", EXTERNAL_MEMBER = 'Could not resolve external class member "', STATIC_LIST_HINT;
 var init_server = __esm(() => {
   init_dist();
   init_stdio();
@@ -51437,6 +51535,9 @@ var init_server = __esm(() => {
     'Give the path relative to the project, such as "scenes/main.tscn" or "res://scenes/main.tscn"',
     "Point projectPath at the project the file belongs to"
   ];
+  OUTPUT_PATH_SOLUTIONS = [
+    'Give outputPath inside the project, relative to it, such as "build/game.exe" or "res://build/game.exe"; copy the build elsewhere once it is exported'
+  ];
   PROJECT_FILE_ARGUMENTS = [
     "scenePath",
     "instancePath",

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

@@ -0,0 +1,224 @@
+extends RefCounted
+
+## Animations and state machines read off their nodes: by the editor's tools from the scene it holds,
+## and by a headless engine with none connected from a bare node of the class given what the file
+## stores, which runs no script of the scene's, so a read answers the same either way.
+
+const FileReads = preload("file_reads.gd")
+const Serialisation = preload("serialisation.gd")
+
+const LOOP_MODE_NAMES: Dictionary[int, String] = {
+	Animation.LOOP_NONE: "none",
+	Animation.LOOP_LINEAR: "linear",
+	Animation.LOOP_PINGPONG: "pingpong",
+}
+const TRACK_TYPE_NAMES: Dictionary[int, String] = {
+	Animation.TYPE_VALUE: "property",
+	Animation.TYPE_POSITION_3D: "position_3d",
+	Animation.TYPE_ROTATION_3D: "rotation_3d",
+	Animation.TYPE_SCALE_3D: "scale_3d",
+	Animation.TYPE_BLEND_SHAPE: "blend_shape",
+	Animation.TYPE_METHOD: "method",
+	Animation.TYPE_BEZIER: "bezier",
+	Animation.TYPE_AUDIO: "audio",
+	Animation.TYPE_ANIMATION: "animation",
+}
+const SWITCH_MODE_NAMES: Dictionary[int, String] = {
+	AnimationNodeStateMachineTransition.SWITCH_MODE_IMMEDIATE: "immediate",
+	AnimationNodeStateMachineTransition.SWITCH_MODE_SYNC: "sync",
+	AnimationNodeStateMachineTransition.SWITCH_MODE_AT_END: "at_end",
+}
+
+
+## [method animations] of the AnimationPlayer at [param player_path] in the file [param scene_path].
+static func scene_animations(scene_path: String, player_path: String, animation_name: String) -> Dictionary:
+	var made: Array = _bare(scene_path, player_path, "AnimationPlayer")
+	if made[0] == null:
+		return made[1]
+	var player: AnimationPlayer = made[0]
+	var answer: Dictionary = animations(player, animation_name)
+	player.free()
+	return answer
+
+
+## [method states] of the AnimationTree at [param tree_path] in the file [param scene_path].
+static func scene_states(scene_path: String, tree_path: String, state_machine_path: String) -> Dictionary:
+	var made: Array = _bare(scene_path, tree_path, "AnimationTree")
+	if made[0] == null:
+		return made[1]
+	var tree: AnimationTree = made[0]
+	var answer: Dictionary = states(tree, state_machine_path)
+	tree.free()
+	return answer
+
+
+## A node of the class the file gives the node at [param node_path], holding every property the
+## files set but its script, as [node, null] or [null, refusal]. The caller frees it.
+static func _bare(scene_path: String, node_path: String, kind: String) -> Array:
+	var read: Dictionary = FileReads.scene_node(scene_path, node_path)
+	if not read.is_empty() and not read.get("ok", false):
+		return [null, read]
+	var type: String = str(read.get("type", ""))
+	if not ClassDB.class_exists(type) or not ClassDB.is_parent_class(type, kind):
+		return [null, {"ok": false, "error": "%s not found at: %s" % [kind, node_path]}]
+	var bare: Node = ClassDB.instantiate(type)
+	bare.name = str(read["name"])
+	var given: Dictionary = read["properties"]
+	for property: Variant in given:
+		if str(property) != "script":
+			bare.set(str(property), given[property])
+	return [bare, null]
+
+
+## The animations of [param player] with their lengths, or [param animation_name] whole when it is
+## given. A track comes back in the shape add_track takes, so one read here can be written to
+## another animation as it stands.
+static func animations(player: AnimationPlayer, animation_name: String) -> Dictionary:
+	if animation_name.is_empty():
+		var listed: Array[Dictionary] = []
+		for called: String in player.get_animation_list():
+			var listed_one: Animation = player.get_animation(StringName(called))
+			var summary: Dictionary = _summary(listed_one)
+			summary["animationName"] = called
+			summary["tracks"] = listed_one.get_track_count()
+			listed.append(summary)
+		return {"ok": true, "animations": listed}
+	if not player.has_animation(StringName(animation_name)):
+		var names: PackedStringArray = player.get_animation_list()
+		return {
+			"ok": false,
+			"error":
+			(
+				"%s has no animation %s. It has: %s."
+				% [player.name, animation_name, ", ".join(names) if not names.is_empty() else "none"]
+			)
+		}
+	var anim: Animation = player.get_animation(StringName(animation_name))
+	var answer: Dictionary = _summary(anim)
+	answer["ok"] = true
+	answer["animationName"] = animation_name
+	var tracks: Array[Dictionary] = []
+	var values: Serialisation = Serialisation.new()
+	for track: int in anim.get_track_count():
+		tracks.append(_track(anim, track, values))
+	answer["tracks"] = tracks
+	return answer
+
+
+static func _summary(anim: Animation) -> Dictionary:
+	return {
+		"length": anim.length,
+		"loopMode": LOOP_MODE_NAMES.get(anim.loop_mode, str(anim.loop_mode)),
+		"step": anim.step,
+	}
+
+
+static func _track(anim: Animation, track: int, values: Serialisation) -> Dictionary:
+	var kind: int = anim.track_get_type(track)
+	var path: NodePath = anim.track_get_path(track)
+	var shaped: Dictionary = {
+		"type": TRACK_TYPE_NAMES.get(kind, str(kind)), "nodePath": str(path.get_concatenated_names())
+	}
+	var property: String = str(path.get_concatenated_subnames())
+	if not property.is_empty():
+		shaped["property"] = property
+	var keyframes: Array[Dictionary] = []
+	var methods: Dictionary = {}
+	for key: int in anim.track_get_key_count(track):
+		var keyframe: Dictionary = {"time": anim.track_get_key_time(track, key)}
+		if kind == Animation.TYPE_METHOD:
+			var method: String = str(anim.method_track_get_name(track, key))
+			methods[method] = true
+			keyframe["method"] = method
+			keyframe["args"] = values.serialize_value(anim.method_track_get_params(track, key))
+		else:
+			keyframe["value"] = values.serialize_value(anim.track_get_key_value(track, key))
+		keyframes.append(keyframe)
+	# One method across every key is the track's, as add_track takes it. Keys calling different
+	# methods, which the editor can make and add_track cannot, keep their own.
+	if methods.size() == 1:
+		shaped["method"] = methods.keys()[0]
+		for keyframe: Dictionary in keyframes:
+			var _shared: bool = keyframe.erase("method")
+	shaped["keyframes"] = keyframes
+	return shaped
+
+
+## The state machine at a slash-separated path of nested state machine names in [param tree], or
+## null when any step of the path is not one. Every node in a tree of state machines is a state
+## machine itself, so the walk asks each step for the child by name and refuses anything else.
+static func state_machine(tree: AnimationTree, state_machine_path: String) -> AnimationNodeStateMachine:
+	if tree == null:
+		return null
+	var current: AnimationNodeStateMachine = tree.tree_root as AnimationNodeStateMachine
+	if state_machine_path == "root":
+		return current
+	for segment: String in state_machine_path.split("/", false):
+		if current == null or not current.has_node(StringName(segment)):
+			return null
+		current = current.get_node(StringName(segment)) as AnimationNodeStateMachine
+	return current
+
+
+## Why [method state_machine] found none at [param state_machine_path] in [param tree]: the step of
+## the path that failed, and what is there instead.
+static func no_machine(tree: AnimationTree, state_machine_path: String) -> String:
+	if tree == null or tree.tree_root == null:
+		return "The AnimationTree has no tree_root."
+	var current: AnimationNodeStateMachine = tree.tree_root as AnimationNodeStateMachine
+	if current == null:
+		return (
+			"The AnimationTree's tree_root is not a state machine: its type is %s."
+			% tree.tree_root.get_class()
+		)
+	var walked: PackedStringArray = []
+	for segment: String in state_machine_path.split("/", false):
+		var where: String = "the root state machine"
+		if not walked.is_empty():
+			where = "the state machine at " + "/".join(walked)
+		if not current.has_node(StringName(segment)):
+			var names: PackedStringArray = []
+			for state: StringName in current.get_node_list():
+				if state != &"Start" and state != &"End":
+					var _listed: bool = names.push_back(str(state))
+			var held: String = ", ".join(names) if not names.is_empty() else "none"
+			return (
+				"%s has no state %s. Its states are: %s."
+				% [where.to_upper()[0] + where.substr(1), segment, held]
+			)
+		var next: AnimationNode = current.get_node(StringName(segment))
+		if not next is AnimationNodeStateMachine:
+			return (
+				"The state %s in %s is not a state machine: its type is %s."
+				% [segment, where, next.get_class()]
+			)
+		current = next
+		var _walked: bool = walked.push_back(segment)
+	return "No state machine at " + state_machine_path
+
+
+## The states and transitions of the state machine at [param state_machine_path] in [param tree].
+static func states(tree: AnimationTree, state_machine_path: String) -> Dictionary:
+	var sm: AnimationNodeStateMachine = state_machine(tree, state_machine_path)
+	if sm == null:
+		return {"ok": false, "error": no_machine(tree, state_machine_path)}
+	var listed: Array[Dictionary] = []
+	for state: StringName in sm.get_node_list():
+		var node: AnimationNode = sm.get_node(state)
+		var entry: Dictionary = {"stateName": str(state), "type": node.get_class()}
+		if node is AnimationNodeAnimation:
+			var plays: AnimationNodeAnimation = node
+			entry["animationName"] = str(plays.animation)
+		listed.append(entry)
+	var transitions: Array[Dictionary] = []
+	for index: int in sm.get_transition_count():
+		var transition: AnimationNodeStateMachineTransition = sm.get_transition(index)
+		var shaped: Dictionary = {
+			"from": str(sm.get_transition_from(index)),
+			"to": str(sm.get_transition_to(index)),
+			"transitionType": SWITCH_MODE_NAMES.get(transition.switch_mode, str(transition.switch_mode)),
+		}
+		if not str(transition.advance_condition).is_empty():
+			shaped["advanceCondition"] = str(transition.advance_condition)
+		transitions.append(shaped)
+	return {"ok": true, "states": listed, "transitions": transitions}

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

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