Wabcut
Wabcut Developer

API Collection

Edit commands

Every edit in Wabcut is a typed, validated, undoable command: 285 of them, shared by the command palette, the AI assistant, wabcut-cli, MCP clients and extensions.


Overview

The typed command protocol (src/command, library wabcut_command) is the one way agents, the CLI, scripts and MCP clients edit a project. Commands are thin, validated adapters over the model's edit:: operations: the model decides what an edit does, the protocol names it, checks it and reports what changed.

Requests#

{"command": "timeline.rippleDelete", "version": 1, "params": {"clips": [42]},
 "expectedRevision": 7, "idempotencyKey": "agent-run-3/step-12", "dryRun": false}
  • command: a name below, one of its aliases, or its LLM tool name (. written as _).
  • version: optional; the newest version when left out.
  • expectedRevision: optional; the request fails with StaleRevision unless the session is at that revision. Every result reports the current revision.
  • idempotencyKey: optional; a successful request is remembered per session, and a replay with the same key returns the first result ("replayed": true) instead of editing again. Reusing a key for a different request fails with IdempotencyConflict.
  • dryRun: validate and compute the result and its ChangeSet without committing. In process the result carries the would-be state as a preview snapshot. Nothing outside the project changes either: what a command does to the host (the clipboard, a version saved to disk) happens only once a request commits, never for a dry run or a batch that fails.

A batch applies several commands in order as one undo step, all or nothing:

{"commands": [{"command": "sequence.addEdit", "params": {"time": "00:00:05:00"}},
              {"command": "clip.setParam", "params": {"clips": [{"track": "V1", "time": "00:00:06:00"}],
                                                 "param": "opacity.opacity", "value": 0.5}}],
 "label": "Dim the second half", "expectedRevision": 7, "dryRun": true}

expectedRevision, idempotencyKey and dryRun belong to the batch, not to its commands. Each command sees the state the previous ones produced; read commands inside a batch report in steps.

References#

  • Times are integer ticks (254016000000 per second) or timecode strings in the sequence's rate ("00:01:02:03", ; before the frames for drop-frame). Deltas may be negative ("-00:00:00:05").
  • Tracks are labels ("V1" is the bottom video track, "A1" the first audio track) or track ids.
  • Clips are clip ids or {"track": "V1", "time": "00:00:03:00"} for the clip under that time.
  • Media is a media id or the media item's exact name.
  • Sequence: every sequence command takes an optional sequence id; it may be left out when the project has exactly one sequence.

Results#

{"ok": true, "revision": 8, "changes": {"sequences": [{"sequence": 2, "tracks": [...], "addedClips": [], "removedClips": [42], ...}]},
 "dryRun": false, "committed": true}

changes (the model's ChangeSet: per sequence the touched tracks and time ranges, added, removed and modified clips, property roles and other changed parts), createdIds, warnings, data (a read command's answer) and steps (per command of a batch) are left out when empty.

Failures change nothing and carry {"ok": false, "error": {"code", "message", "details"}}. Codes: UnknownCommand, UnsupportedVersion, InvalidRequest, InvalidParams (details.issues lists JSON-pointer paths), NotFound, PermissionDenied, StaleRevision, IdempotencyConflict, EditRejected (the model refused the edit), InvariantViolation, LockedTrack, Cancelled, TimedOut (the caller stopped a long request; see ExecutionControl), Internal. In a batch, details.index names the failing command.

Every request is checked in release builds too: params against the schema, references against the project, the result against the model invariants (validate()), and locked tracks must come out unchanged.

Capabilities scope what a client may run: Read, EditSequence, EditProject, MediaAnalysis, Network (the last two have no commands yet).

Command-line and LLM tools#

wabcut-cli cmd <project.wabcut> --json '<request or batch>' [--dry-run] [--save]
wabcut-cli tools --format anthropic|openai|jsonschema
wabcut-cli mcp --project <file.wabcut> [--allow-edit] [--allow-analysis] [--save-on-exit | --autosave]

mcp serves the catalog to MCP clients such as Claude Desktop, Claude Code and Codex; see docs/mcp.md.

tools prints the catalog as Anthropic Messages API tools, OpenAI Chat Completions tools or plain JSON Schema definitions. Each CLI run is a fresh session (revision 0).

Transcript commands (transcript.*, captions.generate; library wabcut_ai_edit, see docs/ai.md) edit the video by editing what it says. They need the transcripts of the project's media, which the host provides (EnginePolicy::services): wabcut-cli reads them from the analysis cache that transcription fills, and without them the commands fail with InvalidRequest. Their word indices refer to transcript.text / transcript.words at the request's revision, so pass expectedRevision. wabcut-cli transcript-edit and wabcut-cli captions wrap them for scripts.

Media-analysis commands (analysis.*, clip.splitAtShots; library wabcut_ai_analysis, see docs/ai.md) detect shots and beats in the project's media (cached per source file); the host provides the analysis (AnalysisServices), else they fail with InvalidRequest. analysis.detectBeats sets the sequence beat grid that edit.snapToBeats, edit.cutToBeats and timeline snapping use; sequence.setBeatGrid sets it by hand or from taps.

Topics

