@skillcap/gdh 3.0.2 → 3.2.0

package/node_modules/@gdh/editor/dist/index.js

@@ -0,0 +1,1380 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import fs from "node:fs/promises";
+import http from "node:http";
+import path from "node:path";
+import { definePackageBoundary, detectFatalGodotStderr, GDH_RUNTIME_BRIDGE_SURFACE_VERSION, normalizeBridgeTargetIdentity, resolveConfiguredGodotEditorBin, } from "@gdh/core";
+const EDITOR_BRIDGE_STATE_DIRECTORY = "editor-bridge";
+const EDITOR_BRIDGE_OPERATIONS_DIRECTORY = "operations";
+const EDITOR_OPERATION_INPUT_FILE = "input.json";
+const EDITOR_OPERATION_OUTPUT_FILE = "output.json";
+const EDITOR_OPERATION_RUNNER_FILE = "runner.gd";
+const EDITOR_ADOPTION_METADATA_FILE = "adopted-editor.json";
+const EDITOR_ADOPTION_TOKEN_FILE = "adopted-editor.token";
+const EDITOR_ADOPTION_HEARTBEAT_FILE = "adopted-editor.heartbeat";
+const EDITOR_ADOPTION_PROTOCOL_VERSION = 1;
+const EDITOR_ADOPTION_HEARTBEAT_STALE_AFTER_MS = 15_000;
+const DEFAULT_EDITOR_OPERATION_TIMEOUT_MS = 30_000;
+const DEFAULT_RETAIN_OPERATION_ARTIFACTS = 20;
+export const editorPackage = definePackageBoundary({
+    name: "@gdh/editor",
+    layer: "capability",
+    responsibility: "Editor Bridge session coordination and Godot-native editor operation execution.",
+    allowedInternalDependencies: ["@gdh/core"],
+});
+export function resolveEditorBridgePaths(input) {
+    const targetRootPath = path.resolve(input.targetPath);
+    const godotProjectRootPath = path.resolve(targetRootPath, input.godotProjectRootPath ?? input.projectConfig?.primaryGodotProjectPath ?? ".");
+    const stateRootPath = path.resolve(input.stateRootPath ?? path.join(targetRootPath, ".gdh-state"));
+    const editorBridgeDirectory = path.join(stateRootPath, EDITOR_BRIDGE_STATE_DIRECTORY);
+    const operationsDirectory = path.join(editorBridgeDirectory, EDITOR_BRIDGE_OPERATIONS_DIRECTORY);
+    const adoptedMetadataPath = path.join(editorBridgeDirectory, EDITOR_ADOPTION_METADATA_FILE);
+    const adoptedTokenPath = path.join(editorBridgeDirectory, EDITOR_ADOPTION_TOKEN_FILE);
+    const adoptedHeartbeatPath = path.join(editorBridgeDirectory, EDITOR_ADOPTION_HEARTBEAT_FILE);
+    const identity = normalizeBridgeTargetIdentity({
+        targetRootPath,
+        godotProjectRootPath,
+        stateRootPath,
+    });
+    return {
+        targetRootPath,
+        godotProjectRootPath,
+        stateRootPath,
+        editorBridgeDirectory,
+        operationsDirectory,
+        adoptedMetadataPath,
+        adoptedTokenPath,
+        adoptedHeartbeatPath,
+        identity,
+    };
+}
+export async function inspectEditorBridgeSession(input) {
+    const paths = resolveEditorBridgePaths(input);
+    const mode = input.mode ?? "auto";
+    if (mode === "disabled") {
+        return {
+            targetPath: paths.targetRootPath,
+            godotProjectRootPath: paths.godotProjectRootPath,
+            mode,
+            state: "blocked",
+            kind: null,
+            summary: "Editor Bridge is disabled by session mode.",
+            reasons: ["editor_bridge_disabled"],
+            identity: paths.identity,
+            adoptedEditor: null,
+        };
+    }
+    const adopted = await inspectAdoptedEditor(paths);
+    if (adopted.state === "ready") {
+        return {
+            targetPath: paths.targetRootPath,
+            godotProjectRootPath: paths.godotProjectRootPath,
+            mode,
+            state: "ready",
+            kind: "adopted",
+            summary: "Adopted editor session is available for the exact target/worktree.",
+            reasons: ["adopted_editor_available"],
+            identity: paths.identity,
+            adoptedEditor: adopted.summary,
+        };
+    }
+    if (mode === "adopt_only") {
+        return {
+            targetPath: paths.targetRootPath,
+            godotProjectRootPath: paths.godotProjectRootPath,
+            mode,
+            state: "unavailable",
+            kind: null,
+            summary: adopted.summaryText,
+            reasons: adopted.reasons,
+            identity: paths.identity,
+            adoptedEditor: null,
+        };
+    }
+    const godotEditorBin = await resolveGodotEditorBin(input);
+    if (godotEditorBin === null) {
+        return {
+            targetPath: paths.targetRootPath,
+            godotProjectRootPath: paths.godotProjectRootPath,
+            mode,
+            state: "blocked",
+            kind: null,
+            summary: "Managed headless editor is unavailable because no Godot editor binary is configured.",
+            reasons: [...adopted.reasons, "godot_editor_bin_unavailable"],
+            identity: paths.identity,
+            adoptedEditor: null,
+        };
+    }
+    return {
+        targetPath: paths.targetRootPath,
+        godotProjectRootPath: paths.godotProjectRootPath,
+        mode,
+        state: "ready",
+        kind: "managed_headless",
+        summary: "Managed headless editor session is available for editor operations.",
+        reasons: [...adopted.reasons, "managed_headless_editor_available"],
+        identity: paths.identity,
+        adoptedEditor: null,
+    };
+}
+function validateEditorOperation(operation) {
+    const kind = readPayloadString(operation["kind"]);
+    const help = createEditorOperationHelp(kind);
+    if (kind === "") {
+        const typeValue = readPayloadString(operation["type"]);
+        const operationHelp = typeValue === "" ? help : createEditorOperationHelp(typeValue);
+        return {
+            summary: typeValue === ""
+                ? `Editor operation payload is missing "kind". Use operation.kind, for example ${JSON.stringify(help.examples[0])}.`
+                : `Editor operation payload used "type": "${typeValue}", but GDH dispatches editor operations with "kind". Use ${JSON.stringify(operationHelp.examples[0])}.`,
+            reasons: typeValue === ""
+                ? ["operation_kind_missing"]
+                : ["operation_kind_missing", "operation_type_unsupported"],
+            help: operationHelp,
+        };
+    }
+    if (!KNOWN_EDITOR_OPERATION_KINDS.has(kind)) {
+        return {
+            summary: `Unsupported editor operation kind "${kind}". Use one of: ${[
+                ...KNOWN_EDITOR_OPERATION_KINDS,
+            ].join(", ")}.`,
+            reasons: ["operation_unsupported"],
+            help,
+        };
+    }
+    const missingField = requiredFieldForOperation(kind, operation);
+    if (missingField !== null) {
+        return {
+            summary: `Editor operation "${kind}" requires "${missingField}". Example: ${JSON.stringify(createEditorOperationHelp(kind).examples[0])}.`,
+            reasons: [`${toSnakeCase(missingField)}_missing`],
+            help: createEditorOperationHelp(kind),
+        };
+    }
+    if (kind === "batch.apply") {
+        const operations = operation["operations"];
+        if (!Array.isArray(operations)) {
+            return {
+                summary: 'Editor operation "batch.apply" requires "operations" as an array of operation payloads.',
+                reasons: ["batch_operations_invalid"],
+                help,
+            };
+        }
+        for (const child of operations) {
+            if (child === null || Array.isArray(child) || typeof child !== "object") {
+                return {
+                    summary: 'Editor operation "batch.apply" children must be operation objects.',
+                    reasons: ["batch_child_operation_invalid"],
+                    help,
+                };
+            }
+            const childValidation = validateEditorOperation(child);
+            if (childValidation !== null)
+                return childValidation;
+        }
+    }
+    return null;
+}
+const KNOWN_EDITOR_OPERATION_KINDS = new Set([
+    "scene.create",
+    "scene.tree",
+    "scene.save",
+    "node.add",
+    "node.remove",
+    "node.reparent",
+    "node.duplicate",
+    "node.set_property",
+    "node.get_property",
+    "node.inspect",
+    "resource.create",
+    "resource.read",
+    "resource.properties",
+    "resource.set_property",
+    "script.attach",
+    "class.search",
+    "class.info",
+    "editor.state",
+    "batch.apply",
+]);
+function requiredFieldForOperation(kind, operation) {
+    const require = (...fields) => fields.find((field) => readPayloadString(operation[field]) === "") ?? null;
+    switch (kind) {
+        case "scene.create":
+        case "scene.tree":
+        case "scene.save":
+            return require("scenePath");
+        case "node.add":
+            return require("scenePath", "nodeType", "nodeName");
+        case "node.remove":
+        case "node.reparent":
+        case "node.duplicate":
+            return require("scenePath", "nodePath");
+        case "node.set_property":
+        case "node.get_property":
+            return require("scenePath", "nodePath", "propertyName");
+        case "node.inspect":
+            return require("scenePath");
+        case "resource.create":
+            return require("resourcePath", "resourceType");
+        case "resource.read":
+        case "resource.properties":
+            return require("resourcePath");
+        case "resource.set_property":
+            return require("resourcePath", "propertyName");
+        case "script.attach":
+            return require("scenePath", "nodePath", "scriptPath");
+        case "class.info":
+            return require("className");
+        default:
+            return null;
+    }
+}
+function createEditorOperationHelp(kind) {
+    const example = editorOperationExample(kind);
+    return {
+        usage: "Use editor.operation.run with an operation object that contains a kind field, or prefer focused MCP tools such as editor.state, editor.scene.tree, editor.resource.read, editor.resource.properties, editor.node.inspect, editor.class.search, and editor.class.info.",
+        helpCommand: 'gdh editor operation run --help; example: gdh editor operation run --input-json \'{"kind":"class.search","query":"Label"}\'',
+        examples: [example],
+    };
+}
+function editorOperationExample(kind) {
+    switch (kind) {
+        case "scene.tree":
+            return { kind: "scene.tree", scenePath: "res://path/to/scene.tscn", maxDepth: 3 };
+        case "node.inspect":
+            return {
+                kind: "node.inspect",
+                scenePath: "res://path/to/scene.tscn",
+                nodePath: ".",
+                includePropertyList: true,
+                propertyLimit: 40,
+            };
+        case "resource.read":
+            return {
+                kind: "resource.read",
+                resourcePath: "res://path/to/resource.tres",
+                propertyNames: ["name"],
+            };
+        case "resource.properties":
+            return { kind: "resource.properties", resourcePath: "res://path/to/resource.tres" };
+        case "class.search":
+            return { kind: "class.search", query: "Label" };
+        case "class.info":
+            return { kind: "class.info", className: "Label", propertyQuery: "text" };
+        case "editor.state":
+            return { kind: "editor.state" };
+        default:
+            return { kind: "editor.state" };
+    }
+}
+function readPayloadString(value) {
+    return typeof value === "string" ? value : "";
+}
+function toSnakeCase(value) {
+    return value.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+export async function runEditorOperation(input) {
+    const paths = resolveEditorBridgePaths(input);
+    const operationValidation = validateEditorOperation(input.operation);
+    if (operationValidation !== null) {
+        return {
+            targetPath: paths.targetRootPath,
+            state: "failed",
+            summary: operationValidation.summary,
+            reasons: operationValidation.reasons,
+            session: {
+                targetPath: paths.targetRootPath,
+                godotProjectRootPath: paths.godotProjectRootPath,
+                mode: input.mode ?? "auto",
+                state: "blocked",
+                kind: null,
+                summary: "Editor operation was rejected before session startup.",
+                reasons: operationValidation.reasons,
+                identity: paths.identity,
+                adoptedEditor: null,
+            },
+            operation: input.operation,
+            output: null,
+            help: operationValidation.help,
+            artifacts: null,
+        };
+    }
+    const session = await inspectEditorBridgeSession(input);
+    if (session.state !== "ready" || session.kind === null) {
+        return {
+            targetPath: paths.targetRootPath,
+            state: "blocked",
+            summary: session.summary,
+            reasons: session.reasons,
+            session,
+            operation: input.operation,
+            output: null,
+            help: null,
+            artifacts: null,
+        };
+    }
+    if (session.kind === "adopted") {
+        return await runAdoptedEditorOperation({ input, paths, session });
+    }
+    const godotEditorBin = await resolveGodotEditorBin(input);
+    if (godotEditorBin === null) {
+        return {
+            targetPath: paths.targetRootPath,
+            state: "blocked",
+            summary: "Managed headless editor is unavailable because no Godot editor binary is configured.",
+            reasons: ["godot_editor_bin_unavailable"],
+            session,
+            operation: input.operation,
+            output: null,
+            help: null,
+            artifacts: null,
+        };
+    }
+    const artifacts = await createOperationArtifacts({
+        paths,
+        operation: input.operation,
+        retainOperationArtifacts: input.retainOperationArtifacts,
+        includeRunner: true,
+    });
+    if (artifacts.runnerPath === null) {
+        throw new Error("Expected headless editor operation artifacts to include a runner path.");
+    }
+    await fs.writeFile(artifacts.runnerPath, renderEditorOperationRunner(), "utf8");
+    const processResult = await (input.spawnEditorProcess ?? spawnEditorProcess)({
+        command: godotEditorBin,
+        args: [
+            "--headless",
+            "--editor",
+            "--path",
+            paths.godotProjectRootPath,
+            "--script",
+            artifacts.runnerPath,
+        ],
+        cwd: paths.godotProjectRootPath,
+        env: {
+            ...process.env,
+            GDH_EDITOR_OPERATION_INPUT: artifacts.inputPath,
+            GDH_EDITOR_OPERATION_OUTPUT: artifacts.outputPath,
+        },
+        timeoutMs: input.timeoutMs ?? DEFAULT_EDITOR_OPERATION_TIMEOUT_MS,
+    });
+    await fs.writeFile(artifacts.stdoutPath, processResult.stdout, "utf8");
+    await fs.writeFile(artifacts.stderrPath, processResult.stderr, "utf8");
+    const runnerOutput = await readRunnerOutput(artifacts.outputPath);
+    if (runnerOutput === null) {
+        const fatality = detectFatalGodotStderr({
+            exitCode: processResult.exitCode ?? 1,
+            stderr: processResult.stderr,
+        });
+        return {
+            targetPath: paths.targetRootPath,
+            state: "failed",
+            summary: fatality.detected || processResult.exitCode !== 0
+                ? "Editor operation failed before producing structured output."
+                : "Editor operation completed without producing structured output.",
+            reasons: fatality.detected
+                ? ["godot_editor_stderr_fatal"]
+                : processResult.exitCode !== 0
+                    ? ["godot_editor_process_failed"]
+                    : ["editor_operation_output_missing"],
+            session,
+            operation: input.operation,
+            output: null,
+            help: null,
+            artifacts,
+        };
+    }
+    const ok = runnerOutput.ok === true;
+    return {
+        targetPath: paths.targetRootPath,
+        state: ok ? "ok" : "failed",
+        summary: runnerOutput.summary ?? (ok ? "Editor operation completed." : "Editor operation failed."),
+        reasons: runnerOutput.reasons ?? [],
+        session,
+        operation: input.operation,
+        output: runnerOutput.output ?? null,
+        help: runnerOutput.help ?? null,
+        artifacts,
+    };
+}
+async function runAdoptedEditorOperation(input) {
+    const adopted = await inspectAdoptedEditor(input.paths);
+    if (adopted.state !== "ready") {
+        return {
+            targetPath: input.paths.targetRootPath,
+            state: "blocked",
+            summary: adopted.summaryText,
+            reasons: adopted.reasons,
+            session: input.session,
+            operation: input.input.operation,
+            output: null,
+            help: null,
+            artifacts: null,
+        };
+    }
+    const artifacts = await createOperationArtifacts({
+        paths: input.paths,
+        operation: input.input.operation,
+        retainOperationArtifacts: input.input.retainOperationArtifacts,
+        includeRunner: false,
+    });
+    const runnerOutput = await (input.input.invokeAdoptedEditor ?? invokeAdoptedEditorOperation)({
+        metadata: adopted.metadata,
+        token: adopted.token,
+        identity: input.paths.identity,
+        operation: input.input.operation,
+        timeoutMs: input.input.timeoutMs ?? DEFAULT_EDITOR_OPERATION_TIMEOUT_MS,
+    }).catch(async (error) => {
+        const summary = error instanceof Error ? error.message : "Adopted editor operation request failed.";
+        await fs.writeFile(artifacts.stderrPath, `${summary}\n`, "utf8");
+        return {
+            ok: false,
+            summary,
+            reasons: ["adopted_editor_request_failed"],
+            output: null,
+        };
+    });
+    await fs.writeFile(artifacts.outputPath, `${JSON.stringify(runnerOutput, null, 2)}\n`, "utf8");
+    const ok = runnerOutput.ok === true;
+    return {
+        targetPath: input.paths.targetRootPath,
+        state: ok ? "ok" : "failed",
+        summary: runnerOutput.summary ?? (ok ? "Editor operation completed." : "Editor operation failed."),
+        reasons: runnerOutput.reasons ?? [],
+        session: input.session,
+        operation: input.input.operation,
+        output: runnerOutput.output ?? null,
+        help: runnerOutput.help ?? null,
+        artifacts,
+    };
+}
+async function inspectAdoptedEditor(paths) {
+    const metadata = await readAdoptedEditorMetadata(paths.adoptedMetadataPath);
+    if (metadata === null) {
+        return adoptedEditorUnavailable("No adopted editor metadata is registered.", [
+            "adopted_editor_not_found",
+        ]);
+    }
+    const reasons = validateAdoptedEditorMetadata(paths, metadata);
+    const token = await readTrimmedFile(paths.adoptedTokenPath);
+    if (token === null)
+        reasons.push("adopted_editor_token_missing");
+    if (metadata.pid !== null && !isProcessAlive(metadata.pid)) {
+        reasons.push("adopted_editor_process_not_alive");
+    }
+    const heartbeatMs = Date.parse(metadata.lastHeartbeatAt);
+    if (!Number.isFinite(heartbeatMs) ||
+        Date.now() - heartbeatMs > EDITOR_ADOPTION_HEARTBEAT_STALE_AFTER_MS) {
+        reasons.push("adopted_editor_heartbeat_stale");
+    }
+    if (reasons.length > 0 || token === null) {
+        return adoptedEditorUnavailable("Registered adopted editor session is stale, incompatible, or incomplete.", reasons.length > 0 ? reasons : ["adopted_editor_unavailable"]);
+    }
+    return {
+        state: "ready",
+        reasons: ["adopted_editor_available"],
+        summaryText: "Adopted editor session is available for the exact target/worktree.",
+        metadata,
+        token,
+        summary: summarizeAdoptedEditor(metadata),
+    };
+}
+function validateAdoptedEditorMetadata(paths, metadata) {
+    const reasons = [];
+    if (metadata.protocolVersion !== EDITOR_ADOPTION_PROTOCOL_VERSION) {
+        reasons.push("adopted_editor_protocol_mismatch");
+    }
+    if (metadata.bridgeSurfaceVersion !== GDH_RUNTIME_BRIDGE_SURFACE_VERSION) {
+        reasons.push("adopted_editor_surface_version_mismatch");
+    }
+    if (metadata.host !== "127.0.0.1") {
+        reasons.push("adopted_editor_host_not_loopback");
+    }
+    if (!Number.isInteger(metadata.port) || metadata.port <= 0 || metadata.port > 65_535) {
+        reasons.push("adopted_editor_port_invalid");
+    }
+    if (metadata.metadataPath !== paths.adoptedMetadataPath) {
+        reasons.push("adopted_editor_metadata_path_mismatch");
+    }
+    if (metadata.tokenFilePath !== paths.adoptedTokenPath) {
+        reasons.push("adopted_editor_token_path_mismatch");
+    }
+    if (metadata.heartbeatPath !== paths.adoptedHeartbeatPath) {
+        reasons.push("adopted_editor_heartbeat_path_mismatch");
+    }
+    if (metadata.targetIdentity.identityKey !== paths.identity.identityKey) {
+        reasons.push("adopted_editor_identity_mismatch");
+    }
+    return reasons;
+}
+function adoptedEditorUnavailable(summaryText, reasons) {
+    return {
+        state: "unavailable",
+        reasons,
+        summaryText,
+        metadata: null,
+        token: null,
+        summary: null,
+    };
+}
+function summarizeAdoptedEditor(metadata) {
+    return {
+        host: metadata.host,
+        port: metadata.port,
+        pid: metadata.pid,
+        metadataPath: metadata.metadataPath,
+        tokenFilePath: metadata.tokenFilePath,
+        heartbeatPath: metadata.heartbeatPath,
+        startedAt: metadata.startedAt,
+        lastHeartbeatAt: metadata.lastHeartbeatAt,
+    };
+}
+async function createOperationArtifacts(input) {
+    await fs.mkdir(input.paths.operationsDirectory, { recursive: true });
+    await pruneOperationArtifacts(input.paths.operationsDirectory, input.retainOperationArtifacts);
+    const operationId = randomUUID();
+    const operationDirectory = path.join(input.paths.operationsDirectory, operationId);
+    await fs.mkdir(operationDirectory, { recursive: true });
+    const inputPath = path.join(operationDirectory, EDITOR_OPERATION_INPUT_FILE);
+    const outputPath = path.join(operationDirectory, EDITOR_OPERATION_OUTPUT_FILE);
+    const runnerPath = input.includeRunner
+        ? path.join(operationDirectory, EDITOR_OPERATION_RUNNER_FILE)
+        : null;
+    const stdoutPath = path.join(operationDirectory, "stdout.log");
+    const stderrPath = path.join(operationDirectory, "stderr.log");
+    await fs.writeFile(inputPath, `${JSON.stringify({ operation: input.operation }, null, 2)}\n`, "utf8");
+    await fs.writeFile(stdoutPath, "", "utf8");
+    await fs.writeFile(stderrPath, "", "utf8");
+    return {
+        operationId,
+        directory: operationDirectory,
+        inputPath,
+        outputPath,
+        runnerPath,
+        stdoutPath,
+        stderrPath,
+    };
+}
+async function invokeAdoptedEditorOperation(input) {
+    const body = JSON.stringify({
+        id: `editor-operation-${Date.now()}-${Math.random().toString(16).slice(2)}`,
+        protocolVersion: EDITOR_ADOPTION_PROTOCOL_VERSION,
+        targetIdentity: input.identity,
+        operation: input.operation,
+    });
+    return await new Promise((resolve, reject) => {
+        const request = http.request({
+            host: input.metadata.host,
+            port: input.metadata.port,
+            method: "POST",
+            path: "/operation",
+            timeout: input.timeoutMs,
+            headers: {
+                authorization: `Bearer ${input.token}`,
+                "content-type": "application/json",
+                "content-length": Buffer.byteLength(body),
+            },
+        }, (response) => {
+            const chunks = [];
+            response.on("data", (chunk) => {
+                chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+            });
+            response.on("end", () => {
+                const text = Buffer.concat(chunks).toString("utf8");
+                if (response.statusCode !== 200) {
+                    reject(new Error(`Adopted editor request failed with HTTP ${response.statusCode}: ${text}`));
+                    return;
+                }
+                resolve(JSON.parse(text));
+            });
+        });
+        request.on("timeout", () => {
+            request.destroy(new Error("Adopted editor operation timed out."));
+        });
+        request.on("error", reject);
+        request.end(body);
+    });
+}
+async function readAdoptedEditorMetadata(metadataPath) {
+    try {
+        return JSON.parse(await fs.readFile(metadataPath, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+async function readTrimmedFile(filePath) {
+    try {
+        const value = (await fs.readFile(filePath, "utf8")).trim();
+        return value.length > 0 ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isProcessAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function resolveGodotEditorBin(input) {
+    if (input.godotEditorBin)
+        return input.godotEditorBin;
+    return await resolveConfiguredGodotEditorBin({
+        targetPath: input.targetPath,
+    }).catch(() => null);
+}
+async function spawnEditorProcess(input) {
+    return await new Promise((resolve) => {
+        const child = spawn(input.command, [...input.args], {
+            cwd: input.cwd,
+            env: input.env,
+            stdio: ["ignore", "pipe", "pipe"],
+            windowsHide: true,
+            shell: false,
+        });
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        const timeout = setTimeout(() => {
+            child.kill("SIGTERM");
+        }, input.timeoutMs);
+        child.stdout?.setEncoding("utf8");
+        child.stderr?.setEncoding("utf8");
+        child.stdout?.on("data", (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr?.on("data", (chunk) => {
+            stderr += chunk;
+        });
+        child.on("error", (error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            resolve({ exitCode: 1, signal: null, stdout, stderr: `${stderr}${String(error.message)}\n` });
+        });
+        child.on("close", (exitCode, signal) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            resolve({ exitCode, signal, stdout, stderr });
+        });
+    });
+}
+async function readRunnerOutput(outputPath) {
+    const content = await fs.readFile(outputPath, "utf8").catch(() => null);
+    if (content === null)
+        return null;
+    try {
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+async function pruneOperationArtifacts(operationsDirectory, retainCount = DEFAULT_RETAIN_OPERATION_ARTIFACTS) {
+    if (retainCount <= 0)
+        return;
+    const entries = await fs.readdir(operationsDirectory, { withFileTypes: true }).catch(() => []);
+    const directories = await Promise.all(entries
+        .filter((entry) => entry.isDirectory())
+        .map(async (entry) => {
+        const absolutePath = path.join(operationsDirectory, entry.name);
+        const stat = await fs.stat(absolutePath).catch(() => null);
+        return stat === null ? null : { absolutePath, mtimeMs: stat.mtimeMs };
+    }));
+    const sorted = directories
+        .filter((entry) => entry !== null)
+        .sort((left, right) => right.mtimeMs - left.mtimeMs);
+    await Promise.all(sorted
+        .slice(retainCount)
+        .map((entry) => fs.rm(entry.absolutePath, { recursive: true, force: true })));
+}
+export function renderEditorOperationRunner() {
+    return `extends SceneTree
+
+func _init() -> void:
+	var input_path := OS.get_environment("GDH_EDITOR_OPERATION_INPUT")
+	var output_path := OS.get_environment("GDH_EDITOR_OPERATION_OUTPUT")
+	var result := _run_operation(input_path)
+	_write_json(output_path, result)
+	quit(0)
+
+func _run_operation(input_path: String) -> Dictionary:
+	var input_text := FileAccess.get_file_as_string(input_path)
+	var parsed = JSON.parse_string(input_text)
+	if typeof(parsed) != TYPE_DICTIONARY:
+		return _failure("Invalid editor operation input JSON.", ["input_json_invalid"])
+	var operation = parsed.get("operation", {})
+	if typeof(operation) != TYPE_DICTIONARY:
+		return _failure("Missing editor operation payload.", ["operation_missing"])
+	return run_editor_operation(operation)
+
+func run_editor_operation(operation: Dictionary) -> Dictionary:
+	return _dispatch_operation(operation)
+
+func _dispatch_operation(operation: Dictionary) -> Dictionary:
+	var kind := str(operation.get("kind", ""))
+	if kind == "":
+		var type_value := str(operation.get("type", ""))
+		if type_value != "":
+			return _failure("Editor operation payload used type='" + type_value + "', but GDH dispatches editor operations with kind. Use operation.kind instead.", ["operation_kind_missing", "operation_type_unsupported"], _operation_help(type_value))
+		return _failure("Editor operation payload is missing kind.", ["operation_kind_missing"], _operation_help("editor.state"))
+	match kind:
+		"scene.create":
+			return _scene_create(operation)
+		"scene.tree":
+			return _scene_tree(operation)
+		"scene.save":
+			return _scene_save(operation)
+		"node.add":
+			return _node_add(operation)
+		"node.remove":
+			return _node_remove(operation)
+		"node.reparent":
+			return _node_reparent(operation)
+		"node.duplicate":
+			return _node_duplicate(operation)
+		"node.set_property":
+			return _node_set_property(operation)
+		"node.get_property":
+			return _node_get_property(operation)
+		"node.inspect":
+			return _node_inspect(operation)
+		"resource.create":
+			return _resource_create(operation)
+		"resource.read":
+			return _resource_read(operation)
+		"resource.properties":
+			return _resource_properties(operation)
+		"resource.set_property":
+			return _resource_set_property(operation)
+		"script.attach":
+			return _script_attach(operation)
+		"class.search":
+			return _class_search(operation)
+		"class.info":
+			return _class_info(operation)
+		"editor.state":
+			return _editor_state(operation)
+		"batch.apply":
+			return _batch_apply(operation)
+		_:
+			return _failure("Unsupported editor operation: " + kind, ["operation_unsupported"], _operation_help(kind))
+
+func _scene_create(operation: Dictionary) -> Dictionary:
+	var scene_path := _res_path(str(operation.get("scenePath", "")))
+	if scene_path == "res://":
+		return _failure("scenePath is required.", ["scene_path_missing"])
+	var root_type := str(operation.get("rootNodeType", "Node"))
+	var root = _instantiate(root_type)
+	if root == null or not (root is Node):
+		return _failure("Unable to instantiate root node type: " + root_type, ["root_node_type_invalid"])
+	root.name = str(operation.get("rootNodeName", root_type))
+	_set_properties(root, operation.get("properties", {}))
+	var packed := PackedScene.new()
+	var pack_err := packed.pack(root)
+	if pack_err != OK:
+		return _failure("Failed to pack scene.", ["scene_pack_failed"])
+	_ensure_parent_dir(scene_path)
+	var save_err := ResourceSaver.save(packed, scene_path)
+	if save_err != OK:
+		return _failure("Failed to save scene: " + scene_path, ["scene_save_failed"])
+	return _success("Scene created.", {"scenePath": scene_path, "rootNodeType": root_type, "rootNodeName": root.name})
+
+func _scene_tree(operation: Dictionary) -> Dictionary:
+	var scene_path := _res_path(str(operation.get("scenePath", "")))
+	if scene_path == "res://":
+		return _failure("scene.tree requires scenePath.", ["scene_path_missing"], _operation_help("scene.tree"))
+	var loaded = load(scene_path)
+	if loaded == null or not (loaded is PackedScene):
+		return _failure("Scene could not be loaded: " + scene_path, ["scene_load_failed"])
+	var root = loaded.instantiate()
+	if root == null:
+		return _failure("Scene could not be instantiated: " + scene_path, ["scene_instantiate_failed"])
+	var max_depth := int(operation.get("maxDepth", -1))
+	var tree := _node_summary(root, ".", 0, max_depth)
+	root.queue_free()
+	return _success("Scene tree loaded.", {"scenePath": scene_path, "tree": tree})
+
+func _scene_save(operation: Dictionary) -> Dictionary:
+	var scene_path := _res_path(str(operation.get("scenePath", "")))
+	var root = _load_scene_root(scene_path)
+	if root == null:
+		return _failure("Scene could not be loaded: " + scene_path, ["scene_load_failed"])
+	return _save_instantiated_scene(root, scene_path)
+
+func _node_add(operation: Dictionary) -> Dictionary:
+	var scene_path := _res_path(str(operation.get("scenePath", "")))
+	var loaded = load(scene_path)
+	if loaded == null or not (loaded is PackedScene):
+		return _failure("Scene could not be loaded: " + scene_path, ["scene_load_failed"])
+	var root = loaded.instantiate()
+	var parent_path := str(operation.get("parentNodePath", "."))
+	var parent = _find_node(root, parent_path)
+	if parent == null:
+		return _failure("Parent node not found: " + parent_path, ["parent_node_not_found"])
+	var node_type := str(operation.get("nodeType", ""))
+	var node = _instantiate(node_type)
+	if node == null or not (node is Node):
+		return _failure("Unable to instantiate node type: " + node_type, ["node_type_invalid"])
+	node.name = str(operation.get("nodeName", node_type))
+	_set_properties(node, operation.get("properties", {}))
+	parent.add_child(node)
+	_set_owner_recursive(node, root)
+	var result := _save_instantiated_scene(root, scene_path)
+	if not result.get("ok", false):
+		return result
+	return _success("Node added.", {"scenePath": scene_path, "nodePath": str(root.get_path_to(node)), "nodeType": node_type, "nodeName": node.name})
+
+func _node_remove(operation: Dictionary) -> Dictionary:
+	var scene_path := _res_path(str(operation.get("scenePath", "")))
+	var root = _load_scene_root(scene_path)
+	if root == null:
+		return _failure("Scene could not be loaded: " + scene_path, ["scene_load_failed"])
+	var node_path := str(operation.get("nodePath", ""))
+	var node = _find_node(root, node_path)
+	if node == null or node == root:
+		return _failure("Node not removable: " + node_path, ["node_not_removable"])
+	var parent = node.get_parent()
+	if parent == null:
+		return _failure("Node parent not found: " + node_path, ["node_parent_not_found"])
+	parent.remove_child(node)
+	node.free()
+	var result := _save_instantiated_scene(root, scene_path)
+	if not result.get("ok", false):
+		return result
+	return _success("Node removed.", {"scenePath": scene_path, "nodePath": node_path})
+
+func _node_reparent(operation: Dictionary) -> Dictionary:
+	var scene_path := _res_path(str(operation.get("scenePath", "")))
+	var root = _load_scene_root(scene_path)
+	if root == null:
+		return _failure("Scene could not be loaded: " + scene_path, ["scene_load_failed"])
+	var node_path := str(operation.get("nodePath", ""))
+	var new_parent_path := str(operation.get("newParentNodePath", ""))
+	var node = _find_node(root, node_path)
+	var new_parent = _find_node(root, new_parent_path)
+	if node == null or node == root:
+		return _failure("Node not reparentable: " + node_path, ["node_not_reparentable"])
+	if new_parent == null:
+		return _failure("New parent node not found: " + new_parent_path, ["new_parent_node_not_found"])
+	if node == new_parent or node.is_ancestor_of(new_parent):
+		return _failure("Cannot reparent a node below itself.", ["node_reparent_cycle"])
+	var old_parent = node.get_parent()
+	if old_parent == null:
+		return _failure("Node parent not found: " + node_path, ["node_parent_not_found"])
+	old_parent.remove_child(node)
+	new_parent.add_child(node)
+	_set_owner_recursive(node, root)
+	var result := _save_instantiated_scene(root, scene_path)
+	if not result.get("ok", false):
+		return result
+	return _success("Node reparented.", {"scenePath": scene_path, "nodePath": str(root.get_path_to(node)), "newParentNodePath": new_parent_path})
+
+func _node_duplicate(operation: Dictionary) -> Dictionary:
+	var scene_path := _res_path(str(operation.get("scenePath", "")))
+	var root = _load_scene_root(scene_path)
+	if root == null:
+		return _failure("Scene could not be loaded: " + scene_path, ["scene_load_failed"])
+	var node_path := str(operation.get("nodePath", ""))
+	var node = _find_node(root, node_path)
+	if node == null:
+		return _failure("Node not found: " + node_path, ["node_not_found"])
+	var parent_path := str(operation.get("parentNodePath", ""))
+	var parent = _find_node(root, parent_path) if not parent_path.is_empty() else node.get_parent()
+	if parent == null:
+		return _failure("Duplicate parent node not found.", ["duplicate_parent_node_not_found"])
+	var duplicate = node.duplicate()
+	if duplicate == null or not (duplicate is Node):
+		return _failure("Node could not be duplicated: " + node_path, ["node_duplicate_failed"])
+	var requested_name := str(operation.get("newNodeName", ""))
+	if not requested_name.is_empty():
+		duplicate.name = requested_name
+	parent.add_child(duplicate)
+	_set_owner_recursive(duplicate, root)
+	var result := _save_instantiated_scene(root, scene_path)
+	if not result.get("ok", false):
+		return result
+	return _success("Node duplicated.", {"scenePath": scene_path, "sourceNodePath": node_path, "nodePath": str(root.get_path_to(duplicate)), "nodeName": duplicate.name})
+
+func _node_set_property(operation: Dictionary) -> Dictionary:
+	var scene_path := _res_path(str(operation.get("scenePath", "")))
+	var root = _load_scene_root(scene_path)
+	if root == null:
+		return _failure("Scene could not be loaded: " + scene_path, ["scene_load_failed"])
+	var node_path := str(operation.get("nodePath", ""))
+	var node = _find_node(root, node_path)
+	if node == null:
+		return _failure("Node not found: " + node_path, ["node_not_found"])
+	var property_name := str(operation.get("propertyName", ""))
+	node.set(property_name, _decode_value(operation.get("value")))
+	var result := _save_instantiated_scene(root, scene_path)
+	if not result.get("ok", false):
+		return result
+	return _success("Node property set.", {"scenePath": scene_path, "nodePath": node_path, "propertyName": property_name})
+
+func _node_get_property(operation: Dictionary) -> Dictionary:
+	var scene_path := _res_path(str(operation.get("scenePath", "")))
+	var root = _load_scene_root(scene_path)
+	if root == null:
+		return _failure("Scene could not be loaded: " + scene_path, ["scene_load_failed"])
+	var node_path := str(operation.get("nodePath", ""))
+	var node = _find_node(root, node_path)
+	if node == null:
+		return _failure("Node not found: " + node_path, ["node_not_found"])
+	var property_name := str(operation.get("propertyName", ""))
+	var value = _encode_value(node.get(property_name))
+	root.queue_free()
+	return _success("Node property read.", {"scenePath": scene_path, "nodePath": node_path, "propertyName": property_name, "value": value})
+
+func _node_inspect(operation: Dictionary) -> Dictionary:
+	var scene_path := _res_path(str(operation.get("scenePath", "")))
+	if scene_path == "res://":
+		return _failure("node.inspect requires scenePath.", ["scene_path_missing"], _operation_help("node.inspect"))
+	var root = _load_scene_root(scene_path)
+	if root == null:
+		return _failure("Scene could not be loaded: " + scene_path, ["scene_load_failed"])
+	var node_path := str(operation.get("nodePath", "."))
+	var node = _find_node(root, node_path)
+	if node == null:
+		root.queue_free()
+		return _failure("Node not found: " + node_path, ["node_not_found"])
+	var property_names = operation.get("propertyNames", [])
+	var properties := {}
+	if typeof(property_names) == TYPE_ARRAY:
+		for property_name in property_names:
+			var key := str(property_name)
+			properties[key] = _encode_value(node.get(key))
+	var property_list := []
+	if bool(operation.get("includePropertyList", false)):
+		property_list = _filter_property_list(node.get_property_list(), str(operation.get("propertyQuery", "")), int(operation.get("propertyLimit", 50)))
+	var summary := _node_summary(node, node_path, 0, 0)
+	root.queue_free()
+	return _success("Node inspected.", {"scenePath": scene_path, "nodePath": node_path, "node": summary, "properties": properties, "propertyList": property_list})
+
+func _resource_create(operation: Dictionary) -> Dictionary:
+	var resource_path := _res_path(str(operation.get("resourcePath", "")))
+	var resource_type := str(operation.get("resourceType", ""))
+	var resource = _instantiate(resource_type)
+	if resource == null or not (resource is Resource):
+		return _failure("Unable to instantiate resource type: " + resource_type, ["resource_type_invalid"])
+	_set_properties(resource, operation.get("properties", {}))
+	_ensure_parent_dir(resource_path)
+	var save_err := ResourceSaver.save(resource, resource_path)
+	if save_err != OK:
+		return _failure("Failed to save resource: " + resource_path, ["resource_save_failed"])
+	return _success("Resource created.", {"resourcePath": resource_path, "resourceType": resource_type})
+
+func _resource_read(operation: Dictionary) -> Dictionary:
+	var resource_path := _res_path(str(operation.get("resourcePath", "")))
+	if resource_path == "res://":
+		return _failure("resource.read requires resourcePath.", ["resource_path_missing"], _operation_help("resource.read"))
+	var resource = load(resource_path)
+	if resource == null or not (resource is Resource):
+		return _failure("Resource could not be loaded: " + resource_path, ["resource_load_failed"])
+	var property_names = operation.get("propertyNames", [])
+	var properties := {}
+	if typeof(property_names) == TYPE_ARRAY:
+		for property_name in property_names:
+			var key := str(property_name)
+			properties[key] = _encode_value(resource.get(key))
+	var script = resource.get_script()
+	return _success("Resource read.", {"resourcePath": resource_path, "class": resource.get_class(), "scriptPath": script.resource_path if script else null, "properties": properties})
+
+func _resource_properties(operation: Dictionary) -> Dictionary:
+	var resource_path := _res_path(str(operation.get("resourcePath", "")))
+	if resource_path == "res://":
+		return _failure("resource.properties requires resourcePath.", ["resource_path_missing"], _operation_help("resource.properties"))
+	var resource = load(resource_path)
+	if resource == null or not (resource is Resource):
+		return _failure("Resource could not be loaded: " + resource_path, ["resource_load_failed"])
+	var script = resource.get_script()
+	var properties := _filter_property_list(resource.get_property_list(), str(operation.get("propertyQuery", "")), int(operation.get("propertyLimit", 80)))
+	return _success("Resource properties loaded.", {"resourcePath": resource_path, "class": resource.get_class(), "scriptPath": script.resource_path if script else null, "properties": properties, "propertiesTruncated": properties.size() >= int(operation.get("propertyLimit", 80))})
+
+func _resource_set_property(operation: Dictionary) -> Dictionary:
+	var resource_path := _res_path(str(operation.get("resourcePath", "")))
+	var resource = load(resource_path)
+	if resource == null or not (resource is Resource):
+		return _failure("Resource could not be loaded: " + resource_path, ["resource_load_failed"])
+	var property_name := str(operation.get("propertyName", ""))
+	resource.set(property_name, _decode_value(operation.get("value")))
+	var save_err := ResourceSaver.save(resource, resource_path)
+	if save_err != OK:
+		return _failure("Failed to save resource: " + resource_path, ["resource_save_failed"])
+	return _success("Resource property set.", {"resourcePath": resource_path, "propertyName": property_name})
+
+func _script_attach(operation: Dictionary) -> Dictionary:
+	var scene_path := _res_path(str(operation.get("scenePath", "")))
+	var root = _load_scene_root(scene_path)
+	if root == null:
+		return _failure("Scene could not be loaded: " + scene_path, ["scene_load_failed"])
+	var node_path := str(operation.get("nodePath", ""))
+	var node = _find_node(root, node_path)
+	if node == null:
+		return _failure("Node not found: " + node_path, ["node_not_found"])
+	var script_path := _res_path(str(operation.get("scriptPath", "")))
+	var script = load(script_path)
+	if script == null or not (script is Script):
+		return _failure("Script could not be loaded: " + script_path, ["script_load_failed"])
+	node.set_script(script)
+	var result := _save_instantiated_scene(root, scene_path)
+	if not result.get("ok", false):
+		return result
+	return _success("Script attached.", {"scenePath": scene_path, "nodePath": node_path, "scriptPath": script_path})
+
+func _class_search(operation: Dictionary) -> Dictionary:
+	var query := str(operation.get("query", "")).to_lower()
+	var base_class := str(operation.get("baseClass", ""))
+	var instantiable_only := bool(operation.get("instantiableOnly", true))
+	var limit := int(operation.get("limit", 50))
+	var classes := []
+	var seen := {}
+	for class_id in ClassDB.get_class_list():
+		if query != "" and not str(class_id).to_lower().contains(query):
+			continue
+		if base_class != "" and class_id != base_class and not ClassDB.is_parent_class(class_id, base_class):
+			continue
+		if instantiable_only and not ClassDB.can_instantiate(class_id):
+			continue
+		classes.append({"name": class_id, "source": "class_db", "baseClass": ClassDB.get_parent_class(class_id), "instantiable": ClassDB.can_instantiate(class_id)})
+		seen[class_id] = true
+		if classes.size() >= limit:
+			break
+	for entry in ProjectSettings.get_global_class_list():
+		var class_id := str(entry.get("class", ""))
+		if seen.has(class_id):
+			continue
+		if query != "" and not class_id.to_lower().contains(query):
+			continue
+		if base_class != "" and str(entry.get("base", "")) != base_class:
+			continue
+		classes.append({"name": class_id, "source": "global_class", "baseClass": str(entry.get("base", "")), "path": str(entry.get("path", "")), "instantiable": true})
+		seen[class_id] = true
+		if classes.size() >= limit:
+			break
+	for entry in _script_class_entries():
+		var class_id := str(entry.get("class", ""))
+		if seen.has(class_id):
+			continue
+		if query != "" and not class_id.to_lower().contains(query):
+			continue
+		if base_class != "" and str(entry.get("base", "")) != base_class:
+			continue
+		classes.append({"name": class_id, "source": "script_scan", "baseClass": str(entry.get("base", "")), "path": str(entry.get("path", "")), "instantiable": true})
+		seen[class_id] = true
+		if classes.size() >= limit:
+			break
+	return _success("Class search completed.", {"classes": classes, "truncated": classes.size() >= limit})
+
+func _class_info(operation: Dictionary) -> Dictionary:
+	var class_id := str(operation.get("className", ""))
+	var property_query := str(operation.get("propertyQuery", "")).to_lower()
+	var property_limit := int(operation.get("propertyLimit", 50))
+	var properties := []
+	if ClassDB.class_exists(class_id):
+		for property in ClassDB.class_get_property_list(class_id, bool(operation.get("includeInherited", true))):
+			var name := str(property.get("name", ""))
+			if property_query != "" and not name.to_lower().contains(property_query):
+				continue
+			properties.append(_property_summary(property))
+			if properties.size() >= property_limit:
+				break
+		return _success("Class info loaded.", {"className": class_id, "source": "class_db", "parentClass": ClassDB.get_parent_class(class_id), "instantiable": ClassDB.can_instantiate(class_id), "properties": properties, "propertiesTruncated": properties.size() >= property_limit})
+	var script_class := _find_script_class(class_id)
+	if script_class.size() > 0:
+		var script_path := str(script_class.get("path", ""))
+		var script = load(script_path)
+		if script and script.has_method("get_script_property_list"):
+			for property in script.get_script_property_list():
+				var name := str(property.get("name", ""))
+				if property_query != "" and not name.to_lower().contains(property_query):
+					continue
+				properties.append(_property_summary(property))
+				if properties.size() >= property_limit:
+					break
+		return _success("Class info loaded.", {"className": class_id, "source": str(script_class.get("source", "script_scan")), "path": script_path, "parentClass": str(script_class.get("base", "")), "instantiable": true, "properties": properties, "propertiesTruncated": properties.size() >= property_limit})
+	return _failure("Class not found: " + class_id, ["class_not_found"])
+
+func _editor_state(_operation: Dictionary) -> Dictionary:
+	var editor_interface = _editor_interface()
+	var current_scene_path = null
+	var open_scenes := []
+	var selected_node_paths := []
+	if editor_interface != null:
+		if editor_interface.has_method("get_open_scenes"):
+			for scene_path in editor_interface.get_open_scenes():
+				open_scenes.append(str(scene_path))
+		var edited_root = editor_interface.get_edited_scene_root()
+		if edited_root != null:
+			current_scene_path = edited_root.scene_file_path
+		var selection = editor_interface.get_selection()
+		if selection != null:
+			for selected_node in selection.get_selected_nodes():
+				if edited_root != null and selected_node is Node:
+					selected_node_paths.append(str(edited_root.get_path_to(selected_node)))
+				else:
+					selected_node_paths.append(str(selected_node.get_path()))
+	return _success("Editor state loaded.", {
+		"projectName": ProjectSettings.get_setting("application/config/name", ""),
+		"engineVersion": Engine.get_version_info().get("string", ""),
+		"features": ProjectSettings.get_setting("application/config/features", []),
+		"godotProjectRootPath": ProjectSettings.globalize_path("res://"),
+		"editorContextAvailable": editor_interface != null,
+		"currentScenePath": current_scene_path,
+		"openScenes": open_scenes,
+		"dirtyScenes": [],
+		"selectedNodePaths": selected_node_paths,
+	})
+
+func _batch_apply(operation: Dictionary) -> Dictionary:
+	var operations = operation.get("operations", [])
+	if typeof(operations) != TYPE_ARRAY:
+		return _failure("batch.apply requires operations array.", ["batch_operations_invalid"])
+	var results := []
+	for child_operation in operations:
+		if typeof(child_operation) != TYPE_DICTIONARY:
+			return _failure("batch.apply child operation must be an object.", ["batch_child_operation_invalid"])
+		var result := _dispatch_operation(child_operation)
+		results.append(result)
+		if not result.get("ok", false):
+			return _failure("Batch operation failed.", ["batch_child_failed", str(child_operation.get("kind", ""))])
+	return _success("Batch applied.", {"results": results})
+
+func _load_scene_root(scene_path: String):
+	var loaded = load(scene_path)
+	if loaded == null or not (loaded is PackedScene):
+		return null
+	return loaded.instantiate()
+
+func _save_instantiated_scene(root: Node, scene_path: String) -> Dictionary:
+	var packed := PackedScene.new()
+	var pack_err := packed.pack(root)
+	if pack_err != OK:
+		return _failure("Failed to pack scene.", ["scene_pack_failed"])
+	var save_err := ResourceSaver.save(packed, scene_path)
+	if save_err != OK:
+		return _failure("Failed to save scene: " + scene_path, ["scene_save_failed"])
+	return _success("Scene saved.", {"scenePath": scene_path})
+
+func _instantiate(class_id: String):
+	if class_id == "":
+		return null
+	if ClassDB.class_exists(class_id) and ClassDB.can_instantiate(class_id):
+		return ClassDB.instantiate(class_id)
+	var script_class := _find_script_class(class_id)
+	if script_class.size() > 0:
+		var script = load(str(script_class.get("path", "")))
+		if script and script.has_method("new"):
+			return script.new()
+	return null
+
+func _set_properties(object: Object, properties) -> void:
+	if typeof(properties) != TYPE_DICTIONARY:
+		return
+	for property_name in properties.keys():
+		object.set(str(property_name), _decode_value(properties[property_name]))
+
+func _decode_value(value):
+	if typeof(value) == TYPE_DICTIONARY:
+		if value.has("$resource"):
+			return load(_res_path(str(value["$resource"])))
+		if value.has("$vector2"):
+			var vector = value["$vector2"]
+			return Vector2(float(vector.get("x", 0.0)), float(vector.get("y", 0.0)))
+		if value.has("$color"):
+			var color = value["$color"]
+			return Color(float(color.get("r", 0.0)), float(color.get("g", 0.0)), float(color.get("b", 0.0)), float(color.get("a", 1.0)))
+	return value
+
+func _encode_value(value, depth := 0):
+	if value == null:
+		return null
+	if depth >= 4:
+		return {"$truncated": "max_depth", "text": str(value)}
+	if value is Vector2:
+		return {"$vector2": {"x": value.x, "y": value.y}}
+	if value is Color:
+		return {"$color": {"r": value.r, "g": value.g, "b": value.b, "a": value.a}}
+	if value is Resource:
+		var resource_path: String = value.resource_path
+		return {"$resource": resource_path if resource_path != "" else null, "class": value.get_class(), "text": str(value)}
+	var value_type := typeof(value)
+	if value_type in [TYPE_BOOL, TYPE_INT, TYPE_FLOAT, TYPE_STRING]:
+		return value
+	if value_type == TYPE_ARRAY:
+		var encoded := []
+		var count := 0
+		for item in value:
+			if count >= 100:
+				encoded.append({"$truncated": "max_items"})
+				break
+			encoded.append(_encode_value(item, depth + 1))
+			count += 1
+		return encoded
+	if value_type == TYPE_DICTIONARY:
+		var encoded_dict := {}
+		var count := 0
+		for key in value.keys():
+			if count >= 100:
+				encoded_dict["$truncated"] = "max_items"
+				break
+			encoded_dict[str(key)] = _encode_value(value[key], depth + 1)
+			count += 1
+		return encoded_dict
+	return str(value)
+
+func _property_summary(property: Dictionary) -> Dictionary:
+	return {"name": str(property.get("name", "")), "type": int(property.get("type", TYPE_NIL)), "hint": int(property.get("hint", 0)), "usage": int(property.get("usage", 0))}
+
+func _filter_property_list(property_list: Array, query: String, limit: int) -> Array:
+	var lowered_query := query.to_lower()
+	var effective_limit := limit if limit > 0 else 50
+	var properties := []
+	for property in property_list:
+		var name := str(property.get("name", ""))
+		if lowered_query != "" and not name.to_lower().contains(lowered_query):
+			continue
+		properties.append(_property_summary(property))
+		if properties.size() >= effective_limit:
+			break
+	return properties
+
+func _editor_interface():
+	var plugin = get("_plugin")
+	if plugin == null:
+		return null
+	if plugin.has_method("get_editor_interface"):
+		return plugin.get_editor_interface()
+	return null
+
+func _find_script_class(class_id: String) -> Dictionary:
+	for entry in ProjectSettings.get_global_class_list():
+		if str(entry.get("class", "")) == class_id:
+			return {"class": class_id, "base": str(entry.get("base", "")), "path": str(entry.get("path", "")), "source": "global_class"}
+	for entry in _script_class_entries():
+		if str(entry.get("class", "")) == class_id:
+			return entry
+	return {}
+
+func _script_class_entries() -> Array:
+	var entries := []
+	_collect_script_class_entries("res://", entries)
+	return entries
+
+func _collect_script_class_entries(directory_path: String, entries: Array) -> void:
+	var dir := DirAccess.open(directory_path)
+	if dir == null:
+		return
+	dir.list_dir_begin()
+	var entry_name := dir.get_next()
+	while entry_name != "":
+		if entry_name.begins_with("."):
+			entry_name = dir.get_next()
+			continue
+		var entry_path := directory_path.path_join(entry_name)
+		if dir.current_is_dir():
+			_collect_script_class_entries(entry_path, entries)
+		elif entry_name.ends_with(".gd"):
+			var script_class := _read_script_class_entry(entry_path)
+			if script_class.size() > 0:
+				entries.append(script_class)
+		entry_name = dir.get_next()
+	dir.list_dir_end()
+
+func _read_script_class_entry(script_path: String) -> Dictionary:
+	var source := FileAccess.get_file_as_string(script_path)
+	var class_id := ""
+	var base_class := ""
+	for raw_line in source.split("\n"):
+		var line := str(raw_line).strip_edges()
+		if line.begins_with("class_name "):
+			var class_tokens := line.split(" ", false)
+			if class_tokens.size() >= 2:
+				class_id = str(class_tokens[1])
+		elif line.begins_with("extends "):
+			var extends_tokens := line.split(" ", false)
+			if extends_tokens.size() >= 2:
+				base_class = str(extends_tokens[1])
+	if class_id == "":
+		return {}
+	return {"class": class_id, "base": base_class, "path": script_path, "source": "script_scan"}
+
+func _node_summary(node: Node, node_path: String, depth: int, max_depth: int) -> Dictionary:
+	var children := []
+	if max_depth < 0 or depth < max_depth:
+		for child in node.get_children():
+			if child is Node:
+				children.append(_node_summary(child, str(node.get_path_to(child)), depth + 1, max_depth))
+	var script = node.get_script()
+	return {"path": node_path, "name": node.name, "type": node.get_class(), "scriptPath": script.resource_path if script else null, "childCount": node.get_child_count(), "children": children}
+
+func _find_node(root: Node, node_path: String):
+	if node_path == "" or node_path == ".":
+		return root
+	return root.get_node_or_null(NodePath(node_path))
+
+func _set_owner_recursive(node: Node, owner: Node) -> void:
+	node.owner = owner
+	for child in node.get_children():
+		if child is Node:
+			_set_owner_recursive(child, owner)
+
+func _res_path(value: String) -> String:
+	if value.begins_with("res://"):
+		return value
+	return "res://" + value.trim_prefix("/")
+
+func _ensure_parent_dir(res_path: String) -> void:
+	var absolute := ProjectSettings.globalize_path(res_path)
+	var dir := absolute.get_base_dir()
+	DirAccess.make_dir_recursive_absolute(dir)
+
+func _write_json(path: String, value: Dictionary) -> void:
+	var file := FileAccess.open(path, FileAccess.WRITE)
+	if file:
+		file.store_string(JSON.stringify(value))
+		file.close()
+
+func _success(summary: String, output: Dictionary) -> Dictionary:
+	return {"ok": true, "summary": summary, "reasons": [], "output": output}
+
+func _failure(summary: String, reasons: Array, help := {}) -> Dictionary:
+	return {"ok": false, "summary": summary, "reasons": reasons, "output": null, "help": help}
+
+func _operation_help(kind: String) -> Dictionary:
+	var examples := {
+		"scene.tree": {"kind": "scene.tree", "scenePath": "res://path/to/scene.tscn", "maxDepth": 3},
+		"node.inspect": {"kind": "node.inspect", "scenePath": "res://path/to/scene.tscn", "nodePath": ".", "includePropertyList": true, "propertyLimit": 40},
+		"resource.read": {"kind": "resource.read", "resourcePath": "res://path/to/resource.tres", "propertyNames": ["name"]},
+		"resource.properties": {"kind": "resource.properties", "resourcePath": "res://path/to/resource.tres"},
+		"class.search": {"kind": "class.search", "query": "Label"},
+		"class.info": {"kind": "class.info", "className": "Label", "propertyQuery": "text"},
+		"editor.state": {"kind": "editor.state"},
+	}
+	var example = examples.get(kind, {"kind": "editor.state"})
+	return {
+		"usage": "Use editor.operation.run with operation.kind, or prefer focused MCP tools: editor.state, editor.scene.tree, editor.node.inspect, editor.resource.read, editor.resource.properties, editor.class.search, editor.class.info.",
+		"helpCommand": "gdh editor operation run --help",
+		"examples": [example],
+	}
+`;
+}
+export function renderEditorOperationCatalogGdscript() {
+    const runner = renderEditorOperationRunner();
+    const marker = "func run_editor_operation(operation: Dictionary) -> Dictionary:";
+    const markerIndex = runner.indexOf(marker);
+    if (markerIndex < 0) {
+        throw new Error("Editor operation runner is missing the catalog marker.");
+    }
+    return runner.slice(markerIndex);
+}
+//# sourceMappingURL=index.js.map