gdharness 1.3.46 → 1.3.48

package/build/cli.js

@@ -11027,9 +11027,10 @@ function rowOf(name) {
 function rowRuns(share, row) {
   return "only" in share ? row !== null && share.only.includes(row) : row === null || !share.besides.includes(row);
 }
-function mismatchedRowsIn(printed) {
+function skippedAsDeclaredIn(printed) {
   const lines = printed.flatMap((text) => stripVTControlCharacters(text).split(/\r?\n/));
   const found = [];
+  const unrunnable = [];
   let suite = null;
   let lastCase = null;
   for (let at = 0;at < lines.length; at += 1) {
@@ -11045,7 +11046,15 @@ function mismatchedRowsIn(printed) {
       lastCase = caseLine[3] === "STARTED" ? lastCase : caseLine[2] ?? null;
       continue;
     }
-    if (suite === null || lastCase === null || !MISMATCHED_ROW.test(line)) {
+    if (suite === null || lastCase === null) {
+      continue;
+    }
+    const declared = UNRUNNABLE_CASE.exec(line)?.[1];
+    if (declared !== undefined) {
+      unrunnable.push({ suite, name: lastCase, reason: declared });
+      continue;
+    }
+    if (!MISMATCHED_ROW.test(line)) {
       continue;
     }
     const parts = [line.trim()];
@@ -11055,7 +11064,7 @@ function mismatchedRowsIn(printed) {
     }
     found.push({ suite, name: lastCase, reason: parts.join(" ").replaceAll(/\[\/?color[^\]]*\]/g, "") });
   }
-  return found;
+  return { mismatched: found, unrunnable };
 }
 function readRun(printed) {
   const lines = stripVTControlCharacters(printed).replaceAll(`\r
@@ -11189,7 +11198,7 @@ function readRun(printed) {
     leftOut,
     engineVersion,
     orphansLeft,
-    mismatched: mismatchedRowsIn(lines)
+    ...skippedAsDeclaredIn(lines)
   };
 }
 function withNestedErrors(printed, piped) {
@@ -11314,7 +11323,7 @@ function judgeEngine(printed, handed, end) {
   if (printed.executed === null || printed.executed === 0) {
     faults.push(printed.executed === null ? "the run never printed its summary" : "the run executed no test case at all, whatever it exited with");
   }
-  for (const row of printed.mismatched) {
+  for (const row of [...printed.mismatched, ...printed.unrunnable]) {
     faults.push(`${row.suite} > ${row.name} never ran: gdUnit4 skipped it, saying "${row.reason}"`);
     failing.add(row.suite);
   }
@@ -11481,7 +11490,7 @@ ${String(error.warning)}`);
   const neverPrinted = [...owed.values()].flatMap((debt) => debt.texts.map((text) => ({ suite: debt.suite, during: debt.during, text, warning: debt.warning })));
   return { printed: unexpected, neverPrinted };
 }
-var SUITE_OPENED, TIME, CASE_LINE, STATISTICS, ERROR_LINE, WARNING_LINE, EXECUTED, MISMATCHED_ROW, BANNER, LEFT_OUT, DRIVER_FALLBACK, MACHINE_WARNED, ORPHANS_REPORTED, STARVED, NESTED_ERROR = "While attempting to print an error, another error was printed:", WINDOWS_EXITS, MEMORY_EXITS, GDUNIT_FAILED = 100, GDUNIT_ORPHANS = 101, GDUNIT_EXITS, GODOT_EXITS, TAIL = 60, MOST_NAMED = 8;
+var SUITE_OPENED, TIME, CASE_LINE, STATISTICS, ERROR_LINE, WARNING_LINE, EXECUTED, MISMATCHED_ROW, UNRUNNABLE_CASE, BANNER, LEFT_OUT, DRIVER_FALLBACK, MACHINE_WARNED, ORPHANS_REPORTED, STARVED, NESTED_ERROR = "While attempting to print an error, another error was printed:", WINDOWS_EXITS, MEMORY_EXITS, GDUNIT_FAILED = 100, GDUNIT_ORPHANS = 101, GDUNIT_EXITS, GODOT_EXITS, TAIL = 60, MOST_NAMED = 8;
 var init_suite_judge = __esm(() => {
   init_engine_leaks();
   init_junit();
@@ -11493,6 +11502,7 @@ var init_suite_judge = __esm(() => {
   WARNING_LINE = /^\s*(?:SCRIPT |USER )?WARNING: (.*?)\s*$/;
   EXECUTED = /^Executed test cases\s*:\s*\((\d+)\//;
   MISMATCHED_ROW = /^\s*The test data set at index \(\d+\) does not match the expected test parameters/;
+  UNRUNNABLE_CASE = /^\s*Reason: '((?:Unknown test case argument's \[.*\] found|Fuzzer argument '.+' must be declared before the test config argument\(s\) \[.*\])\.)'\s*$/;
   BANNER = /^\s*Godot Engine v(\S+?)(?:\s+-\s+\S+)?\s*$/;
   LEFT_OUT = /^gdharness left out (res:\/\/.+?\.gd) > ([^:\s]+):(-?\d+)\s*$/;
   DRIVER_FALLBACK = /^\s*WARNING: Your video card drivers .*, switching to /;
@@ -12101,7 +12111,8 @@ class EngineSlots {
           changes = new FolderChanges(this.directory);
           continue;
         }
-        await changes.next(SLOT_LOOK_MS, SLOT_SETTLE_MS, signal);
+        const sayAt = waiting !== undefined ? said + WAIT_SAID_MS : this.say !== undefined && this.held.size === 0 ? Math.max(began + COMMAND_WAIT_SAID_MS, this.saidAt + WAIT_SAID_MS) : Number.POSITIVE_INFINITY;
+        await changes.next(Math.max(0, Math.min(SLOT_LOOK_MS, sayAt - Date.now())), SLOT_SETTLE_MS, signal);
       }
     } finally {
       changes?.close();
@@ -12159,11 +12170,17 @@ class EngineSlots {
   }
   release(lock) {
     this.held.delete(lock);
-    try {
-      if (holderOf(readFileSync8(lock, "utf8"))?.pid === this.holder.pid) {
-        removeWhole(lock);
-      }
-    } catch {}
+    giveBackSlot(lock, this.holder.pid);
+  }
+  forget(lock) {
+    this.held.delete(lock);
+  }
+  hand(lock, to) {
+    const handed = handSlot(lock, this.holder.pid, to);
+    if (handed) {
+      this.held.delete(lock);
+    }
+    return handed;
   }
   made(path) {
     let made;
@@ -12230,6 +12247,22 @@ class EngineSlots {
     this.starts.set(pid, { started, readAt: Date.now() });
   }
 }
+function handSlot(lock, from, to) {
+  let content;
+  try {
+    content = readWhole(lock);
+  } catch {
+    return false;
+  }
+  return content !== null && holderOf(content)?.pid === from && writeWhole(lock, JSON.stringify(to));
+}
+function giveBackSlot(lock, pid) {
+  try {
+    if (holderOf(readFileSync8(lock, "utf8"))?.pid === pid) {
+      removeWhole(lock);
+    }
+  } catch {}
+}
 function sayWaitsTo(say) {
   saidTo = say;
 }
@@ -12298,8 +12331,14 @@ async function slotForCall() {
     waits.said ??= (waitedMs) => slotWaitedSaid(waitedMs, slots.count, slots.directory, heldBy);
   }
   return {
+    lock,
+    from: slots.holder.pid,
     release: () => {
       slots.release(lock);
+    },
+    handTo: (holder) => slots.hand(lock, holder),
+    leave: () => {
+      slots.forget(lock);
     }
   };
 }
@@ -12838,7 +12877,7 @@ class GameLog {
       return;
     }
     const owner = this.lastHeadline[source];
-    if (owner !== null && /^\s/.test(line)) {
+    if (owner !== null && /^\s/.test(line) && !GDUNIT_CASE.test(line)) {
       owner.detail.push(line.trim());
       owner.continues = false;
       return;
@@ -12915,10 +12954,11 @@ function answersTo(entry, severity, contains) {
   const needle = contains.toLowerCase();
   return [entry.text, ...entry.detail].some((line) => line.toLowerCase().includes(needle));
 }
-var HEADLINE, CRASH, CRASH_FILLER, COLOUR_CODE, STREAMS, ADMITTED, LOCATION2, FRAME, LONGEST_CYCLE = 64;
+var HEADLINE, CRASH, GDUNIT_CASE, CRASH_FILLER, COLOUR_CODE, STREAMS, ADMITTED, LOCATION2, FRAME, LONGEST_CYCLE = 64;
 var init_game_log = __esm(() => {
   HEADLINE = /^(USER )?(SCRIPT ERROR|SHADER ERROR|ERROR|WARNING):\s?(.*)$/;
   CRASH = /^(?:CrashHandlerException|handle_crash): Program crashed with signal \d+/;
+  GDUNIT_CASE = /^\s+res:\/\/.+?\.(?:gd|cs) > .+? (?:STARTED|PASSED|FAILED|ERROR|SKIPPED|FLAKY)(?:\s|$)/;
   CRASH_FILLER = /^(?:=+|-- END OF .* BACKTRACE --|\[\d+\] .* - no debug info in .*)$/;
   COLOUR_CODE = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
   STREAMS = ["stdout", "stderr", "transcript"];
@@ -14215,7 +14255,7 @@ async function operationOutcome(engine, operation, params, projectPath) {
   let ran;
   let answer;
   try {
-    ran = await runEngine(engine.godotPath, args);
+    ran = await runEngine(engine.godotPath, args, { timeout: engine.ceiling ?? OPERATION_CEILING });
     answer = answerIn(answerFile);
   } finally {
     discard(paramsDir);
@@ -14305,7 +14345,7 @@ function answerIn(file) {
     };
   }
 }
-var AFTER_ANSWER_NOTE = "Printed after this operation had written its answer, while the engine ran the project's autoloads and shut down: Godot starts a project's autoloads in every script run and cannot be told not to. An error raised in a project script here is that autoload's own, and none of these changes the answer.", BEFORE_OPERATION_NOTE = "Printed while the engine started the project's autoloads, before this operation ran: an operation that compiles the project's scripts waits for them, because the engine knows an autoload's name only once it is in the tree. An error raised in a project script here is that autoload's own.", OWN_ERROR = "[ERROR] ", ANSWERED = "[gdharness] answered", WAITING = "[gdharness] waiting for the autoloads", BEGUN = "[gdharness] begun", ASIDE = "[gdharness] aside", RESUMED = "[gdharness] resumed", MESSAGES_KEPT = 200, ERRORS_NAMED = 3, NO_BLENDER = "Blender path is invalid or not set", BLENDER_STOPPED = "the import pass stopped at a .blend file and imported nothing: the engine imports .blend files through Blender, which the editor setting filesystem/import/blender/blender_path names, and here it names none. Set it in an editor, or set the project setting filesystem/import/blender/enabled to false with project_settings set, which has the engine leave .blend files unimported.";
+var AFTER_ANSWER_NOTE = "Printed after this operation had written its answer, while the engine ran the project's autoloads and shut down: Godot starts a project's autoloads in every script run and cannot be told not to. An error raised in a project script here is that autoload's own, and none of these changes the answer.", BEFORE_OPERATION_NOTE = "Printed while the engine started the project's autoloads, before this operation ran: an operation that compiles the project's scripts waits for them, because the engine knows an autoload's name only once it is in the tree. An error raised in a project script here is that autoload's own.", OWN_ERROR = "[ERROR] ", ANSWERED = "[gdharness] answered", WAITING = "[gdharness] waiting for the autoloads", BEGUN = "[gdharness] begun", ASIDE = "[gdharness] aside", RESUMED = "[gdharness] resumed", MESSAGES_KEPT = 200, OPERATION_CEILING, ERRORS_NAMED = 3, NO_BLENDER = "Blender path is invalid or not set", BLENDER_STOPPED = "the import pass stopped at a .blend file and imported nothing: the engine imports .blend files through Blender, which the editor setting filesystem/import/blender/blender_path names, and here it names none. Set it in an editor, or set the project setting filesystem/import/blender/enabled to false with project_settings set, which has the engine leave .blend files unimported.";
 var init_headless = __esm(() => {
   init_doc_cache();
   init_engine_leaks();
@@ -14316,6 +14356,7 @@ var init_headless = __esm(() => {
   init_reimport();
   init_scratch();
   init_script_origins();
+  OPERATION_CEILING = { ms: 600000, said: "ten minutes" };
 });
 
 // src/update-check.ts
@@ -16583,13 +16624,25 @@ var init_tool_definitions = __esm(() => {
         ],
         description: "add_track makes property and method tracks; remove_track takes any type read answers."
       },
-      nodePath: { type: "string", description: "Target node, relative to the AnimationPlayer root." },
+      nodePath: {
+        type: "string",
+        description: "Target node, relative to the AnimationPlayer's root_node, which is the player's parent unless the scene sets it."
+      },
       property: { type: "string", description: "For property tracks: the property to animate." },
       update: {
         type: "string",
         enum: ["continuous", "discrete", "capture"],
         description: "For property tracks: how the value moves between keys. continuous blends toward the next key, so a bool or an int changes halfway to it; discrete holds each key's value until the next; capture blends from the value the property holds when playing starts. Without it a new track is made as the editor makes one: as the RESET animation's track for the same property, otherwise continuous for a float, vector, colour or transform and discrete for anything else. The answer gives the track's update."
       },
+      interpolation: {
+        type: "string",
+        enum: ["nearest", "linear", "cubic", "linear_angle", "cubic_angle"],
+        description: "For property tracks: how a continuous track blends between keys. Without it a new track is made linear, or as the RESET track for the same property is, and an existing track keeps its own."
+      },
+      loopWrap: {
+        type: "boolean",
+        description: "For property tracks: whether a looping animation blends its last key into its first. Without it a new track wraps, or as the RESET track for the same property does, and an existing track keeps its own."
+      },
       method: {
         type: "string",
         description: "For method tracks: the method to call. A method track holds every method key for its node, so a key calling another method joins the node's track, with existingTrack true. The answer's methodFound says whether the target node has it; a method it lacks is still added, while a nodePath that reaches no node is refused, since it may be written next, and until it exists each call the track makes fails. A key whose args the method cannot take (too few or too many, or an object where it takes a value or the reverse) is written too, and answers argumentsFit false with misfit saying why. remove_track: only the keys calling this method."
@@ -16947,7 +17000,7 @@ var init_tool_definitions = __esm(() => {
         direction: {
           type: "string",
           enum: ["forward", "reverse"],
-          description: "forward: what this resource loads, with each reference closing a cycle marked circular and the cycle under circular_references, a script's dependencies including every script whose class_name it uses, marked by_class with the name, and the script of every autoload it names, marked by_autoload with the autoload's name. An ext_resource whose uid names another file than its path is followed to that file, as the engine loads it, with the path written under stale_path; one whose uid names no file the project has is followed by its path, as the engine does after warning, with the uid under unknown_uid; and a load or preload of a uid the project does not know is listed under that uid as missing. A shader's #include is followed as the preprocessor reads it, relative to the shader. A file the depth stops at carries beyond_depth, how many files it names that were not walked. A file's dependencies are listed at its first entry, and again further down only where the depth cut that list short and more is left; every other entry for a file naming any carries dependencies_listed_above. summary.total_resources is the file asked about, so 1; total_dependencies counts each file reached, directly or through another, once however many places load it; total_references counts the entries in the tree, and missing names every file referenced that does not exist, with the files referring to it. reverse: every file that refers to it and how, for a file that is gone as well while anything still refers to it, answered with exists: false (a missing file nothing refers to is refused, naming the nearest files), a scene instancing it, a script extending, preloading or loading it, and for a script with a class_name every use of that name, and for an autoload's script every use of the autoload's name, with autoload naming it. Each reference carries a kind: ext_resource, extends, preload, load, include or path for a reference by path, with stale_path when an ext_resource reaches it by its uid under another path, and unknown_uid when one names it by path beside a uid naming no file; setting, plugin, export_preset and import for one in project.godot, a plugin.cfg, export_presets.cfg or an import sidecar; class_name for a use of the declared name, the declaration itself being the script asked about; autoload for code naming the autoload. Three kinds are not uses: doc is a name inside a ## documentation comment, which renaming would break in the generated docs; comment is one in ordinary prose, which it would only make stale; and stale_path is an ext_resource naming it by a path the engine does not load, since its uid leads to the file under loads. summary.in_code is the count with those left out, which is the number to read when the question is whether anything still uses this. Default forward."
+          description: "forward: what this resource loads or names. Each file named by its path carries kind, as reverse words it: ext_resource, extends, preload, load, include, or path for a path only written in a string, which the file itself may never load. Each reference closing a cycle is marked circular, with the cycle under circular_references. A script's dependencies include every script whose class_name it uses, marked by_class with the name, and the script of every autoload it names, marked by_autoload with the autoload's name. An ext_resource whose uid names another file than its path is followed to that file, as the engine loads it, with the path written under stale_path; one whose uid names no file the project has is followed by its path, as the engine does after warning, with the uid under unknown_uid; and a load or preload of a uid the project does not know is listed under that uid as missing. A shader's #include is followed as the preprocessor reads it, relative to the shader. A file the depth stops at carries beyond_depth, how many files it names that were not walked. A file's dependencies are listed at its first entry, and again further down only where the depth cut that list short and more is left; every other entry for a file naming any carries dependencies_listed_above. summary.total_resources is the file asked about, so 1; total_dependencies counts each file reached, directly or through another, once however many places load it; total_references counts the entries in the tree, and missing names every file referenced that does not exist, with the files referring to it. reverse: every file that refers to it and how, for a file that is gone as well while anything still refers to it, answered with exists: false (a missing file nothing refers to is refused, naming the nearest files), a scene instancing it, a script extending, preloading or loading it, and for a script with a class_name every use of that name, and for an autoload's script every use of the autoload's name, with autoload naming it. Each reference carries a kind: ext_resource, extends, preload, load, include or path for a reference by path, with stale_path when an ext_resource reaches it by its uid under another path, and unknown_uid when one names it by path beside a uid naming no file; setting, plugin, export_preset and import for one in project.godot, a plugin.cfg, export_presets.cfg or an import sidecar; class_name for a use of the declared name, the declaration itself being the script asked about; autoload for code naming the autoload. Three kinds are not uses: doc is a name inside a ## documentation comment, which renaming would break in the generated docs; comment is one in ordinary prose, which it would only make stale; and stale_path is an ext_resource naming it by a path the engine does not load, since its uid leads to the file under loads. summary.in_code is the count with those left out, which is the number to read when the question is whether anything still uses this. Default forward."
         },
         depth: {
           type: "integer",
@@ -16982,7 +17035,7 @@ var init_tool_definitions = __esm(() => {
         options: {
           type: "object",
           ops: ["set_options"],
-          description: `set_options: import options keyed as the .import file spells them, {"compress/mode": 1}. A dictionary option whose keys are numbers, a font's opentype_features or any option already holding number keys, takes them written as strings of digits, and opentype_features also takes an OpenType tag by its four-letter name: {"opentype_features": {"liga": 0}} turns ligatures off. Both are written as the numbers the engine reads. One already holding the value given is answered under unchanged_options rather than updated_options, and when none changed nothing is written or reimported. changed gives each option written as {was, now}, was null for one the import file did not hold.`,
+          description: `set_options: import options keyed as the .import file spells them, {"compress/mode": 1}. A dictionary option whose keys are numbers, a font's opentype_features or any option already holding number keys, takes them written as strings of digits, and opentype_features also takes an OpenType tag by its four-letter name: {"opentype_features": {"liga": 0}} turns ligatures off. Both are written as the numbers the engine reads. One already holding the value given is answered under unchanged_options rather than updated_options, and when none changed nothing is written or reimported. changed gives each option written as {was, now}.`,
           additionalProperties: true
         },
         reimport: {
@@ -17022,7 +17075,7 @@ var init_tool_definitions = __esm(() => {
         },
         uid: {
           effect: "read",
-          summary: "the UID of one file and where it was read: a script's or shader's .uid file, an imported file's .import, or a scene's or resource's own header",
+          summary: "the UID of one file and where it was read: a script's or shader's .uid file, an imported file's .import, or a scene's or resource's own header. A file with none is answered with uid null and what would give it one",
           requires: ["resourcePath"]
         },
         refresh_uids: {
@@ -17069,7 +17122,7 @@ var init_tool_definitions = __esm(() => {
           type: "string",
           ops: ["set_preset"],
           enum: ["all_resources", "scenes", "resources", "exclude"],
-          description: "set_preset: what the preset exports: every resource, the scenes listed in files and what they use, the resources listed, or every resource but those listed."
+          description: "set_preset: what the preset exports: every resource, the scenes listed in files and what they use, the resources listed, or every resource but those listed. What a scene or a resource uses is what the engine counts as its dependencies, so a file named only in a string, such as a scene path held in an exported property, or a script reached only by its class_name, is left out of the export, though project_dependencies lists both."
         },
         files: {
           type: "array",
@@ -17130,7 +17183,7 @@ var init_tool_definitions = __esm(() => {
         path: {
           type: ["string", "array"],
           items: { type: "string" },
-          description: 'A test directory or suite file inside the project, or a list of them, all run on one engine: a named set of suites boots once rather than once per suite. An entry given twice, or a suite inside a directory also listed, runs once. An entry "suite.gd:test_name" runs that case alone, as gdharness test reads it and as tests runs it, so it cannot share the list with a whole suite or a directory. An entry that is not there is left out and named under missing, the rest run, and such a run is never called passed; when no entry is there the run is refused before the engine starts, naming each one. A script named that declares no test_ function at the top level is refused the same way, and so is a directory holding no suite. A script that declares test_ functions and does not extend GdUnitTestSuite, which gdUnit4 never runs and never mentions, is refused when named, and under a directory run whole it is named under notSuites and the run is not called passed. A case declared there that gdUnit4 never ran, in a suite that passed, comes back under testsNotRun, and a row it skipped for data that does not fit the case under rowsMismatched with the reason gdUnit4 gave; neither run is called passed. Default tests and test, those the project has, which is where gdharness test looks.'
+          description: 'A test directory or suite file inside the project, or a list of them, all run on one engine: a named set of suites boots once rather than once per suite. An entry given twice, or a suite inside a directory also listed, runs once. An entry "suite.gd:test_name" runs that case alone, as gdharness test reads it and as tests runs it, so it cannot share the list with a whole suite or a directory. An entry that is not there is left out and named under missing, the rest run, and such a run is never called passed; when no entry is there the run is refused before the engine starts, naming each one. A script named that declares no test_ function at the top level is refused the same way, and so is a directory holding no suite. A script that declares test_ functions and does not extend GdUnitTestSuite, which gdUnit4 never runs and never mentions, is refused when named, and under a directory run whole it is named under notSuites and the run is not called passed. A case declared there that gdUnit4 never ran, in a suite that passed, comes back under testsNotRun, a row it skipped for data that does not fit the case under rowsMismatched, and a case it skipped because it cannot run it as declared (a parameter nothing fills, or a fuzzer after a setting) under casesUnrunnable, each with the reason gdUnit4 gave; none of those runs is called passed. Default tests and test, those the project has, which is where gdharness test looks.'
         },
         ignore: {
           type: "array",
@@ -17204,7 +17257,7 @@ var init_tool_definitions = __esm(() => {
       name: "scene_tree",
       title: "Scene tree",
       effect: "read",
-      description: "The nodes of a scene file: names, classes and hierarchy, with properties when asked. A node that instances another scene names that file under instanceOf, and the nodes listed under it come from that file rather than this one; its editableChildren says whether this scene, or a scene it inherits, keeps values of its own for them (scene_node set editableChildren). The root of a scene inheriting another names the scene it inherits under inherits, and every node that scene or one further down makes names its file under inheritedFrom; this file holds only the values it changes on them. A node in any group answers groups, sorted, from this file and every scene it comes from. Needs 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 making its nodes, so no script of theirs runs (autoloads still start once it has answered, as in every headless call). For the nodes of a game that is running, runtime_inspect tree.",
+      description: "The nodes of a scene file: names, classes and hierarchy, with properties when asked. type is the engine class, and a node whose script declares a class_name names it under scriptClass, as scene_node get does. A node that instances another scene names that file under instanceOf, and the nodes listed under it come from that file rather than this one; its editableChildren says whether this scene, or a scene it inherits, keeps values of its own for them (scene_node set editableChildren). The root of a scene inheriting another names the scene it inherits under inherits, and every node that scene or one further down makes names its file under inheritedFrom; this file holds only the values it changes on them. A node in any group answers groups, sorted, from this file and every scene it comes from. Needs 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 making its nodes, so no script of theirs runs (autoloads still start once it has answered, as in every headless call). For the nodes of a game that is running, runtime_inspect tree.",
       parameters: {
         projectPath: PROJECT_PATH,
         scenePath: SCENE_PATH,
@@ -18215,7 +18268,11 @@ var init_tool_definitions = __esm(() => {
       },
       requires: [],
       operations: {
-        tree: { effect: "read", summary: "the live scene tree", requires: [] },
+        tree: {
+          effect: "read",
+          summary: "the live scene tree, with current_scene giving the path of the scene the game is showing and the file it was loaded from, or null when it shows none",
+          requires: []
+        },
         text: {
           effect: "read",
           summary: "every line of text under nodePath, the values in its fields included, in reading order, leaving out what is hidden and everything under it, and a control drawn wholly outside the viewport or scrolled out of a ScrollContainer, which the player cannot read. Every line reads as drawn: rich text without tags, text only as far as it is typed out, a translation rather than its key, an upper-case label in capitals and a secret field as its mask. Tab titles, menu bar titles, list items, a tree's column titles and rows, and an open menu's items and the titles of its separators read a line each. A line drawn as a copy under a node saying the same words, as an outline or a glow is, reads once, counted under copies",
@@ -18620,12 +18677,12 @@ var init_tool_definitions = __esm(() => {
         says: {
           type: "string",
           ops: ["until"],
-          description: 'until: wait for these words to appear anywhere under nodePath, or anywhere in the game when no nodePath is given, instead of for a property, which is how a panel that rebuilds its labels is waited on at all: the labels are named afresh each redraw and the panel is what stays put. Matched the way runtime_inspect find matches says: case-insensitive, a plain word anywhere in the text, a pattern with * or ? a glob over the whole of it, and alternatives separated by | met by whichever appears first ("*won*|*lost*"); on a node the player can see unless includeHidden says otherwise; a label with a line break is matched with the break in the words, and a backslash followed by n counts as one. Instead of, not as well as: a call carrying this and a property is refused, because they ask about different things and answering one of them silently is how a caller watches a screen believing they are watching a property. It looks every frame while a look is cheap and less often on a screen large enough for a look to cost a real share of a frame, so the game keeps its speed; the answer counts the frames the wait spanned and the looks it took, and says under looking_ms how long the looks took between them.'
+          description: 'until: wait for these words to appear anywhere under nodePath, or anywhere in the game when no nodePath is given, instead of for a property, which is how a panel that rebuilds its labels is waited on at all: the labels are named afresh each redraw and the panel is what stays put. Matched the way runtime_inspect find matches says: case-insensitive, a plain word anywhere in the text, a pattern with * or ? a glob over the whole of it, and alternatives separated by | met by whichever appears first ("*won*|*lost*"); on a node the player can see unless includeHidden says otherwise; a label with a line break is matched with the break in the words, and a backslash followed by n counts as one. Instead of, not as well as: a call carrying this and a property is refused, because they ask about different things and answering one of them silently is how a caller watches a screen believing they are watching a property. It looks every frame while a look is cheap and less often on a screen large enough for a look to cost a real share of a frame, so the game keeps its speed; the answer counts the frames the wait spanned and the looks it took, and says under looking_ms how long the looks took between them. A look on a large screen is read about 2ms to a frame, so no frame grows by more, except the last look as the time runs out, which is read whole; longest_hold_ms is the longest the looks held one frame, which tells a long frame the game logs apart from one the wait caused.'
         },
         includeHidden: {
           type: "boolean",
           ops: ["until"],
-          description: "until, with says: count words on a hidden node too, and on one drawn outside the viewport or scrolled out of a ScrollContainer. Default false, since a wait for words is a wait for them to be shown, and a wait that runs out while such a node holds them says so under unseen_note: a button that exists hidden through a whole animation carries its words the whole time and satisfied the wait at once, and every wait on that screen fell back to counting frames."
+          description: "until, with says: count words on a hidden node too, and on one drawn outside the viewport or scrolled out of a ScrollContainer. Default false, since a wait for words is a wait for them to be shown, and a wait that runs out while such a node holds them says so under unseen_note: a button that exists hidden through a whole animation carries its words the whole time and satisfied the wait at once, and every wait on that screen fell back to counting frames. What is drawn over a node is not looked at, so words under a dialog or a panel count either way."
         },
         timeoutMs: {
           type: "integer",
@@ -18701,7 +18758,7 @@ var init_tool_definitions = __esm(() => {
         },
         step_out: {
           effect: "additive",
-          summary: "run to the end of the current function and stop at the next line run at its caller's depth: in its caller, or, when the call was the last thing its caller did, wherever script runs next, such as the caller's next call; a game this server started only",
+          summary: "run to the end of the current function and stop at the next line run at its caller's depth: in its caller, or, when the call was the last thing its caller did, wherever script runs next, such as the caller's next call; only for a game this server started",
           requires: []
         }
       }
@@ -18719,7 +18776,7 @@ var init_tool_definitions = __esm(() => {
         expression: {
           type: "string",
           ops: ["evaluate"],
-          description: "evaluate: a GDScript expression, as Godot's Expression class parses it: members of self by name, locals, autoloads and global classes, operators, indexing and calls, such as wave.spawned[0] or Ledger.entries.size(). An expression that does not parse, or fails as it runs, comes to null, and the game prints why as an error, which editor_output reads for a game this server started. The game reports what an expression raises while it is held inside a runtime_invoke call as raised by that call, and the call's answer says so under errorsNote."
+          description: "evaluate: a GDScript expression, as Godot's Expression class parses it: members of self by name, locals, autoloads and global classes, operators, indexing and calls, such as wave.spawned[0] or Ledger.entries.size(). An expression that does not parse, or fails as it runs, comes to null with failed saying why, as the engine words it, and a null with no failed is the value; for a game the editor plays, the reason reaches only the editor's Debugger panel, so a null there carries a note saying it may be either. The game reports what an expression raises while it is held inside a runtime_invoke call as raised by that call, and the call's answer says so under errorsNote."
         }
       },
       requires: [],
@@ -42552,6 +42609,7 @@ async function handleDAPTool(client, toolName, args) {
         const frameId = typeof safeArgs.frameId === "number" ? safeArgs.frameId : undefined;
         const expression = typeof safeArgs.expression === "string" ? safeArgs.expression : "";
         const evaluated = await client.evaluate(expression, frameId);
+        const nil = evaluated.type === "Nil" || evaluated.value === "null" || evaluated.value === "<null>";
         return {
           content: [
             {
@@ -42560,7 +42618,10 @@ async function handleDAPTool(client, toolName, args) {
                 frame: evaluated.frame,
                 expression,
                 value: evaluated.value,
-                ...evaluated.type === undefined ? {} : { type: evaluated.type }
+                ...evaluated.type === undefined ? {} : { type: evaluated.type },
+                ...nil ? {
+                  note: "null is also what an expression comes to when it does not parse or fails as it runs. For a game the editor plays, why reaches only the editor's Debugger panel, so this cannot say which it was."
+                } : {}
               })
             }
           ]
@@ -49508,6 +49569,13 @@ function restartsOf(run) {
     endedAt: new Date(one.endedAt).toISOString()
   }));
 }
+async function handToTheGame(slot, pid, projectPath) {
+  const started = (await startTimesOf([pid])).get(pid);
+  const by = `a game${projectPath === null ? "" : ` of ${projectPath}`} the editor played for editor_run`;
+  if (started === undefined || !slot.handTo({ pid, started, by })) {
+    slot.release();
+  }
+}
 function followTheRestart(run) {
   if (run.throughEditor || run.pid === null || run.projectPath === null) {
     return false;
@@ -50034,6 +50102,13 @@ function presetsIn(projectPath) {
 function presetPlatform(projectPath, preset) {
   return presetsIn(projectPath)?.find((held) => held.name === preset)?.platform ?? null;
 }
+function engineEndSaid(ending) {
+  if (ending.failure === null && ending.exitSignal === null) {
+    return `the engine ended with ${exitCodeText(ending.exitCode)}`;
+  }
+  const how = howItEnded(ending);
+  return how.startsWith("ended by") ? `the engine was ${how}` : how;
+}
 function exportPresetRefusal(projectPath, preset) {
   const presets = presetsIn(projectPath);
   if (presets === null) {
@@ -50068,7 +50143,24 @@ function exportAnswer(ending, asked, before, after, beside = [], docCacheNote =
   if (verdict.exported) {
     return { content: [{ type: "text", text: answerJson(verdict) }] };
   }
-  const stale = !written && after !== null ? ` The ${asked.outputPath} there is from before this export, which did not write it.` : "";
+  if (written) {
+    const errors = log.count("error");
+    const because = [
+      ...ending.exitCode === 0 && ending.failure === null && ending.exitSignal === null ? [] : [engineEndSaid(ending)],
+      ...errors === 0 ? [] : [`it printed ${String(errors)} ${errors === 1 ? "error" : "errors"}, under entries`]
+    ];
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Export with preset '${asked.preset}' wrote ${asked.outputPath}, but it is not counted as exported, as ${because.join(" and ")}.`
+        },
+        { type: "text", text: answerJson(verdict) }
+      ],
+      isError: true
+    };
+  }
+  const stale = after === null ? "" : ` The ${asked.outputPath} there is from before this export, which did not write it.`;
   const why = ending.exitSignal === null ? stale : ` The engine was ${howItEnded(ending)}, so it has no exit code.${stale}`;
   return {
     content: [
@@ -50823,6 +50915,17 @@ function ownArguments(params) {
 function needsItsOwnProcess(asked) {
   return asked.savesIn !== undefined || asked.env !== undefined;
 }
+function unheldNote(changed) {
+  if (!isPlainObject3(changed)) {
+    return "";
+  }
+  const unheld = Object.entries(changed).filter(([, change]) => isPlainObject3(change) && change["was"] === null).map(([name]) => name);
+  if (unheld.length === 0) {
+    return "";
+  }
+  const one = unheld.length === 1;
+  return ` ${unheld.join(", ")} ${one ? "was" : "were"} not in the import file before, so only that reimport can tell whether the importer has ${one ? "it" : "them"}: one it lacks is dropped from the file then, and the reimport through set_options says which.`;
+}
 
 class GodotServer {
   stdio = null;
@@ -52454,7 +52557,7 @@ class GodotServer {
         ...written,
         payload: {
           ...written.payload,
-          note: "Not reimported: the editor imports it with these options on its next scan, or project_import reimport does now."
+          note: `Not reimported: the editor imports it with these options on its next scan, or project_import reimport does now.${unheldNote(written.payload["changed"])}`
         }
       } : written);
     }
@@ -53509,10 +53612,14 @@ ${error.text}`;
       test: `${row.suite} > ${row.name}`,
       reason: row.reason
     }));
+    const casesUnrunnable = casePrinted.unrunnable.map((one) => ({
+      test: `${one.suite} > ${one.name}`,
+      reason: one.reason
+    }));
     return this.jsonTextResponse({
-      passed: !timedOut && exitCode === 0 && nothingRan === null && report.tests > 0 && report.failures === 0 && report.errors === 0 && hookFailures.length === 0 && uncaught.length === 0 && undeclaredPrinted.length === 0 && declaredNotPrinted.length === 0 && countedLeaks.length === 0 && missing.length === 0 && testsNotRun.length === 0 && casesNotRun.length === 0 && rowsMismatched.length === 0 && notSuites.length === 0,
+      passed: !timedOut && exitCode === 0 && nothingRan === null && report.tests > 0 && report.failures === 0 && report.errors === 0 && hookFailures.length === 0 && uncaught.length === 0 && undeclaredPrinted.length === 0 && declaredNotPrinted.length === 0 && countedLeaks.length === 0 && missing.length === 0 && testsNotRun.length === 0 && casesNotRun.length === 0 && rowsMismatched.length === 0 && casesUnrunnable.length === 0 && notSuites.length === 0,
       verdict: [
-        verdict === "passed" && undeclaredPrinted.length + declaredNotPrinted.length + countedLeaks.length + testsNotRun.length + casesNotRun.length + rowsMismatched.length + notSuites.length > 0 ? undefined : verdict,
+        verdict === "passed" && undeclaredPrinted.length + declaredNotPrinted.length + countedLeaks.length + testsNotRun.length + casesNotRun.length + rowsMismatched.length + casesUnrunnable.length + notSuites.length > 0 ? undefined : verdict,
         ...[false, true].map((warning) => {
           const count = undeclaredPrinted.filter((error) => error.warning === warning).length;
           const word = warning ? "warning" : "error";
@@ -53526,12 +53633,14 @@ ${error.text}`;
         countedLeaks.length > 0 ? "the engine exited holding what it should have freed" : undefined,
         testsNotRun.length + casesNotRun.length > 0 ? `not run: ${[...testsNotRun, ...casesNotRun].join(", ")}` : undefined,
         rowsMismatched.length > 0 ? `${rowsMismatched.length === 1 ? "one row" : `${String(rowsMismatched.length)} rows`} skipped for data that does not fit the case` : undefined,
+        casesUnrunnable.length > 0 ? `${casesUnrunnable.length === 1 ? "one case" : `${String(casesUnrunnable.length)} cases`} skipped as gdUnit4 cannot run ${casesUnrunnable.length === 1 ? "it" : "them"} as declared` : undefined,
         notSuites.length > 0 ? `${notSuites.length === 1 ? "one script declares" : `${String(notSuites.length)} scripts declare`} cases gdUnit4 never runs` : undefined
       ].filter((part) => part !== undefined).join("; "),
       ...missing.length > 0 ? { missing } : {},
       ...notSuites.length > 0 ? { notSuites } : {},
       ...testsNotRun.length + casesNotRun.length > 0 ? { testsNotRun: [...testsNotRun, ...casesNotRun] } : {},
       ...rowsMismatched.length > 0 ? { rowsMismatched } : {},
+      ...casesUnrunnable.length > 0 ? { casesUnrunnable } : {},
       ...timedOut ? { timedOut, hung, silentForMs } : {},
       exitCode,
       exitSignal: run.exitSignal ?? undefined,
@@ -53565,6 +53674,7 @@ ${error.text}`;
         testsNotRun.length > 0 ? `${testsNotRun.join(", ")} ${testsNotRun.length === 1 ? "was" : "were"} asked for and not run, so the run is not called passed: gdUnit4 runs a test_ function only in a script that extends GdUnitTestSuite, and leaves out a suite whose script does not load.` : undefined,
         casesNotRun.length > 0 ? `${casesNotRun.join(", ")} ${casesNotRun.length === 1 ? "is a case" : "are cases"} of a suite that ran and passed, and gdUnit4 never ran ${casesNotRun.length === 1 ? "it" : "them"} and said nothing of it, so the run is not called passed, as gdharness test judges it.` : undefined,
         rowsMismatched.length > 0 ? `gdUnit4 skipped what rowsMismatched names because the row's data does not fit the case's parameters, though it printed ${rowsMismatched.length === 1 ? "the row" : "each row"} passed first; each entry carries gdUnit4's reason. The run is not called passed, as gdharness test judges it.` : undefined,
+        casesUnrunnable.length > 0 ? `gdUnit4 skipped what casesUnrunnable names because it cannot run ${casesUnrunnable.length === 1 ? "that case" : "those cases"} as declared, though it printed ${casesUnrunnable.length === 1 ? "it" : "each"} passed first; each entry carries gdUnit4's reason. A parameter is filled only by _test_parameters, a fuzzer or a setting gdUnit4 names (timeout, do_skip, skip_reason, fuzzer_iterations, fuzzer_seed), and fuzzers come before the settings. The run is not called passed, as gdharness test judges it.` : undefined,
         notSuites.length > 0 ? "What notSuites names declares cases gdUnit4 never runs, so the run is not called passed, as gdharness test judges it." : undefined,
         briefed > 0 ? `${briefed} of the ${failed.length} failing cases, those with the largest reports, are named with their first message only, since their reports would have made the answer too large to deliver; pass one case's suite path to see its reports.` : undefined,
         notApplied.length > 0 ? "An ignore entry named a case that ran all the same: gdUnit4 leaves a case out only as suite_name:test_name, and reads an entry with no colon as a suite name or a piece of a suite path. ignoreNotApplied gives the form for each case that ran." : undefined,
@@ -55114,17 +55224,20 @@ ${error.text}`;
     const sendingFrom = Date.now();
     const breakpoints = await this.dapHoldingBreakpointsOf(projectPath).reapplyBreakpoints();
     this.logDebug(`Breakpoints were sent again after ${Date.now() - sendingFrom}ms`);
+    const slot = await slotForCall();
     if (profiled) {
       const armed = await this.handleViaBridge("profile_start", {
         arm: true,
         frameFunctions: profileFrameFunctions(projectPath)
       });
       if (armed.isError === true) {
+        slot.release();
         return armed;
       }
     }
     const answer = await this.handleViaBridge("play_scene", scene === null ? {} : { scenePath: `res://${scene}` });
     if (answer.isError === true) {
+      slot.release();
       return answer;
     }
     const startedAt = Date.now();
@@ -55154,7 +55267,8 @@ ${error.text}`;
       announcedBefore: alreadyPlaying,
       seenPlaying: readBoolean(playAnswer, "playing") === true,
       ...which === null ? {} : { play: which },
-      bootScene: runtimeWaitMs.scene
+      bootScene: runtimeWaitMs.scene,
+      slot
     };
     this.activeProcess = played;
     this.noteTheLatestRun({ projectPath, pid: null, startedAt });
@@ -55170,6 +55284,11 @@ ${error.text}`;
     sweepTranscripts();
     step("sweep");
     this.logDebug(`After the play: ${steps.join(", ")}`);
+    const runtime = await this.runtimeUp(projectPath, alreadyPlaying, runtimeWaitMs, false);
+    if (played.slot !== undefined) {
+      played.slot.release();
+      delete played.slot;
+    }
     return this.jsonTextResponse({
       started: true,
       through: "editor",
@@ -55186,7 +55305,7 @@ ${error.text}`;
         scriptPath: projectSpelling(projectPath, one.scriptPath),
         reason: one.reason
       })),
-      runtime: await this.runtimeUp(projectPath, alreadyPlaying, runtimeWaitMs, false),
+      runtime,
       message: "The editor is playing it, so its debugger holds it: the debug_* tools can reach it, " + "editor_output reads its console through the debug adapter and the runtime's report of it, and editor_run stop ends it." + endedToStartThis(ended)
     });
   }
@@ -55567,20 +55686,33 @@ ${error.text}`;
     closeSync5(transcript.fd);
     const gameEnv = profiled ? { ...env ?? process.env, [PROFILE_FROM_START]: "1" } : env;
     const profile = profiled ? profilePath(startedAt) : undefined;
-    const launched = await launchOutsideTheTree({
-      command: godotPath,
-      args: cmdArgs,
-      ...gameEnv === undefined ? {} : { env: gameEnv },
-      run: {
-        transcript: transcript.path,
-        startedAt,
-        projectPath,
-        ...this.servedBy(),
-        ...profile === undefined ? {} : { profile },
-        ...debugged ? { breakpoints: this.breakpointsForAGame(projectPath) } : { debugged: false }
-      },
-      ...desktop === undefined ? {} : { desktop }
-    });
+    const slot = await slotForCall();
+    let launched;
+    try {
+      launched = await launchOutsideTheTree({
+        command: godotPath,
+        args: cmdArgs,
+        ...gameEnv === undefined ? {} : { env: gameEnv },
+        run: {
+          transcript: transcript.path,
+          startedAt,
+          projectPath,
+          ...this.servedBy(),
+          ...profile === undefined ? {} : { profile },
+          ...debugged ? { breakpoints: this.breakpointsForAGame(projectPath) } : { debugged: false },
+          slot: { lock: slot.lock, from: slot.from, by: `a game of ${projectPath} editor_run started` }
+        },
+        ...desktop === undefined ? {} : { desktop }
+      });
+    } catch (error) {
+      slot.release();
+      throw error;
+    }
+    if ("error" in launched) {
+      slot.release();
+    } else {
+      slot.leave();
+    }
     if ("error" in launched) {
       return launched;
     }
@@ -55802,6 +55934,11 @@ ${error.text}`;
   tie(run, endpoint) {
     run.announcedPid = endpoint.pid;
     this.noteBootOf(run, endpoint);
+    const slot = run.slot;
+    if (slot !== undefined) {
+      delete run.slot;
+      handToTheGame(slot, endpoint.pid, run.projectPath);
+    }
   }
   playedByOurEditor(endpoint) {
     const editor = this.godotBridge.getStatus().editorPid;

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

@@ -16,6 +16,22 @@ const UPDATE_MODE_NAMES: Dictionary[int, String] = {
 	Animation.UPDATE_DISCRETE: "discrete",
 	Animation.UPDATE_CAPTURE: "capture",
 }
+const INTERPOLATION_NAMES: Dictionary[int, String] = {
+	Animation.INTERPOLATION_NEAREST: "nearest",
+	Animation.INTERPOLATION_LINEAR: "linear",
+	Animation.INTERPOLATION_CUBIC: "cubic",
+	Animation.INTERPOLATION_LINEAR_ANGLE: "linear_angle",
+	Animation.INTERPOLATION_CUBIC_ANGLE: "cubic_angle",
+}
+## The track types whose keys are blended between, so how they are and whether a looping animation
+## blends its last key into its first say how the track moves.
+const INTERPOLATED_TYPES: Array[int] = [
+	Animation.TYPE_VALUE,
+	Animation.TYPE_POSITION_3D,
+	Animation.TYPE_ROTATION_3D,
+	Animation.TYPE_SCALE_3D,
+	Animation.TYPE_BLEND_SHAPE,
+]
 const TRACK_TYPE_NAMES: Dictionary[int, String] = {
 	Animation.TYPE_VALUE: "property",
 	Animation.TYPE_POSITION_3D: "position_3d",
@@ -174,6 +190,10 @@ static func _track(anim: Animation, track: int, values: GdhSerialisation) -> Dic
 	if kind == Animation.TYPE_VALUE:
 		var mode: int = anim.value_track_get_update_mode(track)
 		shaped["update"] = UPDATE_MODE_NAMES.get(mode, str(mode))
+	if kind in INTERPOLATED_TYPES:
+		var interpolation: int = anim.track_get_interpolation_type(track)
+		shaped["interpolation"] = INTERPOLATION_NAMES.get(interpolation, str(interpolation))
+		shaped["loopWrap"] = anim.track_get_interpolation_loop_wrap(track)
 	var keyframes: Array[Dictionary] = []
 	var methods: Dictionary = {}
 	for key: int in anim.track_get_key_count(track):

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

@@ -356,6 +356,12 @@ static func _entry(
 	var data: Dictionary = {
 		"name": node["name"], "type": node["type"], "path": path, "children": children,
 	}
+	var given_values: Dictionary = node["properties"]
+	var attached: Variant = given_values.get("script")
+	if attached is Script:
+		var script: Script = attached
+		if not str(script.get_global_name()).is_empty():
+			data["scriptClass"] = str(script.get_global_name())
 	# The root's file is the scene being read, so only another node's names a second scene.
 	if path != "." and node.has("instanceOf"):
 		data["instanceOf"] = node["instanceOf"]