SSHOW

Delete columns of tables with their cells, as one undo step: count columns from index. A merged cell reaching past them shrinks; a table keeps at least one column.

delete_table_columns

Delete rows of tables with their cells, as one undo step: count rows from index. A merged cell reaching past them shrinks; a table keeps at least one row.

delete_table_rows

Delete variables as one undo step.

delete_variable

Copy objects as one undo step (calling it again copies them again). A copy lands just above its original unless options place it; it keeps its position on the canvas. The result lists the copies.

duplicate_object

Copy scenes with their content as one undo step (calling it again copies them again); the result lists the copies.

duplicate_scene

End the show on its closing card. Needs a running show (show_start). The show is shared live by default: everyone with the project's play link open follows it on their own device.

show_end

Engine guide for authoring actions. Read topic 'apply' once before your first edit — the protocol rules and action recipes (build each object fully in one create, set.style replaces, anchors, decks) — then fetch only the sections you need. Call with no topic for the outline: every section and subsection title; a topic matches any title (case-insensitive substring) and returns that section with its subsections, e.g. 'apply', 'text' (the text rules and F1–F17 formulas), 'style', 'motion', 'object types', 'deck' (a multi-slide recipe).

get_guide

Find objects by a substring of their name or text content — every scene (or one), nested children included — without paging get_scene. Up to 50 matches in scene order: id, sceneId, type, name, text.

find_objects

Fonts a text may name: the registerable catalog (family, languages, weights, hint) and the faces already registered in this project. A fontFamily outside both falls back to the system font — apply_actions warns when that happens.

get_fonts

Navigate the user's editor to a scene (keeps their screen in sync with your edits). It is not a document change, so it is not undoable. The active scene is where an apply_actions op without sceneId lands and what get_scene and get_screenshot read when no scene is given; select_objects, and get_screenshot with objectId or time, work only in it. An unknown sceneId is refused. Returns the new activeSceneId.

set_active_scene

Group objects as one undo step: each entry wraps two or more objects of one scene in a new group. config.id is an alias the result maps to the new group id.

group_objects

Bring an image, video or audio file into the project as an asset and get the `asset://` src to put in create_object / update_object (data.src, image fills) — use it in your next apply_actions (an asset nothing references is garbage-collected). `url` is fetched by the user's editor in the browser: a data: URL always works; an https URL must allow cross-origin reads. Returns id, uri, type, mimeType, size, plus the media's `width`/`height` in pixels and a video/audio `duration` in seconds when the browser can read them — size the object from those or it keeps the 100x100 default and the media arrives squashed.

import_asset

Insert columns into tables as one undo step: count columns at index (omit = after the last column), each new cell in its neighbor's text style, values each table row's texts of the new columns. A merged cell the columns land inside grows over them.

insert_table_columns

Insert rows into tables as one undo step: count rows at index (omit = after the last row), each new cell in its neighbor's text style, values their texts row by row. A merged cell the rows land inside grows over them.

insert_table_rows

Jump the show to a visible scene; a blanked screen comes down with the jump. Needs a running show (show_start). The show is shared live by default: everyone with the project's play link open follows it on their own device. Entering a scene runs its entry and timer rules: a fetch rule sends its request, an openURL rule opens its link.

show_go_to

Leave the show and return to the editor. Needs a running show (show_start). The show is shared live by default: everyone with the project's play link open follows it on their own device.

show_exit

List the projects the user has open right now — each open editor is a target. Call this first to discover projectIds.

list_projects

Merge a range of cells in tables into one cell, as one undo step: their texts join into the range's first cell, line by line. Every cell in the range holds text.

merge_table_cells

Start a new, empty project in this account and get back its projectId and the URL that opens it. Use it when list_projects shows the account has none. The project is empty until someone opens that URL: the editor tools need it open, and reading it before then says it has no saved document — so create it, hand the user the URL, and ask them to open it.

create_project

Advance the show the way the clicker does: a transition still in flight is hurried onto its scene, then the scene's stop points play one by one, then the next scene comes. While the screen is blanked it brings the deck back instead. Needs a running show (show_start). The show is shared live by default: everyone with the project's play link open follows it on their own device. Entering a scene runs its entry and timer rules: a fetch rule sends its request, an openURL rule opens its link.

show_next

Hold the scene clock where it is if it is running, or let a held clock run on to its next stop; calling it again reverses it, and a scene without a timeline has nothing to hold. While the screen is blanked it brings the deck back instead. get_show_state reports which applies (transport.status, cover). Needs a running show (show_start). The show is shared live by default: everyone with the project's play link open follows it on their own device.

show_toggle_playback

