gdharness 1.1.4 → 1.1.6

package/build/cli.js

@@ -388,6 +388,7 @@ function runArguments(options) {
 function editorArguments(projectPath, ports, logFile) {
   return [
     "-e",
+    "--headless",
     "--path",
     projectPath,
     "--lsp-port",
@@ -15874,7 +15875,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "project_settings",
-      description: "Reads or writes project.godot: settings, autoloads, the main scene, input actions, plugins and audio buses.",
+      description: "Reads or writes project.godot: settings, autoloads, the main scene, input actions, plugins and audio buses. A write with an editor open on the project is handed to the editor, which takes the settings the write changed from the file (named under editorAdopted), or reloads the bus layout, so it answers the new values and does not save the old ones back over them. editorNote is an editor that could not take the write, one on an addon from before this, which still holds the old values until editor_launch restart. An enabled plugin's code still loads on the editor's next start.",
       parameters: {
         projectPath: PROJECT_PATH,
         setting: { type: "string", description: 'Setting path, such as "display/window/size/viewport_width".' },
@@ -15986,19 +15987,30 @@ var init_tool_definitions = __esm(() => {
           description: 'set_options: import options keyed as the .import file spells them, {"compress/mode": 1}.',
           additionalProperties: true
         },
-        reimport: { type: "boolean", description: "set_options: reimport afterwards. Default true." },
-        force: { type: "boolean", description: "reimport: reimport even what is current. Default false." }
+        reimport: {
+          type: "boolean",
+          description: "set_options: reimport afterwards, answered under reimport as project_import reimport answers. Default true."
+        },
+        force: { type: "boolean", description: "reimport: reimport even what is current. Default false." },
+        timeoutMs: {
+          type: "integer",
+          minimum: 1,
+          description: "reimport, set_options: how long to wait for the editor to finish reimporting. Default 300000."
+        }
       },
       requires: ["projectPath"],
       operations: {
         status: {
-          summary: "which resources are outdated or failed, or one resource with resourcePath, judged by content as the editor judges it: a source whose hash differs from the one its import recorded, an import whose output under .godot/imported is gone (missing_outputs), and a glTF scene whose import does not depend on an image it names, because it was built before that image was imported (imported_without), each with its reason",
+          summary: "which resources are outdated or failed, or one resource with resourcePath, each with its reason. Judged by content with the checks the editor makes before it reimports: a sidecar changed since its import, as setting an option without a reimport leaves it; a sidecar with no uid or written for another file; an output under .godot/imported that is gone (missing_outputs) or changed; a source whose hash differs from the one its import recorded, or with no record. Beyond the editor, a glTF scene whose import does not depend on an image it names, because it was built before that image was imported (imported_without; a scene whose import runs an import script is not judged on images). failed is an import that failed, which the editor never tries again on its own. Without resourcePath, a sidecar whose source is gone is listed as missing_source",
           requires: []
         },
         options: { summary: "the import options of one resource", requires: ["resourcePath"] },
-        set_options: { summary: "change import options", requires: ["resourcePath", "options"] },
+        set_options: {
+          summary: "change import options in the sidecar, then apply them with a reimport of that resource",
+          requires: ["resourcePath", "options"]
+        },
         reimport: {
-          summary: "reimport one resource, or everything modified without resourcePath",
+          summary: "reimport what status says is outdated or failed, one resource with resourcePath, or what is current as well with force. Through the open editor when one serves the project, so it reloads what it holds, waiting for it to finish; otherwise through the engine's own import pass. Answered from a second status read: reimported lists what is current now, notReimported what is not, with its status and reason, and via says which of the two did the work. stillImporting is an editor that had not finished within timeoutMs",
           requires: []
         },
         uid: { summary: "the UID of one file", requires: ["resourcePath"] },
@@ -16300,7 +16312,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "editor_launch",
-      description: "Opens the Godot editor on a project, in a window on this machine, or restarts the one already connected. An editor goes on serving the addon it read at startup, so restart is what puts a gdharness upgrade into effect; it saves open scenes on the way out and answers with the version that came back. Only an editor with a window can be restarted, because the engine hands back none of the arguments it was started with. editor_status says which editor is connected and whether it is holding an old addon. Opening a project is a save and so is closing one, which is the part that is not obvious from outside: the editor imports the project on open and writes project.godot back, and Godot writes only what differs from its own defaults, so a key named deliberately at its default value is dropped either way. A restart says which under settingsDropped in its own answer because it waits for the editor to return. An open cannot, since it answers as soon as the process exists and the save happens during the import minutes later, so editor_status carries that reading once the editor has connected. Nothing else will say a key went until something depends on one. A restart of an editor this server opened is a quit and then a launch, and this server can be ended between them, usually by the reconnect the restart was being taken for: the editor is gone and nothing replaces it. That is written down before the quit, so the next server says so under restartInterrupted in editor_status rather than waiting for an editor that is not coming, and open finishes it, saying so under finishesRestart.",
+      description: "Opens the Godot editor on a project, or restarts the one already connected. An editor this opens is headless: it shows no window and takes no focus, and it serves the bridge, the language server, the debug adapter and the games it plays as a windowed one does. An editor goes on serving the addon it read at startup, so restart is what puts a gdharness upgrade into effect; it saves open scenes on the way out and answers with the version that came back. An editor a server opened is started again by the server, headless as before. One opened by hand restarts itself, which only one with a window can do, because the engine hands back none of the arguments it was started with. editor_status says which editor is connected and whether it is holding an old addon. Opening a project is a save and so is closing one, which is the part that is not obvious from outside: the editor imports the project on open and writes project.godot back, and Godot writes only what differs from its own defaults, so a key named deliberately at its default value is dropped either way. A restart says which under settingsDropped in its own answer because it waits for the editor to return. An open cannot, since it answers as soon as the process exists and the save happens during the import minutes later, so editor_status carries that reading once the editor has connected. Nothing else will say a key went until something depends on one. A restart of an editor this server opened is a quit and then a launch, and this server can be ended between them, usually by the reconnect the restart was being taken for: the editor is gone and nothing replaces it. That is written down before the quit, so the next server says so under restartInterrupted in editor_status rather than waiting for an editor that is not coming, and open finishes it, saying so under finishesRestart.",
       parameters: { projectPath: { ...PROJECT_PATH, ops: ["open"] } },
       requires: [],
       operations: {
@@ -16326,6 +16338,11 @@ var init_tool_definitions = __esm(() => {
           description: `The game's own arguments, what OS.get_cmdline_user_args() answers, such as ["--level=2"]. The separator is added here. A run with any is started by this server rather than by the editor, which fixes the game's command line when it opens the project, so the debug_* tools do not answer for it.`
         },
         headless: { type: "boolean", ops: ["start"], description: "start: force a window or no window." },
+        visible: {
+          type: "boolean",
+          ops: ["start"],
+          description: "start: on Windows, show the window on the desktop in use. By default a windowed run this server starts goes on a desktop of its own, where it renders and runtime_capture works but the window never shows and never takes the keyboard. A game the editor plays goes there too, since an editor this server opens is on that desktop. Elsewhere than Windows the window shows either way. Default false."
+        },
         savesIn: {
           type: "string",
           ops: ["start", "check"],
@@ -16656,7 +16673,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "runtime_capture",
-      description: "A picture of the running game: the whole screen or one viewport, as an image. Needs the game running with a window.",
+      description: "A picture of the running game: the whole screen or one viewport, as an image. Needs the game running with a window. A capture asked for before the game's first frame is drawn waits for that frame, since the game announces itself before it and the viewport holds nothing it drew until then.",
       parameters: {
         projectPath: RUNNING_PROJECT_PATH,
         pid: RUNNING_PID,
@@ -16923,7 +16940,6 @@ var init_headless_operations = __esm(() => {
       status: "get_import_status",
       options: "get_import_options",
       set_options: "set_import_options",
-      reimport: "reimport_resource",
       uid: "get_uid",
       refresh_classes: "refresh_class_cache"
     }),
@@ -16937,7 +16953,7 @@ var init_headless_operations = __esm(() => {
     })
   });
   ENGINE_PASSES = dictionary({
-    project_import: dictionary({ refresh_uids: "import" })
+    project_import: dictionary({ refresh_uids: "import", reimport: "import" })
   });
   EDITOR_READS = dictionary({
     project_settings: dictionary({ get: "get_project_setting" })
@@ -33091,6 +33107,10 @@ var init_dap_client = __esm(() => {
   init_ports();
 });
 
+// src/desktop.ts
+var HIDDEN_DESKTOP = "gdharness";
+var init_desktop = () => {};
+
 // src/editor-log.ts
 import {
   closeSync,
@@ -37786,7 +37806,8 @@ async function launchOutsideTheTree(spec, runtime = process.execPath, keeper = K
       command: spec.command,
       args: spec.args,
       envChanges: changesFrom(spec.env, process.env),
-      ...spec.run === undefined ? {} : { run: spec.run }
+      ...spec.run === undefined ? {} : { run: spec.run },
+      ...spec.desktop === undefined ? {} : { desktop: spec.desktop }
     });
     let printed = "";
     let complained = "";
@@ -37980,17 +38001,38 @@ var init_project_scan = __esm(() => {
   CARRIES_A_UID = new Set(["gd", "shader", "gdshader"]);
 });
 
+// src/reimport.ts
+import { createHash as createHash5 } from "node:crypto";
+import { existsSync as existsSync15, readFileSync as readFileSync19, rmSync as rmSync10, statSync as statSync7, utimesSync, writeFileSync as writeFileSync14 } from "node:fs";
+import { basename as basename3, join as join21 } from "node:path";
+function forceNextImport(projectPath, resourcePath) {
+  const relative = resourcePath.replace(/^res:\/\//, "");
+  const sidecar = join21(projectPath, `${relative}.import`);
+  if (!existsSync15(sidecar)) {
+    return;
+  }
+  const { atime, mtimeMs } = statSync7(sidecar);
+  writeFileSync14(sidecar, readFileSync19(sidecar, "utf8").replace(/^valid=false\r?\n/m, ""));
+  utimesSync(sidecar, atime, new Date(mtimeMs + 2000));
+  rmSync10(importRecord(projectPath, resourcePath), { force: true });
+}
+function importRecord(projectPath, resourcePath) {
+  const digest = createHash5("md5").update(resourcePath).digest("hex");
+  return join21(projectPath, ".godot", "imported", `${basename3(resourcePath)}-${digest}.md5`);
+}
+var init_reimport = () => {};
+
 // src/restart-note.ts
-import { mkdirSync as mkdirSync12, readFileSync as readFileSync19, rmSync as rmSync10, writeFileSync as writeFileSync14 } from "node:fs";
-import { dirname as dirname15, join as join21 } from "node:path";
+import { mkdirSync as mkdirSync12, readFileSync as readFileSync20, rmSync as rmSync11, writeFileSync as writeFileSync15 } from "node:fs";
+import { dirname as dirname15, join as join22 } from "node:path";
 function restartNotePath(projectPath) {
-  return join21(projectPath, ".godot", "gdharness-restart.json");
+  return join22(projectPath, ".godot", "gdharness-restart.json");
 }
 function noteRestartBegun(note) {
   const path = restartNotePath(note.projectPath);
   try {
     mkdirSync12(dirname15(path), { recursive: true });
-    writeFileSync14(path, `${JSON.stringify(note, null, 2)}
+    writeFileSync15(path, `${JSON.stringify(note, null, 2)}
 `, "utf8");
   } catch (error) {
     console.error(`[SERVER] Could not record the restart at ${path}: ${errorMessage(error)}`);
@@ -37998,7 +38040,7 @@ function noteRestartBegun(note) {
 }
 function restartOwed(projectPath) {
   try {
-    const parsed = JSON.parse(readFileSync19(restartNotePath(projectPath), "utf8"));
+    const parsed = JSON.parse(readFileSync20(restartNotePath(projectPath), "utf8"));
     if (typeof parsed !== "object" || parsed === null) {
       return null;
     }
@@ -38013,7 +38055,7 @@ function restartOwed(projectPath) {
 }
 function restartSettled(projectPath) {
   try {
-    rmSync10(restartNotePath(projectPath), { force: true });
+    rmSync11(restartNotePath(projectPath), { force: true });
   } catch (error) {
     console.error(`[SERVER] Could not clear the restart note: ${errorMessage(error)}`);
   }
@@ -38024,33 +38066,33 @@ var init_restart_note = __esm(() => {
 
 // src/run-record.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 import {
   mkdirSync as mkdirSync13,
   openSync as openSync2,
   readdirSync as readdirSync8,
-  readFileSync as readFileSync20,
+  readFileSync as readFileSync21,
   realpathSync as realpathSync3,
-  rmSync as rmSync11,
-  statSync as statSync7,
-  writeFileSync as writeFileSync15
+  rmSync as rmSync12,
+  statSync as statSync8,
+  writeFileSync as writeFileSync16
 } from "node:fs";
-import { basename as basename3, dirname as dirname16, join as join22, resolve as resolve5 } from "node:path";
+import { basename as basename4, dirname as dirname16, join as join23, resolve as resolve5 } from "node:path";
 function runsDirectory() {
-  return join22(runtimeDirectory(), "runs");
+  return join23(runtimeDirectory(), "runs");
 }
 function realAsFarAsItExists(path) {
   const missing = [];
   let at = path;
   for (;; ) {
     try {
-      return join22(realpathSync3.native(at), ...missing);
+      return join23(realpathSync3.native(at), ...missing);
     } catch {
       const parent = dirname16(at);
       if (parent === at) {
         return path;
       }
-      missing.unshift(basename3(at));
+      missing.unshift(basename4(at));
       at = parent;
     }
   }
@@ -38058,26 +38100,26 @@ function realAsFarAsItExists(path) {
 function projectKey(projectPath) {
   const real = realAsFarAsItExists(resolve5(projectPath)).replace(/[\\/]+$/, "");
   const folded = process.platform === "win32" || process.platform === "darwin" ? real.toLowerCase() : real;
-  return createHash5("sha256").update(folded.replaceAll("\\", "/")).digest("hex").slice(0, 16);
+  return createHash6("sha256").update(folded.replaceAll("\\", "/")).digest("hex").slice(0, 16);
 }
 function runRecordPath(projectPath, directory = runtimeDirectory()) {
-  return join22(directory, "runs", `note-${projectKey(projectPath)}.json`);
+  return join23(directory, "runs", `note-${projectKey(projectPath)}.json`);
 }
 function openTranscript(startedAt) {
   mkdirSync13(runsDirectory(), { recursive: true });
-  const path = join22(runsDirectory(), `run-${startedAt}.log`);
+  const path = join23(runsDirectory(), `run-${startedAt}.log`);
   return { path, fd: openSync2(path, "a") };
 }
 function editorNotePath(projectPath, directory = runtimeDirectory()) {
-  return join22(directory, "runs", `editor-${projectKey(projectPath)}.json`);
+  return join23(directory, "runs", `editor-${projectKey(projectPath)}.json`);
 }
 function writeEditorRunNote(note) {
   mkdirSync13(runsDirectory(), { recursive: true });
-  writeFileSync15(editorNotePath(note.projectPath), JSON.stringify(note, null, 2), "utf8");
+  writeFileSync16(editorNotePath(note.projectPath), JSON.stringify(note, null, 2), "utf8");
 }
 function readEditorRunNote(projectPath) {
   for (const directory of runtimeDirectories()) {
-    const note = editorNoteAt(editorNotePath(projectPath, directory)) ?? editorNoteAt(join22(directory, "runs", "editor-run.json"));
+    const note = editorNoteAt(editorNotePath(projectPath, directory)) ?? editorNoteAt(join23(directory, "runs", "editor-run.json"));
     if (note !== null && isSameDirectory(note.projectPath, projectPath)) {
       return note;
     }
@@ -38087,7 +38129,7 @@ function readEditorRunNote(projectPath) {
 function editorNoteAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync20(path, "utf8"));
+    parsed = JSON.parse(readFileSync21(path, "utf8"));
   } catch {
     return null;
   }
@@ -38109,7 +38151,7 @@ function readRunRecord(projectPath) {
     if (own !== null) {
       return own;
     }
-    const shared = recordAt(join22(directory, "runs", SHARED_NOTE));
+    const shared = recordAt(join23(directory, "runs", SHARED_NOTE));
     if (shared !== null && shared.projectPath !== "" && isSameDirectory(shared.projectPath, projectPath)) {
       return shared;
     }
@@ -38121,13 +38163,13 @@ function everyRunRecord() {
   for (const directory of runtimeDirectories()) {
     let entries;
     try {
-      entries = readdirSync8(join22(directory, "runs"));
+      entries = readdirSync8(join23(directory, "runs"));
     } catch {
       continue;
     }
     for (const entry of entries) {
       if (entry === SHARED_NOTE || entry.startsWith("note-") && entry.endsWith(".json")) {
-        const record = recordAt(join22(directory, "runs", entry));
+        const record = recordAt(join23(directory, "runs", entry));
         if (record !== null) {
           found.push(record);
         }
@@ -38139,7 +38181,7 @@ function everyRunRecord() {
 function recordAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync20(path, "utf8"));
+    parsed = JSON.parse(readFileSync21(path, "utf8"));
   } catch {
     return null;
   }
@@ -38185,7 +38227,7 @@ function runningAs(pid) {
     const began = startedAt(pid, null);
     const when = began === null ? {} : { startedAt: began };
     if (process.platform === "linux") {
-      const raw = readFileSync20(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
+      const raw = readFileSync21(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
       return raw === "" ? null : { kind: "commandLine", text: raw, ...when };
     }
     const args = execFileSync2("ps", ["-p", String(pid), "-o", "args="], {
@@ -38287,7 +38329,7 @@ function judgeRun(record, running, needed) {
   if (running.startedAt !== undefined && running.startedAt - record.startedAt > SAME_RUN_WINDOW_MS) {
     return false;
   }
-  const engine = record.command === undefined ? null : basename3(record.command);
+  const engine = record.command === undefined ? null : basename4(record.command);
   const said = process.platform === "win32" ? running.text.toLowerCase() : running.text;
   const wanted = engine === null || process.platform !== "win32" ? engine : engine.toLowerCase();
   if (wanted !== null && !said.includes(wanted)) {
@@ -38323,19 +38365,19 @@ function judgeAnnouncedGame(running, projectPath, announcedAt) {
 }
 function clearRunRecord(projectPath) {
   for (const directory of runtimeDirectories()) {
-    const shared = join22(directory, "runs", SHARED_NOTE);
+    const shared = join23(directory, "runs", SHARED_NOTE);
     const sharedRecord = recordAt(shared);
     const ours = sharedRecord !== null && sharedRecord.projectPath !== "" && isSameDirectory(sharedRecord.projectPath, projectPath);
     for (const path of [runRecordPath(projectPath, directory), ...ours ? [shared] : []]) {
       try {
-        rmSync11(path, { force: true });
+        rmSync12(path, { force: true });
       } catch {}
     }
   }
 }
 function ageMs(path, now) {
   try {
-    return now - statSync7(path).mtimeMs;
+    return now - statSync8(path).mtimeMs;
   } catch {
     return 0;
   }
@@ -38353,12 +38395,12 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
     if (!entry.startsWith("run-") || !entry.endsWith(".log")) {
       continue;
     }
-    const path = join22(directory, entry);
+    const path = join23(directory, entry);
     if (kept.has(path) || ageMs(path, now) < keepMs) {
       continue;
     }
     try {
-      rmSync11(path);
+      rmSync12(path);
     } catch {}
   }
 }
@@ -38377,19 +38419,19 @@ import {
   closeSync as closeSync2,
   constants,
   copyFileSync,
-  existsSync as existsSync15,
+  existsSync as existsSync16,
   fstatSync,
   mkdirSync as mkdirSync14,
   mkdtempSync as mkdtempSync3,
   openSync as openSync3,
   readdirSync as readdirSync9,
-  readFileSync as readFileSync21,
+  readFileSync as readFileSync22,
   readSync as readSync2,
   rmdirSync,
-  statSync as statSync8
+  statSync as statSync9
 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
-import { basename as basename4, dirname as dirname17, extname as extname2, isAbsolute as isAbsolute3, join as join23, normalize as normalize3, relative as relative3 } from "node:path";
+import { basename as basename5, dirname as dirname17, extname as extname2, isAbsolute as isAbsolute3, join as join24, normalize as normalize3, relative as relative3 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 import { promisify as promisify7 } from "node:util";
@@ -38404,15 +38446,15 @@ function captureDestinationRefusal(outputPath, projects) {
     return `outputPath ${outputPath} does not end in .png, which is what a capture is.`;
   }
   const directory = realPathOr(dirname17(outputPath));
-  if (!existsSync15(directory)) {
+  if (!existsSync16(directory)) {
     return `outputPath's directory ${dirname17(outputPath)} does not exist; a capture creates no directories.`;
   }
-  const where = join23(directory, basename4(outputPath));
+  const where = join24(directory, basename5(outputPath));
   const inside = projects.find((project) => project !== "" && isWithinRoot(realPathOr(project), where));
   if (inside !== undefined) {
     return `outputPath ${outputPath} is inside the project at ${inside}; a capture is saved outside it, so it never becomes part of the game.`;
   }
-  if (existsSync15(where)) {
+  if (existsSync16(where)) {
     return `outputPath ${outputPath} already exists; a capture is not written over a file. Name a new one.`;
   }
   return null;
@@ -38769,6 +38811,28 @@ function scanWaitAnswer(scanned) {
     scanNote: scanned.stillScanning ? `The editor was still scanning the project after ${SCAN_WAIT_MS / 1000} seconds, so this ` + "game started during the scan and may have read a class cache being rewritten. If " + 'editor_output shows "Could not find type" for a class that is declared, editor_rescan ' + "waits for the scan to finish, and a start after it reads the finished cache." : undefined
   };
 }
+function changedSettings(before, after) {
+  if (before === null || after === null) {
+    return null;
+  }
+  const names = new Set([...before.keys(), ...after.keys()]);
+  return [...names].filter((name) => JSON.stringify(before.get(name)) !== JSON.stringify(after.get(name))).sort();
+}
+function importStatuses(payload) {
+  const listed = payload["resources"];
+  if (!Array.isArray(listed)) {
+    return [];
+  }
+  return listed.map((entry) => {
+    const one = asParams(entry);
+    const reason = readString(one, "reason");
+    return {
+      path: readString(one, "path") ?? "",
+      status: readString(one, "status") ?? "unknown",
+      ...reason === undefined ? {} : { reason }
+    };
+  });
+}
 function escapingPropertyValue(properties) {
   if (typeof properties !== "object" || properties === null) {
     return;
@@ -38799,7 +38863,7 @@ function aboveTheRunner(entry) {
 }
 function elsewhereIn(projectPath, asked) {
   const wanted = asked.replace(/^res:\/\//, "").replace(/\/+$/, "");
-  if (wanted === "" || existsSync15(join23(projectPath, wanted))) {
+  if (wanted === "" || existsSync16(join24(projectPath, wanted))) {
     return "";
   }
   const root = (wanted.split("/")[0] ?? "").toLowerCase();
@@ -38813,7 +38877,7 @@ function elsewhereIn(projectPath, asked) {
   return near.length === 0 ? "" : ` The project does have ${there}.`;
 }
 function hasMainScene(projectFile) {
-  const scene = parseProjectGodot(readFileSync21(projectFile, "utf8"))["application"]?.["run/main_scene"];
+  const scene = parseProjectGodot(readFileSync22(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "";
 }
 function runtimeAddonAnnouncesEditors(projectPath) {
@@ -38821,13 +38885,13 @@ function runtimeAddonAnnouncesEditors(projectPath) {
     return false;
   }
   try {
-    return readFileSync21(join23(projectPath, RUNTIME_AUTOLOAD2.path), "utf8").includes('"editor_pid"');
+    return readFileSync22(join24(projectPath, RUNTIME_AUTOLOAD2.path), "utf8").includes('"editor_pid"');
   } catch {
     return false;
   }
 }
 function editorPlaysHeadless(projectFile) {
-  const runArgs = parseProjectGodot(readFileSync21(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
+  const runArgs = parseProjectGodot(readFileSync22(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
   return typeof runArgs === "string" && /(?:^|\s)--headless(?:\s|$)/.test(runArgs);
 }
 function camelCased(params) {
@@ -38846,7 +38910,7 @@ function needsItsOwnProcess(asked) {
 class GodotServer {
   mcp;
   locator = new GodotLocator2;
-  operationsScript = join23(__dirname2, "godot", "operations", "godot_operations.gd");
+  operationsScript = join24(__dirname2, "godot", "operations", "godot_operations.gd");
   godotBridge;
   tools = buildToolDefinitions();
   activeProcess = null;
@@ -39291,7 +39355,14 @@ class GodotServer {
   }
   async dispatch(tool, op, args) {
     if (ENGINE_PASSES[tool]?.[op] !== undefined) {
-      return await this.handleRefreshUids(args);
+      return op === "reimport" ? await this.handleReimport(args) : await this.handleRefreshUids(args);
+    }
+    const settingsWrite = tool === "project_settings" && op !== "get" ? HEADLESS_OPERATIONS[tool]?.[op] : undefined;
+    if (settingsWrite !== undefined) {
+      return await this.handleProjectSettingsWrite(op, settingsWrite, args);
+    }
+    if (tool === "project_import" && op === "set_options") {
+      return await this.handleSetImportOptions(args);
     }
     const headless = HEADLESS_OPERATIONS[tool]?.[op];
     if (headless !== undefined) {
@@ -39550,8 +39621,8 @@ class GodotServer {
     if (path === undefined) {
       return { ok: false, response: this.createErrorResponse("projectPath is required.") };
     }
-    const file = join23(path, "project.godot");
-    if (!existsSync15(file)) {
+    const file = join24(path, "project.godot");
+    if (!existsSync16(file)) {
       return {
         ok: false,
         response: this.createErrorResponse(`Not a Godot project: ${path}`, [
@@ -39822,6 +39893,222 @@ class GodotServer {
       }
     }, scanned));
   }
+  async handleReimport(args) {
+    const project = this.project(args);
+    if (!project.ok) {
+      return project.response;
+    }
+    const contained = this.containProjectFiles(args);
+    if (!contained.ok) {
+      return contained.response;
+    }
+    const outcome = await this.reimport(project.value.path, readNonEmptyString(contained.value, "resourcePath"), args["force"] === true, readPositiveNumber(args, "timeoutMs") ?? REIMPORT_TIMEOUT_MS);
+    return outcome.ok ? this.jsonTextResponse(outcome.payload) : outcome.response;
+  }
+  editorHasOpen(projectPath) {
+    const open = this.godotBridge.getStatus().projectPath;
+    return this.godotBridge.isConnected() && open !== undefined && open !== "" && isSameDirectory(open, projectPath);
+  }
+  async handleProjectSettingsWrite(op, operation, args) {
+    const project = this.project(args);
+    if (!project.ok) {
+      return project.response;
+    }
+    const projectPath = project.value.path;
+    const served = this.editorHasOpen(projectPath);
+    const before = served ? this.settingKeysOf(projectPath) : null;
+    const written = await this.headless(operation, args);
+    if (!served || written.isError === true) {
+      return written;
+    }
+    const answer = asParams(JSON.parse(written.content[0]?.text ?? "{}"));
+    if (AUDIO_BUS_OPS.has(op)) {
+      return this.jsonTextResponse({ ...answer, ...await this.editorTakes("adopt_audio_bus_layout", {}) });
+    }
+    const changed = changedSettings(before, this.settingKeysOf(projectPath));
+    if (changed === null) {
+      return this.jsonTextResponse({
+        ...answer,
+        editorNote: "project.godot could not be read on both sides of the write, so what it changed is unknown and the open editor was not told: it may still hold the old values and write them back the next time it saves. editor_launch restart loads the file."
+      });
+    }
+    if (changed.length === 0) {
+      return written;
+    }
+    const taken = await this.editorTakes("adopt_project_settings", { settings: changed });
+    return this.jsonTextResponse({
+      ...answer,
+      ...taken,
+      ...taken["editorNote"] === undefined ? { editorAdopted: changed } : {}
+    });
+  }
+  async editorTakes(command, args) {
+    try {
+      await this.godotBridge.invokeTool(command, args);
+      return {};
+    } catch (error) {
+      const message = errorMessage(error);
+      const why = message.includes("Unknown tool") ? "runs an addon from before writes were handed to it" : `could not take the change (${message})`;
+      return {
+        editorNote: `The open editor ${why}, so it still holds the old values, answers them when asked, and writes them back over the file the next time it saves. editor_launch restart loads the file and the addon this server ships.`
+      };
+    }
+  }
+  async handleSetImportOptions(args) {
+    const project = this.project(args);
+    if (!project.ok) {
+      return project.response;
+    }
+    const contained = this.containProjectFiles(args);
+    if (!contained.ok) {
+      return contained.response;
+    }
+    const {
+      op: _op,
+      projectPath: _projectPath,
+      reimport: _reimport,
+      timeoutMs: _timeoutMs,
+      ...params
+    } = contained.value;
+    const written = await this.operation("set_import_options", params, project.value.path);
+    if (!written.ok || args["reimport"] === false) {
+      return this.answer(written.ok ? {
+        ...written,
+        payload: {
+          ...written.payload,
+          note: "Not reimported: the editor imports it with these options on its next scan, or project_import reimport does now."
+        }
+      } : written);
+    }
+    const applied = await this.reimport(project.value.path, readNonEmptyString(contained.value, "resourcePath"), true, readPositiveNumber(args, "timeoutMs") ?? REIMPORT_TIMEOUT_MS);
+    if (!applied.ok) {
+      return applied.response;
+    }
+    return this.jsonTextResponse({ ...written.payload, reimport: applied.payload });
+  }
+  async reimport(projectPath, resourcePath, force, timeoutMs) {
+    const ask = resourcePath === undefined ? { includeUpToDate: force } : { resourcePath };
+    const before = await this.operation("get_import_status", ask, projectPath);
+    if (!before.ok) {
+      return { ok: false, response: this.answer(before) };
+    }
+    const listed = importStatuses(before.payload);
+    const missingSource = listed.filter((one) => one.status === "missing_source").map((one) => one.path);
+    if (resourcePath !== undefined && missingSource.length > 0) {
+      return {
+        ok: false,
+        response: this.createErrorResponse(`${missingSource[0]} is not on disk, so there is nothing to import.`)
+      };
+    }
+    const targets = listed.filter((one) => one.status !== "missing_source" && (force || one.status !== "up_to_date")).map((one) => one.path);
+    if (targets.length === 0) {
+      return {
+        ok: true,
+        payload: {
+          reimported: [],
+          notReimported: [],
+          note: resourcePath === undefined ? "Nothing needed reimporting. Pass force to reimport what is current." : `${listed[0]?.path ?? resourcePath} is current. Pass force to reimport it anyway.`
+        }
+      };
+    }
+    const viaEditor = this.editorHasOpen(projectPath);
+    const extra = {};
+    if (viaEditor) {
+      const inEditor = await this.reimportInTheEditor(targets, timeoutMs);
+      if (!inEditor.ok) {
+        return inEditor;
+      }
+      if (!inEditor.finished) {
+        return {
+          ok: true,
+          payload: {
+            via: "editor",
+            stillImporting: true,
+            asked: targets,
+            note: `The editor had not finished after ${timeoutMs} ms. project_import status says what it has done so far; pass a longer timeoutMs to wait it out.`
+          }
+        };
+      }
+    } else {
+      const engine = await this.engine();
+      if (!engine.ok) {
+        return { ok: false, response: engine.response };
+      }
+      for (const target of targets) {
+        forceNextImport(projectPath, target);
+      }
+      const scanned = await this.untilTheEditorsScanIsWritten(projectPath);
+      const imported = await runImport(engine.value, projectPath);
+      if (!imported.ok) {
+        return { ok: false, response: this.answer(withScanWait(imported, scanned)) };
+      }
+      if (imported.messages.length > 0) {
+        extra["engine_messages"] = imported.messages;
+      }
+    }
+    const after = await this.operation("get_import_status", resourcePath === undefined ? { includeUpToDate: true } : { resourcePath }, projectPath);
+    if (!after.ok) {
+      return { ok: false, response: this.answer(after) };
+    }
+    const now = new Map(importStatuses(after.payload).map((one) => [one.path, one]));
+    const reimported = targets.filter((path) => now.get(path)?.status === "up_to_date");
+    const notReimported = targets.filter((path) => now.get(path)?.status !== "up_to_date").map((path) => ({
+      path,
+      status: now.get(path)?.status ?? "unknown",
+      ...now.get(path)?.reason === undefined ? {} : { reason: now.get(path)?.reason }
+    }));
+    return {
+      ok: true,
+      payload: {
+        via: viaEditor ? "editor" : "engine",
+        reimported,
+        notReimported,
+        ...missingSource.length > 0 ? { missingSource } : {},
+        ...extra
+      }
+    };
+  }
+  async reimportInTheEditor(paths, timeoutMs) {
+    const started = Date.now();
+    let completedBefore;
+    for (;; ) {
+      while (Date.now() - started < timeoutMs && await this.editorIsScanningOrImporting()) {
+        await new Promise((settle) => setTimeout(settle, 100));
+      }
+      let answer;
+      try {
+        answer = asParams(await this.godotBridge.invokeTool("reimport_files", { paths: [...paths] }));
+      } catch (error) {
+        const message = errorMessage(error);
+        return {
+          ok: false,
+          response: message.includes("Unknown tool") ? this.createErrorResponse("The editor is running an addon from before reimport_files, so it cannot be asked to reimport.", [
+            "editor_launch restart loads the addon this server ships",
+            "Or close the editor, and project_import reimport runs the engine import instead"
+          ]) : this.createErrorResponse(`The editor answered reimport_files with an error: ${message}`)
+        };
+      }
+      if (answer["started"] !== false) {
+        completedBefore = readNumber(answer, "reimportsCompletedBefore");
+        break;
+      }
+      if (Date.now() - started >= timeoutMs) {
+        return { ok: true, finished: false };
+      }
+      await new Promise((settle) => setTimeout(settle, 100));
+    }
+    while (Date.now() - started < timeoutMs) {
+      await new Promise((settle) => setTimeout(settle, 250));
+      try {
+        const status = asParams(await this.godotBridge.invokeTool("scan_status", {}));
+        const completed = readNumber(status, "reimportsCompleted");
+        if (completedBefore !== undefined && completed !== undefined && completed > completedBefore) {
+          return { ok: true, finished: true };
+        }
+      } catch {}
+    }
+    return { ok: true, finished: false };
+  }
   async operation(operation, params, projectPath) {
     const engine = await this.engine();
     if (!engine.ok) {
@@ -39863,11 +40150,11 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const application = parseProjectGodot(readFileSync21(project.value.file, "utf8"))["application"] ?? {};
+    const application = parseProjectGodot(readFileSync22(project.value.file, "utf8"))["application"] ?? {};
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
-      name: typeof name === "string" && name !== "" ? name : basename4(project.value.path),
+      name: typeof name === "string" && name !== "" ? name : basename5(project.value.path),
       path: project.value.path,
       mainScene: typeof mainScene === "string" && mainScene !== "" ? mainScene : null,
       godotVersion: await this.godotVersion(engine.value),
@@ -39931,11 +40218,11 @@ class GodotServer {
       return this.createErrorResponse(`Cannot create ${dirname17(output.relativePath)} to export into: ${errorMessage(error)}`);
     }
     const debug = readBoolean(args, "debug") ?? false;
-    const exportLogs = mkdtempSync3(join23(tmpdir5(), "gdharness-export-"));
+    const exportLogs = mkdtempSync3(join24(tmpdir5(), "gdharness-export-"));
     const exportArgs = [
       "--headless",
       "--log-file",
-      join23(exportLogs, "engine.log"),
+      join24(exportLogs, "engine.log"),
       "--path",
       project.value.path,
       debug ? "--export-debug" : "--export-release",
@@ -39967,7 +40254,7 @@ class GodotServer {
     log.finish();
     const problems = log.select({ severity: "warning", sinceLastCall: false, limit: 200 });
     const verdict = {
-      exported: ending.exitCode === 0 && log.count("error") === 0 && existsSync15(output.absolutePath),
+      exported: ending.exitCode === 0 && log.count("error") === 0 && existsSync16(output.absolutePath),
       preset,
       outputPath: output.relativePath,
       debug,
@@ -40003,7 +40290,7 @@ class GodotServer {
       return contained.response;
     }
     const runner = "addons/gdUnit4/bin/GdUnitCmdTool.gd";
-    if (!existsSync15(join23(project.value.path, runner))) {
+    if (!existsSync16(join24(project.value.path, runner))) {
       return this.createErrorResponse(`gdUnit4 is not installed in this project: no ${runner}.`, [
         "Install gdUnit4 under addons/gdUnit4, from https://github.com/godot-gdunit-labs/gdUnit4"
       ]);
@@ -40039,7 +40326,7 @@ class GodotServer {
     ];
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 600000;
     this.logDebug(`Running tests: ${engine.value} ${cmdArgs.join(" ")}`);
-    const userData = mkdtempSync3(join23(tmpdir5(), "gdharness-tests-"));
+    const userData = mkdtempSync3(join24(tmpdir5(), "gdharness-tests-"));
     const run = this.spawnGame(engine.value, cmdArgs, userDataIn(userData));
     const console2 = [];
     run.process.stdout?.on("data", (data) => {
@@ -40059,14 +40346,14 @@ class GodotServer {
         resolve(false);
       });
     });
-    const reportsDir = join23(project.value.path, ".godot", ...ours.split("/"));
+    const reportsDir = join24(project.value.path, ".godot", ...ours.split("/"));
     let report = null;
     let reportProblem = null;
     try {
-      const written = existsSync15(reportsDir) ? readdirSync9(reportsDir).filter((name) => name.startsWith("report_")).sort((a, b) => Number(a.slice("report_".length)) - Number(b.slice("report_".length))) : [];
+      const written = existsSync16(reportsDir) ? readdirSync9(reportsDir).filter((name) => name.startsWith("report_")).sort((a, b) => Number(a.slice("report_".length)) - Number(b.slice("report_".length))) : [];
       const newest = written.at(-1);
       if (newest !== undefined) {
-        report = parseJUnit(readFileSync21(join23(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync22(join24(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
@@ -40209,11 +40496,11 @@ class GodotServer {
     const cached = cachedClasses(projectPath);
     const contradicted = cached === null ? [] : contradictedDiagnostics(messages, cached, (resourcePath) => {
       const contained = resolveWithinProject(projectPath, resourcePath);
-      if (!contained.ok || !existsSync15(contained.absolutePath)) {
+      if (!contained.ok || !existsSync16(contained.absolutePath)) {
         return null;
       }
       try {
-        return readFileSync21(contained.absolutePath, "utf8");
+        return readFileSync22(contained.absolutePath, "utf8");
       } catch {
         return null;
       }
@@ -40263,11 +40550,11 @@ class GodotServer {
   }
   sourceOfClass(projectPath, resourcePath) {
     const contained = resolveWithinProject(projectPath, resourcePath);
-    if (!contained.ok || !existsSync15(contained.absolutePath)) {
+    if (!contained.ok || !existsSync16(contained.absolutePath)) {
       return null;
     }
     try {
-      return readFileSync21(contained.absolutePath, "utf8");
+      return readFileSync22(contained.absolutePath, "utf8");
     } catch {
       return null;
     }
@@ -40536,7 +40823,7 @@ class GodotServer {
       return null;
     }
     try {
-      return settingKeys(readFileSync21(join23(projectPath, "project.godot"), "utf8"));
+      return settingKeys(readFileSync22(join24(projectPath, "project.godot"), "utf8"));
     } catch {
       return null;
     }
@@ -40676,7 +40963,8 @@ class GodotServer {
         GDHARNESS_LSP_PORT: String(ports.lsp),
         GDHARNESS_DAP_PORT: String(ports.dap),
         [OPENED_BY_A_SERVER]: "1"
-      }
+      },
+      desktop: HIDDEN_DESKTOP
     });
     if ("error" in launched) {
       return { pid: null, error: launched.error };
@@ -40758,7 +41046,7 @@ class GodotServer {
       userArgs: given.value
     });
     this.logDebug(`Running Godot project: ${engine.value} ${cmdArgs.join(" ")}`);
-    const started = await this.launchKeptGame(engine.value, cmdArgs, project.value.path, needsItsOwnProcess(asked.value) ? environmentFor({ ...asked.value, runtimeDirectory: runtimeDirectory() }) : undefined);
+    const started = await this.launchKeptGame(engine.value, cmdArgs, project.value.path, needsItsOwnProcess(asked.value) ? environmentFor({ ...asked.value, runtimeDirectory: runtimeDirectory() }) : undefined, headless || args["visible"] === true ? undefined : HIDDEN_DESKTOP);
     if ("error" in started) {
       return this.createErrorResponse(`The game could not be started: ${started.error}`, [
         "editor_status says which Godot this server runs and whether it answers"
@@ -40788,7 +41076,7 @@ class GodotServer {
   }
   async runtimeUp(projectPath, before, budget, withArgs) {
     const budgetMs = budget.ms;
-    if (!existsSync15(join23(projectPath, RUNTIME_AUTOLOAD2.path))) {
+    if (!existsSync16(join24(projectPath, RUNTIME_AUTOLOAD2.path))) {
       return runtimeVerdict(null, { addon: false, budgetMs, heldAt: null, running: false, withArgs });
     }
     let asking = null;
@@ -40851,7 +41139,7 @@ class GodotServer {
     }
     let announcedAt;
     try {
-      announcedAt = statSync8(endpoint.file).mtimeMs;
+      announcedAt = statSync9(endpoint.file).mtimeMs;
     } catch {
       return;
     }
@@ -41098,7 +41386,7 @@ class GodotServer {
     });
     return started;
   }
-  async launchKeptGame(godotPath, cmdArgs, projectPath, env) {
+  async launchKeptGame(godotPath, cmdArgs, projectPath, env, desktop) {
     const startedAt = Date.now();
     const transcript = openTranscript(startedAt);
     closeSync2(transcript.fd);
@@ -41106,7 +41394,8 @@ class GodotServer {
       command: godotPath,
       args: cmdArgs,
       ...env === undefined ? {} : { env },
-      run: { transcript: transcript.path, startedAt, projectPath }
+      run: { transcript: transcript.path, startedAt, projectPath },
+      ...desktop === undefined ? {} : { desktop }
     });
     if ("error" in launched) {
       return launched;
@@ -41601,7 +41890,7 @@ class GodotServer {
       notes.push(endedWithoutACode({
         throughEditor: run.throughEditor,
         announced: announced !== undefined || run.announcedPid !== undefined,
-        couldAnnounce: run.projectPath !== null && existsSync15(join23(run.projectPath, RUNTIME_AUTOLOAD2.path)),
+        couldAnnounce: run.projectPath !== null && existsSync16(join24(run.projectPath, RUNTIME_AUTOLOAD2.path)),
         endedHere: typeof run.endedHere === "string",
         pickedUp: run.pickedUp === true
       }));
@@ -41827,6 +42116,7 @@ class GodotServer {
     const ghosts = blind.stillHeld ?? [];
     let waitedForEditorMs = 0;
     let first;
+    let completedBefore;
     for (;; ) {
       const busySince = Date.now();
       let wasBusy = false;
@@ -41841,8 +42131,9 @@ class GodotServer {
       if (first.isError) {
         return first;
       }
-      const declined = asParams(JSON.parse(first.content[0]?.text ?? "{}"))["started"] === false;
-      if (!declined || Date.now() - started >= timeoutMs) {
+      const firstAnswer = asParams(JSON.parse(first.content[0]?.text ?? "{}"));
+      completedBefore = readNumber(firstAnswer, "scansCompletedBefore");
+      if (firstAnswer["started"] !== false || Date.now() - started >= timeoutMs) {
         break;
       }
       await new Promise((settle) => setTimeout(settle, 100));
@@ -41853,7 +42144,9 @@ class GodotServer {
       await new Promise((settle) => setTimeout(settle, 100));
       const status = asParams(await this.godotBridge.invokeTool("rescan_filesystem", { ...args, statusOnly: true }));
       const pending = Boolean(status["pending"]) && Date.now() - started < SCAN_START_MS;
-      busy = Boolean(status["scanning"]) || Boolean(status["importing"]) || pending;
+      const completed = readNumber(status, "scansCompleted");
+      const notYetOver = completedBefore !== undefined && completed !== undefined && completed <= completedBefore;
+      busy = Boolean(status["scanning"]) || Boolean(status["importing"]) || pending || notYetOver;
       if (busy) {
         idleSince = null;
       } else {
@@ -42110,7 +42403,7 @@ class GodotServer {
   async ownRunOnItsWay(projectPath, budgetMs) {
     const run = this.currentRun();
     const project = projectPath ?? run?.projectPath ?? null;
-    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync15(join23(project, RUNTIME_AUTOLOAD2.path)) || !await this.runStillGoing(run)) {
+    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync16(join24(project, RUNTIME_AUTOLOAD2.path)) || !await this.runStillGoing(run)) {
       return null;
     }
     const already = runtimesAnnounced().running;
@@ -42119,7 +42412,7 @@ class GodotServer {
         return !run.announcedBefore.has(one.pid);
       }
       try {
-        return statSync8(one.file).mtimeMs >= run.startedAt;
+        return statSync9(one.file).mtimeMs >= run.startedAt;
       } catch {
         return false;
       }
@@ -42189,8 +42482,8 @@ class GodotServer {
         return this.createErrorResponse(refusal);
       }
     }
-    const screenshotDir = expectsScreenshot ? mkdtempSync3(join23(tmpdir5(), "gdharness-runtime-screenshot-")) : null;
-    const screenshotPath = screenshotDir ? join23(screenshotDir, "capture.png") : null;
+    const screenshotDir = expectsScreenshot ? mkdtempSync3(join24(tmpdir5(), "gdharness-runtime-screenshot-")) : null;
+    const screenshotPath = screenshotDir ? join24(screenshotDir, "capture.png") : null;
     try {
       const reply = await runtimeRequest(choice.endpoint, command, screenshotPath ? { ...params, output_path: screenshotPath } : params, timeoutMs, !expectsScreenshot);
       if (!reply.ok && reply.requestId !== undefined) {
@@ -42231,7 +42524,7 @@ class GodotServer {
             type: "text",
             text: `Screenshot captured: ${dimensions}${chosenAmongSeveral ? ` from pid ${own}, the game this server holds` : ""}${saveTo === null ? "" : `. Saved to ${saveTo}`}`
           },
-          { type: "image", data: readFileSync21(screenshotPath).toString("base64"), mimeType: "image/png" }
+          { type: "image", data: readFileSync22(screenshotPath).toString("base64"), mimeType: "image/png" }
         ]
       };
     } finally {
@@ -42331,7 +42624,7 @@ async function runGodotServer() {
   const server = new GodotServer;
   await server.run();
 }
-var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run7, __dirname2, EDITOR_RESTART_TIMEOUT_MS = 90000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, PLAY_STARTS_WITHIN_MS = 30000, STOP_WAIT_MS = 1e4, EXIT_REPORTED_WITHIN_MS = 2000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, MOST_GROUPS = 20, VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, HANDOVER_MS, HANDOVER_POLL_MS = 250, CACHE_WRITE_MS = 2000, SCAN_WAIT_MS = 30000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, SCAN_SETTLED_MS = 500, WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/";
+var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run7, __dirname2, EDITOR_RESTART_TIMEOUT_MS = 90000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, PLAY_STARTS_WITHIN_MS = 30000, STOP_WAIT_MS = 1e4, EXIT_REPORTED_WITHIN_MS = 2000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, MOST_GROUPS = 20, VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, HANDOVER_MS, HANDOVER_POLL_MS = 250, CACHE_WRITE_MS = 2000, SCAN_WAIT_MS = 30000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, SCAN_SETTLED_MS = 500, REIMPORT_TIMEOUT_MS = 300000, AUDIO_BUS_OPS, WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/";
 var init_server3 = __esm(() => {
   init_mcp();
   init_stdio2();
@@ -42344,6 +42637,7 @@ var init_server3 = __esm(() => {
   init_class_note();
   init_config_pin();
   init_dap_client();
+  init_desktop();
   init_editor_log();
   init_errors();
   init_game_log();
@@ -42360,6 +42654,7 @@ var init_server3 = __esm(() => {
   init_process_children();
   init_process_time();
   init_project_scan();
+  init_reimport();
   init_resources();
   init_restart_note();
   init_run_record();
@@ -42380,6 +42675,11 @@ var init_server3 = __esm(() => {
     object: "an object"
   };
   HANDOVER_MS = SUCCESSOR_CHECK_MS + 5000;
+  AUDIO_BUS_OPS = new Set([
+    "add_audio_bus",
+    "set_audio_bus_effect",
+    "set_audio_bus_volume"
+  ]);
   PATH_SOLUTIONS = [
     'Give the path relative to the project, such as "scenes/main.tscn" or "res://scenes/main.tscn"',
     "Point projectPath at the project the file belongs to"
@@ -42411,8 +42711,8 @@ var init_server3 = __esm(() => {
 });
 
 // src/cli.ts
-import { existsSync as existsSync16 } from "fs";
-import { join as join24, resolve as resolve6 } from "path";
+import { existsSync as existsSync17 } from "fs";
+import { join as join25, resolve as resolve6 } from "path";
 
 // src/bridge-announce.ts
 init_errors();
@@ -44236,7 +44536,7 @@ class UsageError extends Refusal2 {
 function projectArgument(at) {
   const named = args.slice(at).find((value) => !value.startsWith("--"));
   const projectPath = resolve6(named ?? ".");
-  if (!existsSync16(join24(projectPath, "project.godot"))) {
+  if (!existsSync17(join25(projectPath, "project.godot"))) {
     throw new UsageError(`Not a Godot project: ${projectPath} holds no project.godot.`);
   }
   return projectPath;
@@ -44275,7 +44575,7 @@ async function registerRuntime(godot, projectPath) {
     return;
   }
   console.log(`${RUNTIME_AUTOLOAD.name} autoload left at ${named}, which this project registers itself`);
-  if (!existsSync16(join24(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
+  if (!existsSync17(join25(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
     console.log(`  that file is not in this project, so it boots with a missing script: restore it, or point the entry at res://${RUNTIME_AUTOLOAD.path}`);
   }
 }
@@ -44407,7 +44707,7 @@ async function setup() {
       console.log("no harness configured; name one yourself, and gdharness harnesses lists them all");
     }
     if (!args.includes("--no-skill")) {
-      const directories = skillDirectories(chosen.harnesses, projectPath, existsSync16);
+      const directories = skillDirectories(chosen.harnesses, projectPath, existsSync17);
       for (const written of writeSkill(directories, getLocalVersion())) {
         console.log(`skill: ${written.replaced ? "replaced" : "written"} ${written.path}`);
       }
@@ -44501,7 +44801,7 @@ async function upgrade() {
       moved.push(took.from);
     }
   }
-  for (const written of writeSkill(skillDirectories(already, projectPath, existsSync16), version)) {
+  for (const written of writeSkill(skillDirectories(already, projectPath, existsSync17), version)) {
     console.log(`skill: ${written.replaced ? "replaced" : "written"} ${written.path}`);
   }
   console.log(`