gdharness 1.3.47 → 1.3.48

package/build/cli.js

@@ -12111,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();
@@ -12169,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;
@@ -12240,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;
 }
@@ -12308,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);
     }
   };
 }
@@ -12848,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;
@@ -12925,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"];
@@ -14225,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);
@@ -14315,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();
@@ -14326,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
@@ -16593,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."
@@ -16957,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",
@@ -16992,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: {
@@ -17032,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: {
@@ -17079,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",
@@ -17214,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,
@@ -18225,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",
@@ -18635,7 +18682,7 @@ var init_tool_definitions = __esm(() => {
         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",
@@ -18711,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: []
         }
       }
@@ -18729,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: [],
@@ -42562,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: [
             {
@@ -42570,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."
+                } : {}
               })
             }
           ]
@@ -49518,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;
@@ -50044,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) {
@@ -50078,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: [
@@ -50833,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;
@@ -52464,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);
     }
@@ -55131,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();
@@ -55171,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 });
@@ -55187,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",
@@ -55203,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)
     });
   }
@@ -55584,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;
     }
@@ -55819,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"]

package/build/godot/addons/gdharness_editor/tools/animation_tracks.gd

@@ -109,6 +109,9 @@ func add_animation_track(args: Dictionary) -> Dictionary:
 	if anim.track_get_type(track_idx) == Animation.TYPE_VALUE:
 		var mode: int = anim.value_track_get_update_mode(track_idx)
 		answer["update"] = GdhAnimationReads.UPDATE_MODE_NAMES.get(mode, str(mode))
+		var blended: int = anim.track_get_interpolation_type(track_idx)
+		answer["interpolation"] = GdhAnimationReads.INTERPOLATION_NAMES.get(blended, str(blended))
+		answer["loopWrap"] = anim.track_get_interpolation_loop_wrap(track_idx)
 	if built[3]:
 		answer["existingTrack"] = true
 	var replaced: Array = built[5]
