@likec4/diagram 1.57.0 → 1.58.0

package/dist/editor/actor/actions.d.ts

@@ -1,23 +1,18 @@
-import { ActorSystem, ActionFunction, CancelAction, PromiseActorLogic, EventObject, NonReducibleUnknown } from 'xstate';
-import { DiagramMachineRef } from '../../likec4diagram/state/machine';
-import { Snapshot, EditorActorContext, EditorActorEvent, EditorActorEmitedEvent } from './types';
+import { ActorSystem, ActionFunction, CancelAction, PromiseActorLogic, EventObject } from 'xstate';
+import { Snapshot, SyncOp, EditorActorContext, EditorActorEvent, EditorActorEmitedEvent } from './types';
 import { HotkeyActorLogic } from './hotkey';
 import type * as t from '@likec4/core/types';
-/**
- * Actually this is DiagramActorRef
- * But we can't use it here due to circular type inference
- */
-export declare const diagramActorRef: (system: ActorSystem<any>) => DiagramMachineRef;
 export declare function makeSnapshot(system: ActorSystem<any>): Snapshot;
 type LayoutChanges = t.ViewChange.ResetManualLayout | t.ViewChange.SaveViewSnapshot;
 export declare const isLayoutChange: (change: t.ViewChange) => change is LayoutChanges;
+export declare const isLayoutChangeOp: <T extends SyncOp>(op: T) => op is Extract<T, string | LayoutChanges>;
 export declare const withoutSnapshotChanges: (data: t.ViewChange[]) => (t.ViewChange.ChangeElementStyle | t.ViewChange.ChangeAutoLayout | t.ViewChange.ChangeProperty)[];
 export declare const scheduleSync: (delay?: number) => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, never, never, never, "500ms" | "wait-after-edit", never>;
 export declare const cancelSync: () => CancelAction<EditorActorContext, EditorActorEvent, undefined, EditorActorEvent>;
 /**
  * Save the state before editing starts
  */
-export declare const saveBeforeEditing: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
+export declare const saveBeforeEditing: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
     src: "hotkey";
     logic: HotkeyActorLogic;
     id: "hotkey";
@@ -27,7 +22,7 @@ export declare const saveBeforeEditing: ActionFunction<EditorActorContext, Edito
     id: string | undefined;
 } | {
     src: "executeChange";
-    logic: PromiseActorLogic<NonReducibleUnknown, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
+    logic: PromiseActorLogic<import("./setup").EditorCalls.ExecuteChange.Output, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
     id: string | undefined;
 } | {
     src: "applySemanticLayout";
@@ -47,13 +42,22 @@ export declare const pushHistory: () => ActionFunction<EditorActorContext, Edito
     id: string | undefined;
 } | {
     src: "executeChange";
-    logic: PromiseActorLogic<NonReducibleUnknown, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
+    logic: PromiseActorLogic<import("./setup").EditorCalls.ExecuteChange.Output, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
     id: string | undefined;
 } | {
     src: "applySemanticLayout";
     logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
     id: string | undefined;
-}, never, never, never, never>;
+}, never, {
+    type: "has pending";
+    params: unknown;
+} | {
+    type: "can undo";
+    params: unknown;
+} | {
+    type: "can redo";
+    params: unknown;
+}, "500ms" | "wait-after-edit", EditorActorEmitedEvent>;
 export declare const reschedule: (delay?: number) => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, never, never, never, "500ms" | "wait-after-edit", never>;
 export declare const undo: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
     src: "hotkey";
