@elementor/editor-canvas 4.2.0-beta2 → 4.3.0-1001

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@elementor/editor-canvas",
   "description": "Elementor Editor Canvas",
-  "version": "4.2.0-beta2",
+  "version": "4.3.0-1001",
   "private": false,
   "author": "Elementor Team",
   "homepage": "https://elementor.com/",
@@ -37,29 +37,29 @@
     "react-dom": "^18.3.1"
   },
   "dependencies": {
-    "@elementor/editor": "4.2.0-beta2",
-    "dompurify": "^3.2.6",
-    "@elementor/editor-controls": "4.2.0-beta2",
-    "@elementor/editor-documents": "4.2.0-beta2",
-    "@elementor/editor-elements": "4.2.0-beta2",
-    "@elementor/editor-interactions": "4.2.0-beta2",
-    "@elementor/editor-mcp": "4.2.0-beta2",
-    "@elementor/editor-notifications": "4.2.0-beta2",
-    "@elementor/editor-props": "4.2.0-beta2",
-    "@elementor/editor-responsive": "4.2.0-beta2",
-    "@elementor/editor-styles": "4.2.0-beta2",
-    "@elementor/editor-styles-repository": "4.2.0-beta2",
-    "@elementor/editor-ui": "4.2.0-beta2",
-    "@elementor/editor-v1-adapters": "4.2.0-beta2",
-    "@elementor/events": "4.2.0-beta2",
-    "@elementor/http-client": "4.2.0-beta2",
-    "@elementor/schema": "4.2.0-beta2",
-    "@elementor/twing": "4.2.0-beta2",
+    "@elementor/editor": "4.3.0-1001",
+    "@elementor/editor-controls": "4.3.0-1001",
+    "@elementor/editor-documents": "4.3.0-1001",
+    "@elementor/editor-elements": "4.3.0-1001",
+    "@elementor/editor-interactions": "4.3.0-1001",
+    "@elementor/editor-mcp": "4.3.0-1001",
+    "@elementor/editor-notifications": "4.3.0-1001",
+    "@elementor/editor-props": "4.3.0-1001",
+    "@elementor/editor-responsive": "4.3.0-1001",
+    "@elementor/editor-styles": "4.3.0-1001",
+    "@elementor/editor-styles-repository": "4.3.0-1001",
+    "@elementor/editor-ui": "4.3.0-1001",
+    "@elementor/editor-v1-adapters": "4.3.0-1001",
+    "@elementor/events": "4.3.0-1001",
+    "@elementor/http-client": "4.3.0-1001",
+    "@elementor/schema": "4.3.0-1001",
+    "@elementor/twing": "4.3.0-1001",
     "@elementor/ui": "1.37.5",
-    "@elementor/utils": "4.2.0-beta2",
-    "@elementor/wp-media": "4.2.0-beta2",
+    "@elementor/utils": "4.3.0-1001",
+    "@elementor/wp-media": "4.3.0-1001",
     "@floating-ui/react": "^0.27.5",
-    "@wordpress/i18n": "^5.13.0"
+    "@wordpress/i18n": "^5.13.0",
+    "dompurify": "^3.2.6"
   },
   "devDependencies": {
     "tsup": "^8.3.5"

package/src/index.ts

@@ -44,4 +44,4 @@ export { UnknownStyleTypeError, UnknownStyleStateError } from './renderers/error
 export { useCanvasDocument } from './hooks/use-canvas-document';
 export { useEscapeOnCanvas } from './hooks/use-escape-on-canvas';
 export { doAfterRender } from './utils/after-render';
-export { ELEMENT_ADDED_EVENT, type ElementAddedEvent } from './mcp/tools/build-composition/tool';
+export { ELEMENT_ADDED_EVENT, type ElementAddedEvent } from './sync/element-added-event';

package/src/legacy/__tests__/init-legacy-views.test.ts

@@ -45,7 +45,7 @@ describe( 'initLegacyViews', () => {
 		mockLegacyElementor();
 	} );
 
-	it( 'should register a late element type via the legacy manager without leaking the state', () => {
+	it( 'should register a late element type via the legacy manager without leaking state', () => {
 		// Arrange
 		const elementsManager = createMockElementsManager();
 		attachMockElementsManager( elementsManager );

package/src/mcp/canvas-mcp.ts

@@ -2,6 +2,7 @@ import { type MCPRegistryEntry } from '@elementor/editor-mcp';
 import { Schema } from '@elementor/editor-props';
 
 import { initAvailableWidgetsResource } from './resources/available-widgets-resource';
+import { initBestPracticesResource } from './resources/best-practices-resource';
 import { initBreakpointsResource } from './resources/breakpoints-resource';
 import { initDocumentStructureResource } from './resources/document-structure-resource';
 import { initDynamicTagsResource } from './resources/dynamic-tags-resource';
@@ -9,7 +10,7 @@ import { initEditorStateResource } from './resources/editor-state-resource';
 import { initGeneralContextResource } from './resources/general-context-resource';
 import { initSelectedElementResource } from './resources/selected-element-resource';
 import { initWidgetsSchemaResource } from './resources/widgets-schema-resource';
-import { initBuildCompositionsTool } from './tools/build-composition/tool';
+import { initBuildCompositionTool } from './tools/build-composition/tool';
 import { initConfigureElementTool } from './tools/configure-element/tool';
 import { initGetElementConfigTool } from './tools/get-element-config/tool';
 import { getDynamicTagNamesByCategories } from './utils/resolve-dynamic-tag';
@@ -26,8 +27,9 @@ export const initCanvasMcp = ( reg: MCPRegistryEntry ) => {
 	initSelectedElementResource( reg );
 	initEditorStateResource( reg );
 	initGeneralContextResource( reg );
-	initBuildCompositionsTool( reg );
+	initBestPracticesResource( reg );
 	initGetElementConfigTool( reg );
 	initConfigureElementTool( reg );
+	initBuildCompositionTool( reg );
 	initBreakpointsResource( reg );
 };

package/src/mcp/resources/__tests__/available-widgets-resource.test.ts

@@ -0,0 +1,85 @@
+import { httpService } from '@elementor/http-client';
+
+import {
+	AVAILABLE_WIDGETS_URI,
+	AVAILABLE_WIDGETS_URI_V4,
+	initAvailableWidgetsResource,
+} from '../available-widgets-resource';
+
+jest.mock( '@elementor/http-client', () => ( {
+	httpService: jest.fn(),
+} ) );
+
+const mockedHttpService = httpService as jest.MockedFunction< typeof httpService >;
+
+type ResourceHandler = () => Promise< { contents: { text: string }[] } >;
+
+const captureHandlers = () => {
+	const resource = jest.fn();
+	initAvailableWidgetsResource( { resource } as never );
+	return {
+		v4Handler: resource.mock.calls[ 0 ][ 3 ] as ResourceHandler,
+		allHandler: resource.mock.calls[ 1 ][ 3 ] as ResourceHandler,
+	};
+};
+
+describe( 'available-widgets-resource', () => {
+	beforeEach( () => {
+		jest.clearAllMocks();
+	} );
+
+	it( 'fetches all widgets via list-widget-schemas with summary=true', async () => {
+		// Arrange
+		const post = jest.fn().mockResolvedValue( {
+			data: {
+				data: {
+					widgets: [
+						{ type: 'e-heading', description: 'A heading widget' },
+						{ type: 'e-button', description: 'A button widget' },
+					],
+				},
+			},
+		} );
+		mockedHttpService.mockReturnValue( { post } as never );
+		const { allHandler } = captureHandlers();
+
+		// Act
+		const result = await allHandler();
+
+		// Assert
+		expect( post ).toHaveBeenCalledWith( 'elementor/v1/mcp-proxy', {
+			tool: 'list-widget-schemas',
+			input: { summary: true },
+		} );
+		expect( JSON.parse( result.contents[ 0 ].text ) ).toEqual( [
+			{ type: 'e-heading', description: 'A heading widget' },
+			{ type: 'e-button', description: 'A button widget' },
+		] );
+	} );
+
+	it( 'fetches v4 widgets via list-widget-schemas with summary=true', async () => {
+		// Arrange
+		const post = jest.fn().mockResolvedValue( {
+			data: { data: { widgets: [ { type: 'e-heading', description: 'A heading widget' } ] } },
+		} );
+		mockedHttpService.mockReturnValue( { post } as never );
+		const { v4Handler } = captureHandlers();
+
+		// Act
+		const result = await v4Handler();
+
+		// Assert
+		expect( post ).toHaveBeenCalledWith( 'elementor/v1/mcp-proxy', {
+			tool: 'list-widget-schemas',
+			input: { summary: true },
+		} );
+		expect( JSON.parse( result.contents[ 0 ].text ) ).toEqual( [
+			{ type: 'e-heading', description: 'A heading widget' },
+		] );
+	} );
+
+	it( 'exposes the expected resource URIs', () => {
+		expect( AVAILABLE_WIDGETS_URI ).toBe( 'elementor://context/available-widgets' );
+		expect( AVAILABLE_WIDGETS_URI_V4 ).toBe( 'elementor://context/available-widgets/v4' );
+	} );
+} );

package/src/mcp/resources/__tests__/dynamic-tags-resource.test.ts

@@ -1,19 +1,12 @@
-import { Schema } from '@elementor/editor-props';
-import { getElementorConfig } from '@elementor/editor-v1-adapters';
+import { httpService } from '@elementor/http-client';
 
 import { DYNAMIC_TAGS_URI, initDynamicTagsResource } from '../dynamic-tags-resource';
 
-jest.mock( '@elementor/editor-props', () => ( {
-	Schema: {
-		propTypeToJsonSchema: jest.fn( () => ( { mocked: true } ) ),
-	},
+jest.mock( '@elementor/http-client', () => ( {
+	httpService: jest.fn(),
 } ) );
 
-jest.mock( '@elementor/editor-v1-adapters', () => ( {
-	getElementorConfig: jest.fn(),
-} ) );
-
-const mockedGetElementorConfig = getElementorConfig as jest.MockedFunction< typeof getElementorConfig >;
+const mockedHttpService = httpService as jest.MockedFunction< typeof httpService >;
 
 type ResourceHandler = ( uri: URL ) => Promise< { contents: { text: string }[] } >;
 
@@ -34,52 +27,49 @@ describe( 'dynamic-tags-resource', () => {
 		jest.clearAllMocks();
 	} );
 
-	it( 'returns a flat tag list with categories and omits the fallback setting', async () => {
+	it( 'returns the flat tag list fetched from the server', async () => {
 		// Arrange
-		mockedGetElementorConfig.mockReturnValue( {
-			atomicDynamicTags: {
-				tags: {
-					'post-custom-field': {
+		const post = jest.fn().mockResolvedValue( {
+			data: {
+				data: [
+					{
 						name: 'post-custom-field',
 						label: 'Post Custom Field',
-						group: 'post',
 						categories: [ 'text', 'url' ],
-						props_schema: {
-							key: { kind: 'string', key: 'string' },
-							before: { kind: 'string', key: 'string' },
-							fallback: { kind: 'string', key: 'string' },
-						},
+						settings: { key: { mocked: true }, before: { mocked: true } },
 					},
-				},
-				groups: { post: { title: 'Post' } },
+				],
 			},
-		} as never );
+		} );
+		mockedHttpService.mockReturnValue( { post } as never );
 
 		// Act
 		const catalog = await readCatalog();
 
 		// Assert
-		expect( Array.isArray( catalog ) ).toBe( true );
-		expect( catalog ).toHaveLength( 1 );
-		expect( catalog[ 0 ] ).toMatchObject( {
-			name: 'post-custom-field',
-			label: 'Post Custom Field',
-			categories: [ 'text', 'url' ],
+		expect( post ).toHaveBeenCalledWith( 'elementor/v1/mcp-proxy', {
+			tool: 'list-dynamic-tags',
+			input: {},
 		} );
-		expect( catalog[ 0 ] ).not.toHaveProperty( 'group' );
-		expect( Object.keys( catalog[ 0 ].settings ) ).toEqual( [ 'key', 'before' ] );
-		expect( catalog[ 0 ].settings ).not.toHaveProperty( 'fallback' );
+		expect( catalog ).toEqual( [
+			{
+				name: 'post-custom-field',
+				label: 'Post Custom Field',
+				categories: [ 'text', 'url' ],
+				settings: { key: { mocked: true }, before: { mocked: true } },
+			},
+		] );
 	} );
 
-	it( 'returns an empty list when dynamic tags are unavailable', async () => {
+	it( 'returns an empty list when the server returns no data', async () => {
 		// Arrange
-		mockedGetElementorConfig.mockReturnValue( {} as never );
+		const post = jest.fn().mockResolvedValue( { data: {} } );
+		mockedHttpService.mockReturnValue( { post } as never );
 
 		// Act
 		const catalog = await readCatalog();
 
 		// Assert
 		expect( catalog ).toEqual( [] );
-		expect( Schema.propTypeToJsonSchema ).not.toHaveBeenCalled();
 	} );
 } );

package/src/mcp/resources/__tests__/widgets-schema-resource.test.ts

@@ -1,95 +1,103 @@
-import { type V1ElementConfig } from '@elementor/editor-elements';
+import { httpService } from '@elementor/http-client';
 
-import { buildLlmGuidance, enrichPropertiesWithBaseSettingsHints, mergeInstructions } from '../build-llm-guidance';
+jest.mock( '@elementor/http-client', () => ( {
+	httpService: jest.fn(),
+} ) );
 
-const mockEmailBaseSettings = {
-	email: {
-		$$type: 'emails',
-		value: {
-			to: {
-				$$type: 'string-array',
-				value: [ { $$type: 'string', value: 'admin@example.com' } ],
-			},
-			from: { $$type: 'string', value: 'email@example.com' },
-			message: { $$type: 'string', value: '[all-fields]' },
-		},
-	},
-};
+jest.mock( '@elementor/editor-mcp', () => {
+	class MockResourceTemplate {
+		callbacks: { list?: () => Promise< { resources: unknown[] } > };
+		constructor( _uriTemplate: string, callbacks: { list?: () => Promise< { resources: unknown[] } > } ) {
+			this.callbacks = callbacks;
+		}
+	}
+	return { ResourceTemplate: MockResourceTemplate };
+} );
 
-const mockFormWidgetData = {
-	title: 'Form',
-	controls: {},
-	elType: 'widget',
-	meta: { is_container: true },
-	base_settings: mockEmailBaseSettings,
-	atomic_props_schema: {
-		email: { kind: 'object', key: 'emails' },
-		'form-name': { kind: 'string', key: 'string' },
-	},
-} as unknown as V1ElementConfig;
+import { initWidgetsSchemaResource, WIDGET_SCHEMA_URI } from '../widgets-schema-resource';
 
-describe( 'build-llm-guidance', () => {
-	it( 'mergeInstructions combines existing and additional instructions', () => {
-		expect( mergeInstructions( 'First.', 'Second.' ) ).toBe( 'First. Second.' );
-		expect( mergeInstructions( undefined, 'Only.' ) ).toBe( 'Only.' );
-	} );
+const mockedHttpService = httpService as jest.MockedFunction< typeof httpService >;
+
+type ResourceTemplateHandler = (
+	uri: URL,
+	variables: Record< string, string >
+) => Promise< { contents: { text: string }[] } >;
+type ResourceTemplateLike = { callbacks: { list?: () => Promise< { resources: unknown[] } > } };
 
-	it( 'buildLlmGuidance exposes default_settings for widgets with base_settings', () => {
-		const guidance = buildLlmGuidance( mockFormWidgetData, 'e-form', {} );
+const captureHandlers = () => {
+	const resource = jest.fn();
+	initWidgetsSchemaResource( { resource } as never );
+	const call = resource.mock.calls[ 0 ];
+	const template = call[ 1 ] as ResourceTemplateLike;
+	return {
+		list: template.callbacks.list as () => Promise< { resources: unknown[] } >,
+		readHandler: call[ 3 ] as ResourceTemplateHandler,
+	};
+};
 
-		expect( guidance.default_settings ).toEqual( mockEmailBaseSettings );
-		expect( guidance.instructions ).toContain( 'Omit them from elementConfig unless the user explicitly asks' );
-		expect( guidance.can_have_children ).toBe( true );
+describe( 'widgets-schema-resource', () => {
+	beforeEach( () => {
+		jest.clearAllMocks();
 	} );
 
-	it( 'buildLlmGuidance merges style and settings instructions when both exist', () => {
-		const widgetData = {
-			...mockFormWidgetData,
-			base_styles: {
-				'e-form-base': {
-					variants: [
-						{
-							props: {
-								display: { $$type: 'string', value: 'flex' },
-							},
-						},
+	it( 'lists widget types fetched from the server via list-widget-schemas with summary=true', async () => {
+		// Arrange
+		const post = jest.fn().mockResolvedValue( {
+			data: {
+				data: {
+					widgets: [
+						{ type: 'e-heading', description: 'A heading widget' },
+						{ type: 'e-button', description: 'A button widget' },
 					],
 				},
 			},
-		} as unknown as V1ElementConfig;
+		} );
+		mockedHttpService.mockReturnValue( { post } as never );
+		const { list } = captureHandlers();
 
-		const guidance = buildLlmGuidance( widgetData, 'e-form', {} );
+		// Act
+		const result = await list();
 
-		expect( guidance.default_styles ).toEqual( { display: { $$type: 'string', value: 'flex' } } );
-		expect( guidance.default_settings ).toEqual( mockEmailBaseSettings );
-		expect( guidance.instructions ).toContain( 'default styles' );
-		expect( guidance.instructions ).toContain( 'default settings' );
+		// Assert
+		expect( post ).toHaveBeenCalledWith( 'elementor/v1/mcp-proxy', {
+			tool: 'list-widget-schemas',
+			input: { summary: true },
+		} );
+		expect( result.resources ).toEqual( [
+			{ uri: 'elementor://widgets/schema/e-heading', name: 'Widget schema for e-heading' },
+			{ uri: 'elementor://widgets/schema/e-button', name: 'Widget schema for e-button' },
+		] );
 	} );
 
-	it( 'enrichPropertiesWithBaseSettingsHints adds omit guidance to base setting props', () => {
-		const enriched = enrichPropertiesWithBaseSettingsHints(
-			{
-				email: { type: 'object' },
-				'form-name': { type: 'object' },
-			},
-			[ 'email' ]
-		);
+	it( 'reads a single widget schema via the get-widget-schema tool', async () => {
+		// Arrange
+		const post = jest.fn().mockResolvedValue( {
+			data: { data: { type: 'object', properties: { text: { mocked: true } } } },
+		} );
+		mockedHttpService.mockReturnValue( { post } as never );
+		const { readHandler } = captureHandlers();
+		const uri = new URL( 'elementor://widgets/schema/e-heading' );
+
+		// Act
+		const result = await readHandler( uri, { widgetType: 'e-heading' } );
 
-		expect( enriched.email.description ).toContain( 'llm_guidance.default_settings' );
-		expect( enriched[ 'form-name' ].description ).toBeUndefined();
+		// Assert
+		expect( post ).toHaveBeenCalledWith( 'elementor/v1/mcp-proxy', {
+			tool: 'get-widget-schema',
+			input: { widget_type: 'e-heading' },
+		} );
+		expect( JSON.parse( result.contents[ 0 ].text ) ).toEqual( {
+			type: 'object',
+			properties: { text: { mocked: true } },
+		} );
 	} );
-} );
 
-describe( 'widgets-schema-resource base_settings integration', () => {
-	it( 'keeps base setting props in schema while enriching descriptions', () => {
-		const properties = enrichPropertiesWithBaseSettingsHints(
-			{
-				email: { type: 'object', properties: {} },
-			},
-			Object.keys( mockEmailBaseSettings )
-		);
+	it( 'throws when no widget type variable is provided', async () => {
+		// Arrange
+		const { readHandler } = captureHandlers();
+		const uri = new URL( WIDGET_SCHEMA_URI.replace( '{widgetType}', '' ) );
 
-		expect( properties ).toHaveProperty( 'email' );
-		expect( properties.email.description ).toContain( 'omit unless user explicitly requests' );
+		// Act & Assert
+		await expect( readHandler( uri, {} ) ).rejects.toThrow( 'No widget type provided.' );
 	} );
 } );

package/src/mcp/resources/available-widgets-resource.ts

@@ -1,37 +1,45 @@
 import { type MCPRegistryEntry } from '@elementor/editor-mcp';
-import { v1ReadyEvent } from '@elementor/editor-v1-adapters';
+import { type HttpResponse, httpService } from '@elementor/http-client';
 
-import { type AvailableWidget, getAvailableWidgets } from '../utils/element-data-util';
+const MCP_PROXY_URL = 'elementor/v1/mcp-proxy';
 
 export const AVAILABLE_WIDGETS_URI = 'elementor://context/available-widgets';
 export const AVAILABLE_WIDGETS_URI_V4 = 'elementor://context/available-widgets/v4';
 
-export const initAvailableWidgetsResource = ( reg: MCPRegistryEntry ) => {
-	const { resource, sendResourceUpdated } = reg;
+type WidgetSummary = {
+	type: string;
+	description?: string;
+};
 
-	const buildContents = ( uri: string, filterFunction: ( x: AvailableWidget ) => boolean = () => true ) => {
-		const widgets = getAvailableWidgets().filter( filterFunction );
-		return {
-			contents: [
-				{
-					uri,
-					mimeType: 'application/json',
-					text: JSON.stringify( widgets, null, 2 ),
-				},
-			],
-		};
-	};
+type WidgetSummaryResponse = {
+	widgets: WidgetSummary[];
+};
+
+const fetchWidgets = async (): Promise< WidgetSummary[] > => {
+	const { data } = await httpService().post< HttpResponse< WidgetSummaryResponse > >( MCP_PROXY_URL, {
+		tool: 'list-widget-schemas',
+		input: { summary: true },
+	} );
+
+	return data.data?.widgets ?? [];
+};
 
-	const notifyResourcesUpdated = () => {
-		sendResourceUpdated( {
-			uri: AVAILABLE_WIDGETS_URI,
-			...buildContents( AVAILABLE_WIDGETS_URI ),
-		} );
-		sendResourceUpdated( {
-			uri: AVAILABLE_WIDGETS_URI_V4,
-			...buildContents( AVAILABLE_WIDGETS_URI_V4, ( w: AvailableWidget ) => w.version === 'v4' ),
-		} );
+const buildContents = async ( uri: string ) => {
+	const widgets = await fetchWidgets();
+
+	return {
+		contents: [
+			{
+				uri,
+				mimeType: 'application/json',
+				text: JSON.stringify( widgets, null, 2 ),
+			},
+		],
 	};
+};
+
+export const initAvailableWidgetsResource = ( reg: MCPRegistryEntry ) => {
+	const { resource } = reg;
 
 	resource(
 		'available-widgets-v4',
@@ -39,29 +47,15 @@ export const initAvailableWidgetsResource = ( reg: MCPRegistryEntry ) => {
 		{
 			description: 'All registered v4 version widgets',
 		},
-		async () => buildContents( AVAILABLE_WIDGETS_URI_V4, ( w ) => w.version === 'v4' )
+		async () => buildContents( AVAILABLE_WIDGETS_URI_V4 )
 	);
 
 	resource(
 		'available-widgets',
 		AVAILABLE_WIDGETS_URI,
 		{
-			description: 'All registered widget types with v3/v4 version metadata and description.',
+			description: 'All registered v4 widget types with description.',
 		},
 		async () => buildContents( AVAILABLE_WIDGETS_URI )
 	);
-
-	const eventName = v1ReadyEvent().name;
-
-	const onV1Ready = () => {
-		const widgets = getAvailableWidgets();
-		if ( widgets.length === 0 ) {
-			return;
-		}
-		window.removeEventListener( eventName, onV1Ready );
-		notifyResourcesUpdated();
-	};
-
-	window.addEventListener( eventName, onV1Ready );
-	onV1Ready();
 };

package/src/mcp/resources/best-practices-resource.ts

@@ -0,0 +1,34 @@
+import { type MCPRegistryEntry } from '@elementor/editor-mcp';
+import { type HttpResponse, httpService } from '@elementor/http-client';
+
+const MCP_PROXY_URL = 'elementor/v1/mcp-proxy';
+export const BEST_PRACTICES_URI = 'elementor://style/best-practices';
+
+export const initBestPracticesResource = ( reg: MCPRegistryEntry ) => {
+	const { resource } = reg;
+
+	resource(
+		'style-best-practices',
+		BEST_PRACTICES_URI,
+		{
+			description:
+				'Design quality guidelines for avoiding generic AI output: typography, color strategy, spacing, motion, and visual hierarchy best practices.',
+			mimeType: 'text/markdown',
+		},
+		async ( uri: URL ) => {
+			const { data } = await httpService().get< HttpResponse< string > >( MCP_PROXY_URL, {
+				params: { uri: uri.href },
+			} );
+
+			return {
+				contents: [
+					{
+						uri: uri.href,
+						mimeType: 'text/markdown',
+						text: data.data,
+					},
+				],
+			};
+		}
+	);
+};