summer-engine 2.6.6 → 2.7.0

package/dist/mcp/tools/file-tools.js

@@ -0,0 +1,154 @@
+import { z } from "zod";
+import { withEngine } from "./with-engine.js";
+// MCP clients may issue tool calls concurrently. Keep the complete read->write
+// transaction ordered for one project file while allowing unrelated files to
+// proceed in parallel. The tail is always released in `finally`, so a rejected
+// tool call cannot wedge later edits.
+const fileMutationTails = new Map();
+async function withFileMutationTurn(projectIdHash, path, fn) {
+    // Windows project paths are case-insensitive. Canonicalize only the lock key;
+    // preserve the caller's exact safe path in the operation sent to the engine.
+    const canonicalPathKey = path.replace(/\\/g, "/").toLowerCase();
+    const key = `${projectIdHash ?? "unbound"}\n${canonicalPathKey}`;
+    const previous = fileMutationTails.get(key) ?? Promise.resolve();
+    let release;
+    const gate = new Promise((resolve) => {
+        release = resolve;
+    });
+    const current = previous.catch(() => undefined).then(() => gate);
+    fileMutationTails.set(key, current);
+    await previous.catch(() => undefined);
+    try {
+        return await fn();
+    }
+    finally {
+        release();
+        if (fileMutationTails.get(key) === current) {
+            fileMutationTails.delete(key);
+        }
+    }
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function safeProjectPath(path) {
+    const normalized = path.trim().replace(/\\/g, "/");
+    if (!normalized.startsWith("res://") || normalized.includes("..")) {
+        throw new Error("File path must be a traversal-free res:// project path.");
+    }
+    return normalized;
+}
+function validSha256(value) {
+    return typeof value === "string" && /^[0-9a-f]{64}$/i.test(value);
+}
+function readTextPayload(result) {
+    const root = asRecord(result);
+    const data = asRecord(root?.data);
+    if (root?.ok === false) {
+        throw new Error(String(root.error ?? "Engine could not read the file."));
+    }
+    if (data?.encoding === "binary" || typeof data?.content !== "string") {
+        throw new Error("Safe text mutation refused: the engine did not return text content.");
+    }
+    if (data.truncated === true) {
+        throw new Error("Safe text mutation refused: the file exceeds the 1 MB read limit.");
+    }
+    const sha256 = typeof data.sha256 === "string" ? data.sha256 : undefined;
+    if (!validSha256(sha256)) {
+        throw new Error("Safe text mutation refused: the engine did not return a full-file sha256 receipt.");
+    }
+    return {
+        content: data.content,
+        sha256,
+        size: typeof data.size === "number" ? data.size : undefined,
+    };
+}
+function occurrenceCount(content, needle) {
+    let count = 0;
+    let offset = 0;
+    while (true) {
+        const index = content.indexOf(needle, offset);
+        if (index < 0)
+            return count;
+        count++;
+        offset = index + needle.length;
+    }
+}
+export function registerFileTools(server) {
+    server.tool("summer_read_file", `Read a text file from the engine-bound project and return its full-file sha256 receipt.
+
+Use the returned sha256 as expected_sha256 when overwriting an existing file. Paths must begin with res://.`, {
+        path: z.string().describe("Project path, e.g. res://scripts/player.gd"),
+        max_bytes: z.number().int().positive().max(1_000_000).default(200_000),
+    }, async ({ path, max_bytes }) => withEngine(async (client) => client.readProjectFile(safeProjectPath(path), max_bytes)));
+    server.tool("summer_write_file", `Create or safely overwrite a complete text file through the identity-bound engine.
+
+For a new file, set create_only:true. For an existing file, first call summer_read_file and pass its sha256 as expected_sha256. Exactly one guard is required; unguarded writes fail closed. Supports scripts, .tscn scenes, .tres resources, JSON, docs, and project config.`, {
+        path: z.string().describe("Project path, e.g. res://scenes/player.tscn"),
+        content: z.string().describe("Complete new UTF-8 file content."),
+        create_only: z.boolean().optional().describe("Required for a new file; refuses if the path already exists."),
+        expected_sha256: z.string().optional().describe("Required for overwriting an existing file; obtain from summer_read_file."),
+    }, async ({ path, content, create_only, expected_sha256 }) => withEngine(async (client) => {
+        const safePath = safeProjectPath(path);
+        const guardedCreate = create_only === true;
+        const guardedOverwrite = validSha256(expected_sha256);
+        if (expected_sha256 !== undefined && !guardedOverwrite) {
+            throw new Error("Safe write refused: expected_sha256 must be a 64-character hexadecimal sha256 from summer_read_file. Nothing was written.");
+        }
+        if (guardedCreate === guardedOverwrite) {
+            throw new Error("Safe write requires exactly one guard: create_only:true for a new file, or a 64-character expected_sha256 from summer_read_file for an existing file. Nothing was written.");
+        }
+        const op = {
+            op: "WriteFile",
+            path: safePath,
+            content,
+        };
+        if (guardedCreate)
+            op.mustNotExist = true;
+        if (guardedOverwrite)
+            op.expectedSha256 = expected_sha256.toLowerCase();
+        return withFileMutationTurn(client.getBoundProjectIdHash(), safePath, () => client.executeIdentityBoundOps([op]));
+    }));
+    server.tool("summer_replace_text", `Safely replace text in an existing project file through the identity-bound engine.
+
+The MCP server reads the complete file, requires a unique match by default, computes the new content, and submits a sha256-guarded WriteFile. Set replace_all:true only when every exact occurrence should change.`, {
+        path: z.string().describe("Project path, e.g. res://scripts/player.gd"),
+        old_text: z.string().min(1).describe("Exact text to replace."),
+        new_text: z.string().describe("Replacement text; may be empty."),
+        replace_all: z.boolean().default(false).describe("Replace every exact occurrence instead of requiring one unique match."),
+    }, async ({ path, old_text, new_text, replace_all }) => withEngine(async (client) => {
+        const safePath = safeProjectPath(path);
+        return withFileMutationTurn(client.getBoundProjectIdHash(), safePath, async () => {
+            const current = readTextPayload(await client.readProjectFile(safePath, 1_000_000));
+            const matches = occurrenceCount(current.content, old_text);
+            if (matches === 0) {
+                throw new Error("Safe replace refused: old_text was not found. Nothing was written.");
+            }
+            if (!replace_all && matches !== 1) {
+                throw new Error(`Safe replace refused: old_text matched ${matches} times. Provide a unique span or set replace_all:true. Nothing was written.`);
+            }
+            const content = replace_all
+                ? current.content.split(old_text).join(new_text)
+                : current.content.replace(old_text, new_text);
+            if (content === current.content) {
+                return {
+                    ok: true,
+                    noOp: true,
+                    path: safePath,
+                    sha256: current.sha256,
+                    matches,
+                };
+            }
+            return client.executeIdentityBoundOps([
+                {
+                    op: "WriteFile",
+                    path: safePath,
+                    content,
+                    expectedSha256: current.sha256,
+                },
+            ]);
+        });
+    }));
+}

package/dist/mcp/tools/generate-tools.js

@@ -13,6 +13,8 @@ const TOOL_BY_ENDPOINT = {
     "/api/mcp/generate/3d": "summer_generate_3d",
     "/api/mcp/generate/video": "summer_generate_video",
     "/api/mcp/generate/motion": "summer_generate_motion",
+    "/api/mcp/generate/slice-asset-sheet": "summer_slice_asset_sheet",
+    "/api/mcp/workflows": "summer_get_studio_workflow",
 };
 // ---------------------------------------------------------------------------
 // Shared helpers
@@ -129,6 +131,37 @@ async function mcpGenerate(endpoint, body, timeoutMs = 120_000) {
     }
     return { data, status: res.status };
 }