@@ -65,7 +69,59 @@ export declare const undo: () => ActionFunction<EditorActorContext, EditorActorE
     id: string | undefined;
 } | {
     src: "executeChange";
-    logic: PromiseActorLogic<NonReducibleUnknown, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
+    logic: PromiseActorLogic<import("./setup").EditorCalls.ExecuteChange.Output, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
+    id: string | undefined;
+} | {
+    src: "applySemanticLayout";
+    logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
+    id: string | undefined;
+}, never, {
+    type: "has pending";
+    params: unknown;
+} | {
+    type: "can undo";
+    params: unknown;
+} | {
+    type: "can redo";
+    params: unknown;
+}, "500ms" | "wait-after-edit", EditorActorEmitedEvent>;
+export declare const redo: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
+    src: "hotkey";
+    logic: HotkeyActorLogic;
+    id: "hotkey";
+} | {
+    src: "applyLatest";
+    logic: PromiseActorLogic<import("./setup").EditorCalls.ApplyLatestToManual.Output, import("./setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
+    id: string | undefined;
+} | {
+    src: "executeChange";
+    logic: PromiseActorLogic<import("./setup").EditorCalls.ExecuteChange.Output, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
+    id: string | undefined;
+} | {
+    src: "applySemanticLayout";
+    logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
+    id: string | undefined;
+}, never, {
+    type: "has pending";
+    params: unknown;
+} | {
+    type: "can undo";
+    params: unknown;
+} | {
+    type: "can redo";
+    params: unknown;
+}, "500ms" | "wait-after-edit", EditorActorEmitedEvent>;
+export declare const deleteNodesAndEdges: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
+    src: "hotkey";
+    logic: HotkeyActorLogic;
+    id: "hotkey";
+} | {
+    src: "applyLatest";
+    logic: PromiseActorLogic<import("./setup").EditorCalls.ApplyLatestToManual.Output, import("./setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
+    id: string | undefined;
+} | {
+    src: "executeChange";
+    logic: PromiseActorLogic<import("./setup").EditorCalls.ExecuteChange.Output, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
     id: string | undefined;
 } | {
     src: "applySemanticLayout";
@@ -77,6 +133,9 @@ export declare const undo: () => ActionFunction<EditorActorContext, EditorActorE
 } | {
     type: "can undo";
     params: unknown;
+} | {
+    type: "can redo";
+    params: unknown;
 }, "500ms" | "wait-after-edit", EditorActorEmitedEvent>;
 export declare const pushToSyncQueue: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
     src: "hotkey";
@@ -88,7 +147,7 @@ export declare const pushToSyncQueue: () => ActionFunction<EditorActorContext, E
     id: string | undefined;
 } | {
     src: "executeChange";
-    logic: PromiseActorLogic<NonReducibleUnknown, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
+    logic: PromiseActorLogic<import("./setup").EditorCalls.ExecuteChange.Output, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
     id: string | undefined;
 } | {
     src: "applySemanticLayout";
@@ -105,7 +164,7 @@ export declare const clearQueue: () => ActionFunction<EditorActorContext, Editor
     id: string | undefined;
 } | {
     src: "executeChange";
-    logic: PromiseActorLogic<NonReducibleUnknown, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
+    logic: PromiseActorLogic<import("./setup").EditorCalls.ExecuteChange.Output, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
     id: string | undefined;
 } | {
     src: "applySemanticLayout";

package/dist/editor/actor/actions.js

@@ -2,7 +2,6 @@ import "../../_virtual/_rolldown/runtime.js";
 import { machine } from "./setup.js";
 import { createViewChange } from "../../likec4diagram/state/createViewChange.js";
 import { typedSystem } from "../../likec4diagram/state/utils.js";
-import { isViewChange } from "./types.js";
 import { filter, isNot, omit } from "remeda";
 import { assertEvent } from "xstate";
 //#region src/editor/actor/actions.ts
@@ -40,6 +39,7 @@ function makeSnapshot(system) {
 	};
 }
 var isLayoutChange = (change) => change.op === "reset-manual-layout" || change.op === "save-view-snapshot";
