deepsky 2.25.6 → 2.28.3

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import * as vue from 'vue';
 import { Ref, Reactive, ShallowReactive, ShallowRef, ComputedRef } from 'vue';
+import { HotkeysEvent } from 'hotkeys-js';
 import { IMath, DragList } from 'cook-web';
 import { KatexOptions } from 'katex';
 import { Token, Tokens, Marked, TokensList } from 'marked';
@@ -30,7 +31,7 @@ declare namespace IText {
     }
 }
 
-declare namespace ICubeCommand {
+declare namespace ICommandCube {
     type Names = "cube:reset" | "cube:delete" | "cube:insert" | "cube:insert-child" | "cube:delete-child" | "cube:delete-adjacent" | "cube:set-selection-css" | "cube:partition" | "cube:reorder" | "cube:set-css" | "cube:set-attr" | "cube:move" | "cube:merge" | "cube:postil-add" | "cube:postil-remove" | "code:change-lang" | "code:change-active" | "code:change-theme" | "code:update" | "code:add" | "code:remove" | "code:rename" | "detail-list:insert-row" | "detail-list:remove-row" | "detail-list:change-width-col1" | "formula:update" | "linker:update" | "list:add" | "list:remove" | "list:indent" | "list:reset" | "list:transform" | "list-ordered:add" | "list-ordered:remove" | "list-ordered:indent" | "list-ordered:reset" | "rt:reset" | "table:add-title" | "table:remove-title" | "table:add-cell" | "table:remove-cell" | "table:add-row" | "table:remove-row" | "table:add-col" | "table:remove-col" | "table:add-grid-col" | "table:remove-grid-col" | "table:add-grid-row" | "table:remove-grid-row" | "table:merge" | "table:moveto" | "table:update-area" | "table:reorder" | "table:col-resize" | "text:reset" | "text:break" | "text-link:update" | "todo:add" | "todo:remove" | "todo:indent" | "todo:status" | "todo:reset" | "node:layout-update" | "node:append-child" | "map:node-add" | "map:node-remove" | "map:linker-add" | "map:linker-remove" | "map:update-attrs" | "map:node-drag" | "map:sibling-reorder" | "cursor:in-head" | "cursor:in-tail" | "cursor:loc" | (string & {});
     type DeleteDir = "forward" | "backward";
     type CursorFrom = "left" | "right" | "none";
@@ -38,50 +39,50 @@ declare namespace ICubeCommand {
         id: string;
         name: Names;
     }
-    interface Reset extends ICubeCommand.BaseCommand {
+    interface Reset extends ICommandCube.BaseCommand {
         name: "cube:reset";
         data: ICubeBase.Data[];
     }
-    interface InsertChild extends ICubeCommand.BaseCommand {
+    interface InsertChild extends ICommandCube.BaseCommand {
         name: "cube:insert-child";
         data: ICubeBase.Data[];
         pos: number | INote.CubeSide;
     }
-    interface Delete extends ICubeCommand.BaseCommand {
+    interface Delete extends ICommandCube.BaseCommand {
         name: "cube:delete";
-        dir: ICubeCommand.DeleteDir;
+        dir: ICommandCube.DeleteDir;
         start_id: ICubeBase.CubeId | null;
         end_id: ICubeBase.CubeId | null;
         offset_start: number | INote.CubeSide;
         offset_end: number | INote.CubeSide;
         reserve: boolean;
     }
-    interface DeleteAdjacent extends ICubeCommand.BaseCommand {
+    interface DeleteAdjacent extends ICommandCube.BaseCommand {
         name: "cube:delete-adjacent";
-        from: ICubeCommand.CursorFrom;
+        from: ICommandCube.CursorFrom;
         offset: number;
         from_id: ICubeBase.CubeId;
     }
     type CssMethod = "cover" | "toggle" | "replace";
-    interface SetCss extends ICubeCommand.BaseCommand {
+    interface SetCss extends ICommandCube.BaseCommand {
         name: "cube:set-css";
         css: Record<string, string | null>;
         method: CssMethod;
     }
-    interface SetAttr extends ICubeCommand.BaseCommand {
+    interface SetAttr extends ICommandCube.BaseCommand {
         name: "cube:set-attr";
         attr: Record<string, string | null>;
     }
-    interface SetSelectionCss extends ICubeCommand.BaseCommand {
+    interface SetSelectionCss extends ICommandCube.BaseCommand {
         name: "cube:set-selection-css";
         css: Record<string, any>;
         start_id: ICubeBase.CubeId | null;
         end_id: ICubeBase.CubeId | null;
         offset_start: number | INote.CubeSide;
         offset_end: number | INote.CubeSide;
-        method: ICubeCommand.CssMethod;
+        method: ICommandCube.CssMethod;
     }
-    interface Insert extends ICubeCommand.BaseCommand {
+    interface Insert extends ICommandCube.BaseCommand {
         name: "cube:insert";
         data: ICubeBase.Data[];
         start_id: ICubeBase.CubeId;
@@ -89,52 +90,52 @@ declare namespace ICubeCommand {
         offset_start: number;
         offset_end: number;
     }
-    interface DeleteChild extends ICubeCommand.BaseCommand {
+    interface DeleteChild extends ICommandCube.BaseCommand {
         name: "cube:delete-child";
-        dir: ICubeCommand.DeleteDir;
+        dir: ICommandCube.DeleteDir;
         range: [number, number];
         reserve: boolean;
     }
-    interface Partition extends ICubeCommand.BaseCommand {
+    interface Partition extends ICommandCube.BaseCommand {
         name: "cube:partition";
         start_id: ICubeBase.CubeId;
         end_id: ICubeBase.CubeId;
         offset_start: number;
         offset_end: number;
     }
-    interface Reorder extends ICubeCommand.BaseCommand {
+    interface Reorder extends ICommandCube.BaseCommand {
         name: "cube:reorder";
         cubeid: ICubeBase.CubeId;
         index: number | INote.CubeSide;
     }
-    interface Merge extends ICubeCommand.BaseCommand {
+    interface Merge extends ICommandCube.BaseCommand {
         id: ICubeBase.CubeId;
         name: "cube:merge";
         method: INote.CubeMergeMethod;
         cubeid: ICubeBase.CubeId;
         offset: number;
     }
-    interface PostilAdd extends ICubeCommand.BaseCommand {
+    interface PostilAdd extends ICommandCube.BaseCommand {
         name: "cube:postil-add";
         data: ICubeBase.Data[];
     }
-    interface PostilRemove extends ICubeCommand.BaseCommand {
+    interface PostilRemove extends ICommandCube.BaseCommand {
         name: "cube:postil-remove";
         range: [number, number];
     }
 }
 
-declare namespace ICursorCommand {
-    interface Loc extends ICubeCommand.BaseCommand {
+declare namespace ICommandCursor {
+    interface Loc extends ICommandCube.BaseCommand {
         name: "cursor:loc";
         from: string;
         from_offset: number;
         offset: number;
     }
-    interface InHead extends ICubeCommand.BaseCommand {
+    interface InHead extends ICommandCube.BaseCommand {
         name: "cursor:in-head";
     }
-    interface InTail extends ICubeCommand.BaseCommand {
+    interface InTail extends ICommandCube.BaseCommand {
         name: "cursor:in-tail";
     }
 }
@@ -155,30 +156,30 @@ declare namespace IMapTools {
     type Matrix2DArray = [number, number, number, number, number, number];
 }
 
-declare namespace IMapCommand {
-    interface NodeAdd extends ICubeCommand.BaseCommand {
+declare namespace ICommandMap {
+    interface NodeAdd extends ICommandCube.BaseCommand {
         name: "map:node-add";
         data: INodeBase.Base[];
     }
-    interface NodeRemove extends ICubeCommand.BaseCommand {
+    interface NodeRemove extends ICommandCube.BaseCommand {
         name: "map:node-remove";
         data: ICubeBase.CubeId[];
     }
-    interface LinkerAdd extends ICubeCommand.BaseCommand {
+    interface LinkerAdd extends ICommandCube.BaseCommand {
         name: "map:linker-add";
         data: LinkerInfo[];
         to_root?: boolean;
     }
-    interface LinkerRemove extends ICubeCommand.BaseCommand {
+    interface LinkerRemove extends ICommandCube.BaseCommand {
         name: "map:linker-remove";
         data: ICubeBase.CubeId[];
         to_root?: boolean;
     }
-    interface NodeMove extends ICubeCommand.BaseCommand {
+    interface NodeMove extends ICommandCube.BaseCommand {
         name: "map:node-drag";
         data: NodeMoveInfo[];
     }
-    interface SiblingReorder extends ICubeCommand.BaseCommand {
+    interface SiblingReorder extends ICommandCube.BaseCommand {
         name: "map:sibling-reorder";
         upstream_id: ICubeBase.CubeId;
         order: ICubeBase.CubeId[];
@@ -206,7 +207,7 @@ declare abstract class Map2D {
     abstract get rect(): IMath.Rect;
 }
 
-declare abstract class AdapterCubeBase {
+declare abstract class CubeAdapterBase {
     abstract get meta(): INote.CubeMeta;
     get version(): number;
     get type(): INote.Cubes;
@@ -216,233 +217,13 @@ declare abstract class AdapterCubeBase {
     abstract replace_id(versions: INote.CubesVersion, data: any, map: Record<string, string>): ICubeBase.ReplaceIdResult;
 }
 
-declare class AdapterCubeAnnotation extends AdapterCubeBase {
-    get meta(): INote.CubeMeta;
-    get_data(css?: Record<string, any>, attrs?: Record<string, any>): _CubeTextAnnotation;
-    replace_id(versions: INote.CubesVersion, data: _CubeTextAnnotation, map?: Record<string, string>): ICubeBase.ReplaceIdResult<_CubeTextAnnotation>;
-    update_data(versions: INote.CubesVersion, data: _CubeTextAnnotation): ICubeBase.CubeUpdateResult;
-}
-
-declare class AdapterCubeApi extends AdapterCubeBase {
-    get meta(): INote.CubeMeta;
-    get type_argument(): Record<string, string>;
-    get type_funciton(): Record<string, string>;
-    get_line_function(funcname?: string): ILine.Data;
-    get_text_function_type(): IText.Data;
-    get_text_function(funcname?: string): IText.Data;
-    get_text_argument(argname?: string): IText.Data;
-    get_text_argument_type(): IText.Data;
-    get_data(css?: INote.Css, attrs?: INote.Attrs): IApi.Data;
-    update_data(versions: INote.CubesVersion, data: any): ICubeBase.CubeUpdateResult<IApi.Data>;
-    to_v2(versions: INote.CubesVersion, data: IApi.V1): IApi.V2;
-    replace_id(versions: INote.CubesVersion, data: IApi.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<IApi.Data>;
-}
-
-declare class AdapterCubeBoxColumns extends AdapterCubeBase {
-    get meta(): INote.CubeMeta;
-    replace_id(versions: INote.CubesVersion, data: ICubeBoxColumns.Data, map: Record<string, string>): ICubeBase.ReplaceIdResult<ICubeBoxColumns.Data>;
-    get_data(): ICubeBoxColumns.Data;
-    update_data(versions: INote.CubesVersion, data: ICubeBoxColumns.Data): ICubeBase.CubeUpdateResult<ICubeBoxColumns.Data>;
-}
-
-declare class AdapterCubeBoxFolder extends AdapterCubeBase {
-    get meta(): INote.CubeMeta;
-    filter_out_empty(cubes: ICubeBase.Data[]): ICubeBase.Data[];
-    get_data(content?: ICubeBase.Data[], css?: Record<string, any>, attrs?: Partial<ICubeBase.Attrs>): ICubeBoxFolder.Data;
-    replace_id(versions: INote.CubesVersion, data: ICubeBoxFolder.Data, map: Record<string, string>): ICubeBase.ReplaceIdResult<ICubeBoxFolder.Data>;
-    update_data(versions: INote.CubesVersion, data: ICubeBoxFolder.Data): ICubeBase.CubeUpdateResult<ICubeBoxFolder.Data>;
-}
-
-declare class AdapterCubeBoxRoot extends AdapterCubeBase {
-    filter_out_empty(cubes: ICubeBase.Data[]): ICubeBase.Data[];
-    get meta(): INote.CubeMeta;
-    get_data(content?: ICubeBase.Data[], css?: Record<string, any>, attrs?: ICubeBase.Attrs): ICubeBoxRoot.Data;
-    replace_id(versions: INote.CubesVersion, data: ICubeBoxRoot.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<ICubeBoxRoot.Data>;
-    update_data(versions: INote.CubesVersion, data: ICubeBoxRoot.Data): ICubeBase.CubeUpdateResult;
-}
-
-declare class AdapterCubeBox extends AdapterCubeBase {
-    get meta(): INote.CubeMeta;
-    get_data(content?: ICubeBase.Data[], css?: Record<string, any>, attrs?: Record<string, any>): IBox.Data;
-    replace_id(versions: INote.CubesVersion, data: IBox.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<IBox.Data>;
-    update_data(versions: INote.CubesVersion, data: IBox.Data): ICubeBase.CubeUpdateResult;
-}
-
-declare class AdapterCubeCode extends AdapterCubeBase {
-    protected _langs: string[];
-    protected _themes: string[];
-    protected _highlighter: Highlighter | undefined;
-    get langs(): string[];
-    get themes(): string[];
-    get meta(): INote.CubeMeta;
-    get highlighter(): Highlighter | undefined;
-    get lang_map(): {
-        [x: string]: ICode.Langs;
-    };
-    constructor();
-    get_data(): ICode.Data;
-    get_data_by_string(lang?: string, code?: string): ICode.Data;
-    replace_id(versions: INote.CubesVersion, data: ICode.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<ICode.Data>;
-    get_format_from_lang(lang: string): string;
-    get_lang_from_format(format: string): ICode.Langs;
-    update_data(versions: INote.CubesVersion, data: ICode.Data): ICubeBase.CubeUpdateResult;
-}
-
-declare class AdapterCubeDetailList extends AdapterCubeBase {
-    get meta(): INote.CubeMeta;
-    get_data(info?: IDetailList.BoxDataMap[], css?: Record<string, any>, attrs?: Record<string, any>): IDetailList.Data;
-    replace_id(versions: INote.CubesVersion, data: IDetailList.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<IDetailList.Data>;
-    update_data(versions: INote.CubesVersion, data: IDetailList.Data): ICubeBase.CubeUpdateResult<IDetailList.Data>;
-}
-
-declare class AdapterCubeDoc extends AdapterCubeBase {
-    get meta(): INote.CubeMeta;
-    get_data(): IDoc.Data;
-    replace_id(versions: INote.CubesVersion, data: IDoc.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<IDoc.Data>;
-    update_data(versions: INote.CubesVersion, data: IDoc.Data): ICubeBase.CubeUpdateResult;
-}
-
-declare class AdapterCubeFormula extends AdapterCubeBase {
-    get meta(): INote.CubeMeta;
-    get_data(formula?: string, css?: Record<string, string>, attrs?: Partial<IFormula.Attrs>): IFormula.Data;
-    replace_id(versions: INote.CubesVersion, data: IFormula.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<IFormula.Data>;
-    update_data(versions: INote.CubesVersion, data: IFormula.Data): ICubeBase.CubeUpdateResult;
-    render(latex: string, options?: KatexOptions): string;
-}
-
-declare class AdapterCubeImg extends AdapterCubeBase {
+declare class AdapterCubeImg extends CubeAdapterBase {
     get meta(): INote.CubeMeta;
     replace_id(versions: INote.CubesVersion, data: IImg.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<IImg.Data>;
     get_data(src?: string, css?: Record<string, any>, attrs?: Record<string, any>): IImg.Data;
     update_data(versions: INote.CubesVersion, data: IImg.Data): ICubeBase.CubeUpdateResult;
 }
 
-declare class AdapterCubeLine extends AdapterCubeBase {
-    get meta(): INote.CubeMeta;
-    filter_out_empty(cubes: ICubeBase.Data[]): ICubeBase.Data[];
-    get_data(cubelist?: ICubeBase.Data[], css?: Record<string, any>, attrs?: Record<string, any>): ILine.Data;
-    get_data_by_string(text?: string, css?: Record<string, any>, attrs?: Record<string, any>): ILine.Data;
-    replace_id(versions: INote.CubesVersion, data: ILine.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<ILine.Data>;
-    update_data(versions: INote.CubesVersion, data: ILine.Data): ICubeBase.CubeUpdateResult;
-}
-
-declare class AdapterCubeLinker extends AdapterCubeBase {
-    get meta(): INote.CubeMeta;
-    replace_id(versions: INote.CubesVersion, data: ILinker.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<ILinker.Data>;
-    get_data(from: string, to: string, type?: INodeBase.Line): ILinker.Data;
-    update_data(versions: INote.CubesVersion, data: ILinker.Data): ICubeBase.CubeUpdateResult<ILinker.Data>;
-}
-
-declare class AdapterCubeListOrdered extends AdapterCubeBase {
-    get meta(): INote.CubeMeta;
-    get_data(): IListOrdered.Data;
-    get_list_item(cubedata: ICubeBase.Data[]): IList.ListItemData;
-    replace_id(versions: INote.CubesVersion, data: IListOrdered.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<IListOrdered.Data>;
-    update_data(versions: INote.CubesVersion, data: IListOrdered.Data): {
-        data: IListOrdered.Data;
-        usable: boolean;
-    };
-}
-
-declare class AdapterCubeList extends AdapterCubeBase {
-    get meta(): INote.CubeMeta;
-    get_data(children?: ICubeBase.Data[]): IList.Data;
-    get_list_item(cubedata: ICubeBase.Data[]): IList.ListItemData;
-    replace_id(versions: INote.CubesVersion, data: IList.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<IList.Data>;
-    update_data(versions: INote.CubesVersion, data: IList.Data): {
-        data: IList.Data;
-        usable: boolean;
-    };
-}
-
-declare class AdapterCubeLost extends AdapterCubeBase {
-    get meta(): INote.CubeMeta;
-    get_data(cubedata: ICubeBase.Data): ILost.Data;
-    replace_id(versions: INote.CubesVersion, data: ILost.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<ILost.Data>;
-    update_data(versions: INote.CubesVersion, data: ILost.Data): {
-        data: ILost.Data;
-        usable: boolean;
-    };
-}
-
-declare class AdapterCubeMap extends AdapterCubeBase {
-    get meta(): INote.CubeMeta;
-    get_data(): IMap.Data;
-    replace_id(versions: INote.CubesVersion, data: IMap.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<IMap.Data>;
-    update_data(versions: INote.CubesVersion, data: IMap.Data): ICubeBase.CubeUpdateResult;
-}
-
-declare class AdapterCubeNode extends AdapterCubeBase {
-    get meta(): INote.CubeMeta;
-    replace_id(versions: INote.CubesVersion, data: INode.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<INode.Data>;
-    get_data(p: IMath.Point, data?: ICubeBoxRoot.Data[], shape?: INodeBase.Shape): INode.Data;
-    update_data(versions: INote.CubesVersion, data: INode.Data): ICubeBase.CubeUpdateResult<any>;
-}
-
-declare class AdapterCubePostil extends AdapterCubeBase {
-    get meta(): INote.CubeMeta;
-    get_data(data?: ICubeBase.Data[], css?: Record<string, any>): IPostil.V1;
-    replace_id(versions: INote.CubesVersion, data: any, map?: Record<string, string>): ICubeBase.ReplaceIdResult<IPostil.Data>;
-    update_data(versions: INote.CubesVersion, data: any): ICubeBase.CubeUpdateResult<IPostil.Data>;
-}
-
-declare class AdapterCubeRt extends AdapterCubeBase {
-    get min_size(): number;
-    get scale(): number;
-    get meta(): INote.CubeMeta;
-    get_data(text?: string, explanation?: string, css?: Record<string, string>): IRt.Data;
-    replace_id(versions: INote.CubesVersion, data: IRt.Data, map: Record<string, string>): ICubeBase.ReplaceIdResult<IRt.Data>;
-    update_data(versions: INote.CubesVersion, data: IRt.Data): ICubeBase.CubeUpdateResult<IRt.Data>;
-}
-
-declare class AdapterCubeSubmap extends AdapterCubeBase {
-    get meta(): INote.CubeMeta;
-    get_data(width?: number, height?: number): ISubMap.Data;
-    replace_id(versions: INote.CubesVersion, data: ISubMap.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<ISubMap.Data>;
-    update_data(versions: INote.CubesVersion, data: ISubMap.Data): ICubeBase.CubeUpdateResult<ISubMap.Data>;
-}
-
-declare class AdapterCubeTable extends AdapterCubeBase {
-    get meta(): INote.CubeMeta;
-    get_data(row?: number, col?: number): ITable.Data;
-    get_data_by_data(size: [number, number], cells: ITable.CellData[]): ITable.Data;
-    replace_id(versions: INote.CubesVersion, data: ITable.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<ITable.Data>;
-    update_data(versions: INote.CubesVersion, data: ITable.Data): ICubeBase.CubeUpdateResult<ITable.Data>;
-}
-
-declare class AdapterCubeText extends AdapterCubeBase {
-    drop_zero_width_space(text: string, pos: number): INoteCursor.Location;
-    drop_zero_intelligence(text: string, pos: number): INoteCursor.Location;
-    is_empty_text(cube: ICubeBase.Data): boolean;
-    get meta(): INote.CubeMeta;
-    get_data(text?: string, css?: Record<string, any>, attrs?: Record<string, any>): IText.Data;
-    replace_id(versions: INote.CubesVersion, data: IText.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<IText.Data>;
-    update_data(versions: INote.CubesVersion, data: IText.Data): ICubeBase.CubeUpdateResult<IText.Data>;
-}
-
-declare class AdapterCubeTextLink extends AdapterCubeBase {
-    get meta(): INote.CubeMeta;
-    get_data(url: string, title: string, css?: Record<string, any>, attrs?: Record<string, any>): ITextLink.Data;
-    replace_id(versions: INote.CubesVersion, data: ITextLink.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<ITextLink.Data>;
-    update_data(versions: INote.CubesVersion, data: ITextLink.Data): ICubeBase.CubeUpdateResult<ITextLink.Data>;
-}
-
-declare class AdapterCubeTip extends AdapterCubeBase {
-    get meta(): INote.CubeMeta;
-    get_data(cubes: ICubeBase.Data[], css?: Record<string, string>, attrs?: Record<string, string>): ITip.Data;
-    get_data_by_string(info: string, css?: Record<string, string>, attrs?: Record<string, string>): ITip.Data;
-    replace_id(versions: INote.CubesVersion, data: ITip.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<ITip.Data>;
-    update_data(versions: INote.CubesVersion, data: ITip.Data): ICubeBase.CubeUpdateResult<ITip.Data>;
-}
-
-declare class AdapterCubeTodo extends AdapterCubeBase {
-    get meta(): INote.CubeMeta;
-    get_data(): ITodo.Data;
-    get_todo_item(cubedata: ICubeBase.Data[], done?: boolean): _CubeTodoItemData;
-    replace_id(versions: INote.CubesVersion, data: ITodo.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<ITodo.Data>;
-    update_data(versions: INote.CubesVersion, data: ITodo.Data): ICubeBase.CubeUpdateResult<ITodo.Data>;
-}
-
 declare abstract class CubeChild<T extends ICubeBase.Data = any> extends CubeBase<T> {
     protected _pcube: INote.NoteCube;
     protected _children: CubeChild[];
@@ -489,7 +270,7 @@ declare abstract class CubeChild<T extends ICubeBase.Data = any> extends CubeBas
     base_export(): T;
     copy(left: number, right: number): ICubeBase.Data[];
     get_upstream_sum_scale(): _FigScale;
-    remove_self(dir?: ICubeCommand.DeleteDir): Recorder | undefined;
+    remove_self(dir?: ICommandCube.DeleteDir): Recorder | undefined;
     merge(method: INote.CubeMergeMethod): Recorder | undefined;
     find_cube(id: ICubeBase.CubeId): INote.NoteChild | undefined;
     filter(func: ICubeBase.CubeFilterFunc): INote.NoteChild[];
@@ -502,30 +283,30 @@ declare abstract class CubeChild<T extends ICubeBase.Data = any> extends CubeBas
     find_child_index(id: ICubeBase.CubeId): number;
     find_next_cube(id: ICubeBase.CubeId): INote.NoteChild | undefined;
     find_prev_cube(id: ICubeBase.CubeId): INote.NoteChild | undefined;
-    protected on_cube_set_selection_css(command: ICubeCommand.SetSelectionCss): Recorder | void;
-    protected on_insert(command: ICubeCommand.Insert): Recorder | void;
-    protected on_cube_delete(command: ICubeCommand.Delete): Recorder | void;
-    protected on_cube_set_css(command: ICubeCommand.SetCss): Recorder | void;
-    protected on_cube_set_attr(command: ICubeCommand.SetAttr): Recorder | void;
-    protected on_cube_delete_adjacent(command: ICubeCommand.DeleteAdjacent): Recorder | void;
-    protected on_postil_add(cmd: ICubeCommand.PostilAdd): Recorder | void;
-    protected on_postil_remove(command: ICubeCommand.PostilRemove): Recorder | void;
-    protected on_cursor_in_head(command: ICursorCommand.InHead): Recorder | undefined;
-    protected on_cursor_in_tail(command: ICursorCommand.InTail): Recorder | undefined;
+    protected on_cube_set_selection_css(command: ICommandCube.SetSelectionCss): Recorder | void;
+    protected on_insert(command: ICommandCube.Insert): Recorder | void;
+    protected on_cube_delete(command: ICommandCube.Delete): Recorder | void;
+    protected on_cube_set_css(command: ICommandCube.SetCss): Recorder | void;
+    protected on_cube_set_attr(command: ICommandCube.SetAttr): Recorder | void;
+    protected on_cube_delete_adjacent(command: ICommandCube.DeleteAdjacent): Recorder | void;
+    protected on_postil_add(cmd: ICommandCube.PostilAdd): Recorder | void;
+    protected on_postil_remove(command: ICommandCube.PostilRemove): Recorder | void;
+    protected on_cursor_in_head(command: ICommandCursor.InHead): Recorder | undefined;
+    protected on_cursor_in_tail(command: ICommandCursor.InTail): Recorder | undefined;
     is_valid_range(range: [number, number], check_collapse?: boolean): boolean;
     get_valid_index(pos: number | INote.CubeSide): number;
     get_valid_range(range: [number, number]): [number, number];
 }
 
-declare class StatusImg extends StatusCube<IImg.Data> {
+declare class ImgStatus extends CubeStatusBase<IImg.Data> {
     constructor(cube: CubeImg);
 }
 
 declare class CubeImg extends CubeChild<IImg.Data> {
-    protected _status: StatusImg;
+    protected _status: ImgStatus;
     constructor(note: Note, data: IImg.Data, pcube: CubeChild);
     get adapter(): AdapterCubeImg;
-    get status(): StatusImg;
+    get status(): ImgStatus;
     get is_empty(): boolean;
     get meta(): INote.CubeMeta<INote.Cubes>;
     get component(): any;
@@ -537,16 +318,26 @@ declare class CubeImg extends CubeChild<IImg.Data> {
     export(): IImg.Data;
 }
 
-declare class StatusLost extends StatusCube<ILost.Data> {
+declare class AdapterCubeLost extends CubeAdapterBase {
+    get meta(): INote.CubeMeta;
+    get_data(cubedata: ICubeBase.Data): ILost.Data;
+    replace_id(versions: INote.CubesVersion, data: ILost.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<ILost.Data>;
+    update_data(versions: INote.CubesVersion, data: ILost.Data): {
+        data: ILost.Data;
+        usable: boolean;
+    };
+}
+
+declare class LostStatus extends CubeStatusBase<ILost.Data> {
     constructor(cube: CubeLost);
 }
 
 declare class CubeLost extends CubeChild<ILost.Data> {
-    protected _status: StatusLost;
+    protected _status: LostStatus;
     protected _msg: vue.Ref<string, string>;
     constructor(note: Note, data: any, pcube: any, reason: string);
     get adapter(): AdapterCubeLost;
-    get status(): StatusLost;
+    get status(): LostStatus;
     get msg(): string;
     set msg(v: string);
     get component(): any;
@@ -556,11 +347,30 @@ declare class CubeLost extends CubeChild<ILost.Data> {
     build_child(): void;
     gc(): void;
     export(): ILost.Data;
-    on_cursor_in_head(command: ICursorCommand.InHead): Recorder;
-    on_cursor_in_tail(command: ICursorCommand.InTail): Recorder;
+    on_cursor_in_head(command: ICommandCursor.InHead): Recorder;
+    on_cursor_in_tail(command: ICommandCursor.InTail): Recorder;
 }
 
-declare class StatusText extends StatusCube<IText.Data> {
+declare class AdapterCubeLine extends CubeAdapterBase {
+    get meta(): INote.CubeMeta;
+    filter_out_empty(cubes: ICubeBase.Data[]): ICubeBase.Data[];
+    get_data(cubelist?: ICubeBase.Data[], css?: Record<string, any>, attrs?: Record<string, any>): ILine.Data;
+    get_data_by_string(text?: string, css?: Record<string, any>, attrs?: Record<string, any>): ILine.Data;
+    replace_id(versions: INote.CubesVersion, data: ILine.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<ILine.Data>;
+    update_data(versions: INote.CubesVersion, data: ILine.Data): ICubeBase.CubeUpdateResult;
+}
+
+declare class AdapterCubeText extends CubeAdapterBase {
+    drop_zero_width_space(text: string, pos: number): INoteCursor.Location;
+    drop_zero_intelligence(text: string, pos: number): INoteCursor.Location;
+    is_empty_text(cube: ICubeBase.Data): boolean;
+    get meta(): INote.CubeMeta;
+    get_data(text?: string, css?: Record<string, any>, attrs?: Record<string, any>): IText.Data;
+    replace_id(versions: INote.CubesVersion, data: IText.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<IText.Data>;
+    update_data(versions: INote.CubesVersion, data: IText.Data): ICubeBase.CubeUpdateResult<IText.Data>;
+}
+
+declare class TextStatus extends CubeStatusBase<IText.Data> {
     constructor(cube: CubeText);
     get cube(): CubeText;
     get text(): string;
@@ -568,10 +378,10 @@ declare class StatusText extends StatusCube<IText.Data> {
 }
 
 declare class CubeText extends CubeChild<IText.Data> {
-    protected _status: StatusText;
+    protected _status: TextStatus;
     constructor(note: Note, data: IText.Data, pcube: CubeChild);
     get adapter(): AdapterCubeText;
-    get status(): StatusText;
+    get status(): TextStatus;
     get attrs(): IText.Attrs;
     get component(): any;
     get is_empty(): boolean;
@@ -586,44 +396,39 @@ declare class CubeText extends CubeChild<IText.Data> {
     find_child_cube(id: ICubeBase.CubeId): CubeChild | undefined;
     export(): IText.Data;
     protected merge_text(offset: number): Recorder;
-    protected on_text_reset(command: ITextCommand.Reset): Recorder;
-    protected on_cursor_loc(cmd: ICursorCommand.Loc): Recorder;
-    protected on_partition(cmd: ICubeCommand.Partition): Recorder | void;
-    protected on_cube_merge(command: ICubeCommand.Merge): Recorder | void;
-    protected on_cube_insert(command: ICubeCommand.Insert): Recorder | undefined;
-    protected on_cube_delete(command: ICubeCommand.Delete): Recorder | undefined;
-    protected on_cube_set_selection_css(command: ICubeCommand.SetSelectionCss): Recorder | void;
-    protected on_cube_break(command: ITextCommand.Break): Recorder | void;
-    protected on_cube_delete_adjacent(command: ICubeCommand.DeleteAdjacent): Recorder | undefined;
+    protected on_text_reset(command: ICommandText.Reset): Recorder;
+    protected on_cursor_loc(cmd: ICommandCursor.Loc): Recorder;
+    protected on_partition(cmd: ICommandCube.Partition): Recorder | void;
+    protected on_cube_merge(command: ICommandCube.Merge): Recorder | void;
+    protected on_cube_insert(command: ICommandCube.Insert): Recorder | undefined;
+    protected on_cube_delete(command: ICommandCube.Delete): Recorder | undefined;
+    protected on_cube_set_selection_css(command: ICommandCube.SetSelectionCss): Recorder | void;
+    protected on_cube_break(command: ICommandText.Break): Recorder | void;
+    protected on_cube_delete_adjacent(command: ICommandCube.DeleteAdjacent): Recorder | undefined;
     add_link(title: string, link: string): Recorder;
-    add_annotation(annotation?: _CubeTextAnnotation): Recorder;
+    add_annotation(annotation?: ICubeBoxRoot.Data): Recorder;
     set_cursor_in_head(offset?: number): void;
     set_cursor_in_tail(offset?: number): void;
     find_text_nav_pos(pos: number, dir: "left" | "right"): number;
     find_text_deleted(pos: number, dir: "left" | "right"): IText.DeleteInfo;
-    is_text_remain(dir: ICubeCommand.DeleteDir, range: [number, number]): boolean;
+    is_text_remain(dir: ICommandCube.DeleteDir, range: [number, number]): boolean;
     drop_zero_width_space(pos: number): INoteCursor.Location;
     can_merge_with(cube: CubeText): boolean;
     get_valid_range(range: [number, number]): [number, number];
     get_valid_index(pos: number | INote.CubeSide): number;
     is_valid_pos(pos: number): boolean;
-    protected _delete_edge(dir: ICubeCommand.DeleteDir): Recorder | undefined;
+    protected _delete_edge(dir: ICommandCube.DeleteDir): Recorder | undefined;
 }
 
-declare class CommandText {
-    static reset(id: string, info: string, pos?: number, pos_before?: number): ITextCommand.Reset;
-    static break(id: string, offset: number): ITextCommand.Break;
-}
-
-declare class StatusLine extends StatusCube<ILine.Data> {
+declare class LineStatus extends CubeStatusBase<ILine.Data> {
     constructor(cube: CubeLine);
 }
 
 declare class CubeLine extends CubeChild<ILine.Data> {
-    protected _status: StatusLine;
+    protected _status: LineStatus;
     constructor(note: Note, data: ILine.Data, pcube: CubeChild);
     get adapter(): AdapterCubeLine;
-    get status(): StatusLine;
+    get status(): LineStatus;
     get children(): CubeChild[];
     get component(): any;
     get editable(): boolean;
@@ -639,22 +444,30 @@ declare class CubeLine extends CubeChild<ILine.Data> {
     update_data(versions: INote.CubesVersion, data: ILine.Data): ICubeBase.CubeUpdateResult;
     gc(): void;
     inherit_line(data: ICubeBase.Data[]): void;
-    on_cube_merge(command: ICubeCommand.Merge): Recorder | void;
-    on_cube_reset(command: ICubeCommand.Reset): Recorder | void;
-    on_insert_child(command: ICubeCommand.InsertChild): Recorder | void;
-    on_delete_child(command: ICubeCommand.DeleteChild): Recorder | void;
-    on_cube_delete_adjacent(command: ICubeCommand.DeleteAdjacent): Recorder | void;
+    on_cube_merge(command: ICommandCube.Merge): Recorder | void;
+    on_cube_reset(command: ICommandCube.Reset): Recorder | void;
+    on_insert_child(command: ICommandCube.InsertChild): Recorder | void;
+    on_delete_child(command: ICommandCube.DeleteChild): Recorder | void;
+    on_cube_delete_adjacent(command: ICommandCube.DeleteAdjacent): Recorder | void;
 }
 
-declare class StatusBoxRoot extends StatusCube<ICubeBoxRoot.Data> {
+declare class AdapterCubeBoxRoot extends CubeAdapterBase {
+    filter_out_empty(cubes: ICubeBase.Data[]): ICubeBase.Data[];
+    get meta(): INote.CubeMeta;
+    get_data(content?: ICubeBase.Data[], css?: Record<string, any>, attrs?: ICubeBase.Attrs): ICubeBoxRoot.Data;
+    replace_id(versions: INote.CubesVersion, data: ICubeBoxRoot.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<ICubeBoxRoot.Data>;
+    update_data(versions: INote.CubesVersion, data: ICubeBoxRoot.Data): ICubeBase.CubeUpdateResult;
+}
+
+declare class BoxRootStatus extends CubeStatusBase<ICubeBoxRoot.Data> {
     constructor(cube: CubeBoxRoot);
 }
 
 declare class CubeBoxRoot extends CubeChild<ICubeBoxRoot.Data> {
-    protected _status: StatusBoxRoot;
+    protected _status: BoxRootStatus;
     constructor(note: Note, data: ICubeBoxRoot.Data, pcube: INote.NoteCube);
     get adapter(): AdapterCubeBoxRoot;
-    get status(): StatusBoxRoot;
+    get status(): BoxRootStatus;
     get children(): CubeChild[];
     get component(): any;
     get is_empty(): boolean;
@@ -662,27 +475,31 @@ declare class CubeBoxRoot extends CubeChild<ICubeBoxRoot.Data> {
     build_child(data: ICubeBoxRoot.Data): void;
     gc(): void;
     export(): ICubeBoxRoot.Data;
-    on_cube_delete_adjacent(command: ICubeCommand.DeleteAdjacent): Recorder;
-    on_merge(command: ICubeCommand.Merge): Recorder | void;
-    on_cube_reorder(command: ICubeCommand.Reorder): Recorder | void;
-    on_cube_reset(command: ICubeCommand.Reset): Recorder | void;
-    on_insert_child(command: ICubeCommand.InsertChild): Recorder | void;
-    on_delete_child(command: ICubeCommand.DeleteChild): Recorder | void;
+    on_cube_delete_adjacent(command: ICommandCube.DeleteAdjacent): Recorder;
+    on_merge(command: ICommandCube.Merge): Recorder | void;
+    on_cube_reorder(command: ICommandCube.Reorder): Recorder | void;
+    on_cube_reset(command: ICommandCube.Reset): Recorder | void;
+    on_insert_child(command: ICommandCube.InsertChild): Recorder | void;
+    on_delete_child(command: ICommandCube.DeleteChild): Recorder | void;
     get_valid_index(pos: number | INote.CubeSide): number;
 }
 
-declare class CommandBoxRoot {
+declare class AdapterCubeBox extends CubeAdapterBase {
+    get meta(): INote.CubeMeta;
+    get_data(content?: ICubeBase.Data[], css?: Record<string, any>, attrs?: Record<string, any>): IBox.Data;
+    replace_id(versions: INote.CubesVersion, data: IBox.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<IBox.Data>;
+    update_data(versions: INote.CubesVersion, data: IBox.Data): ICubeBase.CubeUpdateResult;
 }
 
-declare class StatusBox extends StatusCube<IBox.Data> {
+declare class BoxStatus extends CubeStatusBase<IBox.Data> {
     constructor(cube: CubeBox);
 }
 
 declare class CubeBox extends CubeChild<IBox.Data> {
-    protected _status: StatusBox;
+    protected _status: BoxStatus;
     constructor(note: Note, data: IBox.Data, pcube: CubeChild);
     get adapter(): AdapterCubeBox;
-    get status(): StatusBox;
+    get status(): BoxStatus;
     get children(): CubeChild[];
     get component(): any;
     get attrs(): IBox.Attrs;
@@ -691,24 +508,32 @@ declare class CubeBox extends CubeChild<IBox.Data> {
     build_child(data: IBox.Data): void;
     export(): IBox.Data;
     gc(): void;
-    on_merge(command: ICubeCommand.Merge): Recorder | void;
-    on_box_order(command: ICubeCommand.Reorder): Recorder | void;
-    on_insert_child(command: ICubeCommand.InsertChild): Recorder | void;
-    on_delete_child(command: ICubeCommand.DeleteChild): Recorder | void;
-    on_box_reset(command: ICubeCommand.Reset): Recorder | void;
-    on_cube_delete_adjacent(command: ICubeCommand.DeleteAdjacent): Recorder;
+    on_merge(command: ICommandCube.Merge): Recorder | void;
+    on_box_order(command: ICommandCube.Reorder): Recorder | void;
+    on_insert_child(command: ICommandCube.InsertChild): Recorder | void;
+    on_delete_child(command: ICommandCube.DeleteChild): Recorder | void;
+    on_box_reset(command: ICommandCube.Reset): Recorder | void;
+    on_cube_delete_adjacent(command: ICommandCube.DeleteAdjacent): Recorder;
     get_valid_index(pos: number | INote.CubeSide): number;
 }
 
-declare class StatusBoxFolder extends StatusCube<ICubeBoxFolder.Data> {
+declare class AdapterCubeBoxFolder extends CubeAdapterBase {
+    get meta(): INote.CubeMeta;
+    filter_out_empty(cubes: ICubeBase.Data[]): ICubeBase.Data[];
+    get_data(content?: ICubeBase.Data[], css?: Record<string, any>, attrs?: Partial<ICubeBase.Attrs>): ICubeBoxFolder.Data;
+    replace_id(versions: INote.CubesVersion, data: ICubeBoxFolder.Data, map: Record<string, string>): ICubeBase.ReplaceIdResult<ICubeBoxFolder.Data>;
+    update_data(versions: INote.CubesVersion, data: ICubeBoxFolder.Data): ICubeBase.CubeUpdateResult<ICubeBoxFolder.Data>;
+}
+
+declare class BoxFolderStatus extends CubeStatusBase<ICubeBoxFolder.Data> {
     constructor(cube: CubeBoxFolder);
 }
 
 declare class CubeBoxFolder extends CubeChild<ICubeBoxFolder.Data> {
-    protected _status: StatusBoxFolder;
+    protected _status: BoxFolderStatus;
     constructor(note: Note, data: ICubeBoxFolder.Data, pcube: CubeChild);
     get adapter(): AdapterCubeBoxFolder;
-    get status(): StatusBoxFolder;
+    get status(): BoxFolderStatus;
     get children(): CubeChild[];
     get component(): any;
     get is_empty(): boolean;
@@ -716,28 +541,32 @@ declare class CubeBoxFolder extends CubeChild<ICubeBoxFolder.Data> {
     build_child(data: ICubeBoxFolder.Data): void;
     gc(): void;
     export(): ICubeBoxFolder.Data;
-    on_cube_delete_adjacent(command: ICubeCommand.DeleteAdjacent): Recorder;
-    on_merge(command: ICubeCommand.Merge): Recorder | void;
-    on_cube_reorder(command: ICubeCommand.Reorder): Recorder | void;
-    on_cube_reset(command: ICubeCommand.Reset): Recorder | void;
-    on_insert_child(command: ICubeCommand.InsertChild): Recorder | void;
-    on_delete_child(command: ICubeCommand.DeleteChild): Recorder | void;
+    on_cube_delete_adjacent(command: ICommandCube.DeleteAdjacent): Recorder;
+    on_merge(command: ICommandCube.Merge): Recorder | void;
+    on_cube_reorder(command: ICommandCube.Reorder): Recorder | void;
+    on_cube_reset(command: ICommandCube.Reset): Recorder | void;
+    on_insert_child(command: ICommandCube.InsertChild): Recorder | void;
+    on_delete_child(command: ICommandCube.DeleteChild): Recorder | void;
     get_valid_index(pos: number | INote.CubeSide): number;
 }
 
-declare class CommandBoxFolder {
+declare class AdapterCubeDoc extends CubeAdapterBase {
+    get meta(): INote.CubeMeta;
+    get_data(): IDoc.Data;
+    replace_id(versions: INote.CubesVersion, data: IDoc.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<IDoc.Data>;
+    update_data(versions: INote.CubesVersion, data: IDoc.Data): ICubeBase.CubeUpdateResult;
 }
 
-declare class StatusDoc extends StatusCubeRoot<IDoc.Data> {
+declare class DocStatus extends CubeStatusBaseRoot<IDoc.Data> {
     constructor(cube: CubeDoc);
 }
 
 declare class CubeDoc extends CubeRoot<IDoc.Data> {
-    protected _status: StatusDoc;
+    protected _status: DocStatus;
     protected _app: any;
     constructor(note: Note, data: IDoc.Data);
     get adapter(): AdapterCubeDoc;
-    get status(): StatusDoc;
+    get status(): DocStatus;
     get app(): any;
     get component(): any;
     get meta(): INote.CubeMeta<INote.Cubes>;
@@ -748,7 +577,21 @@ declare class CubeDoc extends CubeRoot<IDoc.Data> {
     render(dom: HTMLElement): void;
 }
 
-declare class StatusLinker extends StatusCube<ILinker.Data> {
+declare class AdapterCubeMap extends CubeAdapterBase {
+    get meta(): INote.CubeMeta;
+    get_data(): IMap.Data;
+    replace_id(versions: INote.CubesVersion, data: IMap.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<IMap.Data>;
+    update_data(versions: INote.CubesVersion, data: IMap.Data): ICubeBase.CubeUpdateResult;
+}
+
+declare class AdapterCubeLinker extends CubeAdapterBase {
+    get meta(): INote.CubeMeta;
+    replace_id(versions: INote.CubesVersion, data: ILinker.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<ILinker.Data>;
+    get_data(from: string, to: string, type?: INodeBase.Line): ILinker.Data;
+    update_data(versions: INote.CubesVersion, data: ILinker.Data): ICubeBase.CubeUpdateResult<ILinker.Data>;
+}
+
+declare class LinkerStatus extends CubeStatusBase<ILinker.Data> {
     protected _path: Ref<string, string>;
     protected _sample: Reactive<IMath.Point[]>;
     protected _point_from: IMath.Point;
@@ -802,7 +645,7 @@ declare class Linker2D extends Map2D {
     protected _prev_to_rect: IMath.Rect;
     constructor(cube: CubeLinker);
     get linker(): CubeLinker;
-    get status(): StatusLinker;
+    get status(): LinkerStatus;
     get path(): string;
     get attrs(): Record<string, any>;
     get sample(): IMath.Point[];
@@ -820,12 +663,12 @@ declare class Linker2D extends Map2D {
 }
 
 declare class CubeLinker extends MapChild<ILinker.Data> {
-    protected _status: StatusLinker;
+    protected _status: LinkerStatus;
     protected _map2d: Linker2D;
     constructor(note: Note, data: ILinker.Data, pcube: _Map);
     get adapter(): AdapterCubeLinker;
     get map2d(): Linker2D;
-    get status(): StatusLinker;
+    get status(): LinkerStatus;
     get show(): boolean;
     get info(): ILinker.Info;
     get rect(): IMath.Rect;
@@ -837,8 +680,8 @@ declare class CubeLinker extends MapChild<ILinker.Data> {
     get id(): string;
     export(): ILinker.Data;
     build_child(data: ILinker.Data): void;
-    get_linker_info(): IMapCommand.LinkerInfo | undefined;
-    protected on_linker_update(cmd: ILinkerCommand.Update): Recorder;
+    get_linker_info(): ICommandMap.LinkerInfo | undefined;
+    protected on_linker_update(cmd: ICommandLinker.Update): Recorder;
 }
 
 declare class LinkerLine {
@@ -888,10 +731,6 @@ declare class LinkerPoint {
     static free_to_any(from: MapNodeBase, to: MapNodeBase): IMapTools.LinePoints | undefined;
 }
 
-declare class CommandLinker {
-    static update(id: ICubeBase.CubeId, attrs: ILinkerCommand.UpdateAttr): ILinkerCommand.Update;
-}
-
 declare abstract class NoteBase {
     protected _note: Note;
     constructor(note: Note);
@@ -904,6 +743,7 @@ declare abstract class NoteBase {
     get api(): typeof NoteApi;
     get courier(): NoteCourier;
     get history(): NoteHistory;
+    get interaction(): NoteInteraction;
     get cursor(): NoteCursor;
     get event(): NoteEvent;
     get listener(): NoteListener;
@@ -912,7 +752,6 @@ declare abstract class NoteBase {
     get painter(): NotePainter;
     get cubes(): NoteCubes;
     get flag(): NoteFlag;
-    get hotkeys(): NoteHotkeys;
     get action(): NoteAction;
 }
 
@@ -980,24 +819,98 @@ declare class MapInteraction extends NoteBase {
     contextmenu(e: MouseEvent): void;
 }
 
+declare abstract class NoteHotkeyBase extends NoteBase {
+    protected _config: INoteInteraction.HotkeyConfig;
+    protected _registered: boolean;
+    abstract get default_config(): INoteInteraction.HotkeyConfig;
+    abstract execution(e: KeyboardEvent, event: HotkeysEvent): any;
+    get id(): string;
+    get note(): Note;
+    get root(): CubeRoot<any>;
+    get config(): {
+        id: string;
+        name: string;
+        shortcut: string;
+        scope: INoteInteraction.Scope;
+        group: INoteInteraction.Groups;
+        show?: boolean;
+        cursor?: boolean;
+        capture?: boolean;
+        keyup?: boolean;
+    };
+    get shortcut(): string;
+    get scope(): INoteInteraction.Scope;
+    check_allow(e: KeyboardEvent, event: HotkeysEvent): boolean;
+    init(note: Note, config?: INoteInteraction.HotkeyConfig): void;
+    register(): void;
+    export(): INoteInteraction.HotkeyConfig;
+}
+
 declare class NoteInteraction extends NoteBase {
-    private _keydown_handler;
-    private _keyup_handler;
-    protected _useable_interaction_keyboard: boolean;
-    protected _map_interaction_keyboard: Map<string, IMapInteraction.KeyboardApi>;
-    protected _note_interaction_keyboard: Map<string, INoteInteraction.KeyboardApi>;
+    protected _hotkeys: Map<string, NoteHotkeyBase>;
+    protected _inited: boolean;
+    protected _useable_keyboard: boolean;
+    data: Reactive<Record<string, INoteInteraction.HotkeyConfig>>;
     constructor(note: Note);
+    get meta(): INote.CoreMeta;
+    set_scope(scope: INoteInteraction.Scope): void;
     get useable_keyboard(): boolean;
-    get map_interactions_keyboard(): IMapInteraction.KeyboardApi[];
-    get note_interactions_keyboard(): INoteInteraction.KeyboardApi[];
-    add_note_interaction_keyboard(interaction: INoteInteraction.KeyboardApi): void;
-    add_map_interaction_keyboard(interaction: IMapInteraction.KeyboardApi): void;
     set_useable_keyboard(useable: boolean): void;
-    register(): void;
-    keydown(e: KeyboardEvent): void;
-    keyup(e: KeyboardEvent): void;
+    listen(dom: HTMLElement): void;
+    init(config?: Partial<INoteInteraction.Data>): void;
+    register(hotkey: NoteHotkeyBase, config?: INoteInteraction.HotkeyConfig): void;
+    protected init_hotkey(hotkey: NoteHotkeyBase, config?: INoteInteraction.HotkeyConfig): void;
+    protected set_data(config: INoteInteraction.HotkeyConfig): void;
+    reset(data: Record<string, INoteInteraction.HotkeyConfig>): void;
+    export(): INoteInteraction.Data;
+    update_data(...args: any[]): object;
+    get_hotkey_str(name: string): string;
+    which(e: KeyboardEvent): INoteInteraction.HotkeyConfig | undefined;
+    validate_hotkeys(e: KeyboardEvent, cursor?: "all" | "cursor" | "uncursor"): boolean;
+    validate(e: KeyboardEvent, info: INoteInteraction.HotkeyConfig): boolean;
+    protected configs(): INoteInteraction.HotkeyConfig[];
+    protected validate_shortcut(e: KeyboardEvent, shortcut: string): boolean;
+    protected normalize_key(key: string): string;
+    static export_default(): INoteInteraction.Data;
 }
 
+declare abstract class NoteEventListenerBase<E extends Event = Event> {
+    protected records: WeakMap<Note, {
+        host: HTMLElement;
+        handler: EventListener;
+    }>;
+    abstract get type(): string;
+    protected abstract get_host(note: Note, dom: HTMLElement): HTMLElement;
+    protected abstract handle(note: Note, e: E): any;
+    register(note: Note, dom: HTMLElement): void;
+}
+
+declare class PasteEventListener extends NoteEventListenerBase<ClipboardEvent> {
+    get type(): string;
+    protected get_host(note: Note, dom: HTMLElement): HTMLElement;
+    protected handle(note: Note, e: ClipboardEvent): Promise<void>;
+}
+declare const paste_event_listener: PasteEventListener;
+
+declare class CopyEventListener extends NoteEventListenerBase<ClipboardEvent> {
+    get type(): string;
+    protected get_host(note: Note, dom: HTMLElement): HTMLElement;
+    protected handle(note: Note, e: ClipboardEvent): void;
+}
+declare const copy_event_listener: CopyEventListener;
+
+declare class CutEventListener extends NoteEventListenerBase<ClipboardEvent> {
+    get type(): string;
+    protected get_host(note: Note, dom: HTMLElement): HTMLElement;
+    protected handle(note: Note, e: ClipboardEvent): void;
+}
+declare const cut_event_listener: CutEventListener;
+
+declare const NoteEventListeners: NoteEventListenerBase[];
+
+declare const MapHotkeys: Map<string, NoteHotkeyBase>;
+declare function hotkey(cls: typeof NoteHotkeyBase): void;
+
 declare class Waiter {
     protected _promise: Promise<any>;
     protected _resolve: Function;
@@ -1009,7 +922,7 @@ declare class Waiter {
 }
 declare const waiter_map_svg: Waiter;
 
-declare class StatusMap extends StatusCubeRoot<IMap.Data> implements IMapBase.Status {
+declare class MapStatus extends CubeStatusBaseRoot<IMap.Data> implements IMapBase.Status {
     protected _nodes_count: vue.Ref<number, number>;
     protected _view_rect: IMath.Rect;
     protected _nodes_view: ShallowReactive<Set<MapNodeBase>>;
@@ -1124,7 +1037,7 @@ declare class MapCanvas extends NoteBase {
 }
 
 declare class CubeMap extends CubeRoot<IMap.Data> implements IMapBase.Api {
-    protected _status: StatusMap;
+    protected _status: MapStatus;
     protected _map_interaction: MapInteraction;
     protected _grider: MapGrider;
     protected _canvas: MapCanvas;
@@ -1155,7 +1068,7 @@ declare class CubeMap extends CubeRoot<IMap.Data> implements IMapBase.Api {
     get linkers_view(): Set<CubeLinker>;
     get line_deleted(): Set<MapNodeBase<any> | CubeLinker>;
     get id(): string;
-    get status(): StatusMap;
+    get status(): MapStatus;
     get grider(): MapGrider;
     get canvas(): MapCanvas;
     get map_interaction(): MapInteraction;
@@ -1176,7 +1089,7 @@ declare class CubeMap extends CubeRoot<IMap.Data> implements IMapBase.Api {
     find_child_cube(id: ICubeBase.CubeId): INote.NoteChild | undefined;
     pick(...elements: MapChild[]): void;
     remove_node(node: MapNodeBase): void;
-    remove_linker(linker: CubeLinker): IMapCommand.LinkerInfo | undefined;
+    remove_linker(linker: CubeLinker): ICommandMap.LinkerInfo | undefined;
     build_child(data: IMap.Data): Promise<void>;
     init_env(): void;
     init_map2d(): void;
@@ -1186,12 +1099,12 @@ declare class CubeMap extends CubeRoot<IMap.Data> implements IMapBase.Api {
     render(dom: HTMLElement): Promise<void>;
     protected is_noop_sibling_move(siblings: string[], node_id: string, target_id: string, type: "prev" | "next"): boolean;
     protected reorder_siblings(siblings: string[], node_id: string, target_id: string, type: "prev" | "next"): boolean;
-    protected on_sibling_reorder(cmd: IMapCommand.SiblingReorder): Recorder | void;
-    protected on_node_add(cmd: IMapCommand.NodeAdd): Recorder;
-    protected on_node_remove(cmd: IMapCommand.NodeRemove): Recorder | undefined;
-    protected on_linker_add(cmd: IMapCommand.LinkerAdd): Recorder | undefined;
-    protected on_linker_remove(cmd: IMapCommand.LinkerRemove): Recorder | undefined;
-    protected on_node_drag(cmd: IMapCommand.NodeMove): Recorder | undefined;
+    protected on_sibling_reorder(cmd: ICommandMap.SiblingReorder): Recorder | void;
+    protected on_node_add(cmd: ICommandMap.NodeAdd): Recorder;
+    protected on_node_remove(cmd: ICommandMap.NodeRemove): Recorder | undefined;
+    protected on_linker_add(cmd: ICommandMap.LinkerAdd): Recorder | undefined;
+    protected on_linker_remove(cmd: ICommandMap.LinkerRemove): Recorder | undefined;
+    protected on_node_drag(cmd: ICommandMap.NodeMove): Recorder | undefined;
     get_nodes_intersection(rect: IMath.Rect): MapNodeBase[];
     get_linker_id(from_id: string, to_id: string): string;
     get_linker(id: string): CubeLinker | undefined;
@@ -1244,22 +1157,29 @@ declare class CubeMap extends CubeRoot<IMap.Data> implements IMapBase.Api {
     check_show_throttle: () => Promise<boolean>;
 }
 
+declare class AdapterCubeNode extends CubeAdapterBase {
+    get meta(): INote.CubeMeta;
+    replace_id(versions: INote.CubesVersion, data: INode.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<INode.Data>;
+    get_data(p: IMath.Point, data?: ICubeBoxRoot.Data[], shape?: INodeBase.Shape): INode.Data;
+    update_data(versions: INote.CubesVersion, data: INode.Data): ICubeBase.CubeUpdateResult<any>;
+}
+
 declare class Node2D extends NodeBase2D {
     constructor(cube: CubeNode);
     get cube(): CubeNode;
 }
 
-declare class StatusNode extends StatusNodeBase<INode.Data> {
+declare class NodeStatus extends NodeStatusBase<INode.Data> {
     constructor(cube: CubeNode);
 }
 
 declare class CubeNode extends MapNodeBase<INode.Data> {
-    protected _status: StatusNode;
+    protected _status: NodeStatus;
     protected _map2d: Node2D;
     constructor(note: Note, data: INode.Data, pcube: _Map);
     get adapter(): AdapterCubeNode;
     get map2d(): Node2D;
-    get status(): StatusNode;
+    get status(): NodeStatus;
     get component(): any;
     build_child(data: INode.Data): void;
     export(): INode.Data;
@@ -1281,15 +1201,30 @@ declare class NodeShape {
     static circle(map2d: NodeBase2D, padding?: number): string;
 }
 
+declare class AdapterCubeApi extends CubeAdapterBase {
+    get meta(): INote.CubeMeta;
+    get type_argument(): Record<string, string>;
+    get type_funciton(): Record<string, string>;
+    get_line_function(funcname?: string): ILine.Data;
+    get_text_function_type(): IText.Data;
+    get_text_function(funcname?: string): IText.Data;
+    get_text_argument(argname?: string): IText.Data;
+    get_text_argument_type(): IText.Data;
+    get_data(css?: INote.Css, attrs?: INote.Attrs): IApi.Data;
+    update_data(versions: INote.CubesVersion, data: any): ICubeBase.CubeUpdateResult<IApi.Data>;
+    to_v2(versions: INote.CubesVersion, data: IApi.V1): IApi.V2;
+    replace_id(versions: INote.CubesVersion, data: IApi.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<IApi.Data>;
+}
+
 declare class CubeApi extends CubeChild<IApi.Data> {
-    protected _status: StatusApi;
+    protected _status: ApiStatus;
     protected _functions: CubeList;
     protected _arguments: CubeList | undefined;
     protected _exceptions: CubeList | undefined;
     protected _temp_funcnames: string[];
     constructor(note: Note, data: IApi.Data, pcube: CubeChild);
     get adapter(): AdapterCubeApi;
-    get status(): StatusApi;
+    get status(): ApiStatus;
     get functions(): CubeList;
     get arguments(): CubeList | undefined;
     set arguments(val: CubeList | undefined);
@@ -1306,10 +1241,18 @@ declare class CubeApi extends CubeChild<IApi.Data> {
     export(): IApi.Data;
 }
 
-declare class CommandApi {
+declare class AdapterCubeList extends CubeAdapterBase {
+    get meta(): INote.CubeMeta;
+    get_data(children?: ICubeBase.Data[]): IList.Data;
+    get_list_item(cubedata: ICubeBase.Data[]): IList.ListItemData;
+    replace_id(versions: INote.CubesVersion, data: IList.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<IList.Data>;
+    update_data(versions: INote.CubesVersion, data: IList.Data): {
+        data: IList.Data;
+        usable: boolean;
+    };
 }
 
-declare class StatusList extends StatusCube<IList.Data> {
+declare class ListStatus extends CubeStatusBase<IList.Data> {
     protected _items: IList.ListItem[];
     constructor(cube: CubeList);
     get cube(): CubeList;
@@ -1321,11 +1264,11 @@ declare class StatusList extends StatusCube<IList.Data> {
 }
 
 declare class CubeList extends CubeChild<IList.Data> {
-    protected _status: StatusList;
+    protected _status: ListStatus;
     protected _items: IList.ListItem[];
     constructor(note: Note, data: IList.Data, pcube: CubeChild);
     get adapter(): AdapterCubeList;
-    get status(): StatusList;
+    get status(): ListStatus;
     get component(): any;
     get items(): IList.ListItem[];
     get children(): CubeBox[];
@@ -1341,14 +1284,14 @@ declare class CubeList extends CubeChild<IList.Data> {
     splice_items(index: number, delete_count: number, ...insert: IList.ListItem[]): ICubeBase.CubeSpliceResult<IList.ListItem, IList.ListItemData>;
     create(data: IList.ListItemData[]): IList.ListItem[];
     create_item_data(indent?: number): IList.ListItemData;
-    protected on_reset(cmd: IListCommand.Reset): Recorder;
-    protected add_item(cmd: IListCommand.AddItem): Recorder;
-    protected remove_item(cmd: IListCommand.RemoveItem): Recorder | undefined;
-    protected indent_item(cmd: IListCommand.IndentItem): Recorder;
-    on_delete_child(command: ICubeCommand.DeleteChild): Recorder | void;
+    protected on_reset(cmd: ICommandList.Reset): Recorder;
+    protected add_item(cmd: ICommandList.AddItem): Recorder;
+    protected remove_item(cmd: ICommandList.RemoveItem): Recorder | undefined;
+    protected indent_item(cmd: ICommandList.IndentItem): Recorder;
+    on_delete_child(command: ICommandCube.DeleteChild): Recorder | void;
 }
 
-declare class StatusApi extends StatusCube<IApi.Data> {
+declare class ApiStatus extends CubeStatusBase<IApi.Data> {
     protected _arguments: ShallowRef<CubeList | undefined>;
     protected _exceptions: ShallowRef<CubeList | undefined>;
     constructor(cube: CubeApi);
@@ -1358,25 +1301,14 @@ declare class StatusApi extends StatusCube<IApi.Data> {
     update_exceptions(excs: CubeList | undefined): Promise<void>;
 }
 
-declare class StatusAnnotation extends StatusCube<_CubeTextAnnotation> {
-    constructor(cube: CubeAnnotation);
-}
-
-declare class CubeAnnotation extends CubeChild<_CubeTextAnnotation> {
-    protected _status: StatusAnnotation;
-    constructor(note: Note, data: _CubeTextAnnotation, pcube: CubeChild);
-    get adapter(): AdapterCubeAnnotation;
-    get status(): StatusAnnotation;
-    get component(): any;
-    gc(): void;
-    export(): _CubeTextAnnotation;
-    build_child(data: _CubeTextAnnotation): void;
-    on_insert_child(command: ICubeCommand.InsertChild): Recorder | void;
-    on_delete_child(command: ICubeCommand.DeleteChild): Recorder | void;
-    on_reset(cmd: ICubeCommand.Reset): Recorder | void;
+declare class AdapterCubeDetailList extends CubeAdapterBase {
+    get meta(): INote.CubeMeta;
+    get_data(info?: IDetailList.BoxDataMap[], css?: Record<string, any>, attrs?: Record<string, any>): IDetailList.Data;
+    replace_id(versions: INote.CubesVersion, data: IDetailList.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<IDetailList.Data>;
+    update_data(versions: INote.CubesVersion, data: IDetailList.Data): ICubeBase.CubeUpdateResult<IDetailList.Data>;
 }
 
-declare class StatusDetailList extends StatusCube<IDetailList.Data> {
+declare class DetailListStatus extends CubeStatusBase<IDetailList.Data> {
     protected _rows: IDetailList.BoxMap[];
     constructor(cube: CubeDetailList);
     get children(): CubeBox[];
@@ -1403,29 +1335,29 @@ declare namespace IDetailList {
     }
 }
 
-declare namespace IDetailListCommand {
-    interface InsertRow extends ICubeCommand.BaseCommand {
+declare namespace ICommandDetailList {
+    interface InsertRow extends ICommandCube.BaseCommand {
         name: "detail-list:insert-row";
         pos: number | INote.CubeSide;
         rows: IDetailList.BoxDataMap[];
     }
-    interface RemoveRow extends ICubeCommand.BaseCommand {
+    interface RemoveRow extends ICommandCube.BaseCommand {
         name: "detail-list:remove-row";
         range: [number, number];
         reserve: boolean;
     }
-    interface ChangeWidthCol1 extends ICubeCommand.BaseCommand {
+    interface ChangeWidthCol1 extends ICommandCube.BaseCommand {
         name: "detail-list:change-width-col1";
         width: number;
     }
 }
 
 declare class CubeDetailList extends CubeChild<IDetailList.Data> {
-    protected _status: StatusDetailList;
+    protected _status: DetailListStatus;
     protected _rows: IDetailList.BoxMap[];
     constructor(note: Note, data: IDetailList.Data, pcube: CubeChild);
     get adapter(): AdapterCubeDetailList;
-    get status(): StatusDetailList;
+    get status(): DetailListStatus;
     get rows(): IDetailList.BoxMap[];
     get component(): any;
     get children(): CubeBox[];
@@ -1443,19 +1375,20 @@ declare class CubeDetailList extends CubeChild<IDetailList.Data> {
     export(): IDetailList.Data;
     splice_rows(pos: number, deletecount: number, ...items: IDetailList.BoxMap[]): IDetailList.BoxMap[];
     check_delete_edge(child: CubeChild): boolean;
-    insert_row(cmd: IDetailListCommand.InsertRow): Recorder | void;
-    remove_row(cmd: IDetailListCommand.RemoveRow): Recorder | void;
-    protected change_width_col1(cmd: IDetailListCommand.ChangeWidthCol1): Recorder;
-    delete_cube(command: ICubeCommand.DeleteChild): Recorder | void;
+    insert_row(cmd: ICommandDetailList.InsertRow): Recorder | void;
+    remove_row(cmd: ICommandDetailList.RemoveRow): Recorder | void;
+    protected change_width_col1(cmd: ICommandDetailList.ChangeWidthCol1): Recorder;
+    delete_cube(command: ICommandCube.DeleteChild): Recorder | void;
 }
 
-declare class CommandDetailList {
-    static insert_row(id: ICubeBase.CubeId, pos: number | INote.CubeSide, rows: IDetailList.BoxDataMap[]): IDetailListCommand.InsertRow;
-    static remove_row(id: ICubeBase.CubeId, range: [number, number], reserve?: boolean): IDetailListCommand.RemoveRow;
-    static change_width_col1(id: ICubeBase.CubeId, width: number): IDetailListCommand.ChangeWidthCol1;
+declare class AdapterCubePostil extends CubeAdapterBase {
+    get meta(): INote.CubeMeta;
+    get_data(data?: ICubeBase.Data[], css?: Record<string, any>): IPostil.V1;
+    replace_id(versions: INote.CubesVersion, data: any, map?: Record<string, string>): ICubeBase.ReplaceIdResult<IPostil.Data>;
+    update_data(versions: INote.CubesVersion, data: any): ICubeBase.CubeUpdateResult<IPostil.Data>;
 }
 
-declare class StatusPostil extends StatusCube<IPostil.V1> {
+declare class PostilStatus extends CubeStatusBase<IPostil.V1> {
     protected _show: vue.Ref<boolean, boolean>;
     protected _pointer_angle: vue.Ref<number, number>;
     constructor(cube: CubePostil);
@@ -1467,14 +1400,14 @@ declare class StatusPostil extends StatusCube<IPostil.V1> {
 }
 
 declare class CubePostil extends CubeChild<IPostil.V1> {
-    protected _status: StatusPostil;
+    protected _status: PostilStatus;
     protected _handler_update_pos: any;
     protected _handler_corrent: any;
     protected _timer_corrent: any;
     protected _show: boolean;
     constructor(note: Note, data: IPostil.V1, pcube: INote.NoteChild);
     get adapter(): AdapterCubePostil;
-    get status(): StatusPostil;
+    get status(): PostilStatus;
     get default_size(): IMath.Rect;
     get show(): boolean;
     set show(v: boolean);
@@ -1484,23 +1417,30 @@ declare class CubePostil extends CubeChild<IPostil.V1> {
     protected build_child(data: IPostil.Data): void;
     export(): IPostil.V1;
     gc(): void;
-    protected on_insert_child(command: ICubeCommand.InsertChild): Recorder | void;
-    protected on_delete_child(command: ICubeCommand.DeleteChild): Recorder | void;
-    protected on_reset(cmd: ICubeCommand.Reset): Recorder | void;
+    protected on_insert_child(command: ICommandCube.InsertChild): Recorder | void;
+    protected on_delete_child(command: ICommandCube.DeleteChild): Recorder | void;
+    protected on_reset(cmd: ICommandCube.Reset): Recorder | void;
     visible(show: boolean): void;
     update_pos(fresh?: boolean): void;
     update_pointer(): void;
 }
 
-declare class StatusTextLink extends StatusCube<ITextLink.Data> {
+declare class AdapterCubeTextLink extends CubeAdapterBase {
+    get meta(): INote.CubeMeta;
+    get_data(url: string, title: string, css?: Record<string, any>, attrs?: Record<string, any>): ITextLink.Data;
+    replace_id(versions: INote.CubesVersion, data: ITextLink.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<ITextLink.Data>;
+    update_data(versions: INote.CubesVersion, data: ITextLink.Data): ICubeBase.CubeUpdateResult<ITextLink.Data>;
+}
+
+declare class TextLinkStatus extends CubeStatusBase<ITextLink.Data> {
     constructor(cube: CubeTextLink);
 }
 
 declare class CubeTextLink extends CubeChild<ITextLink.Data> {
-    protected _status: StatusTextLink;
+    protected _status: TextLinkStatus;
     constructor(note: Note, data: ITextLink.Data, pcube: CubeChild);
     get adapter(): AdapterCubeTextLink;
-    get status(): StatusTextLink;
+    get status(): TextLinkStatus;
     get info(): ITextLink.Info;
     get component(): any;
     get url(): string;
@@ -1508,11 +1448,15 @@ declare class CubeTextLink extends CubeChild<ITextLink.Data> {
     protected build_child(data: ITextLink.Data): void;
     gc(): void;
     export(): ITextLink.Data;
-    protected on_update_info(command: ITextLinkCommand.Update): Recorder | void;
+    protected on_update_info(command: ICommandTextLink.Update): Recorder | void;
 }
 
-declare class CommandTextLink {
-    static update(id: ICubeBase.CubeId, title: string, url: string): ITextLinkCommand.Update;
+declare class AdapterCubeTodo extends CubeAdapterBase {
+    get meta(): INote.CubeMeta;
+    get_data(): ITodo.Data;
+    get_todo_item(cubedata: ICubeBase.Data[], done?: boolean): _CubeTodoItemData;
+    replace_id(versions: INote.CubesVersion, data: ITodo.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<ITodo.Data>;
+    update_data(versions: INote.CubesVersion, data: ITodo.Data): ICubeBase.CubeUpdateResult<ITodo.Data>;
 }
 
 declare namespace IBox {
@@ -1542,25 +1486,25 @@ interface _CubeTodoItem {
     data: CubeBox;
 }
 
-declare namespace ITodoCommand {
-    interface Reset extends ICubeCommand.BaseCommand {
+declare namespace ICommandTodo {
+    interface Reset extends ICommandCube.BaseCommand {
         name: "todo:reset";
         data: _CubeTodoItemData[];
     }
-    interface AddItem extends ICubeCommand.BaseCommand {
+    interface AddItem extends ICommandCube.BaseCommand {
         name: "todo:add";
         data: _CubeTodoItemData[];
         pos: number;
     }
-    interface RemoveItem extends ICubeCommand.BaseCommand {
+    interface RemoveItem extends ICommandCube.BaseCommand {
         name: "todo:remove";
         range: [number, number];
     }
-    interface Indent extends ICubeCommand.BaseCommand {
+    interface Indent extends ICommandCube.BaseCommand {
         name: "todo:indent";
         items: ItemIndentInfo[];
     }
-    interface Status extends ICubeCommand.BaseCommand {
+    interface Status extends ICommandCube.BaseCommand {
         name: "todo:status";
         index: number;
         done: boolean;
@@ -1571,7 +1515,7 @@ declare namespace ITodoCommand {
     }
 }
 
-declare class StatusTodo extends StatusCube<ITodo.Data> {
+declare class TodoStatus extends CubeStatusBase<ITodo.Data> {
     protected _items: _CubeTodoItem[];
     constructor(cube: CubeTodo);
     get items(): _CubeTodoItem[];
@@ -1584,11 +1528,11 @@ declare class StatusTodo extends StatusCube<ITodo.Data> {
 }
 
 declare class CubeTodo extends CubeChild<ITodo.Data> {
-    protected _status: StatusTodo;
+    protected _status: TodoStatus;
     protected _items: _CubeTodoItem[];
     constructor(note: Note, data: ITodo.Data, pcube: CubeChild);
     get adapter(): AdapterCubeTodo;
-    get status(): StatusTodo;
+    get status(): TodoStatus;
     get items(): _CubeTodoItem[];
     get component(): any;
     get children(): CubeBox[];
@@ -1602,23 +1546,26 @@ declare class CubeTodo extends CubeChild<ITodo.Data> {
     splice_items(index: number, delete_count: number, ...insert: _CubeTodoItem[]): ICubeBase.CubeSpliceResult<_CubeTodoItem, _CubeTodoItemData>;
     create(data: _CubeTodoItemData[]): _CubeTodoItem[];
     create_item_data(indent?: number): _CubeTodoItemData;
-    protected on_reset(cmd: ITodoCommand.Reset): Recorder;
-    protected add_item(cmd: ITodoCommand.AddItem): Recorder;
-    protected remove_item(cmd: ITodoCommand.RemoveItem): Recorder | undefined;
-    protected indent_todoitem(cmd: ITodoCommand.Indent): Recorder;
-    update_status(cmd: ITodoCommand.Status): Recorder | undefined;
-    on_delete_child(command: ICubeCommand.DeleteChild): Recorder | void;
+    protected on_reset(cmd: ICommandTodo.Reset): Recorder;
+    protected add_item(cmd: ICommandTodo.AddItem): Recorder;
+    protected remove_item(cmd: ICommandTodo.RemoveItem): Recorder | undefined;
+    protected indent_todoitem(cmd: ICommandTodo.Indent): Recorder;
+    update_status(cmd: ICommandTodo.Status): Recorder | undefined;
+    on_delete_child(command: ICommandCube.DeleteChild): Recorder | void;
 }
 
-declare class CommandTodo {
-    static reset(id: string, data: _CubeTodoItemData[]): ITodoCommand.Reset;
-    static add(id: string, data: _CubeTodoItemData[], pos: number): ITodoCommand.AddItem;
-    static remove(id: string, range: [number, number]): ITodoCommand.RemoveItem;
-    static indent(id: string, items: IListCommand.ItemIndentInfo[]): ITodoCommand.Indent;
-    static status(id: string, index: number, done: boolean): ITodoCommand.Status;
+declare class AdapterCubeListOrdered extends CubeAdapterBase {
+    get meta(): INote.CubeMeta;
+    get_data(): IListOrdered.Data;
+    get_list_item(cubedata: ICubeBase.Data[]): IList.ListItemData;
+    replace_id(versions: INote.CubesVersion, data: IListOrdered.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<IListOrdered.Data>;
+    update_data(versions: INote.CubesVersion, data: IListOrdered.Data): {
+        data: IListOrdered.Data;
+        usable: boolean;
+    };
 }
 
-declare class StatusListOrdered extends StatusCube<IListOrdered.Data> {
+declare class ListOrderedStatus extends CubeStatusBase<IListOrdered.Data> {
     protected _items: IList.ListItem[];
     constructor(cube: CubeListOrdered);
     get cube(): CubeListOrdered;
@@ -1630,10 +1577,10 @@ declare class StatusListOrdered extends StatusCube<IListOrdered.Data> {
 }
 
 declare class CubeListOrdered extends CubeChild<IListOrdered.Data> {
-    protected _status: StatusListOrdered;
+    protected _status: ListOrderedStatus;
     protected _items: IList.ListItem[];
     constructor(note: Note, data: IListOrdered.Data, pcube: CubeChild);
-    get status(): StatusListOrdered;
+    get status(): ListOrderedStatus;
     get component(): any;
     get children(): CubeBox[];
     get items(): IList.ListItem[];
@@ -1648,31 +1595,34 @@ declare class CubeListOrdered extends CubeChild<IListOrdered.Data> {
     splice_items(index: number, delete_count: number, ...insert: IList.ListItem[]): ICubeBase.CubeSpliceResult<IList.ListItem, IList.ListItemData>;
     create(data: IList.ListItemData[]): IList.ListItem[];
     create_item_data(indent?: number): IList.ListItemData;
-    protected on_reset(cmd: IListOrderedCommand.Reset): Recorder;
-    protected add_item(cmd: IListOrderedCommand.AddItem): Recorder;
-    protected remove_item(cmd: IListOrderedCommand.RemoveItem): Recorder | undefined;
-    protected indent_item(cmd: IListOrderedCommand.IndentItem): Recorder;
-    on_delete_child(command: ICubeCommand.DeleteChild): Recorder | void;
-}
-
-declare class CommandListOrdered {
-    static reset(id: string, data: IList.ListItemData[]): IListOrderedCommand.Reset;
-    static add(id: string, data: IList.ListItemData[], pos: number): IListOrderedCommand.AddItem;
-    static remove(id: string, range: [number, number]): IListOrderedCommand.RemoveItem;
-    static indent(id: string, items: IListCommand.ItemIndentInfo[]): IListOrderedCommand.IndentItem;
+    protected on_reset(cmd: ICommandListOrdered.Reset): Recorder;
+    protected add_item(cmd: ICommandListOrdered.AddItem): Recorder;
+    protected remove_item(cmd: ICommandListOrdered.RemoveItem): Recorder | undefined;
+    protected indent_item(cmd: ICommandListOrdered.IndentItem): Recorder;
+    on_delete_child(command: ICommandCube.DeleteChild): Recorder | void;
 }
 
-declare class CommandCode {
-    static update(id: string, tabid: string, code: string): ICodeCommand.Update;
-    static add(id: string, item: ICode.TabItem, focus?: boolean): ICodeCommand.Add;
-    static remove(id: string, tabid: string): ICodeCommand.Remove;
-    static rename(id: string, tabid: string, filename: string): ICodeCommand.Rename;
-    static change_lang(id: string, tabid: string, lang: string): ICodeCommand.ChangeLang;
-    static change_active(id: string, tabid: string): ICodeCommand.TabActive;
-    static change_theme(id: string, tabid: string, theme: string): ICodeCommand.ChangeTheme;
+declare class AdapterCubeCode extends CubeAdapterBase {
+    protected _langs: string[];
+    protected _themes: string[];
+    protected _highlighter: Highlighter | undefined;
+    get langs(): string[];
+    get themes(): string[];
+    get meta(): INote.CubeMeta;
+    get highlighter(): Highlighter | undefined;
+    get lang_map(): {
+        [x: string]: ICode.Langs;
+    };
+    constructor();
+    get_data(): ICode.Data;
+    get_data_by_string(lang?: string, code?: string): ICode.Data;
+    replace_id(versions: INote.CubesVersion, data: ICode.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<ICode.Data>;
+    get_format_from_lang(lang: string): string;
+    get_lang_from_format(format: string): ICode.Langs;
+    update_data(versions: INote.CubesVersion, data: ICode.Data): ICubeBase.CubeUpdateResult;
 }
 
-declare class StatusCode extends StatusCube<ICode.Data> {
+declare class CodeStatus extends CubeStatusBase<ICode.Data> {
     protected _code_html: vue.Ref<string, string>;
     protected _bg: vue.Ref<string, string>;
     protected _fg: vue.Ref<string, string>;
@@ -1700,13 +1650,13 @@ declare class StatusCode extends StatusCube<ICode.Data> {
 }
 
 declare class CubeCode extends CubeChild<ICode.Data> {
-    protected _status: StatusCode;
+    protected _status: CodeStatus;
     protected _code_html: string;
     _draglist: DragList | undefined;
     constructor(note: Note, data: ICode.Data, pcube: CubeChild);
     get adapter(): AdapterCubeCode;
     get highlighter(): Highlighter | undefined;
-    get status(): StatusCode;
+    get status(): CodeStatus;
     get tabbar_height(): number;
     get max_height_auto(): number;
     get langs(): string[];
@@ -1732,18 +1682,26 @@ declare class CubeCode extends CubeChild<ICode.Data> {
     update_code_html(): void;
     create_tab(lang: ICode.Langs, name: string, theme?: string): ICode.TabItem;
     copy_code(): Function | undefined;
-    protected change_lang(cmd: ICodeCommand.ChangeLang): Recorder | undefined;
-    protected change_theme(cmd: ICodeCommand.ChangeTheme): Recorder | undefined;
-    protected code_update(cmd: ICodeCommand.Update): Recorder | undefined;
-    protected code_add(cmd: ICodeCommand.Add): Recorder;
-    protected code_remove(cmd: ICodeCommand.Remove): Recorder | undefined;
-    protected code_rename(cmd: ICodeCommand.Rename): Recorder | undefined;
-    protected change_active(cmd: ICodeCommand.TabActive): Recorder | undefined;
-    on_cursor_in_tail(command: ICursorCommand.InTail): Recorder;
-    on_cursor_in_head(command: ICursorCommand.InHead): Recorder;
-}
-
-declare class Statusformula extends StatusCube<IFormula.Data> {
+    protected change_lang(cmd: ICommandCode.ChangeLang): Recorder | undefined;
+    protected change_theme(cmd: ICommandCode.ChangeTheme): Recorder | undefined;
+    protected code_update(cmd: ICommandCode.Update): Recorder | undefined;
+    protected code_add(cmd: ICommandCode.Add): Recorder;
+    protected code_remove(cmd: ICommandCode.Remove): Recorder | undefined;
+    protected code_rename(cmd: ICommandCode.Rename): Recorder | undefined;
+    protected change_active(cmd: ICommandCode.TabActive): Recorder | undefined;
+    on_cursor_in_tail(command: ICommandCursor.InTail): Recorder;
+    on_cursor_in_head(command: ICommandCursor.InHead): Recorder;
+}
+
+declare class AdapterCubeFormula extends CubeAdapterBase {
+    get meta(): INote.CubeMeta;
+    get_data(formula?: string, css?: Record<string, string>, attrs?: Partial<IFormula.Attrs>): IFormula.Data;
+    replace_id(versions: INote.CubesVersion, data: IFormula.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<IFormula.Data>;
+    update_data(versions: INote.CubesVersion, data: IFormula.Data): ICubeBase.CubeUpdateResult;
+    render(latex: string, options?: KatexOptions): string;
+}
+
+declare class FormulaStatus extends CubeStatusBase<IFormula.Data> {
     constructor(cube: CubeFormula);
     protected _mathml: vue.ComputedRef<string>;
     get cube(): CubeFormula;
@@ -1753,10 +1711,10 @@ declare class Statusformula extends StatusCube<IFormula.Data> {
 }
 
 declare class CubeFormula extends CubeChild<IFormula.Data> {
-    protected _status: Statusformula;
+    protected _status: FormulaStatus;
     constructor(note: Note, data: IFormula.Data, pcube: CubeChild);
     get adapter(): AdapterCubeFormula;
-    get status(): Statusformula;
+    get status(): FormulaStatus;
     get component(): any;
     get attrs(): IFormula.Attrs;
     get meta(): INote.CubeMeta<INote.Cubes>;
@@ -1764,14 +1722,18 @@ declare class CubeFormula extends CubeChild<IFormula.Data> {
     protected build_child(data: IFormula.Data): void;
     export(): IFormula.Data;
     gc(): void;
-    protected update(cmd: IFormulaCommand.Update): Recorder;
+    protected update(cmd: ICommandFormula.Update): Recorder;
 }
 
-declare class Commandformula {
-    static update(id: string, latex: string, size: IFormula.Size, block?: boolean): IFormulaCommand.Update;
+declare class AdapterCubeTable extends CubeAdapterBase {
+    get meta(): INote.CubeMeta;
+    get_data(row?: number, col?: number): ITable.Data;
+    get_data_by_data(size: [number, number], cells: ITable.CellData[]): ITable.Data;
+    replace_id(versions: INote.CubesVersion, data: ITable.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<ITable.Data>;
+    update_data(versions: INote.CubesVersion, data: ITable.Data): ICubeBase.CubeUpdateResult<ITable.Data>;
 }
 
-declare class StatusTable extends StatusCube<ITable.Data> {
+declare class TableStatus extends CubeStatusBase<ITable.Data> {
     protected _cells: ITable.Cell[];
     protected _title: ShallowRef<CubeBox | undefined>;
     constructor(cube: CubeTable);
@@ -1788,12 +1750,12 @@ declare class StatusTable extends StatusCube<ITable.Data> {
 }
 
 declare class CubeTable extends CubeChild<ITable.Data> {
-    protected _status: StatusTable;
+    protected _status: TableStatus;
     protected _cells: ITable.Cell[];
     protected _title: CubeBox | undefined;
     constructor(note: Note, data: ITable.Data, pcube: CubeChild);
     get adapter(): AdapterCubeTable;
-    get status(): StatusTable;
+    get status(): TableStatus;
     get title(): CubeBox | undefined;
     set title(v: CubeBox | undefined);
     get component(): any;
@@ -1831,54 +1793,43 @@ declare class CubeTable extends CubeChild<ITable.Data> {
     get_selection_size(): [number, number] | undefined;
     get_selection_text(): string;
     copy_selection_table(): ITable.Data | undefined;
-    add_title(cmd: ITableCommand.AddTitle): Recorder;
-    remove_title(cmd: ITableCommand.RemoveTitle): Recorder | undefined;
-    add_cell(cmd: ITableCommand.AddCell): Recorder;
-    remove_cell(cmd: ITableCommand.RemoveCell): Recorder | undefined;
-    add_row(cmd: ITableCommand.AddRow): Recorder;
-    remove_row(cmd: ITableCommand.RemoveRow): Recorder;
-    add_col(cmd: ITableCommand.AddCol): Recorder;
-    remove_col(cmd: ITableCommand.RemoveCol): Function | Recorder | undefined;
-    moveto(cmd: ITableCommand.CellMoveTo): Recorder | undefined;
-    protected update_area(cmd: ITableCommand.CellUpdateArea): Recorder | undefined;
-    merge_cell(cmd: ITableCommand.Merge): Recorder | undefined;
-    add_grid_col(cmd: ITableCommand.AddGridCol): Recorder;
-    remove_grid_col(cmd: ITableCommand.RemoveGridCol): Recorder | undefined;
-    add_grid_row(cmd: ITableCommand.AddGridRow): Recorder;
-    remove_grid_row(cmd: ITableCommand.RemoveGridRow): Recorder | undefined;
-    col_resize(cmd: ITableCommand.ColResize): Recorder | undefined;
-    delete_child(cmd: ICubeCommand.DeleteChild): Recorder | undefined;
+    add_title(cmd: ICommandTable.AddTitle): Recorder;
+    remove_title(cmd: ICommandTable.RemoveTitle): Recorder | undefined;
+    add_cell(cmd: ICommandTable.AddCell): Recorder;
+    remove_cell(cmd: ICommandTable.RemoveCell): Recorder | undefined;
+    add_row(cmd: ICommandTable.AddRow): Recorder;
+    remove_row(cmd: ICommandTable.RemoveRow): Recorder;
+    add_col(cmd: ICommandTable.AddCol): Recorder;
+    remove_col(cmd: ICommandTable.RemoveCol): Function | Recorder | undefined;
+    moveto(cmd: ICommandTable.CellMoveTo): Recorder | undefined;
+    protected update_area(cmd: ICommandTable.CellUpdateArea): Recorder | undefined;
+    merge_cell(cmd: ICommandTable.Merge): Recorder | undefined;
+    add_grid_col(cmd: ICommandTable.AddGridCol): Recorder;
+    remove_grid_col(cmd: ICommandTable.RemoveGridCol): Recorder | undefined;
+    add_grid_row(cmd: ICommandTable.AddGridRow): Recorder;
+    remove_grid_row(cmd: ICommandTable.RemoveGridRow): Recorder | undefined;
+    col_resize(cmd: ICommandTable.ColResize): Recorder | undefined;
+    delete_child(cmd: ICommandCube.DeleteChild): Recorder | undefined;
+}
+
+declare class AdapterCubeTip extends CubeAdapterBase {
+    get meta(): INote.CubeMeta;
+    get_data(cubes: ICubeBase.Data[], css?: Record<string, string>, attrs?: Record<string, string>): ITip.Data;
+    get_data_by_string(info: string, css?: Record<string, string>, attrs?: Record<string, string>): ITip.Data;
+    replace_id(versions: INote.CubesVersion, data: ITip.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<ITip.Data>;
+    update_data(versions: INote.CubesVersion, data: ITip.Data): ICubeBase.CubeUpdateResult<ITip.Data>;
 }
 
-declare class CommandTable {
-    static add_title(id: ICubeBase.CubeId, data: IBox.Data): ITableCommand.AddTitle;
-    static remove_title(id: ICubeBase.CubeId): ITableCommand.RemoveTitle;
-    static add_cell(id: ICubeBase.CubeId, data: ITable.CellData): ITableCommand.AddCell;
-    static remove_cell(id: ICubeBase.CubeId, cid: ICubeBase.CubeId): ITableCommand.RemoveCell;
-    static add_row(id: ICubeBase.CubeId, index: number, rows: IBox.Data[]): ITableCommand.AddRow;
-    static remove_row(id: ICubeBase.CubeId, index: number): ITableCommand.RemoveRow;
-    static add_col(id: ICubeBase.CubeId, index: number, cols: IBox.Data[]): ITableCommand.AddCol;
-    static remove_col(id: ICubeBase.CubeId, index: number): ITableCommand.RemoveCol;
-    static moveto(id: ICubeBase.CubeId, tid: ICubeBase.CubeId, cells: ICubeBase.CubeId[]): ITableCommand.CellMoveTo;
-    static merge(id: ICubeBase.CubeId, area: ITable.CellArea): ITableCommand.Merge;
-    static update_cell_area(id: ICubeBase.CubeId, tid: ICubeBase.CubeId, area: ITable.CellRect): ITableCommand.CellUpdateArea;
-    static add_grid_col(id: ICubeBase.CubeId, index: number, width: number): ITableCommand.AddGridCol;
-    static remove_grid_col(id: ICubeBase.CubeId, index: number): ITableCommand.RemoveGridCol;
-    static add_grid_row(id: ICubeBase.CubeId, index: number): ITableCommand.AddGridRow;
-    static remove_grid_row(id: ICubeBase.CubeId, index: number): ITableCommand.RemoveGridRow;
-    static col_resize(id: ICubeBase.CubeId, cols: [number, number], step: number): ITableCommand.ColResize;
-}
-
-declare class StatusTip extends StatusCube<ITip.Data> {
+declare class TipStatus extends CubeStatusBase<ITip.Data> {
     constructor(cube: CubeTip);
 }
 
 declare class CubeTip extends CubeChild<ITip.Data> {
-    protected _status: StatusTip;
+    protected _status: TipStatus;
     protected _box: CubeBox;
     constructor(note: Note, data: ITip.Data, pcube: CubeChild);
     get adapter(): AdapterCubeTip;
-    get status(): StatusTip;
+    get status(): TipStatus;
     get component(): any;
     get box(): CubeBox;
     set box(value: CubeBox);
@@ -1886,11 +1837,18 @@ declare class CubeTip extends CubeChild<ITip.Data> {
     protected build_child(data: ITip.Data): void;
     export(): ITip.Data;
     gc(): void;
-    on_insert_child(command: ICubeCommand.InsertChild): Recorder | void;
-    on_delete_child(command: ICubeCommand.DeleteChild): Recorder | void;
+    on_insert_child(command: ICommandCube.InsertChild): Recorder | void;
+    on_delete_child(command: ICommandCube.DeleteChild): Recorder | void;
 }
 
-declare class StatusSubmap extends StatusCube<ISubMap.Data> implements IMapBase.Status {
+declare class AdapterCubeSubmap extends CubeAdapterBase {
+    get meta(): INote.CubeMeta;
+    get_data(width?: number, height?: number): ISubMap.Data;
+    replace_id(versions: INote.CubesVersion, data: ISubMap.Data, map?: Record<string, string>): ICubeBase.ReplaceIdResult<ISubMap.Data>;
+    update_data(versions: INote.CubesVersion, data: ISubMap.Data): ICubeBase.CubeUpdateResult<ISubMap.Data>;
+}
+
+declare class SubmapStatus extends CubeStatusBase<ISubMap.Data> implements IMapBase.Status {
     protected _nodes_count: vue.Ref<number, number>;
     protected _view_rect: IMath.Rect;
     protected _nodes_view: ShallowReactive<Set<MapNodeBase>>;
@@ -1979,7 +1937,7 @@ declare class StatusSubmap extends StatusCube<ISubMap.Data> implements IMapBase.
 }
 
 declare class CubeSubMap extends CubeChild<ISubMap.Data> implements IMapBase.Api {
-    protected _status: StatusSubmap;
+    protected _status: SubmapStatus;
     protected _map_interaction: MapInteraction;
     protected _grider: MapGrider;
     protected _has_layout: boolean;
@@ -1998,7 +1956,7 @@ declare class CubeSubMap extends CubeChild<ISubMap.Data> implements IMapBase.Api
     protected _view_rect: Reactive<IMath.Rect>;
     constructor(note: Note, data: ISubMap.Data, pcube: CubeChild);
     get adapter(): AdapterCubeSubmap;
-    get status(): StatusSubmap;
+    get status(): SubmapStatus;
     get grider(): MapGrider;
     get nodes(): Map<string, MapNodeBase<any>>;
     get linkers(): Map<string, CubeLinker>;
@@ -2044,15 +2002,15 @@ declare class CubeSubMap extends CubeChild<ISubMap.Data> implements IMapBase.Api
     init_grider(): void;
     export(): ISubMap.Data;
     remove_node(node: MapNodeBase): void;
-    remove_linker(linker: CubeLinker): IMapCommand.LinkerInfo | undefined;
+    remove_linker(linker: CubeLinker): ICommandMap.LinkerInfo | undefined;
     protected is_noop_sibling_move(siblings: string[], node_id: string, target_id: string, type: "prev" | "next"): boolean;
     protected reorder_siblings(siblings: string[], node_id: string, target_id: string, type: "prev" | "next"): boolean;
-    protected on_sibling_reorder(cmd: IMapCommand.SiblingReorder): Recorder | void;
-    protected on_node_add(cmd: IMapCommand.NodeAdd): Recorder;
-    protected on_node_remove(cmd: IMapCommand.NodeRemove): Recorder | undefined;
-    protected on_linker_add(cmd: IMapCommand.LinkerAdd): Recorder | undefined;
-    protected on_linker_remove(cmd: IMapCommand.LinkerRemove): Recorder | undefined;
-    protected on_node_drag(cmd: IMapCommand.NodeMove): Recorder | undefined;
+    protected on_sibling_reorder(cmd: ICommandMap.SiblingReorder): Recorder | void;
+    protected on_node_add(cmd: ICommandMap.NodeAdd): Recorder;
+    protected on_node_remove(cmd: ICommandMap.NodeRemove): Recorder | undefined;
+    protected on_linker_add(cmd: ICommandMap.LinkerAdd): Recorder | undefined;
+    protected on_linker_remove(cmd: ICommandMap.LinkerRemove): Recorder | undefined;
+    protected on_node_drag(cmd: ICommandMap.NodeMove): Recorder | undefined;
     pick(...elements: MapChild[]): void;
     get_nodes_all(): {
         clear(): void;
@@ -2136,7 +2094,14 @@ declare class CubeSubMap extends CubeChild<ISubMap.Data> implements IMapBase.Api
     };
 }
 
-declare class StatusBoxColumns extends StatusCube<ICubeBoxColumns.Data> {
+declare class AdapterCubeBoxColumns extends CubeAdapterBase {
+    get meta(): INote.CubeMeta;
+    replace_id(versions: INote.CubesVersion, data: ICubeBoxColumns.Data, map: Record<string, string>): ICubeBase.ReplaceIdResult<ICubeBoxColumns.Data>;
+    get_data(): ICubeBoxColumns.Data;
+    update_data(versions: INote.CubesVersion, data: ICubeBoxColumns.Data): ICubeBase.CubeUpdateResult<ICubeBoxColumns.Data>;
+}
+
+declare class BoxColumnsStatus extends CubeStatusBase<ICubeBoxColumns.Data> {
     constructor(cube: CubeBoxColumns);
     get css(): {
         width: string;
@@ -2144,39 +2109,44 @@ declare class StatusBoxColumns extends StatusCube<ICubeBoxColumns.Data> {
 }
 
 declare class CubeBoxColumns extends CubeChild<ICubeBoxColumns.Data> {
-    protected _status: StatusBoxColumns;
+    protected _status: BoxColumnsStatus;
     constructor(note: Note, data: ICubeBoxColumns.Data, pcube: CubeChild);
     get adapter(): AdapterCubeBoxColumns;
-    get status(): StatusBoxColumns;
+    get status(): BoxColumnsStatus;
     get component(): any;
     get attrs(): ICubeBoxColumns.Attrs;
     get min_width(): number;
     protected build_child(data: ICubeBoxColumns.Data): void;
     export(): ICubeBoxColumns.Data;
     gc(): void;
-    protected on_insert_child(cmd: ICubeCommand.InsertChild): Recorder;
-    protected on_delete_child(cmd: ICubeCommand.DeleteChild): Recorder | undefined;
+    protected on_insert_child(cmd: ICommandCube.InsertChild): Recorder;
+    protected on_delete_child(cmd: ICommandCube.DeleteChild): Recorder | undefined;
+}
+
+declare class AdapterCubeRt extends CubeAdapterBase {
+    get min_size(): number;
+    get scale(): number;
+    get meta(): INote.CubeMeta;
+    get_data(text?: string, explanation?: string, css?: Record<string, string>): IRt.Data;
+    replace_id(versions: INote.CubesVersion, data: IRt.Data, map: Record<string, string>): ICubeBase.ReplaceIdResult<IRt.Data>;
+    update_data(versions: INote.CubesVersion, data: IRt.Data): ICubeBase.CubeUpdateResult<IRt.Data>;
 }
 
-declare class StatusRt extends StatusCube<IRt.Data> {
+declare class RtStatus extends CubeStatusBase<IRt.Data> {
     constructor(cube: CubeRt);
 }
 
 declare class CubeRt extends CubeChild<IRt.Data> {
-    protected _status: StatusRt;
+    protected _status: RtStatus;
     constructor(note: Note, data: IRt.Data, pcube: CubeChild);
     get adapter(): AdapterCubeRt;
-    get status(): StatusRt;
+    get status(): RtStatus;
     get info(): IRt.Info;
     get component(): any;
     protected build_child(data: IRt.Data): void;
     export(): IRt.Data;
     gc(): void;
-    protected reset(cmd: IRtCommand.Reset): Recorder;
-}
-
-declare class CommandRt {
-    static reset(id: ICubeBase.CubeId, explanation: string): IRtCommand.Reset;
+    protected reset(cmd: ICommandRt.Reset): Recorder;
 }
 
 declare class NoteScope extends NoteBase {
@@ -2215,7 +2185,7 @@ declare class NoteScope extends NoteBase {
 declare class NoteScopes extends NoteBase {
     protected _scopes: Set<NoteScope>;
     constructor(note: Note);
-    get status(): StatusCubeRoot<any>;
+    get status(): CubeStatusBaseRoot<any>;
     get count(): number;
     get first(): NoteScope | undefined;
     get last(): NoteScope | undefined;
@@ -2235,7 +2205,7 @@ declare class NoteScopes extends NoteBase {
     get_scope_cubes_data(): ICubeBase.Data[];
 }
 
-declare class StatusCubeRoot<T extends ICubeRootBase.Data> extends StatusCube<T> {
+declare class CubeStatusBaseRoot<T extends ICubeRootBase.Data> extends CubeStatusBase<T> {
     protected _scopes: ShallowReactive<Set<NoteScope>>;
     protected _postils: Map<string, any>;
     constructor(cube: CubeRoot);
@@ -2260,7 +2230,7 @@ declare abstract class CubeRoot<T extends ICubeRootBase.Data = any> extends Cube
     protected _dom: HTMLElement | undefined;
     protected _children: INote.NoteChild[];
     abstract get component(): any;
-    abstract get status(): StatusCubeRoot<T>;
+    abstract get status(): CubeStatusBaseRoot<T>;
     abstract render(dom: HTMLElement): any;
     abstract build_child(data: T): any;
     abstract export(): T;
@@ -2310,23 +2280,22 @@ declare abstract class CubeRoot<T extends ICubeRootBase.Data = any> extends Cube
     filter(func: ICubeBase.CubeFilterFunc): INote.NoteChild[];
     each(func: ICubeBase.CubeEachFunc): void;
     find_upstream_untill(): undefined;
-    delete_edge(child: CubeText, dir: ICubeCommand.DeleteDir): Recorder | undefined;
+    delete_edge(child: CubeText, dir: ICommandCube.DeleteDir): Recorder | undefined;
     splice<T = any, K = any>(index: number, delete_count: number, ...insert: INote.NoteChild[]): ICubeBase.CubeSpliceResult<T, K>;
     get_sdk_version(): INote.SDKMeta;
-    protected on_reset(command: ICubeCommand.Reset): Recorder | void;
-    protected on_cube_reorder(command: ICubeCommand.Reorder): Recorder | void;
-    protected on_insert_cube(command: ICubeCommand.InsertChild): Recorder;
-    protected on_delete_cube(command: ICubeCommand.DeleteChild): Recorder | undefined;
-    protected on_cube_set_selection_css(command: ICubeCommand.SetSelectionCss): Recorder | void;
-    protected on_cube_insert(command: ICubeCommand.Insert): Recorder | void;
-    protected on_cube_delete(command: ICubeCommand.Delete): Recorder | void;
-    protected on_cube_set_attr(command: ICubeCommand.SetAttr): Recorder | void;
-    protected on_cursor_in_tail(command: ICursorCommand.InTail): Recorder | undefined;
+    protected on_reset(command: ICommandCube.Reset): Recorder | void;
+    protected on_cube_reorder(command: ICommandCube.Reorder): Recorder | void;
+    protected on_insert_cube(command: ICommandCube.InsertChild): Recorder;
+    protected on_delete_cube(command: ICommandCube.DeleteChild): Recorder | undefined;
+    protected on_cube_set_selection_css(command: ICommandCube.SetSelectionCss): Recorder | void;
+    protected on_cube_insert(command: ICommandCube.Insert): Recorder | void;
+    protected on_cube_delete(command: ICommandCube.Delete): Recorder | void;
+    protected on_cube_set_attr(command: ICommandCube.SetAttr): Recorder | void;
+    protected on_cursor_in_tail(command: ICommandCursor.InTail): Recorder | undefined;
     is_valid_range(range: [number, number], check_collapse?: boolean): boolean;
     get_valid_range(range: [number, number]): [number, number];
 }
 
-declare const AdapterAnnotation: AdapterCubeAnnotation;
 declare const AdapterApi: AdapterCubeApi;
 declare const AdapterBoxColumns: AdapterCubeBoxColumns;
 declare const AdapterBoxFolder: AdapterCubeBoxFolder;
@@ -2356,13 +2325,13 @@ declare class AdapterCubesGlobal {
     get versions(): INote.CubesVersion;
     get metas(): Map<string, INote.CubeMeta>;
     find_cube(type: INote.Cubes): any;
-    find_adapter(type: INote.Cubes): AdapterCubeBase | undefined;
+    find_adapter(type: INote.Cubes): CubeAdapterBase | undefined;
     get_cmd_handler(cubetype: INote.Cubes, cmd: string): ICubeHandler.Handler | undefined;
     set_cmd_handler(cubetype: INote.Cubes, cmd: string, func: ICubeHandler.Handler): void;
     init_cmd_handler(cube: CubeBase): void;
-    register_adapter(type: INote.Cubes, adapter: AdapterCubeBase): AdapterCubeBase;
-    register_cube(type: INote.Cubes, cls: typeof CubeChild | typeof MapChild | typeof CubeRoot): typeof MapChild | typeof CubeChild | typeof CubeRoot;
-    register_handler(type: INote.Cubes, cmd: ICubeCommand.Names, func: ICubeHandler.Handler): ICubeHandler.Handler;
+    register_adapter(type: INote.Cubes, adapter: CubeAdapterBase): CubeAdapterBase;
+    register_cube(type: INote.Cubes, cls: typeof CubeChild | typeof MapChild | typeof CubeRoot): typeof CubeChild | typeof MapChild | typeof CubeRoot;
+    register_handler(type: INote.Cubes, cmd: ICommandCube.Names, func: ICubeHandler.Handler): ICubeHandler.Handler;
     replace_id(versions: INote.CubesVersion, data: ICubeBase.Data[], map?: Record<string, string>): ICubeBase.ReplaceIdResult<ICubeBase.Data[]>;
     update_data(versions: INote.CubesVersion, data: ICubeBase.Data): ICubeBase.CubeUpdateResult;
     update_bulk(versions: INote.CubesVersion, data: ICubeBase.Data[]): any[];
@@ -2373,7 +2342,7 @@ declare class AdapterCubesGlobal {
 }
 declare const AdapterCubes: AdapterCubesGlobal;
 
-declare function cmd(cmd: ICubeCommand.Names): (cls: any, name: string) => void;
+declare function cmd(cmd: ICommandCube.Names): (cls: any, name: string) => void;
 declare function cube(name: INote.Cubes): (cls: any) => void;
 
 declare class DialogBase extends NoteBase {
@@ -3195,6 +3164,8 @@ declare class UiSidebar extends UiBase {
     get folded(): boolean;
     set_visible(visible: boolean): void;
     set(active: IUi.Core | "", folded: boolean): void;
+    open(type: IUiSidebar.Type): void;
+    close(): void;
     toggle(type: IUiSidebar.Type): void;
     export(): {};
 }
@@ -3248,8 +3219,24 @@ declare class UITheme extends UiBase {
     protected _style: HTMLStyleElement;
     protected _builtin_theme: Record<string, IUiTheme.ThemeItem<IUiTheme.Names>>;
     protected _backgrounds: Record<string, IUiTheme.BackgroundItem>;
+    protected _background_virtual_config: IUiTheme.BackgroundVirtualConfig;
+    protected _background_virtual: IUiTheme.BackgroundVirtualState;
     constructor(note: Note);
     get backgrounds(): Record<string, IUiTheme.BackgroundItem>;
+    get background_items(): IUiTheme.BackgroundItem[];
+    get background_virtual_config(): IUiTheme.BackgroundVirtualConfig;
+    get background_virtual(): IUiTheme.BackgroundVirtualState;
+    get background_virtual_row_height(): number;
+    get background_virtual_total_rows(): number;
+    get background_virtual_start_row(): number;
+    get background_virtual_end_row(): number;
+    get background_visible_items(): IUiTheme.BackgroundVirtualItem[];
+    get background_virtual_start_spacer_height(): number;
+    get background_virtual_end_spacer_height(): number;
+    get background_virtual_grid_style(): {
+        gridTemplateColumns: string;
+        gap: string;
+    };
     get builtin_theme(): Record<string, IUiTheme.ThemeItem<IUiTheme.Names>>;
     get themes(): Record<string, IUiTheme.ThemeItem<IUiTheme.Names>>;
     get adapter(): {
@@ -3279,6 +3266,8 @@ declare class UITheme extends UiBase {
         filter: string;
     };
     protected init(): void;
+    protected get_background_virtual_spacer_height(rows: number): number;
+    update_background_virtual_metrics(scroll_top: number, viewport_height: number, grid_top: number, grid_width: number): void;
     get_filter(id?: string, create?: boolean): IUiTheme.BackgroundFilter | undefined;
     get_filter_string(id?: string, create?: boolean): string;
     get_theme(id: string): IUiTheme.ThemeItem | undefined;
@@ -3325,7 +3314,7 @@ declare class UiTips extends UiBase {
 }
 
 declare abstract class ToolBase extends NoteBase {
-    abstract get name(): IUiToolbar.Name | string;
+    abstract get name(): IUiToolbar.Name;
     abstract tools: IUiToolbar.Tool[];
     abstract get_subtools(): Promise<IUiToolbar.ToolItem[]>;
     constructor(note: Note);
@@ -3445,90 +3434,14 @@ declare class NoteCubes extends NoteBase {
     static get meta(): INote.CoreMeta;
 }
 
-declare const keymap: Map<INoteHotkeys.HotKeys, INoteHotkeys.HotKeyHandler>;
-declare function key(keyfunc: INoteHotkeys.HotKeys): (instance: NoteHotkeys, attr: keyof NoteHotkeys) => void;
-declare class NoteHotkeys extends NoteBase {
-    handlers: Map<string, INoteHotkeys.HotKeyHandler>;
-    data: Reactive<INoteHotkeys.NoteHotkeys>;
-    constructor(note: Note);
-    get meta(): INote.CoreMeta<INote.Cores>;
-    listen(dom: HTMLElement): void;
-    protected listen_cursor_hotkey(dom: HTMLElement): void;
-    protected listen_uncursor_hotkey(dom: HTMLElement): void;
-    protected listen_cvx(dom: HTMLElement): void;
-    register(func: INoteHotkeys.HotKeyHandler, info: INoteHotkeys.HotKeyInfo): void;
-    reset(data: Record<string, INoteHotkeys.HotKeyInfo>): void;
-    reset_handler(hotkey_name: string, func: INoteHotkeys.HotKeyHandler): void;
-    export(): INoteHotkeys.NoteHotkeys;
-    update_data(...args: any[]): object;
-    validate(e: KeyboardEvent, info: INoteHotkeys.HotKeyInfo): boolean;
-    which(e: KeyboardEvent): INoteHotkeys.HotKeyInfo | undefined;
-    validate_hotkeys(e: KeyboardEvent, cursor?: "all" | "cursor" | "uncursor"): boolean;
-    get_hotkey_str(name: string): string;
-    clear_scope(e: KeyboardEvent): void;
-    clear_css(e: KeyboardEvent): void;
-    bold(e: KeyboardEvent): void;
-    unindent_line(e: KeyboardEvent): void;
-    indent_line(e: KeyboardEvent): void;
-    undo(e: KeyboardEvent): void;
-    redo(e: KeyboardEvent): void;
-    cursor_navigation(e: KeyboardEvent): Promise<void>;
-    cursor_extend_navigation(e: KeyboardEvent): void;
-    text_break(e: KeyboardEvent): void;
-    break(e: KeyboardEvent): Promise<void>;
-    break_root(e: KeyboardEvent): Promise<void>;
-    text_partition(e: KeyboardEvent): Function | undefined;
-    add_scope(e: KeyboardEvent): void;
-    underline(e: KeyboardEvent): void;
-    copy_format(e: KeyboardEvent): void;
-    apply_format(e: KeyboardEvent): void;
-    italic(e: KeyboardEvent): void;
-    align_left(e: KeyboardEvent): void;
-    align_center(e: KeyboardEvent): void;
-    align_right(e: KeyboardEvent): void;
-    next_root(e: KeyboardEvent): void;
-    prev_root(e: KeyboardEvent): void;
-    add_annotation(e: KeyboardEvent): Function | Recorder | undefined;
-    fold_block(e: KeyboardEvent): void;
-    add_bookmark(e: KeyboardEvent): void;
-    fontsize_up(e: KeyboardEvent): void;
-    fontsize_down(e: KeyboardEvent): void;
-    link(e: KeyboardEvent): void;
-    search_doc(e: KeyboardEvent): void;
-    show_formula_editor(e: KeyboardEvent): void;
-    show_cubelist(e: KeyboardEvent): void;
-    text_rt(e: KeyboardEvent): void;
-    static get meta(): INote.CoreMeta;
-    static get default_hotkeys(): INoteHotkeys.NoteHotkeys;
-}
-
-declare abstract class HotkeyBase {
-    protected _note: Note;
-    protected _config: INoteHotkeys.Config;
-    constructor(note: Note, config: INoteHotkeys.Config);
-    get id(): string;
-    get note(): Note;
-    get config(): {
-        id: string;
-        name: string;
-        shortcut: string;
-        scope: INoteHotkeys.Scope;
-        capture?: boolean;
-        keyup?: boolean;
-    };
-    get shortcut(): string;
-    get scope(): INoteHotkeys.Scope;
-    abstract get default_config(): INoteHotkeys.Config;
-    abstract register(): void;
-    abstract export(): INoteHotkeys.Config;
-}
-
 declare class NoteCursor extends NoteBase {
     protected _selection: Selection;
+    protected _cursor_text: string;
     cursor_step: number;
     scroll_distance: number;
     safa_distance: number;
     constructor(note: Note);
+    get cursor_text(): string;
     get selection(): Selection;
     get meta(): INote.CoreMeta<INote.Cores>;
     get has_selection(): boolean;
@@ -3551,6 +3464,7 @@ declare class NoteCursor extends NoteBase {
     get cube_end(): CubeText | undefined;
     get cube_focus(): CubeChild | undefined;
     get cube_anchor(): CubeChild | undefined;
+    check_cursor(): boolean;
     get_cursor_info(): INoteCursor.CursorInfo;
     protected locate_next_line(dir: "up" | "down", line: CubeLine, pos: INoteCursor.EdgeRect): void;
     protected locate_current_line(dir: "up" | "down", line: CubeLine, pos: INoteCursor.EdgeRect): boolean;
@@ -3590,13 +3504,13 @@ declare class NoteCursor extends NoteBase {
 }
 
 declare class NoteCourier extends NoteBase {
-    protected command_group_do: ICubeCommand.BaseCommand[];
-    protected command_group_undo: ICubeCommand.BaseCommand[];
+    protected command_group_do: ICommandCube.BaseCommand[];
+    protected command_group_undo: ICommandCube.BaseCommand[];
     constructor(note: Note);
     get meta(): INote.CoreMeta<INote.Cores>;
-    protected execute_command_group(cmds: ICubeCommand.BaseCommand[]): void;
+    protected execute_command_group(cmds: ICommandCube.BaseCommand[]): void;
     get_recorder(): Recorder;
-    pass(command: ICubeCommand.BaseCommand): Recorder | void;
+    pass(command: ICommandCube.BaseCommand): Recorder | void;
     load(): void;
     export(): {};
     update_data(...args: any[]): object;
@@ -3640,14 +3554,14 @@ declare class NotePainter extends NoteBase {
     get meta(): INote.CoreMeta<INote.Cores>;
     get format_brush(): {};
     constructor(note: Note);
-    paint(style: Record<string, string | null>, method?: ICubeCommand.CssMethod): void;
+    paint(style: Record<string, string | null>, method?: ICommandCube.CssMethod): void;
     clear(): void;
     text_align(dir: "left" | "center" | "right"): Recorder;
     indent(): void;
     unindent(): void;
     copy_format(): void;
     apply_format_brush(): void;
-    set_bulk_css(css: Record<string, string>, cubes: INote.NoteChild[], method?: ICubeCommand.CssMethod): void;
+    set_bulk_css(css: Record<string, string>, cubes: INote.NoteChild[], method?: ICommandCube.CssMethod): void;
     remove_bulk_css(css: string[], cubes: INote.NoteCube[]): void;
     static get meta(): INote.CoreMeta;
 }
@@ -3670,9 +3584,9 @@ declare class NoteEvent extends NoteBase {
     on_replace_id(func: INoteEvent.ListenerReplaceId): Function;
     emit_replace_id(map: Record<string, string>): Promise<any[]>;
     on_edit_before(func: INoteEvent.ListenerEdit): Function;
-    emit_edit_before(cube: INote.NoteCube, cmd: ICubeCommand.BaseCommand): Promise<any[]>;
+    emit_edit_before(cube: INote.NoteCube, cmd: ICommandCube.BaseCommand): Promise<any[]>;
     on_edit_after(func: INoteEvent.ListenerEdit): Function;
-    emit_edit_after(cube: INote.NoteCube, cmd: ICubeCommand.BaseCommand): Promise<any[]>;
+    emit_edit_after(cube: INote.NoteCube, cmd: ICommandCube.BaseCommand): Promise<any[]>;
     on_text_merge(func: INoteEvent.ListenerTextMerge): Function;
     emit_text_merge(from: string, to: string): Promise<any[]>;
     on_esc(func: INoteEvent.ListenerEsc): Function;
@@ -3827,9 +3741,9 @@ declare class NoteAction extends NoteBase {
     constructor(note: Note);
     ins(text: string): Recorder;
     insert(cubes: ICubeBase.Data[]): Recorder;
-    delete(dir: ICubeCommand.DeleteDir, reserve?: boolean): Recorder | undefined;
-    set_css(cube: INote.NoteCube, css: INote.Css, method?: ICubeCommand.CssMethod): Recorder;
-    set_selection_css(css: INote.Css, method?: ICubeCommand.CssMethod): Recorder | undefined;
+    delete(dir: ICommandCube.DeleteDir, reserve?: boolean): Recorder | undefined;
+    set_css(cube: INote.NoteCube, css: INote.Css, method?: ICommandCube.CssMethod): Recorder;
+    set_selection_css(css: INote.Css, method?: ICommandCube.CssMethod): Recorder | undefined;
 }
 
 declare class Note {
@@ -3841,7 +3755,6 @@ declare class Note {
     protected _isdev: boolean;
     protected _uidata: IUi.Data;
     protected _cubes: NoteCubes;
-    protected _hotkeys: NoteHotkeys;
     protected _history: NoteHistory;
     protected _cursor: NoteCursor;
     protected _courier: NoteCourier;
@@ -3864,7 +3777,6 @@ declare class Note {
     get convertor(): typeof NoteConvertor;
     get cubes(): NoteCubes;
     get api(): typeof NoteApi;
-    get hotkeys(): NoteHotkeys;
     get history(): NoteHistory;
     get cursor(): NoteCursor;
     get courier(): NoteCourier;
@@ -3880,13 +3792,13 @@ declare class Note {
         get versions(): INote.CubesVersion;
         get metas(): Map<string, INote.CubeMeta>;
         find_cube(type: INote.Cubes): any;
-        find_adapter(type: INote.Cubes): AdapterCubeBase | undefined;
+        find_adapter(type: INote.Cubes): CubeAdapterBase | undefined;
         get_cmd_handler(cubetype: INote.Cubes, cmd: string): ICubeHandler.Handler | undefined;
         set_cmd_handler(cubetype: INote.Cubes, cmd: string, func: ICubeHandler.Handler): void;
         init_cmd_handler(cube: CubeBase): void;
-        register_adapter(type: INote.Cubes, adapter: AdapterCubeBase): AdapterCubeBase;
-        register_cube(type: INote.Cubes, cls: typeof CubeChild | typeof MapChild | typeof CubeRoot): typeof MapChild | typeof CubeChild | typeof CubeRoot;
-        register_handler(type: INote.Cubes, cmd: ICubeCommand.Names, func: ICubeHandler.Handler): ICubeHandler.Handler;
+        register_adapter(type: INote.Cubes, adapter: CubeAdapterBase): CubeAdapterBase;
+        register_cube(type: INote.Cubes, cls: typeof CubeChild | typeof MapChild | typeof CubeRoot): typeof CubeChild | typeof MapChild | typeof CubeRoot;
+        register_handler(type: INote.Cubes, cmd: ICommandCube.Names, func: ICubeHandler.Handler): ICubeHandler.Handler;
         replace_id(versions: INote.CubesVersion, data: ICubeBase.Data[], map?: Record<string, string>): ICubeBase.ReplaceIdResult<ICubeBase.Data[]>;
         update_data(versions: INote.CubesVersion, data: ICubeBase.Data): ICubeBase.CubeUpdateResult;
         update_bulk(versions: INote.CubesVersion, data: ICubeBase.Data[]): any[];
@@ -3900,7 +3812,7 @@ declare class Note {
     render_pdf(dom: HTMLElement): void;
     emit_event_after_render(): void;
     find_cube(type: INote.Cubes): any;
-    find_adapter(type: INote.Cubes): AdapterCubeBase | undefined;
+    find_adapter(type: INote.Cubes): CubeAdapterBase | undefined;
     get_sdk_meta(): _SDKMeta;
     export(): INote.Data;
     set_dev(isdev: boolean): void;
@@ -3911,22 +3823,22 @@ declare class Note {
 }
 
 declare class Recorder extends NoteBase {
-    protected do: ICubeCommand.BaseCommand[];
-    protected undo: ICubeCommand.BaseCommand[];
-    protected _bubble: Map<INote.NoteCube, Map<INote.NoteCube, ICubeCommand.BaseCommand[]>>;
+    protected do: ICommandCube.BaseCommand[];
+    protected undo: ICommandCube.BaseCommand[];
+    protected _bubble: Map<INote.NoteCube, Map<INote.NoteCube, ICommandCube.BaseCommand[]>>;
     constructor(note: Note);
     get len_do(): number;
     get len_undo(): number;
-    get stack_do(): ICubeCommand.BaseCommand[];
-    get stack_undo(): ICubeCommand.BaseCommand[];
-    protected set_bubble(cube: INote.NoteCube, cmd: ICubeCommand.BaseCommand): void;
+    get stack_do(): ICommandCube.BaseCommand[];
+    get stack_undo(): ICommandCube.BaseCommand[];
+    protected set_bubble(cube: INote.NoteCube, cmd: ICommandCube.BaseCommand): void;
     bubble(): void;
-    add_cmd(cmd: ICubeCommand.BaseCommand): void;
-    add_recover(command: ICubeCommand.BaseCommand): void;
-    pass(cmd: ICubeCommand.BaseCommand): void;
-    tick(cmd: ICubeCommand.BaseCommand, cube?: INote.NoteCube): void;
-    tell(cube: INote.NoteCube | undefined, ...cmds: ICubeCommand.BaseCommand[]): Recorder;
-    exe(cube: INote.NoteCube | undefined, ...cmds: ICubeCommand.BaseCommand[]): Recorder;
+    add_cmd(cmd: ICommandCube.BaseCommand): void;
+    add_recover(command: ICommandCube.BaseCommand): void;
+    pass(cmd: ICommandCube.BaseCommand): void;
+    tick(cmd: ICommandCube.BaseCommand, cube?: INote.NoteCube): void;
+    tell(cube: INote.NoteCube | undefined, ...cmds: ICommandCube.BaseCommand[]): Recorder;
+    exe(cube: INote.NoteCube | undefined, ...cmds: ICommandCube.BaseCommand[]): Recorder;
     merge(record: Recorder | void | undefined | null): Recorder;
 }
 
@@ -3937,7 +3849,7 @@ declare class NoteHistory extends NoteBase {
     get len_undo(): number;
     get len_redo(): number;
     constructor(note: Note);
-    protected execute_command_group(cmds: ICubeCommand.BaseCommand[]): void;
+    protected execute_command_group(cmds: ICommandCube.BaseCommand[]): void;
     undo(): Function | undefined;
     redo(): Function | undefined;
     record(recorder: Recorder | undefined | void | null): void;
@@ -3950,11 +3862,11 @@ declare class NoteHistory extends NoteBase {
 
 declare class EventBubble {
     readonly recorder: Recorder;
-    readonly map: Map<INote.NoteCube, ICubeCommand.BaseCommand[]>;
-    constructor(recorder: Recorder, map: Map<INote.NoteCube, ICubeCommand.BaseCommand[]>);
+    readonly map: Map<INote.NoteCube, ICommandCube.BaseCommand[]>;
+    constructor(recorder: Recorder, map: Map<INote.NoteCube, ICommandCube.BaseCommand[]>);
 }
 
-declare class StatusCube<T extends ICubeBase.Data> {
+declare class CubeStatusBase<T extends ICubeBase.Data> {
     protected __children: INote.NoteChild[];
     protected _cube: INote.NoteCube;
     protected _data: Reactive<T>;
@@ -3982,17 +3894,17 @@ declare class StatusCube<T extends ICubeBase.Data> {
 }
 
 declare abstract class CubeBase<T extends ICubeBase.Data = any> {
-    protected handler: Map<ICubeCommand.Names, ICubeHandler.Handler>;
-    protected handler_vip: Map<ICubeCommand.Names, ICubeHandler.Handler>;
+    protected handler: Map<ICommandCube.Names, ICubeHandler.Handler>;
+    protected handler_vip: Map<ICommandCube.Names, ICubeHandler.Handler>;
     protected _note: Note;
     abstract data: T;
     abstract get id(): string;
-    abstract get component(): any;
-    abstract get adapter(): AdapterCubeBase;
-    abstract get status(): StatusCube<T>;
     abstract find_cube(id: ICubeBase.CubeId, ...args: any[]): CubeBase | undefined;
     abstract export(): T;
     abstract gc(): any;
+    abstract get component(): any;
+    abstract get status(): CubeStatusBase<T>;
+    abstract get adapter(): CubeAdapterBase;
     protected abstract build_child(data: T): any;
     constructor(note: Note);
     get meta(): INote.CubeMeta<INote.Cubes>;
@@ -4004,7 +3916,6 @@ declare abstract class CubeBase<T extends ICubeBase.Data = any> {
     get root(): CubeRoot<any>;
     get cubes(): NoteCubes;
     get api(): typeof NoteApi;
-    get hotkeys(): NoteHotkeys;
     get history(): NoteHistory;
     get cursor(): NoteCursor;
     get courier(): NoteCourier;
@@ -4015,14 +3926,17 @@ declare abstract class CubeBase<T extends ICubeBase.Data = any> {
     get listener(): NoteListener;
     get interaction(): NoteInteraction;
     update_data(versions: INote.CubesVersion, data: any): ICubeBase.CubeUpdateResult<T>;
-    on(cmd: ICubeCommand.BaseCommand): void | Recorder;
-    get_cmd_handler(name: ICubeCommand.Names): ICubeHandler.Handler | undefined;
-    get_cmd_handler_vip(name: ICubeCommand.Names): ICubeHandler.Handler | undefined;
-    set_cmd_handler(name: ICubeCommand.Names, handler: ICubeHandler.Handler): void;
-    set_cmd_handler_vip(name: ICubeCommand.Names, handler: ICubeHandler.Handler): void;
+    on(cmd: ICommandCube.BaseCommand): void | Recorder;
+    get_cmd_handler(name: ICommandCube.Names): ICubeHandler.Handler | undefined;
+    get_cmd_handler_vip(name: ICommandCube.Names): ICubeHandler.Handler | undefined;
+    set_cmd_handler(name: ICommandCube.Names, handler: ICubeHandler.Handler): void;
+    set_cmd_handler_vip(name: ICommandCube.Names, handler: ICubeHandler.Handler): void;
     event_bubble(event: EventBubble): void;
 }
 
+declare class CubeListenerBase {
+}
+
 declare abstract class MapChild<T extends ICubeBase.Data = any> extends CubeBase<T> {
     abstract get show(): boolean;
     abstract get map2d(): Map2D;
@@ -4069,7 +3983,7 @@ declare abstract class MapChild<T extends ICubeBase.Data = any> extends CubeBase
     base_export(): T;
     copy(left: number, right: number): ICubeBase.Data[];
     get_upstream_sum_scale(): _FigScale;
-    remove_self(dir?: ICubeCommand.DeleteDir): Recorder;
+    remove_self(dir?: ICommandCube.DeleteDir): Recorder;
     merge(method: INote.CubeMergeMethod): Recorder | undefined;
     find_cube(id: ICubeBase.CubeId): CubeChild | MapChild | undefined;
     filter(func: ICubeBase.CubeFilterFunc): Array<CubeChild | MapChild>;
@@ -4082,16 +3996,16 @@ declare abstract class MapChild<T extends ICubeBase.Data = any> extends CubeBase
     find_child_index(id: ICubeBase.CubeId): number;
     find_next_cube(id: ICubeBase.CubeId): CubeChild | undefined;
     find_prev_cube(id: ICubeBase.CubeId): CubeChild | undefined;
-    protected on_cube_set_selection_css(command: ICubeCommand.SetSelectionCss): Recorder | void;
-    protected on_insert(command: ICubeCommand.Insert): Recorder | void;
-    protected on_cube_delete(command: ICubeCommand.Delete): Recorder | void;
-    protected on_cube_set_css(command: ICubeCommand.SetCss): Recorder | void;
-    protected on_cube_set_attr(command: ICubeCommand.SetAttr): Recorder | void;
-    protected on_cube_delete_adjacent(command: ICubeCommand.DeleteAdjacent): Recorder | void;
-    protected on_postil_add(cmd: ICubeCommand.PostilAdd): Recorder | void;
-    protected on_postil_remove(command: ICubeCommand.PostilRemove): Recorder | void;
-    protected on_cursor_in_head(command: ICursorCommand.InHead): Recorder | undefined;
-    protected on_cursor_in_tail(command: ICursorCommand.InTail): Recorder | undefined;
+    protected on_cube_set_selection_css(command: ICommandCube.SetSelectionCss): Recorder | void;
+    protected on_insert(command: ICommandCube.Insert): Recorder | void;
+    protected on_cube_delete(command: ICommandCube.Delete): Recorder | void;
+    protected on_cube_set_css(command: ICommandCube.SetCss): Recorder | void;
+    protected on_cube_set_attr(command: ICommandCube.SetAttr): Recorder | void;
+    protected on_cube_delete_adjacent(command: ICommandCube.DeleteAdjacent): Recorder | void;
+    protected on_postil_add(cmd: ICommandCube.PostilAdd): Recorder | void;
+    protected on_postil_remove(command: ICommandCube.PostilRemove): Recorder | void;
+    protected on_cursor_in_head(command: ICommandCursor.InHead): Recorder | undefined;
+    protected on_cursor_in_tail(command: ICommandCursor.InTail): Recorder | undefined;
     is_valid_range(range: [number, number], check_collapse?: boolean): boolean;
     get_valid_index(pos: number | INote.CubeSide): number;
     get_valid_range(range: [number, number]): [number, number];
@@ -4103,7 +4017,7 @@ declare abstract class MapNodeBase<T extends INodeBase.Base = any> extends MapCh
     protected _layouted: boolean;
     protected _env: MapNodeLayoutEnv;
     abstract map2d: NodeBase2D;
-    abstract get status(): StatusNodeBase<T>;
+    abstract get status(): NodeStatusBase<T>;
     constructor(note: Note, data: T, pcube: _Map);
     get layouted(): boolean;
     set layouted(v: boolean);
@@ -4149,13 +4063,13 @@ declare abstract class MapNodeBase<T extends INodeBase.Base = any> extends MapCh
     break_link_node(id: string): void;
     remove_self(): Recorder;
     find_dom_cube(node: Node): INote.NoteChild | undefined;
-    protected on_reset(command: ICubeCommand.Reset): Recorder | void;
-    protected on_cube_reorder(command: ICubeCommand.Reorder): Recorder | void;
-    protected on_insert_child(command: ICubeCommand.InsertChild): Recorder;
-    protected on_delete_child(command: ICubeCommand.DeleteChild): Recorder | undefined;
-    protected on_cube_insert(command: ICubeCommand.Insert): Recorder | void;
-    protected on_layout_update(cmd: INodeCommand.LayoutUpdate): Recorder;
-    protected on_append_child(cmd: INodeCommand.AppendChild): Recorder;
+    protected on_reset(command: ICommandCube.Reset): Recorder | void;
+    protected on_cube_reorder(command: ICommandCube.Reorder): Recorder | void;
+    protected on_insert_child(command: ICommandCube.InsertChild): Recorder;
+    protected on_delete_child(command: ICommandCube.DeleteChild): Recorder | undefined;
+    protected on_cube_insert(command: ICommandCube.Insert): Recorder | void;
+    protected on_layout_update(cmd: ICommandNode.LayoutUpdate): Recorder;
+    protected on_append_child(cmd: ICommandNode.AppendChild): Recorder;
     static get_default_node_size(padding?: number): IMath.RectArea;
     static get_default_node_pos(pos: _PointView, map: INote.NoteCube & IMapBase.Api): {
         x: number;
@@ -4179,7 +4093,7 @@ declare class MapNodeLayoutEnv {
         index: number;
     };
     get root(): MapNodeBase | undefined;
-    get status(): StatusNodeBase<any>;
+    get status(): NodeStatusBase<any>;
     get map2d(): NodeBase2D;
     get map(): _Map;
     get to(): Set<string>;
@@ -4219,7 +4133,7 @@ declare class MapNodeLayoutEnv {
     get_downstream_layout_type(node: MapNodeBase): INodeBase.Layout;
 }
 
-declare class StatusNodeBase<T extends INodeBase.Base = any> extends StatusCube<T> {
+declare class NodeStatusBase<T extends INodeBase.Base = any> extends CubeStatusBase<T> {
     protected _rect_cbox: IMath.Rect;
     protected _rect: IMath.Rect;
     protected _editable: Ref<boolean, boolean>;
@@ -4270,7 +4184,7 @@ declare class StatusNodeBase<T extends INodeBase.Base = any> extends StatusCube<
         f: number;
     };
     get is_layout_root(): boolean;
-    get upstatus(): StatusNodeBase | undefined;
+    get upstatus(): NodeStatusBase | undefined;
     get node_fill(): string | undefined;
     get node_line_type(): INodeBase.Line;
     get node_line_width(): number;
@@ -4340,7 +4254,7 @@ declare abstract class NodeBase2D extends Map2D {
     get map(): _Map;
     get meter(): NodeLayoutMeter;
     get env(): MapNodeLayoutEnv;
-    get status(): StatusNodeBase<any>;
+    get status(): NodeStatusBase<any>;
     get matrix2d(): {
         a: number;
         b: number;
@@ -4627,26 +4541,26 @@ declare namespace INodeBaseEnv {
     }
 }
 
-declare namespace INodeCommand {
-    interface LayoutUpdate extends ICubeCommand.BaseCommand {
+declare namespace ICommandNode {
+    interface LayoutUpdate extends ICommandCube.BaseCommand {
         name: "node:layout-update";
         attrs: Partial<INodeBase.Attrs>;
     }
-    interface AppendChild extends ICubeCommand.BaseCommand {
+    interface AppendChild extends ICommandCube.BaseCommand {
         name: "node:append-child";
         nodes: INodeBase.Base[];
         previd?: string | null;
     }
 }
 
-declare namespace ITextCommand {
-    interface Reset extends ICubeCommand.BaseCommand {
+declare namespace ICommandText {
+    interface Reset extends ICommandCube.BaseCommand {
         name: "text:reset";
         info: string;
         pos: number;
         pos_before: number;
     }
-    interface Break extends ICubeCommand.BaseCommand {
+    interface Break extends ICommandCube.BaseCommand {
         name: "text:break";
         offset: number;
     }
@@ -4670,7 +4584,7 @@ declare namespace IDoc {
     }
 }
 
-declare namespace IDocCommand { }
+declare namespace ICommandDoc { }
 
 declare namespace IMap {
     interface Data extends ICubeRootBase.Data {
@@ -4791,8 +4705,8 @@ declare namespace ITextLink {
     }
 }
 
-declare namespace ITextLinkCommand {
-    interface Update extends ICubeCommand.BaseCommand {
+declare namespace ICommandTextLink {
+    interface Update extends ICommandCube.BaseCommand {
         name: "text-link:update";
         url: string;
         title: string;
@@ -4814,21 +4728,21 @@ declare namespace IList {
     }
 }
 
-declare namespace IListCommand {
-    interface Reset extends ICubeCommand.BaseCommand {
+declare namespace ICommandList {
+    interface Reset extends ICommandCube.BaseCommand {
         name: "list:reset";
         data: IList.ListItemData[];
     }
-    interface AddItem extends ICubeCommand.BaseCommand {
+    interface AddItem extends ICommandCube.BaseCommand {
         name: "list:add";
         data: IList.ListItemData[];
         pos: number;
     }
-    interface RemoveItem extends ICubeCommand.BaseCommand {
+    interface RemoveItem extends ICommandCube.BaseCommand {
         name: "list:remove";
         range: [number, number];
     }
-    interface IndentItem extends ICubeCommand.BaseCommand {
+    interface IndentItem extends ICommandCube.BaseCommand {
         name: "list:indent";
         items: ItemIndentInfo[];
     }
@@ -4892,7 +4806,7 @@ declare namespace IApi {
     }
 }
 
-declare namespace IApiCommand { }
+declare namespace ICommandApi { }
 
 declare namespace ITip {
     interface Data extends ICubeBase.Data {
@@ -4901,23 +4815,23 @@ declare namespace ITip {
     }
 }
 
-declare namespace IListOrderedCommand {
-    interface Reset extends ICubeCommand.BaseCommand {
+declare namespace ICommandListOrdered {
+    interface Reset extends ICommandCube.BaseCommand {
         name: "list-ordered:reset";
         data: IList.ListItemData[];
     }
-    interface AddItem extends ICubeCommand.BaseCommand {
+    interface AddItem extends ICommandCube.BaseCommand {
         name: "list-ordered:add";
         data: IList.ListItemData[];
         pos: number;
     }
-    interface RemoveItem extends ICubeCommand.BaseCommand {
+    interface RemoveItem extends ICommandCube.BaseCommand {
         name: "list-ordered:remove";
         range: [number, number];
     }
-    interface IndentItem extends ICubeCommand.BaseCommand {
+    interface IndentItem extends ICommandCube.BaseCommand {
         name: "list-ordered:indent";
-        items: IListCommand.ItemIndentInfo[];
+        items: ICommandList.ItemIndentInfo[];
     }
 }
 
@@ -4957,36 +4871,36 @@ declare namespace ICode {
     type LanguagesMap = Record<string, Langs>;
 }
 
-declare namespace ICodeCommand {
-    interface Update extends ICubeCommand.BaseCommand {
+declare namespace ICommandCode {
+    interface Update extends ICommandCube.BaseCommand {
         name: "code:update";
         tabid: string;
         code: string;
     }
-    interface TabActive extends ICubeCommand.BaseCommand {
+    interface TabActive extends ICommandCube.BaseCommand {
         name: "code:change-active";
         tabid: string;
     }
-    interface Add extends ICubeCommand.BaseCommand {
+    interface Add extends ICommandCube.BaseCommand {
         name: "code:add";
         item: ICode.TabItem;
         focus: boolean;
     }
-    interface Remove extends ICubeCommand.BaseCommand {
+    interface Remove extends ICommandCube.BaseCommand {
         name: "code:remove";
         tabid: string;
     }
-    interface Rename extends ICubeCommand.BaseCommand {
+    interface Rename extends ICommandCube.BaseCommand {
         name: "code:rename";
         tabid: string;
         filename: string;
     }
-    interface ChangeLang extends ICubeCommand.BaseCommand {
+    interface ChangeLang extends ICommandCube.BaseCommand {
         name: "code:change-lang";
         tabid: string;
         lang: string;
     }
-    interface ChangeTheme extends ICubeCommand.BaseCommand {
+    interface ChangeTheme extends ICommandCube.BaseCommand {
         name: "code:change-theme";
         tabid: string;
         theme: string;
@@ -5014,8 +4928,8 @@ declare namespace IFormula {
     }
 }
 
-declare namespace IFormulaCommand {
-    interface Update extends ICubeCommand.BaseCommand {
+declare namespace ICommandFormula {
+    interface Update extends ICommandCube.BaseCommand {
         name: "formula:update";
         latex: string;
         size: IFormula.Size;
@@ -5086,72 +5000,72 @@ declare namespace ITable {
     }
 }
 
-declare namespace ITableCommand {
-    interface AddTitle extends ICubeCommand.BaseCommand {
+declare namespace ICommandTable {
+    interface AddTitle extends ICommandCube.BaseCommand {
         name: "table:add-title";
         data: IBox.Data;
     }
-    interface RemoveTitle extends ICubeCommand.BaseCommand {
+    interface RemoveTitle extends ICommandCube.BaseCommand {
         name: "table:remove-title";
     }
-    interface AddCell extends ICubeCommand.BaseCommand {
+    interface AddCell extends ICommandCube.BaseCommand {
         name: "table:add-cell";
         data: ITable.CellData;
     }
-    interface RemoveCell extends ICubeCommand.BaseCommand {
+    interface RemoveCell extends ICommandCube.BaseCommand {
         name: "table:remove-cell";
         cid: ICubeBase.CubeId;
     }
-    interface AddRow extends ICubeCommand.BaseCommand {
+    interface AddRow extends ICommandCube.BaseCommand {
         name: "table:add-row";
         index: number;
         rows: IBox.Data[];
     }
-    interface RemoveRow extends ICubeCommand.BaseCommand {
+    interface RemoveRow extends ICommandCube.BaseCommand {
         name: "table:remove-row";
         index: number;
     }
-    interface AddCol extends ICubeCommand.BaseCommand {
+    interface AddCol extends ICommandCube.BaseCommand {
         name: "table:add-col";
         index: number;
         cols: IBox.Data[];
     }
-    interface RemoveCol extends ICubeCommand.BaseCommand {
+    interface RemoveCol extends ICommandCube.BaseCommand {
         name: "table:remove-col";
         index: number;
     }
-    interface Merge extends ICubeCommand.BaseCommand {
+    interface Merge extends ICommandCube.BaseCommand {
         name: "table:merge";
         area: ITable.CellArea;
     }
-    interface CellMoveTo extends ICubeCommand.BaseCommand {
+    interface CellMoveTo extends ICommandCube.BaseCommand {
         name: "table:moveto";
         tid: string;
         cells: string[];
     }
-    interface CellUpdateArea extends ICubeCommand.BaseCommand {
+    interface CellUpdateArea extends ICommandCube.BaseCommand {
         name: "table:update-area";
         tid: ICubeBase.CubeId;
         area: ITable.CellRect;
     }
-    interface AddGridCol extends ICubeCommand.BaseCommand {
+    interface AddGridCol extends ICommandCube.BaseCommand {
         name: "table:add-grid-col";
         index: number;
         width: number;
     }
-    interface RemoveGridCol extends ICubeCommand.BaseCommand {
+    interface RemoveGridCol extends ICommandCube.BaseCommand {
         name: "table:remove-grid-col";
         index: number;
     }
-    interface AddGridRow extends ICubeCommand.BaseCommand {
+    interface AddGridRow extends ICommandCube.BaseCommand {
         name: "table:add-grid-row";
         index: number;
     }
-    interface RemoveGridRow extends ICubeCommand.BaseCommand {
+    interface RemoveGridRow extends ICommandCube.BaseCommand {
         name: "table:remove-grid-row";
         index: number;
     }
-    interface ColResize extends ICubeCommand.BaseCommand {
+    interface ColResize extends ICommandCube.BaseCommand {
         name: "table:col-resize";
         cols: [number, number];
         step: number;
@@ -5194,8 +5108,8 @@ declare namespace ILinker {
     type Finder = (from: MapNodeBase, to: MapNodeBase) => IMapTools.LinePoints;
 }
 
-declare namespace ILinkerCommand {
-    interface Update extends ICubeCommand.BaseCommand {
+declare namespace ICommandLinker {
+    interface Update extends ICommandCube.BaseCommand {
         name: "linker:update";
         attrs: UpdateAttr;
     }
@@ -5246,8 +5160,8 @@ declare namespace IRt {
     }
 }
 
-declare namespace IRtCommand {
-    interface Reset extends ICubeCommand.BaseCommand {
+declare namespace ICommandRt {
+    interface Reset extends ICommandCube.BaseCommand {
         name: "rt:reset";
         explanation: string;
     }
@@ -5371,31 +5285,118 @@ declare namespace IMapInteraction {
 }
 
 declare namespace INoteInteraction {
-    interface Api {
-        get name(): string;
+    type Scope = "all" | "note" | "none";
+    type Groups = string;
+    interface Data {
+        hotkeys: Record<string, HotkeyConfig>;
     }
-    type Operations = "note:scope-delete";
     interface KeyboardScope {
-        key: string;
         note_mode: INote.Mode;
-        scopes: number;
+    }
+    interface HotkeyConfig {
+        id: string;
+        name: string;
+        shortcut: string;
+        scope: Scope;
+        group: Groups;
+        show?: boolean;
+        cursor?: boolean;
+        capture?: boolean;
+        keyup?: boolean;
+    }
+    interface Api {
+        get name(): string;
     }
     interface KeyboardApi extends Api {
-        get name(): INoteInteraction.Operations;
+        get name(): string;
         check_allow(e: KeyboardEvent, scope: KeyboardScope): boolean;
         keydown(e: KeyboardEvent, scope: KeyboardScope): any;
         keyup(e: KeyboardEvent, scope: KeyboardScope): any;
     }
 }
 
+declare namespace INoteHotkeys {
+    type Scope = "global" | "note" | "map" | "none";
+    interface Config {
+        id: string;
+        name: string;
+        shortcut: string;
+        scope: Scope;
+        capture?: boolean;
+        keyup?: boolean;
+    }
+    enum HotKeys {
+        "format-brush-apply" = "\u5E94\u7528\u683C\u5F0F\u5237",
+        "format-brush-copy" = "\u590D\u5236\u683C\u5F0F\u5237",
+        "undo" = "\u64A4\u9500",
+        "redo" = "\u91CD\u505A",
+        "indent-line" = "\u7F29\u8FDB",
+        "unindent-line" = "\u53CD\u5411\u7F29\u8FDB",
+        "cursor-nav" = "\u5149\u6807\u5BFC\u822A",
+        "cursor-nav-extend" = "\u5149\u6807\u590D\u9009",
+        "line-break" = "\u6362\u884C",
+        "scope-clear" = "\u6E05\u7A7A\u5757\u9009\u533A",
+        "scope-add" = "\u6DFB\u52A0\u5757\u9009\u533A",
+        "root-add-next" = "\u5411\u540E\u6DFB\u52A0\u6839\u7EA7\u5757",
+        "root-add-prev" = "\u5411\u524D\u6DFB\u52A0\u6839\u7EA7\u5757",
+        "root-break" = "\u5206\u88C2\u6839\u7EA7\u5757",
+        "text-add-annotation" = "\u6DFB\u52A0\u6279\u6CE8",
+        "text-italic" = "\u659C\u4F53",
+        "text-bold" = "\u52A0\u7C97",
+        "text-underline" = "\u4E0B\u5212\u7EBF",
+        "text-align-left" = "\u5DE6\u5BF9\u9F50",
+        "text-align-center" = "\u5C45\u4E2D\u5BF9\u9F50",
+        "text-align-right" = "\u53F3\u5BF9\u9F50",
+        "text-partition" = "\u5206\u88C2\u6587\u672C\u5757",
+        "text-fontsize-up" = "\u589E\u52A0\u5B57\u53F7",
+        "text-fontsize-down" = "\u51CF\u5C0F\u5B57\u53F7",
+        "text-rt" = "\u6DFB\u52A0\u6587\u5B57\u6807\u6CE8",
+        "text-add-link" = "\u6DFB\u52A0\u8D85\u94FE\u63A5",
+        "text-break" = "\u6587\u672C\u5757\u6362\u884C",
+        "css-clear" = "\u91CD\u7F6E\u6837\u5F0F",
+        "fold-block" = "\u6298\u53E0\u6240\u5728\u5757",
+        "bookmark-add" = "\u6DFB\u52A0\u4E66\u7B7E",
+        "search-doc" = "\u641C\u7D22",
+        "float-formula" = "\u516C\u5F0F\u9762\u677F",
+        "float-cubelist" = "\u5143\u7D20\u9762\u677F",
+        "paste-md" = "\u7C98\u8D34markdown"
+    }
+    enum Group {
+        core = "\u6838\u5FC3",
+        common = "\u901A\u7528",
+        text = "\u6587\u672C\u5757",
+        block = "\u5757",
+        scope = "\u5757\u9009\u533A",
+        dict = "\u5B57\u5178",
+        bookmark = "\u4E66\u7B7E",
+        search = "\u641C\u7D22",
+        css = "\u6837\u5F0F",
+        float = "\u9762\u677F",
+        other = "\u5176\u4ED6"
+    }
+    interface HotKeyInfo {
+        name: string;
+        show: boolean;
+        meta: boolean;
+        shift: boolean;
+        alt: boolean;
+        ctrl: boolean;
+        key: string[];
+        group: string;
+        cursor?: boolean;
+    }
+    type NoteHotkeys = Record<string, HotKeyInfo>;
+    type HotKeyHandler = (e: KeyboardEvent) => any;
+}
+
 declare namespace ICubeHandler {
     type Handler = (cmd: any, ...args: any[]) => Recorder | void;
 }
 
 declare namespace INoteHistory {
     interface RecorderData {
-        do: ICubeCommand.BaseCommand[];
-        undo: ICubeCommand.BaseCommand[];
+        do: ICommandCube.BaseCommand[];
+        undo: ICommandCube.BaseCommand[];
     }
     interface Stack {
         version: number;
@@ -5565,7 +5566,7 @@ declare namespace INoteEvent {
     type ListenerAssetDownload = (type: INote.AssetType, filename: string) => Promise<boolean>;
     type ListenerAssetCopy = (noteid: string, asset_type: INote.AssetType, filename: string) => Promise<boolean>;
     type ListenerReplaceId = (map: Record<string, string>) => any;
-    type ListenerEdit = (cube: CubeChild, cmd: ICubeCommand.BaseCommand) => any;
+    type ListenerEdit = (cube: CubeChild, cmd: ICommandCube.BaseCommand) => any;
     type ListenerTextMerge = (from: string, to: string) => any;
     type ListenerEsc = () => any;
     type ListenerSelectionChange = (e: Event) => any;
@@ -5595,80 +5596,6 @@ declare namespace INoteFlag {
 declare namespace INoteFloat {
 }
 
-declare namespace INoteHotkeys {
-    type Scope = "global" | "note" | "map" | "none";
-    interface Config {
-        id: string;
-        name: string;
-        shortcut: string;
-        scope: Scope;
-        capture?: boolean;
-        keyup?: boolean;
-    }
-    enum HotKeys {
-        "format-brush-apply" = "\u5E94\u7528\u683C\u5F0F\u5237",
-        "format-brush-copy" = "\u590D\u5236\u683C\u5F0F\u5237",
-        "undo" = "\u64A4\u9500",
-        "redo" = "\u91CD\u505A",
-        "indent-line" = "\u7F29\u8FDB",
-        "unindent-line" = "\u53CD\u5411\u7F29\u8FDB",
-        "cursor-nav" = "\u5149\u6807\u5BFC\u822A",
-        "cursor-nav-extend" = "\u5149\u6807\u590D\u9009",
-        "line-break" = "\u6362\u884C",
-        "scope-clear" = "\u6E05\u7A7A\u5757\u9009\u533A",
-        "scope-add" = "\u6DFB\u52A0\u5757\u9009\u533A",
-        "root-add-next" = "\u5411\u540E\u6DFB\u52A0\u6839\u7EA7\u5757",
-        "root-add-prev" = "\u5411\u524D\u6DFB\u52A0\u6839\u7EA7\u5757",
-        "root-break" = "\u5206\u88C2\u6839\u7EA7\u5757",
-        "text-add-annotation" = "\u6DFB\u52A0\u6279\u6CE8",
-        "text-italic" = "\u659C\u4F53",
-        "text-bold" = "\u52A0\u7C97",
-        "text-underline" = "\u4E0B\u5212\u7EBF",
-        "text-align-left" = "\u5DE6\u5BF9\u9F50",
-        "text-align-center" = "\u5C45\u4E2D\u5BF9\u9F50",
-        "text-align-right" = "\u53F3\u5BF9\u9F50",
-        "text-partition" = "\u5206\u88C2\u6587\u672C\u5757",
-        "text-fontsize-up" = "\u589E\u52A0\u5B57\u53F7",
-        "text-fontsize-down" = "\u51CF\u5C0F\u5B57\u53F7",
-        "text-rt" = "\u6DFB\u52A0\u6587\u5B57\u6807\u6CE8",
-        "text-add-link" = "\u6DFB\u52A0\u8D85\u94FE\u63A5",
-        "text-break" = "\u6587\u672C\u5757\u6362\u884C",
-        "css-clear" = "\u91CD\u7F6E\u6837\u5F0F",
-        "fold-block" = "\u6298\u53E0\u6240\u5728\u5757",
-        "bookmark-add" = "\u6DFB\u52A0\u4E66\u7B7E",
-        "search-doc" = "\u641C\u7D22",
-        "float-formula" = "\u516C\u5F0F\u9762\u677F",
-        "float-cubelist" = "\u5143\u7D20\u9762\u677F",
-        "paste-md" = "\u7C98\u8D34markdown"
-    }
-    enum Group {
-        core = "\u6838\u5FC3",
-        common = "\u901A\u7528",
-        text = "\u6587\u672C\u5757",
-        block = "\u5757",
-        scope = "\u5757\u9009\u533A",
-        dict = "\u5B57\u5178",
-        bookmark = "\u4E66\u7B7E",
-        search = "\u641C\u7D22",
-        css = "\u6837\u5F0F",
-        float = "\u9762\u677F",
-        other = "\u5176\u4ED6"
-    }
-    interface HotKeyInfo {
-        name: string;
-        show: boolean;
-        meta: boolean;
-        shift: boolean;
-        alt: boolean;
-        ctrl: boolean;
-        key: string[];
-        group: string;
-        cursor?: boolean;
-    }
-    type NoteHotkeys = Record<string, HotKeyInfo>;
-    type HotKeyHandler = (e: KeyboardEvent) => any;
-}
-
 declare namespace INoteClipboard {
     interface NoteData {
         noteid: string;
@@ -5704,6 +5631,22 @@ declare namespace IUiTheme {
         path: string;
         filters?: BackgroundFilter;
     }
+    interface BackgroundVirtualConfig {
+        card_min_width: number;
+        card_height: number;
+        grid_gap: number;
+        overscan_rows: number;
+    }
+    interface BackgroundVirtualState {
+        scroll_top: number;
+        viewport_height: number;
+        grid_top: number;
+        columns: number;
+    }
+    interface BackgroundVirtualItem {
+        item: BackgroundItem;
+        index: number;
+    }
     interface ThemeItem<T extends string = Names> {
         id: T;
         name: string;
@@ -6027,7 +5970,7 @@ declare namespace IUiTips {
 }
 
 declare namespace IUiToolbar {
-    type Name = "align" | "annotation" | "border" | "bookmark" | "bold-italic" | "color" | "compose" | "emphasis" | "fold" | "formula" | "font" | "format-brush" | "history" | "indent" | "paste" | "speak" | "scope" | "spacing" | "underline" | "write-mode" | "rt";
+    type Name = "align" | "annotation" | "border" | "bookmark" | "bold-italic" | "color" | "compose" | "emphasis" | "fold" | "formula" | "font" | "format-brush" | "history" | "indent" | "paste" | "speak" | "scope" | "spacing" | "underline" | "write-mode" | "rt" | (string & {});
     interface Tool {
         class: string[];
         tooltip: string;
@@ -6062,29 +6005,130 @@ declare global {
     const _SDK_PUB_DATE: number;
 }
 
+declare class CommandApi {
+}
+
+declare class CommandBoxFolder {
+}
+
+declare class CommandBoxRoot {
+}
+
+declare class CommandCode {
+    static update(id: string, tabid: string, code: string): ICommandCode.Update;
+    static add(id: string, item: ICode.TabItem, focus?: boolean): ICommandCode.Add;
+    static remove(id: string, tabid: string): ICommandCode.Remove;
+    static rename(id: string, tabid: string, filename: string): ICommandCode.Rename;
+    static change_lang(id: string, tabid: string, lang: string): ICommandCode.ChangeLang;
+    static change_active(id: string, tabid: string): ICommandCode.TabActive;
+    static change_theme(id: string, tabid: string, theme: string): ICommandCode.ChangeTheme;
+}
+
 declare class CommandCube {
-    static insert_child(id: string, data: ICubeBase.Data[], pos: number | INote.CubeSide): ICubeCommand.InsertChild;
-    static delete_child(id: string, dir: ICubeCommand.DeleteDir, range: [number, number], reserve?: boolean): ICubeCommand.DeleteChild;
-    static insert(id: string, data: ICubeBase.Data[], start_id: ICubeBase.CubeId, end_id: ICubeBase.CubeId, offset_start: number, offset_end: number): ICubeCommand.Insert;
-    static delete(id: string, dir: ICubeCommand.DeleteDir, start_id: ICubeBase.CubeId | null, end_id: ICubeBase.CubeId | null, offset_start: number | INote.CubeSide, offset_end: number | INote.CubeSide, reserve?: boolean): ICubeCommand.Delete;
-    static delete_adjacent(id: string, from: ICubeCommand.CursorFrom, from_id: ICubeBase.CubeId, offset: number): ICubeCommand.DeleteAdjacent;
-    static set_selection_css(id: ICubeBase.CubeId, css: Record<string, any>, start_id: ICubeBase.CubeId | null, end_id: ICubeBase.CubeId | null, offset_start: number | INote.CubeSide, offset_end: number | INote.CubeSide, method?: ICubeCommand.CssMethod): ICubeCommand.SetSelectionCss;
-    static set_css(id: ICubeBase.CubeId, css: Record<string, any>, method?: ICubeCommand.CssMethod): ICubeCommand.SetCss;
-    static partition(id: ICubeBase.CubeId, start_id: ICubeBase.CubeId, end_id: ICubeBase.CubeId, offset_start: number, offset_end: number): ICubeCommand.Partition;
-    static reorder(id: ICubeBase.CubeId, cubeid: ICubeBase.CubeId, index: number | INote.CubeSide): ICubeCommand.Reorder;
-    static reset(id: ICubeBase.CubeId, data: ICubeBase.Data[]): ICubeCommand.Reset;
-    static merge(id: ICubeBase.CubeId, method: INote.CubeMergeMethod, cubeid: ICubeBase.CubeId, offset: number): ICubeCommand.Merge;
-    static postil_add(id: ICubeBase.CubeId, data?: ICubeBase.Data[]): ICubeCommand.PostilAdd;
-    static postil_remove(id: ICubeBase.CubeId, range: [number, number]): ICubeCommand.PostilRemove;
-    static set_attr(id: ICubeBase.CubeId, attr: Partial<ICubeBase.Attrs>): ICubeCommand.SetAttr;
-    static resize(id: ICubeBase.CubeId, width: number, height?: number): ICubeCommand.SetAttr;
-    static fold(id: ICubeBase.CubeId, fold: boolean): ICubeCommand.SetAttr;
+    static insert_child(id: string, data: ICubeBase.Data[], pos: number | INote.CubeSide): ICommandCube.InsertChild;
+    static delete_child(id: string, dir: ICommandCube.DeleteDir, range: [number, number], reserve?: boolean): ICommandCube.DeleteChild;
+    static insert(id: string, data: ICubeBase.Data[], start_id: ICubeBase.CubeId, end_id: ICubeBase.CubeId, offset_start: number, offset_end: number): ICommandCube.Insert;
+    static delete(id: string, dir: ICommandCube.DeleteDir, start_id: ICubeBase.CubeId | null, end_id: ICubeBase.CubeId | null, offset_start: number | INote.CubeSide, offset_end: number | INote.CubeSide, reserve?: boolean): ICommandCube.Delete;
+    static delete_adjacent(id: string, from: ICommandCube.CursorFrom, from_id: ICubeBase.CubeId, offset: number): ICommandCube.DeleteAdjacent;
+    static set_selection_css(id: ICubeBase.CubeId, css: Record<string, any>, start_id: ICubeBase.CubeId | null, end_id: ICubeBase.CubeId | null, offset_start: number | INote.CubeSide, offset_end: number | INote.CubeSide, method?: ICommandCube.CssMethod): ICommandCube.SetSelectionCss;
+    static set_css(id: ICubeBase.CubeId, css: Record<string, any>, method?: ICommandCube.CssMethod): ICommandCube.SetCss;
+    static partition(id: ICubeBase.CubeId, start_id: ICubeBase.CubeId, end_id: ICubeBase.CubeId, offset_start: number, offset_end: number): ICommandCube.Partition;
+    static reorder(id: ICubeBase.CubeId, cubeid: ICubeBase.CubeId, index: number | INote.CubeSide): ICommandCube.Reorder;
+    static reset(id: ICubeBase.CubeId, data: ICubeBase.Data[]): ICommandCube.Reset;
+    static merge(id: ICubeBase.CubeId, method: INote.CubeMergeMethod, cubeid: ICubeBase.CubeId, offset: number): ICommandCube.Merge;
+    static postil_add(id: ICubeBase.CubeId, data?: ICubeBase.Data[]): ICommandCube.PostilAdd;
+    static postil_remove(id: ICubeBase.CubeId, range: [number, number]): ICommandCube.PostilRemove;
+    static set_attr(id: ICubeBase.CubeId, attr: Partial<ICubeBase.Attrs>): ICommandCube.SetAttr;
+    static resize(id: ICubeBase.CubeId, width: number, height?: number): ICommandCube.SetAttr;
+    static fold(id: ICubeBase.CubeId, fold: boolean): ICommandCube.SetAttr;
 }
 
 declare class CommandCursor {
-    static loc(id: string, offset: number, from: string, from_offset: number): ICursorCommand.Loc;
-    static in_head(id: string): ICursorCommand.InHead;
-    static in_tail(id: string): ICursorCommand.InTail;
+    static loc(id: string, offset: number, from: string, from_offset: number): ICommandCursor.Loc;
+    static in_head(id: string): ICommandCursor.InHead;
+    static in_tail(id: string): ICommandCursor.InTail;
+}
+
+declare class CommandDetailList {
+    static insert_row(id: ICubeBase.CubeId, pos: number | INote.CubeSide, rows: IDetailList.BoxDataMap[]): ICommandDetailList.InsertRow;
+    static remove_row(id: ICubeBase.CubeId, range: [number, number], reserve?: boolean): ICommandDetailList.RemoveRow;
+    static change_width_col1(id: ICubeBase.CubeId, width: number): ICommandDetailList.ChangeWidthCol1;
+}
+
+declare class CommandFormula {
+    static update(id: string, latex: string, size: IFormula.Size, block?: boolean): ICommandFormula.Update;
+}
+
+declare class CommandMap {
+    static node_add(id: ICubeBase.CubeId, data: INodeBase.Base[]): ICommandMap.NodeAdd;
+    static node_remove(id: ICubeBase.CubeId, data: ICubeBase.CubeId[]): ICommandMap.NodeRemove;
+    static linker_add(id: ICubeBase.CubeId, data: ICommandMap.LinkerInfo[], to_root?: boolean): ICommandMap.LinkerAdd;
+    static linker_remove(id: ICubeBase.CubeId, data: ICubeBase.CubeId[], to_root?: boolean): ICommandMap.LinkerRemove;
+    static node_drag(id: ICubeBase.CubeId, data: ICommandMap.NodeMoveInfo[]): ICommandMap.NodeMove;
+    static sibling_reorder(id: ICubeBase.CubeId, upstream_id: ICubeBase.CubeId, order: ICubeBase.CubeId[]): ICommandMap.SiblingReorder;
+}
+
+declare class CommandNode {
+    static layout_change(id: ICubeBase.CubeId, attrs: Partial<INodeBase.Attrs>): ICommandNode.LayoutUpdate;
+    static append_child(id: ICubeBase.CubeId, nodes: INodeBase.Base[], previd?: string | null): ICommandNode.AppendChild;
+}
+
+declare class CommandLinker {
+    static update(id: ICubeBase.CubeId, attrs: ICommandLinker.UpdateAttr): ICommandLinker.Update;
+}
+
+declare class CommandList {
+    static reset(id: string, data: IList.ListItemData[]): ICommandList.Reset;
+    static add(id: string, data: IList.ListItemData[], pos: number): ICommandList.AddItem;
+    static remove(id: string, range: [number, number]): ICommandList.RemoveItem;
+    static indent(id: string, items: ICommandList.ItemIndentInfo[]): ICommandList.IndentItem;
+}
+
+declare class CommandListOrdered {
+    static reset(id: string, data: IList.ListItemData[]): ICommandListOrdered.Reset;
+    static add(id: string, data: IList.ListItemData[], pos: number): ICommandListOrdered.AddItem;
+    static remove(id: string, range: [number, number]): ICommandListOrdered.RemoveItem;
+    static indent(id: string, items: ICommandList.ItemIndentInfo[]): ICommandListOrdered.IndentItem;
+}
+
+declare class CommandRt {
+    static reset(id: ICubeBase.CubeId, explanation: string): ICommandRt.Reset;
+}
+
+declare class CommandTable {
+    static add_title(id: ICubeBase.CubeId, data: IBox.Data): ICommandTable.AddTitle;
+    static remove_title(id: ICubeBase.CubeId): ICommandTable.RemoveTitle;
+    static add_cell(id: ICubeBase.CubeId, data: ITable.CellData): ICommandTable.AddCell;
+    static remove_cell(id: ICubeBase.CubeId, cid: ICubeBase.CubeId): ICommandTable.RemoveCell;
+    static add_row(id: ICubeBase.CubeId, index: number, rows: IBox.Data[]): ICommandTable.AddRow;
+    static remove_row(id: ICubeBase.CubeId, index: number): ICommandTable.RemoveRow;
+    static add_col(id: ICubeBase.CubeId, index: number, cols: IBox.Data[]): ICommandTable.AddCol;
+    static remove_col(id: ICubeBase.CubeId, index: number): ICommandTable.RemoveCol;
+    static moveto(id: ICubeBase.CubeId, tid: ICubeBase.CubeId, cells: ICubeBase.CubeId[]): ICommandTable.CellMoveTo;
+    static merge(id: ICubeBase.CubeId, area: ITable.CellArea): ICommandTable.Merge;
+    static update_cell_area(id: ICubeBase.CubeId, tid: ICubeBase.CubeId, area: ITable.CellRect): ICommandTable.CellUpdateArea;
+    static add_grid_col(id: ICubeBase.CubeId, index: number, width: number): ICommandTable.AddGridCol;
+    static remove_grid_col(id: ICubeBase.CubeId, index: number): ICommandTable.RemoveGridCol;
+    static add_grid_row(id: ICubeBase.CubeId, index: number): ICommandTable.AddGridRow;
+    static remove_grid_row(id: ICubeBase.CubeId, index: number): ICommandTable.RemoveGridRow;
+    static col_resize(id: ICubeBase.CubeId, cols: [number, number], step: number): ICommandTable.ColResize;
+}
+
+declare class CommandText {
+    static reset(id: string, info: string, pos?: number, pos_before?: number): ICommandText.Reset;
+    static break(id: string, offset: number): ICommandText.Break;
+}
+
+declare class CommandTextLink {
+    static update(id: ICubeBase.CubeId, title: string, url: string): ICommandTextLink.Update;
+}
+
+declare class CommandTodo {
+    static reset(id: string, data: _CubeTodoItemData[]): ICommandTodo.Reset;
+    static add(id: string, data: _CubeTodoItemData[], pos: number): ICommandTodo.AddItem;
+    static remove(id: string, range: [number, number]): ICommandTodo.RemoveItem;
+    static indent(id: string, items: ICommandList.ItemIndentInfo[]): ICommandTodo.Indent;
+    static status(id: string, index: number, done: boolean): ICommandTodo.Status;
 }
 
 declare class LayoutChecker {
@@ -6135,20 +6179,6 @@ declare class NodeLayoutInvert {
     };
 }
 
-declare class CommandMap {
-    static node_add(id: ICubeBase.CubeId, data: INodeBase.Base[]): IMapCommand.NodeAdd;
-    static node_remove(id: ICubeBase.CubeId, data: ICubeBase.CubeId[]): IMapCommand.NodeRemove;
-    static linker_add(id: ICubeBase.CubeId, data: IMapCommand.LinkerInfo[], to_root?: boolean): IMapCommand.LinkerAdd;
-    static linker_remove(id: ICubeBase.CubeId, data: ICubeBase.CubeId[], to_root?: boolean): IMapCommand.LinkerRemove;
-    static node_drag(id: ICubeBase.CubeId, data: IMapCommand.NodeMoveInfo[]): IMapCommand.NodeMove;
-    static sibling_reorder(id: ICubeBase.CubeId, upstream_id: ICubeBase.CubeId, order: ICubeBase.CubeId[]): IMapCommand.SiblingReorder;
-}
-
-declare class CommandNode {
-    static layout_change(id: ICubeBase.CubeId, attrs: Partial<INodeBase.Attrs>): INodeCommand.LayoutUpdate;
-    static append_child(id: ICubeBase.CubeId, nodes: INodeBase.Base[], previd?: string | null): INodeCommand.AppendChild;
-}
-
 declare class Matrix2D {
     static get_default(): IMapTools.Matrix2D;
     static to_array(m: IMapTools.Matrix2D): IMapTools.Matrix2DArray;
@@ -6178,7 +6208,7 @@ declare class MapTools {
     static get_direct_layout_parent(node: MapNodeBase, except?: Set<string>): MapNodeBase | null | undefined;
     static get_linker_id(fromid: string, to: string): string;
     static wait_nodes_render(nodes: Iterable<MapNodeBase>): Promise<any>;
-    static create_linker_info(map: _Map, from_id: ICubeBase.CubeId, to_id: ICubeBase.CubeId): IMapCommand.LinkerInfo;
+    static create_linker_info(map: _Map, from_id: ICubeBase.CubeId, to_id: ICubeBase.CubeId): ICommandMap.LinkerInfo;
     static get_rect_area(from: IMath.Point, to: IMath.Point, radius?: number): string;
 }
 
@@ -6197,4 +6227,4 @@ declare class NoteTools {
     static check_mouse_key(e: MouseEvent, key: _PointKey): boolean;
 }
 
-export { AdapterAnnotation, AdapterApi, AdapterBaseUi, AdapterBox, AdapterBoxColumns, AdapterBoxFolder, AdapterBoxRoot, AdapterCode, AdapterCubeBase, AdapterCubes, AdapterDetailList, AdapterDoc, AdapterFormula, AdapterImg, AdapterLine, AdapterLinker, AdapterList, AdapterListOrdered, AdapterLost, AdapterMap, AdapterNode, AdapterPostil, AdapterRt, AdapterSubmap, AdapterTable, AdapterText, AdapterTextLink, AdapterTip, AdapterTodo, AdapterUi, AdapterUiAi, AdapterUiCatalogue, AdapterUiConfig, AdapterUiDialog, AdapterUiDialogCubeList, AdapterUiDict, AdapterUiFloat, AdapterUiMenubar, AdapterUiPreset, AdapterUiSearch, AdapterUiSidebar, AdapterUiStatusbar, AdapterUiTheme, AdapterUiTips, AdapterUiToolbar, CommandApi, CommandBoxFolder, CommandBoxRoot, CommandCode, CommandCube, CommandCursor, CommandDetailList, CommandLinker, CommandListOrdered, CommandMap, CommandNode, CommandRt, CommandTable, CommandText, CommandTextLink, CommandTodo, Commandformula, ConstColors, ConvertorMd, CubeAnnotation, CubeApi, CubeBase, CubeBox, CubeBoxColumns, CubeBoxFolder, CubeBoxRoot, CubeChild, CubeCode, CubeDetailList, CubeDoc, CubeFormula, CubeImg, CubeLine, CubeLinker, CubeList, CubeListOrdered, CubeLost, CubeMap, CubeNode, CubePostil, CubeRoot, CubeRt, CubeSubMap, CubeTable, CubeText, CubeTextLink, CubeTip, CubeTodo, EventBubble, HotkeyBase, IApi, IApiCommand, IBox, ICode, ICodeCommand, ICubeBase, ICubeBaseChild, ICubeBoxColumns, ICubeBoxFolder, ICubeBoxRoot, ICubeCommand, ICubeHandler, ICubeRootBase, ICursorCommand, IDetailList, IDoc, IDocCommand, IFormula, IFormulaCommand, IImg, ILine, ILinker, ILinkerCommand, IList, IListCommand, IListOrdered, IListOrderedCommand, ILost, IMap, IMapBase, IMapCommand, IMapInteraction, IMapTools, IMenuNode, IMiniMap, IMisc, INode, INodeBase, INodeBaseEnv, INodeCommand, INodeDrag, INote, INoteApi, INoteClipboard, INoteConvertor, INoteCourier, INoteCursor, INoteEvent, INoteFlag, INoteFloat, INoteHistory, INoteHotkeys, INoteInteraction, INoteMenu, INoteMod, INoteScope, INoteTools, IPostil, IRt, IRtCommand, ISubMap, ITable, ITableCommand, IText, ITextCommand, ITextLink, ITextLinkCommand, ITip, ITodo, ITodoCommand, IUi, IUiAi, IUiCatalogue, IUiConfig, IUiDialog, IUiDialogCubeList, IUiDict, IUiFloat, IUiMenubar, IUiPreset, IUiSidebar, IUiStatusbar, IUiTheme, IUiTips, IUiToolbar, LayoutChecker, LinkerLine, LinkerPoint, Map2D, MapCanvas, MapChild, MapInteraction, MapNodeBase, MapNodeLayoutEnv, MapTools, Matrix2D, NodeBase2D, NodeLayout, NodeLayoutInvert, NodeLayoutMeter, NodeObserver, NodeShape, Note, NoteAction, NoteApi, NoteBase, NoteClipBoard, NoteConvertor, NoteCourier, NoteCubes, NoteCursor, NoteEvent, NoteFlag, NoteHistory, NoteHotkeys, NoteInteraction, NoteListener, NoteMod, NotePainter, NoteScope, NoteScopes, NoteTools, Recorder, StatusAnnotation, StatusApi, StatusBox, StatusBoxFolder, StatusBoxRoot, StatusCode, StatusCube, StatusCubeRoot, StatusDetailList, StatusDoc, StatusImg, StatusLine, StatusList, StatusListOrdered, StatusLost, StatusMap, StatusNode, StatusNodeBase, StatusPostil, StatusRt, StatusSubmap, StatusTable, StatusText, StatusTextLink, StatusTip, StatusTodo, Statusformula, ToolBase, UI, UICatalogue, UIDict, UISearch, UIStatusbar, UITheme, UIToolbar, UiBase, UiConfig, UiFloat, UiMenubar, UiPreset, UiSidebar, UiTips, Waiter, type _CubeTextAnnotation, type _CubeTodoItem, type _CubeTodoItemData, type _FigScale, type _Map, type _MapCubes, _MapGroup, type _MapPlaceholderLinker, _PlayStatus, type _PointFig, type _PointKey, type _PointView, type _SDKMeta, cmd, cube, key, keymap, node_observer, waiter_map_svg };
+export { AdapterApi, AdapterBaseUi, AdapterBox, AdapterBoxColumns, AdapterBoxFolder, AdapterBoxRoot, AdapterCode, AdapterCubes, AdapterDetailList, AdapterDoc, AdapterFormula, AdapterImg, AdapterLine, AdapterLinker, AdapterList, AdapterListOrdered, AdapterLost, AdapterMap, AdapterNode, AdapterPostil, AdapterRt, AdapterSubmap, AdapterTable, AdapterText, AdapterTextLink, AdapterTip, AdapterTodo, AdapterUi, AdapterUiAi, AdapterUiCatalogue, AdapterUiConfig, AdapterUiDialog, AdapterUiDialogCubeList, AdapterUiDict, AdapterUiFloat, AdapterUiMenubar, AdapterUiPreset, AdapterUiSearch, AdapterUiSidebar, AdapterUiStatusbar, AdapterUiTheme, AdapterUiTips, AdapterUiToolbar, ApiStatus, BoxFolderStatus, BoxRootStatus, BoxStatus, CodeStatus, CommandApi, CommandBoxFolder, CommandBoxRoot, CommandCode, CommandCube, CommandCursor, CommandDetailList, CommandFormula, CommandLinker, CommandList, CommandListOrdered, CommandMap, CommandNode, CommandRt, CommandTable, CommandText, CommandTextLink, CommandTodo, ConstColors, ConvertorMd, CubeAdapterBase, CubeApi, CubeBase, CubeBox, CubeBoxColumns, CubeBoxFolder, CubeBoxRoot, CubeChild, CubeCode, CubeDetailList, CubeDoc, CubeFormula, CubeImg, CubeLine, CubeLinker, CubeList, CubeListOrdered, CubeListenerBase, CubeLost, CubeMap, CubeNode, CubePostil, CubeRoot, CubeRt, CubeStatusBase, CubeStatusBaseRoot, CubeSubMap, CubeTable, CubeText, CubeTextLink, CubeTip, CubeTodo, DetailListStatus, DocStatus, EventBubble, FormulaStatus, IApi, IBox, ICode, ICommandApi, ICommandCode, ICommandCube, ICommandCursor, ICommandDetailList, ICommandDoc, ICommandFormula, ICommandLinker, ICommandList, ICommandListOrdered, ICommandMap, ICommandNode, ICommandRt, ICommandTable, ICommandText, ICommandTextLink, ICommandTodo, ICubeBase, ICubeBaseChild, ICubeBoxColumns, ICubeBoxFolder, ICubeBoxRoot, ICubeHandler, ICubeRootBase, IDetailList, IDoc, IFormula, IImg, ILine, ILinker, IList, IListOrdered, ILost, IMap, IMapBase, IMapInteraction, IMapTools, IMenuNode, IMiniMap, IMisc, INode, INodeBase, INodeBaseEnv, INodeDrag, INote, INoteApi, INoteClipboard, INoteConvertor, INoteCourier, INoteCursor, INoteEvent, INoteFlag, INoteFloat, INoteHistory, INoteHotkeys, INoteInteraction, INoteMenu, INoteMod, INoteScope, INoteTools, IPostil, IRt, ISubMap, ITable, IText, ITextLink, ITip, ITodo, IUi, IUiAi, IUiCatalogue, IUiConfig, IUiDialog, IUiDialogCubeList, IUiDict, IUiFloat, IUiMenubar, IUiPreset, IUiSidebar, IUiStatusbar, IUiTheme, IUiTips, IUiToolbar, ImgStatus, LayoutChecker, LineStatus, LinkerLine, LinkerPoint, ListOrderedStatus, ListStatus, LostStatus, Map2D, MapCanvas, MapChild, MapHotkeys, MapInteraction, MapNodeBase, MapNodeLayoutEnv, MapStatus, MapTools, Matrix2D, NodeBase2D, NodeLayout, NodeLayoutInvert, NodeLayoutMeter, NodeObserver, NodeShape, NodeStatus, NodeStatusBase, Note, NoteAction, NoteApi, NoteBase, NoteClipBoard, NoteConvertor, NoteCourier, NoteCubes, NoteCursor, NoteEvent, NoteEventListenerBase, NoteEventListeners, NoteFlag, NoteHistory, NoteHotkeyBase, NoteInteraction, NoteListener, NoteMod, NotePainter, NoteScope, NoteScopes, NoteTools, PostilStatus, Recorder, RtStatus, SubmapStatus, TableStatus, TextLinkStatus, TextStatus, TipStatus, TodoStatus, ToolBase, UI, UICatalogue, UIDict, UISearch, UIStatusbar, UITheme, UIToolbar, UiBase, UiConfig, UiFloat, UiMenubar, UiPreset, UiSidebar, UiTips, Waiter, type _CubeTextAnnotation, type _CubeTodoItem, type _CubeTodoItemData, type _FigScale, type _Map, type _MapCubes, _MapGroup, type _MapPlaceholderLinker, _PlayStatus, type _PointFig, type _PointKey, type _PointView, type _SDKMeta, cmd, copy_event_listener, cube, cut_event_listener, hotkey, node_observer, paste_event_listener, waiter_map_svg };