@@ -165,6 +168,7 @@ func _add_track(
 	var kind: Animation.TrackType = Animation.TYPE_VALUE
 	var path: NodePath = NodePath(target_path)
 	var update: int = -1
+	var interpolation: int = -1
 	if track_type == "property":
 		var prop_name: String = str(track.get("property", ""))
 		if prop_name.is_empty():
@@ -175,6 +179,11 @@ func _add_track(
 		)
 		if named != null:
 			update = GdhRead.as_int(named)
+		var blended: Variant = GdhAnimationReads.INTERPOLATION_NAMES.find_key(
+			str(track.get("interpolation", ""))
+		)
+		if blended != null:
+			interpolation = GdhRead.as_int(blended)
 		var values: Array = _key_values(target, prop_name, keyframes)
 		if not values[0]:
 			return _not_added(str(values[1]))
@@ -196,6 +205,12 @@ func _add_track(
 				misfit = _key_misfit(target, method_name, arguments, index)
 		method_found = target.has_method(method_name)
 		kind = Animation.TYPE_METHOD
+		# A method key is called at its time and never blended, so neither has anything to set.
+		for blending: String in ["interpolation", "loopWrap"]:
+			if track.has(blending):
+				return _not_added(
+					"track.%s is for property tracks; a method key is not blended." % blending
+				)
 	else:
 		return _not_added(
 			(
@@ -250,6 +265,10 @@ func _add_track(
 			_as_the_editor_makes(anim, track_idx, player, target)
 	if update >= 0:
 		anim.value_track_set_update_mode(track_idx, update as Animation.UpdateMode)
+	if interpolation >= 0:
+		anim.track_set_interpolation_type(track_idx, interpolation as Animation.InterpolationType)
+	if track.has("loopWrap"):
+		anim.track_set_interpolation_loop_wrap(track_idx, GdhRead.as_bool(track["loopWrap"]))
 	for index: int in keyframes.size():
 		var keyframe: Dictionary = keyframes[index]
 		if anim.track_insert_key(track_idx, GdhRead.as_float(keyframe["time"]), keys[index]) < 0:

package/build/godot/addons/gdharness_runtime/runtime_hover.gd

@@ -160,7 +160,7 @@ func _hover(viewport: Viewport, point: Vector2) -> void:
 	var inside: Vector2 = container.get_global_transform_with_canvas().affine_inverse() * point
 	if container.stretch:
 		inside /= container.stretch_shrink
-	for child: Node in container.get_children():
+	for child: Node in container.get_children(true):
 		var shown: SubViewport = child as SubViewport
 		if shown != null and not shown.gui_disable_input:
 			_hover(shown, shown.get_final_transform().affine_inverse() * inside)
@@ -179,7 +179,7 @@ func _drop(viewport: Viewport, until: int) -> void:
 	var over: Control = instance_from_id(top) as Control
 	var container: SubViewportContainer = over as SubViewportContainer
 	if container != null:
-		for child: Node in container.get_children():
+		for child: Node in container.get_children(true):
 			var shown: SubViewport = child as SubViewport
 			if shown != null:
 				_drop(shown, 0)
@@ -264,7 +264,7 @@ func _pressed_at(viewport: Viewport, point: Vector2) -> Node:
 	var inside: Vector2 = container.get_global_transform_with_canvas().affine_inverse() * point
 	if container.stretch:
 		inside /= container.stretch_shrink
-	for child: Node in container.get_children():
+	for child: Node in container.get_children(true):
 		var shown: SubViewport = child as SubViewport
 		if shown != null and not shown.gui_disable_input:
 			var within: Node = _pressed_at(
@@ -277,9 +277,11 @@ func _pressed_at(viewport: Viewport, point: Vector2) -> Node:
 
 ## The controls [param node] holds that the engine keeps as roots of [param node]'s viewport: drawn
 ## on their own, or with no control above them. Not into another viewport, a window or a
-## SubViewport, whose controls are that one's.
+## SubViewport, whose controls are that one's. Internal children count, as they do for the engine,
+## though get_children leaves them out unless asked: a layer added with INTERNAL_MODE_BACK was
+## passed over, and the press predicted for the control under it.
 static func _gather_roots(node: Node, roots: Array[Control]) -> void:
-	for child: Node in node.get_children():
+	for child: Node in node.get_children(true):
 		if child is Viewport:
 			continue
 		var control: Control = child as Control
@@ -331,8 +333,8 @@ func _at(item: CanvasItem, point: Vector2, holder: Transform2D) -> Control:
 	var control: Control = item as Control
 	var local: Vector2 = matrix.affine_inverse() * point
 	if control == null or not control.is_clipping_contents() or _has_point(control, local):
-		for index: int in range(item.get_child_count() - 1, -1, -1):
-			var child: CanvasItem = item.get_child(index) as CanvasItem
+		for index: int in range(item.get_child_count(true) - 1, -1, -1):
+			var child: CanvasItem = item.get_child(index, true) as CanvasItem
 			if child == null or child.top_level:
 				continue
 			var found: Control = _at(child, point, matrix)

package/build/godot/addons/gdharness_runtime/runtime_queries.gd

@@ -61,9 +61,16 @@ func get_tree(params: Dictionary) -> Dictionary:
 		return reached
 	var root: Node = reached["node"]
 
+	# A game whose first scene hands over to another shows a tree that names neither, so which
+	# scene is showing was guessed from the project's documentation.
+	var scene: Node = _host.get_tree().current_scene
+	var showing: Variant = null
+	if scene != null:
+		showing = { "path": str(scene.get_path()), "file": scene.scene_file_path }
 	return {
 		"type": "tree",
 		"root": _serialize_node_tree(root, 0, max_depth, include_properties, named),
+		"current_scene": showing,
 	}
 
 

package/build/godot/addons/gdharness_runtime/runtime_words.gd

@@ -163,7 +163,7 @@ static func pressable_words(from: Node, open: Callable, most: int) -> String:
 			if offered.size() == most:
 				return ", ".join(offered) + ", and more"
 			offered.append(quoted)
-		var children: Array[Node] = node.get_children()
+		var children: Array[Node] = node.get_children(true)
 		for index: int in range(children.size() - 1, -1, -1):
 			pending.push_front(children[index])
 	return ", ".join(offered)