@elementor/editor-canvas 4.2.0-937 → 4.2.0-939

package/dist/index.js

@@ -4198,7 +4198,7 @@ function extractElementData(element) {
     widgetType: model.widgetType || void 0,
     version: resolveElementVersion(element)
   };
-  const title = model.title || element.model?.editor_settings?.title;
+  const title = model.title || element.model?.editor_settings?.title || element.model.getTitle?.();
   if (title) {
     result.title = title;
   }
@@ -4626,13 +4626,13 @@ function getElementDisplayName(container) {
 
 // src/mcp/tools/build-composition/tool.ts
 var import_editor_documents3 = require("@elementor/editor-documents");
-var import_editor_elements15 = require("@elementor/editor-elements");
+var import_editor_elements16 = require("@elementor/editor-elements");
 
 // src/composition-builder/composition-builder.ts
-var import_editor_elements14 = require("@elementor/editor-elements");
+var import_editor_elements15 = require("@elementor/editor-elements");
 
 // src/mcp/utils/do-update-element-property.ts
-var import_editor_elements13 = require("@elementor/editor-elements");
+var import_editor_elements14 = require("@elementor/editor-elements");
 var import_editor_props8 = require("@elementor/editor-props");
 var import_editor_styles4 = require("@elementor/editor-styles");
 var import_editor_v1_adapters21 = require("@elementor/editor-v1-adapters");
@@ -4651,6 +4651,58 @@ var readStoredCustomCssText = (raw) => {
   }
 };
 
+// src/mcp/utils/resolve-canonical-prop-name.ts
+var import_editor_elements13 = require("@elementor/editor-elements");
+function buildAliasToCanonicalMap(schema2) {
+  const aliasToCanonical = {};
+  for (const [canonical, propType] of Object.entries(schema2)) {
+    const aliases = propType.meta?.aliases;
+    if (!Array.isArray(aliases)) {
+      continue;
+    }
+    for (const alias of aliases) {
+      if (typeof alias === "string" && alias) {
+        aliasToCanonical[alias] = canonical;
+      }
+    }
+  }
+  return aliasToCanonical;
+}
+function resolveCanonicalPropName(elementType, propertyName) {
+  const schema2 = (0, import_editor_elements13.getWidgetsCache)()?.[elementType]?.atomic_props_schema;
+  if (!schema2 || schema2[propertyName]) {
+    return propertyName;
+  }
+  return buildAliasToCanonicalMap(schema2)[propertyName] ?? propertyName;
+}
+function resolveCanonicalPropKeys(elementType, props) {
+  const schema2 = (0, import_editor_elements13.getWidgetsCache)()?.[elementType]?.atomic_props_schema;
+  if (!schema2) {
+    return { ...props };
+  }
+  const aliasToCanonical = buildAliasToCanonicalMap(schema2);
+  const resolved = {};
+  for (const [key, value] of Object.entries(props)) {
+    if (schema2[key]) {
+      resolved[key] = value;
+    }
+  }
+  for (const [key, value] of Object.entries(props)) {
+    if (schema2[key]) {
+      continue;
+    }
+    const canonical = aliasToCanonical[key];
+    if (!canonical) {
+      resolved[key] = value;
+      continue;
+    }
+    if (!Object.prototype.hasOwnProperty.call(resolved, canonical)) {
+      resolved[canonical] = value;
+    }
+  }
+  return resolved;
+}
+
 // src/mcp/utils/do-update-element-property.ts
 var LOCAL_STYLE_META = {
   breakpoint: "desktop",
@@ -4667,9 +4719,10 @@ function resolvePropValue(value, forceKey) {
   });
 }
 var doUpdateElementProperty = (params) => {
-  const { elementId, propertyName, propertyValue, elementType, customCssWriteMode = "replace" } = params;
+  const { elementId, propertyValue, elementType, customCssWriteMode = "replace" } = params;
+  const propertyName = params.propertyName === "_styles" ? params.propertyName : resolveCanonicalPropName(elementType, params.propertyName);
   if (propertyName === "_styles") {
-    const elementStyles = (0, import_editor_elements13.getElementStyles)(elementId) || {};
+    const elementStyles = (0, import_editor_elements14.getElementStyles)(elementId) || {};
     const propertyMapValue = propertyValue;
     const styleSchema = (0, import_editor_styles4.getStylesSchema)();
     const transformedStyleValues = Object.fromEntries(
@@ -4726,7 +4779,7 @@ var doUpdateElementProperty = (params) => {
     });
     delete transformedStyleValues.custom_css;
     if (!localStyle) {
-      (0, import_editor_elements13.createElementStyle)({
+      (0, import_editor_elements14.createElementStyle)({
         elementId,
         ...typeof customCss !== "undefined" ? { custom_css: customCss } : {},
         classesProp: "classes",
@@ -4740,7 +4793,7 @@ var doUpdateElementProperty = (params) => {
         }
       });
     } else {
-      (0, import_editor_elements13.updateElementStyle)({
+      (0, import_editor_elements14.updateElementStyle)({
         elementId,
         styleId: localStyle.id,
         meta: {
@@ -4755,7 +4808,7 @@ var doUpdateElementProperty = (params) => {
     }
     return;
   }
-  const elementPropSchema = (0, import_editor_elements13.getWidgetsCache)()?.[elementType]?.atomic_props_schema;
+  const elementPropSchema = (0, import_editor_elements14.getWidgetsCache)()?.[elementType]?.atomic_props_schema;
   if (!elementPropSchema) {
     throw new Error(`No prop schema found for element type: ${elementType}`);
   }
@@ -4778,7 +4831,7 @@ var doUpdateElementProperty = (params) => {
 Expected Schema: ${jsonSchema}`
     );
   }
-  (0, import_editor_elements13.updateElementSettings)({
+  (0, import_editor_elements14.updateElementSettings)({
     id: elementId,
     props: {
       [propertyName]: value
@@ -4836,11 +4889,11 @@ var CompositionBuilder = class _CompositionBuilder {
   elementCustomCSS = {};
   rootContainers = [];
   api = {
-    createElement: import_editor_elements14.createElement,
-    deleteElement: import_editor_elements14.deleteElement,
-    getWidgetsCache: import_editor_elements14.getWidgetsCache,
-    generateElementId: import_editor_elements14.generateElementId,
-    getContainer: import_editor_elements14.getContainer,
+    createElement: import_editor_elements15.createElement,
+    deleteElement: import_editor_elements15.deleteElement,
+    getWidgetsCache: import_editor_elements15.getWidgetsCache,
+    generateElementId: import_editor_elements15.generateElementId,
+    getContainer: import_editor_elements15.getContainer,
     doUpdateElementProperty
   };
   xml;
@@ -5360,19 +5413,19 @@ var initBuildCompositionsTool = (reg) => {
       const { xmlStructure, elementConfig, stylesConfig } = adaptLeafRootParams({
         ...rawParams,
         stylesConfig: convertedStyles,
-        widgetsCache: (0, import_editor_elements15.getWidgetsCache)() ?? {}
+        widgetsCache: (0, import_editor_elements16.getWidgetsCache)() ?? {}
       });
       let generatedXML = "";
       const errors = [];
       const rootContainers = [];
-      const documentContainer = (0, import_editor_elements15.getContainer)("document");
+      const documentContainer = (0, import_editor_elements16.getContainer)("document");
       const currentDocument = (0, import_editor_documents3.getCurrentDocument)();
       const targetContainer = getCompositionTargetContainer(documentContainer, currentDocument?.type.value);
       try {
         const compositionBuilder = CompositionBuilder.fromXMLString(xmlStructure, {
-          createElement: import_editor_elements15.createElement,
-          deleteElement: import_editor_elements15.deleteElement,
-          getWidgetsCache: import_editor_elements15.getWidgetsCache
+          createElement: import_editor_elements16.createElement,
+          deleteElement: import_editor_elements16.deleteElement,
+          getWidgetsCache: import_editor_elements16.getWidgetsCache
         });
         compositionBuilder.setElementConfig(elementConfig);
         compositionBuilder.setStylesConfig(stylesConfig);
@@ -5388,7 +5441,7 @@ var initBuildCompositionsTool = (reg) => {
       }
       if (errors.length) {
         rootContainers.forEach((rootContainer) => {
-          (0, import_editor_elements15.deleteElement)({
+          (0, import_editor_elements16.deleteElement)({
             container: rootContainer,
             options: { useHistory: false }
           });
@@ -5457,7 +5510,7 @@ function assertCompositionXmlUsesV4WidgetsOnly(xmlStructure) {
   if (doc.querySelector("parsererror")) {
     throw new Error("Failed to parse XML string: " + doc);
   }
-  const widgetsCache = (0, import_editor_elements15.getWidgetsCache)() ?? {};
+  const widgetsCache = (0, import_editor_elements16.getWidgetsCache)() ?? {};
   for (const node of doc.querySelectorAll("*")) {
     const type = node.tagName;
     const widgetData = widgetsCache[type];
@@ -5474,10 +5527,10 @@ function assertCompositionXmlUsesV4WidgetsOnly(xmlStructure) {
 }
 
 // src/mcp/tools/configure-element/tool.ts
-var import_editor_elements17 = require("@elementor/editor-elements");
+var import_editor_elements18 = require("@elementor/editor-elements");
 
 // src/mcp/utils/validate-input.ts
-var import_editor_elements16 = require("@elementor/editor-elements");
+var import_editor_elements17 = require("@elementor/editor-elements");
 var import_editor_props9 = require("@elementor/editor-props");
 var import_editor_styles5 = require("@elementor/editor-styles");
 var _widgetsSchema = null;
@@ -5485,7 +5538,7 @@ var validateInput = {
   get widgetsSchema() {
     if (!_widgetsSchema) {
       const schema2 = {};
-      const cache = (0, import_editor_elements16.getWidgetsCache)();
+      const cache = (0, import_editor_elements17.getWidgetsCache)();
       if (!cache) {
         return {};
       }
@@ -5726,19 +5779,28 @@ var initConfigureElementTool = (reg) => {
       { description: "Dynamic tags catalog", uri: DYNAMIC_TAGS_URI }
     ],
     handler: async ({ elementId, propertiesToChange, elementType, style }) => {
-      const widgetData = (0, import_editor_elements17.getWidgetsCache)()?.[elementType];
+      const widgetData = (0, import_editor_elements18.getWidgetsCache)()?.[elementType];
       if (!widgetData) {
         throw new Error(
           `Unknown element type: ${elementType}. Check the available-widgets resource for valid types.`
         );
       }
+      const container = (0, import_editor_elements18.getContainer)(elementId);
+      if (!container) {
+        throw new Error(`Element with id ${elementId} not found`);
+      }
+      const isElementTypeMatchingId = container.settings.get("widgetType") === elementType || container.type === elementType;
+      if (!isElementTypeMatchingId) {
+        throw new Error(`Element with ID ${elementId} is not of type ${elementType}`);
+      }
       if (!widgetData.atomic_props_schema) {
         throw new Error(
           `This tool does not support V3 elements. Please use the elementor-v3-mcp tools instead for element type: ${elementType}`
         );
       }
-      const toUpdate = Object.entries(propertiesToChange);
-      const { valid, errors } = validateInput.validatePropSchema(elementType, propertiesToChange);
+      const propertiesToUpdate = resolveCanonicalPropKeys(elementType, propertiesToChange);
+      const toUpdate = Object.entries(propertiesToUpdate);
+      const { valid, errors } = validateInput.validatePropSchema(elementType, propertiesToUpdate);
       if (!valid) {
         const errorMessage = `Failed to configure element "${elementId}" due to invalid properties: ${errors?.join(
           "\n- "
@@ -5818,7 +5880,7 @@ Provide styling as raw CSS via the "style" parameter (a flat map of CSS property
 }
 
 // src/mcp/tools/get-element-config/tool.ts
-var import_editor_elements18 = require("@elementor/editor-elements");
+var import_editor_elements19 = require("@elementor/editor-elements");
 var import_editor_props10 = require("@elementor/editor-props");
 var import_schema5 = require("@elementor/schema");
 var schema = {
@@ -5853,12 +5915,12 @@ var initGetElementConfigTool = (reg) => {
     schema,
     outputSchema: outputSchema3,
     handler: async ({ elementId }) => {
-      const element = (0, import_editor_elements18.getContainer)(elementId);
+      const element = (0, import_editor_elements19.getContainer)(elementId);
       if (!element) {
         throw new Error(`Element with ID ${elementId} not found.`);
       }
       const elementType = element.model.get("widgetType") || element.model.get("elType") || "";
-      const widgetData = (0, import_editor_elements18.getWidgetsCache)()?.[elementType];
+      const widgetData = (0, import_editor_elements19.getWidgetsCache)()?.[elementType];
       if (!widgetData) {
         throw new Error(
           `Unknown element type: ${elementType}. Check the available-widgets resource for valid types.`
@@ -5870,7 +5932,7 @@ var initGetElementConfigTool = (reg) => {
         );
       }
       const elementRawSettings = element.settings;
-      const propSchema = (0, import_editor_elements18.getWidgetsCache)()?.[elementType]?.atomic_props_schema;
+      const propSchema = (0, import_editor_elements19.getWidgetsCache)()?.[elementType]?.atomic_props_schema;
       if (!elementRawSettings || !propSchema) {
         throw new Error(`No settings or prop schema found for element ID: ${elementId}`);
       }
@@ -5879,7 +5941,7 @@ var initGetElementConfigTool = (reg) => {
       import_editor_props10.Schema.configurableKeys(propSchema).forEach((key) => {
         propValues[key] = structuredClone(elementRawSettings.get(key));
       });
-      const elementStyles = (0, import_editor_elements18.getElementStyles)(elementId) || {};
+      const elementStyles = (0, import_editor_elements19.getElementStyles)(elementId) || {};
       const localStyle = Object.values(elementStyles).find((style) => style.label === "local");
       if (localStyle) {
         const defaultVariant = localStyle.variants.find(
@@ -6035,7 +6097,7 @@ Note: The "size" property controls image resolution/loading, not visual size. Se
 `;
 
 // src/prevent-link-in-link-commands.ts
-var import_editor_elements19 = require("@elementor/editor-elements");
+var import_editor_elements20 = require("@elementor/editor-elements");
 var import_editor_notifications3 = require("@elementor/editor-notifications");
 var import_editor_v1_adapters22 = require("@elementor/editor-v1-adapters");
 var import_i18n4 = require("@wordpress/i18n");
@@ -6106,24 +6168,24 @@ function shouldBlock(sourceElements, targetElements) {
     return false;
   }
   const isSourceContainsAnAnchor = sourceElements.some((src) => {
-    return src?.id ? (0, import_editor_elements19.isElementAnchored)(src.id) || !!(0, import_editor_elements19.getAnchoredDescendantId)(src.id) : false;
+    return src?.id ? (0, import_editor_elements20.isElementAnchored)(src.id) || !!(0, import_editor_elements20.getAnchoredDescendantId)(src.id) : false;
   });
   if (!isSourceContainsAnAnchor) {
     return false;
   }
   const isTargetContainsAnAnchor = targetElements.some((target) => {
-    return target?.id ? (0, import_editor_elements19.isElementAnchored)(target.id) || !!(0, import_editor_elements19.getAnchoredAncestorId)(target.id) : false;
+    return target?.id ? (0, import_editor_elements20.isElementAnchored)(target.id) || !!(0, import_editor_elements20.getAnchoredAncestorId)(target.id) : false;
   });
   return isTargetContainsAnAnchor;
 }
 
 // src/style-commands/paste-style.ts
-var import_editor_elements22 = require("@elementor/editor-elements");
+var import_editor_elements23 = require("@elementor/editor-elements");
 var import_editor_props13 = require("@elementor/editor-props");
 var import_editor_v1_adapters24 = require("@elementor/editor-v1-adapters");
 
 // src/utils/command-utils.ts
-var import_editor_elements20 = require("@elementor/editor-elements");
+var import_editor_elements21 = require("@elementor/editor-elements");
 var import_editor_props12 = require("@elementor/editor-props");
 var import_i18n5 = require("@wordpress/i18n");
 function hasAtomicWidgets(args) {
@@ -6148,7 +6210,7 @@ function getClassesProp(container) {
 }
 function getContainerSchema(container) {
   const type = container?.model.get("widgetType") || container?.model.get("elType");
-  const widgetsCache = (0, import_editor_elements20.getWidgetsCache)();
+  const widgetsCache = (0, import_editor_elements21.getWidgetsCache)();
   const elementType = widgetsCache?.[type];
   return elementType?.atomic_props_schema ?? null;
 }
@@ -6161,11 +6223,11 @@ function getClipboardElements(storageKey = "clipboard") {
   }
 }
 function getTitleForContainers(containers) {
-  return containers.length > 1 ? (0, import_i18n5.__)("Elements", "elementor") : (0, import_editor_elements20.getElementLabel)(containers[0].id);
+  return containers.length > 1 ? (0, import_i18n5.__)("Elements", "elementor") : (0, import_editor_elements21.getElementLabel)(containers[0].id);
 }
 
 // src/style-commands/undoable-actions/paste-element-style.ts
-var import_editor_elements21 = require("@elementor/editor-elements");
+var import_editor_elements22 = require("@elementor/editor-elements");
 var import_editor_styles_repository4 = require("@elementor/editor-styles-repository");
 var import_editor_v1_adapters23 = require("@elementor/editor-v1-adapters");
 var import_i18n6 = require("@wordpress/i18n");
@@ -6178,7 +6240,7 @@ var undoablePasteElementStyle = () => (0, import_editor_v1_adapters23.undoable)(
         if (!classesProp) {
           return null;
         }
-        const originalStyles = (0, import_editor_elements21.getElementStyles)(container.id);
+        const originalStyles = (0, import_editor_elements22.getElementStyles)(container.id);
         const [styleId, styleDef] = Object.entries(originalStyles ?? {})[0] ?? [];
         const originalStyle = Object.keys(styleDef ?? {}).length ? styleDef : null;
         const revertData = {
@@ -6187,7 +6249,7 @@ var undoablePasteElementStyle = () => (0, import_editor_v1_adapters23.undoable)(
         };
         if (styleId) {
           newStyle.variants.forEach(({ meta, props, custom_css: customCss }) => {
-            (0, import_editor_elements21.updateElementStyle)({
+            (0, import_editor_elements22.updateElementStyle)({
               elementId,
               styleId,
               meta,
@@ -6198,7 +6260,7 @@ var undoablePasteElementStyle = () => (0, import_editor_v1_adapters23.undoable)(
         } else {
           const [firstVariant] = newStyle.variants;
           const additionalVariants = newStyle.variants.slice(1);
-          revertData.styleId = (0, import_editor_elements21.createElementStyle)({
+          revertData.styleId = (0, import_editor_elements22.createElementStyle)({
             elementId,
             classesProp,
             label: import_editor_styles_repository4.ELEMENTS_STYLES_RESERVED_LABEL,
@@ -6216,7 +6278,7 @@ var undoablePasteElementStyle = () => (0, import_editor_v1_adapters23.undoable)(
           return;
         }
         if (!revertData.originalStyle) {
-          (0, import_editor_elements21.deleteElementStyle)(container.id, revertData.styleId);
+          (0, import_editor_elements22.deleteElementStyle)(container.id, revertData.styleId);
           return;
         }
         const classesProp = getClassesProp(container);
@@ -6225,7 +6287,7 @@ var undoablePasteElementStyle = () => (0, import_editor_v1_adapters23.undoable)(
         }
         const [firstVariant] = revertData.originalStyle.variants;
         const additionalVariants = revertData.originalStyle.variants.slice(1);
-        (0, import_editor_elements21.createElementStyle)({
+        (0, import_editor_elements22.createElementStyle)({
           elementId: container.id,
           classesProp,
           label: import_editor_styles_repository4.ELEMENTS_STYLES_RESERVED_LABEL,
@@ -6262,7 +6324,7 @@ function pasteStyles(args, pasteLocalStyle) {
   }
   const clipboardElements = getClipboardElements(storageKey);
   const [clipboardElement] = clipboardElements ?? [];
-  const clipboardContainer = (0, import_editor_elements22.getContainer)(clipboardElement.id);
+  const clipboardContainer = (0, import_editor_elements23.getContainer)(clipboardElement.id);
   if (!clipboardElement || !clipboardContainer || !isAtomicWidget(clipboardContainer)) {
     return;
   }
@@ -6281,7 +6343,7 @@ function getClassesWithoutLocalStyle(clipboardContainer, style) {
   if (!classesProp) {
     return [];
   }
-  const classesSetting = (0, import_editor_elements22.getElementSetting)(clipboardContainer.id, classesProp);
+  const classesSetting = (0, import_editor_elements23.getElementSetting)(clipboardContainer.id, classesProp);
   return classesSetting?.value.filter((styleId) => styleId !== style?.id) ?? [];
 }
 function pasteClasses(containers, classes) {
@@ -6290,10 +6352,10 @@ function pasteClasses(containers, classes) {
     if (!classesProp) {
       return;
     }
-    const classesSetting = (0, import_editor_elements22.getElementSetting)(container.id, classesProp);
+    const classesSetting = (0, import_editor_elements23.getElementSetting)(container.id, classesProp);
     const currentClasses = import_editor_props13.classesPropTypeUtil.extract(classesSetting) ?? [];
     const newClasses = import_editor_props13.classesPropTypeUtil.create(Array.from(/* @__PURE__ */ new Set([...classes, ...currentClasses])));
-    (0, import_editor_elements22.updateElementSettings)({
+    (0, import_editor_elements23.updateElementSettings)({
       id: container.id,
       props: { [classesProp]: newClasses }
     });
@@ -6304,7 +6366,7 @@ function pasteClasses(containers, classes) {
 var import_editor_v1_adapters26 = require("@elementor/editor-v1-adapters");
 
 // src/style-commands/undoable-actions/reset-element-style.ts
-var import_editor_elements23 = require("@elementor/editor-elements");
+var import_editor_elements24 = require("@elementor/editor-elements");
 var import_editor_styles_repository5 = require("@elementor/editor-styles-repository");
 var import_editor_v1_adapters25 = require("@elementor/editor-v1-adapters");
 var import_i18n7 = require("@wordpress/i18n");
@@ -6313,9 +6375,9 @@ var undoableResetElementStyle = () => (0, import_editor_v1_adapters25.undoable)(
     do: ({ containers }) => {
       return containers.map((container) => {
         const elementId = container.model.get("id");
-        const containerStyles = (0, import_editor_elements23.getElementStyles)(elementId);
+        const containerStyles = (0, import_editor_elements24.getElementStyles)(elementId);
         Object.keys(containerStyles ?? {}).forEach(
-          (styleId) => (0, import_editor_elements23.deleteElementStyle)(elementId, styleId)
+          (styleId) => (0, import_editor_elements24.deleteElementStyle)(elementId, styleId)
         );
         return containerStyles;
       });
@@ -6331,7 +6393,7 @@ var undoableResetElementStyle = () => (0, import_editor_v1_adapters25.undoable)(
         Object.entries(containerStyles ?? {}).forEach(([styleId, style]) => {
           const [firstVariant] = style.variants;
           const additionalVariants = style.variants.slice(1);
-          (0, import_editor_elements23.createElementStyle)({
+          (0, import_editor_elements24.createElementStyle)({
             elementId,
             classesProp,
             styleId,
@@ -6531,10 +6593,10 @@ function useEscapeOnCanvas(canvasDocument, onEscape) {
 }
 
 // src/utils/after-render.ts
-var import_editor_elements24 = require("@elementor/editor-elements");
+var import_editor_elements25 = require("@elementor/editor-elements");
 function doAfterRender(elementIds, callback) {
   const pending = elementIds.map((elementId) => {
-    const view = (0, import_editor_elements24.getContainer)(elementId)?.view;
+    const view = (0, import_editor_elements25.getContainer)(elementId)?.view;
     if (!view || !hasDoAfterRender(view)) {
       return void 0;
     }

package/dist/index.mjs

@@ -4164,7 +4164,7 @@ function extractElementData(element) {
     widgetType: model.widgetType || void 0,
     version: resolveElementVersion(element)
   };
-  const title = model.title || element.model?.editor_settings?.title;
+  const title = model.title || element.model?.editor_settings?.title || element.model.getTitle?.();
   if (title) {
     result.title = title;
   }
@@ -4599,7 +4599,7 @@ import {
   createElement as createElement13,
   deleteElement as deleteElement2,
   getContainer as getContainer5,
-  getWidgetsCache as getWidgetsCache8
+  getWidgetsCache as getWidgetsCache9
 } from "@elementor/editor-elements";
 
 // src/composition-builder/composition-builder.ts
@@ -4608,14 +4608,14 @@ import {
   deleteElement,
   generateElementId as generateElementId2,
   getContainer as getContainer4,
-  getWidgetsCache as getWidgetsCache7
+  getWidgetsCache as getWidgetsCache8
 } from "@elementor/editor-elements";
 
 // src/mcp/utils/do-update-element-property.ts
 import {
   createElementStyle,
   getElementStyles,
-  getWidgetsCache as getWidgetsCache6,
+  getWidgetsCache as getWidgetsCache7,
   updateElementSettings,
   updateElementStyle
 } from "@elementor/editor-elements";
@@ -4637,6 +4637,58 @@ var readStoredCustomCssText = (raw) => {
   }
 };
 
+// src/mcp/utils/resolve-canonical-prop-name.ts
+import { getWidgetsCache as getWidgetsCache6 } from "@elementor/editor-elements";
+function buildAliasToCanonicalMap(schema2) {
+  const aliasToCanonical = {};
+  for (const [canonical, propType] of Object.entries(schema2)) {
+    const aliases = propType.meta?.aliases;
+    if (!Array.isArray(aliases)) {
+      continue;
+    }
+    for (const alias of aliases) {
+      if (typeof alias === "string" && alias) {
+        aliasToCanonical[alias] = canonical;
+      }
+    }
+  }
+  return aliasToCanonical;
+}
+function resolveCanonicalPropName(elementType, propertyName) {
+  const schema2 = getWidgetsCache6()?.[elementType]?.atomic_props_schema;
+  if (!schema2 || schema2[propertyName]) {
+    return propertyName;
+  }
+  return buildAliasToCanonicalMap(schema2)[propertyName] ?? propertyName;
+}
+function resolveCanonicalPropKeys(elementType, props) {
+  const schema2 = getWidgetsCache6()?.[elementType]?.atomic_props_schema;
+  if (!schema2) {
+    return { ...props };
+  }
+  const aliasToCanonical = buildAliasToCanonicalMap(schema2);
+  const resolved = {};
+  for (const [key, value] of Object.entries(props)) {
+    if (schema2[key]) {
+      resolved[key] = value;
+    }
+  }
+  for (const [key, value] of Object.entries(props)) {
+    if (schema2[key]) {
+      continue;
+    }
+    const canonical = aliasToCanonical[key];
+    if (!canonical) {
+      resolved[key] = value;
+      continue;
+    }
+    if (!Object.prototype.hasOwnProperty.call(resolved, canonical)) {
+      resolved[canonical] = value;
+    }
+  }
+  return resolved;
+}
+
 // src/mcp/utils/do-update-element-property.ts
 var LOCAL_STYLE_META = {
   breakpoint: "desktop",
@@ -4653,7 +4705,8 @@ function resolvePropValue(value, forceKey) {
   });
 }
 var doUpdateElementProperty = (params) => {
-  const { elementId, propertyName, propertyValue, elementType, customCssWriteMode = "replace" } = params;
+  const { elementId, propertyValue, elementType, customCssWriteMode = "replace" } = params;
+  const propertyName = params.propertyName === "_styles" ? params.propertyName : resolveCanonicalPropName(elementType, params.propertyName);
   if (propertyName === "_styles") {
     const elementStyles = getElementStyles(elementId) || {};
     const propertyMapValue = propertyValue;
@@ -4741,7 +4794,7 @@ var doUpdateElementProperty = (params) => {
     }
     return;
   }
-  const elementPropSchema = getWidgetsCache6()?.[elementType]?.atomic_props_schema;
+  const elementPropSchema = getWidgetsCache7()?.[elementType]?.atomic_props_schema;
   if (!elementPropSchema) {
     throw new Error(`No prop schema found for element type: ${elementType}`);
   }
@@ -4824,7 +4877,7 @@ var CompositionBuilder = class _CompositionBuilder {
   api = {
     createElement: createElement12,
     deleteElement,
-    getWidgetsCache: getWidgetsCache7,
+    getWidgetsCache: getWidgetsCache8,
     generateElementId: generateElementId2,
     getContainer: getContainer4,
     doUpdateElementProperty
@@ -5346,7 +5399,7 @@ var initBuildCompositionsTool = (reg) => {
       const { xmlStructure, elementConfig, stylesConfig } = adaptLeafRootParams({
         ...rawParams,
         stylesConfig: convertedStyles,
-        widgetsCache: getWidgetsCache8() ?? {}
+        widgetsCache: getWidgetsCache9() ?? {}
       });
       let generatedXML = "";
       const errors = [];
@@ -5358,7 +5411,7 @@ var initBuildCompositionsTool = (reg) => {
         const compositionBuilder = CompositionBuilder.fromXMLString(xmlStructure, {
           createElement: createElement13,
           deleteElement: deleteElement2,
-          getWidgetsCache: getWidgetsCache8
+          getWidgetsCache: getWidgetsCache9
         });
         compositionBuilder.setElementConfig(elementConfig);
         compositionBuilder.setStylesConfig(stylesConfig);
@@ -5443,7 +5496,7 @@ function assertCompositionXmlUsesV4WidgetsOnly(xmlStructure) {
   if (doc.querySelector("parsererror")) {
     throw new Error("Failed to parse XML string: " + doc);
   }
-  const widgetsCache = getWidgetsCache8() ?? {};
+  const widgetsCache = getWidgetsCache9() ?? {};
   for (const node of doc.querySelectorAll("*")) {
     const type = node.tagName;
     const widgetData = widgetsCache[type];
@@ -5460,10 +5513,10 @@ function assertCompositionXmlUsesV4WidgetsOnly(xmlStructure) {
 }
 
 // src/mcp/tools/configure-element/tool.ts
-import { getWidgetsCache as getWidgetsCache10 } from "@elementor/editor-elements";
+import { getContainer as getContainer6, getWidgetsCache as getWidgetsCache11 } from "@elementor/editor-elements";
 
 // src/mcp/utils/validate-input.ts
-import { getWidgetsCache as getWidgetsCache9 } from "@elementor/editor-elements";
+import { getWidgetsCache as getWidgetsCache10 } from "@elementor/editor-elements";
 import { Schema as Schema4 } from "@elementor/editor-props";
 import { getStylesSchema as getStylesSchema3 } from "@elementor/editor-styles";
 var _widgetsSchema = null;
@@ -5471,7 +5524,7 @@ var validateInput = {
   get widgetsSchema() {
     if (!_widgetsSchema) {
       const schema2 = {};
-      const cache = getWidgetsCache9();
+      const cache = getWidgetsCache10();
       if (!cache) {
         return {};
       }
@@ -5712,19 +5765,28 @@ var initConfigureElementTool = (reg) => {
       { description: "Dynamic tags catalog", uri: DYNAMIC_TAGS_URI }
     ],
     handler: async ({ elementId, propertiesToChange, elementType, style }) => {
-      const widgetData = getWidgetsCache10()?.[elementType];
+      const widgetData = getWidgetsCache11()?.[elementType];
       if (!widgetData) {
         throw new Error(
           `Unknown element type: ${elementType}. Check the available-widgets resource for valid types.`
         );
       }
+      const container = getContainer6(elementId);
+      if (!container) {
+        throw new Error(`Element with id ${elementId} not found`);
+      }
+      const isElementTypeMatchingId = container.settings.get("widgetType") === elementType || container.type === elementType;
+      if (!isElementTypeMatchingId) {
+        throw new Error(`Element with ID ${elementId} is not of type ${elementType}`);
+      }
       if (!widgetData.atomic_props_schema) {
         throw new Error(
           `This tool does not support V3 elements. Please use the elementor-v3-mcp tools instead for element type: ${elementType}`
         );
       }
-      const toUpdate = Object.entries(propertiesToChange);
-      const { valid, errors } = validateInput.validatePropSchema(elementType, propertiesToChange);
+      const propertiesToUpdate = resolveCanonicalPropKeys(elementType, propertiesToChange);
+      const toUpdate = Object.entries(propertiesToUpdate);
+      const { valid, errors } = validateInput.validatePropSchema(elementType, propertiesToUpdate);
       if (!valid) {
         const errorMessage = `Failed to configure element "${elementId}" due to invalid properties: ${errors?.join(
           "\n- "
@@ -5804,7 +5866,7 @@ Provide styling as raw CSS via the "style" parameter (a flat map of CSS property
 }
 
 // src/mcp/tools/get-element-config/tool.ts
-import { getContainer as getContainer6, getElementStyles as getElementStyles2, getWidgetsCache as getWidgetsCache11 } from "@elementor/editor-elements";
+import { getContainer as getContainer7, getElementStyles as getElementStyles2, getWidgetsCache as getWidgetsCache12 } from "@elementor/editor-elements";
 import { Schema as Schema5 } from "@elementor/editor-props";
 import { z as z3 } from "@elementor/schema";
 var schema = {
@@ -5839,12 +5901,12 @@ var initGetElementConfigTool = (reg) => {
     schema,
     outputSchema: outputSchema3,
     handler: async ({ elementId }) => {
-      const element = getContainer6(elementId);
+      const element = getContainer7(elementId);
       if (!element) {
         throw new Error(`Element with ID ${elementId} not found.`);
       }
       const elementType = element.model.get("widgetType") || element.model.get("elType") || "";
-      const widgetData = getWidgetsCache11()?.[elementType];
+      const widgetData = getWidgetsCache12()?.[elementType];
       if (!widgetData) {
         throw new Error(
           `Unknown element type: ${elementType}. Check the available-widgets resource for valid types.`
@@ -5856,7 +5918,7 @@ var initGetElementConfigTool = (reg) => {
         );
       }
       const elementRawSettings = element.settings;
-      const propSchema = getWidgetsCache11()?.[elementType]?.atomic_props_schema;
+      const propSchema = getWidgetsCache12()?.[elementType]?.atomic_props_schema;
       if (!elementRawSettings || !propSchema) {
         throw new Error(`No settings or prop schema found for element ID: ${elementId}`);
       }
@@ -6108,7 +6170,7 @@ function shouldBlock(sourceElements, targetElements) {
 }
 
 // src/style-commands/paste-style.ts
-import { getContainer as getContainer7, getElementSetting, updateElementSettings as updateElementSettings2 } from "@elementor/editor-elements";
+import { getContainer as getContainer8, getElementSetting, updateElementSettings as updateElementSettings2 } from "@elementor/editor-elements";
 import { classesPropTypeUtil } from "@elementor/editor-props";
 import {
   __privateListenTo as listenTo5,
@@ -6117,7 +6179,7 @@ import {
 } from "@elementor/editor-v1-adapters";
 
 // src/utils/command-utils.ts
-import { getElementLabel as getElementLabel2, getWidgetsCache as getWidgetsCache12 } from "@elementor/editor-elements";
+import { getElementLabel as getElementLabel2, getWidgetsCache as getWidgetsCache13 } from "@elementor/editor-elements";
 import { CLASSES_PROP_KEY } from "@elementor/editor-props";
 import { __ as __5 } from "@wordpress/i18n";
 function hasAtomicWidgets(args) {
@@ -6142,7 +6204,7 @@ function getClassesProp(container) {
 }
 function getContainerSchema(container) {
   const type = container?.model.get("widgetType") || container?.model.get("elType");
-  const widgetsCache = getWidgetsCache12();
+  const widgetsCache = getWidgetsCache13();
   const elementType = widgetsCache?.[type];
   return elementType?.atomic_props_schema ?? null;
 }
@@ -6261,7 +6323,7 @@ function pasteStyles(args, pasteLocalStyle) {
   }
   const clipboardElements = getClipboardElements(storageKey);
   const [clipboardElement] = clipboardElements ?? [];
-  const clipboardContainer = getContainer7(clipboardElement.id);
+  const clipboardContainer = getContainer8(clipboardElement.id);
   if (!clipboardElement || !clipboardContainer || !isAtomicWidget(clipboardContainer)) {
     return;
   }
@@ -6538,10 +6600,10 @@ function useEscapeOnCanvas(canvasDocument, onEscape) {
 }
 
 // src/utils/after-render.ts
-import { getContainer as getContainer8 } from "@elementor/editor-elements";
+import { getContainer as getContainer9 } from "@elementor/editor-elements";
 function doAfterRender(elementIds, callback) {
   const pending = elementIds.map((elementId) => {
-    const view = getContainer8(elementId)?.view;
+    const view = getContainer9(elementId)?.view;
     if (!view || !hasDoAfterRender(view)) {
       return void 0;
     }

package/package.json

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

package/src/mcp/resources/document-structure-resource.ts

@@ -136,7 +136,10 @@ function extractElementData( element: UnknownVersionElementInstanceData ): Recor
 		version: resolveElementVersion( element ),
 	};
 
-	const title = model.title || element.model?.editor_settings?.title;
+	const title =
+		model.title ||
+		element.model?.editor_settings?.title ||
+		( element.model as unknown as Record< string, CallableFunction > ).getTitle?.();
 
 	if ( title ) {
 		result.title = title;

package/src/mcp/tools/configure-element/tool.ts

@@ -1,10 +1,12 @@
-import { getWidgetsCache } from '@elementor/editor-elements';
+import { getContainer, getWidgetsCache } from '@elementor/editor-elements';
 import { type MCPRegistryEntry } from '@elementor/editor-mcp';
+import { type PropValue } from '@elementor/editor-props';
 
 import { DYNAMIC_TAGS_URI } from '../../resources/dynamic-tags-resource';
 import { WIDGET_SCHEMA_URI } from '../../resources/widgets-schema-resource';
 import { convertCssToAtomic } from '../../utils/convert-css-to-atomic';
 import { doUpdateElementProperty } from '../../utils/do-update-element-property';
+import { resolveCanonicalPropKeys } from '../../utils/resolve-canonical-prop-name';
 import { validateInput } from '../../utils/validate-input';
 import { CONFIGURE_ELEMENT_GUIDE_URI, generatePrompt } from './prompt';
 import { inputSchema as schema, outputSchema } from './schema';
@@ -42,20 +44,31 @@ export const initConfigureElementTool = ( reg: MCPRegistryEntry ) => {
 					`Unknown element type: ${ elementType }. Check the available-widgets resource for valid types.`
 				);
 			}
+			const container = getContainer( elementId );
+			if ( ! container ) {
+				throw new Error( `Element with id ${ elementId } not found` );
+			}
+			const isElementTypeMatchingId =
+				container.settings.get( 'widgetType' ) === elementType ||
+				( container as Record< string, unknown > ).type === elementType;
+			if ( ! isElementTypeMatchingId ) {
+				throw new Error( `Element with ID ${ elementId } is not of type ${ elementType }` );
+			}
 			if ( ! widgetData.atomic_props_schema ) {
 				throw new Error(
 					`This tool does not support V3 elements. Please use the elementor-v3-mcp tools instead for element type: ${ elementType }`
 				);
 			}
-			const toUpdate = Object.entries( propertiesToChange );
-			const { valid, errors } = validateInput.validatePropSchema( elementType, propertiesToChange );
+			const propertiesToUpdate = resolveCanonicalPropKeys( elementType, propertiesToChange );
+			const toUpdate = Object.entries( propertiesToUpdate );
+			const { valid, errors } = validateInput.validatePropSchema( elementType, propertiesToUpdate );
 			if ( ! valid ) {
 				const errorMessage = `Failed to configure element "${ elementId }" due to invalid properties: ${ errors?.join(
 					'\n- '
 				) }`;
 				throw new Error( errorMessage );
 			}
-			for ( const [ propertyName, propertyValue ] of toUpdate ) {
+			for ( const [ propertyName, propertyValue ] of toUpdate as [ string, PropValue ][] ) {
 				try {
 					doUpdateElementProperty( {
 						elementId,

package/src/mcp/utils/__tests__/do-update-element-property.test.ts

@@ -143,6 +143,49 @@ describe( 'doUpdateElementProperty', () => {
 		);
 	} );
 
+	it( 'persists canonical prop key when an alias property name is used', () => {
+		// Arrange
+		const propertyValue = 'resolved-title';
+		jest.mocked( getWidgetsCache ).mockReturnValue( {
+			[ ELEMENT_TYPE ]: {
+				atomic_props_schema: {
+					// @ts-ignore: Mock type
+					[ PROPERTY_NAME ]: {
+						...PROP_SCHEMA_ENTRY,
+						meta: { aliases: [ 'text' ] },
+					},
+				},
+			},
+		} );
+		jest.mocked( Schema.validatePropValue ).mockReturnValue( {
+			jsonSchema: EXPECTED_JSON_SCHEMA_SNIPPET,
+			valid: true,
+			errorMessages: [],
+			errors: [],
+		} );
+
+		// Act
+		doUpdateElementProperty( {
+			elementId: ELEMENT_ID,
+			elementType: ELEMENT_TYPE,
+			propertyName: 'text',
+			propertyValue,
+		} );
+
+		// Assert
+		expect( Schema.validatePropValue ).toHaveBeenCalledWith(
+			expect.objectContaining( PROP_SCHEMA_ENTRY ),
+			propertyValue
+		);
+		expect( updateElementSettings ).toHaveBeenCalledWith( {
+			id: ELEMENT_ID,
+			props: {
+				[ PROPERTY_NAME ]: propertyValue,
+			},
+			withHistory: false,
+		} );
+	} );
+
 	it( 'replaces existing local style custom_css by default', () => {
 		// Arrange
 		jest.mocked( getElementStyles ).mockReturnValue( {

package/src/mcp/utils/__tests__/resolve-canonical-prop-name.test.ts

@@ -0,0 +1,111 @@
+import { getWidgetsCache } from '@elementor/editor-elements';
+
+import { resolveCanonicalPropKeys, resolveCanonicalPropName } from '../resolve-canonical-prop-name';
+
+jest.mock( '@elementor/editor-elements', () => ( {
+	getWidgetsCache: jest.fn(),
+} ) );
+
+const ELEMENT_TYPE = 'e-paragraph';
+
+const widgetsCacheFixture = {
+	[ ELEMENT_TYPE ]: {
+		atomic_props_schema: {
+			paragraph: {
+				key: 'html-v3',
+				meta: {
+					aliases: [ 'text', 'content' ],
+				},
+			},
+			tag: {
+				key: 'string',
+			},
+		},
+	},
+};
+
+describe( 'resolveCanonicalPropName', () => {
+	beforeEach( () => {
+		// @ts-ignore: Mock values for test
+		jest.mocked( getWidgetsCache ).mockReturnValue( widgetsCacheFixture );
+	} );
+
+	it( 'returns canonical property names unchanged', () => {
+		// Act
+		const resolved = resolveCanonicalPropName( ELEMENT_TYPE, 'paragraph' );
+
+		// Assert
+		expect( resolved ).toBe( 'paragraph' );
+	} );
+
+	it( 'resolves alias property names to canonical keys', () => {
+		// Act
+		const resolved = resolveCanonicalPropName( ELEMENT_TYPE, 'text' );
+
+		// Assert
+		expect( resolved ).toBe( 'paragraph' );
+	} );
+
+	it( 'returns unknown property names unchanged', () => {
+		// Act
+		const resolved = resolveCanonicalPropName( ELEMENT_TYPE, 'unknown' );
+
+		// Assert
+		expect( resolved ).toBe( 'unknown' );
+	} );
+
+	it( 'returns property names unchanged when element type has no schema', () => {
+		// Arrange
+		jest.mocked( getWidgetsCache ).mockReturnValue( null );
+
+		// Act
+		const resolved = resolveCanonicalPropName( 'missing-widget', 'text' );
+
+		// Assert
+		expect( resolved ).toBe( 'text' );
+	} );
+} );
+
+describe( 'resolveCanonicalPropKeys', () => {
+	beforeEach( () => {
+		// @ts-ignore: Mock values for test
+		jest.mocked( getWidgetsCache ).mockReturnValue( widgetsCacheFixture );
+	} );
+
+	it( 'rewrites alias keys to canonical keys', () => {
+		// Act
+		const resolved = resolveCanonicalPropKeys( ELEMENT_TYPE, {
+			text: 'hello',
+		} );
+
+		// Assert
+		expect( resolved ).toEqual( {
+			paragraph: 'hello',
+		} );
+	} );
+
+	it( 'prefers canonical keys when alias and canonical are both provided', () => {
+		// Act
+		const resolved = resolveCanonicalPropKeys( ELEMENT_TYPE, {
+			paragraph: 'canonical',
+			text: 'alias',
+		} );
+
+		// Assert
+		expect( resolved ).toEqual( {
+			paragraph: 'canonical',
+		} );
+	} );
+
+	it( 'passes unknown keys through for downstream validation', () => {
+		// Act
+		const resolved = resolveCanonicalPropKeys( ELEMENT_TYPE, {
+			unknown: 'value',
+		} );
+
+		// Assert
+		expect( resolved ).toEqual( {
+			unknown: 'value',
+		} );
+	} );
+} );

package/src/mcp/utils/do-update-element-property.ts

@@ -12,6 +12,7 @@ import { type Utils as IUtils } from '@elementor/editor-variables';
 import { type z } from '@elementor/schema';
 
 import { mergeCustomCssText, readStoredCustomCssText } from './merge-custom-css';
+import { resolveCanonicalPropName } from './resolve-canonical-prop-name';
 import { DYNAMIC_PROP_TYPE_KEY, dynamicTagLLMResolver } from './resolve-dynamic-tag';
 
 // TODO: see https://elementor.atlassian.net/browse/ED-22513 for better cross-module access
@@ -47,7 +48,11 @@ export function resolvePropValue( value: unknown, forceKey?: string ): PropValue
  * Also, it supports updating styles "on-the-way" by checking for "_styles" property with PropValue bag that fits the common style schema.
  */
 export const doUpdateElementProperty = ( params: OwnParams ) => {
-	const { elementId, propertyName, propertyValue, elementType, customCssWriteMode = 'replace' } = params;
+	const { elementId, propertyValue, elementType, customCssWriteMode = 'replace' } = params;
+	const propertyName =
+		params.propertyName === '_styles'
+			? params.propertyName
+			: resolveCanonicalPropName( elementType, params.propertyName );
 	if ( propertyName === '_styles' ) {
 		const elementStyles = getElementStyles( elementId ) || {};
 		const propertyMapValue = propertyValue as Record< string, PropValue >;

package/src/mcp/utils/resolve-canonical-prop-name.ts

@@ -0,0 +1,71 @@
+import { getWidgetsCache } from '@elementor/editor-elements';
+import { type PropsSchema } from '@elementor/editor-props';
+
+function buildAliasToCanonicalMap( schema: PropsSchema ): Record< string, string > {
+	const aliasToCanonical: Record< string, string > = {};
+
+	for ( const [ canonical, propType ] of Object.entries( schema ) ) {
+		const aliases = propType.meta?.aliases;
+
+		if ( ! Array.isArray( aliases ) ) {
+			continue;
+		}
+
+		for ( const alias of aliases ) {
+			if ( typeof alias === 'string' && alias ) {
+				aliasToCanonical[ alias ] = canonical;
+			}
+		}
+	}
+
+	return aliasToCanonical;
+}
+
+export function resolveCanonicalPropName( elementType: string, propertyName: string ): string {
+	const schema = getWidgetsCache()?.[ elementType ]?.atomic_props_schema;
+
+	if ( ! schema || schema[ propertyName ] ) {
+		return propertyName;
+	}
+
+	return buildAliasToCanonicalMap( schema )[ propertyName ] ?? propertyName;
+}
+
+export function resolveCanonicalPropKeys(
+	elementType: string,
+	props: Record< string, unknown >
+): Record< string, unknown > {
+	const schema = getWidgetsCache()?.[ elementType ]?.atomic_props_schema;
+
+	if ( ! schema ) {
+		return { ...props };
+	}
+
+	const aliasToCanonical = buildAliasToCanonicalMap( schema );
+	const resolved: Record< string, unknown > = {};
+
+	for ( const [ key, value ] of Object.entries( props ) ) {
+		if ( schema[ key ] ) {
+			resolved[ key ] = value;
+		}
+	}
+
+	for ( const [ key, value ] of Object.entries( props ) ) {
+		if ( schema[ key ] ) {
+			continue;
+		}
+
+		const canonical = aliasToCanonical[ key ];
+
+		if ( ! canonical ) {
+			resolved[ key ] = value;
+			continue;
+		}
+
+		if ( ! Object.prototype.hasOwnProperty.call( resolved, canonical ) ) {
+			resolved[ canonical ] = value;
+		}
+	}
+
+	return resolved;
+}