Keymap

Owner: Keymap engineer. Code: src/keymap/ (wabcut_keymap, static, no Qt). Tests: tests/keymap/.

Wabcut uses Premiere Pro's default keyboard shortcuts, panel by panel and OS by OS, so a Premiere editor's hands work unchanged. The default tables are src/keymap/keymaps/premiere-windows.json and premiere-macos.json. They are two separate tables; the macOS one is never produced by swapping Ctrl and Cmd. Linux uses the Windows table. Both JSON files are the editable source of truth and are compiled into the library at build time.

Sources#

The 2026 page has no Tools, playback or ripple-trim tables, so those rows come from the older Adobe pages. Every binding in the JSON names its source.

Verification notes#

Facts the lead verified. All of them match the 2026 page except the two macOS rows the lead later decided to take from Premiere's shipped key set (see below). tests/keymap/test_default_tables.cpp asserts each one per OS and per scope:

The J/K/L/C/V/Q/W/B/N rows. None of the nine is on the 2026 page. Each was checked against the older Adobe pages and against Premiere's default key sets. The test Checked against Adobe: J K L C V Q W B N asserts them.

Cross-check against Premiere's default key sets. Every command with a .kys identity was looked up in the default Windows and macOS key sets listed under Sources, and its decoded shortcut was compared with the table:

• Windows: 217 of 218 match. The remaining one, Send to Media Encoder, is missing from that older key set; a Premiere 26.0 Windows key set confirms cmd.file.export.sendtoqueue = Alt+Shift+M.

• macOS: all 218 match. Two rows disagree with the macOS column of Adobe's 2026 page, and the table follows the shipped key set for both:

  • Trim Edit: the page says Cmd+T; the shipped key set says Shift+T, as on Windows. On the page, Cmd+T is also Graphics > New Layer > Text.
  • Make Subsequence: the page says Cmd+U; the shipped key set says Shift+U, as on Windows. On the page, Cmd+U is also Clip > Make Subclip.

  Lead decision (task K.1): Wabcut must behave like the Premiere that users actually have, so it follows the shipped default key sets rather than the help page wherever they disagree. Both page values look like Shift turned into Cmd, and they would have created two conflicts on macOS. With the shipped values, both default tables are conflict-free (a test asserts it), and the acknowledgedConflicts mechanism stays available for future tables but is empty in both.

Other things found on the page:

