1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

interface UndoableCommand {
    execute(): void;
    undo(): void;
    getDescription(): string;
}
 
class UndoRedoManager {
    private undoStack: UndoableCommand[] = [];
    private redoStack: UndoableCommand[] = [];
    private maxHistorySize: number;
    
    constructor(maxHistorySize: number = 100) {
        this.maxHistorySize = maxHistorySize;
    }
    
    /**
     * Execute a command and add it to the undo history.
     * This clears the redo stack—any "future" is discarded.
     */
    executeCommand(command: UndoableCommand): void {
        command.execute();
        this.undoStack.push(command);
        this.redoStack = []; // Clear redo on new action
        
        // Enforce history size limit
        if (this.undoStack.length > this.maxHistorySize) {
            this.undoStack.shift(); // Remove oldest
        }
    }
    
    /**
     * Undo the most recent command.
     * Moves the command from undo stack to redo stack.
     */
    undo(): boolean {
        const command = this.undoStack.pop();
        if (!command) {
            return false; // Nothing to undo
        }
        
        command.undo();
        this.redoStack.push(command);
        return true;
    }
    
    /**
     * Redo the most recently undone command.
     * Moves the command from redo stack back to undo stack.
     */
    redo(): boolean {
        const command = this.redoStack.pop();
        if (!command) {
            return false; // Nothing to redo
        }
        
        command.execute();
        this.undoStack.push(command);
        return true;
    }
    
    // Query methods for UI
    canUndo(): boolean {
        return this.undoStack.length > 0;
    }
    
    canRedo(): boolean {
        return this.redoStack.length > 0;
    }
    
    getUndoDescription(): string | null {
        const top = this.undoStack[this.undoStack.length - 1];
        return top ? `Undo ${top.getDescription()}` : null;
    }
    
    getRedoDescription(): string | null {
        const top = this.redoStack[this.redoStack.length - 1];
        return top ? `Redo ${top.getDescription()}` : null;
    }
    
    getUndoHistory(): string[] {
        return this.undoStack.map(c => c.getDescription()).reverse();
    }
    
    getRedoHistory(): string[] {
        return this.redoStack.map(c => c.getDescription()).reverse();
    }
    
