auvrynt 1.0.2 → 1.0.5

package/dist/integrations/godot/godot-project-settings.js

@@ -0,0 +1,178 @@
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { join, relative } from "node:path";
+export async function getProjectSettings(registry, input) {
+    const workspace = registry.getWorkspace(input.workspaceId);
+    const godotFile = join(registry.resolvePath(workspace, input.projectPath), "project.godot");
+    const content = await readFile(godotFile, "utf8");
+    const settings = {};
+    let currentSection = "";
+    for (const line of content.split(/\r?\n/)) {
+        const sectionMatch = line.match(/^\[(\w+)\]$/);
+        if (sectionMatch) {
+            currentSection = sectionMatch[1];
+            continue;
+        }
+        const keyValueMatch = line.match(/^(\S+)\s*=\s*(.+)$/);
+        if (keyValueMatch) {
+            const key = currentSection ? `${currentSection}/${keyValueMatch[1]}` : keyValueMatch[1];
+            settings[key] = keyValueMatch[2].trim();
+        }
+    }
+    return settings;
+}
+export async function setProjectSetting(registry, input) {
+    const workspace = registry.getWorkspace(input.workspaceId);
+    const godotFile = join(registry.resolvePath(workspace, input.projectPath), "project.godot");
+    let content = await readFile(godotFile, "utf8");
+    const newValue = JSON.stringify(input.value);
+    const [section, ...keyRest] = input.settingKey.split("/");
+    const key = keyRest.join("/");
+    const keyRegex = new RegExp(`^(${key}\\s*=\\s*)(.+)$`, "m");
+    const previousValue = keyRegex.exec(content)?.[2];
+    if (keyRegex.test(content)) {
+        content = content.replace(keyRegex, `$1${newValue}`);
+    }
+    else {
+        const sectionRegex = new RegExp(`\\[${section}\\]`, "m");
+        content = sectionRegex.test(content)
+            ? content.replace(sectionRegex, `[${section}]\n${key}=${newValue}`)
+            : `${content}\n[${section}]\n${key}=${newValue}\n`;
+    }
+    await writeFile(godotFile, content, "utf8");
+    return { previousValue, newValue };
+}
+export async function getInputMap(registry, input) {
+    const inputActions = {};
+    for (const [key, value] of Object.entries(await getProjectSettings(registry, input))) {
+        if (key.startsWith("input/"))
+            inputActions[key.replace("input/", "")] = [value];
+    }
+    return inputActions;
+}
+export async function getAutoloads(registry, input) {
+    const autoloads = {};
+    for (const [key, value] of Object.entries(await getProjectSettings(registry, input))) {
+        if (key.startsWith("autoload/"))
+            autoloads[key.replace("autoload/", "")] = value;
+    }
+    return autoloads;
+}
+export async function applyPixelArtImportPreset(registry, input) {
+    const workspace = registry.getWorkspace(input.workspaceId);
+    const changed = [];
+    const errors = [];
+    for (const texturePath of input.paths) {
+        try {
+            const importPath = registry.resolvePath(workspace, texturePath) + ".import";
+            let importContent;
+            try {
+                importContent = await readFile(importPath, "utf8");
+            }
+            catch {
+                importContent = `[remap]\n\nimporter="texture"\n`;
+            }
+            for (const [key, value] of [
+                ["process/fix_alpha_border", "false"],
+                ["process/premult_alpha", "false"],
+                ["compress/mode", "0"],
+                ["compress/high_quality", "false"],
+                ["flags/repeat", "0"],
+                ["flags/filter", "false"],
+                ["flags/mipmaps", "false"],
+                ["flags/anisotropic", "false"],
+                ["flags/srgb", "2"],
+            ]) {
+                const keyRegex = new RegExp(`^(${key}\\s*=\\s*)(.*)$`, "m");
+                if (keyRegex.test(importContent))
+                    importContent = importContent.replace(keyRegex, `$1${value}`);
+            }
+            await writeFile(importPath, importContent, "utf8");
+            changed.push(texturePath);
+        }
+        catch (error) {
+            errors.push(`${texturePath}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return { changed, errors };
+}
+export async function generateVscodeConfig(registry, input) {
+    const workspace = registry.getWorkspace(input.workspaceId);
+    const targetDir = registry.resolvePath(workspace, input.projectPath);
+    const vscodeDir = join(targetDir, ".vscode");
+    await mkdir(vscodeDir, { recursive: true });
+    const generated = [];
+    const skipped = [];
+    const godotExe = input.godotExecutable ?? "${env:GODOT_DOTNET_EXECUTABLE}";
+    const tasksPath = join(vscodeDir, "tasks.json");
+    let tasksContent = { version: "2.0.0", tasks: [] };
+    try {
+        tasksContent = JSON.parse(await readFile(tasksPath, "utf8"));
+    }
+    catch { }
+    const godotTasks = [
+        { label: "Godot: Build C#", type: "shell", command: "dotnet build", args: ["${workspaceFolder}"], group: "build" },
+        { label: "Godot: Restore NuGet", type: "shell", command: "dotnet restore", args: ["${workspaceFolder}"] },
+        { label: "Godot: Run Project", type: "shell", command: godotExe, args: ["--path", "${workspaceFolder}", "-d"] },
+        { label: "Godot: Headless Validate", type: "shell", command: godotExe, args: ["--headless", "--path", "${workspaceFolder}", "--editor", "--quit"] },
+    ];
+    const existingLabels = new Set((tasksContent.tasks ?? []).map((task) => task.label));
+    for (const task of godotTasks) {
+        if (!existingLabels.has(task.label))
+            tasksContent.tasks.push(task);
+    }
+    await writeFile(tasksPath, JSON.stringify(tasksContent, null, 2), "utf8");
+    generated.push(relative(workspace.root, tasksPath).replace(/\\/g, "/"));
+    const launchPath = join(vscodeDir, "launch.json");
+    let launchContent = { version: "0.2.0", configurations: [] };
+    try {
+        launchContent = JSON.parse(await readFile(launchPath, "utf8"));
+    }
+    catch { }
+    const existingNames = new Set((launchContent.configurations ?? []).map((configuration) => configuration.name));
+    if (!existingNames.has("Godot C# Debug")) {
+        launchContent.configurations.push({
+            name: "Godot C# Debug",
+            type: "coreclr",
+            request: "attach",
+            processId: "${command:pickProcess}",
+            program: "${workspaceFolder}/bin/Debug/net8.0/${workspaceFolderBasename}.dll",
+        });
+        await writeFile(launchPath, JSON.stringify(launchContent, null, 2), "utf8");
+        generated.push(relative(workspace.root, launchPath).replace(/\\/g, "/"));
+    }
+    else {
+        skipped.push(relative(workspace.root, launchPath).replace(/\\/g, "/"));
+    }
+    return { generated, skipped };
+}
+export async function listExportPresets(registry, input) {
+    const workspace = registry.getWorkspace(input.workspaceId);
+    const presetFile = join(registry.resolvePath(workspace, input.projectPath), "export_presets.cfg");
+    let content;
+    try {
+        content = await readFile(presetFile, "utf8");
+    }
+    catch {
+        return [];
+    }
+    const presets = [];
+    let currentPreset = null;
+    for (const line of content.split(/\r?\n/)) {
+        if (line.startsWith("[preset.")) {
+            if (currentPreset)
+                presets.push(currentPreset);
+            currentPreset = { name: "", platform: "", mode: "release" };
+        }
+        else if (currentPreset) {
+            if (line.startsWith("name="))
+                currentPreset.name = line.replace(/^name=/, "").replace(/"/g, "").trim();
+            else if (line.startsWith("platform="))
+                currentPreset.platform = line.replace(/^platform=/, "").replace(/"/g, "").trim();
+            else if (line.startsWith("export_debug="))
+                currentPreset.mode = line.includes("true") ? "debug" : "release";
+        }
+    }
+    if (currentPreset)
+        presets.push(currentPreset);
+    return presets;
+}

package/dist/integrations/godot/godot-runtime-testing.js

@@ -0,0 +1,263 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { mkdir } from "node:fs/promises";
+import { dirname, relative } from "node:path";
+const execFileAsync = promisify(execFile);
+export async function getRemoteSceneTree(input, bridgeClient) {
+    if (!bridgeClient.status)
+        throw new Error("Godot Editor Bridge is not connected.");
+    return bridgeClient.sendRequest("remote.get_scene_tree", { maxDepth: input.maxDepth ?? 10 });
+}
+export async function getRuntimeProperty(input, bridgeClient) {
+    if (!bridgeClient.status)
+        throw new Error("Godot Editor Bridge is not connected.");
+    return bridgeClient.sendRequest("remote.get_property", {
+        nodePath: input.nodePath,
+        property: input.property,
+    });
+}
+export async function getPerformanceMonitors(input, bridgeClient) {
+    if (!bridgeClient.status)
+        throw new Error("Godot Editor Bridge is not connected.");
+    return bridgeClient.sendRequest("remote.get_performance_monitors", {});
+}
+export function parseCsharpExceptions(logLines) {
+    const exceptions = [];
+    let currentException = null;
+    const exceptionTypes = [
+        "NullReferenceException", "InvalidCastException", "ObjectDisposedException",
+        "InvalidOperationException", "ArgumentException", "ArgumentNullException",
+        "NotImplementedException", "IndexOutOfRangeException", "KeyNotFoundException",
+        "IOException", "FileNotFoundException",
+    ];
+    for (const line of logLines) {
+        const trimmed = line.trim();
+        if (currentException && trimmed.startsWith("---> ")) {
+            const innerMatch = trimmed.slice(5).match(/(\w*Exception):\s*(.*)/);
+            if (innerMatch) {
+                currentException.innerExceptions.push({
+                    exceptionType: innerMatch[1],
+                    message: innerMatch[2],
+                    innerExceptions: [],
+                    stackFrames: [],
+                    firstOccurrence: new Date().toISOString(),
+                    repeatCount: 1,
+                });
+            }
+            continue;
+        }
+        const isException = exceptionTypes.some((type) => trimmed.includes(type)) || trimmed.includes("Exception:");
+        if (isException) {
+            if (currentException)
+                exceptions.push(currentException);
+            const typeMatch = trimmed.match(/(\w+Exception):\s*(.*)/);
+            currentException = {
+                exceptionType: typeMatch?.[1] ?? "Exception",
+                message: typeMatch?.[2] ?? trimmed,
+                innerExceptions: [],
+                stackFrames: [],
+                firstOccurrence: new Date().toISOString(),
+                repeatCount: 1,
+            };
+            continue;
+        }
+        if (currentException) {
+            const frameMatch = trimmed.match(/^at\s+(.*?)(?:\s+in\s+(.*?):line\s+(\d+))?$/);
+            if (frameMatch) {
+                currentException.stackFrames.push({
+                    method: frameMatch[1],
+                    path: frameMatch[2],
+                    line: frameMatch[3] ? Number(frameMatch[3]) : undefined,
+                });
+            }
+        }
+    }
+    if (currentException)
+        exceptions.push(currentException);
+    const collapsed = [];
+    for (const exception of exceptions) {
+        const previous = collapsed.find((entry) => entry.exceptionType === exception.exceptionType && entry.message === exception.message);
+        if (previous)
+            previous.repeatCount++;
+        else
+            collapsed.push(exception);
+    }
+    return collapsed;
+}
+export async function pressAction(input, bridgeClient) {
+    if (!bridgeClient.status)
+        throw new Error("Godot Editor Bridge is not connected for input simulation.");
+    await bridgeClient.sendRequest("input.press_action", {
+        action: input.action,
+        durationMs: Math.min(input.durationMs ?? 100, 2000),
+    });
+    return { sent: true };
+}
+export async function releaseAction(input, bridgeClient) {
+    if (!bridgeClient.status)
+        throw new Error("Godot Editor Bridge is not connected.");
+    await bridgeClient.sendRequest("input.release_action", { action: input.action });
+    return { sent: true };
+}
+export async function mouseClick(input, bridgeClient) {
+    if (!bridgeClient.status)
+        throw new Error("Godot Editor Bridge is not connected.");
+    await bridgeClient.sendRequest("input.mouse_click", {
+        x: input.x,
+        y: input.y,
+        button: input.button ?? 1,
+    });
+    return { sent: true };
+}
+export async function assertNodeExists(input, bridgeClient) {
+    if (!bridgeClient.status)
+        throw new Error("Godot Editor Bridge is not connected.");
+    try {
+        await bridgeClient.sendRequest("remote.get_node", { nodePath: input.nodePath });
+        return { passed: true, message: `Node '${input.nodePath}' exists.` };
+    }
+    catch {
+        return { passed: false, message: `Node '${input.nodePath}' does not exist.` };
+    }
+}
+export async function assertProperty(input, bridgeClient) {
+    if (!bridgeClient.status)
+        throw new Error("Godot Editor Bridge is not connected.");
+    const { value } = await getRuntimeProperty({
+        workspaceId: input.workspaceId,
+        nodePath: input.nodePath,
+        property: input.property,
+    }, bridgeClient);
+    let passed;
+    switch (input.comparison) {
+        case "eq":
+            passed = JSON.stringify(value) === JSON.stringify(input.expected);
+            break;
+        case "neq":
+            passed = JSON.stringify(value) !== JSON.stringify(input.expected);
+            break;
+        case "gt":
+            passed = value > input.expected;
+            break;
+        case "lt":
+            passed = value < input.expected;
+            break;
+        case "approx":
+            passed = Math.abs(value - input.expected) < 0.001;
+            break;
+        case "contains":
+            passed = String(value).includes(String(input.expected));
+            break;
+        case "exists":
+            passed = value !== null && value !== undefined;
+            break;
+        default: passed = false;
+    }
+    return {
+        passed,
+        actual: value,
+        expected: input.expected,
+        message: passed
+            ? `Property '${input.property}' assertion passed.`
+            : `Expected '${input.property}' to be ${input.comparison} '${JSON.stringify(input.expected)}', got '${JSON.stringify(value)}'.`,
+    };
+}
+export async function runTestSequence(registry, processManager, input, bridgeClient) {
+    const maxSteps = 50;
+    const maxDurationMs = 30_000;
+    const maxScreenshots = 5;
+    if (input.steps.length > maxSteps)
+        throw new Error(`Test sequence too long (max ${maxSteps} steps).`);
+    const results = [];
+    let totalDuration = 0;
+    let screenshotCount = 0;
+    for (let index = 0; index < input.steps.length; index++) {
+        const step = input.steps[index];
+        switch (step.type) {
+            case "wait": {
+                const delay = Math.min(step.durationMs, 5000);
+                totalDuration += delay;
+                if (totalDuration > maxDurationMs) {
+                    results.push({ step: index, type: step.type, passed: false, message: "Total duration limit exceeded." });
+                    return { results };
+                }
+                await new Promise((resolveDelay) => setTimeout(resolveDelay, delay));
+                results.push({ step: index, type: step.type, passed: true, message: `Waited ${delay}ms.` });
+                break;
+            }
+            case "press_action": {
+                const result = await pressAction({
+                    workspaceId: input.workspaceId,
+                    processId: input.processId,
+                    action: step.action,
+                    durationMs: step.durationMs,
+                }, bridgeClient).catch((error) => ({ sent: false, error: error.message }));
+                results.push({ step: index, type: step.type, passed: result.sent ?? false, message: `Press action '${step.action}'` });
+                break;
+            }
+            case "screenshot": {
+                if (screenshotCount >= maxScreenshots) {
+                    results.push({ step: index, type: step.type, passed: false, message: "Screenshot limit exceeded." });
+                    break;
+                }
+                screenshotCount++;
+                results.push({ step: index, type: step.type, passed: true, message: `Screenshot step queued to ${step.outputPath}.` });
+                break;
+            }
+            case "assert_node_exists": {
+                const result = await assertNodeExists({ workspaceId: input.workspaceId, nodePath: step.nodePath }, bridgeClient)
+                    .catch(() => ({ passed: false, message: "Bridge error" }));
+                results.push({ step: index, type: step.type, passed: result.passed, message: result.message });
+                break;
+            }
+            case "assert_property": {
+                const result = await assertProperty({
+                    workspaceId: input.workspaceId,
+                    nodePath: step.nodePath,
+                    property: step.property,
+                    comparison: step.comparison,
+                    expected: step.expected,
+                }, bridgeClient).catch((error) => ({ passed: false, actual: null, expected: step.expected, message: error.message }));
+                results.push({ step: index, type: step.type, passed: result.passed, message: result.message });
+                break;
+            }
+            case "assert_no_errors": {
+                const logs = processManager.getProcessLogs({ workspaceId: input.workspaceId, processId: input.processId, lines: 100 });
+                const hasErrors = logs.lines.some((line) => line.includes("ERROR:") || line.includes("Exception:"));
+                results.push({ step: index, type: step.type, passed: !hasErrors, message: hasErrors ? "Runtime errors detected." : "No runtime errors." });
+                break;
+            }
+            default:
+                results.push({ step: index, type: step.type ?? "unknown", passed: false, message: "Unknown step type." });
+        }
+    }
+    return { results };
+}
+export async function exportGodotProject(registry, input) {
+    const workspace = registry.getWorkspace(input.workspaceId);
+    const projectDirectory = registry.resolvePath(workspace, input.projectPath);
+    const absoluteOutputPath = registry.resolveArtifactPath(workspace, input.outputPath, "godot");
+    await mkdir(dirname(absoluteOutputPath), { recursive: true });
+    const godotExecutable = process.env.GODOT_DOTNET_EXECUTABLE ?? process.env.GODOT_EXECUTABLE ?? "godot-mono";
+    const exportFlag = (input.mode ?? "debug") === "debug" ? "--export-debug" : "--export-release";
+    const start = Date.now();
+    try {
+        const { stdout, stderr } = await execFileAsync(godotExecutable, [
+            "--headless", "--path", projectDirectory, exportFlag, input.preset, absoluteOutputPath,
+        ], { cwd: projectDirectory, windowsHide: true });
+        return {
+            success: true,
+            outputFiles: [relative(workspace.root, absoluteOutputPath).replace(/\\/g, "/")],
+            durationMs: Date.now() - start,
+            output: (stdout + "\n" + stderr).slice(0, 1000),
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            outputFiles: [],
+            durationMs: Date.now() - start,
+            output: (error.stdout ?? "") + "\n" + (error.stderr ?? error.message),
+        };
+    }
+}

package/dist/integrations/godot/godot-tools.js

@@ -0,0 +1,193 @@
+import { readFile, readdir } from "node:fs/promises";
+import { cpSync, existsSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+export function parseGodotProjectFile(content) {
+    let configVersion = 5;
+    let name = "Godot Project";
+    let mainScene = "";
+    let renderer = "Forward+";
+    const features = [];
+    const autoloads = {};
+    const inputActions = [];
+    const nameMatch = content.match(/config\/name="([^"]+)"/);
+    if (nameMatch)
+        name = nameMatch[1];
+    const sceneMatch = content.match(/run\/main_scene="([^"]+)"/);
+    if (sceneMatch)
+        mainScene = sceneMatch[1];
+    const versionMatch = content.match(/config_version=(\d+)/);
+    if (versionMatch)
+        configVersion = Number(versionMatch[1]);
+    const rendererMatch = content.match(/rendering\/renderer\/rendering_method="([^"]+)"/);
+    if (rendererMatch)
+        renderer = rendererMatch[1];
+    const featureMatch = content.match(/config\/features=PackedStringArray\((.*?)\)/);
+    if (featureMatch)
+        features.push(...featureMatch[1].split(",").map((feature) => feature.replace(/"/g, "").trim()));
+    const autoloadSection = content.match(/\[autoload\]([\s\S]*?)(?=\n\[|$)/);
+    if (autoloadSection) {
+        for (const line of autoloadSection[1].split("\n")) {
+            const keyValue = line.match(/^(\w+)="([^"]+)"/);
+            if (keyValue)
+                autoloads[keyValue[1]] = keyValue[2];
+        }
+    }
+    const inputSection = content.match(/\[input\]([\s\S]*?)(?=\n\[|$)/);
+    if (inputSection) {
+        for (const line of inputSection[1].split("\n")) {
+            const keyValue = line.match(/^(\w+)=\{/);
+            if (keyValue)
+                inputActions.push(keyValue[1]);
+        }
+    }
+    return { configVersion, name, mainScene, renderer, features, autoloads, inputActions };
+}
+export function parseGodotScene(content) {
+    const nodes = [];
+    const externalResources = [];
+    const signals = [];
+    let currentElement = null;
+    for (const line of content.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("[ext_resource")) {
+            const idMatch = trimmed.match(/id="([^"]+)"/);
+            const typeMatch = trimmed.match(/type="([^"]+)"/);
+            const pathMatch = trimmed.match(/path="([^"]+)"/);
+            if (idMatch && typeMatch && pathMatch) {
+                externalResources.push({ id: idMatch[1], type: typeMatch[1], path: pathMatch[1] });
+            }
+        }
+        else if (trimmed.startsWith("[node")) {
+            const nameMatch = trimmed.match(/name="([^"]+)"/);
+            const typeMatch = trimmed.match(/type="([^"]+)"/);
+            const parentMatch = trimmed.match(/parent="([^"]+)"/);
+            if (nameMatch) {
+                const node = {
+                    name: nameMatch[1],
+                    type: typeMatch ? typeMatch[1] : "Node",
+                    parent: parentMatch ? parentMatch[1] : undefined,
+                    properties: {},
+                };
+                nodes.push(node);
+                currentElement = { type: "node", data: node };
+            }
+        }
+        else if (trimmed.startsWith("[connection")) {
+            const signalMatch = trimmed.match(/signal="([^"]+)"/);
+            const fromMatch = trimmed.match(/from="([^"]+)"/);
+            const toMatch = trimmed.match(/to="([^"]+)"/);
+            const methodMatch = trimmed.match(/method="([^"]+)"/);
+            if (signalMatch && fromMatch && toMatch && methodMatch) {
+                signals.push({ signal: signalMatch[1], from: fromMatch[1], to: toMatch[1], method: methodMatch[1] });
+            }
+        }
+        else if (currentElement?.type === "node" && trimmed.includes("=")) {
+            const equalsIndex = trimmed.indexOf("=");
+            currentElement.data.properties[trimmed.slice(0, equalsIndex).trim()] = trimmed.slice(equalsIndex + 1).trim();
+        }
+    }
+    return { rootNode: nodes.find((node) => !node.parent)?.name, nodes, externalResources, signals };
+}
+export async function detectGodotProject(registry, input) {
+    const workspace = registry.getWorkspace(input.workspaceId);
+    const targetDir = input.path ? registry.resolvePath(workspace, input.path) : workspace.root;
+    let content = "";
+    try {
+        content = await readFile(join(targetDir, "project.godot"), "utf8");
+    }
+    catch {
+        return { projectPath: input.path ?? ".", godotProjectFound: false, hasCSharp: false };
+    }
+    let directoryFiles = [];
+    try {
+        directoryFiles = await readdir(targetDir);
+    }
+    catch { }
+    return {
+        projectPath: input.path ?? ".",
+        godotProjectFound: true,
+        ...parseGodotProjectFile(content),
+        hasCSharp: directoryFiles.some((file) => file.endsWith(".csproj") || file.endsWith(".sln")),
+    };
+}
+export async function godotRun(registry, processManager, input) {
+    const workspace = registry.getWorkspace(input.workspaceId);
+    const projectDir = registry.resolvePath(workspace, input.projectPath);
+    const godotBin = process.env.GODOT_EXECUTABLE ?? "godot";
+    const args = ["--path", `"${projectDir}"`];
+    if (input.scenePath)
+        args.push(`"${registry.resolvePath(workspace, input.scenePath)}"`);
+    if (input.editor)
+        args.push("-e");
+    if (input.debug)
+        args.push("-d");
+    if (input.additionalArguments)
+        args.push(...input.additionalArguments);
+    const result = processManager.startProcess({
+        workspaceId: input.workspaceId,
+        command: `${godotBin} ${args.join(" ")}`,
+        workingDirectory: projectDir,
+    });
+    return { processId: result.processId, status: result.status, detectedUrls: result.detectedUrls };
+}
+export async function inspectGodotScene(registry, input) {
+    const workspace = registry.getWorkspace(input.workspaceId);
+    const absolutePath = registry.resolvePath(workspace, input.scenePath);
+    if (input.scenePath.endsWith(".scn"))
+        throw new Error("Binary .scn scenes are not supported. Use text .tscn format.");
+    const parsed = parseGodotScene(await readFile(absolutePath, "utf8"));
+    return {
+        scenePath: input.scenePath,
+        rootNode: parsed.rootNode,
+        nodeCount: parsed.nodes.length,
+        nodeTypes: Array.from(new Set(parsed.nodes.map((node) => node.type))),
+        nodes: parsed.nodes,
+        externalResources: parsed.externalResources,
+        signals: parsed.signals,
+    };
+}
+function globalGodotPluginTarget() {
+    if (process.platform === "win32") {
+        const appData = process.env.APPDATA || join(homedir(), "AppData", "Roaming");
+        return join(appData, "Godot", "editor_plugins", "auvrynt_bridge");
+    }
+    if (process.platform === "darwin") {
+        return join(homedir(), "Library", "Application Support", "Godot", "editor_plugins", "auvrynt_bridge");
+    }
+    return join(homedir(), ".config", "godot", "editor_plugins", "auvrynt_bridge");
+}
+function globalGodotPluginSource() {
+    const candidateSourceDirs = [];
+    try {
+        const currentFile = fileURLToPath(import.meta.url);
+        candidateSourceDirs.push(join(dirname(currentFile), "..", "..", "..", "addons", "auvrynt_bridge"));
+    }
+    catch {
+        // Fall through to the development checkout candidate.
+    }
+    candidateSourceDirs.push(join(process.cwd(), "addons", "auvrynt_bridge"));
+    return candidateSourceDirs.find((candidate) => existsSync(join(candidate, "plugin.cfg")) && existsSync(join(candidate, "auvrynt_bridge.gd")));
+}
+export function getGlobalGodotPluginStatus() {
+    const targetPath = globalGodotPluginTarget();
+    return {
+        targetPath,
+        installed: existsSync(join(targetPath, "plugin.cfg")) && existsSync(join(targetPath, "auvrynt_bridge.gd")),
+    };
+}
+export function ensureGlobalGodotPlugin() {
+    const targetPath = globalGodotPluginTarget();
+    const sourceDir = globalGodotPluginSource();
+    if (!sourceDir)
+        return { installed: false, targetPath };
+    try {
+        mkdirSync(targetPath, { recursive: true });
+        cpSync(sourceDir, targetPath, { recursive: true, force: true });
+        return getGlobalGodotPluginStatus();
+    }
+    catch {
+        return { installed: false, targetPath };
+    }
+}