Undo/Redo Functionality in JSON Editors

• Undo: Ctrl+Z on Windows/Linux and Cmd+Z on macOS.
• Redo: Cmd+Shift+Z on macOS, and usually Ctrl+Shift+Z in browser-based editors. Some Windows apps also support Ctrl+Y.
• Redo stops working after a new edit: that is normal. Most editors clear the redo branch as soon as you type, paste, or modify the document after an undo.
• Format and minify should be reversible: ideally as one undo step, not hundreds. If they are not, the editor is handling history poorly.

Expected Undoable Actions

• Typing and deleting: normal text edits, backspace, paste, cut, and replacing selections.
• Structural edits: adding or removing keys, moving array items, changing values, and fixing commas or brackets.
• Whole-document actions: format, minify, sort keys, normalize spacing, or repair minor syntax issues should usually appear as a single history step.
• Import and replace actions: opening a file or pasting new JSON should either create one clear history checkpoint or warn that the previous history will be lost.

What Current Browser and Editor Behavior Means

• Modern browsers expose undo and redo related input events such as historyUndo and historyRedo, but the web app still has to integrate those events cleanly into its own editor model.
• Code editor engines usually group nearby edits together instead of storing every keystroke as a separate undo step. That is why one undo often reverses a short burst of typing rather than one character.
• Whole-document operations are the hardest case. If an editor rewrites the full JSON string in one program step, native browser history may reset unless the tool deliberately preserves or recreates the undo stack.

In current CodeMirror builds, adjacent edits are grouped by default within a short time window, which is useful for typing but can surprise users who expect character-by-character undo.

Common Shortcut Patterns

• Windows/Linux: Ctrl+Z usually undoes the last change. For redo, try Ctrl+Shift+Z first in web editors, then Ctrl+Y if the tool is behaving more like a traditional desktop app.
• macOS: Cmd+Z for undo and Cmd+Shift+Z for redo is the expected pattern.
• Toolbar buttons: good editors mirror the keyboard behavior with undo and redo buttons that disable when no history is available.

Common Reasons

• You made a new edit after undo: this is the most common cause. A new keystroke, paste, or formatting action usually clears the redo stack.
• The app replaced the entire document: importing a file, reloading data, prettifying, minifying, or applying a repair step may rebuild the full JSON buffer and drop native history.
• Focus moved away from the editor: the shortcut may be reaching the browser, a modal, or another input field instead of the JSON editor itself.
• The editor caps history for performance: very large JSON documents can force tools to limit snapshot depth or compress history aggressively.

Starting JSON

{
  "service":"billing","retry":3,"timeout":30,"features":{"audit":true}
}

Actions Taken

1. Click Format so the JSON becomes readable.
2. Change "timeout" from 30 to 300.
3. Accidentally remove the "retry" key.

Expected Undo Sequence

• The first undo should restore the deleted "retry" entry.
• The second undo should restore "timeout": 30.
• The third undo should usually revert the formatting pass as one single action, returning to the compact version you started with.
• Redo should then move forward through those same steps in order, until you make a fresh edit.

Formatted State After Step 2

{
  "service": "billing",
  "retry": 3,
  "timeout": 300,
  "features": {
    "audit": true
  }
}

• Undo does nothing: click inside the editor first. Browser shortcuts only affect the currently focused control.
• Undo removes too much at once: the editor is probably grouping nearby edits into one history event. That is normal in many code editors.
• History vanished after paste, format, or import: the tool likely replaced the entire document programmatically instead of preserving the existing history.
• Behavior feels inconsistent in the browser: some browser-driven changes, such as autocomplete, spell correction, password managers, or IME flows, do not always behave like ordinary keystrokes in web editor history.
• Large files feel fragile: use checkpoints before bulk transforms. Some editors shorten history depth on large JSON to control memory usage.