@lvce-editor/rpc-registry 5.3.0 → 5.5.0

package/dist/index.d.ts

@@ -3,35 +3,35 @@
 import { RpcId } from '@lvce-editor/constants';
 import { Rpc, MockRpc } from '@lvce-editor/rpc';
 
-declare const invoke: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer: (method: string, ...params: readonly unknown[]) => Promise<any>, set: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose: () => Promise<void>;
-declare const invoke$1: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer$1: (method: string, ...params: readonly unknown[]) => Promise<any>, set$1: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$1: () => Promise<void>;
+declare const dispose: () => Promise<void>, invoke: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer: (method: string, ...params: readonly unknown[]) => Promise<any>, set: (rpc: import("@lvce-editor/rpc").Rpc) => void;
+declare const dispose$1: () => Promise<void>, invoke$1: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer$1: (method: string, ...params: readonly unknown[]) => Promise<any>, set$1: (rpc: import("@lvce-editor/rpc").Rpc) => void;
 declare const writeText: (text: string) => Promise<void>;
 declare const readText: () => Promise<string>;
 declare const writeImage: (image: any) => Promise<void>;
 declare const readNativeFiles: () => Promise<readonly any[]>;
-declare const invoke$2: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer$2: (method: string, ...params: readonly unknown[]) => Promise<any>, set$2: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$2: () => Promise<void>;
+declare const dispose$2: () => Promise<void>, invoke$2: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer$2: (method: string, ...params: readonly unknown[]) => Promise<any>, set$2: (rpc: import("@lvce-editor/rpc").Rpc) => void;
 export interface Range {
-	readonly rowIndex: number;
 	readonly columnIndex: number;
+	readonly rowIndex: number;
 }
 export interface Selection {
-	readonly start: Range;
 	readonly end: Range;
+	readonly start: Range;
 }
 export interface Change {
-	readonly start: Range;
+	readonly deleted: readonly string[];
 	readonly end: Range;
 	readonly inserted: readonly string[];
-	readonly deleted: readonly string[];
 	readonly origin: string;
+	readonly start: Range;
 }
 export interface PositionAtCursor {
+	readonly columnIndex: number;
+	readonly rowIndex: number;
 	readonly x: number;
 	readonly y: number;
-	readonly rowIndex: number;
-	readonly columnIndex: number;
 }
-declare const invoke$3: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer$3: (method: string, ...params: readonly unknown[]) => Promise<any>, set$3: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$3: () => Promise<void>;
+declare const dispose$3: () => Promise<void>, invoke$3: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer$3: (method: string, ...params: readonly unknown[]) => Promise<any>, set$3: (rpc: import("@lvce-editor/rpc").Rpc) => void;
 declare const sendMessagePortToExtensionHostWorker: (port: MessagePort) => Promise<void>;
 declare const activateByEvent: (event: string) => Promise<void>;
 declare const applyEdit: (editorUid: number, changes: readonly Change[]) => Promise<void>;
@@ -49,21 +49,28 @@ declare const getUri: (editorUid: number) => Promise<string>;
 declare const getLanguageId: (editorUid: number) => Promise<string>;
 declare const getProblems: () => Promise<readonly any[]>;
 declare const registerMockRpc: (commandMap: Record<string, any>) => MockRpc;
-declare const invoke$4: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer$4: (method: string, ...params: readonly unknown[]) => Promise<any>, set$4: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$4: () => Promise<void>;
-declare const invoke$5: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer$5: (method: string, ...params: readonly unknown[]) => Promise<any>, set$5: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$5: () => Promise<void>;
+declare const dispose$4: () => Promise<void>, invoke$4: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer$4: (method: string, ...params: readonly unknown[]) => Promise<any>, set$4: (rpc: import("@lvce-editor/rpc").Rpc) => void;
+declare const dispose$5: () => Promise<void>, invoke$5: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer$5: (method: string, ...params: readonly unknown[]) => Promise<any>, set$5: (rpc: import("@lvce-editor/rpc").Rpc) => void;
 export interface RuntimeStatus {
-	readonly id: string;
 	readonly activationEvent: string;
-	readonly status: number;
 	readonly activationTime: number;
+	readonly id: string;
 	readonly importTime: number;
+	readonly status: number;
 }
-declare const invoke$6: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer$6: (method: string, ...params: readonly unknown[]) => Promise<any>, set$6: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$6: () => Promise<void>;
+declare const dispose$6: () => Promise<void>, invoke$6: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer$6: (method: string, ...params: readonly unknown[]) => Promise<any>, set$6: (rpc: import("@lvce-editor/rpc").Rpc) => void;
 declare const executeReferenceProvider: (id: number, offset: number) => Promise<readonly any[]>;
 declare const executeFileReferenceProvider: (id: number) => Promise<readonly any[]>;
 declare const getRuntimeStatus: (extensionId: string) => Promise<RuntimeStatus>;
 declare const registerMockRpc$1: (commandMap: Record<string, any>) => MockRpc;