clip.*

  • clip.addEffect

    Apply Effect. Adds an effect to the stack of each clip (video effects on video clips, audio effects on audio clips).

  • clip.addKeyframe

    Add Keyframe. Adds a keyframe at a timeline time inside the clip (or replaces the one there).

  • clip.details

    Clip Details. Everything about one clip: track, timeline and source range (ticks and timecode), media, stream, speed, enabled, label colour, linked clips and all parameter values.

  • clip.enable

    Enable. Enables or disables clips (Premiere Shift+E).

  • clip.fade

    Fade. Fades clips in and/or out with keyframes: opacity on video clips (to 0), level on audio clips (to -144 dB).

  • clip.find

    Find Clips. Finds clips by name (case-insensitive substring), by a time they cover, by track and by media.

  • clip.frameHold

    Frame Hold. Holds the frame at a time.

  • clip.insert

    Insert. Insert edit (Premiere ','): puts a media source range onto the patched tracks at a time and pushes later material on those tracks and every sync-locked track later, cutting through clips there.

  • clip.instantReplay

    Instant Replay. Replays a moment right after itself in slow motion, Premiere-style instant replay in one step: the moment's clips are copied and inserted right after it (everything later moves, sync-locked tracks stay in sync) with a speed ramp (100 % easing into "speed" and back), the REPLAY stinger template over the replay and a white flash at each cut.

  • clip.link

    Link. Links clips so they select and edit together.

  • clip.move

    Move. Moves clips in time and across tracks.

  • clip.moveEffect

    Reorder Effect. Moves an effect to another position in the clip's stack.

  • clip.moveKeyframe

    Move Keyframe. Moves a keyframe to another timeline time inside the clip.

  • clip.openNested

    Open Nested Sequence. The sequence a nested or multicam clip plays (open it to edit inside), the range of it the clip shows and, for a multicam clip, its active angles.

  • clip.overwrite

    Overwrite. Overwrite edit (Premiere '.'): puts a media source range onto the patched tracks at a time, replacing whatever is there.

  • clip.pasteAttributes

    Paste Attributes. Premiere's Paste Attributes (Ctrl+Alt+V): the chosen attributes of the clipboard's clip (the first one of each target's kind: video attributes from the copied video clip, audio ones from the audio clip) or of "source" onto "clips".

  • clip.removeAttributes

    Remove Attributes. Premiere's Remove Attributes: the chosen parameters go back to their defaults (keyframes too), time remapping is turned off (the clip plays at 100 % from the frame it started on), effects are removed by id (or all).

  • clip.removeEffect

    Remove Effect. Removes an effect instance from a clip's stack.

  • clip.removeKeyframe

    Remove Keyframe. Removes a keyframe; removing the last one leaves the parameter constant at its value.

  • clip.rename

    Rename Clip. Renames clips (the name shown on the timeline; the media keeps its name).

  • clip.rippleTrim

    Ripple Edit. Ripple edit (B): moves a clip's In or Out point and ripples later material (sync-locked tracks too).

  • clip.roll

    Rolling Edit. Rolling edit (N): moves the edit point at a clip's edge, trimming the neighbour the other way.

  • clip.setAnimated

    Toggle Animation. Premiere's stopwatch.

  • clip.setBlendMode

    Set Blend Mode. Sets the blend mode of video clips (the Opacity section's Blend Mode, Premiere's list): how each clip combines with what is below it.

  • clip.setColor

    Set Label Color. Sets the label colour of clips (0-15).

  • clip.setEffect

    Set Effect. Turns an effect on or off or sets its parameters (constants; animate them with clip.addKeyframe and "effect").

  • clip.setKeyframe

    Set Keyframe. Changes a keyframe's value, interpolation (hold, linear, bezier, easeIn, easeOut, easeInOut) or Bezier handles (slope in units per second, influence 0..1 of the segment).

  • clip.setParam

    Set Clip Parameter. Sets one effect parameter (motion, opacity, volume, pan) on clips.

  • clip.shake

    Camera Shake. A camera shake on a video clip from "at": Motion Position (and Rotation) keys of a seeded random pattern that decays over "seconds", plus a slight zoom so the clip's edges do not show ("cover").

  • clip.slide

    Slide. Slide (U): moves a clip between its neighbours, trimming them to compensate.

  • clip.slip

    Slip. Slip (Y): shifts which source frames clips show, keeping their place and length.

  • clip.speedDuration

    Speed/Duration. Ctrl+R: plays each clip's material at a new speed (percent; 200 = twice as fast) or fits it into a new duration; can reverse it and keep audio pitch.

  • clip.splitAtShots

    Split at Shots. Razors each clip at the cuts in its video (scene-edit detection), with its linked partners.

  • clip.trim

    Trim. Trim an edge (selection tool): moves a clip's In or Out point without moving anything else.

  • clip.unlink

    Unlink. Takes clips out of their link groups.

  • clip.zoomPunch

    Zoom Punch. A punch-in zoom on a moment of a video clip: Motion Scale keys ease in to "scale" times the clip's scale, hitting at "at", hold, and ease back out ("attack" and "release" are shares of "seconds").

sequence.*

  • sequence.addEdit

    Add Edit. Add edit / razor (Premiere Ctrl+K): cuts the clips under a time on the given tracks (default: the targeted tracks).

  • sequence.addEditToAllTracks

    Add Edit to All Tracks. Add edit to all tracks (Premiere Ctrl+Shift+K): cuts every unlocked track at a time.

  • sequence.addTrack

    Add Track. Adds a video track above the top video track or an audio track below the last audio track.

  • sequence.applyAudioTransition

    Apply Audio Transition. Ctrl+Shift+D: a constant-power crossfade on the edit point nearest the playhead on each targeted audio track.

  • sequence.applyDefaultTransitions

    Apply Default Transitions to Selection. Shift+D: default transitions on both ends of each clip (cross dissolve on video, constant power on audio), on the cut where a neighbour meets the clip, otherwise a fade inside it.

  • sequence.applyVideoTransition

    Apply Video Transition. Ctrl+D: a cross dissolve on the edit point nearest the playhead on each targeted video track, shortened to the media there is.

  • sequence.beats

    List Beats. The beats of the sequence's beat grid as arrays in beatFields order: time, place in the bar (1 = downbeat) and index from the grid's downbeat.

  • sequence.create

    New Sequence. Makes a new, empty sequence (3 video and 3 audio tracks, 48 kHz) from a preset (sequence.presets: "1080p60", "1440p144", "2160p60", "shorts" for 1080x1920 60 fps, ...). createdIds: the sequence.

  • sequence.exportMarkers

    Export Markers. Returns the sequence's markers as text: "csv" (Premiere's columns: Marker Name, Description, In, Out, Duration, Marker Type, plus Color) or "youtube" (chapter lines for a video description, from the chapter markers, or every marker when there are none).

  • sequence.extract

    Extract. Extract (Premiere "'"): removes a time range from the targeted tracks and closes the gap; sync-locked tracks lose the same range so they stay in sync.

  • sequence.lift

    Lift. Lift (Premiere ';'): removes a time range from the targeted tracks and leaves a gap.

  • sequence.makeVersion

    Make Vertical or Square Version. Makes a 9:16 Shorts (1080x1920) or 1:1 square (1080x1080) version of a 16:9 gaming edit as a new sequence: with a facecam (a track named like a webcam - facecam, webcam, cam, camera -, a picture-in-picture made with layout.apply, "facecamTrack" or "facecamRegion") Shorts get the vertical split (gameplay on top, facecam below) and square versions the gameplay over a blurred fill with the facecam in a corner; without one, Auto Reframe when the host has it, else the gameplay fitted to the width over a blurred copy of itself.

  • sequence.matchFrame

    Match Frame. Match Frame (Premiere F): the clip under a time on the targeted tracks (the topmost; every track when none is targeted there), its media and the source frame shown.

  • sequence.nest

    Nest. Premiere's Nest: the clips (and, with "linked", their partners) move into a new sequence in the same bin, keeping their tracks, effects, links and the transitions between them, and one nested clip per kind (picture on the lowest selected video track, the mix on the lowest audio track, linked) takes their place.

  • sequence.presets

    Sequence Presets. The sequence presets sequence.create takes: landscape 1080p, 1440p and 4K at 30, 60, 120, 144 and 240 fps (and 59.94), and vertical 1080x1920 for Shorts, TikTok and Reels at 60 ("shorts") and 30 fps.

  • sequence.removeDeadTime

    Remove Dead Time. Finds low-activity stretches of gameplay - game audio and picture motion both low (loading screens, walking, waiting) for at least "minSeconds" - and removes them with handles kept, like a silence cleanup.

  • sequence.removeTrack

    Delete Track. Deletes a track and its clips (their linked partners on other tracks stay, unlinked).

  • sequence.reverseMatchFrame

    Reverse Match Frame. Reverse Match Frame (Premiere Shift+R): where a source frame is used in the sequence: the first use at or after "from", else the first one.

  • sequence.rippleTrimNextToPlayhead

    Ripple Trim Next Edit to Playhead. W: removes the time from the playhead to the next edit point on the targeted tracks and closes it.

  • sequence.rippleTrimPreviousToPlayhead

    Ripple Trim Previous Edit to Playhead. Q: removes the time from the previous edit point to the playhead on the targeted tracks and closes it.

  • sequence.setBeatGrid

    Set Beat Grid. Sets the sequence's beat grid, which timeline snapping, edit.snapToBeats and edit.cutToBeats use: a tempo and the time of a downbeat, a tempo from tapped beats (at least two times), or detected beats; "clear" removes it. analysis.detectBeats sets it from the music.

  • sequence.setMasterFormat

    Set Master Channel Format. The sequence's master: stereo, or 5.1 (mono and stereo tracks through their 5.1 panners; previewed on a stereo device and exported to stereo through an ITU-R BS.775 downmix; exports with 0 channels follow it).

  • sequence.setMasterGain

    Set Master Gain. Sets the master fader: dB, 0 = unity, applied to the sequence's mix after the master effects and before the meters (what export renders).

  • sequence.setPatches

    Set Source Patching. Checks a source patching (Premiere's source track indicators: which source track goes to which sequence track, and which are switched off) and returns it in order.

  • sequence.setTargets

    Set Track Targets. Targets exactly the given tracks (Premiere's track targeting: Lift, Extract, paste, Up/Down navigation and Match Frame use them).

  • sequence.summary

    Sequence Summary. Compact view of a sequence: settings, In/Out marks, every track (label, id, flags) with its clips as arrays in clipFields order (times are timecodes; link = link group, clips with the same value are linked), and markers.

  • sequence.unnest

    Unnest. Resolve's Decompose: a nested clip (with its linked nested partners) is replaced by copies of the clips it shows - trimmed to what it shows, on its track and the ones above (audio: below), with their effects, links and transitions.

timeline.*

  • timeline.removeSilences

    Remove Silences. Ripple-deletes a list of time ranges (e.g. silences found in a transcript) in one step.

  • timeline.rippleDelete

    Ripple Delete. Ripple delete: removes clips and closes the time they used, or closes a gap.

edit.*

  • edit.clear

    Delete. Delete (Premiere Delete key): removes clips and leaves gaps.

  • edit.cutToBeats

    Cut to Beats. Music-video assembly: places the given clips' media (from each clip's source In) and media items (from their start) one after another, each lasting beatsPerCut beats of the beat grid, starting at the first beat at or after "at" (the playhead).

  • edit.insertFromSource

    Insert from Source. Insert edit from the source (Premiere ','), with three-point editing: the source marks (stored on the media unless given), the sequence In/Out marks and the playhead decide where it goes and what it uses.

  • edit.overwriteFromSource

    Overwrite from Source. Overwrite edit from the source (Premiere '.'), with three-point editing like edit.insertFromSource: replaces what is on the patched tracks; nothing moves.

  • edit.snapToBeats

    Snap to Beats. Trims each clip's head and/or tail to the nearest beat of the beat grid when it is within the tolerance (linked partners follow).

track.*

  • track.mask

    Track Mask. Tracks a mask through the clip's media, frame by frame from "time" (forward or backward, to the clip's end or "frames" frames), with pyramidal Lucas-Kanade on features inside the mask and a robust fit of its motion ("model").

  • track.setFormat

    Set Track Channel Format. An audio track's channel format (Premiere's mono, stereo, 5.1 and adaptive tracks): clips are mixed to it (mono averages, 5.1 to stereo is ITU-R BS.775), and it to the master's format; adaptive passes channels through one to one.

  • track.setPan

    Set Track Pan. Sets an audio track's panner: -1 = left .. 0 = centre .. +1 = right, a balance on the track's stereo mix (centre leaves it unchanged; towards a side the other side follows the -3 dB constant-power curve down to silence).

  • track.setRecordArm

    Set Track Record Arm. Arms an audio track for voice-over recording or disarms it (the R button of Premiere's track headers and Audio Track Mixer).

  • track.setRole

    Set Track Role. What an audio track carries: dialogue, music or effects (Premiere's Essential Sound types), or none. audio.autoDuck lowers music-role tracks under dialogue-role tracks.

  • track.setState

    Set Track State. Changes track header toggles: lock, target, sync lock, mute, solo, output, name.

  • track.setSurroundPan

    Set Track 5.1 Panner. The 5.1 panner of a mono or stereo track on a 5.1 master (Premiere's track 5.1 panner): the puck x (-1 left .. +1 right) and y (-1 back .. +1 front; front centre plays stereo on L/R and mono on C) and the LFE send in dB (-144 = off).

  • track.setVolume

    Set Track Volume. Sets an audio track's fader (Premiere's track Volume): dB, 0 = unity, applied to the track's mix after its effects.

  • track.transform

    Track Motion. Tracks a region of a clip ("region": {x, y, width, height} 0..1 of the frame, {"mask": id}, or {"detect": "face"} once a detector is installed) and keys a clip's Motion with it (one undo step): "follow" moves "target" with the region (position; with the similarity model also scale and rotation), "stabilize" keys the tracked clip so the region stays still.

clipboard.*

  • clipboard.copy

    Copy. Copies clips (with their link partners unless "linked": false) to the clipboard exactly: speed, reverse, freeze frames, time remapping, effects and keyframes, names, labels, links, the transitions between them and the markers over them (captions on request).

  • clipboard.cut

    Cut. Copies clips to the clipboard (like clipboard.copy) and deletes them, leaving gaps (Premiere's Cut).

  • clipboard.get

    Clipboard. What the clipboard holds: clips, length, tracks, markers, captions, media; with "export" also the clipboard as JSON text.

  • clipboard.paste

    Paste. Pastes the clipboard (or a "document" from clipboard.copy's export) at "at": overwrite (Ctrl+V) replaces what lies under the pasted clips, insert (Ctrl+Shift+V) first opens the clipboard's length on the destination and sync-locked tracks.

source.*

  • source.addMarker

    Add Clip Marker. Adds a clip marker to a media item, in media time.

  • source.clearMarks

    Clear Source Marks. Clears a media item's source In and/or Out mark (Premiere's Source Monitor Clear In / Clear Out / Clear In and Out).

  • source.load

    Load Source. Opens a media item as the source (Premiere's Source Monitor): its kind, duration, frame rate, stored In/Out marks and the source patching a source edit would use.

  • source.removeMarker

    Remove Clip Marker. Removes a media item's clip marker at an index.

  • source.setMarks

    Set Source Marks. Sets a media item's source In/Out marks (Premiere's Source Monitor I and O).

  • source.updateMarker

    Edit Clip Marker. Changes a media item's clip marker at an index (keys left out keep their values).

marker.*

  • marker.add

    Add Marker. Adds a sequence marker.

  • marker.clearAll

    Clear All Markers. Removes every marker of the sequence (Premiere's Clear All Markers).

  • marker.clearInAndOut

    Clear In and Out. Clears the sequence In and Out marks.

  • marker.list

    List Markers. The sequence's markers in time order with all their fields: index (what marker.update and marker.remove take), start, duration, name, comment, colour, type, web link, and the highlight a highlight finder wrote (score, confidence, reasons, peak, source; null when none).

  • marker.markIn

    Mark In. Sets the sequence In mark at the start of the frame at a time.

  • marker.markOut

    Mark Out. Sets the sequence Out mark at the end of the frame at a time (the frame is included).

  • marker.remove

    Remove Marker. Removes the sequence marker at an index (as listed by sequence.summary).

  • marker.update

    Edit Marker. Changes the sequence marker at an index (as listed by sequence.summary): any of its time, duration, name, comment, colour, type, URL and frame target.

keyframes.*

  • keyframes.move

    Move Keyframes. Moves several keyframes of one parameter together by a timeline distance, keeping their spacing.

  • keyframes.setInterpolation

    Set Keyframe Interpolation. Sets the interpolation (hold, linear, bezier, easeIn, easeOut, easeInOut) of several keyframes of one parameter at once.

timeRemap.*

  • timeRemap.addHold

    Add Hold Segment. Holds the frame shown at a timeline time for a duration inside a remapped clip; the rest of its remap plays later.

  • timeRemap.addKey

    Add Time Remap Key. Adds a remap key at the sampled source position of a timeline time inside a remapped clip.

  • timeRemap.addReverse

    Add Reverse Segment. From a timeline time inside a remapped clip, plays the media backwards at 100 % for a duration, then forwards again over the same frames (a boomerang); the rest of the remap plays later by twice the duration.

  • timeRemap.enable

    Time Remapping. Turns time remapping on (speed ramps, holds and reverse inside one clip; the clip shows the same frames, also beyond its ends for transitions and trims; keyframes of a clip that was not at 100 % then animate at timeline rate) or off (back to a constant speed: the one it shows if a single straight segment covers it, else 100 % from its first frame).

  • timeRemap.moveKey

    Move Time Remap Key. Moves a remap key to another timeline time.

  • timeRemap.removeKey

    Remove Time Remap Key. Removes a remap key (not the only one).

  • timeRemap.setInterpolation

    Set Time Remap Interpolation. Shapes the remap around keys: linear (constant speed between keys), hold (the frame holds until the next key, then jumps), or easeIn / easeOut / easeInOut / bezier for a smooth speed ramp.

  • timeRemap.setKey

    Set Time Remap Key. Changes a remap key's source position, interpolation and Bezier handles together.

  • timeRemap.setSpeed

    Set Segment Speed. Sets the speed of one segment of a remapped clip (between two keys; the one playing at "time", or "segment" by index): its end key and the keys after it move, so later material plays earlier or later.

transition.*

  • transition.add

    Add Transition. Adds a transition at a clip's head or tail: on the cut when the neighbouring clip meets that edge, otherwise inside the clip (a fade from/to black).

  • transition.remove

    Remove Transition. Deletes a transition; the edit point becomes a cut.

  • transition.set

    Set Transition. Changes a transition: its effect, parameters, its length on either side of the cut ("before", "after"), a new total "duration" placed by its alignment, or the alignment itself (which re-splits it; "custom" with "offset" puts the cut that far in).

multicam.*

  • multicam.angles

    Multicam Angles. A multicam source's angles: their names, tracks and sync offsets, and how they were synced.

  • multicam.autoSwitch

    Auto Switch Multicam. Cuts a multicam clip to whoever is speaking, on this computer: the active speaker's close-up after a minimum hold, cut a little before they start, the wide shot for crosstalk, laughter, long pauses and for variety on long monologues, optional reaction shots, never in the middle of a word.

  • multicam.create

    Create Multi-Camera Source Sequence. Premiere's Create Multi-Camera Source Sequence: a new sequence with one angle per media item (its video on a video track, each audio stream on an audio track) synced by "sync": their start timecodes, Source Monitor In or Out marks, first clip markers, audio waveforms (needs the host's audio analysis) or "offsets" given by hand.

  • multicam.flatten

    Flatten. Premiere's Flatten: a multicam clip (with its linked multicam partners) is replaced by the clips of the angles it plays, trimmed to what it shows (audio angles' tracks on its audio track and the ones below).

  • multicam.setSync

    Set Angle Sync. Moves one angle of a multicam source in time (its sync offset: where its material starts); every multicam clip then shows that angle shifted.

  • multicam.switchAngle

    Switch Multicam Angle. Premiere's angle switch (the 1-9 keys while playing): the multicam clip is cut at "at" and plays "angle" from there to its next cut; without "at" the whole clip switches.

project.*

  • project.merge

    Merge Projects. Three-way merge of another copy of this project ("theirs", a project file) into this one, both edited from "base" (the file they started from): edits of different sequences, tracks or clips merge; the same thing changed differently on both sides is a conflict with a stable id.

  • project.summary

    Project Summary. Lists the project's sequences (id, rate, length, track and clip counts) and media counts.

media.*

  • media.list

    List Media. Lists the project's media as arrays in mediaFields order: id, name, duration in ms, whether it has video, its number of audio streams, whether it is a still image and whether it is offline.

  • media.makeSubclip

    Make Subclip. A new media item playing "in".."out" (exclusive) of a media item's file, named "name", in "bin" (default the root).

  • media.newSynthetic

    New Synthetic Item. Makes a synthetic project item (File > New): "colorMatte" (params color.r/g/b, 0..1: a background for text, a flash), "blackVideo" or "transparentVideo" (a layer of its own for effects that draw).

  • media.setAttributes

    Media Attributes. Library metadata of media items: name (new clips take it; existing clips keep theirs), label colour, comment, description and poster frame (a source time, or null to clear it).

  • media.setSubclip

    Edit Subclip. Changes a subclip's range and restriction (Premiere's Edit Subclip).

bin.*

  • bin.create

    New Bin. Adds a bin (in "parent", default the project's root).

  • bin.move

    Move to Bin. Moves bins, media items and sequences into "target" (absent: the project's root).

  • bin.remove

    Delete Bin. Deletes bins with everything in them (sub-bins, media items, sequences).

  • bin.rename

    Rename Bin. Renames a bin (the name may not be empty).

history.*

  • history.checkpoint

    Save Version. Records the project as it is now in the version history (unchanged since the last version: nothing is added).

  • history.diff

    Compare Versions. What changed from one version to another ("current" is the project as it is): per sequence the clips added, removed, moved, trimmed or retimed, effects and keyframes changed, settings, tracks, markers and captions; media and review notes.

  • history.export

    Save Version As. Writes a saved version as a project file of its own ("restore as a new project").

  • history.list

    Version History. The project's saved versions, oldest first, as arrays: id, createdAt (UTC), kind (save, auto, agent, manual, restore), label (named versions are kept), sequences, clips, the bytes the version added.

  • history.name

    Name Version. Names a saved version (an empty label unnames it).

  • history.restore

    Restore Version. Goes back to a saved version: the whole project (one undo step; the project as it was is saved as a version first), or, with "sequence", that sequence of the version as a new sequence next to the current ones (the media it plays is the project's own where the project still has it).

review.*

  • review.add

    Add Review Note. A frame-accurate comment on the sequence: at "time" (a frame) or from "start" to "end", optionally pointing at a spot or rectangle of the frame ("mark"), by "author".

  • review.exportPackage

    Export Review Package. Writes a review package folder for a client or reviewer: notes.json (the notes with timecodes) and index.html (one self-contained page with a thumbnail per note, its mark drawn on it), plus the thumbnails in frames/.

  • review.importPackage

    Import Review Package. Reads a review package's notes back (one undo step): replies and status update the matching notes (by id, else by sequence, time and text), new notes are added at their timecodes, and notes that cannot be placed or that changed on both sides are listed as conflicts and left out.

  • review.list

    Review Notes. The review notes of the sequence ("sequence"; all the project's without it), in time order, with their timecodes, mark, author, status and replies ([author, text, createdAt]).

  • review.remove

    Delete Review Note. Deletes a note and its replies.

  • review.reply

    Reply to Review Note. Adds a reply to a note's thread.

  • review.resolve

    Resolve Review Note. Marks a note resolved (or open again with "resolved": false).

  • review.toMarkers

    Review Notes to Markers. Turns the sequence's review notes ("notes", or all of them) into sequence markers: named after the note's first line, the comment holding the text, author and replies, red while open, green once resolved.

interchange.*

  • interchange.export

    Export Timeline. Writes the sequence (with the sequences it nests and its multicam sources) as a timeline file other editors read, at "path": Final Cut Pro 7 XML ("fcp7-xml": Premiere Pro, DaVinci Resolve), FCPXML ("fcpxml": Final Cut Pro, Resolve; "fcpxmlVersion" 1.10 or 1.11), OpenTimelineIO ("otio") or a CMX3600 EDL ("edl").

render.*

  • render.deletePreviewFiles

    Delete Render Files. Deletes preview files: of the sequence between "start" and "end" (In to Out with Sequence > Delete Render Files In to Out), of the whole sequence, or with "all" of every sequence in the project.

  • render.previewInOut

    Render In to Out. Renders preview files for the red and yellow segments between In and Out (or "start" / "end"; else the whole sequence), so they play in real time; segments with a valid preview are skipped.

  • render.status

    Render Bar. The render bar of a sequence (Premiere's red/yellow/green bar): segments between edit points, each "red" (must be rendered to play in real time: nested sequences, adjustment layers or effects heavier than real time), "yellow" (effects, transitions, blend modes or track mattes that may play in real time), "rendered" (a valid preview file exists) or "none" (plays as it is).

provenance.*

  • provenance.report

    Generated media provenance. Unsigned report of generated segments; no prompts or credentials.

audio.*

  • audio.addEffect

    Add Track or Master Effect. Adds an audio effect to an audio track's stack (applied to the track's mix, before its fader) or to the master bus (applied to the sequence's mix, before the master fader).

  • audio.addKeyframe

    Add Track or Master Keyframe. Adds a keyframe to a parameter of a track or master effect, or (no "effect") to the fader: "volume" or "pan" - at a timeline time (track and master curves run in timeline time).

  • audio.autoDuck

    Auto-Duck Music. Lowers music under speech: finds speech on the dialogue tracks (transcript words, or the audio level where there is no transcript) and writes volume keyframes on the music tracks' clips - down by "amount" over "attack" before each phrase, back up over "release" after "hold", bridging short pauses.

  • audio.channelLevels

    Measure Channel Levels. Peak and RMS of each source channel of audio clips (the clip's source range, at most 120 s), and the channels 30 dB or more under the loudest ("silentChannels"): which microphone is on which channel, and whether a recording has sound on one side only.

  • audio.channels

    Audio Channels. What each audio clip plays (its source channel count and channel map: the clip's, its media item's or none), each audio track's channel format and 5.1 panner, and the master's format.

  • audio.effects

    Audio Effect Stack. The effect stack of an audio track or of the master audio bus: instance ids, effect ids, enabled, parameter values (constants or keyframes in timeline ticks), and the fader after it: "volume" (dB) and, for tracks, "pan".

  • audio.enhanceSpeech

    Enhance Speech. Studio-quality dialogue (Premiere's Enhance Speech, Resolve's Voice Isolation): renders each clip's media with DeepFilterNet3 on this computer (no audio leaves it; the model downloads on first use), records the enhanced take on the media item and puts the Enhance Speech effect first in each clip's stack: the clip plays the take blended with the original by "strength" (toggle the effect to compare), before its level and redactions.

  • audio.essentialSound

    Essential Sound. Premiere's Essential Sound panel: tags clips as dialogue, music, sfx or ambience and applies a preset of that type as ordinary, editable effects at the top of each clip's stack (an Essential Sound record with the type and options, then one marked effect per setting: Gain for loudness; Dialogue Repair: Reduce Rumble (high-pass), DeHum, Reduce Noise or Enhance Speech, Noise Gate, Reduce Reverb (expander), DeEss; Clarity: EQ preset (podcastVoice, phone, radio, streamerVoice), Dynamics (compressor) and a true-peak limiter last; Creative: reverb (smallRoom, largeRoom, hall, plate, outside); Stereo Width), then matches each clip's loudness to the type's target.

  • audio.fillChannel

    Fill Channel. Premiere's Fill Left with Right and Fill Right with Left: both sides of the clips play one channel - for audio heard on one side only ("fix the left-only audio": from left).

  • audio.loudness

    Measure Loudness. EBU R128 / ITU-R BS.1770 loudness as it renders: integrated LUFS, loudness range (LU), true peak (dBTP), sample peak, loudest momentary and short-term LUFS.

  • audio.masterLimiter

    Master True-Peak Limiter. Puts a true-peak brick-wall limiter at the end of the master audio bus (or updates the one there): no true peak of the mix goes above the ceiling (default -1 dBTP, the streaming and EBU R128 maximum).

  • audio.moveEffect

    Reorder Track or Master Effect. Moves an effect to another position in a track or master stack.

  • audio.moveKeyframe

    Move Track or Master Keyframe. Moves keyframe index of a track or master effect parameter or of the fader ("volume" / "pan", no "effect") to another timeline time; fails if another key is there.

  • audio.normalize

    Normalize Loudness. Sets a gain so the loudness hits a delivery target: YouTube / Spotify -14 LUFS, podcasts and Apple Podcasts -16, broadcast EBU R128 -23, ATSC -24, or a custom "lufs".

  • audio.remix

    Remix Music. Premiere's Remix: retimes a music clip to a target length by rearranging its own bars - repeating or skipping sections where the music around the jump sounds alike (beats and bars, then chroma and MFCC self-similarity) - never by stretching it.

  • audio.remixRender

    Render Music Remix. audio.remix rendered into one file: the remix of the music clip (the same plan: its own bars rearranged, intro and outro kept, crossfaded joins) becomes a new media item derived from the song (a float WAV in the user's cache), and the clip plays it from its start.

  • audio.removeEffect

    Remove Track or Master Effect. Removes an effect from a track or master stack.

  • audio.removeKeyframe

    Remove Track or Master Keyframe. Removes keyframe index of a track or master effect parameter or of the fader ("volume" / "pan", no "effect"); the last one leaves a constant.

  • audio.separateStems

    Separate Stems. Splits a music or mixed clip's audio into vocals, drums, bass and other with HTDemucs on this computer (no audio leaves it; the model downloads on first use, and the job refuses on a computer with too little free memory).

  • audio.setChannelVolume

    Set Channel Volume. Premiere's Channel Volume: the volume of one channel of audio clips (1-based clip channel), dB, a constant, or with "time" a keyframe there (the channel's volume becomes animated).

  • audio.setChannels

    Modify Audio Channels. Premiere's Modify > Audio Channels on clips: which source channels feed each of the clip's channels, in a clip format (mono, stereo, 5.1, adaptive), with mutes and per-channel volume.

  • audio.setEffect

    Set Track or Master Effect. Enables or disables an effect of a track or master stack, or sets constant parameters.

  • audio.setMediaChannels

    Modify Media Audio Channels. Modify > Audio Channels on media items: the channel map every audio clip of the item plays unless it has its own (audio.setChannels).

  • audio.splitToMono

    Split to Mono. Splits a clip's channels into linked mono clips, one per source channel, on separate audio tracks (the clip keeps channel 1; the others go on the free audio tracks below it, new ones when needed, or on "tracks"): "split the two mics into separate tracks".

  • audio.syncClips

    Synchronize by Audio. Lines recordings of one event up by their audio: a camera's scratch audio and a separate recorder (dual-system sound), or several cameras.

record.*

  • record.takes

    Voice-over Takes. The takes of a recorded voice-over slot (Premiere's repeated voice-over passes over one range): each pass over the same track and range made a media item in the Voice-over bin, and the clip plays the newest unless record.useTake chose another.

  • record.useTake

    Use Voice-over Take. Plays another take of a recorded voice-over slot (record.takes): that take's media goes over its recorded range on the clip's track as an overwrite, with the clip's level, pan and effects.

takes.*

  • takes.find

    Find Takes. Finds repeated attempts of the same line (retakes and false starts) in a sequence and the recordings it uses: groups of takes, best first, each with its words, a word-by-word difference from the best one, and quality (fillers, false starts, pauses, complete sentence, level, clipping, noise floor, pace).

  • takes.use

    Use Take. Makes the sequence say a line once, with the chosen take: other takes of it on the timeline are removed with their pause, and a take that is not on the timeline replaces the first one there (linked video and audio, with small handles; what follows moves to fit).

dub.*

  • dub.create

    Dub. AI voice-over in another language with the user's own voice provider (ElevenLabs, OpenAI or Gemini; BYOK): each caption cue is spoken and fitted to its slot (sped up at most 15 %, pitch kept; else moved and flagged), on a new "Dub" audio track with the Dialogue role, the original dialogue ducked under it, as one undo step.

plugins.*

  • plugins.list

    List Audio Plugins. The audio plugins (CLAP, VST3) this computer has, by effect id ("plugin.vst3.", "plugin.clap."): name, vendor, version, category, latency (frames), whether it has an editor, and with "params" its parameters (keys "p", ranges, automatable).

  • plugins.scan

    Scan Audio Plugins. Scans the audio plugin folders (Windows: Common Files\CLAP and \VST3, and the user's folders): new and changed files, each in its own helper process, so a plugin that crashes or hangs while scanned goes on the blocklist and nothing else is disturbed.

effect.*

  • effect.list

    List Effects. The effects and transitions Wabcut knows: id, name, category, kind (video, audio, videoTransition, audioTransition) and parameters as arrays in paramFields order. builtIn effects are part of every clip (set their parameters with clip.setParam or keyframes); the others go into a clip's stack.

adjustment.*

  • adjustment.add

    New Adjustment Layer. Adds an adjustment layer clip (File > New > Adjustment Layer, dropped on the timeline): its effects (colour grade, blur, masks, keyframes) apply to the composite of every video track below it for its duration; its Opacity and blend mode mix the adjusted picture over the unadjusted one.

graphic.*

  • graphic.add

    New Graphic. Adds a motion graphic as a clip on a video track (overwriting what is there): "graphic" is the graphic's JSON (docs/graphics.md: name, width/height of its design canvas - default the sequence's frame - layers of text, shapes, images and groups, responsive time).

  • graphic.addLayer

    Add Graphic Layer. Adds a layer (JSON, docs/graphics.md) to a graphic clip: on top of "parent" (a group layer; default the top level), or at "index" (0 = bottom).

  • graphic.applyPreset

    Apply Animation Preset. Animates a layer with editable keyframes: fade, slide, scalePop, bounce (the transform), typewriter and wordByWord (a text-range animator: characters or words appear in turn), wipe (a mask).

  • graphic.get

    Graphic. A graphic clip's graphic as JSON (docs/graphics.md), with its layers listed flat (bottom to top, groups before their children) and, for a template instance, its template and field values.

  • graphic.removeLayer

    Delete Graphic Layer. Removes a layer from a graphic clip (a group with its children); pins to it and template fields bound to it go too.

  • graphic.resolve

    Graphic Draw List. The draw list of a graphic clip at a timeline time (default its start): every visible layer bottom to top with its transform to canvas pixels [a, b, c, d, e, f], opacity, blend mode, shadow, masks, and its path and paints, text runs (and per-character animator values) or image - with the brand kit applied.

  • graphic.update

    Edit Graphic. Changes a graphic clip's graphic with a JSON merge patch (RFC 7386) over its JSON (graphic.get): objects merge, null resets a key to its default, arrays ("layers") are replaced whole.

  • graphic.updateLayer

    Edit Graphic Layer. Changes a layer of a graphic clip with a JSON merge patch (RFC 7386) over the layer's JSON: {"text": {"runs": [{"text": "New"}]}} replaces the runs, {"transform": {"x": 200}} moves it, a curve ({"keys": [{"t": ticks, "v": value}, ...]} or just the array of keys) animates it.

title.*

  • title.add

    New Title. Adds a text title as a clip on a video track: a title media item holding the text and font, and the clip's "wabcut.title.style" effect holding size, fill and stroke colours, stroke width, shadow, alignment, line spacing and tracking.

  • title.setFont

    Set Title Font. Changes a title's font family and/or style.

  • title.setText

    Edit Title Text. Replaces a title's text.

template.*

  • template.instantiate

    Add Template. Adds a graphic made from a template (template.list) as a clip, with field values (by field id: text a string, colour "#RRGGBB" or [r, g, b, a] 0..1 or {"brand": name}, font a family or {"family", "style", "weight"}, image a media id or name, duration a time, checkbox true/false).

  • template.list

    Templates. The graphic templates of the project's library, the user's and the built-in ones that ship with Wabcut (C.16: gaming lower thirds, banners, callouts, stingers, end cards...): id, name, version, default length, canvas, and the fields (id, label, kind, default value) template.instantiate and template.setField take.

  • template.resolve

    Template Draw List. The draw list of a template at a design time, without adding it to a timeline: what template browsers draw for thumbnails and hover previews (C.16).

  • template.save

    Save as Template. Saves a graphic clip's graphic as a template with editable fields (Premiere's Motion Graphics Templates): into the project's library (default), or the user's template library folder ("library": "user"; the host's, not a path).

  • template.setField

    Edit Template Fields. Sets field values of a template instance clip (template.list shows the fields): "field" and "value", or several at once in "values" - one undo step.

lottie.*

  • lottie.import

    Import Lottie. Imports a Lottie animation (Bodymovin JSON from After Effects, LottieFiles) as a motion graphic: from a file ("path") or the JSON itself ("data").

brand.*

  • brand.get

    Brand Kit. The project's brand kit (null when it has none).

  • brand.set

    Set Brand Kit. Sets the project's brand kit - named colours, font roles and logos (media of the project) that graphics, templates and caption styles refer to by name - or removes it (null).

layout.*

  • layout.apply

    Apply Layout. Lays out a gameplay clip and a facecam in one step, with plain editable clip settings: "pip" (gameplay fills the frame, the facecam in a corner with rounded corners or a circle, a border and a drop shadow), "verticalSplit" (9:16: gameplay on top, facecam below, or the other way round) or "verticalBlurFill" (9:16: the gameplay fitted to the width over a blurred copy of itself filling the frame, an optional facecam on top).

  • layout.list

    List Layouts. The layout presets layout.apply takes and their options with defaults: facecam picture-in-picture and the vertical 9:16 shorts layouts.

autozoom.*

  • autozoom.apply

    Auto Zoom. Zooms a screen recording in where things happen (clicks, typing, where the cursor rests) and back out when nothing does, like Screen Studio: smooth, editable Position and Scale keyframes on the clip (the AI-9 camera optimiser), never showing outside the frame.

mask.*

  • mask.add

    Add Mask. Adds a mask to a clip: to an effect ("effect"; the effect then only changes the masked area - a local correction, including the colour grade) or, without "effect", to the clip's opacity mask (it cuts the clip out).

  • mask.list

    List Masks. A clip's masks by effect, with their parameters (keys at media times) and paths.

  • mask.objectSelect

    Select Object. AI Object Mask: segments the person or object you click on (positive and negative clicks), draw a box around, or name ("subject": a face, a person, a car...) on a frame of a clip with SAM 2.1 (local, on this computer), and tracks it through the shot.

  • mask.propagate

    Track Object Mask. Tracks an object mask's object through the clip (or In / Out) from its last clicked frame: after a selection made with "propagate": "none", or across a shot cut with acrossShots.

  • mask.refine

    Refine Object Mask. More clicks (positive: part of the object; negative: not) or a new box on a frame of an object mask: segments it again there and re-tracks from that frame.

  • mask.remove

    Remove Mask. Removes a mask from its effect.

  • mask.update

    Update Mask. Changes a mask: only the fields given (name, shape, mode, inverted, enabled, params, path / pathKeys).

redaction.*

  • redaction.add

    Add Redaction. Marks a region of a media item in SOURCE time for privacy: every use of that range in every sequence (trimmed, sped up, reversed, reused) is blurred, pixelated or covered in preview, export and burn-in, before the clip's own effects; "audio" mutes or bleeps it (only "words" when given).

  • redaction.list

    List Redactions. The project's redactions (of one media item with "media").

  • redaction.override

    Redaction Override. "Don't redact here": the redaction skips this clip (and, with "linked", its linked partners), or applies again with "redact": true.

  • redaction.remove

    Remove Redaction. Removes a redaction everywhere.

  • redaction.update

    Update Redaction. Changes a redaction: only the fields given.

color.*

  • color.auto

    Auto Color. Auto colour: looks at the clip (at "time", default its middle) without its grade and sets the grade's white balance (temperature, tint) and levels (exposure, whites, blacks) as ordinary, editable Basic parameters.

  • color.grade.get

    Get Color Grade. A clip's grade at a time (default: its middle): parameters (only those changed unless "all"), animated ones, curves, LUTs, missing LUTs and whether it does anything.

  • color.grade.set

    Set Color Grade. Sets a clip's colour grade (wabcut.color.grade; added at the end of the stack when the clip has none): "params" by registry key (only those given change; effect.list lists them with ranges), "stages" on or off (basic, creative, curves, wheels, hsl, vignette), "curves" as [x, y] points (master/red/green/blue x and y in 0..1; hueSat/hueHue/hueLuma x = hue in turns and lumaSat/satSat y with 0.5 = no change; [] resets), and the "inputLut" / "look" ("builtin:" or "asset:" from lut.list; "" removes).

  • color.match

    Color Match. Makes clips look like a reference frame: "reference" is {"clip", "time"} (that clip as it looks, alone) or a sequence time (the whole picture).

  • color.matchScene

    Match Scene. Shot-to-shot consistency: matches every clip of the reference clip's scene to it - "scene" (default) is the run of clips on its track cut from the same take without gaps (what clip.splitAtShots makes), "track" every clip on its track, "media" every clip of the same media item, or an explicit "clips" list.

lut.*

  • lut.import

    Import LUT. Adds a .cube LUT file (1D or 3D, up to 65 points per side) to the project as an asset: it relinks and is collected like media.

  • lut.list

    List LUTs. The built-in looks and camera input LUTs (with where their math comes from) and the project's LUT assets (path, offline, how many effects use each).

cdl.*

  • cdl.export

    Export CDL. Writes clips' colour wheels as an ASC CDL: slope = gain - lift, offset = lift + offset, power = gamma, saturation. .cc holds one clip; .ccc and .cdl several (ids are the clip names).

  • cdl.import

    Import CDL. Sets clips' colour wheels from an ASC CDL file (.cc, .ccc, .cdl): the correction whose id is the clip's name, else the one at the clip's position, or "index".

scopes.*

  • scopes.read

    Read Scopes. Scope statistics of the picture at a time (or of one clip alone): luma percentiles in IRE, clipped highlights and crushed blacks, mean colour, saturation and colour cast, with a verdict ("underexposed", "overexposed", "low contrast", "clipped highlights", "crushed blacks" or "ok").

captions.*

  • captions.addCue

    Add Caption. Adds a cue from "start" to "end" (or for "duration").

  • captions.addTrack

    New Caption Track. Adds an empty caption track, styled by a preset (built in: Clean, Bold Box, Podcast, Shorts, Thai-friendly; or one of the project's) and/or style fields.

  • captions.applyPreset

    Apply Caption Preset. Gives a caption track the style of a preset: built in (Clean, Bold Box, Podcast, Shorts, Thai-friendly) or one of the project's.

  • captions.generate

    Generate Captions. Makes a caption track from the transcript: cues of at most maxLines lines of maxCharsPerLine characters and maxDuration seconds, broken at pauses, speaker changes and sentence ends; Thai lines break between words, never at spaces that are not there.

  • captions.generateFromTranscript

    Captions from Transcript. Makes a caption track from the sequence's transcript (with the project's corrections and speakers): cues of at most maxLines lines of maxCharsPerLine characters and maxDuration, broken at pauses, speaker changes and (optionally) sentence ends, at least "gap" apart.

  • captions.get

    Caption Cues. The cues of a caption track (default: the sequence's first) as arrays in cueFields order: start, end, text (its lines joined by newlines).

  • captions.mergeCues

    Merge Captions. Joins "count" consecutive cues (default 2) into one, its text re-wrapped to maxLines lines of maxCharsPerLine characters.

  • captions.presets

    Caption Presets. The caption presets: built in, then the project's, each with its style.

  • captions.remove

    Delete Caption Track. Deletes a caption track of the sequence.

  • captions.removeCue

    Delete Caption. Deletes a cue of a caption track.

  • captions.removePreset

    Delete Caption Preset. Deletes one of the project's caption presets.

  • captions.savePreset

    Save Caption Preset. Saves a named caption style in the project: a caption track's style, with "style" fields applied on top (or the default look).

  • captions.setStyle

    Caption Style. Changes how a caption track looks: font, size (fraction of the frame height), fill, outline, shadow, background box, placement (bottom, top or a custom position), alignment, width, karaoke highlight, speaker names.

  • captions.setTrack

    Caption Track Settings. Renames a caption track, sets its language or shows/hides it.

  • captions.shiftCues

    Shift Captions. Moves the cues that start in [from, to) (default: all of them) by a signed delta, e.g. to resync captions.

  • captions.splitCue

    Split Caption. Cuts a cue in two at a time inside it.

  • captions.translate

    Translate Captions. Translates a caption track into new caption tracks, one per language, keeping the cue timing: cues that would read too fast in the target language borrow time from the gaps, merge with a neighbour or move words across, and text that does not fit two lines is split into more cues (Thai broken between words).

  • captions.updateCue

    Edit Caption. Changes a cue's text, start, end or speaker (null clears the speaker).

  • captions.updateFromTranscript

    Update Captions from Transcript. Rewrites the text of a caption track's cues from the transcript words under them (after transcript corrections), keeping their timing and style; cues with no words under them stay as they are.

transcript.*

  • transcript.addSpeaker

    New Speaker. Adds a speaker to the project.

  • transcript.assignSpeaker

    Assign Speaker. Says who speaks over a timeline range: the words the audio clips there play (on "track" only when given) belong to "speaker", or to a new speaker called "name".

  • transcript.cleanup

    Remove Fillers and Silences. Removes every filler word and pause the review finds with at least minConfidence, in one undo step.

  • transcript.correctRange

    Correct Words. Fixes several consecutive words at once (they read "text", split over them by spaces).

  • transcript.correctWord

    Correct Word. Fixes a transcription mistake: the word reads "text" from now on, in the transcript the project sees and in captions generated or updated afterwards.

  • transcript.corrections

    Transcript Corrections. The project's transcript corrections and how they apply to the current transcripts: applied, conflict (the words changed since, e.g. after re-transcription; the correction still wins), restored (no words there any more; the correction brings them back) or noTranscript.

  • transcript.deleteRanges

    Delete Words. Deletes words (and pauses) like deleting text: ripple deletes on the tracks the words are heard on and their linked partners, cut on frame boundaries just outside the words, neighbouring deletions merged, sync-locked tracks following, locked tracks untouched.

  • transcript.keepRanges

    Keep Only Words. Rough cut: keeps the given word ranges and ripple-deletes everything else on the transcript's tracks, from the first to the last clip that has words.

  • transcript.mergeSpeakers

    Merge Speakers. Makes speakers one: every word, assignment and caption of "from" (one id or several) becomes "into", and the merged speakers go.

  • transcript.moveRange

    Move Words. Moves words (a sentence, a paragraph) to the word boundary before another word: cut out with a ripple and inserted there, with their linked video.

  • transcript.renameSpeaker

    Rename Speaker. Renames a speaker and/or changes its colour.

  • transcript.review

    Review Fillers and Silences. Filler words (language-aware: um, uh, like in disfluent context; Thai อืม, เอ่อ, แบบว่า ...) and pauses longer than a threshold, as a review list: kind, word indices, time range, confidence, label and context.

  • transcript.speakers

    Speakers. The project's speakers (id, name, colour, words in this sequence) and the diarization labels of the sequence's transcripts with the speaker each one is (null: none yet; transcript.renameSpeaker by media and label names one).

  • transcript.text

    Transcript Text. What the sequence says, in timeline order, as paragraphs (split at speaker changes and pauses) with the word indices the other transcript commands take.

  • transcript.transcribe

    Transcribe Media. Transcribes the audio of media items or clips (default: every audio clip of the sequence) so the other transcript commands have words. provider: "auto" (on this computer when the local engine is built, else the user's cloud transcription model), "local", or "cloud:"; cloud transcription goes through the user's consent, spend cap and offline / no-cloud locks.

  • transcript.words

    Transcript Words. The sequence's words in timeline order as arrays in wordFields order: index, text, timeline start and end, the audio clip and track it is heard on, speaker and recognition confidence.

analysis.*

  • analysis.detectBeats

    Detect Beats. Finds the tempo and beats of a clip's music: beat markers labelled 1-2-3-4 (downbeats red) and the sequence's beat grid (snapping, edit.snapToBeats and edit.cutToBeats use it).

  • analysis.detectShots

    Detect Shots. Finds the cuts (hard cuts, fades through black, dissolves; flashes are not cuts) in a clip's video and, for a clip, marks them with sequence markers ("markers": false to only list them).

  • analysis.speakers

    Who Speaks When. Active-speaker detection for a multicam source, on this computer: who speaks when (with crosstalk, silence and laughter) and which angle shows whom (close-up or wide), from the transcripts with their speakers, each angle's microphone level and each camera's faces and lip motion.

  • analysis.subjects

    Find Subjects. Finds the faces, people and salient regions of a media item over time, shot by shot (5-10 samples a second, denser while the picture moves; faces and people tracked within each shot).

search.*

  • search.footage

    Search Footage. Smart search: finds the moments of the project's media that show or say what the query describes ("a dog on the beach", "the part where she mentions the budget", Thai too), by what the frames show (an image-text model) and what is said (the transcripts).

  • search.indexMedia

    Index Media for Search. Brings the smart-search index up to date for some or all media: keyframes of every shot (one per shot, more in long shots) through the image-text model, and the transcript's phrases.

highlights.*

  • highlights.find

    Find Highlights. Finds the best moments of a gaming recording on this computer: game-audio spikes, the player's voice (louder or higher than usual, shouting, laughter), the picture (fast action, flashes, bursts of picture changes), the recording's imported Twitch / YouTube chat log (busy chat, emotes; highlights.importChat) and OBS chapter markers or a marker file next to the recording.

  • highlights.importChat

    Import Chat Log. Reads a stream's chat log (TwitchDownloader JSON, yt-dlp live_chat.json or chat-downloader JSON) and keeps it with a recording's analyses, so highlights.find counts busy chat and emotes.

  • highlights.toReel

    Make Highlight Reel. Makes a new sequence from highlight moments (the sequence's highlight markers, or "moments"): each moment with handles, best first up to "count" / "maxDuration", in time or score order, with transitions between them.

  • highlights.toShort

    Make Highlight Short. Makes one highlight moment (a highlight marker by rank, or start/end) a vertical 1080x1920 Short: the moment cut out with every track, laid out with layout.apply ("verticalSplit" with the facecam under the gameplay when there is one: a facecam clip above the gameplay or "facecamRegion"; else "verticalBlurFill": the whole game view over a blurred copy), captioned, with the moment's title as the hook and loudness for Shorts.

shorts.*

  • shorts.create

    Create Shorts. Makes one new sequence per short (from shorts.find): the range cut out of the source sequence, reframed to 9:16 (or "aspect") with editable keyframes following the speaker, captioned, with the title as a hook for its first seconds; optionally cleaned of fillers and silences and normalised to -14 LUFS.

  • shorts.find

    Find Shorts. Finds the best moments of a long sequence for vertical shorts (20-90 s each): whole sentences, a hook in the first seconds, one topic, lively delivery, faces, few fillers; optionally about a topic ("query").

reframe.*

  • reframe.createSequence

    Auto Reframe. Makes a copy of a sequence at another aspect ("9:16" for vertical shorts, "1:1", "4:5", "16:9") whose video clips keep their subjects in frame: per shot, a smooth virtual camera (still, then steady pans) follows the main subject, all faces, the speaker or an anchor.

  • reframe.rerun

    Reframe Again. Makes a reframed sequence again from its source sequence (after the source was edited), with the parameters it was made with, or new ones given here.

roughcut.*

  • roughcut.fromScript

    Rough Cut from Script. Makes a first cut from a script, an outline or bullet points: each line is found in the transcripts of the recordings (fuzzy, Thai too), the best take of it chosen (fewest fillers and false starts, complete sentence, clean audio; alternates kept), and the takes assembled in script order as a new sequence with linked video and audio trimmed to the words with small handles.

  • roughcut.swapTake

    Swap Take. In a rough cut made by roughcut.fromScript, plays another recorded take of one line in place of the current one; what follows moves to fit (a ripple).

narration.*

  • narration.create

    Narration. Narration from a script with the user's own voice provider (BYOK): each line spoken, over its rough-cut beat when the sequence is a rough cut (AI-11) or one after another, on a new "Narration" audio track with the Dialogue role and the other audio ducked under it, as one undo step.

gen.*

  • gen.broll

    Generate broll. App: opens a human-reviewed Generate proposal with consent and cost preview; acceptance imports one staged edit.

  • gen.extend

    Generate extend. App: opens a human-reviewed Generate proposal with consent and cost preview; acceptance imports one staged edit.

  • gen.image

    Generate image. App: opens a human-reviewed Generate proposal with consent and cost preview; acceptance imports one staged edit.

llm.*

  • llm.local.models

    Local assistant models. Inspect the managed local assistant and its installable models; never downloads implicitly.

  • llm.local.start

    Local assistant start. Start or stop the managed local assistant (an installed, allow-listed model); never downloads implicitly.

  • llm.local.status

    Local assistant status. Inspect the managed local assistant and its installable models; never downloads implicitly.

  • llm.local.stop

    Local assistant stop. Start or stop the managed local assistant (an installed, allow-listed model); never downloads implicitly.

workflow.*

  • workflow.podcast

    Podcast Workflow. The one-click podcast / interview edit, on this computer (local, free): sync the cameras and microphones (multicam by audio), lay out the episode (the multicam picture, each microphone on its own dialogue track), transcribe, Enhance Speech, loudness to -16 LUFS, remove fillers and long pauses, switch cameras to whoever speaks, captions, chapters from the topics (and YouTube chapters), optionally shorts.