Cheap first read of one project: canvas size, scene list (id/name/visible/object count/type histogram), active scene, current selection, the viewport (the canvas area on the user's screen), variables (id/name/type/value), registered fonts (family/weights/styles), the media the project already holds (`assets` — reuse one of these `asset://` uris instead of importing the same file again), the editing context (`editor` — which mode the user is in and whether a write will land as a keyframe; see get_guide('apply')), document notes. Drill into a scene with get_scene.

get_project_overview

One scene: its own fields (name, description, notes, visible, style, data.clip, motion — what update_scene can set) and its object tree in compact form (engine defaults omitted, long text/path/src elided). Default = the active scene. Use get_object for one object's full detail.

get_scene

One object's full serialized detail (style/motion/data; long asset src elided), the sceneId it lives in and its bounds on the canvas (x/y/width/height, document coordinates).

get_object

Where the running presentation stands, as the presenter view sees it: the scene on stage (index / total over visible scenes, a beat ahead while a transition is in flight) and the next one, the speaker notes (scene and project), the scene clock (playing / waiting at a stop / at its end, time, stops passed), what the next clicker input will do (`forecast`: skipAhead, playToNextStop, playToEnd, nextScene, backToFirst, endOfShow, finishTransition, backToShow), the screen cover in effect, whether the audience window still owes a click for fullscreen, and the show timer. `showing` is false with only `mode` when no show is running. Read-only.

get_show_state

Redo the apply_actions this agent last undid. Refused when the newest undone entry is the user's.

redo

Move scenes to another position in the deck, as one undo step.

reorder_scene

Move variables to another position in the list, as one undo step.

reorder_variable

Drive the presentation on the user's screen: 'start' opens it (add fromStart to begin at the first scene instead of the current one) with its opening scene waiting for the first 'next' unless the show loops or its rules run without input, 'next' and 'previous' are the clicker — they hurry an in-flight transition onto its scene (it lands a moment later), then walk the scene's stop points, then cross to the next scene — 'goTo' jumps to `sceneId`, 'togglePlayback' holds the scene clock where it is or lets it run again, 'toggleCover' blanks the screen (`cover` black or white; again brings the deck back), 'endShow' ends on the closing card, and 'exit' returns to the editor. Everything but start needs a running show. The show opens in the editor's own window, since going fullscreen needs the user to do it — with pendingFullscreen it opens at screen size and the user's first click on it goes fullscreen. Nothing here changes the document, so none of it is undoable. The show is shared live by default: everyone who has the project's play link open follows it on their own device, so what it shows them can't be taken back. Entering a scene also runs the rules that fire on entry or on a timer: a fetch rule sends its request, an openURL rule opens its link. Returns the mode the editor ended up in and the scene now on screen; get_show_state reads the rest.

control_show

PNG snapshot of a scene (or one object) as rendered right now, with a text block naming the scene and the pixel size. The cheapest way to verify visual state after edits — prefer this over re-reading the scene tree. Any scene can be captured; `time` (ms) poses the ACTIVE scene at that point of its timeline (see motion.animations) before capturing. A small SSHOW mark in the bottom-right corner is the offline editor's own watermark, not a project object.

get_screenshot

Select objects in the active scene to point the user at them (empty array clears selection). An id from another scene is refused with a pointer to that scene — call set_active_scene first.

select_objects

Set the canvas size every scene shares, in pixels, as one undo step. Objects pinned to the canvas follow its new edges.

set_canvas_size

Replace the interaction rules of objects, or of a scene when id is left out, as one undo step (guide §13). Rules run in a show or the preview: an openURL rule opens its link and a fetch rule calls its web address. A fetch rule is written by hand in the editor, so send back the ones you read unchanged — a new or changed one is skipped.

set_rules

Set motion on objects, or on a scene when id is left out, as one undo step: navigation transitions (guide §8) and the scene's timeline (guide §10). A scene's clock and its objects' tracks can go in one call; transitions and animations merge into what is already there.

set_motion

Replace the style — fills, strokes and effects — of objects, or of a scene (its background) when id is left out, as one undo step. The whole block is replaced: always send all three arrays.

set_style

Start presenting the project in the editor's own window (fromStart = from the first scene). Going fullscreen needs the user's own click, so with pendingFullscreen it opens at screen size and their first click goes fullscreen. The opening scene waits for the first show_next unless the show loops or its rules run on their own. The show is shared live by default: everyone with the project's play link open follows it on their own device. Entering a scene runs its entry and timer rules: a fetch rule sends its request, an openURL rule opens its link. Returns the mode the editor is in and the scene on screen; get_show_state reads the rest.

show_start

Send one input to the running show (or the editor's preview) and see what the document's rules did with it — the interaction counterpart of get_screenshot. `type` is the input: click, doubleClick, longPress, pointerDown, pointerUp, pointerEnter (the pointer moving onto `objectId`), pointerLeave (the pointer leaving the deck), swipe (+ direction), keyDown (+ key, ctrl/shift/alt), message (+ name, and `payload` for what a `message` rule's `into` reads). `objectId` is the object under the pointer — omit it for empty space, which the scene's own rules answer. Returns the rules that fired, the ones a condition or a failure held back (with the reason), `consumed` (a click no rule takes is reported, not passed to the clicker — control_show('next') advances the deck), the scene now on screen, and a screenshot taken once a scene transition the rules started has finished — add `wait` (ms) to let an animation play before the capture. Rules run only while a show or the preview is up: call control_show('start') first and 'exit' when done. Nothing here changes the document, but the rules it fires run for real: a fetch rule sends its request, an openURL rule opens its link, and a live show's audience sees the result.

simulate_event

Undo this agent's last apply_actions. Refused (ok:false with the reason) when the newest history entry is the user's own edit — that one is theirs to undo.

undo

Dissolve groups as one undo step; their children stay where they are on the canvas.

ungroup

Split every merged cell in a range of tables back into single cells, as one undo step; each keeps its text in its first cell.

unmerge_table_cells