+async function mcpGet(endpoint, searchParams, timeoutMs = 30_000) {
+    const token = await getAuthToken();
+    const suffix = searchParams?.size ? `?${searchParams.toString()}` : "";
+    let res;
+    try {
+        res = await fetch(`${GATEWAY_URL}${endpoint}${suffix}`, {
+            headers: {
+                ...(token ? { Authorization: `Bearer ${token}` } : {}),
+                "X-Summer-Client": "summer-cli",
+                "X-Summer-Client-Version": CLI_VERSION,
+                "X-Summer-Client-Surface": "mcp",
+                "X-Summer-MCP-Endpoint": endpoint,
+                "X-Summer-MCP-Tool": TOOL_BY_ENDPOINT[endpoint] ?? "unknown",
+            },
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { error: `Request failed: ${msg}`, status: 0 };
+    }
+    const data = await readJsonResponse(res);
+    if (!res.ok) {
+        return {
+            error: formattedApiErrorMessage(res.status, data),
+            data: { ...data, status: res.status },
+            status: res.status,
+        };
+    }
+    return { data, status: res.status };
+}
 /**
  * Download an image URL to a temp file so the AI can Read it and show the user.
  */
@@ -153,7 +186,7 @@ async function downloadToTemp(url, prefix, ext = "png") {
  * Poll a job until completed, failed, or timeout.
  * Returns the final job status object.
  */
-async function pollJob(jobId, maxWaitMs = 300_000, intervalMs = 5_000) {
+async function pollJob(jobId, maxWaitMs = 600_000, intervalMs = 5_000) {
     const token = await getAuthToken();
     if (!token)
         return { error: "Not signed in" };
@@ -210,6 +243,28 @@ function successResult(data) {
 // Registration
 // ---------------------------------------------------------------------------
 export function registerGenerateTools(server) {
+    // ========================================================================
+    // summer_get_studio_workflow
+    // ========================================================================
+    server.tool("summer_get_studio_workflow", `Discover the same Guided workflow recipes shown in Summer Engine Studio.
+
+Call without workflowId to list every workflow and its support level. Call with
+an id to get the exact starter prompt, ordered steps, required MCP tools, and
+honest limitations. A "manual" support level means Studio still has a visual
+handoff that MCP cannot perform automatically; do not pretend that stage ran.`, {
+        workflowId: z
+            .string()
+            .optional()
+            .describe("Guided workflow id, e.g. sprite-sheet, character-pack, asset-pack, or component-compiler"),
+    }, async ({ workflowId }) => {
+        const params = new URLSearchParams();
+        if (workflowId)
+            params.set("id", workflowId);
+        const result = await mcpGet("/api/mcp/workflows", params);
+        if (result.error)
+            return errorResult(result.error, result.data);
+        return successResult(result.data);
+    });
     // ========================================================================
     // summer_generate_image
     // ========================================================================
@@ -277,6 +332,35 @@ Requires authentication: run 'npx summer-engine login' first.`, {
         });
     });
     // ========================================================================
+    // summer_slice_asset_sheet
+    // ========================================================================
+    server.tool("summer_slice_asset_sheet", `Detect and crop every distinct game asset from an existing image asset sheet.
+
+Use the assetId returned by summer_generate_image (or another Summer image asset).
+The same guided workflow used in Studio removes the sheet background when needed,
+detects named/category-aware bounding boxes, crops each item, and uploads the slices.
+
+Returns source dimensions plus the generated slice URLs, names, categories, bounding
+boxes, and widget metadata when the sheet contains UI controls.
+
+Cloud tool — runs on Summer's servers and works WITHOUT the Summer Engine app open.
+Requires authentication: run 'npx summer-engine login' first.`, {
+        assetId: z
+            .string()
+            .describe("Summer image asset ID to slice, usually returned by summer_generate_image"),
+    }, async ({ assetId }) => {
+        const result = await mcpGenerate("/api/mcp/generate/slice-asset-sheet", { assetId }, 300_000);
+        if (result.error) {
+            return errorResult(result.error, result.data);
+        }
+        return successResult({
+            ...result.data,
+            sliceCount: Array.isArray(result.data?.slices)
+                ? result.data.slices.length
+                : 0,
+        });
+    });
+    // ========================================================================
     // summer_generate_audio
     // ========================================================================
     server.tool("summer_generate_audio", `Generate audio using AI providers via Summer Engine Studio.
@@ -377,7 +461,16 @@ Example:
   })
   // Returns jobId; poll until result includes { assetId, rigAssetId }.
 
-By default, waits for completion (up to 5 min) and returns the result directly.
+Single-image generation automatically assesses whether the source is suitable
+for 3D. If needed, Summer prepares an isolated object view or rig-safe character
+pose before conversion. Set referencePreparation="always" or "never" only when
+you intentionally want to override that shared Studio behavior.
+
+For a complete animated humanoid package, pass rig=true plus animationNames or
+actionIds. This routes through the shared character pipeline instead of a
+one-off mesh job.
+
+By default, waits for completion (up to 10 min) and returns the result directly.
 Set wait=false to get the jobId immediately and poll manually with summer_check_job.
 
 Cloud tool — runs on Summer's servers and works WITHOUT the Summer Engine app open.
@@ -398,21 +491,66 @@ Requires authentication: run 'npx summer-engine login' first.`, {
             .string()
             .optional()
             .describe("Source image URL for image-to-3d or texture"),
+        imageUrls: z
+            .array(z.string())
+            .max(4)
+            .optional()
+            .describe("Up to four views for multi-image-to-3d"),
+        title: z.string().optional().describe("Asset or character title"),
+        idempotencyKey: z
+            .string()
+            .optional()
+            .describe("Stable retry key so the same logical request is not billed or queued twice"),
+        assetIntent: z
+            .enum(["character", "object"])
+            .optional()
+            .describe("Controls whether hidden reference preparation targets a rig-safe character pose or isolated object view"),
+        referencePreparation: z
+            .enum(["auto", "always", "never"])
+            .default("auto")
+            .describe("Shared Studio reference-preparation policy; auto is recommended"),
+        rig: z.boolean().default(false).describe("Auto-rig the generated model"),
+        animationNames: z
+            .array(z.string())
+            .optional()
+            .describe("Animation names for the shared animated-character pipeline, e.g. Idle, Walk, Run, Jump"),
+        actionIds: z
+            .array(z.number().int().min(0).max(696))
+            .optional()
+            .describe("Exact Meshy action ids for the shared animated-character pipeline"),
+        riggingHeightMeters: z
+            .number()
+            .positive()
+            .max(10)
+            .optional()
+            .describe("Character height used by auto-rigging"),
         wait: z
             .boolean()
             .default(true)
-            .describe("Wait for completion (default true, up to 5 min). Set false to get jobId immediately."),
+            .describe("Wait for completion (default true, up to 10 min). Set false to get jobId immediately."),
         options: z
             .record(z.any())
             .optional()
             .describe("Provider-specific params (target_polycount, topology, art_style, etc.)"),
-    }, async ({ prompt, kind, model, imageUrl, wait, options }) => {
+    }, async ({ prompt, kind, model, imageUrl, imageUrls, title, idempotencyKey, assetIntent, referencePreparation, rig, animationNames, actionIds, riggingHeightMeters, wait, options, }) => {
+        const mergedOptions = {
+            ...(options ?? {}),
+            ...(imageUrls ? { imageUrls } : {}),
+            ...(assetIntent ? { assetIntent } : {}),
+            referencePreparation,
+            ...(rig ? { rig: true } : {}),
+            ...(animationNames ? { animationNames } : {}),
+            ...(actionIds ? { actionIds } : {}),
+            ...(riggingHeightMeters !== undefined ? { riggingHeightMeters } : {}),
+        };
         const result = await mcpGenerate("/api/mcp/generate/3d", {
             prompt,
             kind,
             model,
             imageUrl,
-            options,
+            title,
+            idempotencyKey,
+            options: mergedOptions,
         });
         if (result.error) {
             return errorResult(result.error, result.data);

package/dist/mcp/tools/project-tools.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { ASSET_POLICIES, GAME_TASK_MODES, GAME_TASK_TARGETS, VERIFICATION_LEVELS, buildGameTaskPlan, } from "../../lib/game-task-plan.js";
+import { getCachedBootDriftNotice } from "../../lib/mcp-boot-notice.js";
 import { getProjectMemorySummary } from "../../lib/project-memory.js";
 import { withEngine } from "./with-engine.js";
 function asRecord(value) {
@@ -134,18 +135,19 @@ anti-patterns, and recovery steps.`, {}, async () => ({
             {
                 type: "text",
                 text: JSON.stringify({
+                    summerUpdateNotice: getCachedBootDriftNotice()?.text ?? null,
                     startupChecklist: [
                         "Understand the request and outline a brief plan before reaching for tools.",
-                        "Default medium is host file tools: write/edit .gd/.cs/.tscn/.tres/.json/docs/config directly as text.",
-                        "Use Summer MCP only when you need the LIVE engine: play/stop, diagnostics, screenshots/verification, navmesh or light bake, runtime inspect, or asset import.",
+                        "Use summer_read_file, summer_write_file, and summer_replace_text for project text files so reads and guarded writes stay bound to the open engine project.",
+                        "Use Summer MCP for project mutations and live-engine work: scenes, resources, play/stop, diagnostics, screenshots/verification, bake, runtime inspection, and asset import.",
                         "Call summer_get_project_context first so you do not guess scene paths or the project language. It also BINDS this session to the currently-open project (see projectBinding below).",
                         "Use projectMemory from summer_get_project_context to decide which .summer Markdown files to read before creative/audio/dialogue/level/character work.",
                         "After writing code, VERIFY through the engine (see verificationLadder) instead of waiting for the user to navigate to it.",
                     ],
                     safeDefaults: [
                         "Never guess scene filenames (main.tscn/Main.tscn) -- get them from summer_get_project_context.",
-                        "Edit files (including .tscn/.tres) with host file tools by default. Reach for MCP scene-ops only for live-engine needs (bake, play, runtime inspect) or when you want the editor to manage node ids / instancing.",
-                        "If you hand-edit a .tscn that is OPEN in the editor, reload it there afterward -- the editor's open tab can overwrite your file (clobber).",
+                        "Use summer_replace_text for existing project text and summer_write_file with create_only:true for new files; overwrites require the sha256 from summer_read_file.",
+                        "For live scene hierarchy and inspector changes, prefer scene tools. Guarded text writes support .tscn/.tres, and the engine schedules editor reloads after they land.",
                         "Write GDScript by default; use C# only if the project already uses it.",
                         "Never remove multiple top-level nodes unless the user explicitly requests destructive edits.",
                         "Never change priority: locked .summer memory, voice IDs, canon, or provider bindings without explicit user confirmation.",
@@ -153,7 +155,7 @@ anti-patterns, and recovery steps.`, {}, async () => ({
                     buildFlow: [
                         "1. Understand what the user wants (one pass, no tool spelunking first).",
                         "2. Outline the plan fast and briefly; proceed once it is clearly right.",
-                        "3. Execute in pure code -- edit .gd/.tscn/.tres as text (GDScript by default, C# only if the project already uses it).",
+                        "3. Execute through identity-bound MCP mutations -- guarded text tools for files, scene tools for live hierarchy/inspector work (GDScript by default, C# only if the project already uses it).",
                         "4. Verify through the engine using the verificationLadder below, fix, and repeat until it launches clean.",
                     ],
                     // The MCP-native verification ladder. Climb only as high as the
@@ -172,11 +174,10 @@ anti-patterns, and recovery steps.`, {}, async () => ({
                         ],
                         "3_runs": [
                             "Compose the run-and-check yourself — there is no single 'verify' tool:",
-                            "summer_clear_console  -> clean slate",
                             "summer_play [scene]   -> boot the game (or a specific scene)",
                             "summer_get_debugger_errors  -> runtime errors (null refs, missing nodes, physics)",
                             "summer_screenshot target:'game'  -> optional visual of the live frame",
-                            "summer_stop  -> ALWAYS stop; scene mutations are refused while the game runs",
+                            "summer_stop  -> stop when runtime verification is finished; editor scene mutations are not categorically blocked by a running game, but an existing game instance may need a restart to observe them",
                         ],
                         "4_interactive": [
                             "To prove input-driven behavior (does jump/move/shoot actually work), you have two routes when the engine build supports them (both go through summer_batch as raw ops — see rawOpsViaBatch):",
@@ -204,12 +205,12 @@ anti-patterns, and recovery steps.`, {}, async () => ({
                         "To intentionally follow the switch, call summer_get_project_context again to rebind, then retry.",
                     ],
                     liveEngineFlow: [
-                        "Use this flow ONLY when you genuinely need live engine state (navmesh/light bake, instancing into an already-open scene, runtime inspect):",
+                        "Use this flow when you genuinely need live engine state (navmesh/light bake, scene mutation, runtime inspect):",
                         "summer_get_project_context",
-                        "summer_open_main_scene (if needed)",
-                        "summer_get_scene_tree",
-                        "summer_add_node / summer_set_prop / summer_set_resource_property",
-                        "summer_save_scene",
+                        "Choose the exact res:// scenePath. OpenScene is a user-visible tab action, not a mutation prerequisite.",
+                        "summer_get_scene_tree with scenePath when that exact scene is already loaded; omit it only for the visible tab.",
+                        "summer_add_node / summer_set_prop / summer_set_resource_property with scenePath",
+                        "Mutation tools append one final SaveScene; use summer_save_scene only for a standalone save/save-as.",
                         "summer_get_diagnostics",
                     ],
                     // summer_batch forwards each {op, ...} verbatim to the engine, so
@@ -221,11 +222,12 @@ anti-patterns, and recovery steps.`, {}, async () => ({
                         "These are runtime ops, not scene mutations — the batch undo group is a harmless no-op for them.",
                     ],
                     recovery: [
-                        "If you see 'no scene open': run summer_open_main_scene.",
+                        "If a scene mutation reports missing_scene_path: pass the exact res:// scenePath and retry.",
+                        "If a scene target cannot load: repair the named missing/invalid dependency, then retry the same scenePath.",
                         "If open_scene fails: re-check mainScene from summer_get_project_context.",
-                        "If save fails: verify scene is open and game is not running (summer_is_running / summer_stop).",
+                        "If save fails: use the returned scenePath/error to repair the exact cause. A running game alone is not a generic scene-mutation blocker.",
                         "If a mutation is rejected with identity_mismatch: the engine switched projects — call summer_get_project_context to rebind (only if you meant to follow it), then retry.",
-                        "If a .tscn you wrote keeps reverting: the editor has that scene open -- reload or close the tab, then write again.",
+                        "If a guarded file mutation is rejected with content mismatch: call summer_read_file again, review the new content, and retry with its new sha256 only if the edit is still valid.",
                         "If a run op or SimulateInput returns 'unsupported' / an unknown-op error: this engine build predates it — fall back to summer_play + summer_get_debugger_errors, or ask the user to interact.",
                     ],
                     debugging: [
@@ -270,10 +272,11 @@ Use this first in every fresh chat to avoid guessing scene filenames or editing
             mainScene,
             boundProjectIdHash,
             projectMemory: getProjectMemorySummary(projectPath),
+            summerUpdateNotice: getCachedBootDriftNotice()?.text ?? null,
             guidance: mainScene
                 ? "Use `summer_open_scene` with `mainScene` if no scene is open."
                 : "Main scene not found in project state. Open a known scene path explicitly.",
-            fileEditingGuidance: "Edit files (including .gd/.cs/.tscn/.tres/.json/docs) with host file tools by default. Use MCP only for live engine state: play/stop, diagnostics, screenshots/verification, navmesh or light bake, runtime inspect, and asset import. If you edit a .tscn that is open in the editor, reload it there afterward so the editor's tab does not overwrite your changes.",
+            fileEditingGuidance: "Use summer_read_file plus summer_replace_text or guarded summer_write_file for project files, including .gd/.cs/.tscn/.tres/.json/docs. New files require create_only:true; overwrites require the sha256 receipt from summer_read_file. Prefer scene tools for live hierarchy/inspector changes.",
         };
     }));
     server.tool("summer_open_main_scene", `Open the project's configured main scene from project settings.
@@ -315,10 +318,12 @@ Example: Bind jump to Space and W:
         ];
         return client.executeOps(ops);
     }));
-    server.tool("summer_get_scene_tree", `Get the full scene tree structure of the currently open scene.
-
-Use this before structural edits (add/remove/replace).
-If you get "no edited scene", call summer_open_main_scene first.`, {}, async () => withEngine(async (client) => client.getSceneState()));
+    server.tool("summer_get_scene_tree", `Get a scene tree. Pass scenePath to read that exact in-memory/open scene;
+omit it only when you intentionally want the currently visible editor scene.
+Scene mutations load their explicit target, so a follow-up targeted read does
+not require OpenScene.`, {
+        scenePath: z.string().optional().describe("Exact res:// scene path to inspect"),
+    }, async ({ scenePath }) => withEngine(async (client) => client.getSceneState(scenePath)));
     server.tool("summer_import_from_url", `Download a file from a URL and import it into the project. Triggers Godot's full import pipeline — generates .import files, extracts textures from .glb models, creates materials.
 
 Use this for: