Get started
Reference

Studio verbs

Studio verbs

Dispatch a verb with useStudioDispatch() or bus.dispatch(name, input). The capability is what the viewer must hold. A verb that confirms asks the user before it runs, and answers confirmation-denied when they decline.

alert

VerbCapabilityConfirmsInputSummary
studio.alert.dismissembeddingDismiss the map-level alert if one is visible.
studio.alert.showembedding{ level, message }Show a map-level alert (info, warning, or error) at the bottom of the studio map.

collab

VerbCapabilityConfirmsInputSummary
studio.collab.change.applyauthenticated{ action, id, itineraryId, kind, bustToken? }Reconcile a persisted change a collaborator made (an itinerary, segment, waypoint, zone, or collection created/updated/deleted): evict the affected server-state cache and, when the change hit the open itinerary, refetch its vector tiles keyed to the change's bust token.
studio.collab.list.applyauthenticatedRefetch every itineraries listing after a collaborator created or deleted an itinerary, so the sidenav reflects the new set.
studio.collab.lock.clearauthenticated{ id, kind, resource }Release the live lock on an entity a collaborator finished editing.
studio.collab.lock.setauthenticated{ id, kind, resource, userId }Mark an entity (a segment, segment group, waypoint, or zone) as being edited by a collaborator so the local UI can show a locked affordance.
studio.collab.lock.snapshotauthenticated{ locks, resource }Replace the tracked entity locks with the session's authoritative held-lock set (sent on connect or periodically), so a stale locked affordance clears once its holder departs.
studio.collab.peerDraft.clearauthenticated{ id, kind, resource }Drop the live draft preview on an entity a collaborator finished editing.
studio.collab.peerDraft.setauthenticated{ id, kind, resource, userId }Record a collaborator's in-flight edit for live preview, keyed by the edited entity: a segment's live projection or a zone's drawn shape.
studio.collab.peerSelection.setauthenticated{ resource, selection, userId }Mirror the entity a collaborator has focused (null clears their focus).
studio.collab.presence.clearauthenticated{ resource, userId }Stop tracking a collaborator that left the session, dropping their live selection and drafts.
studio.collab.presence.setauthenticated{ connectedAt, userId, resource }Track a collaborator that joined the session (or refresh one already tracked).
studio.collab.presence.snapshotauthenticated{ peers, resource }Replace the tracked collaborators with the session's authoritative connected list (sent on connect or reconnect).
studio.collab.resetauthenticated{ resource }Clear the mirrored collaboration state (peers, locks, and drafts) for an editor resource when its collaboration session tears down, so no stale collaborator lingers into the next document.

collection

VerbCapabilityConfirmsInputSummary
studio.collection.addItineraryeditor{ collectionId, itineraryId }Add an itinerary to a collection.
studio.collection.createeditor{ isPrivate, name, description?, itineraryId?, organizationId? }Create a new collection, optionally adding an itinerary to it as part of the same action.
studio.collection.createCloseauthenticatedClose the new-collection modal.
studio.collection.createOpenauthenticatedOpen the new-collection modal.
studio.collection.deleteeditorYes{ collectionId }Permanently delete a collection.
studio.collection.editCloseauthenticatedClose the edit-collection dialog.
studio.collection.editOpenauthenticated{ description, id, isPrivate, name }Open the dialog for editing a collection's name, description, and privacy.
studio.collection.manage.closeauthenticatedClose the manage-collections dialog.
studio.collection.manage.openauthenticated{ entity, entityId }Open the dialog for managing which collections an entity (an itinerary or a zone) belongs to.
studio.collection.openForEditauthenticated{ collectionId }Point the studio's collection surface at one collection so it opens for editing.
studio.collection.removeItineraryeditor{ collectionId, itineraryId }Remove an itinerary from a collection.
studio.collection.reorderItineraryeditor{ collectionId, itineraryId, position }Set an itinerary's display position within a collection.
studio.collection.updateeditor{ collectionId, description?, isPrivate?, name? }Update a collection's name, description, and/or privacy.
studio.collection.addZoneeditor{ collectionId, zoneId }Add a zone to a collection.
studio.collection.removeZoneeditor{ collectionId, zoneId }Remove a zone from a collection.

contextmenu

VerbCapabilityConfirmsInputSummary
studio.contextmenu.closeembeddingClose the right-click context menu.
studio.contextmenu.openembedding{ lngLat }Open the right-click context menu at a [lng, lat] coordinate.

data

VerbCapabilityConfirmsInputSummary
studio.data.geocodeauthenticated{ query, bbox?, categories?, focus?, language?, limit? }Forward-geocode free text into named places (cities, regions, natural features, addresses) ranked by relevance, optionally biased by a focus point or constrained to a bounding box.
studio.data.poisauthenticated{ area, categories, language?, limit? }List points-of-interest matching 1–10 categories (e.g. WATER_SOURCE, HUT, SHELTER) inside a bounding box or a buffered area (a point or a line expanded by a radius).
studio.data.reverseGeocodeauthenticated{ point, categories?, language?, limit?, radiusMeters? }Resolve a [lng, lat] coordinate into the named places closest to it, ranked by proximity then relevance, optionally constrained by a radius in meters.
studio.data.searchauthenticated{ query, targets, bbox?, focus?, language?, limit?, placeCategories?, poiCategories? }Run a full-text search across places and/or points-of-interest, optionally biased by a focus point or constrained to a bounding box.

edit

VerbCapabilityConfirmsInputSummary
studio.edit.discardActiveauthenticatedDiscard whichever authoring edit is armed (segment, waypoint, or zone), let go of what the editor's forms held unsaved, and return to the clean no-edit state.
studio.edit.formUnsaved.setauthenticated{ form, unsaved }Record whether a form whose fields the editor draws (the itinerary's form, or a waypoint's details) holds something unsaved, so leaving the editor asks first.

embed

VerbCapabilityConfirmsInputSummary
studio.embed.closeauthenticatedClose the embed-in-website wizard.
studio.embed.openauthenticated{ id, kind }Open the embed-in-website wizard for an itinerary or a collection (kind and id), to author a copy-paste iframe snippet of the embedded studio.
studio.embed.setContentembedding{ itineraryId, terrain?, withAccessRestrictions?, withDirectionsControl?, withDownloadControl?, withNavigationControl?, withOverlays?, withOverlaysControl?, withPreferencesControl?, withProfileAnalysis?, withProfileCharacteristics?, withProfileElevation?, withProfilePaceControl?, withStreetviewControl?, withTerrains? }Set the embedded studio's live content from a host postMessage: switch to an itinerary by id, or to the base map alone with a null id, and fold in any display overrides the command carries (terrain, overlay/terrain allowlists, control toggles).

geolocate

VerbCapabilityConfirmsInputSummary
studio.geolocate.confirmauthenticatedConfirm the geolocate prompt: close the modal, fetch the device location, and center the map on it.
studio.geolocate.prompt.closeauthenticatedClose the pre-prompt geolocate modal without requesting a location fix.
studio.geolocate.prompt.openauthenticatedOpen the pre-prompt modal that asks the viewer to share their location.

itinerary