• Maximize Frame shows "Shift +" with no key on the 2026 page; the backtick was lost in rendering. The 2024 page ("Maximize or Restore Active Frame | Shift + ") and the key sets give Shift+.
• Nudge Clip Selection in the Timeline is Alt+arrows on Windows but Cmd+arrows on macOS, not Opt. The brief said "Alt/Opt+arrows"; the table follows the page and the key sets agree. On macOS, Opt+Left/Right is Trim Backward/Forward in Premiere (in the table since M5i).
• Paste Insert (Ctrl+Shift+V / Shift+Cmd+V) is missing from the 2026 Edit table. It is taken from the 2024 page.
• Go to Next/Previous Caption Segment are listed under the Sequence menu, so they are Application-scope here. Premiere stores them in context.timeline. The .kys mapping accounts for this.
• Toggle Trim Type (since M5i) follows the shipped key sets: Ctrl+Shift+T on Windows and Control+T on macOS, in context.global. The 2024 page's Shift+T would shadow Trim Edit in the Timeline, so it is not used (M5j).
• On macOS, Meter Input(s) Only uses the physical Control key (Ctrl+Shift+I in Adobe's macOS column). Qt calls that key MetaModifier, and the table stores it that way.

Key names and modifiers#

Chord text in the JSON is canonical formatKeyChord(…, ChordFormat::Text) output, and a test enforces this. Key codes and modifier bits are Qt's, so the app passes QKeyEvent::key() and modifiers() straight in.

Qt reports ⌘ as ControlModifier and ⌃ as MetaModifier on macOS. parseKeyChord therefore reads "Cmd" as Control and "Ctrl" as Meta on macOS, and rejects Cmd/Opt on Windows/Linux so the two tables cannot be mixed up. ChordFormat::Native renders menus and tooltips: Ctrl+Shift+K on Windows, ⇧⌘K on macOS.

Command table#

All 250 commands. Source: 2026, 2024 and 2017 are the Adobe pages above; † marks the 2026 "assign multiple" page; .kys means Premiere's shipped default key sets. Premiere .kys item is the (context, command name) pair the importer maps from; (not mapped) means no verified pair, so .kys import skips the command.

How resolution works#

KeymapManager::resolve(Scope focused, KeyChord) returns the command for a key press:

1. Scope precedence. The focused panel's bindings are tried first, then Application. A panel shortcut therefore shadows an Application shortcut on the same chord while that panel has focus (Ctrl+L is Loop in the Audio Track Mixer and Link elsewhere). This is Premiere's documented rule: "When a Panel Shortcut has the same assigned shortcut as an application Shortcut, the application shortcut does not function when that panel has focus." Shadowing is by design and is not reported as a conflict.
2. One scope per command. Premiere's commands are per panel, so Wabcut's are too: Edit > Ripple Delete (edit.rippleDelete, Application) and the Timeline panel's Ripple Delete (timeline.rippleDelete) are separate commands. CommandInfo::scope is the only scope a command can be bound in, and load() enforces it.
3. Qt event quirks. The chord from a QKeyEvent is matched to the bound chord. Key_Backtab becomes Shift+Tab. GroupSwitch is ignored. Keypad navigation and editing keys (Enter, Delete, Insert, arrows, Home/End, PgUp/PgDn) fall back to their main-keyboard bindings when they have no keypad-specific one; this also covers macOS, where Qt flags the arrow keys as keypad keys. Keypad Enter falls back to Return. Keypad digits and operators never fall back: Premiere reserves them for timecode entry, and numpad + and - type relative timecode. Shift plus a US-layout symbol (Shift+; arrives as Key_Colon) is matched to the base key (Shift+;). The exact chord is tried in the focused panel and then in Application before any fallback spelling is tried in either.
4. Canonical storage. setChords(), assign() and unassign() store chords in the same form resolve() matches, so a chord captured from a key event in a shortcut editor (Shift+Key_Colon) is stored as Shift+; and takes that key from whichever command held it.
5. Conflicts. conflicts() lists every chord bound to two or more commands in the same scope, with the commands in resolution order. A chord the user added (one that is not among that command's defaults) wins. After that comes the winner order of an acknowledged conflict, then default-table order. A default table must acknowledge each of its own conflicts in acknowledgedConflicts, and load() rejects an acknowledgement that does not match a real conflict. A conflict counts as acknowledged only while its commands and winner are exactly the table's. Both shipped tables are conflict-free, which a test asserts.

User overrides#

Overrides are a diff over the defaults. setChords(command, chords) replaces a command's chords; an empty list unbinds it, and setting the defaults back removes the override. assign(command, chord) works like Premiere's shortcut editor: it takes the chord away from any other command in the same scope and returns those commands so the UI can say so. saveOverrides() writes, and loadOverrides() reads:

{
  "schemaVersion": 1,
  "platform": "windows",
  "overrides": {
    "marker.markIn": [],
    "tool.razor": ["X", "Ctrl++"]
  }
}

Override files are per OS family. Windows and Linux share one, as Premiere key sets do; macOS has its own. Unknown command ids, for example from a newer Wabcut, are skipped with a warning. Malformed files are rejected and the current overrides stay untouched.

Default table format#

{
  "schemaVersion": 1,
  "name": "Adobe Premiere Pro default (macOS)",
  "platform": "macos",
  "sources": { "adobe-2026": { "title": "…", "url": "…", "lastUpdated": "2026-01-07" } },
  "bindings": [
    { "scope": "application", "command": "marker.clearIn", "keys": ["Opt+I"], "source": "adobe-2026" }
  ],
  "acknowledgedConflicts": []
}

An entry in acknowledgedConflicts names a deliberate same-scope conflict and its winner first, for example {"scope": "application", "keys": "Cmd+T", "commands": ["graphics.newTextLayer", "sequence.trimEdit"], "note": "…"}. Both shipped tables leave the list empty.

load() is strict and atomic: it rejects unknown commands, a scope that is not the command's own, duplicate commands, chords spelled for the other OS, and stale acknowledgements. cmake/EmbedKeymaps.cmake turns both files into byte arrays in the build directory, and a test checks the embedded bytes equal the files.

J/K/L transport gesture and key dispatch#

Holding keys needs both press and release events, so the app does not call resolve() itself. The Qt-free KeyDispatcher takes every press and release and returns a KeyResult {handled, commands, transport}. handled tells the caller to consume the event even when nothing runs, for example the auto-repeat of Play/Stop. The dispatcher applies CommandInfo::autoRepeat: frame steps, nudges, zoom and undo repeat while held, while Play/Stop and other toggles do not. It routes the three shuttle commands through TransportGesture, which emits the typed intents of contract revision 2 for PlaybackController::setTransportSpeed(Rational) and stepFrames(int):

• OS auto-repeat never climbs the ladder.
• A hold is recognised by the first auto-repeat press, or by tick() after 300 ms for systems with key repeat turned off.
• The gesture is K-first: only a J/L pressed while K is held takes part, and pressing K always stops, including during slow play.
• With K held, the most recently pressed J/L can become a hold; releasing it hands over to the other one if that is still down.
• Roles follow commands, not keys: rebinding the shuttle commands rebinds the gesture, and several keys may share a role (K and keypad 5 both as stop; slow play ends when the last one is released).
• syncSpeed() tells the gesture what the transport really runs at, for example after Play/Stop, so the next L climbs from there.
• focusLost() forgets held keys and ends slow play, but leaves normal shuttle play running.

Presses and ticks are timed with one clock (std::chrono::steady_clock, or one injected for tests), never with window-system event timestamps. A fresh press of a key the dispatcher thinks is still down is treated as a lost release followed by a new press, so a K release missed in another window does not latch the gesture.

App integration (KeymapDispatcher)#

The Qt side lives in src/app/src/bridge/KeymapDispatcher.{h,cpp}, inside the Wabcut QML module. The keymap module itself stays Qt-free. The bridge static_asserts that every key and modifier constant equals Qt's, so QKeyEvent values convert without a table.

What it does.

• KeymapDispatcher is a QML singleton. It owns the KeymapManager: the built-in Premiere table for the running OS plus the user's overrides from <AppConfigLocation>/keymap/overrides-<os>.json, a path given by QStandardPaths. It also owns the KeyDispatcher with its TransportGesture.
• It installs an event filter on one QQuickWindow (KeymapDispatcher.window). If nothing sets the window, it attaches to the first top-level QQuickWindow that becomes the focus window.
• Presses and releases are both forwarded. Window deactivation, focus-out and hiding reset held gestures, and a 50 ms timer ticks the gesture while K is held.

Declaring scopes (panel owners). The panel's root item sets the attached property, and every descendant inherits it:

import Wabcut

Item {                                // TimelinePanel.qml
    KeymapScope.scope: "timeline"     // timeline, programMonitor, sourceMonitor, project, effectControls,
                                      // effects, audioMixer, history, mediaBrowser, metadata, application
}

The dispatcher resolves against the focused item's nearest KeymapScope, then Application, so Alt+Backspace is Ripple Delete only while focus is inside the timeline, and Shift+Delete works everywhere. An unknown scope id logs a warning and is skipped. KeymapDispatcher.scopeAt(item) shows what applies to an item.

Routing rules. These keep keys away from the editor's shortcuts:

Outputs (feature owners).

• commandTriggered(string commandId) fires for every command except the J/K/L gesture.
• transportIntent(kind, speedNum, speedDen, frames) fires for the gesture. kind is KeymapDispatcher.ShuttleStep | SetSpeed | StepFrames | Stop. Speed is set for ShuttleStep and SetSpeed, frames for StepFrames.
• trigger(commandId) runs a command from a menu or button. Shuttle commands go through the gesture, so a transport-bar button climbs the same ladder.
• syncTransportSpeed(num, den) reports the real transport speed, for example after Play/Stop or a seek.
• shortcutText(commandId) and shortcutTexts(commandId) give display text for tooltips and menus (Ctrl+K on Windows/Linux, ⌘K on macOS). Read KeymapDispatcher.revision in the same binding so it refreshes after edits.
• assignShortcut(commandId, chordText), resetShortcut(id), resetAllShortcuts() and importPremiereKeySet(fileUrl) edit and persist the overrides; assignShortcut returns {ok, lost, error}.

Connections {
    target: KeymapDispatcher
    function onCommandTriggered(commandId) { /* route by id, see below */ }
    function onTransportIntent(kind, speedNum, speedDen, frames) {
        switch (kind) {
        case KeymapDispatcher.ShuttleStep:
        case KeymapDispatcher.SetSpeed:   playback.setTransportSpeed(speedNum, speedDen); break
        case KeymapDispatcher.StepFrames: playback.stepFrames(frames); break
        case KeymapDispatcher.Stop:       playback.pause(); break
        }
    }
}

From C++ (for example ProjectController or the playback bridge), get the instance with engine.singletonInstance<wabcut::app::KeymapDispatcher*>("Wabcut", "KeymapDispatcher") and connect to the same signals. Use keymap().registry().find(id)->displayName as the undo label.

Wiring for the UI shell (M1). Two steps:

• Main.qml should set KeymapDispatcher.window = root in Component.onCompleted. This creates the singleton early and attaches it explicitly.
• Each panel root should set its KeymapScope.scope.

The tooltip calls MockKeymap.chord(id) become KeymapDispatcher.shortcutText(id). Several mock ids differ from the real ones:

The other mock ids (file.save, file.import, edit.find, transport.playStop, transport.shuttleStop, transport.goToStart, transport.goToEnd, tool.selection, tool.razor) already match.

Wiring the edit commands (M5, timeline). Handle commandTriggered in ProjectController with one table from command id to an EditSession::apply(label, fn) call over EditOps. These are the ids the timeline owns, with their Premiere meaning:

Tests: tests/app/test_keymap_dispatcher.cpp drives a hidden window built from tests/app/KeymapScene.qml with synthetic key events and covers each rule above.

Multi-camera (M5l)#

The camera keys run while the Program Monitor shows the multi-camera view (Multicam.viewOn), whichever panel has focus. Main.qml routes them to the Multicam bridge (MulticamEditBridge):

The switches recorded while playing are sent as one multicam.switchAngle {clip, target, switches} when playback stops, so they are one undo step. "Target" is the view's Picture and sound / Picture / Sound pill. A click on an angle in the grid behaves like its digit, and a Ctrl/Cmd+click like Cut to Camera. Angle 10 and up have no key (Premiere's default sets bind only 1-9); click them.

The Project scope: the Library (M5k)#

The Library panel declares KeymapScope.scope: "project", so Premiere's Project panel keys act on it while it has focus. Main.qml sends every project.* command to the Library bridge (LibraryBridge::runCommand):

Two Application commands are the Library's too: edit.find (Ctrl/Cmd+F) shows the Library and focuses its Find bar, and clip.makeSubclip (Ctrl/Cmd+U) asks for the subclip's name and makes it from the Source Monitor's marks. In the grid and the list, the arrows move the selection (Shift extends), Return opens and F2 renames; those keys belong to the view while it has focus. tests/app/test_library.cpp covers the bridge side.

The renamed trim commands of M5j (timeline.toggleTrimType, timeline.trim* -> sequence.*) keep keys saved under their old ids: KeymapManager::loadOverrides maps them (review P2-45).

The Source Monitor scope (M5h)#

The Source Monitor panel declares KeymapScope.scope: "sourceMonitor". Like Premiere's Source Monitor, it has no panel shortcuts of its own: Adobe's default table lists none, and the shipped key sets bind nothing in that context. Its keys resolve to the Application commands, and the app applies them to the source while the panel has focus. The Program Monitor has panel shortcuts (Show Rulers, Ctrl/Cmd+R, and so on), so the same chord can resolve differently there: in the Source Monitor, Ctrl/Cmd+R is Speed/Duration. tests/app/test_source_monitor.cpp checks both the resolution and the routing.

Main.qml asks KeymapDispatcher.scopeAt(window.activeFocusItem). When the focus is in sourceMonitor, the command goes to SourceMonitor.runCommand() first:

The timeline's M5i commands#

The brief named T, Shift+T and Ctrl+T for trimming. In Premiere's current tables, T is the Type tool, Ctrl+T is New Text Layer and Ctrl+Alt+arrows slip. Wabcut follows those tables, as the coordinator approved; Toggle Trim Type is the shipped key sets' Ctrl+Shift+T (Control+T on macOS; M5j). In Premiere, Clear Selected Marker is Ctrl+Alt+M and Clear All Markers is Ctrl+Alt+Shift+M.

Premiere .kys import#

importKys(path) reads a Premiere key set and returns user overrides, which applyKysImport(keymap, import) applies. The format below was checked against real files, not inferred: Premiere 25.0 and 26.0 Windows key sets saved on a development machine, and the Windows and macOS default key sets listed under Sources (50 public key sets were surveyed in total).

<?xml version="1.0" encoding="UTF-8"?>
<PremiereData Version="3">
  <shortcuts Version="5">                       <!-- 4 in older files -->
    <platform>windows</platform>                <!-- "macintosh" on macOS; first or last child -->
    <context.global Version="1">                <!-- one per context: global, timeline, project, … -->
      <itemcount>924</itemcount>
      <item.806 Version="1">
        <virtualkey>1</virtualkey>              <!-- absent: the command has no shortcut -->
        <modifier.ctrl>true</modifier.ctrl>     <!-- Windows: ctrl, alt, shift -->
        <modifier.alt>false</modifier.alt>      <!-- macOS: command, opt, shift, ctrl (= ⌃) -->
        <modifier.shift>true</modifier.shift>
        <commandname>cmd.transport.playintoout</commandname>
      </item.806>

• A key set lists every command of the Premiere version that saved it. A command with several shortcuts has several items with the same name in the same context. The order of an item's children varies between versions.

• Modifiers. Windows writes modifier.ctrl/alt/shift. macOS writes modifier.command (Qt Control), modifier.opt (Alt), modifier.shift and modifier.ctrl, the physical ⌃ key (Qt Meta). Evidence: Undo is modifier.command + Z, Clear In is modifier.opt + I, and Play from Playhead to Out Point is modifier.ctrl

  • Space, matching Adobe's documented macOS defaults Cmd+Z, Opt+I and Ctrl+Space.

• Virtual keys. 0x80000000 | character is a printable key; the character is the unshifted US character, for example 2147483723 = K. 0xC0000000 | character is a keypad key. Small numbers are named keys; each code below was verified by matching a command's documented default key to its <virtualkey>:

  Code	Key	Evidence
  1	Space	Play-Stop Toggle
  2	Backspace (macOS Delete)	Timeline Clear Selection, Ripple Delete
  3	Tab	Project Next Column Field
  4	Return/Enter	Render In to Out, Project Next Row Field
  7–18	F1–F12	Help = 7, Capture = 11 (F5), Batch Capture = 12 (F6), plus F7/F11/F12 in a documented user key set
  35	Delete (macOS Forward Delete)	Clear, Ripple Delete (Shift+)
  36 / 37	Home / End	Go to Sequence-Clip Start/End
  38 / 39	Page Up / Page Down	Show Previous/Next Screen
  42 / 43 / 44 / 45	Left / Right / Up / Down	Step Back/Forward, Go to Previous/Next Edit Point

  The decoder rejects other codes: 0 means "no key"; 5 (probably keypad Enter) and 19–30 (probably F13–F24) have only single, indirect sources; characters outside US-ASCII come from key sets saved with other keyboard layouts. A rejected code produces a warning, and that command keeps its current bindings.

• Mapping. Items map to Wabcut commands by (context, command name) (CommandInfo::kysContext/kysName), because one name can mean different commands in different panels: cmd.edit.clear is Clear in context.global, Clear Selection in context.timeline and Delete in context.project. 245 of the 250 commands have a mapping (Next and Previous Sequence Tab, Start and Stop Voice-over Recording and Remove Attributes have no item in Premiere's key sets). Each mapping was verified by the default key set binding that item to the command's documented default shortcut. Trim Edit maps to cmd.placeholder, an odd name but the evidence is consistent: in both default key sets and in a Premiere 26 Windows key set it is the only item on Shift+T, Adobe's documented Trim Edit key.

• Semantics. A command mentioned in the key set gets exactly the key set's shortcuts; no shortcuts means unbound. Commands the key set does not mention keep their bindings. Overrides equal to the defaults are dropped. Premiere commands with shortcuts but no Wabcut equivalent are listed in KysImport::unmappedCommands, and a macOS key set cannot be applied to a Windows/Linux keymap or the reverse.

TODO (.kys). One source suggests that Premiere 27 nests contexts under mode.Edit / mode.Color (/PremiereData/shortcuts/mode.Edit/context.global/…). No such file has been seen, so the importer rejects that layout as Unsupported instead of guessing. Verify it with a real Premiere 27 key set before adding it. The same applies to virtual keys 5 and 19–30. Export to .kys is not implemented.

Keyboard Shortcuts editor (UI)#

Edit > Keyboard Shortcuts: edit.keyboardShortcuts, Ctrl+Alt+K on Windows/Linux and ⌥⌘K (Opt+Cmd+K) on macOS, as in Premiere. It is also in the logo's File menu and the command palette. M5f; owner: Timeline/UI.

• Code: ShortcutsBridge (QML singleton Shortcuts, src/app/src/bridge/ShortcutsBridge.*) and src/app/qml/shortcuts/.
  • Every edit is made on a copy of the dispatcher's KeymapManager with the engine API (assign, unassign, resetToDefault, applyKysImport, loadOverrides).
  • It is then committed at once with KeymapDispatcher::setOverrides(overrides). That method is C++ only: it replaces every user override atomically on a copy, swaps it in, saves overridesPath and emits keymapChanged.
  • The keys that are dispatched therefore change immediately, and the overrides file stays the only persisted state.
• Keyboard: a US ANSI keyboard with the navigation block and keypad (Shortcuts.keyboard, positions in key units).

  • Each key is filled by what it does with the modifiers shown (keyAssignments(modifiers)):

    • application commands: Theme.keyApplication, violet;
    • panel commands: Theme.keyPanel, teal;
    • both: split.

    These are Premiere's purple/green, and they do not follow the accent.

  • Shifted US symbols are drawn on their base key ("+" is Shift+=). Keypad keys are separate from the main row.

  • Clicking a modifier key, or a modifier toggle, shows another combination.

  • Clicking a key lists what it does in every panel (commandsForKey), with remove buttons and "Give to ".

• Commands: Shortcuts.commands, in registry order, in sections by group.
  • Search matches the Wabcut name, Premiere's name, the id, the group, or a shortcut ("Ctrl+K" finds Add Edit). A filter limits it to application commands, all panels, or one panel.
  • Each row shows the shortcuts as keycaps (× removes one), + to type a new one, and a reset arrow when the command differs from the defaults.
  • Commands Wabcut does not run yet are dimmed. Their keys are kept.
  • Rows have a grip to drag the command onto a key.
• Typing a shortcut: the capture field takes every key (it accepts ShortcutOverride, so neither window shortcuts nor keymap commands fire) and Esc cancels. chordText(key, modifiers) turns the event into storage text.
• Conflicts, before anything changes:
  • checkAssign(command, chord) lists the commands in the same scope that would lose the chord. The editor asks "Reassign / Cancel", and assign then takes the chord from them, as Premiere does.
  • Premiere's third warning is shown too: a panel command and an application command on the same chord. For example, "While the Timeline has focus, “Clear” runs instead".
• Key sets:
  • Premiere Pro (default): the built-in table, with no overrides.
  • Wabcut: three changes. Ctrl+Y also redoes, on Windows. Backspace ripple-deletes in the Timeline, as in DaVinci Resolve and Final Cut Pro; Alt/Opt+Backspace still does too. Timeline "Clear" therefore loses Backspace; Delete still clears, application-wide.
  • User sets: "Save as a new key set…" writes the current overrides to <overrides folder>/sets/<name>.<windows|macos>.json.
  • The chosen set is remembered (shortcuts/preset in QSettings). The editor says "modified" when the keys differ from it, and Reset returns to Premiere Pro's defaults.
• Import and export:
  • Import… reads a Premiere .kys or a Wabcut overrides .json.
    • A .kys is merged into the current keys, as Premiere's import does.
    • The report names the Premiere commands that have no Wabcut equivalent (KysImport::unmappedCommands) and counts the commands that changed.
  • Export… writes the overrides as .json: the overrides schema above, readable by Import.

Extension commands (C.12)#

Extensions add commands with stable ids ext:<extension id>/<command id>. The app registers them at run time (KeymapDispatcher::setExtraCommands): Application scope, group "Extensions", no default key. They are assignable in Keyboard Shortcuts and saved with the user's overrides. A saved key for an ext: id whose extension is off or not installed is kept: the command stays listed as " (unavailable)", and its key says why nothing runs. .kys import never maps to them.

Known gaps and next steps#

• App wiring: the bridge exists; the UI shell still has to attach it and declare panel scopes, and the M5 timeline and playback owners have to consume commandTriggered / transportIntent (see App integration).
• Popups without focus: a modal popup that does not take focus does not block shortcuts; give such popups focus: true.
• Lost key-ups: macOS can drop a key-up while ⌘ is held. The dispatcher heals this on the next press of that key and on focusLost(); until then K counts as held, so J/L step frames instead of shuttling. A bridge that sees modifier changes without a K event could also call focusLost().
• Layouts: shifted-symbol matching assumes a US layout. On other layouts, Premiere-style punctuation shortcuts need the bridge to pass layout-independent keys (for example from nativeVirtualKey()).
• Coverage: commands for features Wabcut does not have yet (captions, graphics, workspaces) are registered so the tables stay a complete transcription; the app can show them disabled. Premiere commands beyond the 2026 page (Select Next Clip, multicam, and so on) can be added when their features exist, together with their .kys identities. M5i's Trim Backward/Forward (Many), Toggle Trim Type and Expand/Minimize All Tracks were verified in M5j against both default key sets; their identities and corrected scopes are recorded in footnotes 13, 15 and 16.
• Editor UI: done in M5f (see "Keyboard Shortcuts editor (UI)"), including Premiere's third warning type, "panel shortcut overrides an application shortcut". Still missing: export to .kys, and keyboards other than US ANSI.

Footnotes#

1. Paste Insert: Not on the 2026 page; in the Edit table of the 2024 page. ↩

2. Remove Attributes (C.11, M5m): Premiere's Edit > Remove Attributes… has no default key, and neither shipped key set (Windows Premiere_default_keys.kys, macOS Default Adobe.kys) lists an item for it, so it has no .kys mapping. It opens the attributes dialog on the selection's own attributes (clip.removeAttributes). ↩

3. Moments (M5o, gaming): Wabcut's, with no default key; Premiere has no counterpart. They act on the clip under the playhead (the selected one if several): Slow-mo at Playhead is the 25 % / 1 s slow motion centred on the playhead (one timeRemap.* undo step, later clips ripple); Punch-in at Playhead zooms to 130 % of the clip's scale for 1 s (Motion keyframes). The Timeline's Moments popover (the zap button in the tracks header) and the clip menu's Moments submenu list the other presets; a key assigned in Keyboard Shortcuts shows next to both. ↩ ↩²

4. Trim Edit: Adobe's 2026 page says Cmd+T on macOS, which collides with Graphics > New Layer > Text. Premiere's shipped macOS key set binds Trim Edit (cmd.placeholder) to Shift+T, and Wabcut follows the shipped key set. ↩

5. Toggle Trim Type: verified in M5j against both shipped key sets: cmd.sequence.toggletrimtype in context.global, Ctrl+Shift+T on Windows and Control+T on macOS (the physical Control key: Qt MetaModifier, written Ctrl in the macOS table). M5i had the 2024 page's Shift+T in the Timeline, which shadowed Trim Edit there; the id moved from timeline.toggleTrimType to sequence.toggleTrimType with the scope. With no edit point selected it still starts a Trim Edit (see "Trim mode" below). ↩

6. Trim Backward / Forward (Many): verified in M5j against both shipped key sets (cmd.sequence.trimbackward, trimforward, trimbackwardmany, trimforwardmany in context.global); the ids moved from timeline.* to sequence.*. Many uses the Large trim offset preference (default 5 frames). Ctrl+Alt+arrows stay Slip, as in Premiere. The Program Monitor's own Ctrl+arrow nudges win while it has focus (Windows). ↩ ↩² ↩³ ↩⁴

7. Zoom to Sequence: Listed on Adobe's 2017 print pages for both OSes but not on the 2024 or 2026 pages; also the binding of cmd.tlnav.zoomto.sequence in the default .kys files. ↩

8. Make Subsequence: Adobe's 2026 page says Cmd+U on macOS, which collides with Clip > Make Subclip. Premiere's shipped macOS key set binds Shift+U, and Wabcut follows the shipped key set. ↩

9. Go to Next Caption Segment: Premiere stores this in context.timeline (cmd.timeline.goto.next.caption.trackitem); the page lists it under the Sequence menu, and the table follows the page. ↩

10. Go to Previous Caption Segment: See Go to Next Caption Segment. ↩

11. Multi-camera keys (M5l): the 2026 page lists none. Both shipped key sets put them in context.global, so they are Application commands (they act in any panel while the Program Monitor shows the multi-camera view; elsewhere they do nothing). Select Camera 1-9 is the bare digit on both OSes (cmd.multicam.choosenocut.cameraN). Cut to Camera N (cmd.multicam.choose.camera.N) is Ctrl+1-8 on Windows, whose key set has no Ctrl+9, and Control+1-9 on macOS: the physical Control key, written Ctrl in the macOS table. Toggle Multi-Camera View is Shift+0. Premiere's 0 (Toggle Multi-Camera Record) has no counterpart: Wabcut always records switches made while playing. ↩

12. Maximize Frame: The 2026 page shows "Shift +" with the key missing (a backtick lost in rendering); the 2024 page lists Maximize or Restore Active Frame = Shift + `. ↩

13. Track Select Forward Tool: The 2017 print pages call it "Track Select Tool". ↩

14. Track Select Backward Tool: Stated in Adobe's 2026 "Assign multiple keyboard shortcuts to a command" page; not in a shortcut table. ↩

15. Type Tool: Not in any Adobe table (the only "Type Tool | T" row is the Legacy Titler); cmd.tools.12text = T in the Windows and macOS default .kys files. ↩

16. Voice-over recording (A.8, ai.md "Voice-over recording"): no default key, as in Premiere. Checked against both shipped key sets: the macOS set lists cmd.timeline.voiceover.track.record (Voice-over Record, the track header's microphone) in context.timeline with no key, and the Windows set does not list it. A custom .kys that binds it maps to record.toggle. record.start / record.stop are Wabcut's (start only / stop only). While a pass runs, Space (Play/Stop) stops it and keeps the take, as in Premiere. ↩ ↩² ↩³

17. Meter Input(s) Only: On macOS this is the physical Control key (Qt MetaModifier), not Command. ↩

18. Move Selection Left: Premiere's internal name really is cmd.project.movel.eft. ↩

19. Expand All Tracks / Minimize All Tracks (M5i): from Adobe's older tables (the 2017 print pages); the 2024 and 2026 pages no longer list them. Verified in M5j against both shipped key sets: cmd.timeline.expand.all.tracks and cmd.timeline.minimize.all.tracks in context.global (so Application scope), Shift+= and Shift+- on both OSes. ↩ ↩²

20. Next / Previous Sequence Tab (M5i): Wabcut's, not Premiere's (source wabcut in the JSON). Premiere has no default for cycling sequence tabs. On macOS this is the physical Control key (Qt MetaModifier), because Cmd+Tab is the system app switcher. Qt reports Ctrl+Shift+Tab as Ctrl+Shift+Backtab; KeyChord::normalized() folds it. ↩ ↩²