Summer Engine

Add one node of any type to the scene at scenePath (it need not be the open tab) and save it. For 3 or more edits, write one summer_run_script instead. Next: summer_set_prop. Guide: summer_docs_read {"id":"tool/add-node"}

Align 2 to 16 3D nodes on one world axis (min, center, max) or space them equally (centers or gaps) from their visible bounds, then save the scene. One undo step. Guide: summer_docs_read {"id":"tool/align-distribute-3d"}

Look up an engine class offline before writing script code: inherits, properties, methods, signals and constants, or one member. Lists only members declared on that class (walk inherits). No engine needed. Next: summer_run_script.

Turn a piece so its measured back faces a wall, ceiling or floor found by a ray, keep it upright and seat it at a standoff: pipes, lamps, signs. Saves the scene; a refused seat puts the piece back. Guide: summer_docs_read {"id":"tool/attach-to-surface"}

Send a list of raw engine ops (AddNode, SetProp, RunVerification...) in one call: one undo step unless an op must travel alone, and one save at the end. Ask for receipt summary on long lists. For computed edits, summer_run_script is simpler. Guide: summer_docs_read {"id":"tool/batch"}

Run any Summer operation by name (from summer_search) with its input. Engine operations run here; cloud ones run on Summer's server with the same approvals: money, publishing and live changes answer needs_approval with a link. 3.x tool names work too.

Capture real gameplay frames (HUD included) from a hidden game window, no editor needed; game flags and player steps get past the title screen. Returns each frame's path and size: look at them before use. Guide: summer_docs_read {"id":"tool/capture-gameplay"}

Clear the editor's Output panel, for a clean slate before the game runs. Guide: summer_docs_read {"id":"tool/clear-console"}

Move and turn one piece so its port (a Marker3D, or an open pipe end such as +Y) meets another piece's port: pipe to pipe, duct to duct. Refuses joins that tilt the piece. Saves the scene. Guide: summer_docs_read {"id":"tool/connect-ports"}

Connect a signal of one node to a method of another so the saved scene keeps it, verified from the saved .tscn. The receiver should define the method. Then test it with summer_play. Guide: summer_docs_read {"id":"tool/connect-signal"}

Write a support-ready Markdown report: doctor checks, engine health, diagnostics, console and debugger output, and a hand-off prompt. No tokens or file contents; the person should still read it before sending it. Guide: summer_docs_read {"id":"tool/create-debug-report"}

Create a new, minimal .tscn file with the root type you name. It fails when the file exists and never touches the open scene. Build it out with summer_run_script and that scenePath. Guide: summer_docs_read {"id":"tool/create-scene"}

Render one pose as a grid of debug views next to the beauty pass: lighting only, albedo, world normals, overdraw and wireframe. Shows why a shot looks wrong. Guide: summer_docs_read {"id":"tool/debug-views"}