-declare const invoke$7: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer$7: (method: string, ...params: readonly unknown[]) => Promise<any>, set$7: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$7: () => Promise<void>;
+declare const dispose$7: () => Promise<void>, invoke$7: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer$7: (method: string, ...params: readonly unknown[]) => Promise<any>, set$7: (rpc: import("@lvce-editor/rpc").Rpc) => void;
+declare const registerMockRpc$2: (commandMap: Record<string, any>) => MockRpc;
+declare const enable: (id: string) => Promise<void>;
+declare const disable: (id: string) => Promise<void>;
+declare const getExtension: (id: string) => Promise<any>;
+declare const install: (id: string) => Promise<void>;
+declare const uninstall: (id: string) => Promise<void>;
+declare const dispose$8: () => Promise<void>, invoke$8: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer$8: (method: string, ...params: readonly unknown[]) => Promise<any>, set$8: (rpc: import("@lvce-editor/rpc").Rpc) => void;
 declare const remove: (uri: string) => Promise<void>;
 declare const readFile: (uri: string) => Promise<string>;
 declare const appendFile: (uri: string, text: string) => Promise<string>;
@@ -78,8 +85,8 @@ declare const rename: (oldUri: string, newUri: string) => Promise<void>;
 declare const copy: (oldUri: string, newUri: string) => Promise<void>;
 declare const getFolderSize: (uri: string) => Promise<void>;
 declare const exists: (uri: string) => Promise<boolean>;
-declare const registerMockRpc$2: (commandMap: Record<string, any>) => MockRpc;
-declare const invoke$8: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer$8: (method: string, ...params: readonly unknown[]) => Promise<any>, set$8: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$8: () => Promise<void>;
+declare const registerMockRpc$3: (commandMap: Record<string, any>) => MockRpc;
+declare const dispose$9: () => Promise<void>, invoke$9: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer$9: (method: string, ...params: readonly unknown[]) => Promise<any>, set$9: (rpc: import("@lvce-editor/rpc").Rpc) => void;
 declare const remove$1: (dirent: string) => Promise<void>;
 declare const readDirWithFileTypes$1: (uri: string) => Promise<readonly any[]>;
 declare const getPathSeparator$1: (root: string) => Promise<string>;
@@ -95,25 +102,25 @@ declare const exists$1: (uri: string) => Promise<boolean>;
 declare const getFolderSize$1: (uri: string) => Promise<number>;
 declare const readFileAsBlob: (uri: string) => Promise<Blob>;
 declare const appendFile$1: (uri: string, text: string) => Promise<string>;
-declare const registerMockRpc$3: (commandMap: Record<string, any>) => MockRpc;
-declare const invoke$9: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer$9: (method: string, ...params: readonly unknown[]) => Promise<any>, set$9: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$9: () => Promise<void>;
-declare const getIcons: (iconRequests: readonly any[]) => Promise<readonly any[]>;
 declare const registerMockRpc$4: (commandMap: Record<string, any>) => MockRpc;
+declare const dispose$10: () => Promise<void>, invoke$10: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer$10: (method: string, ...params: readonly unknown[]) => Promise<any>, set$10: (rpc: import("@lvce-editor/rpc").Rpc) => void;
+declare const getIcons: (iconRequests: readonly any[]) => Promise<readonly any[]>;
+declare const registerMockRpc$5: (commandMap: Record<string, any>) => MockRpc;
 declare const NodeWorker = 1;
 declare const NodeForkedProcess = 2;
 declare const ElectronUtilityProcess = 3;
 declare const ElectronMessagePort = 4;
 declare const WebSocket$1 = 6;
-declare const invoke$10: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer$10: (method: string, ...params: readonly unknown[]) => Promise<any>, set$10: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$10: () => Promise<void>;
-declare const invoke$11: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer$11: (method: string, ...params: readonly unknown[]) => Promise<any>, set$11: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$11: () => Promise<void>;
+declare const dispose$11: () => Promise<void>, invoke$11: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer$11: (method: string, ...params: readonly unknown[]) => Promise<any>, set$11: (rpc: import("@lvce-editor/rpc").Rpc) => void;
+declare const dispose$12: () => Promise<void>, invoke$12: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer$12: (method: string, ...params: readonly unknown[]) => Promise<any>, set$12: (rpc: import("@lvce-editor/rpc").Rpc) => void;
 declare const getVirtualDom: (html: string) => Promise<readonly any[]>;
 declare const render: (markdown: string, options?: any) => Promise<string>;
-declare const registerMockRpc$5: (commandMap: Record<string, any>) => MockRpc;
-declare const invoke$12: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer$12: (method: string, ...params: readonly unknown[]) => Promise<any>, set$12: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$12: () => Promise<void>;
+declare const registerMockRpc$6: (commandMap: Record<string, any>) => MockRpc;
+declare const dispose$13: () => Promise<void>, invoke$13: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer$13: (method: string, ...params: readonly unknown[]) => Promise<any>, set$13: (rpc: import("@lvce-editor/rpc").Rpc) => void;
 declare const readClipBoardText: () => Promise<any>;
 declare const readClipBoard: () => Promise<any>;
 declare const writeClipBoard: (options: any) => Promise<void>;
-declare const invoke$13: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer$13: (method: string, ...params: readonly unknown[]) => Promise<any>, set$13: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$13: () => Promise<void>;
+declare const dispose$14: () => Promise<void>, invoke$14: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer$14: (method: string, ...params: readonly unknown[]) => Promise<any>, set$14: (rpc: import("@lvce-editor/rpc").Rpc) => void;
 declare const searchFileHtml: (uri: string) => Promise<readonly string[]>;
 declare const getFilePathElectron: (file: File) => Promise<string>;
 declare const showContextMenu: (x: number, y: number, id: number, ...args: readonly any[]) => Promise<void>;
@@ -167,6 +174,7 @@ declare const sendMessagePortToRendererProcess: (port: MessagePort) => Promise<v
 declare const sendMessagePortToTextMeasurementWorker: (port: MessagePort) => Promise<void>;
 declare const sendMessagePortToSourceControlWorker: (port: MessagePort) => Promise<void>;
 declare const sendMessagePortToFileSystemProcess: (port: MessagePort, rpcId: number) => Promise<void>;
