gdharness 1.1.31 → 1.1.32

package/build/cli.js

@@ -8733,6 +8733,396 @@ var init_issues = __esm(() => {
   ENHANCEMENT_URL = `${NEW_ISSUE}?template=feature_request.md`;
 });
 
+// src/gdscript-source.ts
+function isIdentifierStart(character) {
+  return character !== undefined && IDENTIFIER_START.test(character);
+}
+function isIdentifierPart(character) {
+  return character !== undefined && IDENTIFIER_PART.test(character);
+}
+function percentIsUniqueNode(source, at) {
+  const next = source[at + 1];
+  if (!isIdentifierStart(next) && next !== '"' && next !== "'") {
+    return false;
+  }
+  let back = at - 1;
+  while (back >= 0 && (source[back] === " " || source[back] === "\t")) {
+    back -= 1;
+  }
+  const before = source[back];
+  if (before === undefined || before === `
+`) {
+    return true;
+  }
+  if (isIdentifierPart(before) || before === ")" || before === "]" || before === '"' || before === "'") {
+    let wordStart = back;
+    while (wordStart > 0 && isIdentifierPart(source[wordStart - 1])) {
+      wordStart -= 1;
+    }
+    const word = source.slice(wordStart, back + 1);
+    return ["return", "and", "or", "not", "in", "is", "as", "if", "elif", "else", "while", "await"].includes(word);
+  }
+  return true;
+}
+function stringEnd(source, at) {
+  const quote = source[at] ?? '"';
+  const fence = source.startsWith(quote.repeat(3), at) ? quote.repeat(3) : quote;
+  let end = at + fence.length;
+  while (end < source.length && !source.startsWith(fence, end)) {
+    if (fence.length === 1 && source[end] === `
+`) {
+      return end;
+    }
+    end += source[end] === "\\" ? 2 : 1;
+  }
+  return Math.min(end + fence.length, source.length);
+}
+function regionsOf(source) {
+  const regions = [];
+  let codeStart = 0;
+  let at = 0;
+  const close = (kind, start, end) => {
+    if (codeStart < start) {
+      regions.push({ kind: "code", start: codeStart, end: start });
+    }
+    regions.push({ kind, start, end });
+    codeStart = end;
+    at = end;
+  };
+  while (at < source.length) {
+    const here = source[at];
+    if (here === "#") {
+      const lineEnd = source.indexOf(`
+`, at);
+      const end = lineEnd === -1 ? source.length : lineEnd;
+      const lineStart = source.lastIndexOf(`
+`, at - 1) + 1;
+      const alone = source.slice(lineStart, at).trim() === "";
+      close(alone && source.startsWith("##", at) ? "doc" : "comment", at, end);
+      continue;
+    }
+    if (here === '"' || here === "'") {
+      const prefixed = at > 0 && ["r", "&", "^"].includes(source[at - 1] ?? "") && !isIdentifierPart(source[at - 2]);
+      const start = prefixed ? at - 1 : at;
+      const dollar = source[start - 1] === "$" || source[start - 1] === "%" && percentIsUniqueNode(source, start - 1);
+      close(dollar ? "nodePath" : "string", dollar ? start - 1 : start, stringEnd(source, at));
+      continue;
+    }
+    if (here === "$" || here === "%" && percentIsUniqueNode(source, at)) {
+      if (source[at + 1] === '"' || source[at + 1] === "'") {
+        at += 1;
+        continue;
+      }
+      let end = at + 1;
+      while (end < source.length && (isIdentifierPart(source[end]) || source[end] === "/" || source[end] === "%")) {
+        end += 1;
+      }
+      if (end > at + 1) {
+        close("nodePath", at, end);
+        continue;
+      }
+    }
+    if (isIdentifierStart(here)) {
+      while (at < source.length && isIdentifierPart(source[at])) {
+        at += 1;
+      }
+      continue;
+    }
+    at += 1;
+  }
+  if (codeStart < source.length) {
+    regions.push({ kind: "code", start: codeStart, end: source.length });
+  }
+  return regions;
+}
+function codeOf(source, regions = regionsOf(source)) {
+  let code = "";
+  for (const region of regions) {
+    const text = source.slice(region.start, region.end);
+    code += region.kind === "code" ? text : text.replace(/[^\n]/g, " ");
+  }
+  return code;
+}
+
+class Lines {
+  starts = [0];
+  text;
+  constructor(text) {
+    this.text = text;
+    for (let at = text.indexOf(`
+`);at !== -1; at = text.indexOf(`
+`, at + 1)) {
+      this.starts.push(at + 1);
+    }
+  }
+  positionOf(offset) {
+    let low = 0;
+    let high = this.starts.length - 1;
+    while (low < high) {
+      const middle = low + high + 1 >> 1;
+      if ((this.starts[middle] ?? 0) <= offset) {
+        low = middle;
+      } else {
+        high = middle - 1;
+      }
+    }
+    return { line: low, character: offset - (this.starts[low] ?? 0) };
+  }
+  offsetOf(position) {
+    const start = this.starts[position.line];
+    if (start === undefined) {
+      return null;
+    }
+    const offset = start + position.character;
+    return offset > this.text.length ? null : offset;
+  }
+  lineAt(offset) {
+    const { line } = this.positionOf(offset);
+    const start = this.starts[line] ?? 0;
+    const end = this.starts[line + 1] ?? this.text.length + 1;
+    return this.text.slice(start, end - 1).replace(/\r$/, "");
+  }
+}
+function escapedForPattern(text) {
+  return text.replace(/[\\^$.*+?()[\]{}|/]/g, "\\$&");
+}
+function wholeWord(name, flags = "gu") {
+  return new RegExp(`(?<![\\p{L}\\p{N}_])${escapedForPattern(name)}(?![\\p{L}\\p{N}_])`, flags);
+}
+function occurrencesOf(source, name, regions = regionsOf(source)) {
+  const found = [];
+  let index = 0;
+  for (const match of source.matchAll(wholeWord(name))) {
+    const offset = match.index;
+    while (index < regions.length - 1 && (regions[index]?.end ?? 0) <= offset) {
+      index += 1;
+    }
+    const kind = regions[index]?.kind ?? "code";
+    let afterDot = false;
+    let declaredAs = null;
+    if (kind === "code") {
+      let back = offset - 1;
+      while (back >= 0 && /[\s\\]/.test(source[back] ?? "")) {
+        back -= 1;
+      }
+      afterDot = source[back] === "." && source[back - 1] !== ".";
+      let wordStart = back + 1;
+      while (wordStart > 0 && isIdentifierPart(source[wordStart - 1])) {
+        wordStart -= 1;
+      }
+      const word = source.slice(wordStart, back + 1);
+      declaredAs = DECLARING.has(word) ? word : null;
+    }
+    found.push({ offset, kind, afterDot, declaredAs });
+  }
+  return found;
+}
+function extendsTarget(source, code, after) {
+  let from = after;
+  while (source[from] === " " || source[from] === "\t") {
+    from += 1;
+  }
+  const quote = source[from];
+  if (quote === '"' || quote === "'") {
+    const end = source.indexOf(quote, from + 1);
+    return end === -1 ? null : source.slice(from, end + 1);
+  }
+  const dotted = new RegExp(`^${NAME}(?:\\.${NAME})*`, "u").exec(code.slice(from));
+  return dotted?.[0] ?? null;
+}
+function shapeOf(source) {
+  const regions = regionsOf(source);
+  const code = codeOf(source, regions);
+  const lines = [];
+  let start = 0;
+  for (const text of code.split(`
+`)) {
+    const indent = /^[ \t]*/.exec(text)?.[0].length ?? 0;
+    lines.push({ start, text, indent });
+    start += text.length + 1;
+  }
+  let className = null;
+  const parseBody = (name, extendsAs, from, indent, bodyStart) => {
+    const declarations = [];
+    const inner = [];
+    let index = from;
+    let openEnum = null;
+    let topExtends = extendsAs;
+    while (index < lines.length) {
+      const line = lines[index];
+      if (line === undefined) {
+        break;
+      }
+      if (openEnum !== null) {
+        openEnum.text += `
+${line.text}`;
+        if (line.text.includes("}")) {
+          collectEnumValues(openEnum.text, openEnum.from, declarations);
+          openEnum = null;
+        }
+        index += 1;
+        continue;
+      }
+      if (line.text.trim() === "") {
+        index += 1;
+        continue;
+      }
+      if (line.indent < indent) {
+        break;
+      }
+      if (line.indent > indent) {
+        index += 1;
+        continue;
+      }
+      const body = line.text.slice(line.indent);
+      const at = line.start + line.indent;
+      if (name === null) {
+        const declared = CLASS_NAME_LINE.exec(body);
+        if (declared?.[1] !== undefined) {
+          className = { name: declared[1], offset: at + declared[0].length - declared[1].length };
+        }
+        if (EXTENDS_LINE.test(body) || CLASS_NAME_LINE.test(body)) {
+          const clause = EXTENDS_CLAUSE.exec(body);
+          if (clause !== null && topExtends === null) {
+            topExtends = extendsTarget(source, code, at + clause.index + clause[0].length);
+          }
+        }
+      }
+      const declared = DECLARATION_LINE.exec(body);
+      if (declared !== null) {
+        const [whole, , isStatic, keyword, declaredName] = declared;
+        if (keyword !== undefined && declaredName !== undefined) {
+          const offset = at + whole.length - declaredName.length;
+          const kind = keyword;
+          declarations.push({ name: declaredName, kind, offset, isStatic: isStatic !== undefined });
+          if (kind === "enum") {
+            const brace = body.indexOf("{");
+            if (brace !== -1) {
+              openEnum = { from: at + brace, text: body.slice(brace) };
+              if (body.includes("}", brace)) {
+                collectEnumValues(openEnum.text, openEnum.from, declarations);
+                openEnum = null;
+              }
+            }
+          }
+          if (kind === "class") {
+            const rest = body.slice(whole.length);
+            const clause = EXTENDS_CLAUSE.exec(rest);
+            const innerExtends = clause === null ? null : extendsTarget(source, code, at + whole.length + clause.index + clause[0].length);
+            const childIndent = lines.slice(index + 1).find((next) => next.text.trim() !== "")?.indent ?? indent + 1;
+            if (childIndent > indent) {
+              const parsed = parseBody(declaredName, innerExtends, index + 1, childIndent, line.start);
+              inner.push(parsed.body);
+              index = parsed.next;
+              continue;
+            }
+            inner.push({
+              name: declaredName,
+              extendsAs: innerExtends,
+              declarations: [],
+              inner: [],
+              start: line.start,
+              end: line.start + line.text.length
+            });
+          }
+        }
+      } else if (/^enum\s*\{/u.test(body)) {
+        const brace = body.indexOf("{");
+        openEnum = { from: at + brace, text: body.slice(brace) };
+        if (body.includes("}", brace)) {
+          collectEnumValues(openEnum.text, openEnum.from, declarations);
+          openEnum = null;
+        }
+      }
+      index += 1;
+    }
+    const last = lines[index - 1];
+    return {
+      body: {
+        name,
+        extendsAs: topExtends,
+        declarations,
+        inner,
+        start: bodyStart,
+        end: last === undefined ? bodyStart : last.start + last.text.length
+      },
+      next: index
+    };
+  };
+  const { body } = parseBody(null, null, 0, 0, 0);
+  return { className, body };
+}
+function collectEnumValues(text, from, into) {
+  const close = text.indexOf("}");
+  const inside = text.slice(1, close === -1 ? text.length : close);
+  for (const match of inside.matchAll(new RegExp(`(^|,)\\s*(${NAME})`, "gu"))) {
+    const valueName = match[2];
+    if (valueName === undefined) {
+      continue;
+    }
+    const offset = from + 1 + match.index + match[0].length - valueName.length;
+    into.push({ name: valueName, kind: "enumValue", offset, isStatic: true });
+  }
+}
+function isIdentifier(name) {
+  return new RegExp(`^${NAME}$`, "u").test(name) && !KEYWORDS.has(name);
+}
+var IDENTIFIER_START, IDENTIFIER_PART, DECLARING, NAME = "[\\p{L}_][\\p{L}\\p{N}_]*", ANNOTATIONS = "(?:@[\\p{L}_][\\p{L}\\p{N}_]*(?:\\([^)]*\\))?\\s+)*", DECLARATION_LINE, CLASS_NAME_LINE, EXTENDS_LINE, EXTENDS_CLAUSE, KEYWORDS;
+var init_gdscript_source = __esm(() => {
+  IDENTIFIER_START = /[\p{L}_]/u;
+  IDENTIFIER_PART = /[\p{L}\p{N}_]/u;
+  DECLARING = new Set(["var", "const", "func", "signal", "enum", "class", "for", "class_name"]);
+  DECLARATION_LINE = new RegExp(`^(${ANNOTATIONS})(static\\s+)?(func|var|const|signal|enum|class)\\s+(${NAME})`, "u");
+  CLASS_NAME_LINE = new RegExp(`^${ANNOTATIONS}class_name\\s+(${NAME})`, "u");
+  EXTENDS_LINE = new RegExp(`^${ANNOTATIONS}(?:class_name\\s+${NAME}\\s+)?extends\\s`, "u");
+  EXTENDS_CLAUSE = /\bextends(?=\s)/u;
+  KEYWORDS = new Set([
+    "and",
+    "as",
+    "assert",
+    "await",
+    "break",
+    "breakpoint",
+    "class",
+    "class_name",
+    "const",
+    "continue",
+    "elif",
+    "else",
+    "enum",
+    "extends",
+    "false",
+    "for",
+    "func",
+    "if",
+    "in",
+    "is",
+    "match",
+    "namespace",
+    "not",
+    "null",
+    "or",
+    "pass",
+    "preload",
+    "return",
+    "self",
+    "signal",
+    "static",
+    "super",
+    "trait",
+    "true",
+    "var",
+    "void",
+    "when",
+    "while",
+    "yield",
+    "INF",
+    "NAN",
+    "PI",
+    "TAU"
+  ]);
+});
+
 // src/class-cache.ts
 import { existsSync as existsSync9, readdirSync as readdirSync3, readFileSync as readFileSync7, statSync as statSync4 } from "node:fs";
 import { join as join9 } from "node:path";
@@ -8783,33 +9173,6 @@ function scriptsNaming(projectPath, classes) {
   });
   return naming.sort((a, b) => a.script.localeCompare(b.script));
 }