    clearHistory(): void {
        this.undoStack = [];
        this.redoStack = [];
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

// Only capture what changes—most memory-efficient
class MoveShapeCommand implements UndoableCommand {
    private shape: Shape;
    private dx: number;
    private dy: number;
    private previousX: number = 0;
    private previousY: number = 0;
    
    constructor(shape: Shape, dx: number, dy: number) {
        this.shape = shape;
        this.dx = dx;
        this.dy = dy;
    }
    
    execute(): void {
        // Capture ONLY the affected state
        this.previousX = this.shape.x;
        this.previousY = this.shape.y;
        
        // Apply transformation
        this.shape.x += this.dx;
        this.shape.y += this.dy;
    }
    
    undo(): void {
        // Restore to captured state
        this.shape.x = this.previousX;
        this.shape.y = this.previousY;
    }
    
    getDescription(): string {
        return `Move shape (${this.dx}, ${this.dy})`;
    }
}
 
// For text editing—capture only the deleted text
class DeleteTextCommand implements UndoableCommand {
    private document: TextDocument;
    private start: number;
    private end: number;
    private deletedText: string = "";
    
    constructor(document: TextDocument, start: number, end: number) {
        this.document = document;
        this.start = start;
        this.end = end;
    }
    
    execute(): void {
        // Capture the text that will be deleted
        this.deletedText = this.document.getText(this.start, this.end);
        this.document.delete(this.start, this.end);
    }
    
    undo(): void {
        // Re-insert the captured text
        this.document.insert(this.start, this.deletedText);
    }
    
    getDescription(): string {
        const preview = this.deletedText.length > 20
            ? this.deletedText.substring(0, 20) + "..."
            : this.deletedText;
        return `Delete "${preview}"`;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

// Capture entire object state—simpler but uses more memory
interface Memento {
    getState(): unknown;
    getTimestamp(): Date;
}
 
interface Originator {
    createMemento(): Memento;
    restoreFromMemento(memento: Memento): void;
}
 
class EditorMemento implements Memento {
    private readonly state: string;
    private readonly cursorPosition: number;
    private readonly selectionRange: [number, number] | null;
    private readonly timestamp: Date;
    
    constructor(
        state: string,
        cursorPosition: number,
        selectionRange: [number, number] | null
    ) {
        this.state = state;
        this.cursorPosition = cursorPosition;
        this.selectionRange = selectionRange;
        this.timestamp = new Date();
    }
    
    getState(): { text: string; cursor: number; selection: [number, number] | null } {
        return {
            text: this.state,
            cursor: this.cursorPosition,
            selection: this.selectionRange
        };
    }
    
    getTimestamp(): Date {
        return this.timestamp;
    }
}
 
class TextEditor implements Originator {
    private text: string = "";
    private cursorPosition: number = 0;
    private selectionRange: [number, number] | null = null;
    
    createMemento(): EditorMemento {
        return new EditorMemento(
            this.text,
            this.cursorPosition,
            this.selectionRange
        );
    }
    
    restoreFromMemento(memento: EditorMemento): void {
        const state = memento.getState();
        this.text = state.text;
        this.cursorPosition = state.cursor;
        this.selectionRange = state.selection;
    }
    
    // Editor operations...
    type(char: string): void {
        this.text = 
            this.text.substring(0, this.cursorPosition) +
            char +
            this.text.substring(this.cursorPosition);
        this.cursorPosition++;
    }
}
 
// Command using memento for undo
class EditCommandWithMemento implements UndoableCommand {
    private editor: TextEditor;
    private action: () => void;
    private description: string;
    private beforeMemento?: EditorMemento;
    private afterMemento?: EditorMemento;
    
    constructor(
        editor: TextEditor,
        action: () => void,
        description: string
    ) {
        this.editor = editor;
        this.action = action;
        this.description = description;
    }
    
    execute(): void {
        this.beforeMemento = this.editor.createMemento();
        this.action();
        this.afterMemento = this.editor.createMemento();
    }
    
    undo(): void {
        if (this.beforeMemento) {
            this.editor.restoreFromMemento(this.beforeMemento);
        }
    }
    
    // Note: We could support redo by restoring afterMemento
    // This avoids re-executing the action (useful for non-deterministic ops)
    
    getDescription(): string {
        return this.description;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

// Multiple operations treated as a single undoable unit
class MacroCommand implements UndoableCommand {
    private commands: UndoableCommand[] = [];
    private name: string;
    
    constructor(name: string, commands: UndoableCommand[]) {
        this.name = name;
        this.commands = [...commands];
    }
    
    execute(): void {
        // Execute all sub-commands in order
        for (const command of this.commands) {
            command.execute();
        }
    }
    
    undo(): void {
        // Undo in REVERSE order—critical for correctness!
        for (let i = this.commands.length - 1; i >= 0; i--) {
            this.commands[i].undo();
        }
    }
    
    getDescription(): string {
        return this.name;
    }
}
 
// Usage: Format paragraph (bold + italic + indent)
const formatParagraphMacro = new MacroCommand(
    "Format Paragraph",
    [
        new ApplyBoldCommand(paragraph),
        new ApplyItalicCommand(paragraph),
        new IndentCommand(paragraph, 2),
    ]
);
 
// Single undo reverses all three operations
undoManager.executeCommand(formatParagraphMacro);
undoManager.undo(); // Reverts indent, italic, and bold together

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

// Commands track dependencies to enable safe selective undo
interface SelectiveUndoableCommand extends UndoableCommand {
    getId(): string;
    getDependencies(): string[]; // IDs of commands this depends on
    affectsRegion?(): { start: number; end: number }; // For conflict detection
}
 
class SelectiveUndoManager {
    private history: SelectiveUndoableCommand[] = [];
    private undone: Set<string> = new Set();
    
    executeCommand(command: SelectiveUndoableCommand): void {
        command.execute();
        this.history.push(command);
    }
    
    /**
     * Undo a specific command by ID.
     * Checks for conflicts with subsequent commands.
     */
    undoCommand(commandId: string): { success: boolean; conflicts?: string[] } {
        const index = this.history.findIndex(c => c.getId() === commandId);
        if (index === -1) {
            return { success: false };
        }
        
        const command = this.history[index];
        
        // Check if any subsequent command depends on this one
        const conflicts = this.findConflicts(command, index);
        if (conflicts.length > 0) {
            return { 
                success: false, 
                conflicts: conflicts.map(c => c.getDescription()) 
            };
        }
        
        // Safe to undo
        command.undo();
        this.undone.add(commandId);
        
        return { success: true };
    }
    
    private findConflicts(
        command: SelectiveUndoableCommand,
        index: number
    ): SelectiveUndoableCommand[] {
        const conflicts: SelectiveUndoableCommand[] = [];
        const region = command.affectsRegion?.();
        
        // Check all subsequent commands
        for (let i = index + 1; i < this.history.length; i++) {
            const subsequent = this.history[i];
            
            // Skip if already undone
            if (this.undone.has(subsequent.getId())) {
                continue;
            }
            
            // Check explicit dependency
            if (subsequent.getDependencies().includes(command.getId())) {
                conflicts.push(subsequent);
                continue;
            }
            
            // Check region overlap (for text operations)
            const subsequentRegion = subsequent.affectsRegion?.();
            if (region && subsequentRegion && this.regionsOverlap(region, subsequentRegion)) {
                conflicts.push(subsequent);
            }
        }
        
        return conflicts;
    }
    
    private regionsOverlap(
        a: { start: number; end: number },
        b: { start: number; end: number }
    ): boolean {
        return a.start < b.end && b.start < a.end;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

// Command that coordinates undo across multiple systems
interface DistributedUndoableCommand extends UndoableCommand {
    prepare(): Promise<boolean>;     // Validate undo is possible
    executeDistributed(): Promise<void>; // Execute with rollback support
    undoDistributed(): Promise<void>;
    getParticipants(): string[];     // Systems involved
}
 
class SaveToCloudCommand implements DistributedUndoableCommand {
    private document: Document;
    private localBackup: string = "";
    private cloudBackup: string = "";
    private localPath: string;
    private cloudPath: string;
    private executed: boolean = false;
    
    constructor(document: Document, localPath: string, cloudPath: string) {
        this.document = document;
        this.localPath = localPath;
        this.cloudPath = cloudPath;
    }
    
    async prepare(): Promise<boolean> {
        // Capture current state of both systems
        try {
            this.localBackup = await fs.readFile(this.localPath, 'utf-8');
            this.cloudBackup = await cloudStorage.download(this.cloudPath);
            return true;
        } catch {
            return false;
        }
    }
    
    async executeDistributed(): Promise<void> {
        const content = this.document.serialize();
        
        try {
            // Execute both operations
            await fs.writeFile(this.localPath, content);
            await cloudStorage.upload(this.cloudPath, content);
            this.executed = true;
        } catch (error) {
            // Rollback local if cloud fails
            await fs.writeFile(this.localPath, this.localBackup);
            throw error;
        }
    }
    
    async undoDistributed(): Promise<void> {
        if (!this.executed) return;
        
        // Restore both systems to backed-up state
        await fs.writeFile(this.localPath, this.localBackup);
        await cloudStorage.upload(this.cloudPath, this.cloudBackup);
    }
    
    // ... sync wrappers for standard interface
    execute(): void {
        // In practice, would need to handle async
    }
    
    undo(): void {
        // In practice, would need to handle async
    }
    
    getParticipants(): string[] {
        return ['local-filesystem', 'cloud-storage'];
    }
    
    getDescription(): string {
        return `Save to cloud (${this.cloudPath})`;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

interface CommandDisposable extends UndoableCommand {
    dispose(): void; // Cleanup when evicted from history
}
 
class ProductionUndoManager {
    private undoStack: CommandDisposable[] = [];
    private redoStack: CommandDisposable[] = [];
    private maxUndoLevels: number;
    private maxMemoryBytes: number;
    private currentMemoryUsage: number = 0;
    
    // Event callbacks for UI updates
    private onHistoryChange?: () => void;
    
    constructor(options: {
        maxUndoLevels?: number;
        maxMemoryBytes?: number;
        onHistoryChange?: () => void;
    } = {}) {
        this.maxUndoLevels = options.maxUndoLevels ?? 100;
        this.maxMemoryBytes = options.maxMemoryBytes ?? 50 * 1024 * 1024; // 50MB
        this.onHistoryChange = options.onHistoryChange;
    }
    
    executeCommand(command: CommandDisposable, sizeBytes: number = 0): void {
        command.execute();
        
        this.undoStack.push(command);
        this.currentMemoryUsage += sizeBytes;
        
        // Clear redo and dispose redo commands
        for (const redoCommand of this.redoStack) {
            redoCommand.dispose();
        }
        this.redoStack = [];
        
        // Enforce limits
        this.enforceHistoryLimits();
        
        this.notifyChange();
    }
    
    private enforceHistoryLimits(): void {
        // Enforce count limit
        while (this.undoStack.length > this.maxUndoLevels) {
            const oldest = this.undoStack.shift();
            oldest?.dispose();
        }
        
        // Enforce memory limit (simplified—real impl would track per-command size)
        while (this.currentMemoryUsage > this.maxMemoryBytes && this.undoStack.length > 1) {
            const oldest = this.undoStack.shift();
            oldest?.dispose();
            // Would subtract this command's size from currentMemoryUsage
        }
    }
    
    undo(levels: number = 1): number {
        let undone = 0;
        
        for (let i = 0; i < levels; i++) {
            const command = this.undoStack.pop();
            if (!command) break;
            
            command.undo();
            this.redoStack.push(command);
            undone++;
        }
        
        if (undone > 0) {
            this.notifyChange();
        }
        
        return undone;
    }
    
    redo(levels: number = 1): number {
        let redone = 0;
        
        for (let i = 0; i < levels; i++) {
            const command = this.redoStack.pop();
            if (!command) break;
            
            command.execute();
            this.undoStack.push(command);
            redone++;
        }
        
        if (redone > 0) {
            this.notifyChange();
        }
        
        return redone;
    }
    
    // Jump to specific point in history
    undoTo(targetUndoDepth: number): void {
        const currentDepth = this.undoStack.length;
        if (targetUndoDepth < currentDepth) {
            this.undo(currentDepth - targetUndoDepth);
        } else if (targetUndoDepth > currentDepth) {
            this.redo(targetUndoDepth - currentDepth);
        }
    }
    
    // Clear all history and dispose commands
    clearHistory(): void {
        for (const command of [...this.undoStack, ...this.redoStack]) {
            command.dispose();
        }
        this.undoStack = [];
        this.redoStack = [];
        this.currentMemoryUsage = 0;
        this.notifyChange();
    }
    
    // History query methods for UI
    getHistorySnapshot(): {
        undoDescriptions: string[];
        redoDescriptions: string[];
        canUndo: boolean;
        canRedo: boolean;
    } {
        return {
            undoDescriptions: this.undoStack.map(c => c.getDescription()),
            redoDescriptions: this.redoStack.map(c => c.getDescription()).reverse(),
            canUndo: this.undoStack.length > 0,
            canRedo: this.redoStack.length > 0,
        };
    }
    
    private notifyChange(): void {
        this.onHistoryChange?.();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

class CheckpointUndoManager<TState> {
    private checkpoints: Array<{
        state: TState;
        timestamp: Date;
        commandIndex: number;
    }> = [];
    private commands: UndoableCommand[] = [];
    private currentIndex: number = -1;
    private checkpointInterval: number = 50; // Checkpoint every 50 commands
    
    private cloneState: (state: TState) => TState;
    private applyCommand: (state: TState, command: UndoableCommand) => TState;
    private currentState: TState;
    
    constructor(
        initialState: TState,
        cloneState: (state: TState) => TState,
        applyCommand: (state: TState, command: UndoableCommand) => TState
    ) {
        this.currentState = cloneState(initialState);
        this.cloneState = cloneState;
        this.applyCommand = applyCommand;
        
        // Create initial checkpoint
        this.createCheckpoint();
    }
    
    executeCommand(command: UndoableCommand): void {
        // Remove any redo history
        this.commands = this.commands.slice(0, this.currentIndex + 1);
        
        // Execute and record
        command.execute();
        this.commands.push(command);
        this.currentIndex++;
        
        // Create checkpoint if needed
        if (this.currentIndex % this.checkpointInterval === 0) {
            this.createCheckpoint();
            this.pruneOldCommands();
        }
    }
    
    private createCheckpoint(): void {
        this.checkpoints.push({
            state: this.cloneState(this.currentState),
            timestamp: new Date(),
            commandIndex: this.currentIndex,
        });
    }
    
    private pruneOldCommands(): void {
        // Keep last 2 checkpoints, discard older commands
        if (this.checkpoints.length > 2) {
            const oldestKeep = this.checkpoints[this.checkpoints.length - 2];
            // Commands older than oldestKeep can be discarded
            // (In practice, need to adjust indices)
        }
    }
    
    undoTo(targetIndex: number): void {
        if (targetIndex < -1 || targetIndex >= this.commands.length) {
            return;
        }
        
        if (targetIndex < this.currentIndex) {
            // Going backward: find nearest checkpoint, then replay
            const checkpoint = this.findNearestCheckpoint(targetIndex);
            this.currentState = this.cloneState(checkpoint.state);
            
            // Replay commands from checkpoint to target
            for (let i = checkpoint.commandIndex + 1; i <= targetIndex; i++) {
                this.currentState = this.applyCommand(
                    this.currentState,
                    this.commands[i]
                );
            }
        } else {
            // Going forward: replay from current
            for (let i = this.currentIndex + 1; i <= targetIndex; i++) {
                this.currentState = this.applyCommand(
                    this.currentState,
                    this.commands[i]
                );
            }
        }
        
        this.currentIndex = targetIndex;
    }
    
    private findNearestCheckpoint(
        targetIndex: number
    ): { state: TState; timestamp: Date; commandIndex: number } {
        // Find checkpoint at or before targetIndex
        for (let i = this.checkpoints.length - 1; i >= 0; i--) {
            if (this.checkpoints[i].commandIndex <= targetIndex) {
                return this.checkpoints[i];
            }
        }
        return this.checkpoints[0];
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

interface CollaborativeCommand {
    id: string;
    userId: string;
    timestamp: number;
    execute(): void;
    undo(): void;
    transform(other: CollaborativeCommand): CollaborativeCommand;
    getDescription(): string;
}
 
class CollaborativeUndoManager {
    private globalHistory: CollaborativeCommand[] = [];
    private userUndoStacks: Map<string, CollaborativeCommand[]> = new Map();
    private userRedoStacks: Map<string, CollaborativeCommand[]> = new Map();
    
    executeCommand(command: CollaborativeCommand): void {
        command.execute();
        this.globalHistory.push(command);
        
        // Add to this user's undo stack
        let userStack = this.userUndoStacks.get(command.userId);
        if (!userStack) {
            userStack = [];
            this.userUndoStacks.set(command.userId, userStack);
        }
        userStack.push(command);
        
        // Clear this user's redo
        this.userRedoStacks.set(command.userId, []);
    }
    
    undoForUser(userId: string): boolean {
        const userStack = this.userUndoStacks.get(userId);
        if (!userStack || userStack.length === 0) {
            return false;
        }
        
        const commandToUndo = userStack.pop()!;
        
        // The key challenge: commandToUndo may have been transformed
        // by subsequent operations from other users.
        // We need to compute the "current" version of this undo.
        
        const transformedUndo = this.computeCurrentUndoEffect(commandToUndo);
        transformedUndo.undo();
        
        // Track for redo
        let redoStack = this.userRedoStacks.get(userId);
        if (!redoStack) {
            redoStack = [];
            this.userRedoStacks.set(userId, redoStack);
        }
        redoStack.push(commandToUndo);
        
        return true;
    }
    
    /**
     * Transform the undo operation against all subsequent operations.
     * This is where Operational Transformation (OT) or CRDT logic applies.
     */
    private computeCurrentUndoEffect(
        originalCommand: CollaborativeCommand
    ): CollaborativeCommand {
        const originalIndex = this.globalHistory.indexOf(originalCommand);
        let currentCommand = originalCommand;
        
        // Transform against all subsequent operations
        for (let i = originalIndex + 1; i < this.globalHistory.length; i++) {
            const subsequent = this.globalHistory[i];
            if (subsequent.userId !== originalCommand.userId) {
                currentCommand = currentCommand.transform(subsequent);
            }
        }
        
        return currentCommand;
    }
}
 
// Example: Transform insert position after another insert
class InsertTextOT implements CollaborativeCommand {
    id: string;
    userId: string;
    timestamp: number;
    private document: TextDocument;
    private position: number;
    private text: string;
    
    constructor(
        userId: string,
        document: TextDocument,
        position: number,
        text: string
    ) {
        this.id = crypto.randomUUID();
        this.userId = userId;
        this.timestamp = Date.now();
        this.document = document;
        this.position = position;
        this.text = text;
    }
    
    execute(): void {
        this.document.insert(this.position, this.text);
    }
    
    undo(): void {
        this.document.delete(this.position, this.position + this.text.length);
    }
    
    /**
     * Transform this operation against a concurrent operation.
     * Returns a new command that achieves the same intent
     * assuming 'other' has already been applied.
     */
    transform(other: CollaborativeCommand): CollaborativeCommand {
        if (other instanceof InsertTextOT) {
            // If other inserted before our position, shift our position
            if (other.position <= this.position) {
                return new InsertTextOT(
                    this.userId,
                    this.document,
                    this.position + other.text.length, // Shifted!
                    this.text
                );
            }
        }
        return this; // No transformation needed
    }
    
    getDescription(): string {
        return `Insert "${this.text}" at ${this.position}`;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

interface CoalescingPolicy {
    shouldCoalesce(current: UndoableCommand, next: UndoableCommand): boolean;
    coalesce(commands: UndoableCommand[]): UndoableCommand;
}
 
class TypingCoalescer implements CoalescingPolicy {
    private maxTimeDiff = 1000; // 1 second
    
    shouldCoalesce(
        current: UndoableCommand,
        next: UndoableCommand
    ): boolean {
        // Only coalesce typing commands
        if (!(current instanceof TypeCharCommand) ||
            !(next instanceof TypeCharCommand)) {
            return false;
        }
        
        // Check if they're consecutive positions
        if (next.position !== current.position + current.text.length) {
            return false;
        }
        
        // Check if within time window
        if (next.timestamp - current.timestamp > this.maxTimeDiff) {
            return false;
        }
        
        return true;
    }
    
    coalesce(commands: UndoableCommand[]): UndoableCommand {
        const typingCommands = commands as TypeCharCommand[];
        const first = typingCommands[0];
        const combinedText = typingCommands.map(c => c.text).join('');
        
        return new InsertTextCommand(
            first.document,
            first.position,
            combinedText
        );
    }
}
 
class CoalescingUndoManager {
    private pendingCommand: UndoableCommand | null = null;
    private coalescingPolicy: CoalescingPolicy;
    private baseManager: UndoRedoManager;
    private flushTimeout: NodeJS.Timeout | null = null;
    
    constructor(
        policy: CoalescingPolicy,
        baseManager: UndoRedoManager
    ) {
        this.coalescingPolicy = policy;
        this.baseManager = baseManager;
    }
    
    executeCommand(command: UndoableCommand): void {
        command.execute();
        
        if (this.pendingCommand &&
            this.coalescingPolicy.shouldCoalesce(this.pendingCommand, command)) {
            // Coalesce with pending
            this.pendingCommand = this.coalescingPolicy.coalesce([
                this.pendingCommand,
                command
            ]);
        } else {
            // Flush pending and start new
            this.flush();
            this.pendingCommand = command;
        }
        
        // Auto-flush after a delay
        if (this.flushTimeout) {
            clearTimeout(this.flushTimeout);
        }
        this.flushTimeout = setTimeout(() => this.flush(), 500);
    }
    
    flush(): void {
        if (this.pendingCommand) {
            this.baseManager.executeCommand(this.pendingCommand);
            this.pendingCommand = null;
        }
    }
    
    undo(): boolean {
        this.flush();
        return this.baseManager.undo();
    }
}