extprg-types 1.0.2 → 1.0.3

package/index.d.ts

@@ -3,7 +3,7 @@
 
 /**
  * Auto-generated. Do not edit manually.
- * 2026-05-07T14:05:16.404Z
+ * 2026-05-07T14:30:53.302Z
  */
 
 // ── 第三方类型导入 ──
@@ -19,120 +19,120 @@ import type * as react_dialog from "@radix-ui/react-dialog";
 
 // ── 本地类型定义 ──
 declare class AIEngine {
-  createTransport(project: Project);
-  createChatFetch(project: Project): typeof fetch;
-  getModels();
+  createTransport(project: Project): Promise<void>;
+  createChatFetch(project: Project): Promise<typeof fetch>;
+  getModels(): Promise<void>;
   readRequestBody(body: BodyInit | null | undefined): Promise<any>;
 }
 
 declare class Association extends StageObject {
-  associationList: StageObject[];
-  color: Color;
+  associationList: Promise<StageObject>[];
+  color: Promise<Color>;
 }
 
 declare class AutoAlign {
   constructor(project: Project);
-  getSelectionOuterRectangle(entities: Entity[]): Rectangle | null;
-  calculateDistanceByRectangle(rectA: Rectangle, rectB: Rectangle);
-  alignRectangleToTargetX(selectedRect: Rectangle, otherRect: Rectangle): number;
-  alignRectangleToTargetY(selectedRect: Rectangle, otherRect: Rectangle): number;
-  _addAlignEffectByRect(selectedRect: Rectangle, otherRect: Rectangle);
-  getGridSnapDeltaX(rect: Rectangle);
-  getGridSnapDeltaY(rect: Rectangle);
-  alignAllSelectedToGrid();
-  alignAllSelected();
-  preAlignAllSelected();
-  onEntityMoveAlignToGrid(selectedEntity: Entity);
-  onEntityMoveAlignToGridX(selectedEntity: Entity);
-  onEntityMoveAlignToGridY(selectedEntity: Entity);
-  onEntityMoveAlignToOtherEntity(selectedEntity: Entity, otherEntities: Entity[], isPreAlign = false);
-  _addAlignEffect(selectedEntity: Entity, otherEntity: Entity);
-  onEntityMoveAlignToTargetEntityX(selectedEntity: Entity, otherEntity: Entity, isPreAlign = false): number;
-  onEntityMoveAlignToTargetEntityY(selectedEntity: Entity, otherEntity: Entity, isPreAlign = false): number;
-  calculateDistance(entityA: Entity, entityB: Entity);
-  autoLayoutSelectedFastTreeMode(selectedRootEntity: ConnectableEntity);
+  getSelectionOuterRectangle(entities: Entity[]): Promise<Rectangle | null>;
+  calculateDistanceByRectangle(rectA: Rectangle, rectB: Rectangle): Promise<void>;
+  alignRectangleToTargetX(selectedRect: Rectangle, otherRect: Rectangle): Promise<number>;
+  alignRectangleToTargetY(selectedRect: Rectangle, otherRect: Rectangle): Promise<number>;
+  _addAlignEffectByRect(selectedRect: Rectangle, otherRect: Rectangle): Promise<void>;
+  getGridSnapDeltaX(rect: Rectangle): Promise<void>;
+  getGridSnapDeltaY(rect: Rectangle): Promise<void>;
+  alignAllSelectedToGrid(): Promise<void>;
+  alignAllSelected(): Promise<void>;
+  preAlignAllSelected(): Promise<void>;
+  onEntityMoveAlignToGrid(selectedEntity: Entity): Promise<void>;
+  onEntityMoveAlignToGridX(selectedEntity: Entity): Promise<void>;
+  onEntityMoveAlignToGridY(selectedEntity: Entity): Promise<void>;
+  onEntityMoveAlignToOtherEntity(selectedEntity: Entity, otherEntities: Entity[], isPreAlign = false): Promise<void>;
+  _addAlignEffect(selectedEntity: Entity, otherEntity: Entity): Promise<void>;
+  onEntityMoveAlignToTargetEntityX(selectedEntity: Entity, otherEntity: Entity, isPreAlign = false): Promise<number>;
+  onEntityMoveAlignToTargetEntityY(selectedEntity: Entity, otherEntity: Entity, isPreAlign = false): Promise<number>;
+  calculateDistance(entityA: Entity, entityB: Entity): Promise<void>;
+  autoLayoutSelectedFastTreeMode(selectedRootEntity: ConnectableEntity): Promise<void>;
 }
 
 declare class AutoCompleteManager {
-  currentWindowId: string | undefined;
+  currentWindowId: Promise<string | undefined>;
   constructor(project: Project);
   handle;
-  openWindow(node: TextNode, entries: Record<string, string>, onSelect: (value: string) => void, setWindowId: (id: string) => void);
-  handleLogic(text: string, node: TextNode, ele: HTMLTextAreaElement, setWindowId: (id: string) => void);
+  openWindow(node: TextNode, entries: Record<string, string>, onSelect: (value: string) => void, setWindowId: (id: string) => void): Promise<void>;
+  handleLogic(text: string, node: TextNode, ele: HTMLTextAreaElement, setWindowId: (id: string) => void): Promise<void>;
   handleReference;
-  handleReferenceFile(searchText: string, node: TextNode, ele: HTMLTextAreaElement, setWindowId: (id: string) => void);
-  handleReferenceSection(searchText: string, node: TextNode, ele: HTMLTextAreaElement, setWindowId: (id: string) => void);
+  handleReferenceFile(searchText: string, node: TextNode, ele: HTMLTextAreaElement, setWindowId: (id: string) => void): Promise<void>;
+  handleReferenceSection(searchText: string, node: TextNode, ele: HTMLTextAreaElement, setWindowId: (id: string) => void): Promise<void>;
 }
 
 declare class AutoCompute {
-  MapOperationNameFunction: StringFunctionMap;
-  MapNameFunction: StringFunctionMap;
-  MapVariableFunction: VariableFunctionMap;
-  MapOtherFunction: OtherFunctionMap;
+  MapOperationNameFunction: Promise<StringFunctionMap>;
+  MapNameFunction: Promise<StringFunctionMap>;
+  MapVariableFunction: Promise<VariableFunctionMap>;
+  MapOtherFunction: Promise<OtherFunctionMap>;
   variables;
   constructor(project: Project);
   tickNumber;
-  tick();
-  funcTypeTrans(mF: MathFunctionType): StringFunctionType;
-  isTextNodeLogic(node: TextNode): boolean;
-  isSectionLogic(section: Section): boolean;
-  sortEntityByLocation(entities: ConnectableEntity[]): ConnectableEntity[];
-  computeTextNode(node: TextNode);
-  computeSection(section: Section);
-  computeEdge(edge: LineEdge);
+  tick(): Promise<void>;
+  funcTypeTrans(mF: MathFunctionType): Promise<StringFunctionType>;
+  isTextNodeLogic(node: TextNode): Promise<boolean>;
+  isSectionLogic(section: Section): Promise<boolean>;
+  sortEntityByLocation(entities: ConnectableEntity[]): Promise<ConnectableEntity>[];
+  computeTextNode(node: TextNode): Promise<void>;
+  computeSection(section: Section): Promise<void>;
+  computeEdge(edge: LineEdge): Promise<void>;
 }
 
 declare class AutoComputeUtils {
   constructor(project: Project);
-  getParentTextNodes(node: TextNode): TextNode[];
-  getParentEntities(node: TextNode): ConnectableEntity[];
-  getChildTextNodes(node: TextNode): TextNode[];
-  getNodeOneResult(node: TextNode, resultText: string);
-  getSectionOneResult(section: Section, resultText: string);
-  getSectionMultiResult(section: Section, resultTextList: string[]);
-  generateMultiResult(node: TextNode, resultTextList: string[]);
-  stringToNumber(str: string);
-  isNodeConnectedWithLogicNode(node: ConnectableEntity): boolean;
-  isNameIsLogicNode(name: string): boolean;
+  getParentTextNodes(node: TextNode): Promise<TextNode>[];
+  getParentEntities(node: TextNode): Promise<ConnectableEntity>[];
+  getChildTextNodes(node: TextNode): Promise<TextNode>[];
+  getNodeOneResult(node: TextNode, resultText: string): Promise<void>;
+  getSectionOneResult(section: Section, resultText: string): Promise<void>;
+  getSectionMultiResult(section: Section, resultTextList: string[]): Promise<void>;
+  generateMultiResult(node: TextNode, resultTextList: string[]): Promise<void>;
+  stringToNumber(str: string): Promise<void>;
+  isNodeConnectedWithLogicNode(node: ConnectableEntity): Promise<boolean>;
+  isNameIsLogicNode(name: string): Promise<boolean>;
 }
 
 declare class AutoLayout {
   constructor(project: Project);
-  isGravityLayoutStart: boolean;
-  tick();
-  setGravityLayoutStart();
-  setGravityLayoutEnd();
-  getDAGLayoutInput(entities: ConnectableEntity[]): {
+  isGravityLayoutStart: Promise<boolean>;
+  tick(): Promise<void>;
+  setGravityLayoutStart(): Promise<void>;
+  setGravityLayoutEnd(): Promise<void>;
+  getDAGLayoutInput(entities: ConnectableEntity[]): Promise<{
     nodes: Array<{ id: string; rectangle: Rectangle }>;
     edges: Array<{ from: string; to: string }>;
-  };
+  }>;
   computeDAGLayout(input: {
     nodes: Array<{ id: string; rectangle: Rectangle }>;
     edges: Array<{ from: string; to: string }>;
-  }): { [nodeId: string]: Vector };
-  topologicalSort(nodes: Array<{ id: string; rectangle: Rectangle }>, edges: Array<{ from: string; to: string }>): { order: string[]; levels: Map<string, number> };
-  autoLayoutDAG(entities: ConnectableEntity[]);
-  gravityLayoutTick();
+  }): Promise<{ [nodeId: string]: Vector }>;
+  topologicalSort(nodes: Array<{ id: string; rectangle: Rectangle }>, edges: Array<{ from: string; to: string }>): Promise<{ order: string[]; levels: Map<string, number> }>;
+  autoLayoutDAG(entities: ConnectableEntity[]): Promise<void>;
+  gravityLayoutTick(): Promise<void>;
 }
 
 declare class AutoLayoutFastTree {
   constructor(project: Project);
-  getTreeBoundingRectangle(node: ConnectableEntity, skipDashed = false): Rectangle;
-  moveTreeRectTo(treeRoot: ConnectableEntity, targetLocation: Vector, skipDashed = false);
-  getSortedChildNodes(_node: ConnectableEntity, childNodes: ConnectableEntity[], direction: "col" | "row" = "col"): ConnectableEntity[];
-  alignTrees(trees: ConnectableEntity[], direction: "top" | "bottom" | "left" | "right", gap = 10, skipDashed = false);
-  adjustChildrenTreesByRootNodeLocation(rootNode: ConnectableEntity, childList: ConnectableEntity[], gap = 100, position: "rightCenter" | "leftCenter" | "bottomCenter" | "topCenter" = "rightCenter", skipDashed = false);
+  getTreeBoundingRectangle(node: ConnectableEntity, skipDashed = false): Promise<Rectangle>;
+  moveTreeRectTo(treeRoot: ConnectableEntity, targetLocation: Vector, skipDashed = false): Promise<void>;
+  getSortedChildNodes(_node: ConnectableEntity, childNodes: ConnectableEntity[], direction: "col" | "row" = "col"): Promise<ConnectableEntity>[];
+  alignTrees(trees: ConnectableEntity[], direction: "top" | "bottom" | "left" | "right", gap = 10, skipDashed = false): Promise<void>;
+  adjustChildrenTreesByRootNodeLocation(rootNode: ConnectableEntity, childList: ConnectableEntity[], gap = 100, position: "rightCenter" | "leftCenter" | "bottomCenter" | "topCenter" = "rightCenter", skipDashed = false): Promise<void>;
   resolveSubtreeOverlaps(rootNode: ConnectableEntity, directionGroups: {
       right?: ConnectableEntity[];
       left?: ConnectableEntity[];
       bottom?: ConnectableEntity[];
       top?: ConnectableEntity[];
-    }, skipDashed = false);
-  hasOverlapOrLineIntersection(rootNode: ConnectableEntity, group1: ConnectableEntity[], group2: ConnectableEntity[], dir1: "left" | "right" | "top" | "bottom", dir2: "left" | "right" | "top" | "bottom", skipDashed = false): boolean;
-  autoLayoutFastTreeMode(rootNode: ConnectableEntity);
-  treeReverseX(selectedRootEntity: ConnectableEntity);
-  treeReverseY(selectedRootEntity: ConnectableEntity);
-  treeReverse(selectedRootEntity: ConnectableEntity, direction: "X" | "Y");
+    }, skipDashed = false): Promise<void>;
+  hasOverlapOrLineIntersection(rootNode: ConnectableEntity, group1: ConnectableEntity[], group2: ConnectableEntity[], dir1: "left" | "right" | "top" | "bottom", dir2: "left" | "right" | "top" | "bottom", skipDashed = false): Promise<boolean>;
+  autoLayoutFastTreeMode(rootNode: ConnectableEntity): Promise<void>;
+  treeReverseX(selectedRootEntity: ConnectableEntity): Promise<void>;
+  treeReverseY(selectedRootEntity: ConnectableEntity): Promise<void>;
+  treeReverse(selectedRootEntity: ConnectableEntity, direction: "X" | "Y"): Promise<void>;
 }
 
 declare class AutoSaveBackupService {
@@ -140,34 +140,34 @@ declare class AutoSaveBackupService {
   lastBackupHash;
   lastSaveTime;
   constructor(project: Project);
-  tick();
-  autoSave();
-  autoBackup();
-  manualBackup();
+  tick(): Promise<void>;
+  autoSave(): Promise<void>;
+  autoBackup(): Promise<void>;
+  manualBackup(): Promise<void>;
   resolveAutoBackupDir(candidate: { kind: "custom"; path: string } | { kind: "default" }): Promise<string | null>;
   tryBackupToDir(backupDir: string): Promise<boolean>;
   backupCurrentProject(backupDir: string): Promise<boolean>;
-  generateBackupFileName(): string;
-  getOriginalFileName(): string;
+  generateBackupFileName(): Promise<string>;
+  getOriginalFileName(): Promise<string>;
   createBackupFile(backupFilePath: string): Promise<void>;
   manageBackupFiles(backupDir: string): Promise<void>;
 }
 
 declare class BackgroundRenderer {
   constructor(project: Project);
-  renderDotBackground(viewRect: Rectangle);
-  renderHorizonBackground(viewRect: Rectangle);
-  renderVerticalBackground(viewRect: Rectangle);
-  renderCartesianBackground(viewRect: Rectangle);
-  getCurrentGap(): number;
-  getLocationXIterator(viewRect: Rectangle, currentGap: number): IterableIterator<number>;
-  getLocationYIterator(viewRect: Rectangle, currentGap: number): IterableIterator<number>;
+  renderDotBackground(viewRect: Rectangle): Promise<void>;
+  renderHorizonBackground(viewRect: Rectangle): Promise<void>;
+  renderVerticalBackground(viewRect: Rectangle): Promise<void>;
+  renderCartesianBackground(viewRect: Rectangle): Promise<void>;
+  getCurrentGap(): Promise<number>;
+  getLocationXIterator(viewRect: Rectangle, currentGap: number): Promise<IterableIterator<number>>;
+  getLocationYIterator(viewRect: Rectangle, currentGap: number): Promise<IterableIterator<number>>;
 }
 
 declare class BaseExporter {
   constructor(project: Project);
-  getTreeTypeString(textNode: TextNode, nodeToStringFunc: (node: TextNode, level: number) => string);
-  getNodeChildrenArray(node: TextNode): ConnectableEntity[];
+  getTreeTypeString(textNode: TextNode, nodeToStringFunc: (node: TextNode, level: number) => string): Promise<void>;
+  getNodeChildrenArray(node: TextNode): Promise<ConnectableEntity>[];
 }
 
 declare class BaseImporter {
@@ -176,102 +176,102 @@ declare class BaseImporter {
 
 declare class Camera {
   frictionExponent;
-  location: Vector;
-  targetLocationByScale: Vector;
-  speed: Vector;
-  accelerateCommander: Vector;
-  currentScale: number;
-  targetScale: number;
-  shakeLocation: Vector;
-  savedCameraState: { location: Vector; scale: number } | null;
+  location: Promise<Vector>;
+  targetLocationByScale: Promise<Vector>;
+  speed: Promise<Vector>;
+  accelerateCommander: Promise<Vector>;
+  currentScale: Promise<number>;
+  targetScale: Promise<number>;
+  shakeLocation: Promise<Vector>;
+  savedCameraState: Promise<{ location: Vector; scale: number } | null>;
   shockMoveDiffLocationsQueue;
-  pageMove(direction: Direction);
-  bombMove(targetLocation: Vector, frameCount = 40);
-  tick();
+  pageMove(direction: Direction): Promise<void>;
+  bombMove(targetLocation: Vector, frameCount = 40): Promise<void>;
+  tick(): Promise<void>;
   tickNumber;
   allowScaleFollowMouseLocationTicks;
-  setAllowScaleFollowMouseLocationTicks(ticks: number);
-  zoomInByKeyboardPress();
-  zoomOutByKeyboardPress();
-  addScaleFollowMouseLocationTime(sec: number);
-  isStartZoomIn: boolean;
-  isStartZoomOut: boolean;
-  dealCycleSpace();
-  setLocationByOtherLocation(otherWorldLocation: Vector, viewLocation: Vector);
-  clearMoveCommander();
-  stopImmediately();
-  dealCameraScaleInTick();
-  constructor(project: Project);
-  reset();
-  resetBySelected();
-  resetByRectangle(viewRectangle: Rectangle);
-  resetScale();
-  resetLocationToZero();
-  saveCameraState();
-  restoreCameraState();
+  setAllowScaleFollowMouseLocationTicks(ticks: number): Promise<void>;
+  zoomInByKeyboardPress(): Promise<void>;
+  zoomOutByKeyboardPress(): Promise<void>;
+  addScaleFollowMouseLocationTime(sec: number): Promise<void>;
+  isStartZoomIn: Promise<boolean>;
+  isStartZoomOut: Promise<boolean>;
+  dealCycleSpace(): Promise<void>;
+  setLocationByOtherLocation(otherWorldLocation: Vector, viewLocation: Vector): Promise<void>;
+  clearMoveCommander(): Promise<void>;
+  stopImmediately(): Promise<void>;
+  dealCameraScaleInTick(): Promise<void>;
+  constructor(project: Project);
+  reset(): Promise<void>;
+  resetBySelected(): Promise<void>;
+  resetByRectangle(viewRectangle: Rectangle): Promise<void>;
+  resetScale(): Promise<void>;
+  resetLocationToZero(): Promise<void>;
+  saveCameraState(): Promise<void>;
+  restoreCameraState(): Promise<void>;
 }
 
 declare class Canvas {
-  ctx: CanvasRenderingContext2D;
+  ctx: Promise<CanvasRenderingContext2D>;
   constructor(project: Project, element: HTMLCanvasElement = document.createElement("canvas"));
-  mount(wrapper: HTMLDivElement);
-  dispose();
+  mount(wrapper: HTMLDivElement): Promise<void>;
+  dispose(): Promise<void>;
 }
 
 declare interface ClickEventPayload {
-  relativeWorldX: number;
-  relativeWorldY: number;
-  worldX: number;
-  worldY: number;
+  relativeWorldX: Promise<number>;
+  relativeWorldY: Promise<number>;
+  worldX: Promise<number>;
+  worldY: Promise<number>;
   customData: any;
-  uuid: string;
+  uuid: Promise<string>;
 }
 
 declare class CollisionBox {
-  shapes: Shape[];
+  shapes: Promise<Shape>[];
   constructor(shapes: Shape[]);
   updateShapeList(shapes: Shape[]): void;
-  isContainsPoint(location: Vector): boolean;
-  isIntersectsWithRectangle(rectangle: Rectangle): boolean;
-  isContainedByRectangle(rectangle: Rectangle): boolean;
-  isIntersectsWithLine(line: Line): boolean;
-  getRectangle(): Rectangle;
+  isContainsPoint(location: Vector): Promise<boolean>;
+  isIntersectsWithRectangle(rectangle: Rectangle): Promise<boolean>;
+  isContainedByRectangle(rectangle: Rectangle): Promise<boolean>;
+  isIntersectsWithLine(line: Line): Promise<boolean>;
+  getRectangle(): Promise<Rectangle>;
 }
 
 declare class CollisionBoxRenderer {
   constructor(project: Project);
-  render(collideBox: CollisionBox, color: Color);
+  render(collideBox: CollisionBox, color: Color): Promise<void>;
 }
 
 declare class ComplexityDetector {
   constructor(project: Project);
-  detectorCurrentStage(): CountResultObject;
+  detectorCurrentStage(): Promise<CountResultObject>;
 }
 
 declare class ConnectableAssociation extends Association {
-  associationList: ConnectableEntity[];
-  reverse();
-  get target(): ConnectableEntity;
+  associationList: Promise<ConnectableEntity>[];
+  reverse(): Promise<void>;
+  get target(): Promise<ConnectableEntity>;
   set target(value: ConnectableEntity);
-  get source(): ConnectableEntity;
+  get source(): Promise<ConnectableEntity>;
   set source(value: ConnectableEntity);
 }
 
 declare class ConnectableEntity extends Entity {
-  geometryCenter: Vector;
+  geometryCenter: Promise<Vector>;
   unknown;
 }
 
 declare class ConnectPoint extends ConnectableEntity {
   CONNECT_POINT_SHRINK_RADIUS;
   CONNECT_POINT_EXPAND_RADIUS;
-  get geometryCenter(): Vector;
-  isHiddenBySectionCollapse: boolean;
-  collisionBox: CollisionBox;
-  uuid: string;
-  get radius(): number;
-  _isSelected: boolean;
-  get isSelected(): any;
+  get geometryCenter(): Promise<Vector>;
+  isHiddenBySectionCollapse: Promise<boolean>;
+  collisionBox: Promise<CollisionBox>;
+  uuid: Promise<string>;
+  get radius(): Promise<number>;
+  _isSelected: Promise<boolean>;
+  get isSelected(): Promise<any>;
   set isSelected(value: boolean);
   constructor(project: Project, {
       uuid = crypto.randomUUID() as string,
@@ -286,128 +286,128 @@ declare class ConnectPoint extends ConnectableEntity {
 
 declare class ContentSearch {
   constructor(project: Project);
-  searchResultNodes: StageObject[];
+  searchResultNodes: Promise<StageObject>[];
   isCaseSensitive;
   searchScope;
   currentSearchResultIndex;
-  getStageObjectText(stageObject: StageObject): string;
-  getSelectedObjectsBounds(): Rectangle | null;
-  isObjectInBounds(obj: StageObject, bounds: Rectangle): boolean;
-  startSearch(searchString: string, autoFocus = true): boolean;
-  nextSearchResult();
-  previousSearchResult();
+  getStageObjectText(stageObject: StageObject): Promise<string>;
+  getSelectedObjectsBounds(): Promise<Rectangle | null>;
+  isObjectInBounds(obj: StageObject, bounds: Rectangle): Promise<boolean>;
+  startSearch(searchString: string, autoFocus = true): Promise<boolean>;
+  nextSearchResult(): Promise<void>;
+  previousSearchResult(): Promise<void>;
 }
 
 declare class Controller {
-  setCursorNameHook: (_: CursorNameEnum) => void;
-  pressingKeySet: Set<string>;
-  pressingKeysString(): string;
+  setCursorNameHook: Promise<(_: CursorNameEnum) => void>;
+  pressingKeySet: Promise<Set<string>>;
+  pressingKeysString(): Promise<string>;
   isMovingEdge;
   lastMoveLocation;
   mouseLocation;
   isCameraLocked;
-  lastSelectedEntityUUID: Set<string>;
-  lastSelectedEdgeUUID: Set<string>;
+  lastSelectedEntityUUID: Promise<Set<string>>;
+  lastSelectedEdgeUUID: Promise<Set<string>>;
   touchStartLocation;
   touchStartDistance;
   touchDelta;
   lastClickTime;
   lastClickLocation;
-  isMouseDown: boolean[];
+  isMouseDown: Promise<boolean>[];
   lastManipulateTime;
-  resetCountdownTimer();
-  isManipulateOverTime();
+  resetCountdownTimer(): Promise<void>;
+  isManipulateOverTime(): Promise<void>;
   edgeHoverTolerance;
   constructor(project: Project);
-  dispose();
-  mousedown(event: MouseEvent);
-  mouseup(event: MouseEvent);
-  mousewheel(event: WheelEvent);
-  handleMousedown(button: number, _x: number, _y: number);
-  handleMouseup(button: number, x: number, y: number);
-  keydown(event: KeyboardEvent);
-  keyup(event: KeyboardEvent);
-  touchstart(e: TouchEvent);
-  touchmove(e: TouchEvent);
-  touchend(e: TouchEvent);
-  associationReshape: ControllerAssociationReshapeClass;
-  camera: ControllerCameraClass;
-  cutting: ControllerCuttingClass;
-  edgeEdit: ControllerEdgeEditClass;
-  entityClickSelectAndMove: ControllerEntityClickSelectAndMoveClass;
-  entityCreate: ControllerEntityCreateClass;
-  extensionEntityClick: ControllerExtensionEntityClickClass;
-  layerMoving: ControllerLayerMovingClass;
-  entityResize: ControllerEntityResizeClass;
-  nodeConnection: ControllerNodeConnectionClass;
-  nodeEdit: ControllerNodeEditClass;
-  penStrokeControl: ControllerPenStrokeControlClass;
-  penStrokeDrawing: ControllerPenStrokeDrawingClass;
-  rectangleSelect: ControllerRectangleSelectClass;
-  sectionEdit: ControllerSectionEditClass;
-  imageScale: ControllerImageScaleClass;
+  dispose(): Promise<void>;
+  mousedown(event: MouseEvent): Promise<void>;
+  mouseup(event: MouseEvent): Promise<void>;
+  mousewheel(event: WheelEvent): Promise<void>;
+  handleMousedown(button: number, _x: number, _y: number): Promise<void>;
+  handleMouseup(button: number, x: number, y: number): Promise<void>;
+  keydown(event: KeyboardEvent): Promise<void>;
+  keyup(event: KeyboardEvent): Promise<void>;
+  touchstart(e: TouchEvent): Promise<void>;
+  touchmove(e: TouchEvent): Promise<void>;
+  touchend(e: TouchEvent): Promise<void>;
+  associationReshape: Promise<ControllerAssociationReshapeClass>;
+  camera: Promise<ControllerCameraClass>;
+  cutting: Promise<ControllerCuttingClass>;
+  edgeEdit: Promise<ControllerEdgeEditClass>;
+  entityClickSelectAndMove: Promise<ControllerEntityClickSelectAndMoveClass>;
+  entityCreate: Promise<ControllerEntityCreateClass>;
+  extensionEntityClick: Promise<ControllerExtensionEntityClickClass>;
+  layerMoving: Promise<ControllerLayerMovingClass>;
+  entityResize: Promise<ControllerEntityResizeClass>;
+  nodeConnection: Promise<ControllerNodeConnectionClass>;
+  nodeEdit: Promise<ControllerNodeEditClass>;
+  penStrokeControl: Promise<ControllerPenStrokeControlClass>;
+  penStrokeDrawing: Promise<ControllerPenStrokeDrawingClass>;
+  rectangleSelect: Promise<ControllerRectangleSelectClass>;
+  sectionEdit: Promise<ControllerSectionEditClass>;
+  imageScale: Promise<ControllerImageScaleClass>;
 }
 
 declare class ControllerAssociationReshapeClass extends ControllerClass {
-  mousewheel: (event: WheelEvent) => void;
-  lastMoveLocation: Vector;
-  mousedown: (event: MouseEvent) => void;
-  mousemove: (event: MouseEvent) => void;
-  mouseup: (event: MouseEvent) => void;
+  mousewheel: Promise<(event: WheelEvent) => void>;
+  lastMoveLocation: Promise<Vector>;
+  mousedown: Promise<(event: MouseEvent) => void>;
+  mousemove: Promise<(event: MouseEvent) => void>;
+  mouseup: Promise<(event: MouseEvent) => void>;
 }
 
 declare class ControllerCameraClass extends ControllerClass {
   isUsingMouseGrabMove;
-  lastMousePressLocation: Vector[];
+  lastMousePressLocation: Promise<Vector>[];
   isPreGrabbingWhenSpace;
   mac;
-  keydown: (event: KeyboardEvent) => void;
-  keyup: (event: KeyboardEvent) => void;
+  keydown: Promise<(event: KeyboardEvent) => void>;
+  keyup: Promise<(event: KeyboardEvent) => void>;
   mousedown;
-  mousemove: (event: MouseEvent) => void;
-  mouseMoveOutWindowForcedShutdown(vectorObject: Vector);
+  mousemove: Promise<(event: MouseEvent) => void>;
+  mouseMoveOutWindowForcedShutdown(vectorObject: Vector): Promise<void>;
   mouseup;
   mousewheel;
-  dealStealthMode(event: WheelEvent);
-  mousewheelFunction(event: WheelEvent);
-  mouseDoubleClick: (event: MouseEvent) => void;
-  moveCameraByMouseMove(x: number, y: number, mouseIndex: number);
-  moveCameraByTouchPadTwoFingerMove(event: WheelEvent);
-  zoomCameraByMouseWheel(event: WheelEvent);
-  moveYCameraByMouseWheel(event: WheelEvent);
-  moveCameraByMouseSideWheel(event: WheelEvent);
-  zoomCameraByMouseSideWheel(event: WheelEvent);
-  moveYCameraByMouseSideWheel(event: WheelEvent);
-  moveXCameraByMouseWheel(event: WheelEvent);
-  moveXCameraByMouseSideWheel(event: WheelEvent);
-  isMouseWheel(event: WheelEvent): boolean;
-  addDistanceNumberAndDetect(distance: number): boolean;
-  detectDeltaY: LimitLengthQueue<number>;
-  importantNumbers: Set<number>;
+  dealStealthMode(event: WheelEvent): Promise<void>;
+  mousewheelFunction(event: WheelEvent): Promise<void>;
+  mouseDoubleClick: Promise<(event: MouseEvent) => void>;
+  moveCameraByMouseMove(x: number, y: number, mouseIndex: number): Promise<void>;
+  moveCameraByTouchPadTwoFingerMove(event: WheelEvent): Promise<void>;
+  zoomCameraByMouseWheel(event: WheelEvent): Promise<void>;
+  moveYCameraByMouseWheel(event: WheelEvent): Promise<void>;
+  moveCameraByMouseSideWheel(event: WheelEvent): Promise<void>;
+  zoomCameraByMouseSideWheel(event: WheelEvent): Promise<void>;
+  moveYCameraByMouseSideWheel(event: WheelEvent): Promise<void>;
+  moveXCameraByMouseWheel(event: WheelEvent): Promise<void>;
+  moveXCameraByMouseSideWheel(event: WheelEvent): Promise<void>;
+  isMouseWheel(event: WheelEvent): Promise<boolean>;
+  addDistanceNumberAndDetect(distance: number): Promise<boolean>;
+  detectDeltaY: Promise<LimitLengthQueue<number>>;
+  importantNumbers: Promise<Set<number>>;
 }
 
 declare class ControllerClass {
   constructor(project: Project);
-  lastMoveLocation: Vector;
-  lastClickTime: number;
-  lastClickLocation: Vector;
-  keydown: (event: KeyboardEvent) => void;
-  keyup: (event: KeyboardEvent) => void;
-  mousedown: (event: PointerEvent) => void;
-  mouseup: (event: PointerEvent) => void;
-  mousemove: (event: PointerEvent) => void;
-  mousewheel: (event: WheelEvent) => void;
-  mouseDoubleClick: (event: PointerEvent) => void;
-  touchstart: (event: TouchEvent) => void;
-  touchmove: (event: TouchEvent) => void;
-  touchend: (event: TouchEvent) => void;
-  dispose();
+  lastMoveLocation: Promise<Vector>;
+  lastClickTime: Promise<number>;
+  lastClickLocation: Promise<Vector>;
+  keydown: Promise<(event: KeyboardEvent) => void>;
+  keyup: Promise<(event: KeyboardEvent) => void>;
+  mousedown: Promise<(event: PointerEvent) => void>;
+  mouseup: Promise<(event: PointerEvent) => void>;
+  mousemove: Promise<(event: PointerEvent) => void>;
+  mousewheel: Promise<(event: WheelEvent) => void>;
+  mouseDoubleClick: Promise<(event: PointerEvent) => void>;
+  touchstart: Promise<(event: TouchEvent) => void>;
+  touchmove: Promise<(event: TouchEvent) => void>;
+  touchend: Promise<(event: TouchEvent) => void>;
+  dispose(): Promise<void>;
   _mouseup;
   _touchstart;
   _touchmove;
-  onePointTouchMoveLocation: Vector;
+  onePointTouchMoveLocation: Promise<Vector>;
   _touchend;
-  mouseMoveOutWindowForcedShutdown(_outsideLocation: Vector);
+  mouseMoveOutWindowForcedShutdown(_outsideLocation: Vector): Promise<void>;
 }
 
 declare class ControllerCuttingClass extends ControllerClass {
@@ -415,32 +415,32 @@ declare class ControllerCuttingClass extends ControllerClass {
   _isControlKeyDown;
   onControlKeyDown;
   onControlKeyUp;
-  registerControlKeyEvents();
-  unregisterControlKeyEvents();
+  registerControlKeyEvents(): Promise<void>;
+  unregisterControlKeyEvents(): Promise<void>;
   constructor(project: Project);
-  dispose();
-  cuttingLine: Line;
+  dispose(): Promise<void>;
+  cuttingLine: Promise<Line>;
   lastMoveLocation;
-  warningEntity: Entity[];
-  warningSections: Section[];
-  warningAssociations: Association[];
+  warningEntity: Promise<Entity>[];
+  warningSections: Promise<Section>[];
+  warningAssociations: Promise<Association>[];
   isUsing;
-  twoPointsMap: Record<string, Vector[]>;
+  twoPointsMap: Promise<Record<string, Vector[]>>;
   cuttingStartLocation;
-  mousedown: (event: MouseEvent) => void;
-  mouseDownEvent(event: MouseEvent);
-  mousemove: (event: MouseEvent) => void;
-  clearIsolationPoint();
-  mouseUpFunction(mouseUpWindowLocation: Vector);
-  mouseup: (event: MouseEvent) => void;
-  mouseMoveOutWindowForcedShutdown(outsideLocation: Vector);
-  updateWarningObjectByCuttingLine();
-  addEffectByWarningEntity();
+  mousedown: Promise<(event: MouseEvent) => void>;
+  mouseDownEvent(event: MouseEvent): Promise<void>;
+  mousemove: Promise<(event: MouseEvent) => void>;
+  clearIsolationPoint(): Promise<void>;
+  mouseUpFunction(mouseUpWindowLocation: Vector): Promise<void>;
+  mouseup: Promise<(event: MouseEvent) => void>;
+  mouseMoveOutWindowForcedShutdown(outsideLocation: Vector): Promise<void>;
+  updateWarningObjectByCuttingLine(): Promise<void>;
+  addEffectByWarningEntity(): Promise<void>;
 }
 
 declare class ControllerEdgeEditClass extends ControllerClass {
-  editEdgeText(clickedLineEdge: Edge, selectAll = true);
-  editMultiTargetEdgeText(clickedEdge: MultiTargetUndirectedEdge, selectAll = true);
+  editEdgeText(clickedLineEdge: Edge, selectAll = true): Promise<void>;
+  editMultiTargetEdgeText(clickedEdge: MultiTargetUndirectedEdge, selectAll = true): Promise<void>;
   mouseDoubleClick;
   keydown;
 }
@@ -449,25 +449,25 @@ declare class ControllerEntityClickSelectAndMoveClass extends ControllerClass {
   isMovingEntity;
   mouseDownViewLocation;
   shakeDetector;
-  shiftAxisLock: "x" | "y" | null;
+  shiftAxisLock: Promise<"x" | "y" | null>;
   shiftAccumulatedDelta;
-  mousedown: (event: MouseEvent) => void;
-  mousemove: (event: MouseEvent) => void;
-  mouseup: (event: MouseEvent) => void;
+  mousedown: Promise<(event: MouseEvent) => void>;
+  mousemove: Promise<(event: MouseEvent) => void>;
+  mouseup: Promise<(event: MouseEvent) => void>;
   mouseMoveOutWindowForcedShutdown(_outsideLocation: Vector): void;
 }
 
 declare class ControllerEntityCreateClass extends ControllerClass {
   constructor(project: Project);
   mouseDoubleClick;
-  createConnectPoint(pressLocation: Vector, addToSections: Section[]);
+  createConnectPoint(pressLocation: Vector, addToSections: Section[]): Promise<void>;
 }
 
 declare class ControllerEntityResizeClass extends ControllerClass {
-  changeSizeEntity: Entity | null;
-  mousedown: (event: MouseEvent) => void;
-  mousemove: (event: MouseEvent) => void;
-  mouseup: (event: MouseEvent) => void;
+  changeSizeEntity: Promise<Entity | null>;
+  mousedown: Promise<(event: MouseEvent) => void>;
+  mousemove: Promise<(event: MouseEvent) => void>;
+  mouseup: Promise<(event: MouseEvent) => void>;
 }
 
 declare class ControllerExtensionEntityClickClass extends ControllerClass {
@@ -480,9 +480,9 @@ declare class ControllerImageScaleClass extends ControllerClass {
 }
 
 declare class ControllerLayerMovingClass extends ControllerClass {
-  get isEnabled(): boolean;
-  mousemove: (event: MouseEvent) => void;
-  mouseup: (event: MouseEvent) => void;
+  get isEnabled(): Promise<boolean>;
+  mousemove: Promise<(event: MouseEvent) => void>;
+  mouseup: Promise<(event: MouseEvent) => void>;
 }
 
 declare class ControllerNodeConnectionClass extends ControllerClass {
@@ -490,45 +490,45 @@ declare class ControllerNodeConnectionClass extends ControllerClass {
   _controlKeyEventRegistered;
   onControlKeyDown;
   onControlKeyUp;
-  registerControlKeyEvents();
-  unregisterControlKeyEvents();
-  _lastRightMousePressLocation: Vector;
-  _isUsing: boolean;
-  get isUsing(): boolean;
-  constructor(project: Project);
-  dispose();
-  connectFromEntities: ConnectableEntity[];
-  connectToEntity: ConnectableEntity | null;
-  mouseLocations: Vector[];
-  getMouseLocationsPoints(): Vector[];
-  createConnectPointWhenConnect();
-  mousedown: (event: MouseEvent) => void;
-  _startImageLocation: Map<string, Vector>;
-  _endImageLocation: Vector | null;
-  _hoverImageLocation: Vector | null;
-  _previewSourceDirection: Direction | null;
-  _previewTargetDirection: Direction | null;
-  getHoverImageNode(): ImageNode | null;
-  getHoverImageLocation(): Vector | null;
-  onMouseDown(event: MouseEvent);
+  registerControlKeyEvents(): Promise<void>;
+  unregisterControlKeyEvents(): Promise<void>;
+  _lastRightMousePressLocation: Promise<Vector>;
+  _isUsing: Promise<boolean>;
+  get isUsing(): Promise<boolean>;
+  constructor(project: Project);
+  dispose(): Promise<void>;
+  connectFromEntities: Promise<ConnectableEntity>[];
+  connectToEntity: Promise<ConnectableEntity | null>;
+  mouseLocations: Promise<Vector>[];
+  getMouseLocationsPoints(): Promise<Vector>[];
+  createConnectPointWhenConnect(): Promise<void>;
+  mousedown: Promise<(event: MouseEvent) => void>;
+  _startImageLocation: Promise<Map<string, Vector>>;
+  _endImageLocation: Promise<Vector | null>;
+  _hoverImageLocation: Promise<Vector | null>;
+  _previewSourceDirection: Promise<Direction | null>;
+  _previewTargetDirection: Promise<Direction | null>;
+  getHoverImageNode(): Promise<ImageNode | null>;
+  getHoverImageLocation(): Promise<Vector | null>;
+  onMouseDown(event: MouseEvent): Promise<void>;
   isMouseHoverOnTarget;
-  mousemove: (event: MouseEvent) => void;
-  mouseMove(event: MouseEvent);
-  mouseup: (event: MouseEvent) => void;
-  mouseUp(event: MouseEvent);
-  getConnectDirectionByMouseTrack(): [Direction | null, Direction | null];
+  mousemove: Promise<(event: MouseEvent) => void>;
+  mouseMove(event: MouseEvent): Promise<void>;
+  mouseup: Promise<(event: MouseEvent) => void>;
+  mouseUp(event: MouseEvent): Promise<void>;
+  getConnectDirectionByMouseTrack(): Promise<[Direction | null, Direction | null]>;
   _hasSourceSparkTriggered;
   _hasTargetSparkTriggered;
-  getOppositeDirection(direction: Direction): Direction;
-  clickMultiConnect(releaseWorldLocation: Vector);
-  clear();
-  updatePreviewDirections();
-  directionToRate(direction: Direction | null): Vector;
-  getPreviewSourceRectangleRate(): Vector;
-  getPreviewTargetRectangleRate(): Vector;
-  dragMultiConnect(connectToEntity: ConnectableEntity, sourceDirection: Direction | null = null, targetDirection: Direction | null = null);
-  isConnecting();
-  addConnectEffect(from: ConnectableEntity, to: ConnectableEntity, sourceRectRate?: Vector, targetRectRate?: Vector);
+  getOppositeDirection(direction: Direction): Promise<Direction>;
+  clickMultiConnect(releaseWorldLocation: Vector): Promise<void>;
+  clear(): Promise<void>;
+  updatePreviewDirections(): Promise<void>;
+  directionToRate(direction: Direction | null): Promise<Vector>;
+  getPreviewSourceRectangleRate(): Promise<Vector>;
+  getPreviewTargetRectangleRate(): Promise<Vector>;
+  dragMultiConnect(connectToEntity: ConnectableEntity, sourceDirection: Direction | null = null, targetDirection: Direction | null = null): Promise<void>;
+  isConnecting(): Promise<void>;
+  addConnectEffect(from: ConnectableEntity, to: ConnectableEntity, sourceRectRate?: Vector, targetRectRate?: Vector): Promise<void>;
 }
 
 declare class ControllerNodeEditClass extends ControllerClass {
@@ -536,45 +536,45 @@ declare class ControllerNodeEditClass extends ControllerClass {
   mouseDoubleClick;
   mouseup;
   mousemove;
-  editUrlNodeTitle(clickedUrlNode: UrlNode);
-  editLatexNode(node: LatexNode);
+  editUrlNodeTitle(clickedUrlNode: UrlNode): Promise<void>;
+  editLatexNode(node: LatexNode): Promise<void>;
 }
 
 declare class ControllerPenStrokeControlClass extends ControllerClass {
   isAdjusting;
-  startAdjustWidthLocation: Vector;
-  lastAdjustWidthLocation: Vector;
-  mousedown: (event: MouseEvent) => void;
-  mousemove: (event: MouseEvent) => void;
-  mouseup: (event: MouseEvent) => void;
+  startAdjustWidthLocation: Promise<Vector>;
+  lastAdjustWidthLocation: Promise<Vector>;
+  mousedown: Promise<(event: MouseEvent) => void>;
+  mousemove: Promise<(event: MouseEvent) => void>;
+  mouseup: Promise<(event: MouseEvent) => void>;
   onMouseMoveWhenAdjusting;
 }
 
 declare class ControllerPenStrokeDrawingClass extends ControllerClass {
-  _isUsing: boolean;
-  currentSegments: PenStrokeSegment[];
+  _isUsing: Promise<boolean>;
+  currentSegments: Promise<PenStrokeSegment>[];
   isDrawingLine;
-  currentStrokeWidth: number;
+  currentStrokeWidth: Promise<number>;
   constructor(project: Project);
   mousedown;
   mousemove;
   mouseup;
-  releaseMouseAndClear();
-  mousewheel: (event: WheelEvent) => void;
-  getCurrentStrokeColor();
-  changeCurrentStrokeColorAlpha(dAlpha: number);
+  releaseMouseAndClear(): Promise<void>;
+  mousewheel: Promise<(event: WheelEvent) => void>;
+  getCurrentStrokeColor(): Promise<void>;
+  changeCurrentStrokeColorAlpha(dAlpha: number): Promise<void>;
 }
 
 declare class ControllerRectangleSelectClass extends ControllerClass {
-  _isUsing: boolean;
-  selectingRectangle: Rectangle | null;
-  get isUsing(): any;
-  shutDown();
-  mouseMoveOutWindowForcedShutdown(mouseLocation: Vector);
-  mousedown: (event: MouseEvent) => void;
-  mousemove: (event: MouseEvent) => void;
+  _isUsing: Promise<boolean>;
+  selectingRectangle: Promise<Rectangle | null>;
+  get isUsing(): Promise<any>;
+  shutDown(): Promise<void>;
+  mouseMoveOutWindowForcedShutdown(mouseLocation: Vector): Promise<void>;
+  mousedown: Promise<(event: MouseEvent) => void>;
+  mousemove: Promise<(event: MouseEvent) => void>;
   isSelectDirectionRight;
-  getSelectMode(): "contain" | "intersect";
+  getSelectMode(): Promise<"contain" | "intersect">;
   mouseup;
 }
 
@@ -583,67 +583,67 @@ declare class ControllerSectionEditClass extends ControllerClass {
   mouseDoubleClick;
   mousemove;
   keydown;
-  editSectionTitle(section: Section);
+  editSectionTitle(section: Section): Promise<void>;
 }
 
 declare class ControllerUtils {
-  autoComplete: AutoCompleteManager;
+  autoComplete: Promise<AutoCompleteManager>;
   constructor(project: Project);
-  editTextNode(clickedNode: TextNode, selectAll = true);
-  editNodeDetailsByKeyboard();
-  editNodeDetails(clickedNode: Entity);
-  addTextNodeByLocation(location: Vector, selectCurrent: boolean = false, autoEdit: boolean = false);
-  createConnectPoint(location: Vector);
-  addTextNodeFromCurrentSelectedNode(direction: Direction, selectCurrent = false);
-  textNodeInEditModeByUUID(uuid: string);
-  getClickedStageObject(clickedLocation: Vector);
-  isClickedResizeRect(clickedLocation: Vector): boolean;
-  selectedEntityNormalizing();
+  editTextNode(clickedNode: TextNode, selectAll = true): Promise<void>;
+  editNodeDetailsByKeyboard(): Promise<void>;
+  editNodeDetails(clickedNode: Entity): Promise<void>;
+  addTextNodeByLocation(location: Vector, selectCurrent: boolean = false, autoEdit: boolean = false): Promise<void>;
+  createConnectPoint(location: Vector): Promise<void>;
+  addTextNodeFromCurrentSelectedNode(direction: Direction, selectCurrent = false): Promise<void>;
+  textNodeInEditModeByUUID(uuid: string): Promise<void>;
+  getClickedStageObject(clickedLocation: Vector): Promise<void>;
+  isClickedResizeRect(clickedLocation: Vector): Promise<boolean>;
+  selectedEntityNormalizing(): Promise<void>;
 }
 
 declare class CopyEngine {
-  copyEngineImage: CopyEngineImage;
-  copyEngineText: CopyEngineText;
+  copyEngineImage: Promise<CopyEngineImage>;
+  copyEngineText: Promise<CopyEngineText>;
   constructor(project: Project);
-  copy();
-  paste();
-  virtualClipboardPaste();
-  cut();
-  readSystemClipboardAndPaste();
+  copy(): Promise<void>;
+  paste(): Promise<void>;
+  virtualClipboardPaste(): Promise<void>;
+  cut(): Promise<void>;
+  readSystemClipboardAndPaste(): Promise<void>;
 }
 
 declare class CopyEngineImage {
   constructor(project: Project);
-  processClipboardImage();
-  processImageStandard();
-  copyEnginePasteImage(item: Blob);
+  processClipboardImage(): Promise<void>;
+  processImageStandard(): Promise<void>;
+  copyEnginePasteImage(item: Blob): Promise<void>;
   debugImageData(imageData: any): void;
-  fixImageData(data: Uint8ClampedArray): Uint8ClampedArray;
-  processImageWindowsCompat();
-  ensureImageDataFormat(data: any, width: number, height: number): Uint8ClampedArray;
+  fixImageData(data: Uint8ClampedArray): Promise<Uint8ClampedArray>;
+  processImageWindowsCompat(): Promise<void>;
+  ensureImageDataFormat(data: any, width: number, height: number): Promise<Uint8ClampedArray>;
   validateCanvasContent(ctx: CanvasRenderingContext2D, width: number, height: number): void;
   createBlobFromCanvas(canvas: HTMLCanvasElement): Promise<Blob>;
 }
 
 declare class CopyEngineText {
   constructor(project: Project);
-  copyEnginePastePlainText(item: string);
+  copyEnginePastePlainText(item: string): Promise<void>;
 }
 
 declare class CubicCatmullRomSplineEdge extends Edge {
-  uuid: string;
-  text: string;
-  _source: ConnectableEntity;
-  _target: ConnectableEntity;
-  color: Color;
+  uuid: Promise<string>;
+  text: Promise<string>;
+  _source: Promise<ConnectableEntity>;
+  _target: Promise<ConnectableEntity>;
+  color: Promise<Color>;
   alpha;
   tension;
-  controlPoints: Vector[];
-  getControlPoints(): Vector[];
-  addControlPoint();
-  _collisionBox: CollisionBox;
-  get collisionBox(): CollisionBox;
-  fromTwoEntity(project: Project, source: ConnectableEntity, target: ConnectableEntity): CubicCatmullRomSplineEdge;
+  controlPoints: Promise<Vector>[];
+  getControlPoints(): Promise<Vector>[];
+  addControlPoint(): Promise<void>;
+  _collisionBox: Promise<CollisionBox>;
+  get collisionBox(): Promise<CollisionBox>;
+  fromTwoEntity(project: Project, source: ConnectableEntity, target: ConnectableEntity): Promise<CubicCatmullRomSplineEdge>;
   constructor(project: Project, {
       uuid,
       source,
@@ -656,10 +656,10 @@ declare class CubicCatmullRomSplineEdge extends Edge {
       sourceRectRate,
       targetRectRate,
     }: Serialized.CubicCatmullRomSplineEdge, unknown = false);
-  getShape(): CubicCatmullRomSpline;
-  get textRectangle(): Rectangle;
-  autoUpdateControlPoints();
-  getArrowHead(): { location: Vector; direction: Vector };
+  getShape(): Promise<CubicCatmullRomSpline>;
+  get textRectangle(): Promise<Rectangle>;
+  autoUpdateControlPoints(): Promise<void>;
+  getArrowHead(): Promise<{ location: Vector; direction: Vector }>;
   adjustSizeByText(): void;
 }
 
@@ -703,7 +703,7 @@ declare class CurveRenderer {
   renderSolidLineMultiple(locations: Vector[], color: Color, width: number): void;
   renderPenStroke(stroke: PenStrokeSegment[], color: Color): void;
   renderSolidLineMultipleSmoothly(locations: Vector[], color: Color, width: number): void;
-  smoothPoints(points: Vector[], tension = 0.5);
+  smoothPoints(points: Vector[], tension = 0.5): Promise<void>;
   renderSolidLineMultipleWithWidth(locations: Vector[], color: Color, widthList: number[]): void;
   renderSolidLineMultipleWithShadow(locations: Vector[], color: Color, width: number, shadowColor: Color, shadowBlur: number): void;
   renderDashedLine(start: Vector, end: Vector, color: Color, width: number, dashLength: number): void;
@@ -718,23 +718,23 @@ declare class CurveRenderer {
 
 declare class DeleteManager {
   deleteHandlers;
-  registerHandler<T extends StageObject>(constructor: Constructor<T>, handler: DeleteHandler<T>);
-  constructor(project: Project);
-  deleteEntities(deleteNodes: Entity[]);
-  findDeleteHandler(object: StageObject);
-  deleteSvgNode(entity: SvgNode);
-  deleteLatexNode(entity: LatexNode);
-  deleteReferenceBlockNode(entity: ReferenceBlockNode);
-  deleteExtensionEntity(entity: ExtensionEntity);
-  deletePenStroke(penStroke: PenStroke);
-  deleteSection(entity: Section);
-  deleteImageNode(entity: ImageNode);
-  deleteUrlNode(entity: UrlNode);
-  deleteConnectPoint(entity: ConnectPoint);
-  deleteTextNode(entity: TextNode);
-  deleteEntityAfterClearAssociation(entity: ConnectableEntity);
-  deleteEdge(deleteEdge: Edge): boolean;
-  deleteMultiTargetUndirectedEdge(edge: MultiTargetUndirectedEdge);
+  registerHandler<T extends StageObject>(constructor: Constructor<T>, handler: DeleteHandler<T>): Promise<void>;
+  constructor(project: Project);
+  deleteEntities(deleteNodes: Entity[]): Promise<void>;
+  findDeleteHandler(object: StageObject): Promise<void>;
+  deleteSvgNode(entity: SvgNode): Promise<void>;
+  deleteLatexNode(entity: LatexNode): Promise<void>;
+  deleteReferenceBlockNode(entity: ReferenceBlockNode): Promise<void>;
+  deleteExtensionEntity(entity: ExtensionEntity): Promise<void>;
+  deletePenStroke(penStroke: PenStroke): Promise<void>;
+  deleteSection(entity: Section): Promise<void>;
+  deleteImageNode(entity: ImageNode): Promise<void>;
+  deleteUrlNode(entity: UrlNode): Promise<void>;
+  deleteConnectPoint(entity: ConnectPoint): Promise<void>;
+  deleteTextNode(entity: TextNode): Promise<void>;
+  deleteEntityAfterClearAssociation(entity: ConnectableEntity): Promise<void>;
+  deleteEdge(deleteEdge: Edge): Promise<boolean>;
+  deleteMultiTargetUndirectedEdge(edge: MultiTargetUndirectedEdge): Promise<void>;
 }
 
 declare function Dialog({ ...props }: React.ComponentProps<typeof DialogPrimitive.Root>);
@@ -758,168 +758,168 @@ declare enum Direction {
 
 declare class DrawingControllerRenderer {
   constructor(project: Project);
-  renderTempDrawing();
-  renderTrace(currentStrokeColor: Color);
-  renderMouse(currentStrokeColor: Color);
-  renderAdjusting(currentStrokeColor: Color);
-  renderAxisMouse();
+  renderTempDrawing(): Promise<void>;
+  renderTrace(currentStrokeColor: Color): Promise<void>;
+  renderMouse(currentStrokeColor: Color): Promise<void>;
+  renderAdjusting(currentStrokeColor: Color): Promise<void>;
+  renderAxisMouse(): Promise<void>;
   diffAngle;
-  rotateUpAngle();
-  rotateDownAngle();
-  renderAngleMouse(mouseLocation: Vector);
-  renderLine(lineStart: Vector, lineEnd: Vector);
+  rotateUpAngle(): Promise<void>;
+  rotateDownAngle(): Promise<void>;
+  renderAngleMouse(mouseLocation: Vector): Promise<void>;
+  renderLine(lineStart: Vector, lineEnd: Vector): Promise<void>;
 }
 
 declare class Edge extends ConnectableAssociation {
-  uuid: string;
-  text: string;
-  collisionBox: CollisionBox;
-  get isHiddenBySectionCollapse(): boolean;
-  _isSelected: boolean;
-  get isSelected(): boolean;
+  uuid: Promise<string>;
+  text: Promise<string>;
+  collisionBox: Promise<CollisionBox>;
+  get isHiddenBySectionCollapse(): Promise<boolean>;
+  _isSelected: Promise<boolean>;
+  get isSelected(): Promise<boolean>;
   set isSelected(value: boolean);
-  get textRectangle(): Rectangle;
-  get bodyLine(): Line;
-  get sourceLocation(): Vector;
-  get targetLocation(): Vector;
-  targetRectangleRate: Vector;
-  sourceRectangleRate: Vector;
-  getCenterLine(source: ConnectableEntity, target: ConnectableEntity): Line;
-  getNormalVectorByRate(rate: Vector): Vector | null;
-  getExactEdgePositionByRate(rect: Rectangle, rate: Vector): Vector | null;
+  get textRectangle(): Promise<Rectangle>;
+  get bodyLine(): Promise<Line>;
+  get sourceLocation(): Promise<Vector>;
+  get targetLocation(): Promise<Vector>;
+  targetRectangleRate: Promise<Vector>;
+  sourceRectangleRate: Promise<Vector>;
+  getCenterLine(source: ConnectableEntity, target: ConnectableEntity): Promise<Line>;
+  getNormalVectorByRate(rate: Vector): Promise<Vector | null>;
+  getExactEdgePositionByRate(rect: Rectangle, rate: Vector): Promise<Vector | null>;
   adjustSizeByText(): void;
-  rename(text: string);
-  isIntersectsWithRectangle(rectangle: Rectangle): boolean;
-  isIntersectsWithLocation(location: Vector): boolean;
-  isIntersectsWithLine(line: Line): boolean;
-  isLeftToRight(): boolean;
-  isRightToLeft(): boolean;
-  isTopToBottom(): boolean;
-  isBottomToTop(): boolean;
-  isUnknownDirection(): boolean;
+  rename(text: string): Promise<void>;
+  isIntersectsWithRectangle(rectangle: Rectangle): Promise<boolean>;
+  isIntersectsWithLocation(location: Vector): Promise<boolean>;
+  isIntersectsWithLine(line: Line): Promise<boolean>;
+  isLeftToRight(): Promise<boolean>;
+  isRightToLeft(): Promise<boolean>;
+  isTopToBottom(): Promise<boolean>;
+  isBottomToTop(): Promise<boolean>;
+  isUnknownDirection(): Promise<boolean>;
 }
 
 declare class EdgeRenderer {
-  currentRenderer: EdgeRendererClass;
-  constructor(project: Project);
-  checkRendererBySettings(lineStyle: Settings["lineStyle"]);
-  updateRenderer(style: Settings["lineStyle"]);
-  renderLineEdge(edge: LineEdge);
-  renderCrEdge(edge: CubicCatmullRomSplineEdge);
-  getMinNonCollapseParentSection(innerEntity: ConnectableEntity): Section;
-  getEdgeView(edge: LineEdge): LineEdge;
-  getEdgeSvg(edge: LineEdge): React.ReactNode;
-  renderVirtualEdge(startNode: ConnectableEntity, mouseLocation: Vector, sourceRectangleRate?: Vector);
-  renderVirtualConfirmedEdge(startNode: ConnectableEntity, endNode: ConnectableEntity, sourceRectangleRate?: Vector, targetRectangleRate?: Vector);
-  getCuttingEffects(edge: Edge);
-  getConnectedEffects(startNode: ConnectableEntity, toNode: ConnectableEntity, sourceRectangleRate?: Vector, targetRectangleRate?: Vector);
-  renderArrowHead(endPoint: Vector, direction: Vector, size: number, color: Color);
-  generateArrowHeadSvg(endPoint: Vector, direction: Vector, size: number, edgeColor: Color): React.ReactNode;
+  currentRenderer: Promise<EdgeRendererClass>;
+  constructor(project: Project);
+  checkRendererBySettings(lineStyle: Settings["lineStyle"]): Promise<void>;
+  updateRenderer(style: Settings["lineStyle"]): Promise<void>;
+  renderLineEdge(edge: LineEdge): Promise<void>;
+  renderCrEdge(edge: CubicCatmullRomSplineEdge): Promise<void>;
+  getMinNonCollapseParentSection(innerEntity: ConnectableEntity): Promise<Section>;
+  getEdgeView(edge: LineEdge): Promise<LineEdge>;
+  getEdgeSvg(edge: LineEdge): Promise<React.ReactNode>;
+  renderVirtualEdge(startNode: ConnectableEntity, mouseLocation: Vector, sourceRectangleRate?: Vector): Promise<void>;
+  renderVirtualConfirmedEdge(startNode: ConnectableEntity, endNode: ConnectableEntity, sourceRectangleRate?: Vector, targetRectangleRate?: Vector): Promise<void>;
+  getCuttingEffects(edge: Edge): Promise<void>;
+  getConnectedEffects(startNode: ConnectableEntity, toNode: ConnectableEntity, sourceRectangleRate?: Vector, targetRectangleRate?: Vector): Promise<void>;
+  renderArrowHead(endPoint: Vector, direction: Vector, size: number, color: Color): Promise<void>;
+  generateArrowHeadSvg(endPoint: Vector, direction: Vector, size: number, edgeColor: Color): Promise<React.ReactNode>;
 }
 
 declare class EdgeRendererClass {
   constructor();
-  isCycleState(edge: LineEdge): boolean;
-  isNormalState(edge: LineEdge): boolean;
+  isCycleState(edge: LineEdge): Promise<boolean>;
+  isNormalState(edge: LineEdge): Promise<boolean>;
   renderNormalState(edge: LineEdge): void;
   renderShiftingState(edge: LineEdge): void;
   renderCycleState(edge: LineEdge): void;
-  getNormalStageSvg(edge: LineEdge): React.ReactNode;
-  getShiftingStageSvg(edge: LineEdge): React.ReactNode;
-  getCycleStageSvg(edge: LineEdge): React.ReactNode;
+  getNormalStageSvg(edge: LineEdge): Promise<React.ReactNode>;
+  getShiftingStageSvg(edge: LineEdge): Promise<React.ReactNode>;
+  getCycleStageSvg(edge: LineEdge): Promise<React.ReactNode>;
   renderVirtualEdge(startNode: ConnectableEntity, mouseLocation: Vector, sourceRectangleRate?: Vector): void;
   renderVirtualConfirmedEdge(startNode: ConnectableEntity, endNode: ConnectableEntity, sourceRectangleRate?: Vector, targetRectangleRate?: Vector): void;
-  getCuttingEffects(edge: Edge): Effect[];
-  getConnectedEffects(startNode: ConnectableEntity, toNode: ConnectableEntity, sourceRectangleRate?: Vector, targetRectangleRate?: Vector): Effect[];
+  getCuttingEffects(edge: Edge): Promise<Effect>[];
+  getConnectedEffects(startNode: ConnectableEntity, toNode: ConnectableEntity, sourceRectangleRate?: Vector, targetRectangleRate?: Vector): Promise<Effect>[];
 }
 
 declare class Effect {
   constructor(timeProgress: ProgressNumber, delay: number = 0);
-  subEffects: Effect[];
+  subEffects: Promise<Effect>[];
   tick(project: Project): void;
   render(project: Project): void;
 }
 
 declare class Effects {
   constructor(project: Project);
-  effects: Effect[];
-  addEffect(effect: Effect);
-  get effectsCount(): any;
-  addEffects(effects: Effect[]);
-  tick();
+  effects: Promise<Effect>[];
+  addEffect(effect: Effect): Promise<void>;
+  get effectsCount(): Promise<any>;
+  addEffects(effects: Effect[]): Promise<void>;
+  tick(): Promise<void>;
 }
 
 declare class Entity extends StageObject {
   move(delta: Vector): void;
   isAlignExcluded;
   moveTo(location: Vector): void;
-  details: Value;
-  isMouseHover: boolean;
-  detailsButtonRectangle(): Rectangle;
-  isMouseInDetailsButton(mouseWorldLocation: Vector): boolean;
-  referenceButtonCircle(): Circle;
-  isMouseInReferenceButton(mouseWorldLocation: Vector): boolean;
-  updateFatherSectionByMove();
-  updateOtherEntityLocationByMove();
-  collideWithOtherEntity(other: Entity);
-  isHiddenBySectionCollapse: boolean;
+  details: Promise<Value>;
+  isMouseHover: Promise<boolean>;
+  detailsButtonRectangle(): Promise<Rectangle>;
+  isMouseInDetailsButton(mouseWorldLocation: Vector): Promise<boolean>;
+  referenceButtonCircle(): Promise<Circle>;
+  isMouseInReferenceButton(mouseWorldLocation: Vector): Promise<boolean>;
+  updateFatherSectionByMove(): Promise<void>;
+  updateOtherEntityLocationByMove(): Promise<void>;
+  collideWithOtherEntity(other: Entity): Promise<void>;
+  isHiddenBySectionCollapse: Promise<boolean>;
   detailsManager;
 }
 
 declare class EntityDetailsButtonRenderer {
   constructor(project: Project);
-  render(entity: Entity);
+  render(entity: Entity): Promise<void>;
 }
 
 declare class EntityMoveManager {
   constructor(project: Project);
-  moveAccelerateCommander: Vector;
-  moveSpeed: Vector;
+  moveAccelerateCommander: Promise<Vector>;
+  moveSpeed: Promise<Vector>;
   frictionExponent;
-  tick();
-  continuousMoveKeyPress(direction: Vector);
-  continuousMoveKeyRelease(direction: Vector);
-  stopImmediately();
-  canMoveEntity(entity: Entity): boolean;
-  moveEntityUtils(entity: Entity, delta: Vector, isAutoAdjustSection: boolean = true);
-  jumpMoveEntityUtils(entity: Entity, delta: Vector);
-  moveEntityToUtils(entity: Entity, location: Vector);
-  moveSelectedEntities(delta: Vector, isAutoAdjustSection: boolean = true);
-  jumpMoveSelectedConnectableEntities(delta: Vector);
-  moveEntitiesWithChildren(delta: Vector, skipDashed = true);
-  moveWithChildren(node: ConnectableEntity, delta: Vector, skipDashed = false);
+  tick(): Promise<void>;
+  continuousMoveKeyPress(direction: Vector): Promise<void>;
+  continuousMoveKeyRelease(direction: Vector): Promise<void>;
+  stopImmediately(): Promise<void>;
+  canMoveEntity(entity: Entity): Promise<boolean>;
+  moveEntityUtils(entity: Entity, delta: Vector, isAutoAdjustSection: boolean = true): Promise<void>;
+  jumpMoveEntityUtils(entity: Entity, delta: Vector): Promise<void>;
+  moveEntityToUtils(entity: Entity, location: Vector): Promise<void>;
+  moveSelectedEntities(delta: Vector, isAutoAdjustSection: boolean = true): Promise<void>;
+  jumpMoveSelectedConnectableEntities(delta: Vector): Promise<void>;
+  moveEntitiesWithChildren(delta: Vector, skipDashed = true): Promise<void>;
+  moveWithChildren(node: ConnectableEntity, delta: Vector, skipDashed = false): Promise<void>;
 }
 
 declare class EntityRenderer {
-  sectionSortedZIndex: Section[];
-  extensionEntityRenderer: ExtensionEntityRenderer;
+  sectionSortedZIndex: Promise<Section>[];
+  extensionEntityRenderer: Promise<ExtensionEntityRenderer>;
   constructor(project: Project);
-  sortSectionsByZIndex();
+  sortSectionsByZIndex(): Promise<void>;
   tickNumber;
-  renderAllSectionsBackground(viewRectangle: Rectangle);
-  renderAllSectionsBigTitle(viewRectangle: Rectangle);
-  shouldSkipEntity(entity: Entity, viewRectangle: Rectangle): boolean;
-  isBackgroundImageNode(entity: Entity): boolean;
-  renderAllEntities(viewRectangle: Rectangle);
-  renderEntity(entity: Entity);
-  renderEntityDebug(entity: Entity);
-  renderConnectPoint(connectPoint: ConnectPoint);
-  renderImageNode(imageNode: ImageNode);
-  renderPenStroke(penStroke: PenStroke);
-  renderEntityDetails(entity: Entity);
-  _renderEntityDetails(entity: Entity, limitLiens: number);
-  renderEntityTagShap(entity: Entity);
+  renderAllSectionsBackground(viewRectangle: Rectangle): Promise<void>;
+  renderAllSectionsBigTitle(viewRectangle: Rectangle): Promise<void>;
+  shouldSkipEntity(entity: Entity, viewRectangle: Rectangle): Promise<boolean>;
+  isBackgroundImageNode(entity: Entity): Promise<boolean>;
+  renderAllEntities(viewRectangle: Rectangle): Promise<void>;
+  renderEntity(entity: Entity): Promise<void>;
+  renderEntityDebug(entity: Entity): Promise<void>;
+  renderConnectPoint(connectPoint: ConnectPoint): Promise<void>;
+  renderImageNode(imageNode: ImageNode): Promise<void>;
+  renderPenStroke(penStroke: PenStroke): Promise<void>;
+  renderEntityDetails(entity: Entity): Promise<void>;
+  _renderEntityDetails(entity: Entity, limitLiens: number): Promise<void>;
+  renderEntityTagShap(entity: Entity): Promise<void>;
 }
 
 declare class ExtensionEntity extends ConnectableEntity {
-  get geometryCenter(): Vector;
-  uuid: string;
+  get geometryCenter(): Promise<Vector>;
+  uuid: Promise<string>;
   extensionId;
   typeName;
   customData: any;
-  collisionBox: CollisionBox;
+  collisionBox: Promise<CollisionBox>;
   isHiddenBySectionCollapse;
-  _bitmapCache: ImageBitmap | null;
+  _bitmapCache: Promise<ImageBitmap | null>;
   _isDirty;
   _isRendering;
   _renderFailed;
@@ -936,28 +936,28 @@ declare class ExtensionEntity extends ConnectableEntity {
       customData?: any;
       collisionBox?: CollisionBox;
     } = {});
-  get rectangle(): Rectangle;
-  get location(): Vector;
+  get rectangle(): Promise<Rectangle>;
+  get location(): Promise<Vector>;
   set location(v: Vector);
   move(delta: Vector): void;
   moveTo(location: Vector): void;
-  markDirty();
-  setCustomData(data: any);
+  markDirty(): Promise<void>;
+  setCustomData(data: any): Promise<void>;
 }
 
 declare interface ExtensionEntityConfig {
   initialData: any;
-  collisionBox: CollisionBox;
+  collisionBox: Promise<CollisionBox>;
 }
 
 declare class ExtensionEntityRenderer {
   constructor(project: Project);
-  render(entity: ExtensionEntity);
-  drawPendingBox(ctx: CanvasRenderingContext2D, x: number, y: number, w: number, h: number);
-  drawErrorBox(ctx: CanvasRenderingContext2D, x: number, y: number, w: number, h: number, text: string, extensionId: string, color: string);
-  drawCollisionBox(ctx: CanvasRenderingContext2D, entity: ExtensionEntity, scale: number);
-  renderSelectionOutline(ctx: CanvasRenderingContext2D, entity: ExtensionEntity, scale: number);
-  triggerWorkerRender(entity: ExtensionEntity);
+  render(entity: ExtensionEntity): Promise<void>;
+  drawPendingBox(ctx: CanvasRenderingContext2D, x: number, y: number, w: number, h: number): Promise<void>;
+  drawErrorBox(ctx: CanvasRenderingContext2D, x: number, y: number, w: number, h: number, text: string, extensionId: string, color: string): Promise<void>;
+  drawCollisionBox(ctx: CanvasRenderingContext2D, entity: ExtensionEntity, scale: number): Promise<void>;
+  renderSelectionOutline(ctx: CanvasRenderingContext2D, entity: ExtensionEntity, scale: number): Promise<void>;
+  triggerWorkerRender(entity: ExtensionEntity): Promise<void>;
 }
 
 declare interface FileSystemProvider {
@@ -974,8 +974,8 @@ declare class GenerateFromFolder {
   constructor(project: Project);
   generateFromFolder(folderPath: string): Promise<void>;
   generateTreeFromFolder(folderPath: string): Promise<void>;
-  getColorByPath(path: string): Color;
-  fileExtColorMap: Record<string, string>;
+  getColorByPath(path: string): Promise<Color>;
+  fileExtColorMap: Promise<Record<string, string>>;
 }
 
 declare class GraphImporter extends BaseImporter {
@@ -985,57 +985,57 @@ declare class GraphImporter extends BaseImporter {
 
 declare class GraphMethods {
   constructor(project: Project);
-  isTree(node: ConnectableEntity, skipDashed = false): boolean;
-  getNodeDisplayName(node: ConnectableEntity): string;
-  validateTreeStructure(rootNode: ConnectableEntity, skipDashed = false): TreeValidationResult;
-  nodeChildrenArray(node: ConnectableEntity, skipDashed = false): ConnectableEntity[];
-  nodeParentArray(node: ConnectableEntity, skipDashed = false): ConnectableEntity[];
-  edgeChildrenArray(node: ConnectableEntity): Edge[];
-  edgeParentArray(node: ConnectableEntity): Edge[];
-  getReversedEdgeDict(skipDashed = false): Record<string, string>;
-  isCurrentNodeInTreeStructAndNotRoot(node: ConnectableEntity): boolean;
-  getRoots(node: ConnectableEntity, skipDashed = false): ConnectableEntity[];
-  isConnected(node: ConnectableEntity, target: ConnectableEntity): boolean;
-  getSuccessorSet(node: ConnectableEntity, isHaveSelf: boolean = true, skipDashed = false): ConnectableEntity[];
-  getOneStepSuccessorSet(node: ConnectableEntity): ConnectableEntity[];
-  getEdgesBetween(node1: ConnectableEntity, node2: ConnectableEntity): Edge[];
-  getEdgeFromTwoEntity(fromNode: ConnectableEntity, toNode: ConnectableEntity): Edge | null;
-  getHyperEdgesByNode(node: ConnectableEntity): MultiTargetUndirectedEdge[];
-  getOutgoingEdges(node: ConnectableEntity): Edge[];
-  getIncomingEdges(node: ConnectableEntity): Edge[];
-  getNodesConnectedByHyperEdges(node: ConnectableEntity): ConnectableEntity[];
-  nodeChildrenArrayWithinSet(node: ConnectableEntity, nodeSet: Set<string>): ConnectableEntity[];
-  nodeParentArrayWithinSet(node: ConnectableEntity, nodeSet: Set<string>): ConnectableEntity[];
-  getTreeRootByNodes(nodes: ConnectableEntity[]): ConnectableEntity | null;
-  isTreeByNodes(nodes: ConnectableEntity[]): boolean;
-  isDAGByNodes(nodes: ConnectableEntity[]): boolean;
+  isTree(node: ConnectableEntity, skipDashed = false): Promise<boolean>;
+  getNodeDisplayName(node: ConnectableEntity): Promise<string>;
+  validateTreeStructure(rootNode: ConnectableEntity, skipDashed = false): Promise<TreeValidationResult>;
+  nodeChildrenArray(node: ConnectableEntity, skipDashed = false): Promise<ConnectableEntity>[];
+  nodeParentArray(node: ConnectableEntity, skipDashed = false): Promise<ConnectableEntity>[];
+  edgeChildrenArray(node: ConnectableEntity): Promise<Edge>[];
+  edgeParentArray(node: ConnectableEntity): Promise<Edge>[];
+  getReversedEdgeDict(skipDashed = false): Promise<Record<string, string>>;
+  isCurrentNodeInTreeStructAndNotRoot(node: ConnectableEntity): Promise<boolean>;
+  getRoots(node: ConnectableEntity, skipDashed = false): Promise<ConnectableEntity>[];
+  isConnected(node: ConnectableEntity, target: ConnectableEntity): Promise<boolean>;
+  getSuccessorSet(node: ConnectableEntity, isHaveSelf: boolean = true, skipDashed = false): Promise<ConnectableEntity>[];
+  getOneStepSuccessorSet(node: ConnectableEntity): Promise<ConnectableEntity>[];
+  getEdgesBetween(node1: ConnectableEntity, node2: ConnectableEntity): Promise<Edge>[];
+  getEdgeFromTwoEntity(fromNode: ConnectableEntity, toNode: ConnectableEntity): Promise<Edge | null>;
+  getHyperEdgesByNode(node: ConnectableEntity): Promise<MultiTargetUndirectedEdge>[];
+  getOutgoingEdges(node: ConnectableEntity): Promise<Edge>[];
+  getIncomingEdges(node: ConnectableEntity): Promise<Edge>[];
+  getNodesConnectedByHyperEdges(node: ConnectableEntity): Promise<ConnectableEntity>[];
+  nodeChildrenArrayWithinSet(node: ConnectableEntity, nodeSet: Set<string>): Promise<ConnectableEntity>[];
+  nodeParentArrayWithinSet(node: ConnectableEntity, nodeSet: Set<string>): Promise<ConnectableEntity>[];
+  getTreeRootByNodes(nodes: ConnectableEntity[]): Promise<ConnectableEntity | null>;
+  isTreeByNodes(nodes: ConnectableEntity[]): Promise<boolean>;
+  isDAGByNodes(nodes: ConnectableEntity[]): Promise<boolean>;
 }
 
 declare class HistoryManager extends HistoryManagerAbs {
-  memoryEfficient: HistoryManagerAbs;
-  timeEfficient: HistoryManagerAbs;
-  currentManager: HistoryManagerAbs;
+  memoryEfficient: Promise<HistoryManagerAbs>;
+  timeEfficient: Promise<HistoryManagerAbs>;
+  currentManager: Promise<HistoryManagerAbs>;
   constructor(project: Project);
   recordStep(): void;
   undo(): void;
   redo(): void;
-  get(index: number): Record<string, any>[];
+  get(index: number): Promise<Record<string, any>>[];
   clearHistory(): void;
   switchMode(useTimeEfficient: boolean): void;
 }
 
 declare class ImageNode extends ConnectableEntity implements ResizeAble {
-  isHiddenBySectionCollapse: boolean;
-  uuid: string;
-  collisionBox: CollisionBox;
-  attachmentId: string;
-  scale: number;
-  isBackground: boolean;
-  _isSelected: boolean;
-  get isSelected(): any;
+  isHiddenBySectionCollapse: Promise<boolean>;
+  uuid: Promise<string>;
+  collisionBox: Promise<CollisionBox>;
+  attachmentId: Promise<string>;
+  scale: Promise<number>;
+  isBackground: Promise<boolean>;
+  _isSelected: Promise<boolean>;
+  get isSelected(): Promise<any>;
   set isSelected(value: boolean);
-  bitmap: ImageBitmap | undefined;
-  state: "loading" | "success" | "notFound";
+  bitmap: Promise<ImageBitmap | undefined>;
+  state: Promise<"loading" | "success" | "notFound">;
   constructor(project: Project, {
       uuid = crypto.randomUUID() as string,
       collisionBox = new CollisionBox([new Rectangle(Vector.getZero(), Vector.getZero())]),
@@ -1044,28 +1044,28 @@ declare class ImageNode extends ConnectableEntity implements ResizeAble {
       scale = 1,
       isBackground = false,
     }, unknown = false);
-  scaleUpdate(scaleDiff: number);
-  get rectangle(): Rectangle;
-  get geometryCenter(): any;
+  scaleUpdate(scaleDiff: number): Promise<void>;
+  get rectangle(): Promise<Rectangle>;
+  get geometryCenter(): Promise<any>;
   move(delta: Vector): void;
   moveTo(location: Vector): void;
-  reverseColors();
-  swapRedBlueChannels();
-  resizeHandle(delta: Vector);
-  getResizeHandleRect(): Rectangle;
+  reverseColors(): Promise<void>;
+  swapRedBlueChannels(): Promise<void>;
+  resizeHandle(delta: Vector): Promise<void>;
+  getResizeHandleRect(): Promise<Rectangle>;
 }
 
 declare class ImageRenderer {
   constructor(project: Project);
-  renderImageElement(source: Exclude<CanvasImageSource, VideoFrame | SVGElement>, location: Vector, scale: number = 1 / (window.devicePixelRatio || 1));
-  renderImageBitmap(bitmap: ImageBitmap | undefined, location: Vector, scale: number = 1 / (window.devicePixelRatio || 1));
+  renderImageElement(source: Exclude<CanvasImageSource, VideoFrame | SVGElement>, location: Vector, scale: number = 1 / (window.devicePixelRatio || 1)): Promise<void>;
+  renderImageBitmap(bitmap: ImageBitmap | undefined, location: Vector, scale: number = 1 / (window.devicePixelRatio || 1)): Promise<void>;
 }
 
 declare class InputElement {
   input(location: Vector, defaultValue: string, onChange: (value: string) => void = () => {}, style: Partial<CSSStyleDeclaration> = {}): Promise<string>;
   textarea(defaultValue: string, onChange: (value: string, element: HTMLTextAreaElement) => void = () => {}, style: Partial<CSSStyleDeclaration> = {}, selectAllWhenCreated = true): Promise<string>;
-  addSuccessEffect();
-  addFailEffect(withToast = true);
+  addSuccessEffect(): Promise<void>;
+  addFailEffect(withToast = true): Promise<void>;
   constructor(project: Project);
 }
 
@@ -1073,30 +1073,30 @@ declare class KeyBindHintEngine {
   constructor(project: Project);
   ITEMS_PER_PAGE;
   currentPage;
-  currentModifierCombo: string;
-  lastModifierCombo: string;
+  currentModifierCombo: Promise<string>;
+  lastModifierCombo: Promise<string>;
   isShowingHint;
   hasOtherKeyPressed;
   hasModifierReleased;
-  cachedKeyBinds: Array<{
+  cachedKeyBinds: Promise<Array<{
     id: string;
     key: string;
     displayKey: string;
     title: string;
-  }>;
-  getCurrentModifierCombo(): string;
-  isOnlyModifiersPressed(): boolean;
-  convertModifierComboForMatching(combo: string): string;
-  isKeyBindMatchModifier(key: string, modifierCombo: string): boolean;
-  getMatchingKeyBinds(modifierCombo: string): Array<{
+  }>>;
+  getCurrentModifierCombo(): Promise<string>;
+  isOnlyModifiersPressed(): Promise<boolean>;
+  convertModifierComboForMatching(combo: string): Promise<string>;
+  isKeyBindMatchModifier(key: string, modifierCombo: string): Promise<boolean>;
+  getMatchingKeyBinds(modifierCombo: string): Promise<Array<{
     id: string;
     key: string;
     displayKey: string;
     title: string;
-  }>;
-  getKeyBindTitle(id: string): string;
-  update();
-  render();
+  }>>;
+  getKeyBindTitle(id: string): Promise<string>;
+  update(): Promise<void>;
+  render(): Promise<void>;
 }
 
 declare type KeyBindIcon = ForwardRefExoticComponent<Omit<LucideProps, "ref"> & RefAttributes<SVGSVGElement>>;
@@ -1106,67 +1106,67 @@ declare type KeyBindWhen = (project?: Project) => boolean | Promise<boolean>;
 declare class KeyboardOnlyEngine {
   constructor(project: Project);
   openning;
-  setOpenning(value: boolean);
-  isOpenning();
-  dispose();
+  setOpenning(value: boolean): Promise<void>;
+  isOpenning(): Promise<void>;
+  dispose(): Promise<void>;
   startEditNode;
   onKeyUp;
   onKeyDown;
-  addSuccessEffect();
-  addFailEffect();
+  addSuccessEffect(): Promise<void>;
+  addFailEffect(): Promise<void>;
 }
 
 declare class KeyboardOnlyGraphEngine {
   targetLocationController;
-  virtualTargetLocation(): Vector;
-  tick();
+  virtualTargetLocation(): Promise<Vector>;
+  tick(): Promise<void>;
   constructor(project: Project);
-  isEnableVirtualCreate(): boolean;
+  isEnableVirtualCreate(): Promise<boolean>;
   _isCreating;
-  _creatingFromUUID: string | null;
-  creatingFromUUID(): string | null;
-  isCreating(): boolean;
+  _creatingFromUUID: Promise<string | null>;
+  creatingFromUUID(): Promise<string | null>;
+  isCreating(): Promise<boolean>;
   createStart(): void;
   lastPressTabTime;
-  getPressTabTimeInterval(): number;
-  createFinished();
+  getPressTabTimeInterval(): Promise<number>;
+  createFinished(): Promise<void>;
   moveVirtualTarget(delta: Vector): void;
   createCancel(): void;
-  isTargetLocationHaveEntity(): boolean;
+  isTargetLocationHaveEntity(): Promise<boolean>;
 }
 
 declare class KeyboardOnlyTreeEngine {
   constructor(project: Project);
-  getNodePreDirection(node: ConnectableEntity): "right" | "left" | "down" | "up";
-  preDirectionCacheMap: Map<string, "right" | "left" | "down" | "up">;
-  getGrowthLineStart(node: ConnectableEntity, direction: "right" | "left" | "down" | "up"): Vector;
-  getGrowthLineEnd(node: ConnectableEntity, direction: "right" | "left" | "down" | "up"): Vector;
-  findConnectTargetByGrowthLine(node: ConnectableEntity, direction: "right" | "left" | "down" | "up"): ConnectableEntity | null;
+  getNodePreDirection(node: ConnectableEntity): Promise<"right" | "left" | "down" | "up">;
+  preDirectionCacheMap: Promise<Map<string, "right" | "left" | "down" | "up">>;
+  getGrowthLineStart(node: ConnectableEntity, direction: "right" | "left" | "down" | "up"): Promise<Vector>;
+  getGrowthLineEnd(node: ConnectableEntity, direction: "right" | "left" | "down" | "up"): Promise<Vector>;
+  findConnectTargetByGrowthLine(node: ConnectableEntity, direction: "right" | "left" | "down" | "up"): Promise<ConnectableEntity | null>;
   changePreDirection(nodes: ConnectableEntity[], direction: "right" | "left" | "down" | "up"): void;
   addNodeEffectByPreDirection(node: ConnectableEntity): void;
-  onDeepGenerateNode(defaultText = "新节点", selectAll = true);
-  onBroadGenerateNode();
-  adjustTreeNode(entity: ConnectableEntity, withEffect = true);
-  onDeleteCurrentNode();
-  calculateNewNodeFontScaleLevel(parentNode: ConnectableEntity, preDirection: "right" | "left" | "down" | "up"): number;
+  onDeepGenerateNode(defaultText = "新节点", selectAll = true): Promise<void>;
+  onBroadGenerateNode(): Promise<void>;
+  adjustTreeNode(entity: ConnectableEntity, withEffect = true): Promise<void>;
+  onDeleteCurrentNode(): Promise<void>;
+  calculateNewNodeFontScaleLevel(parentNode: ConnectableEntity, preDirection: "right" | "left" | "down" | "up"): Promise<number>;
 }
 
 declare class LatexNode extends ConnectableEntity {
-  uuid: string;
-  latexSource: string;
-  collisionBox: CollisionBox;
-  color: Color;
-  fontScaleLevel: number;
-  isHiddenBySectionCollapse: boolean;
-  image: HTMLImageElement;
-  svgOriginalSize: Vector;
-  state: "loading" | "success" | "error";
-  currentRenderedColorCss: string;
-  _isSelected: boolean;
-  get isSelected(): any;
+  uuid: Promise<string>;
+  latexSource: Promise<string>;
+  collisionBox: Promise<CollisionBox>;
+  color: Promise<Color>;
+  fontScaleLevel: Promise<number>;
+  isHiddenBySectionCollapse: Promise<boolean>;
+  image: Promise<HTMLImageElement>;
+  svgOriginalSize: Promise<Vector>;
+  state: Promise<"loading" | "success" | "error">;
+  currentRenderedColorCss: Promise<string>;
+  _isSelected: Promise<boolean>;
+  get isSelected(): Promise<any>;
   set isSelected(value: boolean);
-  get rectangle(): Rectangle;
-  get geometryCenter(): Vector;
+  get rectangle(): Promise<Rectangle>;
+  get geometryCenter(): Promise<Vector>;
   constructor(project: Project, {
       uuid = crypto.randomUUID(),
       details = [],
@@ -1182,7 +1182,7 @@ declare class LatexNode extends ConnectableEntity {
       color?: Color;
       fontScaleLevel?: number;
     });
-  getScale(): number;
+  getScale(): Promise<number>;
   increaseFontSize(anchorRate?: Vector): void;
   decreaseFontSize(anchorRate?: Vector): void;
   updateCollisionBoxByScale(anchorRate?: Vector): void;
@@ -1196,37 +1196,37 @@ declare class LatexNode extends ConnectableEntity {
 
 declare class LatexNodeRenderer {
   constructor(project: Project);
-  getTargetColorCss(node: LatexNode): string;
-  render(node: LatexNode);
+  getTargetColorCss(node: LatexNode): Promise<string>;
+  render(node: LatexNode): Promise<void>;
 }
 
 declare class LayoutManager {
   constructor(project: Project);
-  alignLeft();
-  alignRight();
-  alignTop();
-  alignBottom();
-  alignCenterHorizontal();
-  alignCenterVertical();
-  alignHorizontalSpaceBetween();
-  alignVerticalSpaceBetween();
-  alignLeftToRightNoSpace();
-  alignTopToBottomNoSpace();
-  layoutBySelected(layoutFunction: (entities: Entity[]) => void, isDeep: boolean);
-  adjustSelectedTextNodeWidth(mode: "maxWidth" | "minWidth" | "average");
-  layoutToSquare(entities: Entity[]);
-  layoutToTightSquare(entities: Entity[]);
+  alignLeft(): Promise<void>;
+  alignRight(): Promise<void>;
+  alignTop(): Promise<void>;
+  alignBottom(): Promise<void>;
+  alignCenterHorizontal(): Promise<void>;
+  alignCenterVertical(): Promise<void>;
+  alignHorizontalSpaceBetween(): Promise<void>;
+  alignVerticalSpaceBetween(): Promise<void>;
+  alignLeftToRightNoSpace(): Promise<void>;
+  alignTopToBottomNoSpace(): Promise<void>;
+  layoutBySelected(layoutFunction: (entities: Entity[]) => void, isDeep: boolean): Promise<void>;
+  adjustSelectedTextNodeWidth(mode: "maxWidth" | "minWidth" | "average"): Promise<void>;
+  layoutToSquare(entities: Entity[]): Promise<void>;
+  layoutToTightSquare(entities: Entity[]): Promise<void>;
 }
 
 declare class LineEdge extends Edge {
-  uuid: string;
-  text: string;
-  color: Color;
-  lineType: string;
-  get collisionBox(): CollisionBox;
-  get shiftingIndex(): number;
+  uuid: Promise<string>;
+  text: Promise<string>;
+  color: Promise<Color>;
+  lineType: Promise<string>;
+  get collisionBox(): Promise<CollisionBox>;
+  get shiftingIndex(): Promise<number>;
   set shiftingIndex(value: number);
-  _shiftingIndex: number;
+  _shiftingIndex: Promise<number>;
   constructor(project: Project, {
       associationList = [] as ConnectableEntity[],
       text = "",
@@ -1236,12 +1236,12 @@ declare class LineEdge extends Edge {
       targetRectangleRate = Vector.same(0.5),
       lineType = "solid",
     }, unknown = false);
-  fromTwoEntity(project: Project, source: ConnectableEntity, target: ConnectableEntity): LineEdge;
-  rename(text: string);
-  get edgeWidth(): number;
-  get textFontSize(): number;
-  get textRectangle(): Rectangle;
-  get shiftingMidPoint(): Vector;
+  fromTwoEntity(project: Project, source: ConnectableEntity, target: ConnectableEntity): Promise<LineEdge>;
+  rename(text: string): Promise<void>;
+  get edgeWidth(): Promise<number>;
+  get textFontSize(): Promise<number>;
+  get textRectangle(): Promise<Rectangle>;
+  get shiftingMidPoint(): Promise<Vector>;
   adjustSizeByText(): void;
 }
 
@@ -1333,8 +1333,8 @@ declare enum LogicNodeNameEnum {
 }
 
 declare class MarkdownExporter extends BaseExporter {
-  export(textNode: TextNode): string;
-  getNodeMarkdown(node: TextNode, level: number): string;
+  export(textNode: TextNode): Promise<string>;
+  getNodeMarkdown(node: TextNode, level: number): Promise<string>;
 }
 
 declare class MarkdownImporter extends BaseImporter {
@@ -1343,57 +1343,57 @@ declare class MarkdownImporter extends BaseImporter {
 }
 
 declare interface MarkdownNode {
-  title: string;
-  content: string;
-  children: MarkdownNode[];
+  title: Promise<string>;
+  content: Promise<string>;
+  children: Promise<MarkdownNode>[];
 }
 
 declare class MermaidExporter {
   constructor(project: Project);
-  export(entities: Entity[]): string;
+  export(entities: Entity[]): Promise<string>;
 }
 
 declare class MermaidImporter extends BaseImporter {
   constructor(project: Project);
   import(text: string, diffLocation: Vector = Vector.getZero()): void;
-  normalizeLine(line: string): string;
-  decodeMermaidText(value: string): string;
-  sanitizeLabel(raw: string | undefined): string | undefined;
-  parseNodeToken(token: string): MermaidNodeToken;
+  normalizeLine(line: string): Promise<string>;
+  decodeMermaidText(value: string): Promise<string>;
+  sanitizeLabel(raw: string | undefined): Promise<string | undefined>;
+  parseNodeToken(token: string): Promise<MermaidNodeToken>;
 }
 
 declare class MouseInteraction {
   constructor(project: Project);
-  _hoverEdges: Edge[];
-  _hoverSections: Section[];
-  _hoverConnectPoints: ConnectPoint[];
-  _hoverMultiTargetEdges: MultiTargetUndirectedEdge[];
-  get hoverEdges(): Edge[];
-  get firstHoverEdge(): Edge | undefined;
-  get hoverSections(): Section[];
-  get hoverConnectPoints(): ConnectPoint[];
-  get firstHoverSection(): Section | undefined;
-  get hoverMultiTargetEdges(): MultiTargetUndirectedEdge[];
-  get firstHoverMultiTargetEdge(): MultiTargetUndirectedEdge | undefined;
+  _hoverEdges: Promise<Edge>[];
+  _hoverSections: Promise<Section>[];
+  _hoverConnectPoints: Promise<ConnectPoint>[];
+  _hoverMultiTargetEdges: Promise<MultiTargetUndirectedEdge>[];
+  get hoverEdges(): Promise<Edge>[];
+  get firstHoverEdge(): Promise<Edge | undefined>;
+  get hoverSections(): Promise<Section>[];
+  get hoverConnectPoints(): Promise<ConnectPoint>[];
+  get firstHoverSection(): Promise<Section | undefined>;
+  get hoverMultiTargetEdges(): Promise<MultiTargetUndirectedEdge>[];
+  get firstHoverMultiTargetEdge(): Promise<MultiTargetUndirectedEdge | undefined>;
   updateByMouseMove(mouseWorldLocation: Vector): void;
 }
 
 declare class MultiTargetEdgeMove {
   constructor(project: Project);
-  moveMultiTargetEdge(diffLocation: Vector);
+  moveMultiTargetEdge(diffLocation: Vector): Promise<void>;
 }
 
 declare class MultiTargetUndirectedEdge extends ConnectableAssociation {
-  uuid: string;
-  get collisionBox(): CollisionBox;
-  text: string;
-  color: Color;
-  rectRates: Vector[];
-  centerRate: Vector;
-  arrow: UndirectedEdgeArrowType;
-  renderType: MultiTargetUndirectedEdgeRenderType;
-  padding: number;
-  rename(text: string);
+  uuid: Promise<string>;
+  get collisionBox(): Promise<CollisionBox>;
+  text: Promise<string>;
+  color: Promise<Color>;
+  rectRates: Promise<Vector>[];
+  centerRate: Promise<Vector>;
+  arrow: Promise<UndirectedEdgeArrowType>;
+  renderType: Promise<MultiTargetUndirectedEdgeRenderType>;
+  padding: Promise<number>;
+  rename(text: string): Promise<void>;
   constructor(project: Project, {
       associationList = [] as ConnectableEntity[],
       text = "",
@@ -1415,17 +1415,17 @@ declare class MultiTargetUndirectedEdge extends ConnectableAssociation {
       padding?: number;
       renderType?: MultiTargetUndirectedEdgeRenderType;
     }, unknown = false);
-  get centerLocation(): Vector;
-  get textRectangle(): Rectangle;
-  createFromSomeEntity(project: Project, entities: ConnectableEntity[]);
-  _isSelected: boolean;
-  get isSelected(): boolean;
+  get centerLocation(): Promise<Vector>;
+  get textRectangle(): Promise<Rectangle>;
+  createFromSomeEntity(project: Project, entities: ConnectableEntity[]): Promise<void>;
+  _isSelected: Promise<boolean>;
+  get isSelected(): Promise<boolean>;
   set isSelected(value: boolean);
 }
 
 declare class MultiTargetUndirectedEdgeRenderer {
   constructor(project: Project);
-  render(edge: MultiTargetUndirectedEdge);
+  render(edge: MultiTargetUndirectedEdge): Promise<void>;
   renderLineShape(edge: MultiTargetUndirectedEdge, edgeColor: Color, centerLocation: Vector): void;
   renderConvexShape(edge: MultiTargetUndirectedEdge, edgeColor: Color): void;
   renderCircle(edge: MultiTargetUndirectedEdge, edgeColor: Color): void;
@@ -1438,72 +1438,72 @@ declare class NodeAdder {
     }): Promise<string>;
   addTextNodeFromCurrentSelectedNode(direction: Direction, addToSections: Section[], selectCurrent = false): Promise<string>;
   getAutoName(): Promise<string>;
-  getAutoColor(): Color;
-  addConnectPoint(clickWorldLocation: Vector, addToSections: Section[]): string;
+  getAutoColor(): Promise<Color>;
+  addConnectPoint(clickWorldLocation: Vector, addToSections: Section[]): Promise<string>;
   addNodeGraphByText(text: string, diffLocation: Vector = Vector.getZero()): void;
   addNodeTreeByText(text: string, indention: number, diffLocation: Vector = Vector.getZero()): void;
   addNodeMermaidByText(text: string, diffLocation: Vector = Vector.getZero()): void;
-  addNodeByMarkdown(markdownText: string, diffLocation: Vector = Vector.getZero(), autoLayout = true);
-  getIndentLevel(line: string, indention: number): number;
+  addNodeByMarkdown(markdownText: string, diffLocation: Vector = Vector.getZero(), autoLayout = true): Promise<void>;
+  getIndentLevel(line: string, indention: number): Promise<number>;
 }
 
 declare class NodeConnector {
   constructor(project: Project);
-  isConnectable(fromNode: ConnectableEntity, toNode: ConnectableEntity): boolean;
+  isConnectable(fromNode: ConnectableEntity, toNode: ConnectableEntity): Promise<boolean>;
   connectConnectableEntity(fromNode: ConnectableEntity, toNode: ConnectableEntity, text: string = "", targetRectRate?: [number, number], sourceRectRate?: [number, number]): void;
   connectEntityFast(fromNode: ConnectableEntity, toNode: ConnectableEntity, text: string = ""): void;
   addCrEdge(fromNode: ConnectableEntity, toNode: ConnectableEntity): void;
-  reverseEdges(edges: LineEdge[]);
-  changeEdgeTarget(edge: LineEdge, newTarget: ConnectableEntity);
-  changeEdgeSource(edge: LineEdge, newSource: ConnectableEntity);
-  changeSelectedEdgeTarget(newTarget: ConnectableEntity);
-  changeSelectedEdgeSource(newSource: ConnectableEntity);
+  reverseEdges(edges: LineEdge[]): Promise<void>;
+  changeEdgeTarget(edge: LineEdge, newTarget: ConnectableEntity): Promise<void>;
+  changeEdgeSource(edge: LineEdge, newSource: ConnectableEntity): Promise<void>;
+  changeSelectedEdgeTarget(newTarget: ConnectableEntity): Promise<void>;
+  changeSelectedEdgeSource(newSource: ConnectableEntity): Promise<void>;
 }
 
 declare class PenStroke extends Entity {
-  isAlignExcluded: boolean;
-  isHiddenBySectionCollapse: boolean;
-  collisionBox: CollisionBox;
-  uuid: string;
+  isAlignExcluded: Promise<boolean>;
+  isHiddenBySectionCollapse: Promise<boolean>;
+  collisionBox: Promise<CollisionBox>;
+  uuid: Promise<string>;
   move(delta: Vector): void;
   moveTo(location: Vector): void;
-  updateCollisionBoxBySegmentList();
-  segments: PenStrokeSegment[];
-  color: Color;
-  getPath(): Vector[];
+  updateCollisionBoxBySegmentList(): Promise<void>;
+  segments: Promise<PenStrokeSegment>[];
+  color: Promise<Color>;
+  getPath(): Promise<Vector>[];
   constructor(project: Project, { uuid = crypto.randomUUID() as string, segments = [] as PenStrokeSegment[], color = Color.White });
-  getCollisionBoxFromSegmentList(segmentList: PenStrokeSegment[]): CollisionBox;
+  getCollisionBoxFromSegmentList(segmentList: PenStrokeSegment[]): Promise<CollisionBox>;
 }
 
 declare class PenStrokeSegment {
-  location: Vector;
-  pressure: number;
+  location: Promise<Vector>;
+  pressure: Promise<number>;
   constructor(location: Vector, pressure: number);
 }
 
 declare class PlainTextExporter {
   constructor(project: Project);
-  export(nodes: Entity[]): string;
+  export(nodes: Entity[]): Promise<string>;
 }
 
 declare interface PrgMetadata {
-  version: string;
-  extension?: ExtensionMetadata;
+  version: Promise<string>;
+  extension?: Promise<ExtensionMetadata>;
 }
 
 declare class Project extends Tab {
   latestVersion;
-  _uri: URI;
-  _projectState: ProjectState;
+  _uri: Promise<URI>;
+  _projectState: Promise<ProjectState>;
   _isSaving;
-  stage: StageObject[];
-  tags: string[];
+  stage: Promise<StageObject>[];
+  tags: Promise<string>[];
   attachments;
   encoder;
   decoder;
   constructor(uri: URI);
-  newDraft(): Project;
-  compareVersion(version1: string, version2: string): number;
+  newDraft(): Promise<Project>;
+  compareVersion(version1: string, version2: string): Promise<number>;
   checkAndConfirmUpgrade(currentVersion: string, latestVersion: string): Promise<boolean>;
   parseProjectFile(): Promise<{
     serializedStageObjects: any[];
@@ -1512,108 +1512,108 @@ declare class Project extends Tab {
     metadata: PrgMetadata;
     readme?: string;
   }>;
-  init();
-  get isDraft(): any;
-  get title(): string;
-  get icon(): any;
-  get uri(): any;
+  init(): Promise<void>;
+  get isDraft(): Promise<any>;
+  get title(): Promise<string>;
+  get icon(): Promise<any>;
+  get uri(): Promise<any>;
   set uri(uri: URI);
-  stash();
-  save();
-  references: { sections: Record<string, string[]>; files: string[] };
-  metadata: PrgMetadata;
-  readme?: string;
-  getFileContent();
-  get stageHash(): any;
-  addAttachment(data: Blob);
+  stash(): Promise<void>;
+  save(): Promise<void>;
+  references: Promise<{ sections: Record<string, string[]>; files: string[] }>;
+  metadata: Promise<PrgMetadata>;
+  readme?: Promise<string>;
+  getFileContent(): Promise<void>;
+  get stageHash(): Promise<any>;
+  addAttachment(data: Blob): Promise<void>;
   set projectState(state: ProjectState);
-  get projectState(): ProjectState;
+  get projectState(): Promise<ProjectState>;
   set isSaving(isSaving: boolean);
-  get isSaving(): boolean;
+  get isSaving(): Promise<boolean>;
   containerRef;
-  loadService(service: { id?: string; new (...args: any[]): any });
+  loadService(service: { id?: string; new (...args: any[]): any }): Promise<void>;
   componentDidMount(): void;
-  currentComponent: React.ComponentType | null;
-  getComponent(): React.ComponentType;
-  render(): React.ReactNode;
-  canvas: Canvas;
-  inputElement: InputElement;
-  controllerUtils: ControllerUtils;
-  autoComputeUtils: AutoComputeUtils;
-  renderUtils: RenderUtils;
-  worldRenderUtils: WorldRenderUtils;
-  historyManager: HistoryManager;
-  stageManager: StageManager;
-  camera: Camera;
-  effects: Effects;
-  autoCompute: AutoCompute;
-  rectangleSelect: RectangleSelect;
-  stageNodeRotate: StageNodeRotate;
-  complexityDetector: ComplexityDetector;
-  aiEngine: AIEngine;
-  copyEngine: CopyEngine;
-  autoLayout: AutoLayout;
-  autoLayoutFastTree: AutoLayoutFastTree;
-  layoutManager: LayoutManager;
-  autoAlign: AutoAlign;
-  mouseInteraction: MouseInteraction;
-  contentSearch: ContentSearch;
-  deleteManager: DeleteManager;
-  nodeAdder: NodeAdder;
-  entityMoveManager: EntityMoveManager;
-  stageUtils: StageUtils;
-  multiTargetEdgeMove: MultiTargetEdgeMove;
-  nodeConnector: NodeConnector;
-  stageObjectColorManager: StageObjectColorManager;
-  stageObjectSelectCounter: StageObjectSelectCounter;
-  sectionInOutManager: SectionInOutManager;
-  sectionPackManager: SectionPackManager;
-  sectionCollisionSolver: SectionCollisionSolver;
-  tagManager: TagManager;
-  syncAssociationManager: StageSyncAssociationManager;
-  keyboardOnlyEngine: KeyboardOnlyEngine;
-  keyboardOnlyGraphEngine: KeyboardOnlyGraphEngine;
-  keyboardOnlyTreeEngine: KeyboardOnlyTreeEngine;
-  selectChangeEngine: SelectChangeEngine;
-  textRenderer: TextRenderer;
-  imageRenderer: ImageRenderer;
-  referenceBlockRenderer: ReferenceBlockRenderer;
-  shapeRenderer: ShapeRenderer;
-  entityRenderer: EntityRenderer;
-  edgeRenderer: EdgeRenderer;
-  multiTargetUndirectedEdgeRenderer: MultiTargetUndirectedEdgeRenderer;
-  curveRenderer: CurveRenderer;
-  svgRenderer: SvgRenderer;
-  drawingControllerRenderer: DrawingControllerRenderer;
-  collisionBoxRenderer: CollisionBoxRenderer;
-  entityDetailsButtonRenderer: EntityDetailsButtonRenderer;
-  straightEdgeRenderer: StraightEdgeRenderer;
-  symmetryCurveEdgeRenderer: SymmetryCurveEdgeRenderer;
-  verticalPolyEdgeRenderer: VerticalPolyEdgeRenderer;
-  sectionRenderer: SectionRenderer;
-  svgNodeRenderer: SvgNodeRenderer;
-  latexNodeRenderer: LatexNodeRenderer;
-  textNodeRenderer: TextNodeRenderer;
-  urlNodeRenderer: UrlNodeRenderer;
-  backgroundRenderer: BackgroundRenderer;
-  searchContentHighlightRenderer: SearchContentHighlightRenderer;
-  renderer: Renderer;
-  controller: Controller;
-  stageExport: StageExport;
-  stageExportPng: StageExportPng;
-  stageExportSvg: StageExportSvg;
-  stageImport: StageImport;
-  generateFromFolder: GenerateFromFolder;
-  keyBindHintEngine: KeyBindHintEngine;
-  sectionMethods: SectionMethods;
-  graphMethods: GraphMethods;
-  stageStyleManager: StageStyleManager;
-  autoSaveBackup: AutoSaveBackupService;
-  referenceManager: ReferenceManager;
+  currentComponent: Promise<React.ComponentType | null>;
+  getComponent(): Promise<React.ComponentType>;
+  render(): Promise<React.ReactNode>;
+  canvas: Promise<Canvas>;
+  inputElement: Promise<InputElement>;
+  controllerUtils: Promise<ControllerUtils>;
+  autoComputeUtils: Promise<AutoComputeUtils>;
+  renderUtils: Promise<RenderUtils>;
+  worldRenderUtils: Promise<WorldRenderUtils>;
+  historyManager: Promise<HistoryManager>;
+  stageManager: Promise<StageManager>;
+  camera: Promise<Camera>;
+  effects: Promise<Effects>;
+  autoCompute: Promise<AutoCompute>;
+  rectangleSelect: Promise<RectangleSelect>;
+  stageNodeRotate: Promise<StageNodeRotate>;
+  complexityDetector: Promise<ComplexityDetector>;
+  aiEngine: Promise<AIEngine>;
+  copyEngine: Promise<CopyEngine>;
+  autoLayout: Promise<AutoLayout>;
+  autoLayoutFastTree: Promise<AutoLayoutFastTree>;
+  layoutManager: Promise<LayoutManager>;
+  autoAlign: Promise<AutoAlign>;
+  mouseInteraction: Promise<MouseInteraction>;
+  contentSearch: Promise<ContentSearch>;
+  deleteManager: Promise<DeleteManager>;
+  nodeAdder: Promise<NodeAdder>;
+  entityMoveManager: Promise<EntityMoveManager>;
+  stageUtils: Promise<StageUtils>;
+  multiTargetEdgeMove: Promise<MultiTargetEdgeMove>;
+  nodeConnector: Promise<NodeConnector>;
+  stageObjectColorManager: Promise<StageObjectColorManager>;
+  stageObjectSelectCounter: Promise<StageObjectSelectCounter>;
+  sectionInOutManager: Promise<SectionInOutManager>;
+  sectionPackManager: Promise<SectionPackManager>;
+  sectionCollisionSolver: Promise<SectionCollisionSolver>;
+  tagManager: Promise<TagManager>;
+  syncAssociationManager: Promise<StageSyncAssociationManager>;
+  keyboardOnlyEngine: Promise<KeyboardOnlyEngine>;
+  keyboardOnlyGraphEngine: Promise<KeyboardOnlyGraphEngine>;
+  keyboardOnlyTreeEngine: Promise<KeyboardOnlyTreeEngine>;
+  selectChangeEngine: Promise<SelectChangeEngine>;
+  textRenderer: Promise<TextRenderer>;
+  imageRenderer: Promise<ImageRenderer>;
+  referenceBlockRenderer: Promise<ReferenceBlockRenderer>;
+  shapeRenderer: Promise<ShapeRenderer>;
+  entityRenderer: Promise<EntityRenderer>;
+  edgeRenderer: Promise<EdgeRenderer>;
+  multiTargetUndirectedEdgeRenderer: Promise<MultiTargetUndirectedEdgeRenderer>;
+  curveRenderer: Promise<CurveRenderer>;
+  svgRenderer: Promise<SvgRenderer>;
+  drawingControllerRenderer: Promise<DrawingControllerRenderer>;
+  collisionBoxRenderer: Promise<CollisionBoxRenderer>;
+  entityDetailsButtonRenderer: Promise<EntityDetailsButtonRenderer>;
+  straightEdgeRenderer: Promise<StraightEdgeRenderer>;
+  symmetryCurveEdgeRenderer: Promise<SymmetryCurveEdgeRenderer>;
+  verticalPolyEdgeRenderer: Promise<VerticalPolyEdgeRenderer>;
+  sectionRenderer: Promise<SectionRenderer>;
+  svgNodeRenderer: Promise<SvgNodeRenderer>;
+  latexNodeRenderer: Promise<LatexNodeRenderer>;
+  textNodeRenderer: Promise<TextNodeRenderer>;
+  urlNodeRenderer: Promise<UrlNodeRenderer>;
+  backgroundRenderer: Promise<BackgroundRenderer>;
+  searchContentHighlightRenderer: Promise<SearchContentHighlightRenderer>;
+  renderer: Promise<Renderer>;
+  controller: Promise<Controller>;
+  stageExport: Promise<StageExport>;
+  stageExportPng: Promise<StageExportPng>;
+  stageExportSvg: Promise<StageExportSvg>;
+  stageImport: Promise<StageImport>;
+  generateFromFolder: Promise<GenerateFromFolder>;
+  keyBindHintEngine: Promise<KeyBindHintEngine>;
+  sectionMethods: Promise<SectionMethods>;
+  graphMethods: Promise<GraphMethods>;
+  stageStyleManager: Promise<StageStyleManager>;
+  autoSaveBackup: Promise<AutoSaveBackupService>;
+  referenceManager: Promise<ReferenceManager>;
 }
 
 declare namespace RecentFileManager {
-  const store: Store;
+  const store: Promise<Store>;
 declare type RecentFile = {
     uri: URI;
     /**
@@ -1621,49 +1621,49 @@ declare type RecentFile = {
      */
     time: number;
   };
-  function init();
-  function addRecentFile(file: RecentFile);
-  function addRecentFileByUri(uri: URI);
-  function addRecentFilesByUris(uris: URI[]);
-  function removeRecentFileByUri(uri: URI);
-  function clearAllRecentFiles();
+  function init(): Promise<void>;
+  function addRecentFile(file: RecentFile): Promise<void>;
+  function addRecentFileByUri(uri: URI): Promise<void>;
+  function addRecentFilesByUris(uris: URI[]): Promise<void>;
+  function removeRecentFileByUri(uri: URI): Promise<void>;
+  function clearAllRecentFiles(): Promise<void>;
   function getRecentFiles(): Promise<RecentFile[]>;
-  function validAndRefreshRecentFiles();
-  function sortTimeRecentFiles();
-  function clearRecentFiles();
+  function validAndRefreshRecentFiles(): Promise<void>;
+  function sortTimeRecentFiles(): Promise<void>;
+  function clearRecentFiles(): Promise<void>;
 }
 
 declare class RectangleSelect {
   constructor(project: Project);
   selectStartLocation;
   selectEndLocation;
-  getSelectStartLocation(): Vector;
-  getSelectEndLocation(): Vector;
-  selectingRectangle: Rectangle | null;
-  limitSection: Section | null;
+  getSelectStartLocation(): Promise<Vector>;
+  getSelectEndLocation(): Promise<Vector>;
+  selectingRectangle: Promise<Rectangle | null>;
+  limitSection: Promise<Section | null>;
   isSelectDirectionRight;
-  getRectangle(): Rectangle | null;
-  shutDown();
-  startSelecting(worldLocation: Vector);
-  moveSelecting(newEndLocation: Vector);
-  endSelecting();
-  updateStageObjectByMove();
-  isSelectWithEntity(entity: StageObject);
-  getSelectMode(): "contain" | "intersect";
-  getSelectMoveDistance(): number;
+  getRectangle(): Promise<Rectangle | null>;
+  shutDown(): Promise<void>;
+  startSelecting(worldLocation: Vector): Promise<void>;
+  moveSelecting(newEndLocation: Vector): Promise<void>;
+  endSelecting(): Promise<void>;
+  updateStageObjectByMove(): Promise<void>;
+  isSelectWithEntity(entity: StageObject): Promise<void>;
+  getSelectMode(): Promise<"contain" | "intersect">;
+  getSelectMoveDistance(): Promise<number>;
 }
 
 declare class ReferenceBlockNode extends ConnectableEntity implements ResizeAble {
-  isHiddenBySectionCollapse: boolean;
-  uuid: string;
-  collisionBox: CollisionBox;
-  fileName: string;
-  sectionName: string;
-  scale: number;
-  attachmentId: string;
-  _isSelected: boolean;
-  bitmap: ImageBitmap | undefined;
-  state: "loading" | "success" | "notFound";
+  isHiddenBySectionCollapse: Promise<boolean>;
+  uuid: Promise<string>;
+  collisionBox: Promise<CollisionBox>;
+  fileName: Promise<string>;
+  sectionName: Promise<string>;
+  scale: Promise<number>;
+  attachmentId: Promise<string>;
+  _isSelected: Promise<boolean>;
+  bitmap: Promise<ImageBitmap | undefined>;
+  state: Promise<"loading" | "success" | "notFound">;
   constructor(project: Project, {
       uuid = crypto.randomUUID() as string,
       collisionBox = new CollisionBox([new Rectangle(Vector.getZero(), new Vector(400, 200))]),
@@ -1673,41 +1673,41 @@ declare class ReferenceBlockNode extends ConnectableEntity implements ResizeAble
       attachmentId = "",
       details = [],
     }, unknown = false);
-  get isSelected(): any;
+  get isSelected(): Promise<any>;
   set isSelected(value: boolean);
-  loadImageFromAttachment();
-  generateScreenshot();
-  updateCollisionBox();
-  scaleUpdate(scaleDiff: number);
-  get rectangle(): Rectangle;
-  get geometryCenter(): any;
+  loadImageFromAttachment(): Promise<void>;
+  generateScreenshot(): Promise<void>;
+  updateCollisionBox(): Promise<void>;
+  scaleUpdate(scaleDiff: number): Promise<void>;
+  get rectangle(): Promise<Rectangle>;
+  get geometryCenter(): Promise<any>;
   move(delta: Vector): void;
   moveTo(location: Vector): void;
-  refresh();
-  goToSource();
-  focusSectionInProject(project: Project);
-  resizeHandle(delta: Vector);
-  getResizeHandleRect(): Rectangle;
+  refresh(): Promise<void>;
+  goToSource(): Promise<void>;
+  focusSectionInProject(project: Project): Promise<void>;
+  resizeHandle(delta: Vector): Promise<void>;
+  getResizeHandleRect(): Promise<Rectangle>;
 }
 
 declare class ReferenceBlockRenderer {
   constructor(project: Project);
-  render(referenceBlockNode: ReferenceBlockNode);
-  renderBrackets(rect: Rectangle, color: Color);
-  renderSourceSectionBorder(section: Section, countNumber: number, color: Color = new Color(118, 78, 209));
+  render(referenceBlockNode: ReferenceBlockNode): Promise<void>;
+  renderBrackets(rect: Rectangle, color: Color): Promise<void>;
+  renderSourceSectionBorder(section: Section, countNumber: number, color: Color = new Color(118, 78, 209)): Promise<void>;
 }
 
 declare class ReferenceManager {
   constructor(project: Project);
-  referenceBlockTextParser(text: string): parserResult;
-  onClickReferenceNumber(clickLocation: Vector);
-  buildSectionName2SectionMap(sectionNames: string[]): Record<string, Section>;
-  updateOneSectionReferenceInfo(recentFiles: RecentFileManager.RecentFile[], sectionName: string);
-  updateCurrentProjectReference();
-  checkReferenceBlockInProject(project: Project, fileName: string, sectionName: string);
-  insertRefDataToSourcePrgFile(fileName: string, sectionName: string);
-  jumpToReferenceLocation(fileName: string, referenceBlockNodeSectionName: string);
-  openSectionReferencePanel(section: Section);
+  referenceBlockTextParser(text: string): Promise<parserResult>;
+  onClickReferenceNumber(clickLocation: Vector): Promise<void>;
+  buildSectionName2SectionMap(sectionNames: string[]): Promise<Record<string, Section>>;
+  updateOneSectionReferenceInfo(recentFiles: RecentFileManager.RecentFile[], sectionName: string): Promise<void>;
+  updateCurrentProjectReference(): Promise<void>;
+  checkReferenceBlockInProject(project: Project, fileName: string, sectionName: string): Promise<void>;
+  insertRefDataToSourcePrgFile(fileName: string, sectionName: string): Promise<void>;
+  jumpToReferenceLocation(fileName: string, referenceBlockNodeSectionName: string): Promise<void>;
+  openSectionReferencePanel(section: Section): Promise<void>;
 }
 
 declare class Renderer {
@@ -1716,80 +1716,80 @@ declare class Renderer {
   NODE_ROUNDED_RADIUS;
   w;
   h;
-  renderedEdges: number;
-  timings: { [key: string]: number };
+  renderedEdges: Promise<number>;
+  timings: Promise<{ [key: string]: number }>;
   deltaTime;
   lastTime;
   frameCount;
   frameIndex;
   fps;
-  resizeWindow(newW: number, newH: number);
-  constructor(project: Project);
-  tick();
-  tick_();
-  renderViewElements(_viewRectangle: Rectangle);
-  renderZoomLevelStage();
-  renderMainStageElements(viewRectangle: Rectangle);
-  renderStageElementsWithoutReactions(viewRectangle: Rectangle);
-  isOverView(viewRectangle: Rectangle, entity: StageObject): boolean;
-  renderCenterPointer();
-  renderHoverCollisionBox();
-  renderSelectingRectangle();
-  renderCuttingLine();
-  renderConnectingLine();
-  renderCrosshairOnHoverImage();
-  renderKeyboardOnly();
-  rendererLayerMovingLine();
-  renderJumpLine(startLocation: Vector, endLocation: Vector);
-  renderWarningStageObjects();
-  renderTags();
-  renderEntities(viewRectangle: Rectangle);
-  renderEdges(viewRectangle: Rectangle);
-  renderBackground();
-  updateFPS();
-  renderDebugDetails();
-  renderSpecialKeys();
-  transformWorld2View(location: Vector): Vector;
-  transformWorld2View(rectangle: Rectangle): Rectangle;
-  transformWorld2View(arg1: Vector | Rectangle): Vector | Rectangle;
-  transformView2World(location: Vector): Vector;
-  transformView2World(rectangle: Rectangle): Rectangle;
-  transformView2World(arg1: Vector | Rectangle): Vector | Rectangle;
-  getCoverWorldRectangle(): Rectangle;
+  resizeWindow(newW: number, newH: number): Promise<void>;
+  constructor(project: Project);
+  tick(): Promise<void>;
+  tick_(): Promise<void>;
+  renderViewElements(_viewRectangle: Rectangle): Promise<void>;
+  renderZoomLevelStage(): Promise<void>;
+  renderMainStageElements(viewRectangle: Rectangle): Promise<void>;
+  renderStageElementsWithoutReactions(viewRectangle: Rectangle): Promise<void>;
+  isOverView(viewRectangle: Rectangle, entity: StageObject): Promise<boolean>;
+  renderCenterPointer(): Promise<void>;
+  renderHoverCollisionBox(): Promise<void>;
+  renderSelectingRectangle(): Promise<void>;
+  renderCuttingLine(): Promise<void>;
+  renderConnectingLine(): Promise<void>;
+  renderCrosshairOnHoverImage(): Promise<void>;
+  renderKeyboardOnly(): Promise<void>;
+  rendererLayerMovingLine(): Promise<void>;
+  renderJumpLine(startLocation: Vector, endLocation: Vector): Promise<void>;
+  renderWarningStageObjects(): Promise<void>;
+  renderTags(): Promise<void>;
+  renderEntities(viewRectangle: Rectangle): Promise<void>;
+  renderEdges(viewRectangle: Rectangle): Promise<void>;
+  renderBackground(): Promise<void>;
+  updateFPS(): Promise<void>;
+  renderDebugDetails(): Promise<void>;
+  renderSpecialKeys(): Promise<void>;
+  transformWorld2View(location: Vector): Promise<Vector>;
+  transformWorld2View(rectangle: Rectangle): Promise<Rectangle>;
+  transformWorld2View(arg1: Vector | Rectangle): Promise<Vector | Rectangle>;
+  transformView2World(location: Vector): Promise<Vector>;
+  transformView2World(rectangle: Rectangle): Promise<Rectangle>;
+  transformView2World(arg1: Vector | Rectangle): Promise<Vector | Rectangle>;
+  getCoverWorldRectangle(): Promise<Rectangle>;
 }
 
 declare class RenderUtils {
   constructor(project: Project);
-  renderPixel(location: Vector, color: Color);
-  renderArrow(direction: Vector, location: Vector, color: Color, size: number);
+  renderPixel(location: Vector, color: Color): Promise<void>;
+  renderArrow(direction: Vector, location: Vector, color: Color, size: number): Promise<void>;
 }
 
 declare interface ResizeAble {
   resizeHandle(delta: Vector): void;
-  getResizeHandleRect(): Rectangle;
+  getResizeHandleRect(): Promise<Rectangle>;
 }
 
 declare class SearchContentHighlightRenderer {
   constructor(project: Project);
-  render(frameTickIndex: number);
+  render(frameTickIndex: number): Promise<void>;
 }
 
 declare class Section extends ConnectableEntity {
-  _isSelected: boolean;
-  uuid: string;
-  _isEditingTitle: boolean;
-  _collisionBoxWhenCollapsed: CollisionBox;
-  _collisionBoxNormal: CollisionBox;
-  get isEditingTitle(): any;
+  _isSelected: Promise<boolean>;
+  uuid: Promise<string>;
+  _isEditingTitle: Promise<boolean>;
+  _collisionBoxWhenCollapsed: Promise<CollisionBox>;
+  _collisionBoxNormal: Promise<CollisionBox>;
+  get isEditingTitle(): Promise<any>;
   set isEditingTitle(value: boolean);
   bigTitleCameraScale;
-  get collisionBox(): CollisionBox;
-  collapsedCollisionBox(): CollisionBox;
-  color: Color;
-  text: string;
-  children: Entity[];
-  isCollapsed: boolean;
-  locked: boolean;
+  get collisionBox(): Promise<CollisionBox>;
+  collapsedCollisionBox(): Promise<CollisionBox>;
+  color: Promise<Color>;
+  text: Promise<string>;
+  children: Promise<Entity>[];
+  isCollapsed: Promise<boolean>;
+  locked: Promise<boolean>;
   isHiddenBySectionCollapse;
   constructor(project: Project, {
       uuid = crypto.randomUUID() as string,
@@ -1802,14 +1802,14 @@ declare class Section extends ConnectableEntity {
       children = [] as Entity[],
       details = [] as Value,
     } = {}, unknown = false);
-  fromEntities(project: Project, entities: Entity[]): Section;
-  rename(newName: string);
-  adjustLocationAndSize();
-  adjustChildrenStateByCollapse(parentCollapsed = false);
-  get isSelected(): any;
+  fromEntities(project: Project, entities: Entity[]): Promise<Section>;
+  rename(newName: string): Promise<void>;
+  adjustLocationAndSize(): Promise<void>;
+  adjustChildrenStateByCollapse(parentCollapsed = false): Promise<void>;
+  get isSelected(): Promise<any>;
   set isSelected(value: boolean);
-  get rectangle(): Rectangle;
-  get geometryCenter(): any;
+  get rectangle(): Promise<Rectangle>;
+  get geometryCenter(): Promise<any>;
   move(delta: Vector): void;
   collideWithOtherEntity(other: Entity): void;
   moveTo(location: Vector): void;
@@ -1819,90 +1819,90 @@ declare class SectionCollisionSolver {
   constructor(project: Project);
   solveOverlaps(grownSection: Section, visited: Set<string> = new Set()): void;
   updateAncestorsAfterShift(entity: Entity, visited: Set<string>): void;
-  getSiblingsSections(section: Section): Section[];
-  computePushDelta(grownRect: Rectangle, siblingRect: Rectangle): Vector;
+  getSiblingsSections(section: Section): Promise<Section>[];
+  computePushDelta(grownRect: Rectangle, siblingRect: Rectangle): Promise<Vector>;
   rawShiftEntityTree(entity: Entity, delta: Vector): void;
 }
 
 declare class SectionInOutManager {
   constructor(project: Project);
-  goInSection(entities: Entity[], section: Section);
-  goInSections(entities: Entity[], sections: Section[]);
-  goOutSection(entities: Entity[], section: Section);
-  entityDropParent(entity: Entity);
-  sectionDropChild(section: Section, entity: Entity);
-  convertSectionToTextNode(section: Section);
+  goInSection(entities: Entity[], section: Section): Promise<void>;
+  goInSections(entities: Entity[], sections: Section[]): Promise<void>;
+  goOutSection(entities: Entity[], section: Section): Promise<void>;
+  entityDropParent(entity: Entity): Promise<void>;
+  sectionDropChild(section: Section, entity: Entity): Promise<void>;
+  convertSectionToTextNode(section: Section): Promise<void>;
 }
 
 declare class SectionMethods {
   constructor(project: Project);
-  getFatherSections(entity: Entity): Section[];
-  isObjectBeLockedBySection(object: StageObject): boolean;
-  getFatherSectionsList(entity: Entity): Section[];
-  getSectionsByInnerLocation(location: Vector): Section[];
-  deeperSections(sections: Section[]): Section[];
-  shallowerSection(sections: Section[]): Section[];
-  shallowerNotSectionEntities(entities: Entity[]): Entity[];
-  isEntityInSection(entity: Entity, section: Section): boolean;
-  isEntityInSection_fake(entity: Entity, section: Section): boolean;
-  _isEntityInSection(entity: Entity, section: Section, deep = 0): boolean;
-  isTreePack(rootNode: Section);
-  getSectionMaxDeep(section: Section): number;
-  getAllEntitiesInSelectedSectionsOrEntities(selectedEntities: Entity[]): Entity[];
-  getSortedSectionsByZ(sections: Section[]): Section[];
+  getFatherSections(entity: Entity): Promise<Section>[];
+  isObjectBeLockedBySection(object: StageObject): Promise<boolean>;
+  getFatherSectionsList(entity: Entity): Promise<Section>[];
+  getSectionsByInnerLocation(location: Vector): Promise<Section>[];
+  deeperSections(sections: Section[]): Promise<Section>[];
+  shallowerSection(sections: Section[]): Promise<Section>[];
+  shallowerNotSectionEntities(entities: Entity[]): Promise<Entity>[];
+  isEntityInSection(entity: Entity, section: Section): Promise<boolean>;
+  isEntityInSection_fake(entity: Entity, section: Section): Promise<boolean>;
+  _isEntityInSection(entity: Entity, section: Section, deep = 0): Promise<boolean>;
+  isTreePack(rootNode: Section): Promise<void>;
+  getSectionMaxDeep(section: Section): Promise<number>;
+  getAllEntitiesInSelectedSectionsOrEntities(selectedEntities: Entity[]): Promise<Entity>[];
+  getSortedSectionsByZ(sections: Section[]): Promise<Section>[];
 }
 
 declare class SectionPackManager {
   constructor(project: Project);
   packSection(): void;
-  modifyHiddenDfs(section: Section, isCollapsed: boolean);
+  modifyHiddenDfs(section: Section, isCollapsed: boolean): Promise<void>;
   unpackSection(): void;
   switchCollapse(): void;
   textNodeToSection(): void;
   textNodeTreeToSection(rootNode: TextNode): void;
   textNodeTreeToSectionNoDeep(rootNode: TextNode): void;
-  targetTextNodeToSection(textNode: TextNode, ignoreEdges: boolean = false, addConnectPoints: boolean = false): Section;
-  unpackSelectedSections();
-  unpackSections(entities: Entity[]);
-  packEntityToSection(addEntities: Entity[]);
+  targetTextNodeToSection(textNode: TextNode, ignoreEdges: boolean = false, addConnectPoints: boolean = false): Promise<Section>;
+  unpackSelectedSections(): Promise<void>;
+  unpackSections(entities: Entity[]): Promise<void>;
+  packEntityToSection(addEntities: Entity[]): Promise<void>;
   createSectionFromSelectionRectangle(): void;
   packSelectedEntitiesToSection(): void;
-  getSmartSectionTitle(addEntities: Entity[]): string;
+  getSmartSectionTitle(addEntities: Entity[]): Promise<string>;
 }
 
 declare class SectionRenderer {
   constructor(project: Project);
-  renderCollapsed(section: Section);
-  renderNoCollapse(section: Section);
-  renderBackgroundColor(section: Section);
-  renderBigCoveredTitle(section: Section);
-  renderTopTitle(section: Section);
+  renderCollapsed(section: Section): Promise<void>;
+  renderNoCollapse(section: Section): Promise<void>;
+  renderBackgroundColor(section: Section): Promise<void>;
+  renderBigCoveredTitle(section: Section): Promise<void>;
+  renderTopTitle(section: Section): Promise<void>;
   render(section: Section): void;
 }
 
 declare class SelectChangeEngine {
   lastSelectNodeByKeyboardUUID;
   constructor(project: Project);
-  selectUp(addSelect = false);
-  selectDown(addSelect = false);
-  selectLeft(addSelect = false);
-  selectRight(addSelect = false);
-  navigateInDirection(selectedNode: ConnectableEntity, direction: Direction): ConnectableEntity | null;
-  getSameLevelCandidates(parentSection: Section, excludeNode: ConnectableEntity): ConnectableEntity[];
-  getTopLevelCandidates(excludeNode: ConnectableEntity): ConnectableEntity[];
-  expandSelect(isKeepExpand = false, reversed: boolean = false);
-  afterSelect(selectedNodeRect: ConnectableEntity, newSelectedConnectableEntity: ConnectableEntity | null, clearOldSelect = true);
-  getCurrentSelectedNode(): ConnectableEntity | null;
-  addEffect(selectedNodeRect: Rectangle, newSelectNodeRect: Rectangle);
-  getMostNearConnectableEntity(nodes: ConnectableEntity[], location: Vector): ConnectableEntity | null;
-  selectMostNearLocationNode(location: Vector): ConnectableEntity | null;
-  collectNodesInStrip(node: ConnectableEntity, direction: Direction, candidates: ConnectableEntity[]): ConnectableEntity[];
-  getMostNearInStripByDh(nodes: ConnectableEntity[], nodeRect: Rectangle, direction: Direction): ConnectableEntity | null;
-  collectFanNodes(node: ConnectableEntity, direction: Direction, candidates: ConnectableEntity[]): ConnectableEntity[];
-  collectTopNodes(node: ConnectableEntity, candidates?: ConnectableEntity[]): ConnectableEntity[];
-  collectBottomNodes(node: ConnectableEntity, candidates?: ConnectableEntity[]): ConnectableEntity[];
-  collectLeftNodes(node: ConnectableEntity, candidates?: ConnectableEntity[]): ConnectableEntity[];
-  collectRightNodes(node: ConnectableEntity, candidates?: ConnectableEntity[]): ConnectableEntity[];
+  selectUp(addSelect = false): Promise<void>;
+  selectDown(addSelect = false): Promise<void>;
+  selectLeft(addSelect = false): Promise<void>;
+  selectRight(addSelect = false): Promise<void>;
+  navigateInDirection(selectedNode: ConnectableEntity, direction: Direction): Promise<ConnectableEntity | null>;
+  getSameLevelCandidates(parentSection: Section, excludeNode: ConnectableEntity): Promise<ConnectableEntity>[];
+  getTopLevelCandidates(excludeNode: ConnectableEntity): Promise<ConnectableEntity>[];
+  expandSelect(isKeepExpand = false, reversed: boolean = false): Promise<void>;
+  afterSelect(selectedNodeRect: ConnectableEntity, newSelectedConnectableEntity: ConnectableEntity | null, clearOldSelect = true): Promise<void>;
+  getCurrentSelectedNode(): Promise<ConnectableEntity | null>;
+  addEffect(selectedNodeRect: Rectangle, newSelectNodeRect: Rectangle): Promise<void>;
+  getMostNearConnectableEntity(nodes: ConnectableEntity[], location: Vector): Promise<ConnectableEntity | null>;
+  selectMostNearLocationNode(location: Vector): Promise<ConnectableEntity | null>;
+  collectNodesInStrip(node: ConnectableEntity, direction: Direction, candidates: ConnectableEntity[]): Promise<ConnectableEntity>[];
+  getMostNearInStripByDh(nodes: ConnectableEntity[], nodeRect: Rectangle, direction: Direction): Promise<ConnectableEntity | null>;
+  collectFanNodes(node: ConnectableEntity, direction: Direction, candidates: ConnectableEntity[]): Promise<ConnectableEntity>[];
+  collectTopNodes(node: ConnectableEntity, candidates?: ConnectableEntity[]): Promise<ConnectableEntity>[];
+  collectBottomNodes(node: ConnectableEntity, candidates?: ConnectableEntity[]): Promise<ConnectableEntity>[];
+  collectLeftNodes(node: ConnectableEntity, candidates?: ConnectableEntity[]): Promise<ConnectableEntity>[];
+  collectRightNodes(node: ConnectableEntity, candidates?: ConnectableEntity[]): Promise<ConnectableEntity>[];
 }
 
 declare namespace Serialized {
@@ -2033,7 +2033,7 @@ declare type File = {
 
 declare interface Service {
   tick(): void;
-  dispose(): void | Promise<void>;
+  dispose(): Promise<void | Promise<void>>;
 }
 
 declare type Settings = z.infer<typeof settingsSchema>;
@@ -2043,180 +2043,180 @@ declare class ShapeRenderer {
   renderCircle(centerLocation: Vector, radius: number, color: Color, strokeColor: Color, strokeWidth: number): void;
   renderArc(centerLocation: Vector, radius: number, angle1: number, angle2: number, strokeColor: Color, strokeWidth: number): void;
   renderRectFromCenter(centerLocation: Vector, width: number, height: number, color: Color, strokeColor: Color, strokeWidth: number, radius: number = 0): void;
-  renderRect(rect: Rectangle, color: Color, strokeColor: Color, strokeWidth: number, radius: number = 0);
-  renderDashedRect(rect: Rectangle, color: Color, strokeColor: Color, strokeWidth: number, radius: number = 0, dashLength = 5);
-  renderRectWithShadow(rect: Rectangle, fillColor: Color, strokeColor: Color, strokeWidth: number, shadowColor: Color, shadowBlur: number, shadowOffsetX: number = 0, shadowOffsetY: number = 0, radius: number = 0);
+  renderRect(rect: Rectangle, color: Color, strokeColor: Color, strokeWidth: number, radius: number = 0): Promise<void>;
+  renderDashedRect(rect: Rectangle, color: Color, strokeColor: Color, strokeWidth: number, radius: number = 0, dashLength = 5): Promise<void>;
+  renderRectWithShadow(rect: Rectangle, fillColor: Color, strokeColor: Color, strokeWidth: number, shadowColor: Color, shadowBlur: number, shadowOffsetX: number = 0, shadowOffsetY: number = 0, radius: number = 0): Promise<void>;
   renderPolygonAndFill(points: Vector[], fillColor: Color, strokeColor: Color, strokeWidth: number, lineJoin: "round" | "bevel" = "round"): void;
   renderTriangleFromCenter(centerLocation: Vector, size: number, rotation: number, fillColor: Color, strokeColor: Color, strokeWidth: number): void;
   renderSquareFromCenter(centerLocation: Vector, size: number, rotation: number, fillColor: Color, strokeColor: Color, strokeWidth: number): void;
-  renderCircleTransition(viewLocation: Vector, radius: number, centerColor: Color);
-  renderCameraShapeBorder(rect: Rectangle, borderColor: Color, borderWidth: number);
-  renderResizeArrow(rect: Rectangle, color: Color, strokeWidth: number);
+  renderCircleTransition(viewLocation: Vector, radius: number, centerColor: Color): Promise<void>;
+  renderCameraShapeBorder(rect: Rectangle, borderColor: Color, borderWidth: number): Promise<void>;
+  renderResizeArrow(rect: Rectangle, color: Color, strokeWidth: number): Promise<void>;
 }
 
 declare class StageExport {
-  plainTextExporter: PlainTextExporter;
-  markdownExporter: MarkdownExporter;
-  tabExporter: TabExporter;
-  mermaidExporter: MermaidExporter;
+  plainTextExporter: Promise<PlainTextExporter>;
+  markdownExporter: Promise<MarkdownExporter>;
+  tabExporter: Promise<TabExporter>;
+  mermaidExporter: Promise<MermaidExporter>;
   constructor(project: Project);
-  getPlainTextByEntities(nodes: Entity[]);
-  getMarkdownStringByTextNode(textNode: TextNode);
-  getTabStringByTextNode(textNode: TextNode);
-  getMermaidTextByEntities(entities: Entity[]): string;
+  getPlainTextByEntities(nodes: Entity[]): Promise<void>;
+  getMarkdownStringByTextNode(textNode: TextNode): Promise<void>;
+  getTabStringByTextNode(textNode: TextNode): Promise<void>;
+  getMermaidTextByEntities(entities: Entity[]): Promise<string>;
 }
 
 declare class StageExportPng {
   constructor(project: Project);
-  exportStage_(emitter: EventEmitter<EventMap>, signal: AbortSignal, sleepTime: number);
-  exportStage(signal: AbortSignal, sleepTime: number = 2);
-  generateCanvasNode(): HTMLCanvasElement;
+  exportStage_(emitter: EventEmitter<EventMap>, signal: AbortSignal, sleepTime: number): Promise<void>;
+  exportStage(signal: AbortSignal, sleepTime: number = 2): Promise<void>;
+  generateCanvasNode(): Promise<HTMLCanvasElement>;
 }
 
 declare class StageExportSvg {
   constructor(project: Project);
-  svgConfig: SvgExportConfig;
-  exportContext: {
+  svgConfig: Promise<SvgExportConfig>;
+  exportContext: Promise<{
     outputDir: string;
     imageMap: Map<string, string>; // attachmentId -> relative file path
-  } | null;
-  setConfig(config: SvgExportConfig);
-  dumpNode(node: TextNode);
-  dumpSection(section: Section);
-  dumpSectionBase(section: Section);
-  dumpEdge(edge: LineEdge): React.ReactNode;
-  dumpEntityDetails(entity: Entity): React.ReactNode;
-  getEntityDetailsDataAttribute(entity: Entity): string | undefined;
-  dumpUrlNode(node: UrlNode);
-  dumpImageNode(node: ImageNode, svgConfigObject: SvgExportConfig);
-  getEntitiesOuterRectangle(entities: Entity[], padding: number): Rectangle;
-  dumpSelected(): React.ReactNode;
-  dumpStage(): React.ReactNode;
-  dumpStageToSVGString(): string;
-  dumpSelectedToSVGString(): string;
+  } | null>;
+  setConfig(config: SvgExportConfig): Promise<void>;
+  dumpNode(node: TextNode): Promise<void>;
+  dumpSection(section: Section): Promise<void>;
+  dumpSectionBase(section: Section): Promise<void>;
+  dumpEdge(edge: LineEdge): Promise<React.ReactNode>;
+  dumpEntityDetails(entity: Entity): Promise<React.ReactNode>;
+  getEntityDetailsDataAttribute(entity: Entity): Promise<string | undefined>;
+  dumpUrlNode(node: UrlNode): Promise<void>;
+  dumpImageNode(node: ImageNode, svgConfigObject: SvgExportConfig): Promise<void>;
+  getEntitiesOuterRectangle(entities: Entity[], padding: number): Promise<Rectangle>;
+  dumpSelected(): Promise<React.ReactNode>;
+  dumpStage(): Promise<React.ReactNode>;
+  dumpStageToSVGString(): Promise<string>;
+  dumpSelectedToSVGString(): Promise<string>;
   exportStageToSVGFile(filePath: string): Promise<void>;
   exportSelectedToSVGFile(filePath: string): Promise<void>;
 }
 
 declare class StageImport {
-  graphImporter: GraphImporter;
-  treeImporter: TreeImporter;
-  mermaidImporter: MermaidImporter;
-  markdownImporter: MarkdownImporter;
+  graphImporter: Promise<GraphImporter>;
+  treeImporter: Promise<TreeImporter>;
+  mermaidImporter: Promise<MermaidImporter>;
+  markdownImporter: Promise<MarkdownImporter>;
   constructor(project: Project);
-  addNodeGraphByText(text: string, diffLocation: Vector = Vector.getZero());
-  addNodeTreeByText(text: string, indention: number, diffLocation: Vector = Vector.getZero());
-  addNodeTreeByTextFromNode(uuid: string, text: string, indention: number): { success: boolean; error?: string; nodeCount?: number };
-  addNodeMermaidByText(text: string, diffLocation: Vector = Vector.getZero());
-  addNodeByMarkdown(markdownText: string, diffLocation: Vector = Vector.getZero(), autoLayout = true);
+  addNodeGraphByText(text: string, diffLocation: Vector = Vector.getZero()): Promise<void>;
+  addNodeTreeByText(text: string, indention: number, diffLocation: Vector = Vector.getZero()): Promise<void>;
+  addNodeTreeByTextFromNode(uuid: string, text: string, indention: number): Promise<{ success: boolean; error?: string; nodeCount?: number }>;
+  addNodeMermaidByText(text: string, diffLocation: Vector = Vector.getZero()): Promise<void>;
+  addNodeByMarkdown(markdownText: string, diffLocation: Vector = Vector.getZero(), autoLayout = true): Promise<void>;
 }
 
 declare class StageManager {
   constructor(project: Project);
-  get(uuid: string);
-  isEmpty(): boolean;
-  getTextNodes(): TextNode[];
-  getConnectableEntity(): ConnectableEntity[];
-  isEntityExists(uuid: string): boolean;
-  getSections(): Section[];
-  getImageNodes(): ImageNode[];
-  getConnectPoints(): ConnectPoint[];
-  getUrlNodes(): UrlNode[];
-  getPenStrokes(): PenStroke[];
-  getSvgNodes(): SvgNode[];
-  getLatexNodes(): LatexNode[];
-  getStageObjects(): StageObject[];
-  getEntities(): Entity[];
-  getEntitiesByUUIDs(uuids: string[]): Entity[];
-  isNoEntity(): boolean;
-  delete(stageObject: StageObject);
-  getAssociations(): Association[];
-  getEdges(): Edge[];
-  getLineEdges(): LineEdge[];
-  getCrEdges(): CubicCatmullRomSplineEdge[];
-  add(stageObject: StageObject);
-  updateReferences();
-  getTextNodeByUUID(uuid: string): TextNode | null;
-  getConnectableEntityByUUID(uuid: string): ConnectableEntity | null;
-  isSectionByUUID(uuid: string): boolean;
-  getSectionByUUID(uuid: string): Section | null;
-  getCenter(): Vector;
-  getSize(): Vector;
-  getBoundingRectangle(): Rectangle;
-  findTextNodeByLocation(location: Vector): TextNode | null;
-  findLineEdgeByLocation(location: Vector): LineEdge | null;
-  findAssociationByLocation(location: Vector): Association | null;
-  findSectionByLocation(location: Vector): Section | null;
-  findImageNodeByLocation(location: Vector): ImageNode | null;
-  findConnectableEntityByLocation(location: Vector): ConnectableEntity | null;
-  findEntityByLocation(location: Vector): Entity | null;
-  findConnectPointByLocation(location: Vector): ConnectPoint | null;
-  isHaveEntitySelected(): boolean;
-  getSelectedEntities(): Entity[];
-  getSelectedAssociations(): Association[];
-  getSelectedStageObjects(): StageObject[];
-  getBoundingBoxOfSelected(): Rectangle;
-  isEntityOnLocation(location: Vector): boolean;
-  isAssociationOnLocation(location: Vector): boolean;
-  deleteEntities(deleteNodes: Entity[]);
-  deleteSelectedStageObjects();
-  deleteAssociation(deleteAssociation: Association): boolean;
-  deleteEdge(deleteEdge: Edge): boolean;
+  get(uuid: string): Promise<void>;
+  isEmpty(): Promise<boolean>;
+  getTextNodes(): Promise<TextNode>[];
+  getConnectableEntity(): Promise<ConnectableEntity>[];
+  isEntityExists(uuid: string): Promise<boolean>;
+  getSections(): Promise<Section>[];
+  getImageNodes(): Promise<ImageNode>[];
+  getConnectPoints(): Promise<ConnectPoint>[];
+  getUrlNodes(): Promise<UrlNode>[];
+  getPenStrokes(): Promise<PenStroke>[];
+  getSvgNodes(): Promise<SvgNode>[];
+  getLatexNodes(): Promise<LatexNode>[];
+  getStageObjects(): Promise<StageObject>[];
+  getEntities(): Promise<Entity>[];
+  getEntitiesByUUIDs(uuids: string[]): Promise<Entity>[];
+  isNoEntity(): Promise<boolean>;
+  delete(stageObject: StageObject): Promise<void>;
+  getAssociations(): Promise<Association>[];
+  getEdges(): Promise<Edge>[];
+  getLineEdges(): Promise<LineEdge>[];
+  getCrEdges(): Promise<CubicCatmullRomSplineEdge>[];
+  add(stageObject: StageObject): Promise<void>;
+  updateReferences(): Promise<void>;
+  getTextNodeByUUID(uuid: string): Promise<TextNode | null>;
+  getConnectableEntityByUUID(uuid: string): Promise<ConnectableEntity | null>;
+  isSectionByUUID(uuid: string): Promise<boolean>;
+  getSectionByUUID(uuid: string): Promise<Section | null>;
+  getCenter(): Promise<Vector>;
+  getSize(): Promise<Vector>;
+  getBoundingRectangle(): Promise<Rectangle>;
+  findTextNodeByLocation(location: Vector): Promise<TextNode | null>;
+  findLineEdgeByLocation(location: Vector): Promise<LineEdge | null>;
+  findAssociationByLocation(location: Vector): Promise<Association | null>;
+  findSectionByLocation(location: Vector): Promise<Section | null>;
+  findImageNodeByLocation(location: Vector): Promise<ImageNode | null>;
+  findConnectableEntityByLocation(location: Vector): Promise<ConnectableEntity | null>;
+  findEntityByLocation(location: Vector): Promise<Entity | null>;
+  findConnectPointByLocation(location: Vector): Promise<ConnectPoint | null>;
+  isHaveEntitySelected(): Promise<boolean>;
+  getSelectedEntities(): Promise<Entity>[];
+  getSelectedAssociations(): Promise<Association>[];
+  getSelectedStageObjects(): Promise<StageObject>[];
+  getBoundingBoxOfSelected(): Promise<Rectangle>;
+  isEntityOnLocation(location: Vector): Promise<boolean>;
+  isAssociationOnLocation(location: Vector): Promise<boolean>;
+  deleteEntities(deleteNodes: Entity[]): Promise<void>;
+  deleteSelectedStageObjects(): Promise<void>;
+  deleteAssociation(deleteAssociation: Association): Promise<boolean>;
+  deleteEdge(deleteEdge: Edge): Promise<boolean>;
   w;
-  connectEntity(fromNode: ConnectableEntity, toNode: ConnectableEntity, isCrEdge: boolean = false);
-  connectMultipleEntities(fromNodes: ConnectableEntity[], toNode: ConnectableEntity, isCrEdge: boolean = false, sourceRectRate?: [number, number], targetRectRate?: [number, number]);
-  reverseNodeEdges(connectEntity: ConnectableEntity);
-  reverseSelectedNodeEdge();
-  reverseSelectedEdges();
-  generateNodeTreeByText(text: string, indention: number = 4, location = this.project.camera.location);
-  generateNodeGraphByText(text: string, location = this.project.camera.location);
-  generateNodeMermaidByText(text: string, location = this.project.camera.location);
-  generateNodeByMarkdown(text: string, location = this.project.camera.location, autoLayout = true);
-  packEntityToSection(addEntities: Entity[]);
-  packEntityToSectionBySelected();
-  goInSection(entities: Entity[], section: Section);
-  goOutSection(entities: Entity[], section: Section);
-  packSelectedSection();
-  unpackSelectedSection();
-  sectionSwitchCollapse();
-  connectEntityByCrEdge(fromNode: ConnectableEntity, toNode: ConnectableEntity);
-  refreshAllStageObjects();
-  refreshSelected();
-  changeSelectedEdgeConnectLocation(direction: Direction | null, isSource: boolean = false);
-  changeEdgesConnectLocation(edges: Edge[], direction: Direction | null, isSource: boolean = false);
-  switchLineEdgeToCrEdge();
-  switchEdgeToUndirectedEdge();
-  switchUndirectedEdgeToEdge();
-  addSelectedCREdgeControlPoint();
-  addSelectedCREdgeTension();
-  reduceSelectedCREdgeTension();
-  setSelectedEdgeLineType(lineType: string);
-  selectAll();
-  clearSelectAll();
+  connectEntity(fromNode: ConnectableEntity, toNode: ConnectableEntity, isCrEdge: boolean = false): Promise<void>;
+  connectMultipleEntities(fromNodes: ConnectableEntity[], toNode: ConnectableEntity, isCrEdge: boolean = false, sourceRectRate?: [number, number], targetRectRate?: [number, number]): Promise<void>;
+  reverseNodeEdges(connectEntity: ConnectableEntity): Promise<void>;
+  reverseSelectedNodeEdge(): Promise<void>;
+  reverseSelectedEdges(): Promise<void>;
+  generateNodeTreeByText(text: string, indention: number = 4, location = this.project.camera.location): Promise<void>;
+  generateNodeGraphByText(text: string, location = this.project.camera.location): Promise<void>;
+  generateNodeMermaidByText(text: string, location = this.project.camera.location): Promise<void>;
+  generateNodeByMarkdown(text: string, location = this.project.camera.location, autoLayout = true): Promise<void>;
+  packEntityToSection(addEntities: Entity[]): Promise<void>;
+  packEntityToSectionBySelected(): Promise<void>;
+  goInSection(entities: Entity[], section: Section): Promise<void>;
+  goOutSection(entities: Entity[], section: Section): Promise<void>;
+  packSelectedSection(): Promise<void>;
+  unpackSelectedSection(): Promise<void>;
+  sectionSwitchCollapse(): Promise<void>;
+  connectEntityByCrEdge(fromNode: ConnectableEntity, toNode: ConnectableEntity): Promise<void>;
+  refreshAllStageObjects(): Promise<void>;
+  refreshSelected(): Promise<void>;
+  changeSelectedEdgeConnectLocation(direction: Direction | null, isSource: boolean = false): Promise<void>;
+  changeEdgesConnectLocation(edges: Edge[], direction: Direction | null, isSource: boolean = false): Promise<void>;
+  switchLineEdgeToCrEdge(): Promise<void>;
+  switchEdgeToUndirectedEdge(): Promise<void>;
+  switchUndirectedEdgeToEdge(): Promise<void>;
+  addSelectedCREdgeControlPoint(): Promise<void>;
+  addSelectedCREdgeTension(): Promise<void>;
+  reduceSelectedCREdgeTension(): Promise<void>;
+  setSelectedEdgeLineType(lineType: string): Promise<void>;
+  selectAll(): Promise<void>;
+  clearSelectAll(): Promise<void>;
 }
 
 declare class StageNodeRotate {
   constructor(project: Project);
-  moveEdges(lastMoveLocation: Vector, diffLocation: Vector);
+  moveEdges(lastMoveLocation: Vector, diffLocation: Vector): Promise<void>;
   rotateNodeDfs(rotateCenterNode: ConnectableEntity, currentNode: ConnectableEntity, degrees: number, visitedUUIDs: string[]): void;
 }
 
 declare class StageObject {
-  project: Project;
-  uuid: string;
-  collisionBox: CollisionBox;
-  get isPhysical(): boolean;
-  _isSelected: boolean;
-  get isSelected(): boolean;
+  project: Promise<Project>;
+  uuid: Promise<string>;
+  collisionBox: Promise<CollisionBox>;
+  get isPhysical(): Promise<boolean>;
+  _isSelected: Promise<boolean>;
+  get isSelected(): Promise<boolean>;
   set isSelected(value: boolean);
-  _isSyncing: boolean;
+  _isSyncing: Promise<boolean>;
 }
 
 declare class StageObjectColorManager {
   constructor(project: Project);
-  setSelectedStageObjectColor(color: Color);
-  darkenNodeColor();
-  lightenNodeColor();
+  setSelectedStageObjectColor(color: Color): Promise<void>;
+  darkenNodeColor(): Promise<void>;
+  lightenNodeColor(): Promise<void>;
 }
 
 declare class StageObjectSelectCounter {
@@ -2231,7 +2231,7 @@ declare class StageObjectSelectCounter {
   selectedSectionCount;
   selectedMultiTargetUndirectedEdgeCount;
   lastUpdateTimestamp;
-  update();
+  update(): Promise<void>;
 }
 
 declare class StageStyleManager {
@@ -2242,33 +2242,33 @@ declare class StageStyleManager {
 declare class StageSyncAssociationManager {
   constructor(project: Project);
   createTwinsFromSelectedEntities(): void;
-  getSyncAssociations(): SyncAssociation[];
-  getSyncAssociationsByMember(member: StageObject): SyncAssociation[];
-  getSyncSiblings(member: StageObject): StageObject[];
-  createTwinTextNode(source: TextNode): TextNode;
+  getSyncAssociations(): Promise<SyncAssociation>[];
+  getSyncAssociationsByMember(member: StageObject): Promise<SyncAssociation>[];
+  getSyncSiblings(member: StageObject): Promise<StageObject>[];
+  createTwinTextNode(source: TextNode): Promise<TextNode>;
   syncFrom(source: StageObject, key: SyncableKey, syncingSet: Set<string> = new Set()): void;
   onStageObjectDeleted(deleted: StageObject): void;
 }
 
 declare class StageUtils {
   constructor(project: Project);
-  replaceAutoNameWithoutStage(template: string): string;
-  replaceAutoNameTemplate(currentName: string, targetStageObject: StageObject): string;
-  isNameConflictWithTextNodes(name: string): boolean;
-  isNameConflictWithSections(name: string): boolean;
+  replaceAutoNameWithoutStage(template: string): Promise<string>;
+  replaceAutoNameTemplate(currentName: string, targetStageObject: StageObject): Promise<string>;
+  isNameConflictWithTextNodes(name: string): Promise<boolean>;
+  isNameConflictWithSections(name: string): Promise<boolean>;
 }
 
 declare class StraightEdgeRenderer extends EdgeRendererClass {
   constructor(project: Project);
-  getCuttingEffects(edge: LineEdge): Effect[];
-  getConnectedEffects(startNode: ConnectableEntity, toNode: ConnectableEntity, sourceRectangleRate?: Vector, targetRectangleRate?: Vector): Effect[];
+  getCuttingEffects(edge: LineEdge): Promise<Effect>[];
+  getConnectedEffects(startNode: ConnectableEntity, toNode: ConnectableEntity, sourceRectangleRate?: Vector, targetRectangleRate?: Vector): Promise<Effect>[];
   renderLine(start: Vector, end: Vector, edge: LineEdge, width: number): void;
   renderNormalState(edge: LineEdge): void;
-  getNormalStageSvg(edge: LineEdge): React.ReactNode;
-  getCycleStageSvg(): React.ReactNode;
-  getShiftingStageSvg(): React.ReactNode;
-  renderArrowHead(edge: LineEdge, direction: Vector, endPoint = edge.bodyLine.end.clone(), size = 15);
-  shouldRenderTargetArrow(edge: LineEdge): boolean;
+  getNormalStageSvg(edge: LineEdge): Promise<React.ReactNode>;
+  getCycleStageSvg(): Promise<React.ReactNode>;
+  getShiftingStageSvg(): Promise<React.ReactNode>;
+  renderArrowHead(edge: LineEdge, direction: Vector, endPoint = edge.bodyLine.end.clone(), size = 15): Promise<void>;
+  shouldRenderTargetArrow(edge: LineEdge): Promise<boolean>;
   renderShiftingState(edge: LineEdge): void;
   renderCycleState(edge: LineEdge): void;
   renderVirtualEdge(startNode: ConnectableEntity, mouseLocation: Vector, sourceRectangleRate?: Vector): void;
@@ -2276,14 +2276,14 @@ declare class StraightEdgeRenderer extends EdgeRendererClass {
 }
 
 declare class SvgNode extends ConnectableEntity implements ResizeAble {
-  color: Color;
-  uuid: string;
-  scale: number;
-  collisionBox: CollisionBox;
-  attachmentId: string;
-  isHiddenBySectionCollapse: boolean;
-  originalSize: Vector;
-  image: HTMLImageElement;
+  color: Promise<Color>;
+  uuid: Promise<string>;
+  scale: Promise<number>;
+  collisionBox: Promise<CollisionBox>;
+  attachmentId: Promise<string>;
+  isHiddenBySectionCollapse: Promise<boolean>;
+  originalSize: Promise<Vector>;
+  image: Promise<HTMLImageElement>;
   constructor(project: Project, {
       uuid = crypto.randomUUID(),
       details = [],
@@ -2292,22 +2292,22 @@ declare class SvgNode extends ConnectableEntity implements ResizeAble {
       scale = 1,
       color = Color.Transparent,
     });
-  get geometryCenter(): Vector;
-  scaleUpdate(scaleDiff: number);
+  get geometryCenter(): Promise<Vector>;
+  scaleUpdate(scaleDiff: number): Promise<void>;
   move(delta: Vector): void;
   moveTo(location: Vector): void;
-  changeColor(newColor: Color, mode: "fill" | "stroke" = "fill");
-  resizeHandle(delta: Vector);
-  getResizeHandleRect(): Rectangle;
+  changeColor(newColor: Color, mode: "fill" | "stroke" = "fill"): Promise<void>;
+  resizeHandle(delta: Vector): Promise<void>;
+  getResizeHandleRect(): Promise<Rectangle>;
 }
 
 declare class SvgNodeRenderer {
   constructor(project: Project);
-  render(svgNode: SvgNode);
+  render(svgNode: SvgNode): Promise<void>;
 }
 
 declare class SvgRenderer {
-  svgCache: { [key: string]: HTMLImageElement };
+  svgCache: Promise<{ [key: string]: HTMLImageElement }>;
   constructor(project: Project);
   renderSvgFromLeftTop(svg: string, location: Vector, width: number, height: number): void;
   renderSvgFromCenter(svg: string, centerLocation: Vector, width: number, height: number): void;
@@ -2317,15 +2317,15 @@ declare class SvgRenderer {
 
 declare class SymmetryCurveEdgeRenderer extends EdgeRendererClass {
   constructor(project: Project);
-  shouldRenderTargetArrow(edge: LineEdge): boolean;
-  getCuttingEffects(edge: LineEdge): Effect[];
-  getConnectedEffects(startNode: ConnectableEntity, toNode: ConnectableEntity, sourceRectangleRate?: Vector, targetRectangleRate?: Vector): Effect[];
+  shouldRenderTargetArrow(edge: LineEdge): Promise<boolean>;
+  getCuttingEffects(edge: LineEdge): Promise<Effect>[];
+  getConnectedEffects(startNode: ConnectableEntity, toNode: ConnectableEntity, sourceRectangleRate?: Vector, targetRectangleRate?: Vector): Promise<Effect>[];
   renderNormalState(edge: LineEdge): void;
   renderShiftingState(edge: LineEdge): void;
   renderCycleState(edge: LineEdge): void;
-  getNormalStageSvg(edge: LineEdge): React.ReactNode;
-  getCycleStageSvg(): React.ReactNode;
-  getShiftingStageSvg(): React.ReactNode;
+  getNormalStageSvg(edge: LineEdge): Promise<React.ReactNode>;
+  getCycleStageSvg(): Promise<React.ReactNode>;
+  getShiftingStageSvg(): Promise<React.ReactNode>;
   renderVirtualEdge(startNode: ConnectableEntity, mouseLocation: Vector, sourceRectangleRate?: Vector): void;
   renderVirtualConfirmedEdge(startNode: ConnectableEntity, endNode: ConnectableEntity, sourceRectangleRate?: Vector, targetRectangleRate?: Vector): void;
   renderArrowCurve(curve: SymmetryCurve, color: Color, width = 2, edge?: LineEdge): void;
@@ -2335,13 +2335,13 @@ declare class SymmetryCurveEdgeRenderer extends EdgeRendererClass {
 declare type SyncableKey = "text" | "color" | "details";
 
 declare class SyncAssociation extends Association {
-  uuid: string;
-  keys: SyncableKey[];
-  associationList: StageObject[];
-  get collisionBox(): CollisionBox;
-  get isPhysical(): boolean;
-  _isSelected: boolean;
-  get isSelected(): boolean;
+  uuid: Promise<string>;
+  keys: Promise<SyncableKey>[];
+  associationList: Promise<StageObject>[];
+  get collisionBox(): Promise<CollisionBox>;
+  get isPhysical(): Promise<boolean>;
+  _isSelected: Promise<boolean>;
+  get isSelected(): Promise<boolean>;
   set isSelected(value: boolean);
   constructor(project: Project, {
       uuid = crypto.randomUUID() as string,
@@ -2361,65 +2361,65 @@ declare class Tab extends React.Component<Record<string, never>, Record<string,
   eventEmitter;
   services;
   fileSystemProviders;
-  tickableServices: Service[];
+  tickableServices: Promise<Service>[];
   rafHandle;
-  getComponent(): React.ComponentType;
-  get title(): string;
-  get icon(): React.ComponentType<any> | null;
+  getComponent(): Promise<React.ComponentType>;
+  get title(): Promise<string>;
+  get icon(): Promise<React.ComponentType<any> | null>;
   constructor(props: Record<string, never>);
-  registerFileSystemProvider(scheme: string, provider: { new (...args: any[]): FileSystemProvider });
-  get fs(): FileSystemProvider;
-  on(event: string | symbol, listener: (...args: any[]) => void): this;
-  emit(event: string | symbol, ...args: any[]): boolean;
-  removeAllListeners(event?: string | symbol): this;
-  loadService(service: { id?: string; new (...args: any[]): any });
-  disposeService(serviceId: string);
-  getService<T extends keyof this & string>(serviceId: T): this[T];
+  registerFileSystemProvider(scheme: string, provider: { new (...args: any[]): FileSystemProvider }): Promise<void>;
+  get fs(): Promise<FileSystemProvider>;
+  on(event: string | symbol, listener: (...args: any[]) => void): Promise<this>;
+  emit(event: string | symbol, ...args: any[]): Promise<boolean>;
+  removeAllListeners(event?: string | symbol): Promise<this>;
+  loadService(service: { id?: string; new (...args: any[]): any }): Promise<void>;
+  disposeService(serviceId: string): Promise<void>;
+  getService<T extends keyof this & string>(serviceId: T): Promise<this[T]>;
   init(): Promise<void>;
-  loop();
-  pause();
-  tick();
-  dispose();
-  get isRunning(): boolean;
-  render(): React.ReactNode;
+  loop(): Promise<void>;
+  pause(): Promise<void>;
+  tick(): Promise<void>;
+  dispose(): Promise<void>;
+  get isRunning(): Promise<boolean>;
+  render(): Promise<React.ReactNode>;
 }
 
 declare class TabExporter extends BaseExporter {
-  export(textNode: TextNode): string;
-  getTabText(node: TextNode, level: number): string;
+  export(textNode: TextNode): Promise<string>;
+  getTabText(node: TextNode, level: number): Promise<string>;
 }
 
 declare class TagManager {
   constructor(project: Project);
-  tagSet: Set<string>;
-  reset(uuids: string[]);
-  addTag(uuid: string);
-  removeTag(uuid: string);
-  hasTag(uuid: string): boolean;
-  updateTags();
-  moveUpTag(uuid: string);
-  moveDownTag(uuid: string);
-  changeTagBySelected();
-  refreshTagNamesUI();
-  moveCameraToTag(tagUUID: string);
+  tagSet: Promise<Set<string>>;
+  reset(uuids: string[]): Promise<void>;
+  addTag(uuid: string): Promise<void>;
+  removeTag(uuid: string): Promise<void>;
+  hasTag(uuid: string): Promise<boolean>;
+  updateTags(): Promise<void>;
+  moveUpTag(uuid: string): Promise<void>;
+  moveDownTag(uuid: string): Promise<void>;
+  changeTagBySelected(): Promise<void>;
+  refreshTagNamesUI(): Promise<void>;
+  moveCameraToTag(tagUUID: string): Promise<void>;
 }
 
 declare class TextNode extends ConnectableEntity implements ResizeAble {
-  uuid: string;
-  text: string;
-  collisionBox: CollisionBox;
-  color: Color;
-  isAiGenerating: boolean;
-  fontScaleLevel: number;
+  uuid: Promise<string>;
+  text: Promise<string>;
+  collisionBox: Promise<CollisionBox>;
+  color: Promise<Color>;
+  isAiGenerating: Promise<boolean>;
+  fontScaleLevel: Promise<number>;
   enableResizeCharCount;
-  sizeAdjust: string;
-  _isSelected: boolean;
-  get isSelected(): any;
-  get rectangle(): Rectangle;
-  get geometryCenter(): any;
+  sizeAdjust: Promise<string>;
+  _isSelected: Promise<boolean>;
+  get isSelected(): Promise<any>;
+  get rectangle(): Promise<Rectangle>;
+  get geometryCenter(): Promise<any>;
   set isSelected(value: boolean);
-  _isEditing: boolean;
-  get isEditing(): any;
+  _isEditing: Promise<boolean>;
+  get isEditing(): Promise<any>;
   set isEditing(value: boolean);
   isHiddenBySectionCollapse;
   constructor(project: Project, {
@@ -2439,58 +2439,58 @@ declare class TextNode extends ConnectableEntity implements ResizeAble {
       collisionBox?: CollisionBox;
       fontScaleLevel?: number;
     }, unknown = false);
-  fontSizeCache: number;
-  getFontSize(): number;
-  getPadding(): number;
-  getBorderWidth(): number;
-  getBorderRadius(): number;
+  fontSizeCache: Promise<number>;
+  getFontSize(): Promise<number>;
+  getPadding(): Promise<number>;
+  getBorderWidth(): Promise<number>;
+  getBorderRadius(): Promise<number>;
   updateFontSizeCache(): void;
-  setFontScaleLevel(level: number);
+  setFontScaleLevel(level: number): Promise<void>;
   increaseFontSize(anchorRate?: Vector): void;
   decreaseFontSize(anchorRate?: Vector): void;
   _adjustLocationToKeepAnchor(oldRect: Rectangle, anchorRate: Vector): void;
-  adjustSizeByText();
-  adjustHeightByText();
-  forceAdjustSizeByText();
-  rename(text: string);
-  resizeHandle(delta: Vector);
-  resizeWidthTo(width: number);
-  getResizeHandleRect(): Rectangle;
-  move(delta: Vector);
+  adjustSizeByText(): Promise<void>;
+  adjustHeightByText(): Promise<void>;
+  forceAdjustSizeByText(): Promise<void>;
+  rename(text: string): Promise<void>;
+  resizeHandle(delta: Vector): Promise<void>;
+  resizeWidthTo(width: number): Promise<void>;
+  getResizeHandleRect(): Promise<Rectangle>;
+  move(delta: Vector): Promise<void>;
   collideWithOtherEntity(other: Entity): void;
-  moveTo(location: Vector);
+  moveTo(location: Vector): Promise<void>;
 }
 
 declare class TextNodeRenderer {
   constructor(project: Project);
-  renderTextNode(node: TextNode);
+  renderTextNode(node: TextNode): Promise<void>;
   renderKeyboardTreeHint(node: TextNode): void;
-  renderLogicNodeWarningTrap(node: TextNode);
-  renderTextNodeTextLayer(node: TextNode);
+  renderLogicNodeWarningTrap(node: TextNode): Promise<void>;
+  renderTextNodeTextLayer(node: TextNode): Promise<void>;
 }
 
 declare class TextRenderer {
   cache;
   constructor(project: Project);
-  hash(text: string, size: number): string;
-  getCache(text: string, size: number);
-  getCacheNearestSize(text: string, size: number): ImageBitmap | undefined;
-  buildCache(text: string, size: number, color: Color): CanvasImageSource;
+  hash(text: string, size: number): Promise<string>;
+  getCache(text: string, size: number): Promise<void>;
+  getCacheNearestSize(text: string, size: number): Promise<ImageBitmap | undefined>;
+  buildCache(text: string, size: number, color: Color): Promise<CanvasImageSource>;
   renderText(text: string, location: Vector, size: number, color: Color = Color.White): void;
   renderTempText(text: string, location: Vector, size: number, color: Color = Color.White): void;
   renderTextFromCenter(text: string, centerLocation: Vector, size: number, color: Color = Color.White): void;
   renderTempTextFromCenter(text: string, centerLocation: Vector, size: number, color: Color = Color.White): void;
   renderTextInRectangle(text: string, rectangle: Rectangle, color: Color): void;
-  getFontSizeByRectangleSize(text: string, rectangle: Rectangle): Vector;
+  getFontSizeByRectangleSize(text: string, rectangle: Rectangle): Promise<Vector>;
   renderMultiLineText(text: string, location: Vector, fontSize: number, limitWidth: number, color: Color = Color.White, lineHeight: number = 1.2, limitLines: number = Infinity): void;
   renderTempMultiLineText(text: string, location: Vector, fontSize: number, limitWidth: number, color: Color = Color.White, lineHeight: number = 1.2, limitLines: number = Infinity): void;
   renderMultiLineTextFromCenterWithStroke(text: string, centerLocation: Vector, size: number, fillColor: Color, strokeColor: Color, limitWidth: number = Infinity, lineHeight: number = 1.2): void;
   renderMultiLineTextFromCenter(text: string, centerLocation: Vector, size: number, limitWidth: number, color: Color, lineHeight: number = 1.2, limitLines: number = Infinity): void;
   renderTempMultiLineTextFromCenter(text: string, centerLocation: Vector, size: number, limitWidth: number, color: Color, lineHeight: number = 1.2, limitLines: number = Infinity): void;
-  textArrayCache: LruCache<string, string[]>;
-  textToTextArrayWrapCache(text: string, fontSize: number, limitWidth: number): string[];
-  textToTextArray(text: string, fontSize: number, limitWidth: number): string[];
-  measureMultiLineTextSize(text: string, fontSize: number, limitWidth: number, lineHeight: number = 1.2): Vector;
+  textArrayCache: Promise<LruCache<string, string[]>>;
+  textToTextArrayWrapCache(text: string, fontSize: number, limitWidth: number): Promise<string>[];
+  textToTextArray(text: string, fontSize: number, limitWidth: number): Promise<string>[];
+  measureMultiLineTextSize(text: string, fontSize: number, limitWidth: number, lineHeight: number = 1.2): Promise<Vector>;
 }
 
 declare const transformedKeys;
@@ -2498,42 +2498,42 @@ declare const transformedKeys;
 declare class TreeImporter extends BaseImporter {
   constructor(project: Project);
   import(text: string, indention: number, diffLocation: Vector = Vector.getZero()): void;
-  importFromNode(uuid: string, text: string, indention: number): { success: boolean; error?: string; nodeCount?: number };
-  getIndentLevel(line: string, indention: number): number;
+  importFromNode(uuid: string, text: string, indention: number): Promise<{ success: boolean; error?: string; nodeCount?: number }>;
+  getIndentLevel(line: string, indention: number): Promise<number>;
 }
 
 declare interface UIKeyBind {
-  id: string;
-  key: string;
-  isEnabled: boolean;
-  onPress: (project?: Project) => void;
-  when: KeyBindWhen;
-  icon?: KeyBindIcon;
-  isContinuous?: boolean;
-  onRelease?: (project?: Project) => void;
+  id: Promise<string>;
+  key: Promise<string>;
+  isEnabled: Promise<boolean>;
+  onPress: Promise<(project?: Project) => void>;
+  when: Promise<KeyBindWhen>;
+  icon?: Promise<KeyBindIcon>;
+  isContinuous?: Promise<boolean>;
+  onRelease?: Promise<(project?: Project) => void>;
 }
 
 declare class UrlNode extends ConnectableEntity {
-  uuid: string;
-  title: string;
-  url: string;
-  color: Color;
-  collisionBox: CollisionBox;
-  width: number;
-  height: number;
-  titleHeight: number;
-  _isEditingTitle: boolean;
-  isMouseHoverTitle: boolean;
-  isMouseHoverUrl: boolean;
-  get isEditingTitle(): any;
+  uuid: Promise<string>;
+  title: Promise<string>;
+  url: Promise<string>;
+  color: Promise<Color>;
+  collisionBox: Promise<CollisionBox>;
+  width: Promise<number>;
+  height: Promise<number>;
+  titleHeight: Promise<number>;
+  _isEditingTitle: Promise<boolean>;
+  isMouseHoverTitle: Promise<boolean>;
+  isMouseHoverUrl: Promise<boolean>;
+  get isEditingTitle(): Promise<any>;
   set isEditingTitle(value: boolean);
-  get geometryCenter(): Vector;
-  get titleRectangle(): Rectangle;
-  get urlRectangle(): Rectangle;
-  get rectangle(): Rectangle;
+  get geometryCenter(): Promise<Vector>;
+  get titleRectangle(): Promise<Rectangle>;
+  get urlRectangle(): Promise<Rectangle>;
+  get rectangle(): Promise<Rectangle>;
   move(delta: Vector): void;
   moveTo(location: Vector): void;
-  isHiddenBySectionCollapse: boolean;
+  isHiddenBySectionCollapse: Promise<boolean>;
   constructor(project: Project, {
       uuid = crypto.randomUUID() as string,
       title = "",
@@ -2543,7 +2543,7 @@ declare class UrlNode extends ConnectableEntity {
       color = Color.Transparent,
     });
   rename(title: string): void;
-  adjustSizeByText();
+  adjustSizeByText(): Promise<void>;
 }
 
 declare class UrlNodeRenderer {
@@ -2554,20 +2554,20 @@ declare class UrlNodeRenderer {
 
 declare class VerticalPolyEdgeRenderer extends EdgeRendererClass {
   constructor(project: Project);
-  getCuttingEffects(edge: LineEdge): Effect[];
-  getConnectedEffects(startNode: ConnectableEntity, toNode: ConnectableEntity, sourceRectangleRate?: Vector, targetRectangleRate?: Vector): Effect[];
-  getVerticalDirection(edge: LineEdge): Vector;
-  fixedLength: number;
-  renderTest(edge: LineEdge);
-  gaussianFunction(x: number);
+  getCuttingEffects(edge: LineEdge): Promise<Effect>[];
+  getConnectedEffects(startNode: ConnectableEntity, toNode: ConnectableEntity, sourceRectangleRate?: Vector, targetRectangleRate?: Vector): Promise<Effect>[];
+  getVerticalDirection(edge: LineEdge): Promise<Vector>;
+  fixedLength: Promise<number>;
+  renderTest(edge: LineEdge): Promise<void>;
+  gaussianFunction(x: number): Promise<void>;
   renderNormalState(edge: LineEdge): void;
   renderShiftingState(edge: LineEdge): void;
-  shouldRenderTargetArrow(edge: LineEdge): boolean;
-  renderArrowHead(edge: LineEdge, direction: Vector, endPoint = edge.bodyLine.end.clone());
+  shouldRenderTargetArrow(edge: LineEdge): Promise<boolean>;
+  renderArrowHead(edge: LineEdge, direction: Vector, endPoint = edge.bodyLine.end.clone()): Promise<void>;
   renderCycleState(edge: LineEdge): void;
-  getNormalStageSvg(edge: LineEdge): React.ReactNode;
-  getCycleStageSvg(): React.ReactNode;
-  getShiftingStageSvg(): React.ReactNode;
+  getNormalStageSvg(edge: LineEdge): Promise<React.ReactNode>;
+  getCycleStageSvg(): Promise<React.ReactNode>;
+  getShiftingStageSvg(): Promise<React.ReactNode>;
   renderVirtualEdge(startNode: ConnectableEntity, mouseLocation: Vector, sourceRectangleRate?: Vector): void;
   renderVirtualConfirmedEdge(startNode: ConnectableEntity, endNode: ConnectableEntity, sourceRectangleRate?: Vector, targetRectangleRate?: Vector): void;
 }
@@ -2581,28 +2581,13 @@ declare class WorldRenderUtils {
   renderDoubleSymmetryCurve(curve: SymmetryCurve, color: Color, width: number, gap: number): void;
   renderLaser(start: Vector, end: Vector, width: number, color: Color): void;
   renderPrismaticBlock(centerLocation: Vector, radius: number, color: Color, strokeColor: Color, strokeWidth: number): void;
-  renderRectangleFlash(rectangle: Rectangle, shadowColor: Color, shadowBlur: number, roundedRadius = 0);
+  renderRectangleFlash(rectangle: Rectangle, shadowColor: Color, shadowBlur: number, roundedRadius = 0): Promise<void>;
   renderCuttingFlash(start: Vector, end: Vector, width: number, shadowColor: Color): void;
 }
 
-// ── Asyncify: 递归包裹所有属性和方法返回值为 Promise ──
-// 用于模拟 Comlink 代理的行为，所有值访问都是异步的
-type Asyncify<T> =
-  T extends null | undefined | void | never
-    ? T
-    : T extends (...args: infer A) => infer R
-      ? (...args: A) => Promise<Asyncify<Awaited<R>>>
-      : T extends Promise<unknown>
-        ? T
-        : T extends Array<infer U>
-          ? Promise<Asyncify<U>>[]
-          : T extends object
-            ? { [K in keyof T]: Asyncify<T[K]> }
-            : Promise<T>;
-
 // ── 扩展宿主 API ──
 
-export declare function extensionHostApiFactory(extension: Extension): Asyncify<{
+export declare function extensionHostApiFactory(extension: Extension): {
     toast(message: string): Promise<void>;
     toast_success(message: string): Promise<void>;
     toast_error(message: string): Promise<void>;
@@ -2611,32 +2596,32 @@ export declare function extensionHostApiFactory(extension: Extension): Asyncify<
     dialog_input: typeof Dialog.input;
     dialog_copy: typeof Dialog.copy;
     dialog_buttons: typeof Dialog.buttons;
-    fetch: fetch;
-    fetch_base64(url: string): Promise<string>;
-    fetch_json(url: string): Promise<unknown>;
-    fetch_binary(url: string): Promise<{ buffer: Uint8Array; mimeType: string }>;
-    shell_execute(program: string, args?: string[], stdin?: string): Promise<{ code: number | null; stdout: string; stderr: string }>;
+    fetch: typeof fetch;
+    fetch_base64(url: string): Promise<Promise<string>>;
+    fetch_json(url: string): Promise<Promise<unknown>>;
+    fetch_binary(url: string): Promise<Promise<{ buffer: Uint8Array; mimeType: string }>>;
+    shell_execute(program: string, args?: string[], stdin?: string): Promise<Promise<{ code: number | null; stdout: string; stderr: string }>>;
     settings_getOwn(key: string): Promise<any>;
     settings_setOwn(key: string, value: unknown): Promise<void>;
     settings_getGlobal(key: string): Promise<any>;
     settings_setGlobal(key: string, value: unknown): Promise<any>;
     keybinds_register(id: string, icon: KeyBindIcon, defaultKey: string, onPress: () => void, onRelease?: () => void, isContinuous?: boolean): Promise<void>;
     keybinds_unregisterAll(): Promise<void>;
-    tabs_getAll(): Promise<Tab[]>;
-    tabs_getAllProjects(): Promise<Project[]>;
-    tabs_getCurrent(): Promise<Tab | null>;
-    tabs_getCurrentProject(): Promise<Project | null>;
+    tabs_getAll(): Promise<Promise<Tab>[]>;
+    tabs_getAllProjects(): Promise<Promise<Project>[]>;
+    tabs_getCurrent(): Promise<Promise<Tab | null>>;
+    tabs_getCurrentProject(): Promise<Promise<Project | null>>;
     entity_registerType(typeName: string, initialData: any, collisionBox: CollisionBox, renderFn: (data: any) => Promise<ImageBitmap>): Promise<void>;
     entity_onClick(typeName: string, handler: (payload: ClickEventPayload) => void): Promise<void>;
-    entity_create(typeName: string, data: any, location: { x: number; y: number }): Promise<ExtensionEntity>;
-  }>;
+    entity_create(typeName: string, data: any, location: { x: number; y: number }): Promise<Promise<ExtensionEntity>>;
+  };
 
 declare global {
-  prg: Asyncify<ReturnType<typeof extensionHostApiFactory>>;
+  const prg: ReturnType<typeof extensionHostApiFactory>;
   interface Window {
-    prg: Asyncify<ReturnType<typeof extensionHostApiFactory>>;
+    prg: ReturnType<typeof extensionHostApiFactory>;
   }
   interface DedicatedWorkerGlobalScope {
-    prg: Asyncify<ReturnType<typeof extensionHostApiFactory>>;
+    prg: ReturnType<typeof extensionHostApiFactory>;
   }
 }