VerbCapabilityConfirmsInputSummary
studio.itinerary.getActiveauthenticatedGet the active itinerary: its id, name, the segments (id, name, mode, length in km, start/end [lng,lat], and the stored elevation profile: ascent/descent in m, altitude min/max in m, steepest up/down gradient in degrees), and the waypoints (id, name, position, mode).
studio.itinerary.profile.pace.setembedding{ speedKmh }Set the reader's OWN travel pace for the open itinerary, in km/h on level ground, and re-time the profile's figures for it.
studio.itinerary.profile.sheet.setembedding{ snap }Open the elevation profile's bottom sheet to a snap point on a narrow viewport: 'peek' (the key figures alone), 'half' (plus the elevation chart), or 'full' (plus the surface and way-type analysis).
studio.itinerary.profileMarker.setembedding{ lngLat, icon? }Show or clear a map marker at the elevation profile's hovered coordinate.
studio.itinerary.createeditor{ activityId, name, collectionIds?, isPrivate?, organizationId? }Create a new itinerary from an activity and a name (with an optional owning organization), set it as the active itinerary, and return its id.
studio.itinerary.activateembedding{ itineraryId }Activate an itinerary as the editor's focus: mirrors the loaded itinerary from the query cache into the UI store.
studio.itinerary.createOpenauthenticatedOpen the create-itinerary surface in the sidenav.
studio.itinerary.deleteeditorYes{ itineraryId }Permanently delete an itinerary and all of its segments and waypoints.
studio.itinerary.duplicateeditor{ itineraryId, name, organizationId?, segmentIds?, waypointIds? }Copy an itinerary into a new one, optionally into another organization.
studio.itinerary.duplicate.closeeditorClose the duplicate-itinerary form without copying anything.
studio.itinerary.duplicate.openeditor{ itineraryId }Open the duplicate-itinerary form for an itinerary.
studio.itinerary.emphasis.setembedding{ mode }Emphasize itineraries on the map by dimming the unfocused ones: 'none' restores full opacity, 'dimAll' dims every itinerary, 'itinerary' (with id), 'segment' (with id), 'segments' (with ids), or 'waypoint' (with id) keeps those at full opacity and dims the rest.
studio.itinerary.exclusions.setauthenticated{ segmentIds, waypointIds }Suppress itinerary segments and waypoints from the map's tile render by id, so a feature being edited elsewhere is not drawn twice.
studio.itinerary.exportembedding{ format, itineraryId, segmentId?, variant? }Download the published version of an itinerary (or of one of its segments) as a GPX, FIT, TCX, GeoJSON, KML, KMZ or CSV file.
studio.itinerary.export.closeembeddingClose the export dialog.
studio.itinerary.export.openembedding{ itineraryId, segmentId? }Open the export dialog for an itinerary (optionally limited to a single segment) so a file can be downloaded in any offered format.
studio.itinerary.hover.setembedding{ hovered }Record which itinerary segment or waypoint the pointer is over on the map so the editor list highlights the matching row (null clears it).
studio.itinerary.import.clearDraftauthenticatedReturn the import surface from its staging step back to the file step, keeping the open session, provider, activity, and uploaded file so the user can re-preview.
studio.itinerary.import.confirmeditorConfirm the reviewed import, persisting it as a new itinerary and opening it in the editor.
studio.itinerary.import.discardauthenticatedDiscard the open itinerary import, closing the surface without persisting.
studio.itinerary.import.openauthenticated{ provider? }Open the itinerary import surface in the studio, optionally on a specific file format (gpx, geojson, kml, kmz, fit or tcx).
studio.itinerary.import.setActivityauthenticated{ activityId }Set the activity override for the import (null resolves the source's best-effort activity) and re-run the preview from the retained source so every segment re-routes under the new activity, keeping the uploaded file and form state.
studio.itinerary.import.setCollectionsauthenticated{ collectionIds }Set the collections the imported itinerary will be added to on the open import session.
studio.itinerary.import.setGranularityauthenticated{ granularity }Set the import segmentation granularity (auto splits on the source structure, single collapses to one segment) and re-run the preview from the retained source, keeping the uploaded file and form state.
studio.itinerary.import.setNameauthenticated{ name }Set the editable itinerary name on the open import session.
studio.itinerary.import.setOrganizationauthenticated{ organizationId }Set the organization that will own the imported itinerary on the open import session (null defaults to the authenticated user's organization).
studio.itinerary.import.setPrivateauthenticated{ isPrivate }Set whether the imported itinerary is persisted as private on the open import session.
studio.itinerary.import.setProviderauthenticated{ provider }Switch the import provider, clearing any preview from the previous source.
studio.itinerary.import.setSegmentModesauthenticated{ modes }Set the chosen candidate (routed or freehand) on specific proposed import segments in one step.
studio.itinerary.import.submitPrevieweditor{ file, provider, activityId?, granularity? }Preview an itinerary import from a picked file, producing a reviewable draft of proposed segments and waypoints.
studio.itinerary.import.toggleModeauthenticated{ segmentId }Toggle a proposed segment between its routed (directions) and freehand (linestring) candidate.
studio.itinerary.openForEditauthenticated{ itineraryId }Load an itinerary into the editor and frame it on the map.
studio.itinerary.publisheditor{ itineraryId }Publish the itinerary, freezing its current segments, waypoints, and groups into the version the share link and the embed serve.
studio.itinerary.renameeditor{ itineraryId, name }Rename an itinerary, persisting its new display name.
studio.itinerary.segment.removeeditorYes{ itineraryId, segmentId }Delete a segment from an itinerary.
studio.itinerary.segment.renameeditor{ itineraryId, name, segmentId }Rename a segment within an itinerary, persisting its new display name.
studio.itinerary.segment.selectembedding{ segmentId }Select an itinerary segment to focus the elevation profile and map highlight on (null clears the selection).
studio.itinerary.suggest.applyCandidateeditor{ seed, segmentName }Apply a generated route candidate to the open itinerary: it reshapes the segment the batch targeted (opening a live edit the user saves), or appends it as a new routed segment when the batch targeted none.
studio.itinerary.suggest.beginPickauthenticated{ target }Arm a map click to set the suggested route's start or end point.
studio.itinerary.suggest.cancelPickauthenticatedCancel an armed map pick for the suggested route's start or end point.
studio.itinerary.suggest.clearDraftauthenticatedReturn the suggest surface from its draft editor back to the candidate list, keeping the generated candidates and inputs so the user can pick another route.
studio.itinerary.suggest.commiteditorCommit the suggest session's draft as a new itinerary and open it in the editor, ready to keep shaping.
studio.itinerary.suggest.discardauthenticatedDiscard the open suggest surface, closing it without creating an itinerary.
studio.itinerary.suggest.generateauthenticated{ targetSegmentId? }`Generate route suggestions for the open suggest session (initial or regenerate): asks the data API for ${SUGGESTION_TARGET_COUNT} candidates matching the activity, distance, ascent, and start/end, reproducing kept ones and avoiding already-seen seeds.
studio.itinerary.suggest.selectauthenticated{ seed }Select a generated candidate by its seed to preview its route on the map.
studio.itinerary.suggest.setActivityauthenticated{ activityId }Set the activity the suggested routes are generated for, by catalog id or activity slug (null clears it).
studio.itinerary.suggest.setAscentauthenticated{ ascentMeters }Set the target elevation gain in meters for the suggested routes (null uses the activity default).
studio.itinerary.suggest.setCollectionsauthenticated{ collectionIds }Set the collections the committed itinerary will be added to on the open suggest session.
studio.itinerary.suggest.setDistanceauthenticated{ distanceMeters }`Set the target distance for the suggested routes, in meters: above 0 and at most ${SUGGEST_DISTANCE_MAX_METERS} (${SUGGEST_DISTANCE_MAX_METERS / METERS_PER_KILOMETER} km).
studio.itinerary.suggest.setEndauthenticated{ lngLat }Set the end point for a point-to-point suggested route from a [lng, lat] coordinate (null clears it).
studio.itinerary.suggest.setNameauthenticated{ name }Set the editable itinerary name on the open suggest session.
studio.itinerary.suggest.setOrganizationauthenticated{ organizationId }Set the organization that will own the committed itinerary on the open suggest session (null defaults to the authenticated user's organization).
studio.itinerary.suggest.setPrivateauthenticated{ isPrivate }Set whether the committed itinerary is persisted as private on the open suggest session.
studio.itinerary.suggest.setRouteTypeauthenticated{ routeType }Set the suggested route shape: a loop that returns to the start, or a point-to-point line between a start and an end.
studio.itinerary.suggest.setSpeedauthenticated{ speedKmh }Set the travel speed in km/h for the suggested routes (null uses the activity default).
studio.itinerary.suggest.setStartauthenticated{ lngLat }Set the start point for the suggested routes from a [lng, lat] coordinate.
studio.itinerary.suggest.startFromeditor{ itineraryName, segmentName }Start from the selected suggested route: shape it into the suggest session's editable draft so the user can name it, set visibility/owner/collections, and tweak it before creating.
studio.itinerary.suggest.toggleKeepauthenticated{ seed }`Pin or unpin a generated candidate by its seed so a regenerate reproduces it.
studio.itinerary.suggestOpenauthenticatedOpen the suggest-itineraries surface.
studio.itinerary.unpublisheditorYes{ itineraryId }Withdraw the itinerary's publication, so the share link and the embed stop serving it.
studio.itinerary.updateeditor{ isPrivate, itineraryId }Change an itinerary's visibility (private or public), persisting the change.
studio.itinerary.waypoint.removeeditorYes{ itineraryId, waypointId }Delete a waypoint from an itinerary.
studio.itinerary.waypoint.renameeditor{ itineraryId, name, waypointId }Rename a waypoint within an itinerary, persisting its new display name.
studio.itinerary.waypoint.selectembedding{ waypointId }Select an itinerary waypoint to focus the map highlight on (null clears the selection).
studio.itinerary.tiles.refresheditor{ revision? }Refetch the itinerary vector tiles in place.
studio.itinerary.directions.closeembeddingClose the turn-by-turn directions dialog.
studio.itinerary.directions.openembedding{ itineraryId, segmentId? }Open the turn-by-turn directions dialog for an itinerary (optionally limited to a single segment) so a PDF of the indications can be downloaded.
studio.itinerary.group.createeditor{ color, itineraryId, name, segmentIds, speed? }Group two or more neighbouring segments under one name, colour, and optional speed, so they read as a single leg on the elevation profile and in the segment chooser.
studio.itinerary.group.deleteeditor{ groupId, itineraryId }Dissolve a segment group.
studio.itinerary.group.modal.closeeditorClose the segment-group form without saving.
studio.itinerary.group.modal.openeditor{ groupId, itineraryId, seedSegmentIds }Open the segment-group form, on an existing group or seeded with a run to group.
studio.itinerary.group.setRangeeditor{ groupId, itineraryId, segmentIds }Replace which segments a group covers.
studio.itinerary.group.updateeditor{ groupId, itineraryId, color?, name?, speed? }Change a segment group's name, colour, or speed: at least one of the three is given.
studio.itinerary.segment.createeditor{ itineraryId, mode, name, color? }`Append a segment to an itinerary: 'directions' routes through ${VIA_RANGE} [lng, lat] vias (the backend computes the route), 'linestring' stores a freehand drawn line.
studio.itinerary.segment.editBegineditor{ color, mode, segmentId, activitySlug?, insertAnchor?, name?, pinnedEnd?, pinnedStart?, seedVias? }Begin editing a segment's geometry: opens the edit session in the segment color.
studio.itinerary.segment.editCanceleditorCancel the segment edit open when the cancel runs: discard its draft, restore the segment's saved geometry on the map, and unlock the base map.
studio.itinerary.segment.editCommiteditor{ mode, color?, itineraryId?, name?, segmentId? }Commit the active segment edit: persist the current draft (update the segment, or create it when editing a new one), then close the edit and unlock the base map.
studio.itinerary.segment.editProposeeditor{ segmentId, vias }`Propose a reshaped geometry for an existing directions-mode segment by its new [lng, lat] vias (${VIA_RANGE}; use the fewest that pin the intended route), then hand a live, draggable edit session to the user to adjust and save.
studio.itinerary.segment.editRedoeditorRedo the last undone change to the active segment edit's geometry.
studio.itinerary.segment.editUndoeditorUndo the last change to the active segment edit's geometry.
studio.itinerary.segment.inserteditor{ afterSegmentId, itineraryId, mode, name, vias }`Insert a segment into the middle of an itinerary's chain, after the named segment (or at the head when it is null), and renumber the chain. 'directions' routes through ${VIA_RANGE} [lng, lat] vias; 'linestring' stores a freehand drawn line and is available to the user only.
studio.itinerary.segment.insertBegineditor{ afterSegmentId, itineraryId, mode, activitySlug? }Begin drawing a segment that will be inserted after the named segment (or at the head when it is null).
studio.itinerary.segment.mergeeditorYes{ itineraryId, segmentId }`Merge a segment with the one that follows it in the chain, leaving a single segment that keeps the first one's identity and name.
studio.itinerary.segment.recoloreditor{ color, itineraryId, segmentId }Change a segment's display color, persisting the new hex color.
studio.itinerary.segment.roadAccessCloseembeddingClose the dialog telling about a restricted stretch of a segment's route.
studio.itinerary.segment.roadAccessOpenembedding{ itineraryId, kind, segmentId }Open the dialog telling about a restricted stretch of a segment's route: who the way it goes through is open to, by the kind of restriction the map draws it with.
studio.itinerary.segment.setModeeditorYes{ itineraryId, mode, segmentId }Change which engine defines a segment's geometry: 'directions' re-routes it along trails and paths, 'linestring' keeps the current line as a freehand track.
studio.itinerary.segment.setSpeededitor{ itineraryId, segmentId, speed }Set a segment's travel speed (km/h, or null to use the activity default).
studio.itinerary.segment.spliteditorYes{ fraction, itineraryId, segmentId }Split a segment into two at a fraction of its length (strictly between 0 and 1: 0.5 cuts it in half).
studio.itinerary.segment.splitPickBegineditor{ itineraryId, segmentId }Arm the map to pick the point a segment is split at.
studio.itinerary.segment.splitPickCanceleditorCancel the armed split-point pick without splitting anything.
studio.itinerary.segment.splitPickSeteditor{ lngLat }Resolve a picked map coordinate into a segment split: projects the point onto the armed segment's line and splits it at the resulting fraction.
studio.itinerary.segment.updateGeometryeditor{ itineraryId, mode, segmentId }`Replace a segment's geometry: 'directions' re-routes through ${VIA_RANGE} vias, 'linestring' stores a new freehand line.
studio.itinerary.segment.via.promptCloseeditorDismiss the segment handle prompt, leaving the geometry unchanged.
studio.itinerary.segment.via.promptOpeneditor{ index, lngLat }Open the prompt asking whether a clicked handle of the segment being edited should be removed or routed through again.
studio.itinerary.segment.via.removeeditor{ index }Remove the prompted point from the segment being edited.
studio.itinerary.segment.via.repeateditor{ index }Extend the segment being edited so it passes through the prompted point again (the loop-closing path).
studio.itinerary.waypoint.createeditor{ color, icon, itineraryId, lngLat, mode, name }`Create a waypoint at a coordinate in one shot (no authoring session): persist a point or poi waypoint with the given position, icon, color, and name.
studio.itinerary.waypoint.detailsCloseembeddingClose the waypoint details dialog.
studio.itinerary.waypoint.detailsOpenembedding{ waypointId }Open the details dialog on one waypoint, showing what the waypoint declares about itself (its services, timing, contact, media and custom fields) as a form for an editor and as a read-only card for a viewer.
studio.itinerary.waypoint.editBegineditor{ initialColor, initialIcon, initialLngLat, initialName, intent, mode, waypointId }Begin authoring a waypoint: opens the edit session in the chosen mode (point drop or POI pick) with the supplied initial icon/color/name.
studio.itinerary.waypoint.editCanceleditorCancel the waypoint authoring session open when the cancel runs: discard its draft, which never reached the saved waypoint, tear the engine down, and restore the pre-session POI view (enrichment set and group visibility).
studio.itinerary.waypoint.editCommiteditor{ waypointId, itineraryId? }Commit the active waypoint authoring session: persist the draft (create or update) and tear the session down.
studio.itinerary.waypoint.editProposeeditor{ lngLat, waypointId }Propose a new position for an existing waypoint by its new [lng, lat] (longitude first, WGS84 degrees): opens a live, draggable edit session for the user to adjust and Save.
studio.itinerary.waypoint.editRedoeditorRedo the last undone change to the active waypoint draft.
studio.itinerary.waypoint.editSetColoreditor{ color, waypointId }Set the color on the active waypoint draft; re-styles the rendered draft live.
studio.itinerary.waypoint.editSetIconeditor{ icon, waypointId }Set the icon on the active waypoint draft; re-styles the rendered draft live.
studio.itinerary.waypoint.editSetNameeditor{ name, waypointId }Set the display name on the active waypoint draft.
studio.itinerary.waypoint.editSetPositioneditor{ lngLat, poiSeed, waypointId }Set the position on the active waypoint draft from an engine placement.
studio.itinerary.waypoint.editUndoeditorUndo the last change to the active waypoint draft.
studio.itinerary.waypoint.recoloreditor{ color, itineraryId, waypointId }Recolor a saved waypoint to a hex color like #4c6ef5.
studio.itinerary.waypoint.setDetailseditor{ itineraryId, waypointId, amenities?, contact?, description?, media?, properties?, timing? }Set what a waypoint says about the place it marks: its services, its cut-off and expected arrivals, how to reach it, its photos and links, and the author's own fields.
studio.itinerary.waypoint.setIconeditor{ icon, itineraryId, waypointId }Change a saved waypoint's icon (one of the pickable waypoint icons).

map

VerbCapabilityConfirmsInputSummary
studio.map.getViewauthenticatedGet the live map view: center [lng, lat], zoom, and bearing in degrees.
studio.map.applyCameraembedding{ bearing?, center?, pitch?, zoom? }Apply a default view to the map: center ([lng,lat]), zoom, bearing (0=north, clockwise; a bearing west of north may be given as a negative number, as studio.map.getView reports it), and/or pitch.
studio.map.fitBoundsembedding{ bounds, animate?, maxZoom?, padding? }Fit the map viewport to a [west, south, east, north] bounding box.
studio.map.fitBoundsOrFlyembedding{ bounds?, point?, zoom? }Move the camera to frame a result: when bounds is given, fit the [west, south, east, north] box; otherwise fly to the [lng, lat] point at zoom (default ${POINT_ZOOM}).
studio.map.fitBoundsToSegmentembedding{ segmentId, animate?, maxZoom?, padding? }Zoom and pan the map to fit an itinerary segment (null fits the whole itinerary).
studio.map.locateembeddingCenter the map on the device's current location, or open the prompt that asks the reader to share it when asking would prompt.
studio.map.resetNorthembeddingReset the map orientation to north (clears bearing and pitch).
studio.map.zoomInembeddingZoom the map in by one step.
studio.map.zoomOutembeddingZoom the map out by one step.

overlay

VerbCapabilityConfirmsInputSummary
studio.overlay.getActiveauthenticatedGet the currently active overlay, the stacked enrichment overlays, the base terrain, and the shared overlay timestamp.
studio.overlay.listAvailableauthenticatedList every available map overlay with its classification: kind (vector = sampleable feature properties; dem-surface = sample via the terrain tools; raster-visual = display only), whether it is timestamp-aware, and its zoom range.
studio.overlay.timestamp.setembedding{ timestamp }Set the instant the time-aware overlays read at: the forecast tiles and the hillshade sun angle.
studio.overlay.category.setembedding{ slug }Set the active overlay category shown in the layers panel (null clears the explicit choice, so the panel falls back to the category owning the active overlay).
studio.overlay.enrichment.setembedding{ enabled, overlay }Toggle an enrichment overlay (e.g. hillshade or pois) on or off by its slug.
studio.overlay.sampleAlongSegmentauthenticated{ overlay, segmentId, samples?, timestamp? }Enable a vector overlay, frame an itinerary segment, wait for the tiles to render, then sample the overlay's feature properties at evenly-spaced points along the segment.
studio.overlay.sampleAtauthenticated{ lngLat, overlay, timestamp? }Read a vector overlay's feature properties at a single [lng, lat].
studio.overlay.setembedding{ overlay }Activate a map overlay by slug, or clear the active overlay (null).
studio.overlay.pois.display.setauthenticated{ enabled }Show or hide every POI group on the map at once.
studio.overlay.pois.group.setauthenticated{ enabled, group }Show or hide a single POI group on the map (water, toilets, parking, health, lodging, food, or viewpoints).

panel

VerbCapabilityConfirmsInputSummary
studio.panel.closeembeddingClose whichever floating studio panel (layers or preferences) is open.
studio.panel.toggleembedding{ panel }Toggle a floating studio panel (layers or preferences); opening one replaces whichever panel was open.

preferences

VerbCapabilityConfirmsInputSummary
studio.preferences.setembedding{ language?, length?, pace?, slope?, temperature? }Update the viewer's display preferences (length, pace, slope, temperature units, language).

question

VerbCapabilityConfirmsInputSummary
studio.question.askauthenticated{ options, question }Ask the user to pick between 2-4 options, shown as buttons in the chat.
VerbCapabilityConfirmsInputSummary
studio.search.clearHighlightauthenticatedClear the transient search-result overlay from the map.
studio.search.highlightauthenticated{ kind }Paint a transient search-result overlay on the map: a place pin, a POI category icon, or a way polyline / dashed bounds rectangle.
studio.search.query.setauthenticated{ query }Set the search box value; the search effect re-runs against it.
studio.search.runauthenticated{ query, target, bbox?, focus?, language?, limit? }Run the unified search for a single target (places, pois, ways, itineraries, zones, or collections) and return that target's section.
studio.search.selectResultauthenticated{ kind }Activate a search result: move the camera, paint the highlight, and open the matching editor surface for an itinerary, collection, or zone.
studio.search.viewportScope.setauthenticated{ scoped }Set the search viewport-scope flag (true = restrict to viewport, false = unscoped).

segment

VerbCapabilityConfirmsInputSummary
studio.segment.lengthauthenticated{ segmentId }Measure the length in meters of an itinerary segment's line, read from its stored geometry.
studio.segment.pointAtFractionauthenticated{ fraction, segmentId }Return the [lng, lat] at a fraction (0–1) along an itinerary segment's length, measured along the path (e.g. 0.33 for the first third).

selection

VerbCapabilityConfirmsInputSummary
studio.selection.getauthenticatedGet the current studio selection: the focused segment or waypoint, by id and kind.

share

VerbCapabilityConfirmsInputSummary
studio.share.closeauthenticatedClose the share-link modal.
studio.share.openauthenticated{ id, kind }Open the share-link modal for an itinerary or a collection (kind and id), to see its read-only link anyone can open, create one where none is set, and copy it.
VerbCapabilityConfirmsInputSummary
studio.shareLink.disableeditorYes{ id, kind }Disable the share link for an itinerary or a collection.
studio.shareLink.minteditor{ id, kind }Get or create the read-only share link for an itinerary or a collection and return its token.
studio.shareLink.rotateeditorYes{ id, kind }Reset the share link for an itinerary or a collection, retiring the current token and returning a fresh one.

sidenav

VerbCapabilityConfirmsInputSummary
studio.sidenav.backauthenticatedGo back from what the studio sidenav shows: close the zone, create, import or suggest surface and show what was behind it, or leave the open itinerary for the list.

state

VerbCapabilityConfirmsInputSummary
studio.state.getauthenticatedGet the current studio state: the active itinerary (segments + waypoints), the selection, any open edit session and its current draft, the enabled overlays, the map camera (center, zoom and bearing), the unit/locale preferences, and the available-overlay catalog.

streetview

VerbCapabilityConfirmsInputSummary
studio.streetview.closeembeddingClose the Street View panorama.
studio.streetview.corridor.setembedding{ lines, radiusMeters }Draw or clear the Street View droppable-corridor band on the map.
studio.streetview.coverage.setembedding{ visible }Show or hide the Street View coverage overlay on the map.
studio.streetview.moveembedding{ lat, lng }Update the Street View open position as the walker steps forward.
studio.streetview.openembedding{ lat, lng }Open the Street View panorama at a [lng, lat] coordinate.

tabs

VerbCapabilityConfirmsInputSummary
studio.tabs.closeauthenticated{ tabId }Close a co-pilot tab.
studio.tabs.createauthenticated{ kind }Open a new co-pilot tab and activate it.
studio.tabs.openauthenticated{ kind }Reveal and focus the co-pilot, opening it if it is not yet open.
studio.tabs.switchauthenticated{ tabId }Switch the studio's active tab (Search or a co-pilot conversation) by id.

terrain

VerbCapabilityConfirmsInputSummary
studio.terrain.sampleAlongSegmentauthenticated{ segmentId, samples? }Sample the surface (elevation, slope, aspect, and steepness band) at evenly-spaced points along an itinerary segment from the terrain DEM.
studio.terrain.sampleAreaauthenticated{ bbox, cols?, rows? }Sample the surface (elevation in m, slope in degrees, aspect 0–360° downhill, and the steepness band) over a [west, south, east, north] bbox on a cols × rows grid of evenly-spaced points from the terrain DEM.
studio.terrain.sampleAtauthenticated{ lngLat }Sample the surface at a single [lng, lat] from the terrain DEM: elevation (m), slope (degrees), aspect (0–360° compass bearing, downhill), and the steepness band (25-30..45+, derived from slope; absent below 25°).
studio.terrain.setembedding{ terrain, variant? }Switch the studio base layer to a terrain by slug (e.g. topo, satellite), optionally setting its light/dark tint.

video

VerbCapabilityConfirmsInputSummary
studio.video.cancelauthenticatedCancel the video recording in progress, or stop the live video preview flight in progress.
studio.video.closeauthenticatedClose the export-as-video wizard, stopping any preview or recording in progress.
studio.video.downloadauthenticatedDownload the recorded video file.
studio.video.duration.setauthenticated{ targetDurationMs }Set the total length of the video flight in milliseconds.
studio.video.mode.setauthenticated{ mode }Set the video camera mode: a Smart/Cinematic/Drone/Helicopter/Chase/Overview preset regenerates the plan; Director seeds an empty plan for an explicit shot sequence.
studio.video.openauthenticated{ itineraryId, segmentId? }Open the export-as-video wizard for an itinerary (optionally limited to a single segment), seeded with the Smart camera preset.
studio.video.orbitauthenticated{ at, pitchDeg, zoom, clockwise?, dwellMs?, turns? }Add an orbit to the video plan: hold at a point and sweep the heading around it.
studio.video.output.setauthenticated{ aspect?, bitrateMbps?, format?, fps?, preset?, quality?, resolution? }Reconfigure the video encoder output (format, resolution, fps, aspect, or bitrate).
studio.video.plan.getauthenticatedRead the current camera plan of the open video export wizard.
studio.video.preset.setauthenticated{ preset }Apply a ready-made video preset (Vertical 9:16, Widescreen 16:9, or Square 1:1) to the encoder output.
studio.video.preview.pauseauthenticatedPause the live video preview flight.
studio.video.preview.playauthenticatedResume the paused video preview flight, fly on from the frame a seek parked the camera on, or fly from the first frame when there is neither.
studio.video.preview.seekauthenticated{ fraction }Seek the video preview to a progress fraction (0..1) along the flight: the camera is parked on that frame and the wizard's status reads parked at the fraction, with nothing flying.
studio.video.preview.startauthenticatedStart a live preview flight of the current video plan on the wizard map.
studio.video.preview.stopauthenticatedStop the live video preview flight and reset it.
studio.video.profile.design.setauthenticated{ design }Set the live profile overlay design: the full elevation graph, a compact stats strip, or a minimal distance chip.
studio.video.profile.language.setauthenticated{ language }Set the video-scoped language the profile overlay localizes its labels in.
studio.video.profile.toggleauthenticated{ enabled }Toggle the live profile-details overlay on the video preview and recording.
studio.video.profile.units.setauthenticated{ length, pace, slope }Set the video-scoped units the profile overlay formats with: the length system, the travel-rate form (a speed or its reciprocal) and the slope unit.
studio.video.recordauthenticatedRecord and encode the current video plan into a downloadable video file.
studio.video.route.setauthenticated{ route, activityGlyphUrl?, profileSource? }Set the route geometry the video camera plan is resolved against, regenerating a preset plan from it.
studio.video.shot.addauthenticated{ zoom, at, pitchDeg, bearingMode?, bearingDeg?, holdMs?, speedScale? }Add a camera keyframe to the video plan at a progress fraction along the route.
studio.video.shot.addHoldauthenticated{ at, holdMs, pitchDeg, zoom }Add a hold beat to the video plan: pause the camera at a point for a dwell.
studio.video.shot.removeauthenticated{ id }Remove a camera keyframe from the video plan by id.
studio.video.shot.setauthenticated{ id, zoom?, at?, bearingMode?, bearingDeg?, holdMs?, pitchDeg?, speedScale? }Edit an existing camera keyframe in the video plan by id.
studio.video.step.setauthenticated{ step }Switch the video export wizard to the Format, Camera, Overlay (profile), or Review step.

zone

VerbCapabilityConfirmsInputSummary
studio.zone.beginOriginPickeditorArm the map so the next click sets the reachability origin.
studio.zone.cancelOriginPickeditorDisarm the reachability origin pick without placing a point.
studio.zone.createeditor{ level, mode, name, collectionIds?, description?, endAt?, geojson?, isPrivate?, organizationId?, source?, startAt? }Create a zone from its name (2 to 30 characters, unique within the organization: a taken name fails with conflict), mode and level, an optional description (at most 100 characters), plus EITHER a drawn GeoJSON Feature (a hand-drawn zone) OR a reachability source: an isochrones query { kind: 'isochrones', activity, location: [lng, lat], range_type: 'time' | 'distance', range, speed? } the backend computes the polygon from (a computed zone).
studio.zone.createBegineditor{ method, origin? }Open the zone surface on a create, seeded with the authoring method ('draw' or 'reachability') and, for a reachability zone, the [lng, lat] origin to measure from.
studio.zone.deleteeditorYes{ zoneId }Permanently delete a zone by id.
studio.zone.editBegineditor{ intent, level, mode, zoneId, organizationId?, seedGeometry? }Begin editing a zone's geometry: opens the edit session in the zone's mode and level color.
studio.zone.editCanceleditorCancel the active zone edit: discard the draft, restore the zone's saved geometry on the map, and unlock the base map.
studio.zone.editCommiteditor{ intent, name?, zoneId, description?, endAt?, startAt? }Commit the active zone edit: persist the drawn draft and its metadata (create a new zone, or update a saved zone's geometry, name, description, severity, and time window).
studio.zone.editProposeeditor{ geometry, level, zoneId, name?, organizationId?, source? }Propose a zone for the user to confirm: either pass a ready GeoJSON Feature ({kind:'feature'}: an isochrone Polygon from the data API, a drawn polygon area, or a DEM-thresholded band) OR a parametric spec ({kind:'circle'|'sector'|'sensor'} with a [lng, lat] center, radius in METERS, and bearings in compass DEGREES) which the tool builds into a Polygon.
studio.zone.editRedoeditorRedo the last undone change to the active zone edit: its shape, and the name, severity and organization a proposal set with it.
studio.zone.editUndoeditorUndo the last change to the active zone edit: its shape, and the name, severity and organization a proposal set with it.
studio.zone.openauthenticatedOpen the zone surface in the sidenav, on a fresh hand-drawn create.
studio.zone.openForEditeditor{ zoneId, bounds?, point? }Load a saved zone into the editor: fetch its canonical geometry, open the zone panel and frame its bounds.
studio.zone.openForViewauthenticated{ zoneId, bounds?, point? }Open a saved zone in read-only view: fetch its canonical geometry, bind the zone panel to it, and frame its bounds, without arming an edit session.
studio.zone.publisheditor{ zoneId }Publish the zone, freezing its current shape and details into the version the public surfaces serve: the collection embeds and share links that hold it.
studio.zone.reachabilityPreviewauthenticated{ activity, level, location, ranges, rangeType, speed? }Preview reachability bands for a computed zone on the map: compute the isochrones for an origin, activity, travel budget and optional speed, and paint them without persisting.
studio.zone.recomputeeditor{ zoneId? }Refresh a computed zone's geometry by re-running the reachability query it stores, unchanged: for when the world it measures may have moved, not to change the query itself.
studio.zone.setCreateMethodeditor{ method }Switch the zone create between drawing by hand and computing reachability.
studio.zone.setLeveleditor{ level }Set the severity level on the active zone edit, recoloring the live draft.
studio.zone.setOrigineditor{ lngLat }Set the [lng, lat] origin a reachability zone is measured from.
studio.zone.unpublisheditorYes{ zoneId }Withdraw the zone's publication, so the public surfaces stop serving it.
studio.zone.updateeditor{ zoneId, description?, endAt?, isPrivate?, level?, name?, startAt?, geojson?, source? }Update a zone's METADATA: its name (2 to 30 characters, unique within the organization: a taken name fails with conflict), description (at most 100 characters; null clears it), severity level, start/end time window (startAt, endAt: RFC 3339 timestamps such as 2026-03-07T08:00:00Z; null clears a bound) and visibility (isPrivate), which takes effect at once, published or not.