@likec4/diagram 1.56.0 → 1.58.0

package/dist/editor/actor/state.sync-queue.d.ts

@@ -0,0 +1,612 @@
+import { ActionFunction, PromiseActorLogic, EventObject, CancelAction, LogAction, GuardArgs, ActorRef, MachineSnapshot, AnyActorRef, StateValue, AnyEventObject, DoneActorEvent, ErrorActorEvent, ActionArgs } from 'xstate';
+import { EditorActorContext, EditorActorEvent, EditorActorEmitedEvent } from './types';
+import { HotkeyActorLogic } from './hotkey';
+import { DiagramView, Any, ViewId, ViewChange } from '@likec4/core';
+export declare const syncQueue: {
+    initial: string;
+    states: {
+        idle: {
+            always: {
+                target: "#queue-pending";
+                guard: "has pending";
+            };
+            on: {
+                'delete.nodes-edges': {
+                    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, {
+                        type: "has pending";
+                        params: unknown;
+                    } | {
+                        type: "can undo";
+                        params: unknown;
+                    } | {
+                        type: "can redo";
+                        params: unknown;
+                    }, "500ms" | "wait-after-edit", EditorActorEmitedEvent>;
+                };
+                'change.sync-snapshot': {
+                    target: "#queue-pending";
+                    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>;
+                };
+                'change.*': {
+                    target: "#queue-process";
+                    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>;
+                };
+                undo: {
+                    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, {
+                        type: "has pending";
+                        params: unknown;
+                    } | {
+                        type: "can undo";
+                        params: unknown;
+                    } | {
+                        type: "can redo";
+                        params: unknown;
+                    }, "500ms" | "wait-after-edit", EditorActorEmitedEvent>;
+                };
+                redo: {
+                    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, {
+                        type: "has pending";
+                        params: unknown;
+                    } | {
+                        type: "can undo";
+                        params: unknown;
+                    } | {
+                        type: "can redo";
+                        params: unknown;
+                    }, "500ms" | "wait-after-edit", EditorActorEmitedEvent>;
+                };
+                cancel: {
+                    target: "#queue-idle";
+                    actions: CancelAction<EditorActorContext, EditorActorEvent, undefined, EditorActorEvent>;
+                };
+                'view.synched': {
+                    actions: LogAction<EditorActorContext, {
+                        type: "view.synched";
+                    }, undefined, EditorActorEvent>;
+                };
+            };
+            id: string;
+        };
+        pending: {
+            on: {
+                'change.sync-snapshot': {
+                    target: "#queue-pending";
+                    reenter: true;
+                    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>;
+                };
+                'change.*': {
+                    target: "#queue-process";
+                    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>;
+                };
+                'delete.nodes-edges': {
+                    target: "#queue-pending";
+                    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, {
+                        type: "has pending";
+                        params: unknown;
+                    } | {
+                        type: "can undo";
+                        params: unknown;
+                    } | {
+                        type: "can redo";
+                        params: unknown;
+                    }, "500ms" | "wait-after-edit", EditorActorEmitedEvent>;
+                    reenter: true;
+                };
+                'edit.move.start': {
+                    target: "#queue-suspended";
+                };
+                undo: {
+                    target: "#queue-pending";
+                    reenter: true;
+                    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, {
+                        type: "has pending";
+                        params: unknown;
+                    } | {
+                        type: "can undo";
+                        params: unknown;
+                    } | {
+                        type: "can redo";
+                        params: unknown;
+                    }, "500ms" | "wait-after-edit", EditorActorEmitedEvent>;
+                };
+                redo: {
+                    target: "#queue-pending";
+                    reenter: true;
+                    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, {
+                        type: "has pending";
+                        params: unknown;
+                    } | {
+                        type: "can undo";
+                        params: unknown;
+                    } | {
+                        type: "can redo";
+                        params: unknown;
+                    }, "500ms" | "wait-after-edit", EditorActorEmitedEvent>;
+                };
+                cancel: {
+                    target: "#queue-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>;
+                };
+                'view.synched': {
+                    actions: LogAction<EditorActorContext, {
+                        type: "view.synched";
+                    }, undefined, EditorActorEvent>;
+                };
+            };
+            after: {
+                'wait-after-edit': ({
+                    readonly target: "#queue-idle";
+                } | {
+                    target: "#queue-process";
+                    guard: "has pending";
+                })[];
+            };
+            id: string;
+        };
+        suspended: {
+            on: {
+                'edit.*': {
+                    readonly target: "#queue-idle";
+                };
+                cancel: {
+                    target: "#queue-idle";
+                    actions: CancelAction<EditorActorContext, EditorActorEvent, undefined, EditorActorEvent>[];
+                };
+            };
+            id: string;
+        };
+        process: {
+            initial: string;
+            tags: "busy"[];
+            states: {
+                peekFromQueue: {
+                    entry: 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>;
+                    always: ({
+                        guard: ({ context: { processing } }: GuardArgs<EditorActorContext, EditorActorEvent>) => boolean;
+                        target: string;
+                    } | {
+                        target: "#queue-process";
+                        guard: "has pending";
+                        reenter: true;
+                    } | {
+                        target: "#queue-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>;
+                        guard?: never;
+                    })[];
+                };
+                /**
+                 * Syncing state, some edits are not yet synced
+                 */
+                applyLatestToManual: {
+                    initial: string;
+                    entry: 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>;
+                    states: {
+                        call: {
+                            invoke: {
+                                src: "applyLatest";
+                                input: ({ context }: {
+                                    context: EditorActorContext;
+                                    event: EditorActorEvent;
+                                    self: ActorRef<MachineSnapshot<EditorActorContext, EditorActorEvent, Record<string, AnyActorRef>, StateValue, string, unknown, any, any>, EditorActorEvent, AnyEventObject>;
+                                }) => {
+                                    current: DiagramView<Any>;
+                                    viewId: ViewId;
+                                };
+                                onDone: {
+                                    actions: ActionFunction<EditorActorContext, DoneActorEvent<import("./setup").EditorCalls.ApplyLatestToManual.Output, string>, EditorActorEvent, undefined, never, never, never, "500ms" | "wait-after-edit", never>;
+                                    target: string;
+                                };
+                                onError: {
+                                    target: "#queue-idle";
+                                    actions: ActionFunction<EditorActorContext, ErrorActorEvent<unknown, string>, 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>;
+                                };
+                            };
+                        };
+                        wait: {
+                            on: {
+                                '*': {
+                                    actions: LogAction<EditorActorContext, EditorActorEvent, undefined, EditorActorEvent>;
+                                };
+                            };
+                            after: {
+                                '500ms': {
+                                    target: "#queue-idle";
+                                    actions: ( ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, never, never, never, "500ms" | "wait-after-edit", never> | 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>)[];
+                                };
+                            };
+                        };
+                    };
+                };
+                /**
+                 * User requested semantic layout, we will call the AI
+                 */
+                applySemanticLayout: {
+                    tags: "ai-semantic-layout"[];
+                    invoke: {
+                        src: "applySemanticLayout";
+                        input: ({ context }: {
+                            context: EditorActorContext;
+                            event: EditorActorEvent;
+                            self: ActorRef<MachineSnapshot<EditorActorContext, EditorActorEvent, Record<string, AnyActorRef>, StateValue, string, unknown, any, any>, EditorActorEvent, AnyEventObject>;
+                        }) => {
+                            viewId: ViewId;
+                        };
+                        onDone: {
+                            target: string;
+                        };
+                        onError: {
+                            actions: ({ event }: ActionArgs<EditorActorContext, ErrorActorEvent<unknown, string>, EditorActorEvent>) => void;
+                            target: string;
+                        };
+                    };
+                };
+                /**
+                 * Calls `executeChange` to save the snapshot
+                 */
+                executeChanges: {
+                    invoke: {
+                        src: "executeChange";
+                        input: ({ context: { processing, syncQueue, viewId } }: {
+                            context: EditorActorContext;
+                            event: EditorActorEvent;
+                            self: ActorRef<MachineSnapshot<EditorActorContext, EditorActorEvent, Record<string, AnyActorRef>, StateValue, string, unknown, any, any>, EditorActorEvent, AnyEventObject>;
+                        }) => {
+                            changes: ViewChange[];
+                            viewId: ViewId;
+                        };
+                        onDone: {
+                            actions: ActionFunction<EditorActorContext, DoneActorEvent<import("./setup").EditorCalls.ExecuteChange.Output, string>, 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>;
+                            target: string;
+                        };
+                        onError: {
+                            actions: ({ event }: ActionArgs<EditorActorContext, ErrorActorEvent<unknown, string>, EditorActorEvent>) => void;
+                            target: string;
+                        };
+                    };
+                };
+                waitViewSynced: {
+                    on: {
+                        'view.synched': {
+                            target: string;
+                        };
+                    };
+                    after: {
+                        2000: string;
+                    };
+                };
+                decideNext: {
+                    entry: 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>;
+                    always: ({
+                        readonly target: "#queue-idle";
+                    } | {
+                        target: "#queue-process";
+                        guard: "has pending";
+                        reenter: true;
+                    })[];
+                };
+                failure: {
+                    always: {
+                        target: "#queue-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>;
+                    };
+                };
+            };
+            on: {};
+            id: string;
+        };
+    };
+    on: {};
+};