+declare const sendMessagePortToExtensionManagementWorker: (port: MessagePort, rpcId: number) => Promise<void>;
 declare const getPreference: (key: string) => Promise<any>;
 declare const getAllExtensions: () => Promise<readonly any[]>;
 declare const rerenderEditor: (key: string) => Promise<void>;
@@ -179,7 +187,7 @@ declare const getBlob: (uri: string) => Promise<Blob>;
 declare const getExtensionCommands: () => Promise<readonly any[]>;
 declare const showErrorDialog: (errorInfo: any) => Promise<void>;
 declare const getFolderSize$2: (uri: string) => Promise<number>;
-declare const getExtension: (id: string) => Promise<any>;
+declare const getExtension$1: (id: string) => Promise<any>;
 declare const getMarkdownDom: (html: string) => Promise<any>;
 declare const renderMarkdown: (markdown: string, options: any) => Promise<any>;
 declare const openNativeFolder: (uri: string) => Promise<void>;
@@ -193,45 +201,45 @@ declare const getAllPreferences: () => Promise<any>;
 declare const showSaveFilePicker: () => Promise<string>;
 declare const getLogsDir: () => Promise<string>;
 declare const measureTextBlockHeight: (actualInput: string, fontFamily: string, fontSize: number, lineHeightPx: number, width: number) => Promise<number>;
-declare const registerMockRpc$6: (commandMap: Record<string, any>) => MockRpc;
-declare const invoke$14: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer$14: (method: string, ...params: readonly unknown[]) => Promise<any>, set$14: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$14: () => Promise<void>;
 declare const registerMockRpc$7: (commandMap: Record<string, any>) => MockRpc;
-declare const invoke$15: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer$15: (method: string, ...params: readonly unknown[]) => Promise<any>, set$15: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$15: () => Promise<void>;
+declare const dispose$15: () => Promise<void>, invoke$15: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer$15: (method: string, ...params: readonly unknown[]) => Promise<any>, set$15: (rpc: import("@lvce-editor/rpc").Rpc) => void;
 declare const registerMockRpc$8: (commandMap: Record<string, any>) => MockRpc;
+declare const dispose$16: () => Promise<void>, invoke$16: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer$16: (method: string, ...params: readonly unknown[]) => Promise<any>, set$16: (rpc: import("@lvce-editor/rpc").Rpc) => void;
+declare const registerMockRpc$9: (commandMap: Record<string, any>) => MockRpc;
 declare const measureTextWidth: (text: string, fontWeight: number, fontSize: number, fontFamily: string, letterSpacing: number, isMonoSpaceFont: boolean, charWidth: number) => Promise<number>;
-declare const invoke$16: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer$16: (method: string, ...params: readonly unknown[]) => Promise<any>, set$16: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$16: () => Promise<void>;
+declare const dispose$17: () => Promise<void>, invoke$17: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer$17: (method: string, ...params: readonly unknown[]) => Promise<any>, set$17: (rpc: import("@lvce-editor/rpc").Rpc) => void;
 declare const search: (options: any) => Promise<any>;
 declare const searchIncremental: (options: any) => Promise<any>;
 declare const getIncrementalResults: (searchId: string, minLineY: number, maxLineY: number) => Promise<any>;
-declare const invoke$17: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer$17: (method: string, ...params: readonly unknown[]) => Promise<any>, set$17: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$17: () => Promise<void>;
-declare const invoke$18: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer$18: (method: string, ...params: readonly unknown[]) => Promise<any>, set$18: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$18: () => Promise<void>;
+declare const dispose$18: () => Promise<void>, invoke$18: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer$18: (method: string, ...params: readonly unknown[]) => Promise<any>, set$18: (rpc: import("@lvce-editor/rpc").Rpc) => void;
+declare const dispose$19: () => Promise<void>, invoke$19: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer$19: (method: string, ...params: readonly unknown[]) => Promise<any>, set$19: (rpc: import("@lvce-editor/rpc").Rpc) => void;
 export interface LazyRpc {
-	readonly setFactory: (value: () => Promise<Rpc>) => void;
 	readonly invoke: (method: string, ...params: readonly any[]) => Promise<any>;
+	readonly setFactory: (value: () => Promise<Rpc>) => void;
 }
 export declare const createLazyRpc: (rpcId: number) => LazyRpc;
 export declare const getIpcType: (argv: readonly string[]) => number;