-function codeOf(source) {
-  let code = "";
-  let at = 0;
-  while (at < source.length) {
-    const here = source[at] ?? "";
-    if (here === "#") {
-      const end = source.indexOf(`
-`, at);
-      at = end === -1 ? source.length : end;
-      continue;
-    }
-    if (here === '"' || here === "'") {
-      const fence = source.startsWith(here.repeat(3), at) ? here.repeat(3) : here;
-      let end = at + fence.length;
-      while (end < source.length && !source.startsWith(fence, end)) {
-        end += source[end] === "\\" ? 2 : 1;
-      }
-      const literal = source.slice(at, Math.min(end + fence.length, source.length));
-      code += literal.replace(/[^\n]/g, " ");
-      at = end + fence.length;
-      continue;
-    }
-    code += here;
-    at += 1;
-  }
-  return code;
-}
 function cachedClasses(projectPath) {
   const cache = join9(projectPath, ".godot", "global_script_class_cache.cfg");
   if (!existsSync9(cache)) {
@@ -9068,6 +9431,7 @@ function unseenByEditor(projectPath, editorHolds) {
 }
 var DECLARATION, TOOL;
 var init_class_cache = __esm(() => {
+  init_gdscript_source();
   DECLARATION = /^(?:@[a-z_]+(?:\([^)\n]*\))?\s+)*class_name\s+([A-Za-z_][A-Za-z0-9_]*)/m;
   TOOL = /^[ \t]*(?:@[a-z_]+(?:\([^)\n]*\))?[ \t]+)*@tool\b/m;
 });