Load one library entry by id (<kind>/<slug>, as returned by summer_docs_search). Skills: the SKILL.md body plus metadata (status, use_when, related) and how to invoke the skill in your host (bare slug). Tools: how to call it (MCP name, `summer tool <slug> --args`, engine requirement, authority) plus the descriptor. Templates: the pinned repo @ commit and tree digest (or built-in) and the `summer create <slug>` command. References: the markdown body. Hosted skills (publish-your-game, store-listing, store-art, grow-analytics; also by their summer://skills/<slug> URI): the current text from the hosted Summer Engine MCP with the store sign-in, else the local summary plus why and how to load the rest. Linked files: a body ends with its relative links and the id that loads each; a file an entry links loads by <entry id>/<link as written> (e.g. skill/spatial-placement/references/kit-placement-tools.md), by the relative path alone when one entry ships it, inside library/ only. part: 'skill' = body only, 'resource' = the resource.yaml descriptor only, 'all' (default) = both. The LAST line of every load is the feedback footer `— entry_id: <id>@<content-hash>. If this entry is wrong, stale, or you deviate from it, report via summer_call {"op":"docs.feedback"}.` — copy that entry_id verbatim into summer_call {"op":"docs.feedback"} once you have verified the outcome in-engine. Unknown id -> {ok:false, error:'not_found', nearest:[up to 3 ids]}. No engine needed; reads the library shipped with this package.

Search the Summer library — skills, tools, templates, references, examples, collections — by describing the task in plain words ('make stylized water', 'the player falls through the floor', 'which tool reads script errors'). This is the FIRST MOVE for any task: even a 1% chance the library covers it means you search, then read the entry you pick with summer_docs_read before acting — never act on a summary alone. Ranking: BM25 over ids, summaries, use_when lines and facets with kind-aware priors and related-entry boosts (the same ranker the routing eval gates). When this install ships registry/generated/embeddings.json and the embedding endpoint answers within 1.5s, lexical and semantic rankings are fused (reciprocal rank fusion) and each hit's matched_by says which side found it; offline or without embeddings it is lexical only and never fails for that reason. Returns {query, semantic, count, results: [{id, kind, status, summary, use_when, score, matched_by, mcp_tool_name?}], hint}. Scores compare only within one response. kinds narrows to some of the six kinds; include_preview:false hides preview entries; deprecated entries never surface. No engine needed. Privacy: only when semantic search is active is the query text sent to the Summer gateway to be embedded; nothing else leaves the machine.

Enable an editor plugin in res://addons/<name>/ and return the real result: enabled with its autoloads, or why it failed. Older engines only queue it (queued true); then check summer_get_debugger_errors. Guide: summer_docs_read {"id":"tool/enable-plugin"}

Delete one saved camera viewpoint by name. Returns the names that remain. Guide: summer_docs_read {"id":"tool/camera-bookmark"}

Run one named editor action exactly as its menu item or shortcut would: open Project Settings, switch the main screen, toggle a panel. Editor work only; scene work is summer_run_script. Read the effect back with summer_ui_tree. Guide: summer_docs_read {"id":"tool/ui-actions"}

List the camera viewpoints saved in this project: names, poses and dates. A bookmark gives screenshots that line up before and after a change: summer_screenshot with framing bookmark. Guide: summer_docs_read {"id":"tool/camera-bookmark"}

List the editor's named actions (menu items and shortcuts) with labels and shortcuts, filtered by text. Actions marked denied are refused. Next: summer_engine_invoke_ui_action. Guide: summer_docs_read {"id":"tool/ui-actions"}

Save a named camera viewpoint in the project (res://.summer/camera_bookmarks.json): position and look_at as Vector3 literals, or neither to take the editor's 3D camera. The scene file is not touched. Next: summer_screenshot. Guide: summer_docs_read {"id":"tool/camera-bookmark"}

Export the game headless as the file the Summer Games store takes: a bundle for iPhone, Android, macOS and Windows, a web build or a desktop download. Returns path, sha256 and size. Upload it with store.upload_file. Guide: summer_docs_read {"id":"tool/export-game"}

List or install Summer Engine export templates (web, macOS, Windows) from Summer's CDN, each sha256-checked. Needed only for summer_export_game with format download. Guide: summer_docs_read {"id":"tool/export-templates"}

Make a mesh with a bpy script in the person's own Blender (4.2 or newer, headless), import the .glb into the project and optionally place it. For exact modular kits and effect meshes, not characters or props. Guide: summer_docs_read {"id":"tool/fabricate-3d"}

Fit a camera to the world bounds of some nodes and render them with the scene's real environment and lights; bookmark_name also saves the pose. Returns the image and a caption with the pose and bounds. Guide: summer_docs_read {"id":"tool/frame-nodes"}

Find, score and save camera poses for a shot type (establishing, eye level, low angle, detail, corridor), tested against the real geometry in the open editor. Returns the best 3 poses and a sheet to look at, and saves the best as a bookmark. Guide: summer_docs_read {"id":"tool/frame-shot"}

Pause or resume the RUNNING game, step exactly N frames, set the time scale, or list the live game instances. Step between two summer_game_probe reads for exact checks. Guide: summer_docs_read {"id":"tool/game-control"}

Drive the RUNNING game's input: a script of timed actions, keys and clicks, or record real input and replay it on a seeded instance. Input is an action: prove its effect with summer_game_probe. Guide: summer_docs_read {"id":"tool/game-input"}

Read state and pixels of one frame of the RUNNING game together: the live tree, property values and a screenshot stamped with the same frame numbers. The evidence read of a playtest. Guide: summer_docs_read {"id":"tool/game-probe"}

Read recent editor Output messages, collapsed and filtered (errors and warnings by default; errors_only false for print output). A played game's runtime errors are not here: read summer_get_diagnostics first. Guide: summer_docs_read {"id":"tool/get-console"}

Read the played game's runtime errors from the debugger (null references, missing nodes, physics errors), collapsed, with call stacks on request. After a fix, read summer_get_diagnostics again. Guide: summer_docs_read {"id":"tool/get-debugger-errors"}

Read the played game's runtime warnings from the debugger, with file, line and call stack. Guide: summer_docs_read {"id":"tool/get-debugger-warnings"}

Read the editor console, the runtime debugger and script errors together, with complete counts and errors first. The first read after a change and after play. Next: summer_get_debugger_errors or summer_get_console for the details. Guide: summer_docs_read {"id":"tool/get-diagnostics"}

Bind this session to the project open in Summer Engine and read it: project, current and main scene, engine health, project memory and warnings. Call it first in every chat; the scene tree and settings come on request (include). Next: summer_get_scene_tree. Guide: summer_docs_read {"id":"tool/get-project-context"}

Read the node tree of the RUNNING game: spawned enemies, autoloads and pooled nodes that editor reads never show. Needs a running game. Next: summer_inspect_runtime_node. Guide: summer_docs_read {"id":"tool/get-runtime-tree"}

Read the node tree of a scene: names, types and paths. Pass scenePath for an exact scene and depth for deep trees; the engine stops at depth 2 and 200 nodes by default and says truncated. Next: summer_inspect_node. Guide: summer_docs_read {"id":"tool/get-scene-tree"}

Check one GDScript file for parse and compile errors without running the game: line, message and severity of each. The first check after writing a script. Guide: summer_docs_read {"id":"tool/get-script-errors"}

Search project files with a regular expression: file, line and text of each match, with optional context lines and a result cap. Then read the part you need with summer_read_file. Guide: summer_docs_read {"id":"tool/grep"}

Search the Summer asset library, import the best match into the project and, for a 3D model, add it to a scene. Needs the Summer sign-in. For an exact asset use summer_import_asset_by_id. Guide: summer_docs_read {"id":"tool/import-asset"}

Import one Summer asset by its id (from a search, the person's assets or a generation) into the project; a 3D model can go straight into the scene at scenePath. Needs the Summer sign-in. Guide: summer_docs_read {"id":"tool/import-asset-by-id"}

Download one file (model, texture, audio) from a URL into the project and run the import, so it is ready to use. For a model, next: summer_instantiate_scene. Guide: summer_docs_read {"id":"tool/import-from-url"}

Download several files from URLs into the project in one call, with one import scan at the end. Guide: summer_docs_read {"id":"tool/import-from-url-batch"}

Find a CC0 HDRI sky on Poly Haven (or take an exact id) and import it into res://sky/ for environment light. Returns a ready summer_run_script snippet that wires it into the WorldEnvironment. Guide: summer_docs_read {"id":"tool/import-hdri"}

Create an input action when it is missing and bind keys or mouse buttons to it, for example jump to Space. Then try it with summer_play. Guide: summer_docs_read {"id":"tool/input-map-bind"}

Measure a 3D asset file without placing it: bounds, origin, meshes, largest flat faces, open pipe ends, Marker3D anchors and collision shapes. Measure each kit piece once before placing it. Next: summer_instantiate_scene. Guide: summer_docs_read {"id":"tool/inspect-asset"}

Read one node of the open scene: every editable property with its value and type, or only the fields you name (transform, global_transform, scene_file_path, aabb). Next: summer_set_prop. Guide: summer_docs_read {"id":"tool/inspect-node"}

Read a resource file (a mesh's bounds and surfaces, a scene's nodes, any resource's non-default properties) or a resource a node holds (nodePath and property). Next: summer_set_resource_property. Guide: summer_docs_read {"id":"tool/inspect-resource"}

Read the live properties of one node in the RUNNING game (transform, visibility, physics state...) without stopping it. Paths are absolute; take them from summer_get_runtime_tree. Guide: summer_docs_read {"id":"tool/inspect-runtime-node"}

Add an existing .tscn, .glb or .gltf as a child node in the scene at scenePath, placed in the same call (position, rotation_degrees, scale or transform). Pass target_size for imported models. Next: summer_screenshot. Guide: summer_docs_read {"id":"tool/instantiate-scene"}

Check whether the game is running, and which scene it runs. Guide: summer_docs_read {"id":"tool/is-running"}