auvrynt 1.0.2 → 1.0.5

package/dist/godot-project-settings.js

@@ -1,223 +1 @@
-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 = {};
-    const lines = content.split(/\r?\n/);
-    let currentSection = "";
-    for (const line of lines) {
-        const sectionMatch = line.match(/^\[(\w+)\]$/);
-        if (sectionMatch) {
-            currentSection = sectionMatch[1];
-            continue;
-        }
-        const kvMatch = line.match(/^(\S+)\s*=\s*(.+)$/);
-        if (kvMatch) {
-            const key = currentSection ? `${currentSection}/${kvMatch[1]}` : kvMatch[1];
-            settings[key] = kvMatch[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 newValueStr = JSON.stringify(input.value);
-    const keyParts = input.settingKey.split("/");
-    const [section, ...keyRest] = keyParts;
-    const key = keyRest.join("/");
-    const keyRegex = new RegExp(`^(${key}\\s*=\\s*)(.+)$`, "m");
-    const prev = keyRegex.exec(content)?.[2];
-    if (keyRegex.test(content)) {
-        content = content.replace(keyRegex, `$1${newValueStr}`);
-    }
-    else {
-        const sectionRegex = new RegExp(`\\[${section}\\]`, "m");
-        if (sectionRegex.test(content)) {
-            content = content.replace(sectionRegex, `[${section}]\n${key}=${newValueStr}`);
-        }
-        else {
-            content += `\n[${section}]\n${key}=${newValueStr}\n`;
-        }
-    }
-    await writeFile(godotFile, content, "utf8");
-    return { previousValue: prev, newValue: newValueStr };
-}
-export async function getInputMap(registry, input) {
-    const settings = await getProjectSettings(registry, input);
-    const inputActions = {};
-    for (const [key, value] of Object.entries(settings)) {
-        if (key.startsWith("input/")) {
-            const actionName = key.replace("input/", "");
-            inputActions[actionName] = [value];
-        }
-    }
-    return inputActions;
-}
-export async function getAutoloads(registry, input) {
-    const settings = await getProjectSettings(registry, input);
-    const autoloads = {};
-    for (const [key, value] of Object.entries(settings)) {
-        if (key.startsWith("autoload/")) {
-            const name = key.replace("autoload/", "");
-            autoloads[name] = 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 absPath = registry.resolvePath(workspace, texturePath);
-            const importPath = absPath + ".import";
-            let importContent;
-            try {
-                importContent = await readFile(importPath, "utf8");
-            }
-            catch {
-                // Create a minimal .import file
-                importContent = `[remap]\n\nimporter="texture"\n`;
-            }
-            // Apply pixel art import settings
-            const pixelArtSettings = [
-                ["process/fix_alpha_border", "false"],
-                ["process/premult_alpha", "false"],
-                ["compress/mode", "0"], // Lossless
-                ["compress/high_quality", "false"],
-                ["flags/repeat", "0"],
-                ["flags/filter", "false"], // nearest neighbour
-                ["flags/mipmaps", "false"],
-                ["flags/anisotropic", "false"],
-                ["flags/srgb", "2"],
-            ];
-            for (const [key, val] of pixelArtSettings) {
-                const keyRegex = new RegExp(`^(${key}\\s*=\\s*)(.*)$`, "m");
-                if (keyRegex.test(importContent)) {
-                    importContent = importContent.replace(keyRegex, `$1${val}`);
-                }
-            }
-            await writeFile(importPath, importContent, "utf8");
-            changed.push(texturePath);
-        }
-        catch (err) {
-            errors.push(`${texturePath}: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
-    return { changed, errors };
-}
-// ─── VS Code Configuration Generator ────────────────────────────────────────
-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}";
-    // tasks.json
-    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((t) => t.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, "/"));
-    // launch.json
-    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((c) => c.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 = [];
-    const lines = content.split(/\r?\n/);
-    let currentPreset = null;
-    for (const line of lines) {
-        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;
-}
+export * from "./integrations/godot/godot-project-settings.js";

package/dist/godot-runtime-testing.js

@@ -1,249 +1 @@
-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);
-// ─── Remote Scene Tree ────────────────────────────────────────────────────
-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 currentEx = null;
-    const EXCEPTION_TYPES = [
-        "NullReferenceException", "InvalidCastException", "ObjectDisposedException",
-        "InvalidOperationException", "ArgumentException", "ArgumentNullException",
-        "NotImplementedException", "IndexOutOfRangeException", "KeyNotFoundException",
-        "IOException", "FileNotFoundException",
-    ];
-    for (const line of logLines) {
-        const trimmed = line.trim();
-        // Check inner exception prefix FIRST (before top-level exception detection)
-        if (currentEx && trimmed.startsWith("---> ")) {
-            const innerMatch = trimmed.slice(5).match(/(\w*Exception):\s*(.*)/);
-            if (innerMatch) {
-                currentEx.innerExceptions.push({
-                    exceptionType: innerMatch[1],
-                    message: innerMatch[2],
-                    innerExceptions: [],
-                    stackFrames: [],
-                    firstOccurrence: new Date().toISOString(),
-                    repeatCount: 1,
-                });
-            }
-            continue;
-        }
-        const isException = EXCEPTION_TYPES.some((t) => trimmed.includes(t)) || trimmed.includes("Exception:");
-        if (isException) {
-            if (currentEx)
-                exceptions.push(currentEx);
-            const typeMatch = trimmed.match(/(\w+Exception):\s*(.*)/);
-            currentEx = {
-                exceptionType: typeMatch?.[1] ?? "Exception",
-                message: typeMatch?.[2] ?? trimmed,
-                innerExceptions: [],
-                stackFrames: [],
-                firstOccurrence: new Date().toISOString(),
-                repeatCount: 1,
-            };
-            continue;
-        }
-        if (currentEx) {
-            const frameMatch = trimmed.match(/^at\s+(.*?)(?:\s+in\s+(.*?):line\s+(\d+))?$/);
-            if (frameMatch) {
-                currentEx.stackFrames.push({
-                    method: frameMatch[1],
-                    path: frameMatch[2],
-                    line: frameMatch[3] ? Number(frameMatch[3]) : undefined,
-                });
-            }
-        }
-    }
-    if (currentEx)
-        exceptions.push(currentEx);
-    // Collapse repeated exceptions
-    const collapsed = [];
-    for (const ex of exceptions) {
-        const prev = collapsed.find((e) => e.exceptionType === ex.exceptionType && e.message === ex.message);
-        if (prev) {
-            prev.repeatCount++;
-        }
-        else {
-            collapsed.push(ex);
-        }
-    }
-    return collapsed;
-}
-export async function pressAction(input, bridgeClient) {
-    if (!bridgeClient.status)
-        throw new Error("Godot Editor Bridge is not connected for input simulation.");
-    const duration = Math.min(input.durationMs ?? 100, 2000);
-    await bridgeClient.sendRequest("input.press_action", { action: input.action, durationMs: duration });
-    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 MAX_STEPS = 50;
-    const MAX_DURATION_MS = 30000;
-    const MAX_SCREENSHOTS = 5;
-    if (input.steps.length > MAX_STEPS) {
-        throw new Error(`Test sequence too long (max ${MAX_STEPS} steps).`);
-    }
-    const results = [];
-    let totalDuration = 0;
-    let screenshotCount = 0;
-    for (let i = 0; i < input.steps.length; i++) {
-        const step = input.steps[i];
-        switch (step.type) {
-            case "wait": {
-                const delay = Math.min(step.durationMs, 5000);
-                totalDuration += delay;
-                if (totalDuration > MAX_DURATION_MS) {
-                    results.push({ step: i, type: step.type, passed: false, message: "Total duration limit exceeded." });
-                    return { results };
-                }
-                await new Promise((r) => setTimeout(r, delay));
-                results.push({ step: i, type: step.type, passed: true, message: `Waited ${delay}ms.` });
-                break;
-            }
-            case "press_action": {
-                const r = await pressAction({ workspaceId: input.workspaceId, processId: input.processId, action: step.action, durationMs: step.durationMs }, bridgeClient).catch((err) => ({ sent: false, error: err.message }));
-                results.push({ step: i, type: step.type, passed: r.sent ?? false, message: `Press action '${step.action}'` });
-                break;
-            }
-            case "screenshot": {
-                if (screenshotCount >= MAX_SCREENSHOTS) {
-                    results.push({ step: i, type: step.type, passed: false, message: "Screenshot limit exceeded." });
-                    break;
-                }
-                screenshotCount++;
-                results.push({ step: i, type: step.type, passed: true, message: `Screenshot step queued to ${step.outputPath}.` });
-                break;
-            }
-            case "assert_node_exists": {
-                const r = await assertNodeExists({ workspaceId: input.workspaceId, nodePath: step.nodePath }, bridgeClient).catch(() => ({ passed: false, message: "Bridge error" }));
-                results.push({ step: i, type: step.type, passed: r.passed, message: r.message });
-                break;
-            }
-            case "assert_property": {
-                const r = await assertProperty({ workspaceId: input.workspaceId, nodePath: step.nodePath, property: step.property, comparison: step.comparison, expected: step.expected }, bridgeClient).catch((err) => ({ passed: false, actual: null, expected: step.expected, message: err.message }));
-                results.push({ step: i, type: step.type, passed: r.passed, message: r.message });
-                break;
-            }
-            case "assert_no_errors": {
-                const logs = processManager.getProcessLogs({ workspaceId: input.workspaceId, processId: input.processId, lines: 100 });
-                const hasErrors = logs.lines.some((l) => l.includes("ERROR:") || l.includes("Exception:"));
-                results.push({ step: i, type: step.type, passed: !hasErrors, message: hasErrors ? "Runtime errors detected." : "No runtime errors." });
-                break;
-            }
-            default: {
-                results.push({ step: i, 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 projectDir = registry.resolvePath(workspace, input.projectPath);
-    const absoluteOutputPath = registry.resolvePath(workspace, input.outputPath);
-    await mkdir(dirname(absoluteOutputPath), { recursive: true });
-    const godotExe = process.env.GODOT_DOTNET_EXECUTABLE ?? process.env.GODOT_EXECUTABLE ?? "godot-mono";
-    const exportFlag = (input.mode ?? "debug") === "debug" ? "--export-debug" : "--export-release";
-    const args = ["--headless", "--path", projectDir, exportFlag, input.preset, absoluteOutputPath];
-    const start = Date.now();
-    try {
-        const { stdout, stderr } = await execFileAsync(godotExe, args, { cwd: projectDir });
-        return {
-            success: true,
-            outputFiles: [relative(workspace.root, absoluteOutputPath).replace(/\\/g, "/")],
-            durationMs: Date.now() - start,
-            output: (stdout + "\n" + stderr).slice(0, 1000),
-        };
-    }
-    catch (err) {
-        return {
-            success: false,
-            outputFiles: [],
-            durationMs: Date.now() - start,
-            output: (err.stdout ?? "") + "\n" + (err.stderr ?? err.message),
-        };
-    }
-}
+export * from "./integrations/godot/godot-runtime-testing.js";

package/dist/godot-tools.js

@@ -1,183 +1 @@
-import { readFile, readdir } from "node:fs/promises";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-import { join } from "node:path";
-const execFileAsync = promisify(execFile);
-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((f) => f.replace(/"/g, "").trim()));
-    }
-    // Parse [autoload] section
-    const autoloadSection = content.match(/\[autoload\]([\s\S]*?)(?=\n\[|$)/);
-    if (autoloadSection) {
-        const lines = autoloadSection[1].split("\n");
-        for (const line of lines) {
-            const kv = line.match(/^(\w+)="([^"]+)"/);
-            if (kv)
-                autoloads[kv[1]] = kv[2];
-        }
-    }
-    // Parse [input] section
-    const inputSection = content.match(/\[input\]([\s\S]*?)(?=\n\[|$)/);
-    if (inputSection) {
-        const lines = inputSection[1].split("\n");
-        for (const line of lines) {
-            const kv = line.match(/^(\w+)=\{/);
-            if (kv)
-                inputActions.push(kv[1]);
-        }
-    }
-    return { configVersion, name, mainScene, renderer, features, autoloads, inputActions };
-}
-export function parseGodotScene(content) {
-    const nodes = [];
-    const externalResources = [];
-    const signals = [];
-    const lines = content.split(/\r?\n/);
-    let currentElement = null;
-    for (const line of lines) {
-        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 eqIdx = trimmed.indexOf("=");
-            const k = trimmed.slice(0, eqIdx).trim();
-            const v = trimmed.slice(eqIdx + 1).trim();
-            currentElement.data.properties[k] = v;
-        }
-    }
-    const rootNode = nodes.find((n) => !n.parent)?.name;
-    return { rootNode, 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;
-    const projectGodotPath = join(targetDir, "project.godot");
-    let content = "";
-    try {
-        content = await readFile(projectGodotPath, "utf8");
-    }
-    catch {
-        return {
-            projectPath: input.path ?? ".",
-            godotProjectFound: false,
-            hasCSharp: false,
-        };
-    }
-    const parsed = parseGodotProjectFile(content);
-    let dirFiles = [];
-    try {
-        dirFiles = await readdir(targetDir);
-    }
-    catch { }
-    const hasCSharp = dirFiles.some((f) => f.endsWith(".csproj") || f.endsWith(".sln"));
-    return {
-        projectPath: input.path ?? ".",
-        godotProjectFound: true,
-        ...parsed,
-        hasCSharp,
-    };
-}
-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) {
-        const absScene = registry.resolvePath(workspace, input.scenePath);
-        args.push(`"${absScene}"`);
-    }
-    if (input.editor)
-        args.push("-e");
-    if (input.debug)
-        args.push("-d");
-    if (input.additionalArguments)
-        args.push(...input.additionalArguments);
-    const command = `${godotBin} ${args.join(" ")}`;
-    const result = processManager.startProcess({
-        workspaceId: input.workspaceId,
-        command,
-        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 content = await readFile(absolutePath, "utf8");
-    const parsed = parseGodotScene(content);
-    const nodeTypes = Array.from(new Set(parsed.nodes.map((n) => n.type)));
-    return {
-        scenePath: input.scenePath,
-        rootNode: parsed.rootNode,
-        nodeCount: parsed.nodes.length,
-        nodeTypes,
-        nodes: parsed.nodes,
-        externalResources: parsed.externalResources,
-        signals: parsed.signals,
-    };
-}
+export * from "./integrations/godot/godot-tools.js";

package/dist/http-rate-limit.js

@@ -0,0 +1 @@
+export * from "./infrastructure/http-rate-limit.js";

package/dist/http-server-hardening.js

@@ -0,0 +1 @@
+export * from "./infrastructure/http-server-hardening.js";