@@ -17174,7 +17538,7 @@ var init_tool_definitions = __esm(() => {
           requires: ["resourcePath", "options"]
         },
         reimport: {
-          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. A whole-project reimport also answers missingSource, the .import files whose source is not beside them, empty when there are none, whether or not anything needed reimporting; one resourcePath is not a walk of the project and leaves it out. stillImporting is an editor that had not finished within timeoutMs",
+          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. The editor scans first, since its reimport passes over a file it has not taken in, such as one an installer has just written; what that scan imported is named under importedByTheScan and is not imported again unless force asks. Answered from a second status read: reimported lists what is current now, notReimported what is not, one entry per status and reason with the paths sharing them, and via says which of the two did the work. A whole-project reimport also answers missingSource, the .import files whose source is not beside them, empty when there are none, whether or not anything needed reimporting; one resourcePath is not a walk of the project and leaves it out. stillImporting is an editor that had not finished within timeoutMs",
           requires: []
         },
         uid: {
@@ -17392,7 +17756,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "script_edit",
-      description: "Creates a GDScript file, or adds functions, variables and signals to one. Every declaration written carries a type. Both load what they wrote under the project's own warning settings and answer with parses; the engine's reasons for a refusal come back under engine_messages. create answers with the extends and class_name the engine read, and a script declaring a class_name is put in the project's class list, with registered saying whether it is there. modify makes every addition or none, and answers with the line each one is on in the file written.",
+      description: "Creates a GDScript file, or adds functions, variables and signals to one. Every declaration written carries a type. Both load what they wrote under the project's own warning settings and answer with parses; the engine's reasons for a refusal come back under engine_messages. create answers with the extends and class_name the engine read, and a script declaring a class_name is put in the project's class list, with registered saying whether it is there. modify makes every addition or none, and answers with the line each one is on in the file written. rename renames a class or a member wherever the engine uses it and writes every file or none: changed lists each file with its changed lines as they now read, and leftAlone lists every other whole-word occurrence of the old name with what the tokenizer makes of it (code, string, comment, doc, nodePath, scene or text) and, where it is not plain, why: a find_children string, a word in a comment, a node named like the class, a call on a value whose type the analyser could not tell. Read leftAlone before calling the rename done; nothing in it was changed. Afterwards an open editor scans the changed files and reloads every changed script, which is also the compile check, and its answer comes back under editor; with no editor the class cache is rebuilt and the changed scripts are compiled in a fresh engine, under classCache and compiled.",
       parameters: {
         projectPath: PROJECT_PATH,
         scriptPath: SCRIPT_PATH,
@@ -17407,12 +17771,32 @@ var init_tool_definitions = __esm(() => {
           enum: ["singleton", "state_machine", "component", "resource"],
           description: "create: a starting shape."
         },
-        modifications: SCRIPT_MODIFICATIONS
+        modifications: SCRIPT_MODIFICATIONS,
+        symbol: {
+          type: "string",
+          ops: ["rename"],
+          description: "rename: what to rename, declared by the script at scriptPath: its class_name, or a method, variable, constant, signal, enum, enum value or inner class at its top level. A class is renamed from the files and needs no editor: every bare use in code, the declaration, doc links such as [Told] and [method Told.say], and the script_class a .tres records. A script that declares something of its own by the old name, and a use after a dot, are left alone, since which of those mean the class cannot be told from the text. A member is renamed from what the editor's language server resolves to it, so it needs the editor open on this project; a method is renamed together with every override of it in the classes inheriting it, and from the topmost class declaring it when scriptPath's is itself an override. Doc links naming the member through any class inheriting it are renamed too, and so are a scene's or resource's saved value of a variable on a node or resource whose script inherits it, and a connection naming the signal on its emitter or the method on its receiver. A name the engine itself declares on the native base, such as _ready, is refused, as is a new name already taken: by a class, an autoload, an identifier in code, a native class or built-in type, or a member anywhere in the class's chain."
+        },
+        newName: { type: "string", ops: ["rename"], description: "rename: the new name." },
+        newScriptPath: {
+          type: "string",
+          ops: ["rename"],
+          description: "rename: also move the declaring script here, with its .uid beside it, rewriting every string that names it by path in the same style it was written (res:// or relative), and the relative paths in the moved script itself."
+        },
+        preview: {
+          type: "boolean",
+          ops: ["rename"],
+          description: "rename: answer with what would change and what would be left alone, and write nothing. Default false."
+        }
       },
       requires: ["projectPath", "scriptPath"],
       operations: {
         create: { summary: "a new script file", requires: [] },
-        modify: { summary: "add to an existing script", requires: ["modifications"] }
+        modify: { summary: "add to an existing script", requires: ["modifications"] },
+        rename: {
+          summary: "rename a class or a member wherever the engine uses it, across the project",
+          requires: ["symbol", "newName"]
+        }
       }
     },
     {
@@ -17647,7 +18031,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "editor_status",
-      description: "Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and whether a game with the runtime addon is reachable: runtimeConnected counts the games of the project this server serves, and runtimes lists every game on the machine with ofThisProject saying which is which, since a game of another project is reached only by naming its projectPath. playingInEditor is null when the editor was not asked or did not answer, which is not the same as a no: with no editor connected there is nobody to ask, and an editor that does not serve the question is given a moment and then left. A game can be playing while this is null, so read it as unanswered rather than as nothing playing, and use processActive and runtimes, which come from elsewhere and do not depend on the editor answering. game.run names the run processActive is about, the one editor_output and editor_run stop answer for: its pid, its project, and adopted true when this server read it back from another server rather than starting it; null when there is none. editor.scan says whether the editor is scanning or importing and how many milliseconds ago its last scan finished (finishedMsAgo), or is null when it did not answer: the editor rewrites the class cache just after a scan, and editor_run waits that out before starting a game, saying so under waitedForEditorScanMs. Each game under runtimes is pinged with a short wait, so one held at a breakpoint is listed as unreachable rather than making this call wait out the runtime timeout; for the run this server is reporting on, heldAt says whether that is what it is, with the same three answers editor_output gives. A game the editor played announces the editor under editorPid, and so does whatever that game started for itself; a game some other server started announces none, which is how the two are told apart when both are running from one project. Each game also says which runtime addon it loaded, under addonVersion (null when it cannot say); addonIsStale is true when that code is not what this server ships, and staleNote says whether the project needs gdharness upgrade, the game a restart, or this server a reconnect. A second checkout of a project, such as a git worktree, carries addons of its own and is where this shows. Every runtime_* answer from such a game carries addonIsStale and staleNote too. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means \"not reached yet\" as often as it means \"no editor\". True is worth waiting out; false is an editor that is not there. False beside restartInterrupted is one that an editor_launch restart on a previous server asked to quit, where the launch half never ran because that server was ended in between, usually by the reconnect the restart was taken for; editor_launch open finishes it. True beside restartUnderway is a restart still in progress, its server alive and within the wait for the old editor to go: the editor is coming, and opening another would put two on one project. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. settingsDropped appears here once when the editor this server opened saved project.godot on its way in, which is the same reading editor_launch restart makes in its own answer. A game that has announced itself in a protocol this server does not speak is listed under unreadable rather than left out, with the protocol it speaks and whether the server or the addon is the older half. This happens during an upgrade that moves the runtime protocol, which most do not: installing replaces the addon on disk as soon as the pin moves, while a server that is already running stays on the version it started with, so the two speak different protocols until the server is reconnected. Those games are real and running, but no tool here can reach them until the halves match, so runtimes stays empty and runtimeConnected stays false. An upgrade that leaves the protocol alone opens no such window and this list stays empty through it. addonIsStale is decided by the code of the editor addons rather than their version, so an editor started before an upgrade that left that code alone reports the older addonVersion, is not stale, and addonNote says so: it needs no restart. port is the one the editor bridge is on; when that is not the one this server was configured with, portWanted names the configured one and portNote says why it moved and, when it was the server this one replaced, which pid kept it. A server replacing another of its project that holds the configured port waits for it to stand down and takes the port over, which takes a few seconds; bridgeHandover says so while it waits, and it moves only if that server has not let go within the wait. An editor that has connected and not yet greeted, which lasts a frame and longer while it imports, reports nothing about itself: greeting says so, addonIsStale is absent rather than guessed, and a restart asked then waits for the greeting to learn who opened it. startedByAnEditor is an editor another editor started, by Godot's own restart or the project manager, which has none of the arguments a server gave the one before it; startedByAnEditorNote says what that costs. An engine run that loads the editor addon to do one job and quit, such as a gate's godot --headless --import, an export or a script, is not taken as the editor: a process that greets without a server's mark has its command line read first, and while that is read identifying is true and connected false; one started with such an option is turned away, and turnedAway names the last one, its pid and the option.",
+      description: "Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and whether a game with the runtime addon is reachable: runtimeConnected counts the games of the project this server serves, and runtimes lists every game on the machine with ofThisProject saying which is which, since a game of another project is reached only by naming its projectPath. playingInEditor is null when the editor was not asked or did not answer, which is not the same as a no: with no editor connected there is nobody to ask, and an editor that does not serve the question is given a moment and then left. A game can be playing while this is null, so read it as unanswered rather than as nothing playing, and use processActive and runtimes, which come from elsewhere and do not depend on the editor answering. game.run names the run processActive is about, the one editor_output and editor_run stop answer for: its pid, its project, and adopted true when this server read it back from another server rather than starting it; null when there is none. editor.scan says whether the editor is scanning or importing and how many milliseconds ago its last scan finished (finishedMsAgo), or is null when it did not answer: the editor rewrites the class cache just after a scan, and editor_run waits that out before starting a game, saying so under waitedForEditorScanMs. Each game under runtimes is pinged with a short wait, so one held at a breakpoint is listed as unreachable rather than making this call wait out the runtime timeout; for the run this server is reporting on, heldAt says whether that is what it is, with the same three answers editor_output gives. A game the editor played announces the editor under editorPid, and so does whatever that game started for itself; a game some other server started announces none, which is how the two are told apart when both are running from one project. Each game also says which runtime addon it loaded, under addonVersion (null when it cannot say); addonIsStale is true when that code is not what this server ships, and staleNote says whether the project needs gdharness upgrade, the game a restart, or this server a reconnect. A second checkout of a project, such as a git worktree, carries addons of its own and is where this shows. Every runtime_* answer from such a game carries addonIsStale and staleNote too. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means \"not reached yet\" as often as it means \"no editor\". True is worth waiting out; false is an editor that is not there. False beside restartInterrupted is one that an editor_launch restart on a previous server asked to quit, where the launch half never ran because that server was ended in between, usually by the reconnect the restart was taken for; editor_launch open finishes it. True beside restartUnderway is a restart still in progress, its server alive and within the wait for the old editor to go: the editor is coming, and opening another would put two on one project. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. settingsDropped appears here once when the editor this server opened saved project.godot on its way in, which is the same reading editor_launch restart makes in its own answer. A game that has announced itself in a protocol this server does not speak is listed under unreadable rather than left out, with the protocol it speaks and whether the server or the addon is the older half. This happens during an upgrade that moves the runtime protocol, which most do not: installing replaces the addon on disk as soon as the pin moves, while a server that is already running stays on the version it started with, so the two speak different protocols until the server is reconnected. Those games are real and running, but no tool here can reach them until the halves match, so runtimes stays empty and runtimeConnected stays false. An upgrade that leaves the protocol alone opens no such window and this list stays empty through it. addonIsStale is decided by the code of the editor addons rather than their version, so an editor started before an upgrade that left that code alone reports the older addonVersion, is not stale, and addonNote says so: it needs no restart. port is the one the editor bridge is on; when that is not the one this server was configured with, portWanted names the configured one and portNote says why it moved and, when it was the server this one replaced, which pid kept it. A server replacing another of its project that holds the configured port waits for it to stand down and takes the port over, which takes a few seconds; bridgeHandover says so while it waits, and it moves only if that server has not let go within the wait. An editor that has connected and not yet greeted, which lasts a frame and longer while it imports, reports nothing about itself: greeting says so, addonIsStale is absent rather than guessed, and a restart asked then waits for the greeting to learn who opened it. startedByAnEditor is an editor another editor started, by Godot's own restart or the project manager, which has none of the arguments a server gave the one before it; startedByAnEditorNote says what that costs. An engine run that loads the editor addon to do one job and quit, such as a gate's godot --headless --import, an export or a script, is not taken as the editor: a process that greets without a server's mark has its command line read first, and while that is read identifying is true and connected false; one started with such an option is turned away, and turnedAway names the last one, its pid and the option. Every other call made while an editor is arriving, before its greeting or while it is looked up, waits up to ten seconds for it to settle rather than acting on connected as it reads in that window.",
       parameters: {},
       requires: []
     },
@@ -34440,7 +34824,7 @@ function theFirstOf(path) {
     closeSync(handle);
   }
 }
-function shapeOf(text) {
+function shapeOf2(text) {
   const values = [];
   let shape = "";
   let at = 0;
@@ -34470,7 +34854,7 @@ function shapeOf(text) {
 }
 function bursts(entries, before, keep) {
   const shapes = new Map;
-  const shaped = entries.map((entry) => shapeOf(entry.text));
+  const shaped = entries.map((entry) => shapeOf2(entry.text));
   for (const [at, entry] of entries.entries()) {
     const key = `${entry.severity}\x00${shaped[at]?.shape ?? entry.text}`;
     const group = shapes.get(key) ?? { indices: [], values: [] };
@@ -37648,6 +38032,10 @@ var init_godot_bridge = __esm(() => {
     isConnected() {
       return this.socket?.readyState === import_websocket.default.OPEN && this.connectionInfo?.identifying !== true;
     }
+    isArriving() {
+      const info = this.connectionInfo;
+      return this.socket?.readyState === import_websocket.default.OPEN && info !== null && (info.greeted !== true || info.identifying === true);
+    }
     getStatus() {
       const identifying = this.connectionInfo?.identifying === true;
       const editor = identifying ? null : this.connectionInfo;
@@ -37816,6 +38204,7 @@ var init_godot_bridge = __esm(() => {
             this.connectionInfo.startedByAnEditor = typeof message.started_by_an_editor === "boolean" ? message.started_by_an_editor : undefined;
             this.connectionInfo.syncsBreakpoints = typeof message.syncs_breakpoints === "boolean" ? message.syncs_breakpoints : undefined;
             this.log("info", `Godot ready: ${message.project_path}`);
+            this.connectionInfo.greeted = true;
             const pid = this.connectionInfo.editorPid;
             if (!this.connectionInfo.openedByAServer && pid !== undefined && this.oneShotReader !== null) {
               this.identify(pid);
@@ -38875,6 +39264,39 @@ class GodotLSPClient {
       }
     });
   }
+  async getReferences(filePath, content, line, character) {
+    await this.ensureConnected();
+    await this.ensureInitializedForFile(filePath);
+    const result = await this.withDocument(filePath, async () => {
+      const uri = this.syncDocument(filePath, content);
+      try {
+        return await this.sendRequest("textDocument/references", {
+          textDocument: { uri },
+          position: { line, character },
+          context: { includeDeclaration: true }
+        });
+      } finally {
+        this.closeDocument(uri);
+      }
+    });
+    return locationsIn(result);
+  }
+  async getDefinitions(filePath, content, line, character) {
+    await this.ensureConnected();
+    await this.ensureInitializedForFile(filePath);
+    const result = await this.withDocument(filePath, async () => {
+      const uri = this.syncDocument(filePath, content);
+      try {
+        return await this.sendRequest("textDocument/definition", {
+          textDocument: { uri },
+          position: { line, character }
+        });
+      } finally {
+        this.closeDocument(uri);
+      }
+    });
+    return locationsIn(result);
+  }
   async getDocumentSymbols(filePath, content) {
     await this.ensureConnected();
     await this.ensureInitializedForFile(filePath);
@@ -38894,6 +39316,22 @@ class GodotLSPClient {
     return this.connected;
   }
 }
+function locationsIn(result) {
+  const entries = Array.isArray(result) ? result : result === null || result === undefined ? [] : [result];
+  const found = [];
+  for (const entry of entries) {
+    const location = entry;
+    const uri = location.uri ?? location.targetUri;
+    const start = location.range?.start ?? location.targetSelectionRange?.start;
+    if (typeof uri !== "string" || typeof start?.line !== "number" || typeof start.character !== "number") {
+      continue;
+    }
+    try {
+      found.push({ file: fileURLToPath3(uri), line: start.line, character: start.character });
+    } catch {}
+  }
+  return found;
+}
 function asToolResponse(payload) {
   return {
     content: [
@@ -39187,6 +39625,35 @@ function scriptsWithoutUid(projectPath) {
 function isBinary(bytes) {
   return bytes.subarray(0, 8000).includes(0);
 }
+function projectTexts(projectPath) {
+  const found = [];
+  const visit = (directory, prefix) => {
+    if (steppedOver(directory)) {
+      return;
+    }
+    for (const entry of readdirSync7(directory, { withFileTypes: true })) {
+      if (skipped(entry.name)) {
+        continue;
+      }
+      const absolute = join20(directory, entry.name);
+      const spelled = `${prefix}${entry.name}`;
+      if (entry.isDirectory()) {
+        visit(absolute, `${spelled}/`);
+        continue;
+      }
+      const extension = entry.name.includes(".") ? entry.name.split(".").pop()?.toLowerCase() ?? "" : "";
+      if (!entry.isFile() || BINARY_EXTENSIONS.has(extension)) {
+        continue;
+      }
+      const bytes = readFileSync17(absolute);
+      if (!isBinary(bytes)) {
+        found.push({ path: `res://${spelled}`, absolute, text: bytes.toString("utf8") });
+      }
+    }
+  };
+  visit(projectPath, "");
+  return found;
+}
 function searchProject(projectPath, options) {
   const extensions = options.fileTypes === undefined ? null : new Set(options.fileTypes.map((ext) => ext.replace(/^\./, "").toLowerCase()).filter(Boolean));
   const result = {
@@ -39245,7 +39712,7 @@ function searchProject(projectPath, options) {
   visit(projectPath);
   return result;
 }
-var SKIPPED, SCENE_EXTENSIONS, ASSET_EXTENSIONS, CARRIES_A_UID;
+var SKIPPED, SCENE_EXTENSIONS, ASSET_EXTENSIONS, CARRIES_A_UID, BINARY_EXTENSIONS;
 var init_project_scan = __esm(() => {
   SKIPPED = new Set(["node_modules"]);
   SCENE_EXTENSIONS = new Set(["tscn", "scn"]);
@@ -39280,19 +39747,1050 @@ var init_project_scan = __esm(() => {
     "shader"
   ]);
   CARRIES_A_UID = new Set(["gd", "shader", "gdshader"]);
+  BINARY_EXTENSIONS = new Set([
+    ...[...ASSET_EXTENSIONS].filter((extension) => !["svg", "gltf", "gdshader", "shader", "fnt"].includes(extension)),
+    "scn",
+    "res",
+    "zip",
+    "pck",
+    "exe",
+    "dll",
+    "so",
+    "dylib"
+  ]);
+});
+
+// src/rename.ts
+import { existsSync as existsSync17, mkdirSync as mkdirSync10, readFileSync as readFileSync18, renameSync, unlinkSync as unlinkSync2, writeFileSync as writeFileSync12 } from "node:fs";
+import { dirname as dirname14, posix } from "node:path";
+
+class Script {
+  path;
+  text;
+  regions;
+  shape;
+  lines;
+  constructor(path, text) {
+    this.path = path;
+    this.text = text;
+    this.regions = regionsOf(text);
+    this.shape = shapeOf(text);
+    this.lines = new Lines(text);
+  }
+  occurrences(name) {
+    return occurrencesOf(this.text, name, this.regions);
+  }
+}
+function classId(file, inner) {
+  return `${file}#${inner.join(".")}`;
+}
+function fileOf(id) {
+  return id.slice(0, id.lastIndexOf("#"));
+}
+
+class ClassGraph {
+  nodes = new Map;
+  declared;
+  constructor(scripts, declared) {
+    this.declared = declared;
+    for (const script of scripts.values()) {
+      const add = (body, inner) => {
+        const id = classId(script.path, inner);
+        this.nodes.set(id, { id, file: script.path, inner, body, parent: null, native: null });
+        for (const child of body.inner) {
+          if (child.name !== null) {
+            add(child, [...inner, child.name]);
+          }
+        }
+      };
+      add(script.shape.body, []);
+    }
+    for (const node of this.nodes.values()) {
+      const resolved = this.resolve(node, node.body.extendsAs);
+      node.parent = resolved.id;
+      node.native = resolved.native;
+    }
+  }
+  resolve(node, written) {
+    if (written === null) {
+      return { id: null, native: "RefCounted" };
+    }
+    if (written.startsWith('"') || written.startsWith("'")) {
+      const path = resolvedPath(written.slice(1, -1), node.file);
+      const id = classId(path, []);
+      return this.nodes.has(id) ? { id, native: null } : { id: null, native: null };
+    }
+    const [first = "", ...rest] = written.split(".");
+    for (let depth = node.inner.length;depth >= 0; depth -= 1) {
+      const scope = this.nodes.get(classId(node.file, node.inner.slice(0, depth)));
+      if (scope?.body.inner.some((child) => child.name === first) === true) {
+        const id = classId(node.file, [...node.inner.slice(0, depth), first, ...rest]);
+        return this.nodes.has(id) ? { id, native: null } : { id: null, native: null };
+      }
+    }
+    const globalFile = this.declared.get(first);
+    if (globalFile !== undefined) {
+      const id = classId(globalFile, rest);
+      return this.nodes.has(id) ? { id, native: null } : { id: null, native: null };
+    }
+    return { id: null, native: rest.length === 0 ? first : null };
+  }
+  ancestors(id) {
+    const found = [];
+    let at = this.nodes.get(id)?.parent ?? null;
+    while (at !== null && !found.includes(at)) {
+      found.push(at);
+      at = this.nodes.get(at)?.parent ?? null;
+    }
+    return found;
+  }
+  nativeBase(id) {
+    const chain = [id, ...this.ancestors(id)];
+    return this.nodes.get(chain[chain.length - 1] ?? id)?.native ?? null;
+  }
+  descendants(id) {
+    const found = new Set([id]);
+    for (const node of this.nodes.values()) {
+      if (this.ancestors(node.id).includes(id)) {
+        found.add(node.id);
+      }
+    }
+    return found;
+  }
+  bodyAt(file, offset) {
+    let best = classId(file, []);
+    let depth = 0;
+    for (const node of this.nodes.values()) {
+      if (node.file === file && node.inner.length > depth && node.body.start <= offset && offset <= node.body.end) {
+        best = node.id;
+        depth = node.inner.length;
+      }
+    }
+    return best;
+  }
+  declaration(id, name) {
+    const found = this.nodes.get(id)?.body.declarations.find((one) => one.name === name);
+    return found === undefined ? undefined : { kind: found.kind, offset: found.offset };
+  }
+}
+function resolvedPath(written, from) {
+  if (written.startsWith("res://")) {
+    return `res://${posix.normalize(written.slice("res://".length))}`;
+  }
+  const directory = posix.dirname(from.slice("res://".length));
+  return `res://${posix.normalize(posix.join(directory, written))}`;
+}
+function relativeTo(target, from) {
+  return posix.relative(posix.dirname(from.slice("res://".length)), target.slice("res://".length));
+}
+function scriptsOf(texts) {
+  const scripts = new Map;
+  for (const file of texts) {
+    if (file.path.endsWith(".gd")) {
+      scripts.set(file.path, new Script(file.path, file.text));
+    }
+  }
+  return scripts;
+}
+function declaredIn(scripts) {
+  const declared = new Map;
+  for (const script of scripts.values()) {
+    if (script.shape.className !== null) {
+      declared.set(script.shape.className.name, script.path);
+    }
+  }
+  return declared;
+}
+function docLinkAt(text, offset) {
+  const lineStart = text.lastIndexOf(`
+`, offset - 1) + 1;
+  const nextBreak = text.indexOf(`
+`, offset);
+  const lineEnd = nextBreak < 0 ? text.length : nextBreak;
+  const open = text.lastIndexOf("[", offset);
+  const close = text.indexOf("]", offset);
+  if (open < lineStart || close === -1 || close > lineEnd) {
+    return null;
+  }
+  const inside = text.slice(open + 1, close);
+  if (inside.includes("[") || inside.includes("]")) {
+    return null;
+  }
+  const match = /^(?:([a-z_]+)\s+)?([\p{L}_][\p{L}\p{N}_]*(?:\.[\p{L}_][\p{L}\p{N}_]*)*)$/u.exec(inside);
+  if (match === null || match[1] !== undefined && !DOC_LINK_KINDS.has(match[1])) {
+    return null;
+  }
+  const parts = (match[2] ?? "").split(".");
+  const pathStart = open + 1 + inside.length - (match[2] ?? "").length;
+  let at = pathStart;
+  for (const [index, part] of parts.entries()) {
+    if (at === offset) {
+      return { kind: match[1] ?? null, parts, index };
+    }
+    at += part.length + 1;
+  }
+  return null;
+}
+
+class PlanBuilder {
+  edits = new Map;
+  mentions = [];
+  oldName;
+  newName;
+  constructor(oldName, newName) {
+    this.oldName = oldName;
+    this.newName = newName;
+  }
+  edit(file, offset, kind, length = this.oldName.length, replacement = this.newName) {
+    const key = `${file}:${offset}`;
+    if (!this.edits.has(key)) {
+      this.edits.set(key, { file, offset, length, replacement, kind });
+    }
+  }
+  edited(file, offset) {
+    return this.edits.has(`${file}:${offset}`);
+  }
+  mention(file, lines, offset, kind, why) {
+    this.mentions.push({
+      file,
+      line: lines.positionOf(offset).line + 1,
+      kind,
+      text: lines.lineAt(offset).trim(),
+      ...why === undefined ? {} : { why }
+    });
+  }
+  mentionTheRest(texts, scripts, whyFor) {
+    const already = new Set(this.mentions.map((one) => `${one.file}:${one.line}:${one.kind}:${one.text}`));
+    for (const file of texts) {
+      const script = scripts.get(file.path);
+      const lines = script?.lines ?? new Lines(file.text);
+      const occurrences = script?.occurrences(this.oldName) ?? occurrencesOf(file.text, this.oldName, [{ kind: "code", start: 0, end: file.text.length }]);
+      for (const occurrence of occurrences) {
+        if (this.edited(file.path, occurrence.offset)) {
+          continue;
+        }
+        const kind = script !== undefined ? occurrence.kind : /\.(tscn|tres)$/.test(file.path) ? "scene" : "text";
+        const why = whyFor(file.path, occurrence, kind);
+        const key = `${file.path}:${lines.positionOf(occurrence.offset).line + 1}:${kind}:${lines.lineAt(occurrence.offset).trim()}`;
+        if (already.has(key)) {
+          continue;
+        }
+        already.add(key);
+        this.mention(file.path, lines, occurrence.offset, kind, why);
+      }
+    }
+  }
+  build() {
+    const edits = [...this.edits.values()].sort((a, b) => a.file.localeCompare(b.file) || a.offset - b.offset);
+    const mentions = [...this.mentions].sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
+    return { edits, mentions };
+  }
+}
+function declaresItsOwn(script, name, except) {
+  return script.occurrences(name).some((occurrence) => occurrence.kind === "code" && occurrence.offset !== except && occurrence.declaredAs !== null && occurrence.declaredAs !== "class_name");
+}
+function planClassRename(args) {
+  const { texts, scripts, declaring, oldName, newName } = args;
+  const plan = new PlanBuilder(oldName, newName);
+  const declarationAt = declaring.shape.className?.offset ?? null;
+  for (const script of scripts.values()) {
+    const ownDeclaration = script.path === declaring.path ? declarationAt : null;
+    const shadowed = declaresItsOwn(script, oldName, ownDeclaration);
+    for (const occurrence of script.occurrences(oldName)) {
+      if (occurrence.kind === "code") {
+        if (occurrence.offset === ownDeclaration) {
+          plan.edit(script.path, occurrence.offset, "declaration");
+        } else if (!shadowed && !occurrence.afterDot && occurrence.declaredAs === null) {
+          plan.edit(script.path, occurrence.offset, "code");
+        }
+      } else if (occurrence.kind === "doc") {
+        const link = docLinkAt(script.text, occurrence.offset);
+        if (link?.index === 0 && !shadowed) {
+          plan.edit(script.path, occurrence.offset, "doc link");
+        }
+      }
+    }
+  }
+  for (const file of texts) {
+    if (!/\.(tscn|tres)$/.test(file.path)) {
+      continue;
+    }
+    for (const section of sectionsOf(file.text)) {
+      if (section.kind === "gd_resource" || section.kind === "gd_scene") {
+        const recorded = section.attributes.get("script_class");
+        if (recorded?.value === oldName) {
+          plan.edit(file.path, recorded.offset, "resource class");
+        }
+      }
+    }
+  }
+  plan.mentionTheRest(texts, scripts, (file, occurrence, kind) => {
+    const script = scripts.get(file);
+    if (kind !== "code" || script === undefined) {
+      return;
+    }
+    if (occurrence.declaredAs === "class_name") {
+      return `this script declares a class of the same name`;
+    }
+    if (occurrence.declaredAs !== null || declaresItsOwn(script, oldName, null)) {
+      return `this script declares something of its own named ${oldName}, so which uses mean the class cannot be told from the text`;
+    }
+    if (occurrence.afterDot) {
+      return `after a dot, a member of something else rather than the class`;
+    }
+    return;
+  });
+  return plan.build();
+}
+function planMemberRename(args) {
+  const { texts, scripts, graph, root, family, kind, oldName, newName, resolved } = args;
+  const plan = new PlanBuilder(oldName, newName);
+  const heirs = graph.descendants(root);
+  const docKind = DOC_KIND[kind];
+  const familyAt = new Set(family.map((one) => `${one.file}:${one.offset}`));
+  for (const one of family) {
+    plan.edit(one.file, one.offset, "declaration");
+  }
+  for (const one of resolved) {
+    const script = scripts.get(one.file);
+    if (script === undefined || script.text.slice(one.offset, one.offset + oldName.length) !== oldName) {
+      continue;
+    }
+    const occurrence = script.occurrences(oldName).find((each) => each.offset === one.offset);
+    if (occurrence === undefined) {
+      continue;
+    }
+    if (occurrence.kind === "code") {
+      plan.edit(one.file, one.offset, familyAt.has(`${one.file}:${one.offset}`) ? "declaration" : "code");
+    } else if (occurrence.kind === "doc" && docLinkAt(script.text, one.offset) !== null) {
+      plan.edit(one.file, one.offset, "doc link");
+    } else {
+      plan.mention(one.file, script.lines, one.offset, occurrence.kind, `the language server resolved this to the ${kind === "func" ? "method" : "member"}, and it is inside ${occurrence.kind === "string" ? "a string" : occurrence.kind === "nodePath" ? "a node path" : "a comment"}, so it is left for you`);
+    }
+  }
+  for (const script of scripts.values()) {
+    for (const occurrence of script.occurrences(oldName)) {
+      if (occurrence.kind !== "doc") {
+        continue;
+      }
+      const link = docLinkAt(script.text, occurrence.offset);
+      if (link === null || link.index !== link.parts.length - 1 || link.kind !== docKind || docKind === null) {
+        continue;
+      }
+      const qualifiers = link.parts.slice(0, -1);
+      let owner = null;
+      if (qualifiers.length === 0) {
+        owner = graph.bodyAt(script.path, occurrence.offset);
+      } else {
+        const [first = "", ...rest] = qualifiers;
+        const file = graph.declared.get(first);
+        owner = file === undefined ? null : `${file}#${rest.join(".")}`;
+      }
+      if (owner !== null && heirs.has(owner)) {
+        plan.edit(script.path, occurrence.offset, "doc link");
+      }
+    }
+  }
+  planScenes(texts, heirs, kind, oldName, plan);
+  plan.mentionTheRest(texts, scripts, (_file, occurrence, mentionKind) => mentionKind === "code" ? occurrence.afterDot ? "not resolved to this member by the language server: another class with a member of the same name, or a value whose type the analyser could not tell" : "not resolved to this member by the language server" : undefined);
+  return plan.build();
+}
+function sectionsOf(text) {
+  const sections = [];
+  let current = null;
+  let depth = 0;
+  let inString = false;
+  let offset = 0;
+  for (const line of text.split(`
+`)) {
+    const atTop = depth === 0 && !inString;
+    const header = atTop ? /^\[([a-z_]+)(.*)\]\s*$/.exec(line.replace(/\r$/, "")) : null;
+    if (header !== null) {
+      const attributes = new Map;
+      const rest = header[2] ?? "";
+      const restAt = offset + 1 + (header[1]?.length ?? 0);
+      for (const attribute of rest.matchAll(/([a-z_]+)=("(?:[^"\\]|\\.)*"|[A-Za-z]+\("(?:[^"\\]|\\.)*"\)|[^\s\]]+)/g)) {
+        const raw = attribute[2] ?? "";
+        const quoted = raw.startsWith('"');
+        attributes.set(attribute[1] ?? "", {
+          value: quoted ? raw.slice(1, -1) : raw,
+          offset: restAt + attribute.index + (attribute[1]?.length ?? 0) + 1 + (quoted ? 1 : 0)
+        });
+      }
+      current = { kind: header[1] ?? "", attributes, properties: [] };
+      sections.push(current);
+    } else if (atTop && current !== null) {
+      const property = /^([A-Za-z_][\w/:]*) = (.*)$/.exec(line.replace(/\r$/, ""));
+      if (property !== null) {
+        current.properties.push({ key: property[1] ?? "", offset, value: property[2] ?? "" });
+      }
+    }
+    for (let at = 0;at < line.length; at += 1) {
+      const character = line[at];
+      if (inString) {
+        if (character === "\\") {
+          at += 1;
+        } else if (character === '"') {
+          inString = false;
+        }
+      } else if (character === '"') {
+        inString = true;
+      } else if (character === "[" || character === "{" || character === "(") {
+        depth += 1;
+      } else if (character === "]" || character === "}" || character === ")") {
+        depth = Math.max(0, depth - 1);
+      }
+    }
+    if (header !== null) {
+      depth = 0;
+    }
+    offset += line.length + 1;
+  }
+  return sections;
+}
+function resourceReference(value) {
+  const match = /^(Ext|Sub)Resource\(\s*"([^"]*)"\s*\)$/.exec(value.trim());
+  return match === null ? null : { external: match[1] === "Ext", id: match[2] ?? "" };
+}
+
+class SceneReader {
+  cache = new Map;
+  texts;
+  uids;
+  constructor(texts, uids) {
+    this.texts = texts;
+    this.uids = uids;
+  }
+  sections(path) {
+    let found = this.cache.get(path);
+    if (found === undefined) {
+      const text = this.texts.get(path);
+      found = text === undefined ? [] : sectionsOf(text);
+      this.cache.set(path, found);
+    }
+    return found;
+  }
+  external(path, id) {
+    const entry = this.sections(path).find((section) => section.kind === "ext_resource" && section.attributes.get("id")?.value === id);
+    if (entry === undefined) {
+      return null;
+    }
+    const written = entry.attributes.get("path")?.value;
+    if (written !== undefined) {
+      return resolvedPath(written, path);
+    }
+    const uid = entry.attributes.get("uid")?.value;
+    return uid === undefined ? null : this.uids.get(uid) ?? null;
+  }
+  scriptOf(path, section, depth = 0) {
+    const script = section.properties.find((property) => property.key === "script");
+    if (script !== undefined) {
+      const reference = resourceReference(script.value);
+      return reference?.external === true ? this.external(path, reference.id) : null;
+    }
+    const instance = section.attributes.get("instance")?.value;
+    const reference = instance === undefined ? null : resourceReference(instance);
+    if (reference?.external !== true || depth > 8) {
+      return null;
+    }
+    const scene = this.external(path, reference.id);
+    if (scene === null) {
+      return null;
+    }
+    const rootNode = this.sections(scene).find((candidate) => candidate.kind === "node" && !candidate.attributes.has("parent"));
+    return rootNode === undefined ? null : this.scriptOf(scene, rootNode, depth + 1);
+  }
+  nodesByPath(path) {
+    const nodes = new Map;
+    for (const section of this.sections(path)) {
+      if (section.kind !== "node") {
+        continue;
+      }
+      const name = section.attributes.get("name")?.value ?? "";
+      const parent = section.attributes.get("parent")?.value;
+      nodes.set(parent === undefined ? "." : parent === "." ? name : `${parent}/${name}`, section);
+    }
+    return nodes;
+  }
+}
+function planScenes(texts, heirs, kind, oldName, plan) {
+  const byPath = new Map(texts.map((file) => [file.path, file.text]));
+  const uids = new Map;
+  for (const file of texts) {
+    if (file.path.endsWith(".uid")) {
+      uids.set(file.text.trim(), file.path.slice(0, -".uid".length));
+    }
+  }
+  const reader = new SceneReader(byPath, uids);
+  const inherits = (script) => script !== null && heirs.has(`${script}#`);
+  for (const file of texts) {
+    if (!/\.(tscn|tres)$/.test(file.path) || !file.text.includes(oldName)) {
+      continue;
+    }
+    const sections = reader.sections(file.path);
+    if (kind === "var") {
+      for (const section of sections) {
+        if (!["node", "resource", "sub_resource"].includes(section.kind)) {
+          continue;
+        }
+        const property = section.properties.find((one) => one.key === oldName);
+        if (property !== undefined && inherits(reader.scriptOf(file.path, section))) {
+          plan.edit(file.path, property.offset, "scene property");
+        }
+      }
+    }
+    if (kind === "signal" || kind === "func") {
+      const nodes = reader.nodesByPath(file.path);
+      for (const section of sections) {
+        if (section.kind !== "connection") {
+          continue;
+        }
+        const attribute = section.attributes.get(kind === "signal" ? "signal" : "method");
+        const node = nodes.get(section.attributes.get(kind === "signal" ? "from" : "to")?.value ?? "");
+        if (attribute?.value === oldName && node !== undefined && inherits(reader.scriptOf(file.path, node))) {
+          plan.edit(file.path, attribute.offset, "scene connection");
+        }
+      }
+    }
+  }
+}
+function literalsOf(file, script) {
+  const found = [];
+  if (script !== undefined) {
+    for (const region of script.regions) {
+      if (region.kind !== "string") {
+        continue;
+      }
+      const literal = file.text.slice(region.start, region.end);
+      const quote = /["']/.exec(literal);
+      if (quote === null || literal.startsWith('"""', quote.index) || literal.startsWith("'''", quote.index)) {
+        continue;
+      }
+      found.push({ offset: region.start + quote.index + 1, value: literal.slice(quote.index + 1, -1) });
+    }
+    return found;
+  }
+  for (const match of file.text.matchAll(/"((?:[^"\\\n]|\\.)*)"/g)) {
+    found.push({ offset: match.index + 1, value: match[1] ?? "" });
+  }
+  return found;
+}
+function planMove(args, plan) {
+  const { texts, scripts, from, to, exists } = args;
+  const edits = [...plan.edits];
+  const mentions = [...plan.mentions];
+  const editedAt = new Set(edits.map((one) => `${one.file}:${one.offset}`));
+  const add = (file, offset, length, replacement) => {
+    if (!editedAt.has(`${file}:${offset}`)) {
+      editedAt.add(`${file}:${offset}`);
+      edits.push({ file, offset, length, replacement, kind: "path" });
+    }
+  };
+  for (const file of texts) {
+    const script = scripts.get(file.path);
+    for (const literal of literalsOf(file, script)) {
+      const autoload = literal.value.startsWith("*") ? "*" : "";
+      const written = literal.value.slice(autoload.length);
+      if (written === "" || written.startsWith("uid://") || written.includes(`
+`)) {
+        continue;
+      }
+      const isAbsolute = written.startsWith("res://");
+      const target = resolvedPath(written, file.path);
+      if (target === from) {
+        const replacement = isAbsolute ? to : relativeTo(to, file.path === from ? to : file.path);
+        add(file.path, literal.offset + autoload.length, written.length, replacement);
+      } else if (file.path === from && !isAbsolute && /\.[a-z0-9]+$/i.test(written) && exists(target)) {
+        add(file.path, literal.offset, written.length, relativeTo(target, to));
+      }
+    }
+    const lines = script?.lines ?? new Lines(file.text);
+    for (const match of file.text.matchAll(new RegExp(from.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&"), "g"))) {
+      const offset = match.index;
+      const covered = edits.some((one) => one.file === file.path && one.offset <= offset && offset < one.offset + one.length);
+      if (!covered) {
+        const region = script?.regions.find((one) => one.start <= offset && offset < one.end);
+        mentions.push({
+          file: file.path,
+          line: lines.positionOf(offset).line + 1,
+          kind: region !== undefined ? region.kind : /\.(tscn|tres)$/.test(file.path) ? "scene" : "text",
+          text: lines.lineAt(offset).trim(),
+          why: `names ${from} outside a string the engine reads as a path`
+        });
+      }
+    }
+  }
+  return {
+    edits: edits.sort((a, b) => a.file.localeCompare(b.file) || a.offset - b.offset),
+    mentions: mentions.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line)
+  };
+}
+function rewritesOf(plan, texts, move) {
+  const byPath = new Map(texts.map((file) => [file.path, file]));
+  const byFile = new Map;
+  for (const edit of plan.edits) {
+    byFile.set(edit.file, [...byFile.get(edit.file) ?? [], edit]);
+  }
+  if (move !== null && !byFile.has(move.from)) {
+    byFile.set(move.from, []);
+  }
+  const rewrites = [];
+  for (const [path, edits] of byFile) {
+    const file = byPath.get(path);
+    if (file === undefined) {
+      continue;
+    }
+    let after = file.text;
+    let lastStart = Number.POSITIVE_INFINITY;
+    for (const edit of [...edits].sort((a, b) => b.offset - a.offset)) {
+      if (edit.offset + edit.length > lastStart) {
+        throw new Error(`two edits overlap in ${path} at offset ${edit.offset}`);
+      }
+      after = after.slice(0, edit.offset) + edit.replacement + after.slice(edit.offset + edit.length);
+      lastStart = edit.offset;
+    }
+    rewrites.push({
+      path,
+      absolute: file.absolute,
+      before: file.text,
+      after,
+      writeTo: move?.from === path ? move.absoluteTo : file.absolute
+    });
+  }
+  return rewrites.sort((a, b) => a.path.localeCompare(b.path));
+}
+function applyRewrites(rewrites) {
+  for (const rewrite of rewrites) {
+    const now = readFileSync18(rewrite.absolute, "utf8");
+    if (now !== rewrite.before) {
+      throw new Error(`${rewrite.path} changed on disk while the rename was being worked out; nothing was written`);
+    }
+    if (rewrite.writeTo !== rewrite.absolute && existsSync17(rewrite.writeTo)) {
+      throw new Error(`${rewrite.writeTo} already exists; nothing was written`);
+    }
+  }
+  const done = [];
+  try {
+    for (const rewrite of rewrites) {
+      mkdirSync10(dirname14(rewrite.writeTo), { recursive: true });
+      const staging = `${rewrite.writeTo}.gdharness-rename`;
+      writeFileSync12(staging, rewrite.after, "utf8");
+      renameSync(staging, rewrite.writeTo);
+      let movedUid = false;
+      if (rewrite.writeTo !== rewrite.absolute) {
+        unlinkSync2(rewrite.absolute);
+        if (existsSync17(`${rewrite.absolute}.uid`)) {
+          renameSync(`${rewrite.absolute}.uid`, `${rewrite.writeTo}.uid`);
+          movedUid = true;
+        }
+      }
+      done.push({ rewrite, movedUid });
+    }
+  } catch (error) {
+    for (const { rewrite, movedUid } of done.reverse()) {
+      try {
+        writeFileSync12(rewrite.absolute, rewrite.before, "utf8");
+        if (rewrite.writeTo !== rewrite.absolute) {
+          unlinkSync2(rewrite.writeTo);
+          if (movedUid) {
+            renameSync(`${rewrite.writeTo}.uid`, `${rewrite.absolute}.uid`);
+          }
+        }
+      } catch {}
+    }
+    throw error;
+  }
+}
+var DOC_LINK_KINDS, DOC_KIND;
+var init_rename = __esm(() => {
+  init_gdscript_source();
+  DOC_LINK_KINDS = new Set([
+    "method",
+    "member",
+    "signal",
+    "constant",
+    "enum",
+    "annotation",
+    "theme_item"
+  ]);
+  DOC_KIND = {
+    func: "method",
+    var: "member",
+    signal: "signal",
+    const: "constant",
+    enumValue: "constant",
+    enum: "enum",
+    class: null
+  };
+});
+
+// src/rename-symbol.ts
+import { existsSync as existsSync18, realpathSync as realpathSync5 } from "node:fs";
+import { basename as basename5, dirname as dirname15, join as join21, relative as relative4, resolve as resolve6 } from "node:path";
+function resourcePathOf(projectPath, absolute) {
+  const inside = relative4(onDiskSpelling(projectPath), onDiskSpelling(absolute));
+  if (inside === "" || inside.startsWith("..") || /^[A-Za-z]:/.test(inside)) {
+    return null;
+  }
+  return `res://${inside.replace(/\\/g, "/")}`;
+}
+function onDiskSpelling(path) {
+  const missing = [];
+  let at = resolve6(path);
+  for (;; ) {
+    try {
+      return join21(realpathSync5.native(at), ...missing.reverse());
+    } catch {
+      const parent = dirname15(at);
+      if (parent === at) {
+        return resolve6(path);
+      }
+      missing.push(basename5(at));
+      at = parent;
+    }
+  }
+}
+function usedAsIdentifier(scripts, name, most) {
+  const found = [];
+  for (const script of scripts.values()) {
+    for (const occurrence of script.occurrences(name)) {
+      if (occurrence.kind === "code" && !occurrence.afterDot) {
+        found.push(`${script.path}:${script.lines.positionOf(occurrence.offset).line + 1}`);
+        if (found.length >= most) {
+          return found;
+        }
+      }
+    }
+  }
+  return found;
+}
+function autoloadNames(texts) {
+  const settings = texts.find((file) => file.path === "res://project.godot");
+  return settings === undefined ? [] : Object.keys(parseProjectGodot(settings.text)["autoload"] ?? {});
+}
+async function renameSymbol(request, services) {
+  const { projectPath, symbol, newName } = request;
+  if (!isIdentifier(newName)) {
+    return {
+      ok: false,
+      reason: `${newName} is not a name GDScript accepts: a letter or underscore, then letters, digits and underscores, and not a keyword.`
+    };
+  }
+  if (newName === symbol) {
+    return { ok: false, reason: `${symbol} is already called ${newName}; nothing to rename.` };
+  }
+  const declaringPath = resourcePathOf(projectPath, request.scriptPath);
+  if (declaringPath === null) {
+    return { ok: false, reason: `${request.scriptPath} is not inside the project.` };
+  }
+  let moveTo = null;
+  if (request.newScriptPath !== null) {
+    moveTo = resourcePathOf(projectPath, request.newScriptPath);
+    if (moveTo === null || !moveTo.endsWith(".gd")) {
+      return {
+        ok: false,
+        reason: `newScriptPath must be a .gd path inside the project, and ${request.newScriptPath} is not.`
+      };
+    }
+    if (existsSync18(request.newScriptPath)) {
+      return { ok: false, reason: `${moveTo} already exists, so the script cannot be moved there.` };
+    }
+  }
+  const texts = projectTexts(projectPath);
+  const scripts = scriptsOf(texts);
+  const declaring = scripts.get(declaringPath);
+  if (declaring === undefined) {
+    return {
+      ok: false,
+      reason: `${declaringPath} is not among the scripts the engine sees: it is under a directory holding a .gdignore, or one spelled with a dot.`
+    };
+  }
+  const declared = declaredIn(scripts);
+  const isClass = declaring.shape.className?.name === symbol;
+  let plan;
+  let what;
+  let resolvedBy;
+  let overrides = [];
+  let declaringFiles = [declaringPath];
+  if (isClass) {
+    what = "class";
+    resolvedBy = "the files";
+    const conflicts = [];
+    const holder = declared.get(newName);
+    if (holder !== undefined) {
+      conflicts.push(`${newName} is already the class_name of ${holder}`);
+    }
+    if (autoloadNames(texts).includes(newName)) {
+      conflicts.push(`${newName} is already an autoload in project.godot`);
+    }
+    for (const place of usedAsIdentifier(scripts, newName, 10)) {
+      conflicts.push(`${newName} is already an identifier at ${place}`);
+    }
+    const taken = (await services.namesTaken([newName], null))[newName];
+    if (taken !== undefined && taken.as.length > 0) {
+      conflicts.push(`${newName} is ${taken.as.join(" and ")}`);
+    }
+    if (conflicts.length > 0) {
+      return {
+        ok: false,
+        reason: `${symbol} cannot be renamed to ${newName}: the name is taken.`,
+        conflicts
+      };
+    }
+    plan = planClassRename({ texts, scripts, declaring, oldName: symbol, newName });
+  } else {
+    const declaration = declaring.shape.body.declarations.find((one) => one.name === symbol);
+    if (declaration === undefined) {
+      const names = [
+        ...declaring.shape.className === null ? [] : [declaring.shape.className.name],
+        ...declaring.shape.body.declarations.map((one) => one.name)
+      ];
+      return {
+        ok: false,
+        reason: `${declaringPath} declares no ${symbol} at its top level. What it declares there: ${names.join(", ") || "nothing"}. A local variable or a member of an inner class is not renamed by this call.`
+      };
+    }
+    const kind = declaration.kind;
+    what = WHAT[kind];
+    resolvedBy = "the editor's language server";
+    const graph = new ClassGraph(scripts, declared);
+    const own = `${declaringPath}#`;
+    let root = own;
+    if (kind === "func") {
+      for (const ancestor of graph.ancestors(own)) {
+        if (graph.declaration(ancestor, symbol)?.kind === "func") {
+          root = ancestor;
+        }
+      }
+    }
+    const native = graph.nativeBase(root);
+    const taken = await services.namesTaken([symbol, newName], native);
+    const engineOwned = taken[symbol]?.declaredBy ?? null;
+    if (engineOwned !== null) {
+      return {
+        ok: false,
+        reason: `${symbol} is declared by the engine's ${engineOwned}, which ${root === own ? declaringPath : fileOf(root)} inherits from, so the script ${kind === "func" ? "overrides" : "shadows"} an engine name rather than declaring its own, and the engine calls it by that name.`
+      };
+    }
+    const conflicts = [];
+    const newOwner = taken[newName]?.declaredBy ?? null;
+    if (newOwner !== null) {
+      conflicts.push(`${newName} is declared by the engine's ${newOwner}, which this class inherits from`);
+    }
+    for (const id of new Set([root, ...graph.ancestors(root), ...graph.descendants(root)])) {
+      if (graph.declaration(id, newName) !== undefined) {
+        conflicts.push(`${newName} is already declared in ${id.endsWith("#") ? fileOf(id) : `${fileOf(id)}, class ${id.slice(id.lastIndexOf("#") + 1)}`}`);
+      }
+    }
+    if (conflicts.length > 0) {
+      return {
+        ok: false,
+        reason: `${symbol} cannot be renamed to ${newName}: the name is taken.`,
+        conflicts
+      };
+    }
+    const family = [];
+    if (kind === "func") {
+      for (const id of graph.descendants(root)) {
+        const found = graph.declaration(id, symbol);
+        if (found?.kind === "func") {
+          family.push({ file: fileOf(id), offset: found.offset });
+        }
+      }
+    } else {
+      family.push({ file: declaringPath, offset: declaration.offset });
+    }
+    overrides = family.map((one) => one.file).filter((file) => file !== fileOf(root));
+    declaringFiles = family.map((one) => one.file);
+    const resolved = await resolveMember(projectPath, texts, scripts, family, symbol, services);
+    if (resolved === null) {
+      const first = family[0];
+      const script = first === undefined ? undefined : scripts.get(first.file);
+      const line = first === undefined || script === undefined ? 0 : script.lines.positionOf(first.offset).line + 1;
+      return {
+        ok: false,
+        reason: `The language server resolved nothing at ${first?.file ?? declaringPath}:${line}, where ${symbol} is declared, not even the declaration, so it is not analysing that script and its answer would rename nothing.`,
+        advice: [
+          "script_diagnostics on that script says whether the editor can parse it",
+          "editor_status says whether the editor connected is this project's"
+        ]
+      };
+    }
+    plan = planMemberRename({
+      texts,
+      scripts,
+      graph,
+      root,
+      family,
+      kind,
+      oldName: symbol,
+      newName,
+      resolved
+    });
+  }
+  if (moveTo !== null) {
+    plan = planMove({
+      texts,
+      scripts,
+      from: declaringPath,
+      to: moveTo,
+      exists: (path) => existsSync18(`${projectPath}/${path.slice("res://".length)}`)
+    }, plan);
+  }
+  const rewrites = rewritesOf(plan, texts, moveTo === null || request.newScriptPath === null ? null : { from: declaringPath, to: moveTo, absoluteTo: request.newScriptPath });
+  const graph = new ClassGraph(scripts, declared);
+  const rank = (path) => (declaringFiles.includes(path) ? 0 : 1000) + graph.ancestors(`${path}#`).length;
+  const scriptsInOrder = rewrites.map((rewrite) => rewrite.path).filter((path) => path.endsWith(".gd")).sort((a, b) => rank(a) - rank(b) || a.localeCompare(b)).map((path) => path === declaringPath && moveTo !== null ? moveTo : path);
+  return {
+    ok: true,
+    isClass,
+    moved: moveTo === null ? null : { from: declaringPath, to: moveTo },
+    scriptsInOrder,
+    rewrites,
+    report: {
+      renamed: { what, from: symbol, to: newName, declaredIn: declaringPath, resolvedBy },
+      ...overrides.length > 0 ? { overridesRenamed: overrides } : {},
+      ...moveTo === null ? {} : { moved: { from: declaringPath, to: moveTo } },
+      changed: changedReport(plan.edits, rewrites),
+      leftAlone: plan.mentions,
+      summary: summaryOf(plan.edits, plan.mentions, rewrites)
+    }
+  };
+}
+async function resolveMember(projectPath, texts, scripts, family, name, services) {
+  const absoluteOf = new Map(texts.map((file) => [file.path, file.absolute]));
+  const key = (place) => `${place.file}:${place.offset}`;
+  const toResolved = (located) => {
+    const file = resourcePathOf(projectPath, located.file);
+    const offset = file === null ? null : scripts.get(file)?.lines.offsetOf(located);
+    return file === null || offset === null || offset === undefined ? null : { file, offset };
+  };
+  const ask = async (question, place) => {
+    const script = scripts.get(place.file);
+    const absolute = absoluteOf.get(place.file);
+    if (script === undefined || absolute === undefined) {
+      return [];
+    }
+    const answered = await services[question](absolute, script.text, script.lines.positionOf(place.offset));
+    return answered.map(toResolved).filter((one) => one !== null);
+  };
+  const ours = new Map;
+  const settled = new Set;
+  const root = family[0];
+  if (root === undefined) {
+    return [];
+  }
+  const seeded = await ask("references", root);
+  if (seeded.length === 0) {
+    return null;
+  }
+  for (const place of seeded) {
+    ours.set(key(place), place);
+  }
+  const declarations = new Set(family.map(key));
+  for (const script of scripts.values()) {
+    for (const occurrence of script.occurrences(name)) {
+      const place = { file: script.path, offset: occurrence.offset };
+      if (occurrence.kind !== "code" || ours.has(key(place)) || settled.has(key(place))) {
+        continue;
+      }
+      const declared = await ask("definitions", place);
+      const only = declared.length === 1 ? declared[0] : undefined;
+      if (only === undefined) {
+        settled.add(key(place));
+        continue;
+      }
+      const isOurs = declarations.has(key(only));
+      const same = [place, ...await ask("references", place)];
+      for (const one of same) {
+        if (isOurs) {
+          ours.set(key(one), one);
+        } else {
+          settled.add(key(one));
+        }
+      }
+    }
+  }
+  return [...ours.values()];
+}
+function changedReport(edits, rewrites) {
+  return rewrites.map((rewrite) => {
+    const lines = rewrite.after.split(`
+`);
+    const byLine = new Map;
+    const starts = [0];
+    for (let at = rewrite.before.indexOf(`
+`);at !== -1; at = rewrite.before.indexOf(`
+`, at + 1)) {
+      starts.push(at + 1);
+    }
+    let count = 0;
+    for (const edit of edits) {
+      if (edit.file !== rewrite.path) {
+        continue;
+      }
+      count += 1;
+      let line = 0;
+      while (line + 1 < starts.length && (starts[line + 1] ?? 0) <= edit.offset) {
+        line += 1;
+      }
+      byLine.set(line, (byLine.get(line) ?? new Set).add(edit.kind));
+    }
+    return {
+      file: rewrite.path,
+      edits: count,
+      lines: [...byLine.entries()].sort(([a], [b]) => a - b).map(([line, kinds]) => ({
+        line: line + 1,
+        kinds: [...kinds],
+        text: (lines[line] ?? "").replace(/\r$/, "").trim()
+      }))
+    };
+  });
+}
+function summaryOf(edits, mentions, rewrites) {
+  const count = (values) => {
+    const counted = {};
+    for (const value of values) {
+      counted[value] = (counted[value] ?? 0) + 1;
+    }
+    return counted;
+  };
+  return {
+    filesChanged: rewrites.length,
+    edits: edits.length,
+    editsByKind: count(edits.map((edit) => edit.kind)),
+    leftAlone: mentions.length,
+    leftAloneByKind: count(mentions.map((mention) => mention.kind))
+  };
+}
+var WHAT;
+var init_rename_symbol = __esm(() => {
+  init_gdscript_source();
+  init_project_scan();
+  init_rename();
+  init_resources();
+  WHAT = {
+    func: "method",
+    var: "variable",
+    const: "constant",
+    signal: "signal",
+    enum: "enum",
+    class: "inner class",
+    enumValue: "enum value"
+  };
 });
 
 // src/restart-note.ts
-import { mkdirSync as mkdirSync10, readFileSync as readFileSync18, rmSync as rmSync9, writeFileSync as writeFileSync12 } from "node:fs";
-import { dirname as dirname14, join as join21 } from "node:path";
+import { mkdirSync as mkdirSync11, readFileSync as readFileSync19, rmSync as rmSync9, writeFileSync as writeFileSync13 } from "node:fs";
+import { dirname as dirname16, 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 {
-    mkdirSync10(dirname14(path), { recursive: true });
-    writeFileSync12(path, `${JSON.stringify(note, null, 2)}
+    mkdirSync11(dirname16(path), { recursive: true });
+    writeFileSync13(path, `${JSON.stringify(note, null, 2)}
 `, "utf8");
   } catch (error) {
     console.error(`[SERVER] Could not record the restart at ${path}: ${errorMessage(error)}`);
@@ -39300,7 +40798,7 @@ function noteRestartBegun(note) {
 }
 function restartOwed(projectPath) {
   try {
-    const parsed = JSON.parse(readFileSync18(restartNotePath(projectPath), "utf8"));
+    const parsed = JSON.parse(readFileSync19(restartNotePath(projectPath), "utf8"));
     if (typeof parsed !== "object" || parsed === null) {
       return null;
     }
@@ -39328,62 +40826,62 @@ var init_restart_note = __esm(() => {
 import { execFile as execFile4 } from "node:child_process";
 import { createHash as createHash4 } from "node:crypto";
 import {
-  mkdirSync as mkdirSync11,
+  mkdirSync as mkdirSync12,
   openSync as openSync2,
   readdirSync as readdirSync8,
-  readFileSync as readFileSync19,
-  realpathSync as realpathSync5,
+  readFileSync as readFileSync20,
+  realpathSync as realpathSync6,
   rmSync as rmSync10,
   statSync as statSync8,
-  writeFileSync as writeFileSync13
+  writeFileSync as writeFileSync14
 } from "node:fs";
-import { basename as basename5, dirname as dirname15, join as join22, resolve as resolve6 } from "node:path";
+import { basename as basename6, dirname as dirname17, join as join23, resolve as resolve7 } from "node:path";
 import { promisify as promisify4 } from "node:util";
 function runsDirectory() {
-  return join22(runtimeDirectory(), "runs");
+  return join23(runtimeDirectory(), "runs");
 }
 function realAsFarAsItExists(path) {
   const missing = [];
   let at = path;
   for (;; ) {
     try {
-      return join22(realpathSync5.native(at), ...missing);
+      return join23(realpathSync6.native(at), ...missing);
     } catch {
-      const parent = dirname15(at);
+      const parent = dirname17(at);
       if (parent === at) {
         return path;
       }
-      missing.unshift(basename5(at));
+      missing.unshift(basename6(at));
       at = parent;
     }
   }
 }
 function projectKey(projectPath) {
-  const real = realAsFarAsItExists(resolve6(projectPath)).replace(/[\\/]+$/, "");
+  const real = realAsFarAsItExists(resolve7(projectPath)).replace(/[\\/]+$/, "");
   const folded = process.platform === "win32" || process.platform === "darwin" ? real.toLowerCase() : real;
   return createHash4("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) {
-  mkdirSync11(runsDirectory(), { recursive: true });
-  const path = join22(runsDirectory(), `run-${startedAt}.log`);
+  mkdirSync12(runsDirectory(), { recursive: true });
+  const path = join23(runsDirectory(), `run-${startedAt}.log`);
   return { path, fd: openSync2(path, "a") };
 }
 function noteIsAbout(note, playing) {
   return note.play !== undefined && playing !== null && note.play.play === playing.play && note.play.editorPid === playing.editorPid;
 }
 function editorNotePath(projectPath, directory = runtimeDirectory()) {
-  return join22(directory, "runs", `editor-${projectKey(projectPath)}.json`);
+  return join23(directory, "runs", `editor-${projectKey(projectPath)}.json`);
 }
 function writeEditorRunNote(note) {
-  mkdirSync11(runsDirectory(), { recursive: true });
-  writeFileSync13(editorNotePath(note.projectPath), JSON.stringify(note, null, 2), "utf8");
+  mkdirSync12(runsDirectory(), { recursive: true });
+  writeFileSync14(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;
     }
@@ -39393,7 +40891,7 @@ function readEditorRunNote(projectPath) {
 function editorNoteAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync19(path, "utf8"));
+    parsed = JSON.parse(readFileSync20(path, "utf8"));
   } catch {
     return null;
   }
@@ -39417,7 +40915,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;
     }
@@ -39429,13 +40927,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);
         }
@@ -39447,7 +40945,7 @@ function everyRunRecord() {
 function recordAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync19(path, "utf8"));
+    parsed = JSON.parse(readFileSync20(path, "utf8"));
   } catch {
     return null;
   }
@@ -39498,7 +40996,7 @@ async function runningAs(pid) {
     const began = await startedAt(pid, null);
     const when = began === null ? {} : { startedAt: began };
     if (process.platform === "linux") {
-      const raw = readFileSync19(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
+      const raw = readFileSync20(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
       return raw === "" ? null : { kind: "commandLine", text: raw, ...when };
     }
     const args = (await execFileAsync("ps", ["-p", String(pid), "-o", "args="], { encoding: "utf8", timeout: 15000 })).stdout.trim();
@@ -39604,7 +41102,7 @@ function whyNotTheRun(record, running, needed) {
   if (after > SAME_RUN_WINDOW_MS) {
     return `that process started ${Math.round(after / 1000)} seconds after the run had`;
   }
-  const engine = record.command === undefined ? null : basename5(record.command);
+  const engine = record.command === undefined ? null : basename6(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)) {
@@ -39643,7 +41141,7 @@ 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] : []]) {
@@ -39673,7 +41171,7 @@ 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;
     }
@@ -39700,17 +41198,17 @@ import {
   closeSync as closeSync2,
   constants,
   copyFileSync,
-  existsSync as existsSync17,
+  existsSync as existsSync19,
   fstatSync,
-  mkdirSync as mkdirSync12,
+  mkdirSync as mkdirSync13,
   openSync as openSync3,
   readdirSync as readdirSync9,
-  readFileSync as readFileSync20,
+  readFileSync as readFileSync21,
   readSync as readSync2,
   rmdirSync as rmdirSync2,
   statSync as statSync9
 } from "node:fs";
-import { basename as basename6, dirname as dirname16, extname as extname2, isAbsolute as isAbsolute3, join as join23, normalize as normalize2, relative as relative4 } from "node:path";
+import { basename as basename7, dirname as dirname18, extname as extname2, isAbsolute as isAbsolute3, join as join24, normalize as normalize2, relative as relative5 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 import { promisify as promisify5 } from "node:util";
@@ -39731,16 +41229,16 @@ function captureDestinationRefusal(outputPath, projects) {
   if (extname2(outputPath).toLowerCase() !== ".png") {
     return `outputPath ${outputPath} does not end in .png, which is what a capture is.`;
   }
-  const directory = realPathOr(dirname16(outputPath));
-  if (!existsSync17(directory)) {
-    return `outputPath's directory ${dirname16(outputPath)} does not exist; a capture creates no directories.`;
+  const directory = realPathOr(dirname18(outputPath));
+  if (!existsSync19(directory)) {
+    return `outputPath's directory ${dirname18(outputPath)} does not exist; a capture creates no directories.`;
   }
-  const where = join23(directory, basename6(outputPath));
+  const where = join24(directory, basename7(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 (existsSync17(where)) {
+  if (existsSync19(where)) {
     return `outputPath ${outputPath} already exists; a capture is not written over a file. Name a new one.`;
   }
   return null;
@@ -39768,7 +41266,7 @@ function patienceForFrames(frames, atLeast) {
   return Math.max(atLeast, frames / SLOWEST_FRAME_RATE * 1000 + atLeast);
 }
 function projectSpelling(projectPath, absolutePath) {
-  return `res://${relative4(realPathOr(projectPath), realPathOr(absolutePath)).replaceAll("\\", "/")}`;
+  return `res://${relative5(realPathOr(projectPath), realPathOr(absolutePath)).replaceAll("\\", "/")}`;
 }
 function whichGame(args) {
   return { projectPath: args["projectPath"], pid: args["pid"] };
@@ -40266,7 +41764,7 @@ function aboveTheRunner(entry) {
 }
 function elsewhereIn(projectPath, asked) {
   const wanted = asked.replace(/^res:\/\//, "").replace(/\/+$/, "");
-  if (wanted === "" || existsSync17(join23(projectPath, wanted))) {
+  if (wanted === "" || existsSync19(join24(projectPath, wanted))) {
     return "";
   }
   const root = (wanted.split("/")[0] ?? "").toLowerCase();
@@ -40280,7 +41778,7 @@ function elsewhereIn(projectPath, asked) {
   return near.length === 0 ? "" : ` The project does have ${there}.`;
 }
 function hasMainScene(projectFile) {
-  const scene = parseProjectGodot(readFileSync20(projectFile, "utf8"))["application"]?.["run/main_scene"];
+  const scene = parseProjectGodot(readFileSync21(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "";
 }
 function runtimeAddonAnnouncesEditors(projectPath) {
@@ -40288,13 +41786,13 @@ function runtimeAddonAnnouncesEditors(projectPath) {
     return false;
   }
   try {
-    return readFileSync20(join23(projectPath, RUNTIME_AUTOLOAD.path), "utf8").includes('"editor_pid"');
+    return readFileSync21(join24(projectPath, RUNTIME_AUTOLOAD.path), "utf8").includes('"editor_pid"');
   } catch {
     return false;
   }
 }
 function editorPlaysHeadless(projectFile) {
-  const runArgs = parseProjectGodot(readFileSync20(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
+  const runArgs = parseProjectGodot(readFileSync21(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
   return typeof runArgs === "string" && /(?:^|\s)--headless(?:\s|$)/.test(runArgs);
 }
 function camelCased(params) {
@@ -40313,7 +41811,7 @@ function needsItsOwnProcess(asked) {
 class GodotServer {
   mcp;
   locator = new GodotLocator;
-  operationsScript = join23(__dirname2, "godot", "operations", "godot_operations.gd");
+  operationsScript = join24(__dirname2, "godot", "operations", "godot_operations.gd");
   godotBridge;
   tools = buildToolDefinitions();
   activeProcess = null;
@@ -40616,7 +42114,7 @@ class GodotServer {
         return checked.response;
       }
       const named = args["projectPath"];
-      if (typeof named === "string" && existsSync17(join23(named, "project.godot"))) {
+      if (typeof named === "string" && existsSync19(join24(named, "project.godot"))) {
         this.lastProjectPath = named;
       }
       this.updates.refresh();
@@ -40809,6 +42307,9 @@ class GodotServer {
     return { ok: true, op };
   }
   async dispatch(tool, op, args) {
+    if (tool !== "editor_status" && this.godotBridge.isArriving()) {
+      await this.waitForBridge(() => !this.godotBridge.isArriving(), Date.now() + GREETING_WAIT_MS);
+    }
     if (ENGINE_PASSES[tool]?.[op] !== undefined) {
       return op === "reimport" ? await this.handleReimport(args) : await this.handleRefreshUids(args);
     }
@@ -40909,6 +42410,8 @@ class GodotServer {
           default:
             return await bridge("connect_animation_states");
         }
+      case "script_edit":
+        return await this.handleRenameSymbol(args);
       case "script_info":
         switch (op) {
           case "symbols":
@@ -41084,8 +42587,8 @@ class GodotServer {
     if (path === undefined) {
       return { ok: false, response: this.createErrorResponse("projectPath is required.") };
     }
-    const file = join23(path, "project.godot");
-    if (!existsSync17(file)) {
+    const file = join24(path, "project.godot");
+    if (!existsSync19(file)) {
       return {
         ok: false,
         response: this.createErrorResponse(`Not a Godot project: ${path}`, [
@@ -41525,8 +43028,39 @@ class GodotServer {
     }
     const viaEditor = this.editorHasOpen(projectPath);
     const extra = {};
+    const statusAsk = resourcePath === undefined ? { includeUpToDate: true } : { resourcePath };
     if (viaEditor) {
-      const inEditor = await this.reimportInTheEditor(targets, timeoutMs);
+      const scan = await this.handleRescanFilesystem({ projectPath, timeoutMs });
+      if (scan.isError === true) {
+        return { ok: false, response: scan };
+      }
+      const scanned = asParams(JSON.parse(scan.content[0]?.text ?? "{}"));
+      if (scanned["stillWorking"] === true) {
+        return {
+          ok: true,
+          payload: {
+            via: "editor",
+            stillImporting: true,
+            asked: targets,
+            ...sourceless,
+            note: `The editor's scan of the project had not finished after ${timeoutMs} ms, and the reimport waits for it. project_import status says what it has done so far; pass a longer timeoutMs to wait it out.`
+          }
+        };
+      }
+      let remaining = targets;
+      if (!force) {
+        const between = await this.operation("get_import_status", statusAsk, projectPath);
+        if (!between.ok) {
+          return { ok: false, response: this.answer(between) };
+        }
+        const fresh = new Map(importStatuses(between.payload).map((one) => [one.path, one.status]));
+        const caughtUp = targets.filter((path) => fresh.get(path) === "up_to_date");
+        remaining = targets.filter((path) => !caughtUp.includes(path));
+        if (caughtUp.length > 0) {
+          extra["importedByTheScan"] = caughtUp;
+        }
+      }
+      const inEditor = remaining.length === 0 ? { ok: true, finished: true } : await this.reimportInTheEditor(remaining, timeoutMs);
       if (!inEditor.ok) {
         return inEditor;
       }
@@ -41557,17 +43091,22 @@ class GodotServer {
         extra["extensionNote"] = imported.extensionNote;
       }
     }
-    const after = await this.operation("get_import_status", resourcePath === undefined ? { includeUpToDate: true } : { resourcePath }, projectPath);
+    const after = await this.operation("get_import_status", statusAsk, 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 }
-    }));
+    const groups = new Map;
+    for (const path of targets.filter((one) => now.get(one)?.status !== "up_to_date")) {
+      const status = now.get(path)?.status ?? "unknown";
+      const reason = now.get(path)?.reason;
+      const key = `${status}\x00${reason ?? ""}`;
+      const group = groups.get(key) ?? { status, ...reason === undefined ? {} : { reason }, paths: [] };
+      group.paths.push(path);
+      groups.set(key, group);
+    }
+    const notReimported = [...groups.values()];
     return {
       ok: true,
       payload: {
@@ -41659,11 +43198,11 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const application = parseProjectGodot(readFileSync20(project.value.file, "utf8"))["application"] ?? {};
+    const application = parseProjectGodot(readFileSync21(project.value.file, "utf8"))["application"] ?? {};
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
-      name: typeof name === "string" && name !== "" ? name : basename6(project.value.path),
+      name: typeof name === "string" && name !== "" ? name : basename7(project.value.path),
       path: project.value.path,
       mainScene: typeof mainScene === "string" && mainScene !== "" ? mainScene : null,
       godotVersion: await this.godotVersion(engine.value),
@@ -41715,18 +43254,18 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const folder = dirname16(output.absolutePath);
+    const folder = dirname18(output.absolutePath);
     try {
-      mkdirSync12(folder, { recursive: true });
+      mkdirSync13(folder, { recursive: true });
     } catch (error) {
-      return this.createErrorResponse(`Cannot create ${dirname16(output.relativePath)} to export into: ${errorMessage(error)}`);
+      return this.createErrorResponse(`Cannot create ${dirname18(output.relativePath)} to export into: ${errorMessage(error)}`);
     }
     const debug = readBoolean(args, "debug") ?? false;
     const exportLogs = scratchDirectory("export");
     const exportArgs = [
       "--headless",
       "--log-file",
-      join23(exportLogs, "engine.log"),
+      join24(exportLogs, "engine.log"),
       "--path",
       project.value.path,
       debug ? "--export-debug" : "--export-release",
@@ -41734,7 +43273,7 @@ class GodotServer {
       output.absolutePath
     ];
     this.logDebug(`Exporting: ${engine.value} ${exportArgs.join(" ")}`);
-    const writtenAt = () => existsSync17(output.absolutePath) ? statSync9(output.absolutePath).mtimeMs : null;
+    const writtenAt = () => existsSync19(output.absolutePath) ? statSync9(output.absolutePath).mtimeMs : null;
     const before = writtenAt();
     let ending;
     try {
@@ -41757,7 +43296,7 @@ class GodotServer {
       return contained.response;
     }
     const runner = "addons/gdUnit4/bin/GdUnitCmdTool.gd";
-    if (!existsSync17(join23(project.value.path, runner))) {
+    if (!existsSync19(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"
       ]);
@@ -41824,21 +43363,21 @@ class GodotServer {
       await untilGone([run.process.pid]);
     }
     await run.settled;
-    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 = existsSync17(reportsDir) ? readdirSync9(reportsDir).filter((name) => name.startsWith("report_")).sort((a, b) => Number(a.slice("report_".length)) - Number(b.slice("report_".length))) : [];
+      const written = existsSync19(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(readFileSync20(join23(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync21(join24(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
     } finally {
       discard(reportsDir, userData);
       try {
-        rmdirSync2(dirname16(reportsDir));
+        rmdirSync2(dirname18(reportsDir));
       } catch {}
     }
     const engineEntries = run.log.select({ severity: "warning", sinceLastCall: false, limit: 200 }).entries.map(aboveTheRunner);
@@ -42016,11 +43555,11 @@ class GodotServer {
     const cached = cachedClasses(projectPath);
     const contradicted = cached === null ? [] : contradictedDiagnostics(messages, cached, (resourcePath) => {
       const contained = resolveWithinProject(projectPath, resourcePath);
-      if (!contained.ok || !existsSync17(contained.absolutePath)) {
+      if (!contained.ok || !existsSync19(contained.absolutePath)) {
         return null;
       }
       try {
-        return readFileSync20(contained.absolutePath, "utf8");
+        return readFileSync21(contained.absolutePath, "utf8");
       } catch {
         return null;
       }
@@ -42076,23 +43615,26 @@ class GodotServer {
   }
   sourceOfClass(projectPath, resourcePath) {
     const contained = resolveWithinProject(projectPath, resourcePath);
-    if (!contained.ok || !existsSync17(contained.absolutePath)) {
+    if (!contained.ok || !existsSync19(contained.absolutePath)) {
       return null;
     }
     try {
-      return readFileSync20(contained.absolutePath, "utf8");
+      return readFileSync21(contained.absolutePath, "utf8");
     } catch {
       return null;
     }
   }
   async handleLSP(toolName, args) {
+    return handleLSPTool(await this.lsp(), toolName, args);
+  }
+  async lsp() {
     const port = this.editorServes("lspPort", "GDHARNESS_LSP_PORT", DEFAULT_LSP_PORT);
     if (this.lspClient !== null && this.lspClient.port !== port) {
       await this.lspClient.disconnect();
       this.lspClient = null;
     }
     this.lspClient ??= new GodotLSPClient(port);
-    return handleLSPTool(this.lspClient, toolName, args);
+    return this.lspClient;
   }
   async handleDAP(toolName, args) {
     return handleDAPTool(this.dap(), toolName, args);
@@ -42388,7 +43930,7 @@ class GodotServer {
       return null;
     }
     try {
-      return settingKeys(readFileSync20(join23(projectPath, "project.godot"), "utf8"));
+      return settingKeys(readFileSync21(join24(projectPath, "project.godot"), "utf8"));
     } catch {
       return null;
     }
@@ -42402,14 +43944,7 @@ class GodotServer {
       ]);
     }
     if (!hasSaidWhoItIs(before)) {
-      const settled = await this.waitForBridge(() => hasSaidWhoItIs(this.godotBridge.getStatus()) || !this.godotBridge.isConnected(), Date.now() + GREETING_WAIT_MS);
-      if (!settled) {
-        return this.createErrorResponse(`The editor has connected and has not said who it is within ${GREETING_WAIT_MS / 1000}s, so whether this server or the editor itself restarts it cannot be told.`, [
-          "editor_status says when it has, under greeting while it has not",
-          "Then ask for the restart again"
-        ]);
-      }
-      return this.handleRestartEditor(args);
+      return this.createErrorResponse(`The editor has connected and has not said who it is within ${GREETING_WAIT_MS / 1000}s, so whether this server or the editor itself restarts it cannot be told.`, ["editor_status says when it has, under greeting while it has not", "Then ask for the restart again"]);
     }
     const mine = before.openedByAServer === true && before.projectPath !== undefined;
     if (!mine && args["hidden"] === true) {
@@ -42717,7 +44252,7 @@ class GodotServer {
   }
   async runtimeUp(projectPath, before, budget, withArgs) {
     const budgetMs = budget.ms;
-    if (!existsSync17(join23(projectPath, RUNTIME_AUTOLOAD.path))) {
+    if (!existsSync19(join24(projectPath, RUNTIME_AUTOLOAD.path))) {
       return runtimeVerdict(null, { addon: false, budgetMs, heldAt: null, running: false, withArgs });
     }
     let asking = null;
@@ -42968,7 +44503,7 @@ class GodotServer {
       return 0;
     }
     try {
-      return reportAlreadyInTranscript(readFileSync20(game.transcript), readFileSync20(report));
+      return reportAlreadyInTranscript(readFileSync21(game.transcript), readFileSync21(report));
     } catch (error) {
       this.logDebug(`Could not compare a picked-up run's report with its transcript: ${errorMessage(error)}`);
       return 0;
@@ -43726,7 +45261,7 @@ class GodotServer {
       notes.push(endedWithoutACode({
         throughEditor: run.throughEditor,
         announced: announced !== undefined || run.announcedPid !== undefined,
-        couldAnnounce: run.projectPath !== null && existsSync17(join23(run.projectPath, RUNTIME_AUTOLOAD.path)),
+        couldAnnounce: run.projectPath !== null && existsSync19(join24(run.projectPath, RUNTIME_AUTOLOAD.path)),
         endedHere: typeof run.endedHere === "string",
         pickedUp: run.pickedUp === true
       }));
@@ -43973,11 +45508,9 @@ class GodotServer {
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 30000;
     const started = Date.now();
     const projectPath = typeof args["projectPath"] === "string" ? args["projectPath"] : "";
-    const before = projectPath === "" ? null : cachedClasses(projectPath);
-    const writtenBefore = projectPath === "" ? null : cacheWrittenAt(projectPath);
-    const blind = await this.classesTheEditorCannotSee(args);
-    const atRisk = before === null ? [] : blind.unseen.filter((one) => before.has(one.className));
-    const ghosts = blind.stillHeld ?? [];
+    let before = null;
+    let writtenBefore = null;
+    let blind = { unseen: [] };
     let waitedForEditorMs = 0;
     let first;
     let completedBefore;
@@ -43993,6 +45526,9 @@ class GodotServer {
       if (wasBusy) {
         waitedForEditorMs += Date.now() - busySince;
       }
+      before = projectPath === "" ? null : cachedClasses(projectPath);
+      writtenBefore = projectPath === "" ? null : cacheWrittenAt(projectPath);
+      blind = await this.classesTheEditorCannotSee(args);
       first = await this.handleViaBridge("rescan_filesystem", args);
       if (first.isError) {
         return first;
@@ -44009,6 +45545,9 @@ class GodotServer {
       }
       await new Promise((settle) => setTimeout(settle, 100));
     }
+    const held = before;
+    const atRisk = held === null ? [] : blind.unseen.filter((one) => held.has(one.className));
+    const ghosts = blind.stillHeld ?? [];
     let busy = true;
     let idleSince = null;
     while (Date.now() - started < timeoutMs) {
@@ -44146,9 +45685,12 @@ class GodotServer {
     });
   }
   async reloadDependents(projectPath, classes) {
+    return await this.reloadInEditor(scriptsNaming(projectPath, classes));
+  }
+  async reloadInEditor(scripts) {
     const reloaded = [];
     const notReloaded = [];
-    for (const { script: scriptPath, tool } of scriptsNaming(projectPath, classes)) {
+    for (const { script: scriptPath, tool } of scripts) {
       if (tool) {
         notReloaded.push({
           scriptPath,
@@ -44265,6 +45807,159 @@ class GodotServer {
     });
     return this.godotBridge.isConnected() ? await this.alsoSayWhatTheEditorCannotSee(answered, args) : answered;
   }
+  async handleRenameSymbol(given) {
+    const project = this.project(given);
+    if (!project.ok) {
+      return project.response;
+    }
+    const contained = this.containProjectFiles(given);
+    if (!contained.ok) {
+      return contained.response;
+    }
+    const args = contained.value;
+    const projectPath = project.value.path;
+    const scriptPath = resolveWithinProject(projectPath, readNonEmptyString(args, "scriptPath") ?? "");
+    if (!scriptPath.ok) {
+      return this.createErrorResponse(scriptPath.reason);
+    }
+    if (!existsSync19(scriptPath.absolutePath)) {
+      return this.createErrorResponse(`Script file does not exist: ${scriptPath.absolutePath}`);
+    }
+    const asked = readNonEmptyString(args, "newScriptPath");
+    const moveTo = asked === undefined ? null : resolveWithinProject(projectPath, asked);
+    if (moveTo !== null && !moveTo.ok) {
+      return this.createErrorResponse(moveTo.reason);
+    }
+    const languageServer = {
+      problem: null,
+      initialized: false
+    };
+    const askTheLanguageServer = async (question) => {
+      const client = await this.lsp();
+      try {
+        if (!languageServer.initialized) {
+          await client.initialize(projectPath);
+          languageServer.initialized = true;
+        }
+        return await question(client);
+      } catch (error) {
+        languageServer.problem = normalizeLSPError(error, client.port);
+        throw error;
+      }
+    };
+    const symbol = readNonEmptyString(args, "symbol") ?? "";
+    const newName = readNonEmptyString(args, "newName") ?? "";
+    const outcome = await renameSymbol({
+      projectPath,
+      scriptPath: scriptPath.absolutePath,
+      symbol,
+      newName,
+      newScriptPath: moveTo === null ? null : moveTo.absolutePath
+    }, {
+      namesTaken: async (names, base) => {
+        const asked = await this.operation("names_taken", { names: [...names], base: base ?? "" }, projectPath);
+        if (!asked.ok) {
+          throw new Error(`the engine could not be asked whether ${names.join(" or ")} is taken: ${asked.message}`);
+        }
+        return asParams(asked.payload["taken"]);
+      },
+      references: async (absolute, text, at) => await askTheLanguageServer((client) => client.getReferences(absolute, text, at.line, at.character)),
+      definitions: async (absolute, text, at) => await askTheLanguageServer((client) => client.getDefinitions(absolute, text, at.line, at.character))
+    }).catch((error) => ({ ok: false, reason: errorMessage(error) }));
+    if (!outcome.ok) {
+      if (languageServer.problem !== null) {
+        return this.createErrorResponse(`Renaming a member needs the editor's language server, because which uses of the name are this class's depends on the types only the engine's analyser knows. ${languageServer.problem}`, [
+          "editor_launch opens the editor, whose language server this uses",
+          "A class_name is renamed from the files and needs no editor"
+        ]);
+      }
+      const said = outcome.conflicts === undefined ? "" : ` ${outcome.conflicts.join("; ")}.`;
+      return this.createErrorResponse(`${outcome.reason}${said}`, outcome.advice ?? []);
+    }
+    if (readBoolean(args, "preview") === true) {
+      return this.jsonTextResponse({ preview: true, ...outcome.report });
+    }
+    try {
+      applyRewrites(outcome.rewrites);
+    } catch (error) {
+      return this.createErrorResponse(`Nothing was renamed: ${errorMessage(error)}`);
+    }
+    const settled = this.godotBridge.isConnected() ? await this.settleRenameInEditor(projectPath, outcome.scriptsInOrder, {
+      gone: outcome.moved === null ? [] : [outcome.moved.from],
+      oldClass: outcome.isClass ? symbol : null,
+      newClass: outcome.isClass ? newName : null
+    }) : await this.settleRenameOnDisk(projectPath, outcome.scriptsInOrder, {
+      rebuildCache: outcome.isClass || outcome.moved !== null,
+      moved: outcome.moved !== null
+    });
+    return this.jsonTextResponse({ ok: settled.ok, ...outcome.report, ...settled.report });
+  }
+  async settleRenameInEditor(projectPath, changed, names) {
+    const { gone, oldClass, newClass } = names;
+    const scanned = asParams(JSON.parse((await this.handleRescanFilesystem({
+      projectPath,
+      timeoutMs: 60000,
+      updateFiles: [...gone, ...changed]
+    })).content[0]?.text ?? "{}"));
+    const reloadedByTheScan = new Set((readArray(scanned, "dependentsReloaded") ?? []).map(String));
+    const toReload = [];
+    for (const script of changed) {
+      if (!reloadedByTheScan.has(script)) {
+        const source = this.sourceOfClass(projectPath, script);
+        toReload.push({ script, tool: source !== null && isToolScript(source) });
+      }
+    }
+    const done = await this.reloadInEditor(toReload);
+    const notReloaded = done.notReloaded;
+    const reloaded = [...reloadedByTheScan, ...done.reloaded].sort();
+    const checked = oldClass === null ? null : await this.classesTheEditorCannotSee({ projectPath });
+    const stillHeld = oldClass !== null && (checked?.stillHeld?.includes(oldClass) === true || (readArray(scanned, "cacheDropped") ?? []).map(String).includes(oldClass) || (readArray(scanned, "cacheAtMissingPaths") ?? []).map(String).includes(oldClass));
+    const unseen = newClass !== null && checked?.unseen.some((one) => one.className === newClass) === true;
+    const notes = [];
+    if (stillHeld) {
+      notes.push(`The editor still holds ${oldClass} after the scan, so it resolves the old name until it is restarted with editor_launch restart, and writes it back into the class cache on every scan until then.`);
+    }
+    if (unseen) {
+      notes.push(`The editor does not hold ${newClass} after the scan, so every use of it reads as an unknown identifier there: editor_rescan on its own, or editor_launch restart.`);
+    }
+    if (scanned["stillWorking"] === true) {
+      notes.push("The editor was still scanning when the wait ran out, so it may not hold the new names yet.");
+    }
+    return {
+      ok: scanned["stillWorking"] !== true && notReloaded.length === 0 && !stillHeld && !unseen,
+      report: {
+        editor: {
+          reloaded,
+          ...notReloaded.length > 0 ? { notReloaded } : {},
+          ...stillHeld ? { stillHolds: oldClass } : {},
+          ...typeof scanned["note"] === "string" ? { scanNote: scanned["note"] } : {}
+        },
+        ...notes.length > 0 ? { note: notes.join(" ") } : {}
+      }
+    };
+  }
+  async settleRenameOnDisk(projectPath, changed, asked) {
+    const report = {};
+    let ok = true;
+    if (asked.moved) {
+      const engine = await this.engine();
+      const imported = engine.ok ? await runImport(engine.value, projectPath) : null;
+      const problem = imported === null ? engine.ok ? "" : engine.response.content.map((block) => block.text).join(" ") : imported.ok ? null : imported.message;
+      report["uidTable"] = problem === null ? "rebuilt by an import pass" : `not rebuilt: ${problem}`;
+      ok &&= problem === null;
+    }
+    if (asked.rebuildCache) {
+      const rebuilt = await this.rebuildClassCache(projectPath);
+      report["classCache"] = rebuilt.ok ? rebuilt.payload : { rebuilt: false, problem: rebuilt.message };
+      ok &&= rebuilt.ok;
+    }
+    if (changed.length > 0) {
+      const compiled = await this.operation("check_scripts", { paths: [...changed] }, projectPath);
+      report["compiled"] = compiled.ok ? { ...compiled.payload, ...engineExtras(compiled) } : { problem: compiled.message };
+      ok &&= compiled.ok && (readArray(compiled.payload, "failed") ?? []).length === 0;
+    }
+    return { ok, report };
+  }
   async alsoSayWhatTheEditorCannotSee(answered, args) {
     const first = answered.content[0];
     if (answered.isError || first?.type !== "text" || typeof first.text !== "string") {
@@ -44393,7 +46088,7 @@ class GodotServer {
   async ownRunOnItsWay(projectPath, budgetMs) {
     const run = await this.currentRun();
     const project = projectPath ?? run?.projectPath ?? null;
-    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync17(join23(project, RUNTIME_AUTOLOAD.path)) || !await this.runStillGoing(run)) {
+    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync19(join24(project, RUNTIME_AUTOLOAD.path)) || !await this.runStillGoing(run)) {
       return null;
     }
     const already = runtimesAnnounced().running;
@@ -44477,7 +46172,7 @@ class GodotServer {
       }
     }
     const screenshotDir = expectsScreenshot ? scratchDirectory("runtime-screenshot") : null;
-    const screenshotPath = screenshotDir ? join23(screenshotDir, "capture.png") : null;
+    const screenshotPath = screenshotDir ? join24(screenshotDir, "capture.png") : null;
     const staleNote = this.runtimeStaleNote(choice.endpoint);
     const stale = staleNote === undefined ? {} : { addonIsStale: true, staleNote };
     const refused = (message) => this.createErrorResponse(staleNote === undefined ? message : `${message}
@@ -44526,7 +46221,7 @@ ${staleNote}`);
 
 ${staleNote}`}`
           },
-          { type: "image", data: readFileSync20(screenshotPath).toString("base64"), mimeType: "image/png" }
+          { type: "image", data: readFileSync21(screenshotPath).toString("base64"), mimeType: "image/png" }
         ]
       };
     } finally {
@@ -44660,6 +46355,8 @@ var init_server3 = __esm(() => {
   init_process_children();
   init_process_time();
   init_project_scan();
+  init_rename();
+  init_rename_symbol();
   init_resources();
   init_restart_note();
   init_run_record();
@@ -44670,7 +46367,7 @@ var init_server3 = __esm(() => {
   init_tool_definitions();
   init_update_check();
   run4 = promisify5(execFile5);
-  __dirname2 = dirname16(fileURLToPath5(import.meta.url));
+  __dirname2 = dirname18(fileURLToPath5(import.meta.url));
   CONSOLE_WRAPPER = /_console(\.exe)?$/i;
   LONGEST_BOOT_NOTED_MS = 5 * 60000;
   VALUE_NAMES = {
@@ -44694,6 +46391,7 @@ var init_server3 = __esm(() => {
     "scriptPath",
     "resourcePath",
     "newPath",
+    "newScriptPath",
     "path",
     "script"
   ];
@@ -44719,8 +46417,8 @@ var init_server3 = __esm(() => {
 init_bridge_announce();
 init_errors();
 init_godot_path();
-import { existsSync as existsSync18 } from "node:fs";
-import { join as join24, resolve as resolve7 } from "node:path";
+import { existsSync as existsSync20 } from "node:fs";
+import { join as join25, resolve as resolve8 } from "node:path";
 
 // src/harnesses.ts
 import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync2, rmSync as rmSync2, statSync as statSync2, writeFileSync as writeFileSync2 } from "node:fs";
@@ -45889,7 +47587,13 @@ formatting. \`script_diagnostics\` and \`script_info\` come from the editor's ow
 \`project_info\`, \`project_dependencies\`, \`project_settings\`, \`project_import\`,
 \`project_export\`, \`project_test\`, \`script_edit\`, \`script_info structure\` and
 \`editor_classes\` need nothing open: they run a short headless engine and are gone before the
-answer is printed. \`project_settings get\` is on that list too, reading as it does like a look at
+answer is printed. The exception is \`script_edit rename\` of a method, variable, signal or other
+member, which asks the editor's language server which uses are that class's.
+
+To rename a class or a member across the project, use \`script_edit rename\` rather than a text
+replacement: it changes the uses the engine resolves, doc links and what scenes record, and lists
+every other occurrence of the word under \`leftAlone\`, a \`find_children\` string or a word in a
+comment, for you to read. Pass \`preview\` first on a large rename. \`project_settings get\` is on that list too, reading as it does like a look at
 a config file: it starts an engine so that a setting nobody wrote down still answers with the
 default the engine registers for it.
 
@@ -46040,8 +47744,8 @@ class UsageError extends Refusal {
 }
 function projectArgument(at) {
   const named = args.slice(at).find((value) => !value.startsWith("--"));
-  const projectPath = resolve7(named ?? ".");
-  if (!existsSync18(join24(projectPath, "project.godot"))) {
+  const projectPath = resolve8(named ?? ".");
+  if (!existsSync20(join25(projectPath, "project.godot"))) {
     throw new UsageError(`Not a Godot project: ${projectPath} holds no project.godot.`);
   }
   return projectPath;
@@ -46086,7 +47790,7 @@ async function registerRuntime(godot, projectPath) {
     return;
   }
   console.log(`${RUNTIME_AUTOLOAD.name} autoload left at ${named}, which this project registers itself`);
-  if (!existsSync18(join24(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
+  if (!existsSync20(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}`);
   }
 }
@@ -46218,7 +47922,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, existsSync18);
+      const directories = skillDirectories(chosen.harnesses, projectPath, existsSync20);
       for (const written of writeSkill(directories, getLocalVersion())) {
         console.log(`skill: ${written.replaced ? "replaced" : "written"} ${written.path}`);
       }
@@ -46332,7 +48036,7 @@ async function upgrade() {
       moved.push(took.from);
     }
   }
-  for (const written of writeSkill(skillDirectories(already, projectPath, existsSync18), version)) {
+  for (const written of writeSkill(skillDirectories(already, projectPath, existsSync20), version)) {
     console.log(`skill: ${written.replaced ? "replaced" : "written"} ${written.path}`);
   }
   console.log(`