Manual — undo & history

One list of what changed, for the whole desk.

The console keeps a journal of the changes made to it: one entry per gesture, in plain sentences, with who made it and when. Ctrl+Z walks back through it, and any single entry can be taken back on its own without disturbing the ones after it. What the journal deliberately does not hold is as important as what it does.

One console, one journal.

The journal belongs to the desk, not to your screen. Every surface writing to the console — the laptop at front of house, the tablet on the wing, a control surface, a script — appends to the same list, so your Ctrl+Z can walk back the change somebody else just made.

That is the point rather than a hazard, and the list is what makes it safe: each entry says where it came from before you press anything. An entry made on a surface names the surface, one made by a REST client names the client’s address, and an entry that is itself an undo says that too.

It holds the last 512 changes and the panel says so at the foot of the list. The bound is a count and not a span of time, because a quiet passage should not cost you the history of the noisy one before it.

The journal is not saved. It lives for as long as the console is running, and a restart starts a fresh one — an entry remembers what a field read a moment ago, which is a claim only the running process can make honestly.

What an entry says.

An entry is one sentence: what was changed, then what it read before and what it reads now. Channels are named the way the rest of the desk names them — CH3, Aux2, Main — levels carry one decimal, and a switch reads on or off.

CH3 fader −6.0 → −12.0
A fader move. One drag is one entry, not forty.
CH1 phantom power off → on
A discrete change: the two values are the words the control uses.
CH3 → Aux1 send −20.0 → −14.0
A send names both ends, because “send” alone would not say which.
Paste onto 8 channels
One gesture that touched eight strips is one entry, and reverts as one.
Strip order
A reorder has no before-and-after worth printing, so it prints neither.

A drag is one entry. While you are moving a fader the console keeps folding the movement into the entry it already opened, keeping the value you started from and the value you are at now, and seals it half a second after you stop. Two separate nudges a second apart are two entries, and CH3’s fader never folds into CH4’s.

The sentence is built on your screen, in your language, from a change the console describes rather than a phrase it writes — so the same entry reads as a sentence in Catalan, Spanish or English depending on who is looking at it.

Undo, redo, and where the cursor sits.

The undo and redo buttons live in the header, and each one names what it would hit before you press it — Undo: CH3 fader rather than an arrow with no object. The keys are Ctrl+Z, Ctrl+Shift+Z and Ctrl+Y, and they do nothing while you are typing in a field.

Undo and redo move a cursor through the one list; they do not add to it. Entries below the cursor are the ones the desk is currently sounding; entries above it are undone and stay in the list, dimmed and struck through, because redo is one press away. The foot of the panel counts how many are in that state.

Making any new change from an undone position drops the undone entries — the ordinary rule, and the reason the panel shows them struck through rather than hiding them: you can see what you are about to lose.

Taking back one change out of the middle.

Every entry in the list carries an Undo this button. It writes exactly one field — the one that entry addressed — back to the value the entry started from. Nothing else moves. Move a fader, mute another channel, pan a third, then take back the fader: the fader returns and the mute and the pan stay where they are.

A revert is a change like any other, so it appends its own entry, marked as having come from the history rather than from a surface. The list grows by one; it never rewrites itself.

There is no entry in the list you cannot take back. Anything that must never be replayed never became an entry in the first place — which is the next section.

When the field has moved since.

An entry can be minutes old, and in that time somebody else — or a later gesture of your own — may have moved the same control. Taking the entry back would then jump the field from a value nobody expects to another value nobody asked for, so the console asks first:

This has changed since — db reads −3.0 now, not the −12.0 this step left (changed by entry 47).

Go back anyway makes the write. Leave it does nothing. Both the header’s buttons and the list’s rows draw the offer in space they already reserve, so nothing under your finger moves when it appears. A jump-back taken from a row in the list records in its new entry that it went over the later one, so the list says a jump-back happened and what it jumped over.

Ctrl+Z asks the same question. The top of the list is compared before it is replayed, exactly as a row in the list is compared when you click it, and redo compares the value its own undo left standing. One question, three doors: if the field still reads what the step left, the walk goes through without a word; if it does not, you get the offer and nothing is written until you answer it.

The console never takes that decision for you and never retries behind your back. If the desk moves again while the question is on screen, the offer is dropped rather than answered against a value that has gone stale.

What the journal never holds.

The gig-safety controls are not in the list at all. No entry, no address, no refusal — the list simply never mentions them:

Mute, solo and solo-safe.
Cue, the monitor, talkback and dim.
A spare’s hold.
Recall safe.

A list with a per-entry revert is a more dangerous thing than a single Ctrl+Z: it can reach back past everything that happened since. Undoing a spare swap puts a dead microphone back on a channel; undoing a mute opens one you closed for a reason. These controls are one press to set and one press to clear, and that is the whole recovery they need.

Changes the console makes on its own account are also absent — recalling a scene, loading a session, healing a route, a control surface re-driving itself. The list is what people did to the desk.

Meters, RTA and telemetry never appear: they are measurements, not settings.

What empties it.

Loading a show empties the journal, and so does anything else that restates the desk wholesale: recalling a scene, loading a session or a patch, applying a channel config, saving or deleting one, and resizing the console. After one of those the list starts again from empty.

That is deliberate. Those actions rewrite hundreds of facts at once, and a list that offered to take one of them back out of the middle would be offering something it cannot honestly do. The way back from a load is the autosave the console takes before it, which is its own mechanism.

The list itself is /history, the cursor is /history/cursor, and a single entry is taken back at /history/entries/{id}/revert. All three doors — that one and /history/cursor/undo and /history/cursor/redo — take the same override argument, and every fire spells it out: a client that has to write false cannot mean true by accident. Fields, ranges and the refusals each can send back are in the REST reference and the refusal and undo-label codes.