+var isLayoutChangeOp = (op) => op === "apply-latest-to-manual" || op === "apply-semantic-layout" || op === "sync-snapshot" || isLayoutChange(op);
 filter(isNot(isLayoutChange));
 var scheduleSync = (delay = 50) => {
 	return machine.raise({ type: "change.sync-snapshot" }, delay ? {
@@ -47,10 +47,13 @@ var scheduleSync = (delay = 50) => {
 		id: "sync-snapshot"
 	} : void 0);
 };
+var cancelSync = () => {
+	return machine.cancel("sync-snapshot");
+};
 /**
 * Save the state before editing starts
 */
-var saveBeforeEditing = machine.assign(({ system, event }) => {
+var saveBeforeEditing = () => machine.assign(({ system, event }) => {
 	assertEvent(event, "edit.move.start");
 	return { editing: {
 		subject: event.subject,
@@ -60,22 +63,52 @@ var saveBeforeEditing = machine.assign(({ system, event }) => {
 /**
 * When editing finishes, push the "beforeEditing" state to the history stack
 */
-var pushHistory = () => machine.assign(({ context }) => {
+var pushHistory = () => machine.enqueueActions(({ context, enqueue }) => {
 	const editing = context.editing;
-	if (editing) return {
-		editing: null,
-		history: {
-			head: editing.before,
-			tail: context.history
-		}
-	};
-	return {};
+	if (editing) {
+		enqueue.assign({
+			editing: null,
+			history: {
+				head: editing.before,
+				tail: context.history
+			},
+			redo: null
+		});
+		enqueue(scheduleSync());
+	}
 });
-var reschedule = (delay = 300) => machine.raise(({ event }) => ({ ...event }), { delay });
-var undo = () => machine.enqueueActions(({ context: { history }, enqueue }) => {
+var undo = () => machine.enqueueActions(({ context: { history, redo }, system, enqueue }) => {
 	if (!history) return;
 	const last = history.head;
-	enqueue.assign({ history: history.tail });
+	enqueue.assign({
+		history: history.tail,
+		redo: {
+			head: makeSnapshot(system),
+			tail: redo
+		}
+	});
+	enqueue(cancelSync());
+	enqueue(scheduleSync(100));
+	enqueue.sendTo(typedSystem.diagramActor, {
+		type: "update.view",
+		view: last.view,
+		xyedges: last.xyedges,
+		xynodes: last.xynodes,
+		source: "editor"
+	});
+});
+var redo = () => machine.enqueueActions(({ context: { history, redo }, system, enqueue }) => {
+	if (!redo) return;
+	const last = redo.head;
+	enqueue.assign({
+		history: {
+			head: makeSnapshot(system),
+			tail: history
+		},
+		redo: redo.tail
+	});
+	enqueue(cancelSync());
+	enqueue(scheduleSync(100));
 	enqueue.sendTo(typedSystem.diagramActor, {
 		type: "update.view",
 		view: last.view,
@@ -83,13 +116,41 @@ var undo = () => machine.enqueueActions(({ context: { history }, enqueue }) => {
 		xynodes: last.xynodes,
 		source: "editor"
 	});
-	enqueue.cancel("undo-view");
-	enqueue.raise({
-		type: "change.view",
-		change: last.change
-	}, {
-		delay: 200,
-		id: "undo-view"
+});
+var deleteNodesAndEdges = () => machine.enqueueActions(({ context, system, event, enqueue }) => {
+	assertEvent(event, "delete.nodes-edges");
+	const deletedNodeIds = new Set(event.nodeIds);
+	const willNotBeDeletedNode = (node) => !deletedNodeIds.has(typeof node === "string" ? node : node.id);
+	const snapshot = makeSnapshot(system);
+	const deletedEdgeIds = new Set(event.edgeIds);
+	for (const edge of snapshot.view.edges) if (deletedNodeIds.has(edge.source) || deletedNodeIds.has(edge.target)) deletedEdgeIds.add(edge.id);
+	const willNotBeDeletedEdge = (edge) => !deletedEdgeIds.has(typeof edge === "string" ? edge : edge.id);
+	enqueue.assign({
+		history: {
+			head: snapshot,
+			tail: context.history
+		},
+		redo: null
+	});
+	const cleanupNode = (node) => {
+		if (node.children.every(willNotBeDeletedNode) && node.inEdges.every(willNotBeDeletedEdge) && node.outEdges.every(willNotBeDeletedEdge)) return node;
+		return {
+			...node,
+			children: node.children.filter(willNotBeDeletedNode),
+			inEdges: node.inEdges.filter(willNotBeDeletedEdge),
+			outEdges: node.outEdges.filter(willNotBeDeletedEdge)
+		};
+	};
+	enqueue(cancelSync());
+	enqueue(scheduleSync());
+	enqueue.sendTo(typedSystem.diagramActor, {
+		type: "update.view",
+		view: {
+			...snapshot.view,
+			nodes: snapshot.view.nodes.filter(willNotBeDeletedNode).map(cleanupNode),
+			edges: snapshot.view.edges.filter(willNotBeDeletedEdge)
+		},
+		source: "editor"
 	});
 });
 var pushToSyncQueue = () => machine.assign(({ context: { syncQueue }, event }) => {
@@ -102,7 +163,7 @@ var pushToSyncQueue = () => machine.assign(({ context: { syncQueue }, event }) =
 			nextOp = "apply-semantic-layout";
 			break;
 		case "change.latest-to-manual":
-			nextOp = "apply-semantic-layout";
+			nextOp = "apply-latest-to-manual";
 			break;
 		case "change.sync-snapshot":
 			nextOp = "sync-snapshot";
@@ -110,13 +171,18 @@ var pushToSyncQueue = () => machine.assign(({ context: { syncQueue }, event }) =
 		default: throw new Error(`Invalid event type: ${event.type}`);
 	}
 	if (syncQueue.length === 0) return { syncQueue: [nextOp] };
-	const isNextLayoutChange = isViewChange(nextOp) && isLayoutChange(nextOp);
+	if (syncQueue.length === 1 && syncQueue[0] === nextOp) return {};
+	const isNextLayoutChange = isLayoutChangeOp(nextOp);
 	let pending = syncQueue.filter((existingOp) => {
 		if (existingOp === nextOp) return false;
-		if (isNextLayoutChange && isViewChange(existingOp) && isLayoutChange(existingOp)) return false;
+		if (isNextLayoutChange && isLayoutChangeOp(existingOp)) return false;
 		return true;
 	});
 	return { syncQueue: pending.length > 0 ? [...pending, nextOp] : [nextOp] };
 });
+var clearQueue = () => machine.assign({
+	syncQueue: [],
+	processing: null
+});
 //#endregion
-export { makeSnapshot, pushHistory, pushToSyncQueue, reschedule, saveBeforeEditing, scheduleSync, undo };
+export { cancelSync, clearQueue, deleteNodesAndEdges, makeSnapshot, pushHistory, pushToSyncQueue, redo, saveBeforeEditing, scheduleSync, undo };

package/dist/editor/actor/hotkey.d.ts

@@ -1,6 +1,6 @@
 import { AnyEventObject, CallbackActorLogic, NonReducibleUnknown } from 'xstate';
 export type HotKeyEvent = {
-    type: 'undo';
+    type: 'undo' | 'redo';
 };
 export interface HotkeyActorLogic extends CallbackActorLogic<AnyEventObject, NonReducibleUnknown, HotKeyEvent> {
 }

package/dist/editor/actor/hotkey.js

@@ -10,6 +10,13 @@ var hotkey = fromCallback(({ sendBack }) => {
 			sendBack({ type: "undo" });
 		},
 		{ preventDefault: true }
+	], [
+		"mod + shift + z",
+		(event) => {
+			event.stopPropagation();
+			sendBack({ type: "redo" });
+		},
+		{ preventDefault: true }
 	]]);
 	document.body.addEventListener("keydown", ctrlZHandler, { capture: true });
 	return () => {

package/dist/editor/actor/machine.d.ts

@@ -1,5 +1,5 @@
 import { ActorRef, SnapshotFrom, StateMachine } from 'xstate';
-import { EditorActorEvent, EditorActorContext, EditorActorEmitedEvent, EditorActorInput, EditorActorStateTag } from './types';
+import { EditorActorContext, EditorActorEmitedEvent, EditorActorEvent, EditorActorInput, EditorActorStateTag } from './types';
 export interface EditorActorLogic extends StateMachine<EditorActorContext, EditorActorEvent, any, any, any, any, any, {
     editor: 'idle' | 'moving';
     syncQueue: 'idle' | 'pending' | 'suspended' | 'process';

package/dist/editor/actor/machine.js

@@ -8,6 +8,7 @@ var editorActorLogic = machine.createMachine({
 		viewId: input.viewId,
 		editing: null,
 		history: null,
+		redo: null,
 		pending: null,
 		syncQueue: [],
 		processing: null

package/dist/editor/actor/setup.d.ts

@@ -1,5 +1,5 @@
-import { NonReducibleUnknown, SetupReturn, PromiseActorLogic, EventObject, MetaObject } from 'xstate';
 import { EditorActorContext, EditorActorEmitedEvent, EditorActorEvent, EditorActorInput, EditorActorStateTag } from './types';
+import { SetupReturn, PromiseActorLogic, EventObject, NonReducibleUnknown, MetaObject } from 'xstate';
 import { HotkeyActorLogic } from './hotkey';
 import type * as t from '@likec4/core/types';
 export declare namespace EditorCalls {
@@ -32,12 +32,18 @@ export declare namespace EditorCalls {
             viewId: t.ViewId;
             changes: t.ViewChange[];
         };
-        type Output = NonReducibleUnknown;
+        /**
+         * Returns the changes that were applied to the view
+         */
+        type Output = {
+            requested: t.ViewChange[];
+            applied: t.ViewChange[];
+        };
     }
 }
 export declare const machine: SetupReturn<EditorActorContext, EditorActorEvent, {
     applyLatest: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
-    executeChange: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
+    executeChange: PromiseActorLogic<EditorCalls.ExecuteChange.Output, EditorCalls.ExecuteChange.Input, EventObject>;
     applySemanticLayout: PromiseActorLogic<EditorCalls.ApplySemanticLayout.Output, EditorCalls.ApplySemanticLayout.Input, EventObject>;
     hotkey: HotkeyActorLogic;
 }, {
@@ -45,4 +51,5 @@ export declare const machine: SetupReturn<EditorActorContext, EditorActorEvent,
 }, {}, {
     'has pending': unknown;
     'can undo': unknown;
+    'can redo': unknown;
 }, "500ms" | "wait-after-edit", EditorActorStateTag, EditorActorInput, NonReducibleUnknown, EditorActorEmitedEvent, MetaObject>;

package/dist/editor/actor/setup.js

@@ -27,8 +27,9 @@ var machine = setup({
 		"wait-after-edit": 1e3
 	},
 	guards: {
-		"has pending": ({ context }) => context.syncQueue.length > 0 || !!context.processing,
-		"can undo": ({ context }) => context.history !== null
+		"has pending": ({ context }) => context.syncQueue.length > 0,
+		"can undo": ({ context }) => context.history !== null,
+		"can redo": ({ context }) => context.redo !== null
 	}
 });
 //#endregion

package/dist/editor/actor/state.editor.d.ts

@@ -1,4 +1,4 @@
-import { StopAction, ActionFunction, PromiseActorLogic, EventObject, NonReducibleUnknown } from 'xstate';
+import { StopAction, ActionFunction, PromiseActorLogic, EventObject } from 'xstate';
 import { EditorActorContext, EditorActorEvent, EditorActorEmitedEvent } from './types';
 import { HotkeyActorLogic } from './hotkey';
 export declare const editor: {
@@ -14,10 +14,36 @@ export declare const editor: {
         };
         moving: {
             entry: StopAction<EditorActorContext, EditorActorEvent, undefined, EditorActorEvent>[];
+            exit: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
+                src: "hotkey";
+                logic: HotkeyActorLogic;
+                id: "hotkey";
+            } | {
+                src: "applyLatest";
+                logic: PromiseActorLogic<import("./setup").EditorCalls.ApplyLatestToManual.Output, import("./setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                id: string | undefined;
+            } | {
+                src: "executeChange";
+                logic: PromiseActorLogic<import("./setup").EditorCalls.ExecuteChange.Output, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
+                id: string | undefined;
+            } | {
+                src: "applySemanticLayout";
+                logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
+                id: string | undefined;
+            }, never, {
+                type: "has pending";
+                params: unknown;
+            } | {
+                type: "can undo";
+                params: unknown;
+            } | {
+                type: "can redo";
+                params: unknown;
+            }, "500ms" | "wait-after-edit", EditorActorEmitedEvent>[];
             on: {
                 'edit.move.end': {
                     target: "#idle";
-                    actions: ( ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, never, never, never, "500ms" | "wait-after-edit", never> | ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
+                    actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
                         src: "hotkey";
                         logic: HotkeyActorLogic;
                         id: "hotkey";
@@ -27,19 +53,26 @@ export declare const editor: {
                         id: string | undefined;
                     } | {
                         src: "executeChange";
-                        logic: PromiseActorLogic<NonReducibleUnknown, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
+                        logic: PromiseActorLogic<import("./setup").EditorCalls.ExecuteChange.Output, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
                         id: string | undefined;
                     } | {
                         src: "applySemanticLayout";
                         logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
                         id: string | undefined;
-                    }, never, never, never, never>)[];
+                    }, never, {
+                        type: "has pending";
+                        params: unknown;
+                    } | {
+                        type: "can undo";
+                        params: unknown;
+                    } | {
+                        type: "can redo";
+                        params: unknown;
+                    }, "500ms" | "wait-after-edit", EditorActorEmitedEvent>;
                 };
                 'edit.move.cancel': {
                     target: "#idle";
-                    actions: ActionFunction<EditorActorContext, {
-                        type: "edit.move.cancel";
-                    }, EditorActorEvent, undefined, {
+                    actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
                         src: "hotkey";
                         logic: HotkeyActorLogic;
                         id: "hotkey";
@@ -49,25 +82,39 @@ export declare const editor: {
                         id: string | undefined;
                     } | {
                         src: "executeChange";
-                        logic: PromiseActorLogic<NonReducibleUnknown, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
+                        logic: PromiseActorLogic<import("./setup").EditorCalls.ExecuteChange.Output, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
                         id: string | undefined;
                     } | {
                         src: "applySemanticLayout";
                         logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
                         id: string | undefined;
-                    }, never, never, never, never>[];
+                    }, never, never, never, never>;
                 };
-                undo: {
+                cancel: {
                     target: "#idle";
+                    actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
+                        src: "hotkey";
+                        logic: HotkeyActorLogic;
+                        id: "hotkey";
+                    } | {
+                        src: "applyLatest";
+                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplyLatestToManual.Output, import("./setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                        id: string | undefined;
+                    } | {
+                        src: "executeChange";
+                        logic: PromiseActorLogic<import("./setup").EditorCalls.ExecuteChange.Output, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
+                        id: string | undefined;
+                    } | {
+                        src: "applySemanticLayout";
+                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
+                        id: string | undefined;
+                    }, never, never, never, never>;
                 };
             };
             id: string;
         };
     };
     on: {
-        cancel: {
-            target: "#idle";
-        };
         '*': {
             actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
                 src: "hotkey";
@@ -79,7 +126,7 @@ export declare const editor: {
                 id: string | undefined;
             } | {
                 src: "executeChange";
-                logic: PromiseActorLogic<NonReducibleUnknown, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
+                logic: PromiseActorLogic<import("./setup").EditorCalls.ExecuteChange.Output, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
                 id: string | undefined;
             } | {
                 src: "applySemanticLayout";
@@ -91,6 +138,9 @@ export declare const editor: {
             } | {
                 type: "can undo";
                 params: unknown;
+            } | {
+                type: "can redo";
+                params: unknown;
             }, "500ms" | "wait-after-edit", EditorActorEmitedEvent>;
         };
     };

package/dist/editor/actor/state.editor.js

@@ -1,7 +1,6 @@
 import "../../_virtual/_rolldown/runtime.js";
 import { machine } from "./setup.js";
-import { pushHistory, saveBeforeEditing, scheduleSync } from "./actions.js";
-import { assign } from "xstate";
+import { pushHistory, saveBeforeEditing } from "./actions.js";
 //#region src/editor/actor/state.editor.ts
 var to = {
 	idle: { target: "#idle" },
@@ -10,7 +9,7 @@ var to = {
 var idOf = (t) => ({ id: t.target.substring(1) });
 var stopHotkey = () => machine.stopChild("hotkey");
 var ensureHotKey = () => machine.enqueueActions(({ check, enqueue, self }) => {
-	const hasUndo = check("can undo");
+	const hasUndo = check("can undo") || check("can redo");
 	const hotkey = self.getSnapshot().children["hotkey"];
 	if (!hasUndo && hotkey) {
 		enqueue.stopChild(hotkey);
@@ -25,19 +24,24 @@ var idle = machine.createStateConfig({
 	...idOf(to.idle),
 	on: { "edit.move.start": { ...to.moving } }
 });
+var clearEditing = () => machine.assign({ editing: null });
 var moving = machine.createStateConfig({
 	...idOf(to.moving),
-	entry: [saveBeforeEditing, stopHotkey()],
+	entry: [saveBeforeEditing(), stopHotkey()],
+	exit: [ensureHotKey()],
 	on: {
 		"edit.move.end": {
-			actions: [pushHistory(), scheduleSync()],
+			actions: pushHistory(),
 			...to.idle
 		},
 		"edit.move.cancel": {
-			actions: [assign({ editing: null })],
+			actions: clearEditing(),
 			...to.idle
 		},
-		"undo": { ...to.idle }
+		"cancel": {
+			actions: clearEditing(),
+			...to.idle
+		}
 	}
 });
 var editor = machine.createStateConfig({
@@ -46,10 +50,7 @@ var editor = machine.createStateConfig({
 		idle,
 		moving
 	},
-	on: {
-		"cancel": { ...to.idle },
-		"*": { actions: ensureHotKey() }
-	}
+	on: { "*": { actions: ensureHotKey() } }
 });
 //#endregion
 export { editor };