-declare const registerMockRpc$9: (rpcId: number, commandMap: Record<string, any>) => MockRpc;
-declare const set$19: (id: number, rpc: Rpc) => void;
+declare const registerMockRpc$10: (rpcId: number, commandMap: Record<string, any>) => MockRpc;
+declare const set$20: (id: number, rpc: Rpc) => void;
 export declare const get: (id: number) => Rpc;
 declare const remove$2: (id: number) => void;
 export interface SearchResult {
-	readonly type: number;
-	readonly start: number;
 	readonly end: number;
 	readonly lineNumber: number;
+	readonly start: number;
 	readonly text: string;
+	readonly type: number;
 }
 export interface TextEdit {
-	readonly text: string;
-	readonly startRowIndex: number;
-	readonly startColumnIndex: number;
 	readonly endColumnIndex: number;
 	readonly endRowIndex: number;
+	readonly startColumnIndex: number;
+	readonly startRowIndex: number;
+	readonly text: string;
 }
 
 declare namespace SyntaxHighlightingWorker {
-	export { dispose$18 as dispose, invoke$18 as invoke, invokeAndTransfer$18 as invokeAndTransfer, set$18 as set };
+	export { dispose$19 as dispose, invoke$19 as invoke, invokeAndTransfer$19 as invokeAndTransfer, set$19 as set };
 }
 declare namespace ClipBoardProcess {
 	export { dispose, invoke, invokeAndTransfer, set };
@@ -254,41 +262,44 @@ declare namespace ErrorWorker {
 declare namespace ExtensionHost {
 	export { dispose$6 as dispose, executeFileReferenceProvider, executeReferenceProvider, getRuntimeStatus, invoke$6 as invoke, invokeAndTransfer$6 as invokeAndTransfer, registerMockRpc$1 as registerMockRpc, set$6 as set };
 }
+declare namespace ExtensionManagementWorker {
+	export { disable, dispose$7 as dispose, enable, getExtension, install, invoke$7 as invoke, invokeAndTransfer$7 as invokeAndTransfer, registerMockRpc$2 as registerMockRpc, set$7 as set, uninstall };
+}
 declare namespace FileSystemProcess {
-	export { appendFile, copy, dispose$7 as dispose, exists, getFolderSize, getPathSeparator, getRealPath, invoke$7 as invoke, invokeAndTransfer$7 as invokeAndTransfer, mkdir, readDirWithFileTypes, readFile, readJson, registerMockRpc$2 as registerMockRpc, remove, rename, set$7 as set, stat, writeFile };
+	export { appendFile, copy, dispose$8 as dispose, exists, getFolderSize, getPathSeparator, getRealPath, invoke$8 as invoke, invokeAndTransfer$8 as invokeAndTransfer, mkdir, readDirWithFileTypes, readFile, readJson, registerMockRpc$3 as registerMockRpc, remove, rename, set$8 as set, stat, writeFile };
 }
 declare namespace FileSystemWorker {
-	export { appendFile$1 as appendFile, copy$1 as copy, createFile, dispose$8 as dispose, exists$1 as exists, getFolderSize$1 as getFolderSize, getPathSeparator$1 as getPathSeparator, getRealPath$1 as getRealPath, invoke$8 as invoke, invokeAndTransfer$8 as invokeAndTransfer, mkdir$1 as mkdir, readDirWithFileTypes$1 as readDirWithFileTypes, readFile$1 as readFile, readFileAsBlob, registerMockRpc$3 as registerMockRpc, remove$1 as remove, rename$1 as rename, set$8 as set, stat$1 as stat, writeFile$1 as writeFile };
+	export { appendFile$1 as appendFile, copy$1 as copy, createFile, dispose$9 as dispose, exists$1 as exists, getFolderSize$1 as getFolderSize, getPathSeparator$1 as getPathSeparator, getRealPath$1 as getRealPath, invoke$9 as invoke, invokeAndTransfer$9 as invokeAndTransfer, mkdir$1 as mkdir, readDirWithFileTypes$1 as readDirWithFileTypes, readFile$1 as readFile, readFileAsBlob, registerMockRpc$4 as registerMockRpc, remove$1 as remove, rename$1 as rename, set$9 as set, stat$1 as stat, writeFile$1 as writeFile };
 }
 declare namespace IconThemeWorker {
-	export { dispose$9 as dispose, getIcons, invoke$9 as invoke, invokeAndTransfer$9 as invokeAndTransfer, registerMockRpc$4 as registerMockRpc, set$9 as set };
+	export { dispose$10 as dispose, getIcons, invoke$10 as invoke, invokeAndTransfer$10 as invokeAndTransfer, registerMockRpc$5 as registerMockRpc, set$10 as set };
 }
 declare namespace IpcType {
 	export { ElectronMessagePort, ElectronUtilityProcess, NodeForkedProcess, NodeWorker, WebSocket$1 as WebSocket };
 }
 declare namespace MainProcess {
-	export { dispose$10 as dispose, invoke$10 as invoke, invokeAndTransfer$10 as invokeAndTransfer, set$10 as set };
+	export { dispose$11 as dispose, invoke$11 as invoke, invokeAndTransfer$11 as invokeAndTransfer, set$11 as set };
 }
 declare namespace MarkdownWorker {
-	export { dispose$11 as dispose, getVirtualDom, invoke$11 as invoke, invokeAndTransfer$11 as invokeAndTransfer, registerMockRpc$5 as registerMockRpc, render, set$11 as set };
+	export { dispose$12 as dispose, getVirtualDom, invoke$12 as invoke, invokeAndTransfer$12 as invokeAndTransfer, registerMockRpc$6 as registerMockRpc, render, set$12 as set };
 }
 declare namespace RendererProcess {
-	export { dispose$12 as dispose, invoke$12 as invoke, invokeAndTransfer$12 as invokeAndTransfer, readClipBoard, readClipBoardText, set$12 as set, writeClipBoard };
+	export { dispose$13 as dispose, invoke$13 as invoke, invokeAndTransfer$13 as invokeAndTransfer, readClipBoard, readClipBoardText, set$13 as set, writeClipBoard };
 }
 declare namespace RendererWorker {
-	export { activateByEvent$1 as activateByEvent, applyBulkReplacement, closeWidget$1 as closeWidget, confirm, disableExtension, dispose$13 as dispose, enableExtension, getActiveEditorId, getAllExtensions, getAllPreferences, getBlob, getChromeVersion, getColorThemeNames, getElectronVersion, getExtension, getExtensionCommands, getFileHandles, getFileIcon, getFilePathElectron, getFolderIcon, getFolderSize$2 as getFolderSize, getIcons$1 as getIcons, getKeyBindings, getLogsDir, getMarkdownDom, getNodeVersion, getPreference, getRecentlyOpened, getV8Version, getWebViewSecret, getWindowId, getWorkspacePath, handleDebugChange, handleDebugPaused, handleDebugResumed, handleDebugScriptParsed, handleWorkspaceRefresh, installExtension, invoke$13 as invoke, invokeAndTransfer$13 as invokeAndTransfer, measureTextBlockHeight, openExtensionSearch, openExternal, openNativeFolder, openUri, openUrl, openWidget, readClipBoardText$1 as readClipBoardText, readFile$2 as readFile, registerMockRpc$6 as registerMockRpc, registerWebViewInterceptor, renderMarkdown, rerenderEditor, searchFileFetch, searchFileHtml, searchFileMemory, sendMessagePortToEditorWorker, sendMessagePortToErrorWorker, sendMessagePortToExtensionHostWorker$1 as sendMessagePortToExtensionHostWorker, sendMessagePortToFileSystemProcess, sendMessagePortToFileSystemWorker, sendMessagePortToIconThemeWorker, sendMessagePortToMarkdownWorker, sendMessagePortToRendererProcess, sendMessagePortToSearchProcess, sendMessagePortToSourceControlWorker, sendMessagePortToSyntaxHighlightingWorker, sendMessagePortToTextMeasurementWorker, set$13 as set, setAdditionalFocus, setColorTheme, setExtensionsSearchValue, setFocus, setWebViewPort, setWorkspacePath, showContextMenu, showContextMenu2, showErrorDialog, showMessageBox, showSaveFilePicker, uninstallExtension, unregisterWebViewInterceptor, writeClipBoardImage, writeClipBoardText };
+	export { activateByEvent$1 as activateByEvent, applyBulkReplacement, closeWidget$1 as closeWidget, confirm, disableExtension, dispose$14 as dispose, enableExtension, getActiveEditorId, getAllExtensions, getAllPreferences, getBlob, getChromeVersion, getColorThemeNames, getElectronVersion, getExtension$1 as getExtension, getExtensionCommands, getFileHandles, getFileIcon, getFilePathElectron, getFolderIcon, getFolderSize$2 as getFolderSize, getIcons$1 as getIcons, getKeyBindings, getLogsDir, getMarkdownDom, getNodeVersion, getPreference, getRecentlyOpened, getV8Version, getWebViewSecret, getWindowId, getWorkspacePath, handleDebugChange, handleDebugPaused, handleDebugResumed, handleDebugScriptParsed, handleWorkspaceRefresh, installExtension, invoke$14 as invoke, invokeAndTransfer$14 as invokeAndTransfer, measureTextBlockHeight, openExtensionSearch, openExternal, openNativeFolder, openUri, openUrl, openWidget, readClipBoardText$1 as readClipBoardText, readFile$2 as readFile, registerMockRpc$7 as registerMockRpc, registerWebViewInterceptor, renderMarkdown, rerenderEditor, searchFileFetch, searchFileHtml, searchFileMemory, sendMessagePortToEditorWorker, sendMessagePortToErrorWorker, sendMessagePortToExtensionHostWorker$1 as sendMessagePortToExtensionHostWorker, sendMessagePortToExtensionManagementWorker, sendMessagePortToFileSystemProcess, sendMessagePortToFileSystemWorker, sendMessagePortToIconThemeWorker, sendMessagePortToMarkdownWorker, sendMessagePortToRendererProcess, sendMessagePortToSearchProcess, sendMessagePortToSourceControlWorker, sendMessagePortToSyntaxHighlightingWorker, sendMessagePortToTextMeasurementWorker, set$14 as set, setAdditionalFocus, setColorTheme, setExtensionsSearchValue, setFocus, setWebViewPort, setWorkspacePath, showContextMenu, showContextMenu2, showErrorDialog, showMessageBox, showSaveFilePicker, uninstallExtension, unregisterWebViewInterceptor, writeClipBoardImage, writeClipBoardText };
 }
 declare namespace SourceControlWorker {
-	export { dispose$14 as dispose, invoke$14 as invoke, invokeAndTransfer$14 as invokeAndTransfer, registerMockRpc$7 as registerMockRpc, set$14 as set };
+	export { dispose$15 as dispose, invoke$15 as invoke, invokeAndTransfer$15 as invokeAndTransfer, registerMockRpc$8 as registerMockRpc, set$15 as set };
 }
 declare namespace TextMeasurementWorker {
-	export { dispose$15 as dispose, invoke$15 as invoke, invokeAndTransfer$15 as invokeAndTransfer, measureTextWidth, registerMockRpc$8 as registerMockRpc, set$15 as set };
+	export { dispose$16 as dispose, invoke$16 as invoke, invokeAndTransfer$16 as invokeAndTransfer, measureTextWidth, registerMockRpc$9 as registerMockRpc, set$16 as set };
 }
 declare namespace SearchProcess {
-	export { dispose$16 as dispose, getIncrementalResults, invoke$16 as invoke, invokeAndTransfer$16 as invokeAndTransfer, search, searchIncremental, set$16 as set };
+	export { dispose$17 as dispose, getIncrementalResults, invoke$17 as invoke, invokeAndTransfer$17 as invokeAndTransfer, search, searchIncremental, set$17 as set };
 }
 declare namespace SharedProcess {
-	export { dispose$17 as dispose, invoke$17 as invoke, invokeAndTransfer$17 as invokeAndTransfer, set$17 as set };
+	export { dispose$18 as dispose, invoke$18 as invoke, invokeAndTransfer$18 as invokeAndTransfer, set$18 as set };
 }
 
 export {
@@ -299,6 +310,7 @@ export {
 	EmbedsProcess,
 	ErrorWorker,
 	ExtensionHost,
+	ExtensionManagementWorker,
 	FileSystemProcess,
 	FileSystemWorker,
 	IconThemeWorker,
@@ -315,9 +327,9 @@ export {
 	SourceControlWorker,
 	SyntaxHighlightingWorker,
 	TextMeasurementWorker,
-	registerMockRpc$9 as registerMockRpc,
+	registerMockRpc$10 as registerMockRpc,
 	remove$2 as remove,
-	set$19 as set,
+	set$20 as set,
 };
 
 export {};

package/dist/parts/ClipBoardProcess/ClipBoardProcess.js

@@ -1,3 +1,3 @@
 import { RpcId } from '@lvce-editor/constants';
 import * as RpcFactory from "../RpcFactory/RpcFactory.js";
-export const { invoke, invokeAndTransfer, set, dispose } = RpcFactory.create(RpcId.ClipBoardProcess);
+export const { dispose, invoke, invokeAndTransfer, set } = RpcFactory.create(RpcId.ClipBoardProcess);

package/dist/parts/ClipBoardWorker/ClipBoardWorker.js

@@ -1,6 +1,6 @@
 import { RpcId } from '@lvce-editor/constants';
 import * as RpcFactory from "../RpcFactory/RpcFactory.js";
-export const { invoke, invokeAndTransfer, set, dispose } = RpcFactory.create(RpcId.ClipBoardWorker);
+export const { dispose, invoke, invokeAndTransfer, set } = RpcFactory.create(RpcId.ClipBoardWorker);
 export const writeText = async (text) => {
     // @ts-ignore
     return invoke('ClipBoard.writeText', text);

package/dist/parts/CreateLazyRpc/CreateLazyRpc.js

@@ -13,13 +13,13 @@ export const createLazyRpc = (rpcId) => {
         await rpcPromise;
     };
     return {
-        setFactory(value) {
-            factory = value;
-        },
         async invoke(method, ...params) {
             await ensureRpc();
             const rpc = RpcRegistry.get(rpcId);
             return rpc.invoke(method, ...params);
         },
+        setFactory(value) {
+            factory = value;
+        },
     };
 };

package/dist/parts/DebugWorker/DebugWorker.js

@@ -1,3 +1,3 @@
 import { RpcId } from '@lvce-editor/constants';
 import * as RpcFactory from "../RpcFactory/RpcFactory.js";
-export const { invoke, invokeAndTransfer, set, dispose } = RpcFactory.create(RpcId.DebugWorker);
+export const { dispose, invoke, invokeAndTransfer, set } = RpcFactory.create(RpcId.DebugWorker);

package/dist/parts/EditorWorker/EditorWorker.js

@@ -1,7 +1,7 @@
 import { RpcId } from '@lvce-editor/constants';
 import { createMockRpc } from '@lvce-editor/rpc';
 import * as RpcFactory from "../RpcFactory/RpcFactory.js";
-export const { invoke, invokeAndTransfer, set, dispose } = RpcFactory.create(RpcId.EditorWorker);
+export const { dispose, invoke, invokeAndTransfer, set } = RpcFactory.create(RpcId.EditorWorker);
 export const sendMessagePortToExtensionHostWorker = async (port) => {
     const command = 'HandleMessagePort.handleMessagePort2';
     await invokeAndTransfer(

package/dist/parts/EmbedsProcess/EmbedsProcess.js

@@ -1,3 +1,3 @@
 import { RpcId } from '@lvce-editor/constants';
 import * as RpcFactory from "../RpcFactory/RpcFactory.js";
-export const { invoke, invokeAndTransfer, set, dispose } = RpcFactory.create(RpcId.EmbedsProcess);
+export const { dispose, invoke, invokeAndTransfer, set } = RpcFactory.create(RpcId.EmbedsProcess);

package/dist/parts/ErrorWorker/ErrorWorker.js

@@ -1,3 +1,3 @@
 import { RpcId } from '@lvce-editor/constants';
 import * as RpcFactory from "../RpcFactory/RpcFactory.js";
-export const { invoke, invokeAndTransfer, set, dispose } = RpcFactory.create(RpcId.ErrorWorker);
+export const { dispose, invoke, invokeAndTransfer, set } = RpcFactory.create(RpcId.ErrorWorker);

package/dist/parts/ExtensionHost/ExtensionHost.js

@@ -1,7 +1,7 @@
 import { RpcId } from '@lvce-editor/constants';
 import { createMockRpc } from '@lvce-editor/rpc';
 import * as RpcFactory from "../RpcFactory/RpcFactory.js";
-export const { invoke, invokeAndTransfer, set, dispose } = RpcFactory.create(RpcId.ExtensionHostWorker);
+export const { dispose, invoke, invokeAndTransfer, set } = RpcFactory.create(RpcId.ExtensionHostWorker);
 export const executeReferenceProvider = async (id, offset) => {
     // @ts-ignore
     return invoke('ExtensionHostReference.executeReferenceProvider', id, offset);

package/dist/parts/ExtensionManagementWorker/ExtensionManagementWorker.js

@@ -0,0 +1,24 @@
+import { createMockRpc } from '@lvce-editor/rpc';
+import * as RpcFactory from "../RpcFactory/RpcFactory.js";
+const id = 9006;
+export const { dispose, invoke, invokeAndTransfer, set } = RpcFactory.create(id);
+export const registerMockRpc = (commandMap) => {
+    const mockRpc = createMockRpc({ commandMap });
+    set(mockRpc);
+    return mockRpc;
+};
+export const enable = (id) => {
+    return invoke(`Extensions.enable`, id);
+};
+export const disable = (id) => {
+    return invoke(`Extensions.disable`, id);
+};
+export const getExtension = (id) => {
+    return invoke(`Extensions.getExtension`, id);
+};
+export const install = (id) => {
+    return invoke(`Extensions.install`, id);
+};
+export const uninstall = (id) => {
+    return invoke(`Extensions.uninstall`, id);
+};

package/dist/parts/FileSystemProcess/FileSystemProcess.js

@@ -1,7 +1,7 @@
 import { RpcId } from '@lvce-editor/constants';
 import { createMockRpc } from '@lvce-editor/rpc';
 import * as RpcFactory from "../RpcFactory/RpcFactory.js";
-export const { invoke, invokeAndTransfer, set, dispose } = RpcFactory.create(RpcId.FileSystemProcess);
+export const { dispose, invoke, invokeAndTransfer, set } = RpcFactory.create(RpcId.FileSystemProcess);
 export const remove = async (uri) => {
     return invoke('FileSystem.remove', uri);
 };

package/dist/parts/FileSystemWorker/FileSystemWorker.js

@@ -1,7 +1,7 @@
 import { RpcId } from '@lvce-editor/constants';
 import { createMockRpc } from '@lvce-editor/rpc';
 import * as RpcFactory from "../RpcFactory/RpcFactory.js";
-export const { invoke, invokeAndTransfer, set, dispose } = RpcFactory.create(RpcId.FileSystemWorker);
+export const { dispose, invoke, invokeAndTransfer, set } = RpcFactory.create(RpcId.FileSystemWorker);
 export const remove = async (dirent) => {
     return invoke('FileSystem.remove', dirent);
 };

package/dist/parts/IconThemeWorker/IconThemeWorker.js

@@ -1,7 +1,7 @@
 import { RpcId } from '@lvce-editor/constants';
 import { createMockRpc } from '@lvce-editor/rpc';
 import * as RpcFactory from "../RpcFactory/RpcFactory.js";
-export const { invoke, invokeAndTransfer, set, dispose } = RpcFactory.create(RpcId.IconThemeWorker);
+export const { dispose, invoke, invokeAndTransfer, set } = RpcFactory.create(RpcId.IconThemeWorker);
 export const getIcons = async (iconRequests) => {
     // @ts-ignore
     return invoke('IconTheme.getIcons', iconRequests);

package/dist/parts/Main/Main.js

@@ -5,6 +5,7 @@ export * as EditorWorker from "../EditorWorker/EditorWorker.js";
 export * as EmbedsProcess from "../EmbedsProcess/EmbedsProcess.js";
 export * as ErrorWorker from "../ErrorWorker/ErrorWorker.js";
 export * as ExtensionHost from "../ExtensionHost/ExtensionHost.js";
+export * as ExtensionManagementWorker from "../ExtensionManagementWorker/ExtensionManagementWorker.js";
 export * as FileSystemProcess from "../FileSystemProcess/FileSystemProcess.js";
 export * as FileSystemWorker from "../FileSystemWorker/FileSystemWorker.js";
 export * as IconThemeWorker from "../IconThemeWorker/IconThemeWorker.js";

package/dist/parts/MainProcess/MainProcess.js

@@ -1,3 +1,3 @@
 import { RpcId } from '@lvce-editor/constants';
 import * as RpcFactory from "../RpcFactory/RpcFactory.js";
-export const { invoke, invokeAndTransfer, set, dispose } = RpcFactory.create(RpcId.MainProcess);
+export const { dispose, invoke, invokeAndTransfer, set } = RpcFactory.create(RpcId.MainProcess);

package/dist/parts/MarkdownWorker/MarkdownWorker.js

@@ -1,7 +1,7 @@
 import { RpcId } from '@lvce-editor/constants';
 import { createMockRpc } from '@lvce-editor/rpc';
 import * as RpcFactory from "../RpcFactory/RpcFactory.js";
-export const { invoke, invokeAndTransfer, set, dispose } = RpcFactory.create(RpcId.MarkdownWorker);
+export const { dispose, invoke, invokeAndTransfer, set } = RpcFactory.create(RpcId.MarkdownWorker);
 export const getVirtualDom = async (html) => {
     // @ts-ignore
     return invoke('Markdown.getVirtualDom', html);

package/dist/parts/RendererProcess/RendererProcess.js

@@ -1,6 +1,6 @@
 import { RpcId } from '@lvce-editor/constants';
 import * as RpcFactory from "../RpcFactory/RpcFactory.js";
-export const { invoke, invokeAndTransfer, set, dispose } = RpcFactory.create(RpcId.RendererProcess);
+export const { dispose, invoke, invokeAndTransfer, set } = RpcFactory.create(RpcId.RendererProcess);
 export const readClipBoardText = async () => {
     // @ts-ignore
     return await invoke('ClipBoard.readText');

package/dist/parts/RendererWorker/RendererWorker.js

@@ -2,7 +2,7 @@ import * as Assert from '@lvce-editor/assert';
 import { InputSource, RpcId } from '@lvce-editor/constants';
 import { createMockRpc } from '@lvce-editor/rpc';
 import * as RpcFactory from "../RpcFactory/RpcFactory.js";
-export const { invoke, invokeAndTransfer, set, dispose } = RpcFactory.create(RpcId.RendererWorker);
+export const { dispose, invoke, invokeAndTransfer, set } = RpcFactory.create(RpcId.RendererWorker);
 export const searchFileHtml = async (uri) => {
     return invoke('ExtensionHost.searchFileWithHtml', uri);
 };
@@ -201,6 +201,10 @@ export const sendMessagePortToFileSystemProcess = async (port, rpcId) => {
     const command = 'HandleMessagePortForFileSystemProcess.handleMessagePortForFileSystemProcess';
     await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess', port, command, rpcId);
 };
+export const sendMessagePortToExtensionManagementWorker = async (port, rpcId) => {
+    const command = 'ExtensionManagement.handleMessagePort';
+    await invokeAndTransfer('SendMessagePortToExtensionHostWorker.SendMessagePortToExtensionManagementWorker', port, command, rpcId);
+};
 export const getPreference = async (key) => {
     return await invoke('Preferences.get', key);
 };

package/dist/parts/RpcFactory/RpcFactory.js

@@ -1,6 +1,10 @@
 import * as RpcRegistry from "../RpcRegistry/RpcRegistry.js";
 export const create = (rpcId) => {
     return {
+        async dispose() {
+            const rpc = RpcRegistry.get(rpcId);
+            await rpc.dispose();
+        },
         // @ts-ignore
         invoke(method, ...params) {
             const rpc = RpcRegistry.get(rpcId);
@@ -16,9 +20,5 @@ export const create = (rpcId) => {
         set(rpc) {
             RpcRegistry.set(rpcId, rpc);
         },
-        async dispose() {
-            const rpc = RpcRegistry.get(rpcId);
-            await rpc.dispose();
-        },
     };
 };

package/dist/parts/SearchProcess/SearchProcess.js

@@ -1,6 +1,6 @@
 import { RpcId } from '@lvce-editor/constants';
 import * as RpcFactory from "../RpcFactory/RpcFactory.js";
-export const { invoke, invokeAndTransfer, set, dispose } = RpcFactory.create(RpcId.SearchProcess);
+export const { dispose, invoke, invokeAndTransfer, set } = RpcFactory.create(RpcId.SearchProcess);
 // TODO add tests for this
 export const search = async (options) => {
     const result = await invoke('TextSearch.search', options);

package/dist/parts/SharedProcess/SharedProcess.js

@@ -1,3 +1,3 @@
 import { RpcId } from '@lvce-editor/constants';
 import * as RpcFactory from "../RpcFactory/RpcFactory.js";
-export const { invoke, invokeAndTransfer, set, dispose } = RpcFactory.create(RpcId.SharedProcess);
+export const { dispose, invoke, invokeAndTransfer, set } = RpcFactory.create(RpcId.SharedProcess);

package/dist/parts/SourceControlWorker/SourceControlWorker.js

@@ -1,7 +1,7 @@
 import { RpcId } from '@lvce-editor/constants';
 import { createMockRpc } from '@lvce-editor/rpc';
 import * as RpcFactory from "../RpcFactory/RpcFactory.js";
-export const { invoke, invokeAndTransfer, set, dispose } = RpcFactory.create(RpcId.SourceControlWorker);
+export const { dispose, invoke, invokeAndTransfer, set } = RpcFactory.create(RpcId.SourceControlWorker);
 export const registerMockRpc = (commandMap) => {
     const mockRpc = createMockRpc({ commandMap });
     set(mockRpc);

package/dist/parts/SyntaxHighlightingWorker/SyntaxHighlightingWorker.js

@@ -1,3 +1,3 @@
 import { RpcId } from '@lvce-editor/constants';
 import * as RpcFactory from "../RpcFactory/RpcFactory.js";
-export const { invoke, invokeAndTransfer, set, dispose } = RpcFactory.create(RpcId.MarkdownWorker);
+export const { dispose, invoke, invokeAndTransfer, set } = RpcFactory.create(RpcId.MarkdownWorker);

package/dist/parts/TextMeasurementWorker/TextMeasurementWorker.js

@@ -1,7 +1,7 @@
 import { RpcId } from '@lvce-editor/constants';
 import { createMockRpc } from '@lvce-editor/rpc';
 import * as RpcFactory from "../RpcFactory/RpcFactory.js";
-export const { invoke, invokeAndTransfer, set, dispose } = RpcFactory.create(RpcId.IconThemeWorker);
+export const { dispose, invoke, invokeAndTransfer, set } = RpcFactory.create(RpcId.IconThemeWorker);
 export const registerMockRpc = (commandMap) => {
     const mockRpc = createMockRpc({ commandMap });
     set(mockRpc);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/rpc-registry",
-  "version": "5.3.0",
+  "version": "5.5.0",
   "description": "Rpc Registry",
   "repository": {
     "type": "git",
@@ -13,7 +13,7 @@
   "main": "dist/index.js",
   "dependencies": {
     "@lvce-editor/assert": "^1.4.0",
-    "@lvce-editor/constants": "^1.40.0",
+    "@lvce-editor/constants": "^1.43.0",
     "@lvce-editor/rpc": "^4.20.0"
   },
   "types": "dist/index.d.ts"