@elementor/editor-canvas 4.3.0-998 → 4.3.0-beta1

package/dist/index.js

@@ -81,10 +81,10 @@ var BEST_PRACTICES_FULL_URI = `${CANVAS_SERVER_NAME}_${BEST_PRACTICES_URI}`;
 var MCP_PROXY_URL = "elementor/v1/mcp-proxy";
 var listWidgetTypes = async () => {
   const { data } = await (0, import_http_client.httpService)().post(MCP_PROXY_URL, {
-    tool: "list-widgets",
-    input: {}
+    tool: "list-widget-schemas",
+    input: { summary: true }
   });
-  return (data.data ?? []).map((widget) => widget.type);
+  return (data.data?.widgets ?? []).map((widget) => widget.type);
 };
 var fetchWidgetSchema = async (widgetType) => {
   const { data } = await (0, import_http_client.httpService)().post(MCP_PROXY_URL, {
@@ -116,13 +116,13 @@ var initWidgetsSchemaResource = (reg) => {
       if (!widgetType) {
         throw new Error("No widget type provided.");
       }
-      const schema2 = await fetchWidgetSchema(widgetType);
+      const schema = await fetchWidgetSchema(widgetType);
       return {
         contents: [
           {
             uri: uri.toString(),
             mimeType: "application/json",
-            text: JSON.stringify(schema2)
+            text: JSON.stringify(schema)
           }
         ]
       };
@@ -1310,10 +1310,10 @@ var getMultiPropsValue = (multiProps) => {
 // src/renderers/create-props-resolver.ts
 var TRANSFORM_DEPTH_LIMIT = 3;
 function createPropsResolver({ transformers, schema: initialSchema, onPropResolve }) {
-  async function resolve({ props, schema: schema2, signal, renderContext }) {
-    schema2 = schema2 ?? initialSchema;
+  async function resolve({ props, schema, signal, renderContext }) {
+    schema = schema ?? initialSchema;
     const promises = Promise.all(
-      Object.entries(schema2).map(async ([key, type]) => {
+      Object.entries(schema).map(async ([key, type]) => {
         const value = props[key] ?? type.default;
         const transformed = await transform({ value, key, type, signal, renderContext });
         onPropResolve?.({ key, value: transformed, propValue: value, propType: type });
@@ -2037,6 +2037,40 @@ var dateTimeTransformer = createTransformer((values) => {
   }).join(" ");
 });
 
+// src/utils/sanitize-escaped-html.ts
+var import_dompurify = __toESM(require("dompurify"));
+var ALLOWED_NON_OPERATIONAL_ATTRS = [
+  "href",
+  "target",
+  "class",
+  "id",
+  "style",
+  "title",
+  "lang",
+  "dir",
+  "role"
+];
+function getAllowedHtmlWrapperTags() {
+  return window.elementorCommon?.config?.allowedHTMLWrapperTags ?? [];
+}
+function sanitizeEscapedHtml(value) {
+  if (!value) {
+    return "";
+  }
+  const allowedTags = [...getAllowedHtmlWrapperTags()];
+  return import_dompurify.default.sanitize(value, {
+    ALLOWED_TAGS: allowedTags,
+    ALLOWED_ATTR: [...ALLOWED_NON_OPERATIONAL_ATTRS],
+    ALLOW_DATA_ATTR: true,
+    ALLOW_ARIA_ATTR: true
+  });
+}
+
+// src/transformers/settings/escaped-html-transformer.ts
+var escapedHtmlTransformer = createTransformer((value) => {
+  return sanitizeEscapedHtml(value);
+});
+
 // src/transformers/settings/html-v2-transformer.ts
 var htmlV2Transformer = createTransformer((value) => {
   return value?.content ?? "";
@@ -2073,6 +2107,102 @@ var timeRangeTransformer = createTransformer((value) => {
   };
 });
 
+// src/transformers/shared/process-svg-content.ts
+var import_dompurify2 = __toESM(require("dompurify"));
+var SVG_INLINE_STYLES = "width: 100%; height: 100%; overflow: unset;";
+function processSvgContent(svgText) {
+  const sanitized = import_dompurify2.default.sanitize(svgText, {
+    USE_PROFILES: { svg: true, svgFilters: true }
+  });
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(sanitized, "image/svg+xml");
+  const svgElement = doc.querySelector("svg");
+  if (!svgElement) {
+    return null;
+  }
+  svgElement.setAttribute("fill", "currentColor");
+  const existingStyle = svgElement.getAttribute("style") ?? "";
+  const trimmed = existingStyle.trim();
+  const merged = trimmed ? `${trimmed.replace(/;$/, "")}; ${SVG_INLINE_STYLES}` : SVG_INLINE_STYLES;
+  svgElement.setAttribute("style", merged);
+  return svgElement.outerHTML;
+}
+
+// src/transformers/shared/icon-transformer.ts
+var FONT_AWESOME_JSON = {
+  width: 0,
+  height: 1,
+  path: 4
+};
+var fontAwesomeJsonCache = /* @__PURE__ */ new Map();
+var iconTransformer = createTransformer(async (value, { signal }) => {
+  const iconValue = typeof value.value === "string" ? value.value : null;
+  const library = typeof value.library === "string" ? value.library : null;
+  if (!iconValue || !library) {
+    return { html: null, url: null };
+  }
+  const iconName = getFontAwesomeIconName(iconValue);
+  const jsonFileName = getFontAwesomeJsonFileName(library);
+  if (!iconName || !jsonFileName) {
+    return { html: null, url: null };
+  }
+  const icons = await fetchFontAwesomeIcons(jsonFileName, signal);
+  const iconData = icons?.[iconName];
+  if (!iconData) {
+    return { html: null, url: null };
+  }
+  const svgText = buildFontAwesomeSvg(iconData);
+  const html = processSvgContent(svgText);
+  return { html, url: null };
+});
+function getFontAwesomeIconName(iconValue) {
+  const match = iconValue.match(/^fa\S*\s+fa-(.+)$/);
+  return match?.[1] ?? null;
+}
+function getFontAwesomeJsonFileName(library) {
+  if (!library.startsWith("fa-")) {
+    return null;
+  }
+  return library.replace(/^fa-/, "");
+}
+function getAssetsBaseUrl() {
+  const assetsUrl = window.elementorCommon?.config?.urls?.assets;
+  return typeof assetsUrl === "string" && assetsUrl !== "" ? assetsUrl : null;
+}
+async function fetchFontAwesomeIcons(jsonFileName, signal) {
+  const cached = fontAwesomeJsonCache.get(jsonFileName);
+  if (cached) {
+    return cached;
+  }
+  const icons = await loadFontAwesomeIcons(jsonFileName, signal);
+  if (icons) {
+    fontAwesomeJsonCache.set(jsonFileName, icons);
+  }
+  return icons;
+}
+async function loadFontAwesomeIcons(jsonFileName, signal) {
+  const assetsUrl = getAssetsBaseUrl();
+  if (!assetsUrl) {
+    return null;
+  }
+  try {
+    const response = await fetch(`${assetsUrl}lib/font-awesome/json/${jsonFileName}.json`, { signal });
+    if (!response.ok) {
+      return null;
+    }
+    const data = await response.json();
+    return data.icons ?? null;
+  } catch {
+    return null;
+  }
+}
+function buildFontAwesomeSvg(iconData) {
+  const width = iconData[FONT_AWESOME_JSON.width];
+  const height = iconData[FONT_AWESOME_JSON.height];
+  const path = iconData[FONT_AWESOME_JSON.path];
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${width} ${height}"><path d="${path}"></path></svg>`;
+}
+
 // src/transformers/shared/image-src-transformer.ts
 var imageSrcTransformer = createTransformer((value) => ({
   id: value.id ?? null,
@@ -2114,26 +2244,7 @@ var plainTransformer = createTransformer((value) => {
 });
 
 // src/transformers/shared/svg-src-transformer.ts
-var import_dompurify = __toESM(require("dompurify"));
 var import_wp_media2 = require("@elementor/wp-media");
-var SVG_INLINE_STYLES = "width: 100%; height: 100%; overflow: unset;";
-function processSvgContent(svgText) {
-  const sanitized = import_dompurify.default.sanitize(svgText, {
-    USE_PROFILES: { svg: true, svgFilters: true }
-  });
-  const parser = new DOMParser();
-  const doc = parser.parseFromString(sanitized, "image/svg+xml");
-  const svgElement = doc.querySelector("svg");
-  if (!svgElement) {
-    return null;
-  }
-  svgElement.setAttribute("fill", "currentColor");
-  const existingStyle = svgElement.getAttribute("style") ?? "";
-  const trimmed = existingStyle.trim();
-  const merged = trimmed ? `${trimmed.replace(/;$/, "")}; ${SVG_INLINE_STYLES}` : SVG_INLINE_STYLES;
-  svgElement.setAttribute("style", merged);
-  return svgElement.outerHTML;
-}
 async function fetchSvgContent(url, signal) {
   try {
     const response = await fetch(url, { signal });
@@ -2189,7 +2300,7 @@ var videoSrcTransformer = createTransformer(async (value) => {
 
 // src/init-settings-transformers.ts
 function initSettingsTransformers() {
-  settingsTransformersRegistry.register("classes", createClassesTransformer()).register("link", linkTransformer).register("query", queryTransformer).register("image", imageTransformer).register("image-src", imageSrcTransformer).register("svg-src", svgSrcTransformer).register("video-src", videoSrcTransformer).register("attributes", attributesTransformer).register("date-time", dateTimeTransformer).register("html-v2", htmlV2Transformer).register("html-v3", htmlV3Transformer).register("date-range", dateRangeTransformer).register("time-range", timeRangeTransformer).registerFallback(plainTransformer);
+  settingsTransformersRegistry.register("classes", createClassesTransformer()).register("link", linkTransformer).register("query", queryTransformer).register("image", imageTransformer).register("image-src", imageSrcTransformer).register("svg-src", svgSrcTransformer).register("icon", iconTransformer).register("video-src", videoSrcTransformer).register("attributes", attributesTransformer).register("date-time", dateTimeTransformer).register("html-v2", htmlV2Transformer).register("html-v3", htmlV3Transformer).register("escaped-html", escapedHtmlTransformer).register("date-range", dateRangeTransformer).register("time-range", timeRangeTransformer).registerFallback(plainTransformer);
 }
 
 // src/transformers/styles/background-color-overlay-transformer.ts
@@ -2466,11 +2577,11 @@ function getVal2(val) {
 var transformOriginTransformer = createTransformer((value) => {
   const x = getVal2(value.x);
   const y = getVal2(value.y);
-  const z5 = getVal2(value.z);
-  if (x === DEFAULT_XY && y === DEFAULT_XY && z5 === DEFAULT_Z) {
+  const z3 = getVal2(value.z);
+  if (x === DEFAULT_XY && y === DEFAULT_XY && z3 === DEFAULT_Z) {
     return null;
   }
-  return `${x} ${y} ${z5}`;
+  return `${x} ${y} ${z3}`;
 });
 
 // src/transformers/styles/transform-rotate-transformer.ts
@@ -2548,13 +2659,13 @@ function initStyleTransformers() {
     "layout-direction",
     createMultiPropsTransformer(["row", "column"], ({ propKey, key }) => `${key}-${propKey}`)
   ).register("flex", flexTransformer).register(
-    "border-width",
+    "border-width-v2",
     createMultiPropsTransformer(
       ["block-start", "block-end", "inline-start", "inline-end"],
       ({ key }) => `border-${key}-width`
     )
   ).register(
-    "border-radius",
+    "border-radius-v2",
     createMultiPropsTransformer(
       ["start-start", "start-end", "end-start", "end-end"],
       ({ key }) => `border-${key}-radius`
@@ -2578,28 +2689,13 @@ function createDomRenderer() {
     render: environment.render
   };
 }
+function getAllowedHtmlWrapperTags2() {
+  return window.elementorCommon?.config?.allowedHTMLWrapperTags ?? [];
+}
 function escapeHtmlTag(value) {
-  const allowedTags = [
-    "a",
-    "article",
-    "aside",
-    "button",
-    "div",
-    "footer",
-    "h1",
-    "h2",
-    "h3",
-    "h4",
-    "h5",
-    "h6",
-    "header",
-    "main",
-    "nav",
-    "p",
-    "section",
-    "span"
-  ];
-  return allowedTags.includes(value) ? value : "div";
+  const allowedTags = getAllowedHtmlWrapperTags2();
+  const normalizedTag = value?.toLowerCase?.() ?? "";
+  return allowedTags.includes(normalizedTag) ? value : "div";
 }
 function escapeURL(value) {
   const allowedProtocols = ["http:", "https:", "mailto:", "tel:"];
@@ -2694,6 +2790,52 @@ function createElementViewClassDeclaration() {
 // src/legacy/create-nested-templated-element-type.ts
 var import_editor_elements6 = require("@elementor/editor-elements");
 
+// src/renderers/compute-html-tag.ts
+var DEFAULT_LINK_TAG = "a";
+function computeHtmlTag(settings, defaultTag, options = {}) {
+  const followLink = options.followLink ?? true;
+  if (followLink && settingsHaveActiveLink(settings)) {
+    const link = settings.link;
+    return extractLinkHtmlTag(isRecord(link) ? link : {});
+  }
+  const settingsTag = extractHtmlTagValue(settings.tag);
+  if (null !== settingsTag && "" !== settingsTag) {
+    return settingsTag;
+  }
+  return defaultTag;
+}
+function settingsHaveActiveLink(settings) {
+  const link = settings.link;
+  if (!isRecord(link)) {
+    return false;
+  }
+  const href = extractHtmlTagValue(link.href);
+  if (null !== href && "" !== href) {
+    return true;
+  }
+  const attributes = link.attributes;
+  return typeof attributes === "string" && "" !== attributes;
+}
+function extractLinkHtmlTag(link) {
+  const tag = extractHtmlTagValue(link.tag);
+  if (null !== tag && "" !== tag) {
+    return tag;
+  }
+  return DEFAULT_LINK_TAG;
+}
+function extractHtmlTagValue(value) {
+  if (isRecord(value) && typeof value.value === "string") {
+    return value.value;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  return null;
+}
+function isRecord(value) {
+  return typeof value === "object" && null !== value && !Array.isArray(value);
+}
+
 // src/legacy/create-pending-element.ts
 var import_editor_elements5 = require("@elementor/editor-elements");
 function createPendingElement(wrapperView, data, options = {}) {
@@ -2754,7 +2896,13 @@ function setupTwigRenderer({ renderer, element }) {
     transformers: settingsTransformersRegistry,
     schema: element.atomic_props_schema
   });
-  return { templateKey, baseStylesDictionary, resolveProps };
+  return {
+    templateKey,
+    baseStylesDictionary,
+    resolveProps,
+    defaultHtmlTag: element.default_html_tag ?? "div",
+    htmlTagFollowsLink: element.html_tag_follows_link ?? true
+  };
 }
 function createBeforeRender(view) {
   view._ensureViewIsIntact();
@@ -2794,7 +2942,7 @@ function createTemplatedElementView({
   element
 }) {
   const BaseView = createElementViewClassDeclaration();
-  const { templateKey, baseStylesDictionary, resolveProps } = setupTwigRenderer({
+  const { templateKey, baseStylesDictionary, resolveProps, defaultHtmlTag, htmlTagFollowsLink } = setupTwigRenderer({
     type,
     renderer,
     element
@@ -2864,6 +3012,7 @@ function createTemplatedElementView({
           interaction_id: this.getInteractionId(),
           type,
           settings,
+          tag: computeHtmlTag(settings, defaultHtmlTag, { followLink: htmlTagFollowsLink }),
           base_styles: baseStylesDictionary,
           ...this.getResolverRenderContext?.() ?? {}
         };
@@ -2953,7 +3102,7 @@ function createNestedTemplatedElementView({
   element
 }) {
   const legacyWindow = window;
-  const { templateKey, baseStylesDictionary, resolveProps } = setupTwigRenderer({
+  const { templateKey, baseStylesDictionary, resolveProps, defaultHtmlTag, htmlTagFollowsLink } = setupTwigRenderer({
     type,
     renderer,
     element
@@ -3028,6 +3177,7 @@ function createNestedTemplatedElementView({
           interaction_id: this.getInteractionId(),
           type,
           settings: resolvedSettings,
+          tag: computeHtmlTag(resolvedSettings, defaultHtmlTag, { followLink: htmlTagFollowsLink }),
           base_styles: baseStylesDictionary,
           editor_attributes: buildEditorAttributes(model),
           editor_classes: buildEditorClasses(model),
@@ -3531,7 +3681,7 @@ var import_editor_props3 = require("@elementor/editor-props");
 var hasKey = (propType) => {
   return "key" in propType;
 };
-var TEXT_PROP_TYPE_KEYS = /* @__PURE__ */ new Set([import_editor_props3.htmlV3PropTypeUtil.key, import_editor_props3.stringPropTypeUtil.key]);
+var TEXT_PROP_TYPE_KEYS = /* @__PURE__ */ new Set([import_editor_props3.escapedHtmlPropTypeUtil.key, import_editor_props3.htmlV3PropTypeUtil.key, import_editor_props3.stringPropTypeUtil.key]);
 var isCoreTextPropTypeKey = (key) => {
   return TEXT_PROP_TYPE_KEYS.has(key);
 };
@@ -3551,7 +3701,7 @@ var isInlineEditingAllowed = ({ rawValue, propTypeFromSchema }) => {
   if (rawValue === null || rawValue === void 0) {
     return isAllowedBySchema(propTypeFromSchema);
   }
-  return import_editor_props3.htmlV3PropTypeUtil.isValid(rawValue) || import_editor_props3.stringPropTypeUtil.isValid(rawValue);
+  return import_editor_props3.escapedHtmlPropTypeUtil.isValid(rawValue) || import_editor_props3.htmlV3PropTypeUtil.isValid(rawValue) || import_editor_props3.stringPropTypeUtil.isValid(rawValue);
 };
 
 // src/legacy/replacements/inline-editing/inline-editing-elements.tsx
@@ -3636,17 +3786,26 @@ var InlineEditingReplacement = class extends ReplacementBase {
   }
   getExtractedContentValue() {
     const propValue = this.getInlineEditablePropValue();
+    if (import_editor_props4.escapedHtmlPropTypeUtil.isValid(propValue)) {
+      return import_editor_props4.escapedHtmlPropTypeUtil.extract(propValue) ?? "";
+    }
     const extracted = import_editor_props4.htmlV3PropTypeUtil.extract(propValue);
     return import_editor_props4.stringPropTypeUtil.extract(extracted?.content ?? null) ?? "";
   }
+  createContentPropValue(value) {
+    const content = value || "";
+    const propTypeKey = this.getInlineEditablePropTypeKey();
+    if (propTypeKey === import_editor_props4.htmlV3PropTypeUtil.key) {
+      return import_editor_props4.htmlV3PropTypeUtil.create({
+        content: import_editor_props4.stringPropTypeUtil.create(content),
+        children: []
+      });
+    }
+    return import_editor_props4.escapedHtmlPropTypeUtil.create(content);
+  }
   setContentValue(value) {
     const settingKey = this.getInlineEditablePropertyName();
-    const html = value || "";
-    const parsed = (0, import_editor_props4.parseHtmlChildren)(html);
-    const valueToSave = import_editor_props4.htmlV3PropTypeUtil.create({
-      content: parsed.content ? import_editor_props4.stringPropTypeUtil.create(parsed.content) : null,
-      children: parsed.children
-    });
+    const valueToSave = this.createContentPropValue(value);
     (0, import_editor_v1_adapters13.undoable)(
       {
         do: () => {
@@ -3675,7 +3834,7 @@ var InlineEditingReplacement = class extends ReplacementBase {
       return null;
     }
     if (propType.kind === "union") {
-      const textKeys = [import_editor_props4.htmlV3PropTypeUtil.key, import_editor_props4.stringPropTypeUtil.key];
+      const textKeys = [import_editor_props4.escapedHtmlPropTypeUtil.key, import_editor_props4.htmlV3PropTypeUtil.key, import_editor_props4.stringPropTypeUtil.key];
       for (const key of textKeys) {
         if (propType.prop_types[key]) {
           return key;
@@ -3930,6 +4089,52 @@ function createNestedTemplatedType(type, renderer, element) {
   });
 }
 
+// src/legacy/list-type.ts
+var LIST_TYPE = "e-list";
+function initListType() {
+  registerElementType(
+    LIST_TYPE,
+    (options) => createListType(options)
+  );
+}
+function createListType(options) {
+  const BaseType = createNestedTemplatedElementType(options);
+  let ListView = null;
+  return class extends BaseType {
+    getView() {
+      if (!ListView) {
+        ListView = createListView(options);
+      }
+      return ListView;
+    }
+  };
+}
+function createListView(options) {
+  const BaseView = createNestedTemplatedElementView(options);
+  return BaseView.extend({
+    getRenderContext() {
+      const parentContext = this._parent?.getRenderContext?.();
+      const settings = this.model.get("settings");
+      const showMarkersProp = settings?.get?.("show_markers");
+      const showMarkers = showMarkersProp?.value ?? showMarkersProp ?? true;
+      return {
+        ...parentContext,
+        show_markers: showMarkers
+      };
+    },
+    getResolverRenderContext() {
+      const parentContext = this._parent?.getResolverRenderContext?.();
+      const settings = this.model.get("settings");
+      const showMarkersProp = settings?.get?.("show_markers");
+      const showMarkers = showMarkersProp?.value ?? showMarkersProp ?? true;
+      return {
+        ...parentContext,
+        show_markers: showMarkers
+      };
+    }
+  });
+}
+
 // src/legacy/tabs-model-extensions.ts
 var import_editor_props5 = require("@elementor/editor-props");
 var tabModelExtensions = {
@@ -3947,10 +4152,7 @@ var tabModelExtensions = {
       ...paragraphElement,
       settings: {
         ...paragraphElement.settings,
-        paragraph: import_editor_props5.htmlV3PropTypeUtil.create({
-          content: import_editor_props5.stringPropTypeUtil.create(`Tab ${position}`),
-          children: []
-        })
+        paragraph: import_editor_props5.escapedHtmlPropTypeUtil.create(`Tab ${position}`)
       }
     };
     return [updatedParagraph, ...elements.slice(1)];
@@ -3961,22 +4163,22 @@ function initTabsModelExtensions() {
 }
 
 // src/mcp/canvas-mcp.ts
-var import_editor_props9 = require("@elementor/editor-props");
+var import_editor_props8 = require("@elementor/editor-props");
 
 // src/mcp/resources/available-widgets-resource.ts
 var import_http_client3 = require("@elementor/http-client");
 var MCP_PROXY_URL2 = "elementor/v1/mcp-proxy";
 var AVAILABLE_WIDGETS_URI = "elementor://context/available-widgets";
 var AVAILABLE_WIDGETS_URI_V4 = "elementor://context/available-widgets/v4";
-var fetchWidgets = async (version) => {
+var fetchWidgets = async () => {
   const { data } = await (0, import_http_client3.httpService)().post(MCP_PROXY_URL2, {
-    tool: "list-widgets",
-    input: version ? { version } : {}
+    tool: "list-widget-schemas",
+    input: { summary: true }
   });
-  return data.data ?? [];
+  return data.data?.widgets ?? [];
 };
-var buildContents = async (uri, version) => {
-  const widgets = await fetchWidgets(version);
+var buildContents = async (uri) => {
+  const widgets = await fetchWidgets();
   return {
     contents: [
       {
@@ -3995,13 +4197,13 @@ var initAvailableWidgetsResource = (reg) => {
     {
       description: "All registered v4 version widgets"
     },
-    async () => buildContents(AVAILABLE_WIDGETS_URI_V4, "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)
   );
@@ -4134,11 +4336,10 @@ var import_http_client5 = require("@elementor/http-client");
 var DYNAMIC_TAGS_URI = "elementor://dynamic-tags";
 var MCP_PROXY_URL4 = "elementor/v1/mcp-proxy";
 var fetchDynamicTags = async () => {
-  const { data } = await (0, import_http_client5.httpService)().post(MCP_PROXY_URL4, {
-    tool: "list-dynamic-tags",
-    input: {}
+  const { data } = await (0, import_http_client5.httpService)().get(MCP_PROXY_URL4, {
+    params: { uri: DYNAMIC_TAGS_URI }
   });
-  return data.data ?? [];
+  return data.data ?? "[]";
 };
 var initDynamicTagsResource = (reg) => {
   const { resource } = reg;
@@ -4150,13 +4351,12 @@ var initDynamicTagsResource = (reg) => {
       mimeType: "application/json"
     },
     async (uri) => {
-      const tags = await fetchDynamicTags();
       return {
         contents: [
           {
             uri: uri.href,
             mimeType: "application/json",
-            text: JSON.stringify(tags)
+            text: await fetchDynamicTags()
           }
         ]
       };
@@ -4479,104 +4679,13 @@ function getElementDisplayName(container) {
   }
 }
 
-// src/mcp/tools/build-composition/tool.ts
-var import_editor_documents2 = require("@elementor/editor-documents");
-var import_editor_elements11 = require("@elementor/editor-elements");
-var import_http_client6 = require("@elementor/http-client");
-var import_schema = require("@elementor/schema");
-var MCP_PROXY_URL5 = "elementor/v1/mcp-proxy";
-var initBuildCompositionTool = (reg) => {
-  const { addTool } = reg;
-  addTool({
-    name: "build-composition",
-    description: "Build a V4 element composition on the Elementor canvas via the server-side MCP ability. Pass the raw XML tags directly as xmlStructure \u2014 do NOT wrap the value in <![CDATA[ ... ]]>, code fences, or quotes. The document is saved as a draft. Reload the editor after calling this tool to see the result.",
-    schema: {
-      xmlStructure: import_schema.z.string().describe(
-        'Valid XML structure with custom Elementor widget tags. Every element MUST have a unique configuration-id attribute (e.g. <e-heading configuration-id="hero-title"></e-heading>). No attributes, classes, IDs, or text nodes in XML. Pass raw XML \u2014 do not wrap in CDATA.'
-      ),
-      elementConfig: import_schema.z.record(
-        import_schema.z.string().describe("configuration-id"),
-        import_schema.z.record(import_schema.z.string().describe("property name"), import_schema.z.any().describe("PropValue"))
-      ).optional().describe("Map configuration-id \u2192 widget PropValues ($$type + value)."),
-      style: import_schema.z.record(
-        import_schema.z.string().describe("configuration-id"),
-        import_schema.z.record(import_schema.z.string().describe("CSS property name"), import_schema.z.string().describe("CSS value"))
-      ).optional().describe(
-        "Map configuration-id \u2192 raw CSS declarations (property \u2192 value strings; no selectors). Server converts to native styles; unconvertible declarations become the element custom CSS."
-      ),
-      parentId: import_schema.z.string().optional().describe("ID of the parent container. Omit or pass 'document' to insert at document root."),
-      dryRun: import_schema.z.boolean().optional().describe("If true, validate and return the resolved tree without persisting.")
-    },
-    outputSchema: {
-      rootElementIds: import_schema.z.array(import_schema.z.string()),
-      previewUrl: import_schema.z.string(),
-      version: import_schema.z.string(),
-      resolvedXml: import_schema.z.string(),
-      llmInstructions: import_schema.z.string(),
-      warnings: import_schema.z.array(import_schema.z.string()).optional()
-    },
-    handler: async ({ xmlStructure, elementConfig, style, parentId, dryRun }) => {
-      const document2 = (0, import_editor_documents2.getCurrentDocument)();
-      if (!document2?.id) {
-        throw new Error("No active document found.");
-      }
-      try {
-        const { data } = await (0, import_http_client6.httpService)().post(MCP_PROXY_URL5, {
-          tool: "build-composition",
-          input: {
-            post_id: document2.id,
-            xml_structure: xmlStructure,
-            element_config: elementConfig ?? {},
-            style: style ?? {},
-            parent_id: parentId ?? "document",
-            dry_run: dryRun ?? false
-          }
-        });
-        if (!dryRun) {
-          await (0, import_editor_documents2.reloadCurrentDocument)();
-          const [firstRootId] = data.data.root_element_ids;
-          if (firstRootId) {
-            (0, import_editor_elements11.selectElement)(firstRootId);
-            (0, import_editor_elements11.getContainer)(firstRootId)?.view?.el?.scrollIntoView({
-              behavior: "smooth",
-              block: "center"
-            });
-          }
-        }
-        return {
-          rootElementIds: data.data.root_element_ids,
-          previewUrl: data.data.preview_url,
-          version: data.data.version,
-          resolvedXml: data.data.resolved_xml,
-          llmInstructions: data.data.llm_instructions,
-          warnings: data.data.warnings
-        };
-      } catch (error) {
-        throw new Error(getErrorMessage(error));
-      }
-    }
-  });
-};
-function getErrorMessage(error) {
-  if (error instanceof import_http_client6.AxiosError) {
-    const data = error.response?.data;
-    if (data?.message) {
-      return data.code ? `${data.code}: ${data.message}` : data.message;
-    }
-  }
-  if (error instanceof Error) {
-    return error.message;
-  }
-  return "build-composition failed with an unknown error.";
-}
-
 // src/mcp/tools/configure-element/tool.ts
-var import_editor_elements14 = require("@elementor/editor-elements");
+var import_editor_elements13 = require("@elementor/editor-elements");
 var import_editor_mcp3 = require("@elementor/editor-mcp");
 var import_editor_props7 = require("@elementor/editor-props");
 
 // src/mcp/utils/do-update-element-property.ts
-var import_editor_elements13 = require("@elementor/editor-elements");
+var import_editor_elements12 = require("@elementor/editor-elements");
 var import_editor_props6 = require("@elementor/editor-props");
 var import_editor_styles4 = require("@elementor/editor-styles");
 var import_editor_v1_adapters20 = require("@elementor/editor-v1-adapters");
@@ -4596,10 +4705,10 @@ var readStoredCustomCssText = (raw) => {
 };
 
 // src/mcp/utils/resolve-canonical-prop-name.ts
-var import_editor_elements12 = require("@elementor/editor-elements");
-function buildAliasToCanonicalMap(schema2) {
+var import_editor_elements11 = require("@elementor/editor-elements");
+function buildAliasToCanonicalMap(schema) {
   const aliasToCanonical = {};
-  for (const [canonical, propType] of Object.entries(schema2)) {
+  for (const [canonical, propType] of Object.entries(schema)) {
     const aliases = propType.meta?.aliases;
     if (!Array.isArray(aliases)) {
       continue;
@@ -4613,26 +4722,26 @@ function buildAliasToCanonicalMap(schema2) {
   return aliasToCanonical;
 }
 function resolveCanonicalPropName(elementType, propertyName) {
-  const schema2 = (0, import_editor_elements12.getWidgetsCache)()?.[elementType]?.atomic_props_schema;
-  if (!schema2 || schema2[propertyName]) {
+  const schema = (0, import_editor_elements11.getWidgetsCache)()?.[elementType]?.atomic_props_schema;
+  if (!schema || schema[propertyName]) {
     return propertyName;
   }
-  return buildAliasToCanonicalMap(schema2)[propertyName] ?? propertyName;
+  return buildAliasToCanonicalMap(schema)[propertyName] ?? propertyName;
 }
 function resolveCanonicalPropKeys(elementType, props) {
-  const schema2 = (0, import_editor_elements12.getWidgetsCache)()?.[elementType]?.atomic_props_schema;
-  if (!schema2) {
+  const schema = (0, import_editor_elements11.getWidgetsCache)()?.[elementType]?.atomic_props_schema;
+  if (!schema) {
     return { ...props };
   }
-  const aliasToCanonical = buildAliasToCanonicalMap(schema2);
+  const aliasToCanonical = buildAliasToCanonicalMap(schema);
   const resolved = {};
   for (const [key, value] of Object.entries(props)) {
-    if (schema2[key]) {
+    if (schema[key]) {
       resolved[key] = value;
     }
   }
   for (const [key, value] of Object.entries(props)) {
-    if (schema2[key]) {
+    if (schema[key]) {
       continue;
     }
     const canonical = aliasToCanonical[key];
@@ -4680,9 +4789,9 @@ var dynamicTagLLMResolver = (value) => {
     }
   };
 };
-var buildStrictSettings = (schema2, provided) => {
+var buildStrictSettings = (schema, provided) => {
   const settings = {};
-  for (const [key, propType] of Object.entries(schema2)) {
+  for (const [key, propType] of Object.entries(schema)) {
     if (OMITTED_DYNAMIC_SETTING_KEYS.includes(key)) {
       continue;
     }
@@ -4714,6 +4823,20 @@ var LOCAL_STYLE_META = {
   breakpoint: "desktop",
   state: null
 };
+var UnsupportedPropertyError = class extends Error {
+  elementType;
+  propertyName;
+  constructor(elementType, propertyName, availableProperties) {
+    super(
+      `Property "${propertyName}" does not exist on element type "${elementType}". Available properties are: ${availableProperties.join(
+        ", "
+      )}`
+    );
+    this.name = "UnsupportedPropertyError";
+    this.elementType = elementType;
+    this.propertyName = propertyName;
+  }
+};
 function resolvePropValue(value, forceKey) {
   const Utils = window.elementorV2.editorVariables.Utils;
   return import_editor_props6.Schema.adjustLlmPropValueSchema(value, {
@@ -4728,7 +4851,7 @@ var doUpdateElementProperty = (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_elements12.getElementStyles)(elementId) || {};
     const propertyMapValue = propertyValue;
     const styleSchema = (0, import_editor_styles4.getStylesSchema)();
     const transformedStyleValues = Object.fromEntries(
@@ -4785,7 +4908,7 @@ var doUpdateElementProperty = (params) => {
     });
     delete transformedStyleValues.custom_css;
     if (!localStyle) {
-      (0, import_editor_elements13.createElementStyle)({
+      (0, import_editor_elements12.createElementStyle)({
         elementId,
         ...typeof customCss !== "undefined" ? { custom_css: customCss } : {},
         classesProp: "classes",
@@ -4799,7 +4922,7 @@ var doUpdateElementProperty = (params) => {
         }
       });
     } else {
-      (0, import_editor_elements13.updateElementStyle)({
+      (0, import_editor_elements12.updateElementStyle)({
         elementId,
         styleId: localStyle.id,
         meta: {
@@ -4814,17 +4937,12 @@ var doUpdateElementProperty = (params) => {
     }
     return;
   }
-  const elementPropSchema = (0, import_editor_elements13.getWidgetsCache)()?.[elementType]?.atomic_props_schema;
+  const elementPropSchema = (0, import_editor_elements12.getWidgetsCache)()?.[elementType]?.atomic_props_schema;
   if (!elementPropSchema) {
     throw new Error(`No prop schema found for element type: ${elementType}`);
   }
   if (!elementPropSchema[propertyName]) {
-    const propertyNames = Object.keys(elementPropSchema);
-    throw new Error(
-      `Property "${propertyName}" does not exist on element type "${elementType}". Available properties are: ${propertyNames.join(
-        ", "
-      )}`
-    );
+    throw new UnsupportedPropertyError(elementType, propertyName, Object.keys(elementPropSchema));
   }
   const propKey = elementPropSchema[propertyName].key;
   const value = resolvePropValue(propertyValue, propKey);
@@ -4837,7 +4955,7 @@ var doUpdateElementProperty = (params) => {
 Expected Schema: ${jsonSchema}`
     );
   }
-  (0, import_editor_elements13.updateElementSettings)({
+  (0, import_editor_elements12.updateElementSettings)({
     id: elementId,
     props: {
       [propertyName]: value
@@ -4894,8 +5012,6 @@ For all non-primitive entries in \`propertiesToChange\`, provide the schema \`ke
 
 Use the EXACT PropType schema given, and ALWAYS include the \`key\` from the schema for every property you are changing in \`propertiesToChange\`.
 
-Check \`llm_guidance.default_settings\` in the widget schema \u2014 include a key in \`propertiesToChange\` only when the user explicitly asks to change it.
-
 # Dynamic tags
 A value can be made dynamic wherever its schema exposes a variant with "$$type": "dynamic". This may be the property root OR a NESTED field: for example an image is made dynamic on its "src" (the root stays "image"), NOT on the whole "image" value.
 Put the dynamic object EXACTLY at the node whose schema offers the "dynamic" variant, in place of the static variant. The variant's "name" enumerates the tags allowed at that node.
@@ -4922,7 +5038,7 @@ Do NOT send "group" (it is resolved automatically). Use { "settings": {} } only
   );
   configureElementToolPrompt.parameter(
     "style",
-    'A flat map of raw CSS declarations (property \u2192 value), e.g. { "line-height": "1.25rem", "color": "var(--primary-text, #000)" }. Set a value to null to reset that property to its default. OPTIONAL.'
+    'A flat map of raw CSS declarations (property \u2192 value), e.g. { "line-height": "1.25rem", "color": "var(--primary-text, #000)" }. font-family must be a single Google Font name or a var(--label) \u2014 no fallback stacks. Set a value to null to reset that property to its default. OPTIONAL.'
   );
   configureElementToolPrompt.example(`
 \`\`\`json
@@ -4954,36 +5070,39 @@ Do NOT send "group" (it is resolved automatically). Use { "settings": {} } only
 V4 only: If MCP fails, give manual steps using V4 UI.
 
 V4 Editor structure:
-Panel tabs: General (\u2192 Settings section: ID, Tag, Link), Style, Interactions.
+Panel tabs: General (\u2192 Settings section: ID, Tag, and Link where the widget supports it), Style, Interactions.
 NO Advanced tab. Never mention Advanced tab.
+Note: \`link\` is valid only when the element's PropType schema (which you must already have) includes a \`link\` property. Sending \`link\` to a widget whose schema lacks it is skipped and reported in the response \`warnings\` (other changes still apply) and the link is lost.
 `);
   return configureElementToolPrompt.prompt();
 };
-var CONFIGURE_ELEMENT_GUIDE_TEXT = generatePrompt();
 
 // src/mcp/tools/configure-element/schema.ts
-var import_schema2 = require("@elementor/schema");
+var import_schema = require("@elementor/schema");
 var inputSchema = {
-  propertiesToChange: import_schema2.z.record(
-    import_schema2.z.string().describe("The property name."),
-    import_schema2.z.any().describe(`PropValue, refer to [${WIDGET_SCHEMA_URI}] by correct type, as appears in elementType`),
-    import_schema2.z.any()
+  propertiesToChange: import_schema.z.record(
+    import_schema.z.string().describe("The property name."),
+    import_schema.z.any().describe(`PropValue, refer to [${WIDGET_SCHEMA_URI}] by correct type, as appears in elementType`),
+    import_schema.z.any()
   ).describe("An object record containing property names and their new values to be set on the element"),
-  style: import_schema2.z.record(
-    import_schema2.z.string().describe('A CSS property name, e.g. "color", "margin-top".'),
-    import_schema2.z.string().nullable().describe(
+  style: import_schema.z.record(
+    import_schema.z.string().describe('A CSS property name, e.g. "color", "margin-top".'),
+    import_schema.z.string().nullable().describe(
       'A CSS value, e.g. "red", "10px", "1px solid #000". Use null to reset the property to its default.'
     )
   ).describe(
     "Raw CSS declarations as a flat property\u2192value map. Converted to native styles server-side; any declaration that cannot be converted is stored as the element custom CSS. A null value resets that property to its default."
   ).default({}),
-  elementType: import_schema2.z.string().describe("The type of the element to retrieve the schema"),
-  elementId: import_schema2.z.string().describe("The unique id of the element to configure")
+  elementType: import_schema.z.string().describe("The type of the element to retrieve the schema"),
+  elementId: import_schema.z.string().describe("The unique id of the element to configure")
 };
 var outputSchema = {
-  success: import_schema2.z.boolean().describe(
+  success: import_schema.z.boolean().describe(
     "Whether the configuration change was successful, only if propertyName and propertyValue are provided"
-  )
+  ),
+  warnings: import_schema.z.string().describe(
+    'Non-fatal notices. Present when some props were skipped because they are not in the element schema (e.g. a "link" on a widget with no link prop). Other changes were still applied.'
+  ).optional()
 };
 
 // src/mcp/tools/configure-element/tool.ts
@@ -5012,13 +5131,13 @@ var initConfigureElementTool = (reg) => {
       { description: "Dynamic tags catalog", uri: DYNAMIC_TAGS_URI }
     ],
     handler: async ({ elementId, propertiesToChange, elementType, style }) => {
-      const widgetData = (0, import_editor_elements14.getWidgetsCache)()?.[elementType];
+      const widgetData = (0, import_editor_elements13.getWidgetsCache)()?.[elementType];
       if (!widgetData) {
         throw new Error(
           `Unknown element type: ${elementType}. Check the available-widgets resource for valid types.`
         );
       }
-      const container = (0, import_editor_elements14.getContainer)(elementId);
+      const container = (0, import_editor_elements13.getContainer)(elementId);
       if (!container) {
         throw new Error(`Element with id ${elementId} not found`);
       }
@@ -5033,6 +5152,7 @@ var initConfigureElementTool = (reg) => {
       }
       const propertiesToUpdate = resolveCanonicalPropKeys(elementType, propertiesToChange);
       const toUpdate = Object.entries(propertiesToUpdate);
+      const skippedProps = [];
       for (const [propertyName, propertyValue] of toUpdate) {
         if (!import_editor_props7.Schema.isPropKeyConfigurable(propertyName)) {
           throw new Error(`Not allowed to update ${propertyName}`);
@@ -5045,6 +5165,10 @@ var initConfigureElementTool = (reg) => {
             propertyValue
           });
         } catch (error) {
+          if (error instanceof UnsupportedPropertyError) {
+            skippedProps.push(error.propertyName);
+            continue;
+          }
           const errorMessage = createUpdateErrorMessage({
             propertyName,
             elementId,
@@ -5057,7 +5181,10 @@ var initConfigureElementTool = (reg) => {
       }
       await applyStyleFromCss({ elementId, elementType, style });
       return {
-        success: true
+        success: true,
+        warnings: skippedProps.length ? `Skipped unsupported props (not in the "${elementType}" schema; other changes were applied): ${skippedProps.join(
+          ", "
+        )}.` : void 0
       };
     }
   });
@@ -5109,143 +5236,74 @@ Provide styling as raw CSS via the "style" parameter (a flat map of CSS property
 }`;
 }
 
-// src/mcp/tools/create-element/tool.ts
-var import_editor_documents3 = require("@elementor/editor-documents");
+// src/mcp/tools/get-page-structure/tool.ts
+var import_editor_documents2 = require("@elementor/editor-documents");
 var import_http_client7 = require("@elementor/http-client");
-var import_schema4 = require("@elementor/schema");
-var MCP_PROXY_URL6 = "elementor/v1/mcp-proxy";
-var initCreateElementTool = (reg) => {
+var import_schema3 = require("@elementor/schema");
+
+// src/mcp/utils/get-mcp-error-message.ts
+var import_http_client6 = require("@elementor/http-client");
+function getMcpErrorMessage(error, toolName) {
+  if (error instanceof import_http_client6.AxiosError) {
+    const data = error.response?.data;
+    if (data?.message) {
+      return data.code ? `${data.code}: ${data.message}` : data.message;
+    }
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return `${toolName} failed with an unknown error.`;
+}
+
+// src/mcp/tools/get-page-structure/tool.ts
+var MCP_PROXY_URL5 = "elementor/v1/mcp-proxy";
+var initGetPageStructureTool = (reg) => {
   const { addTool } = reg;
   addTool({
-    name: "create-element",
-    description: "Insert a new element into the current Elementor document via the server-side MCP ability. The document is saved as a draft. Reload the editor after calling this tool to see the result.",
+    name: "get-page-structure",
+    description: "Returns a lean Elementor element tree skeleton (id, elType, widgetType, title, nested elements) for a post or page. If no postId is provided, uses the currently open document. Optionally scope to a subtree with elementId. Set includeContent=true (requires elementId) to also return each node's settings and styles.",
     schema: {
-      elementType: import_schema4.z.string().describe("Registry identifier of the element to create, e.g. 'e-heading', 'e-flexbox'."),
-      parentId: import_schema4.z.string().optional().describe("ID of the parent container. Omit or pass 'document' to insert at the document root.")
+      postId: import_schema3.z.number().optional().describe(
+        "WordPress post ID of the Elementor document. If omitted, uses the currently open document."
+      ),
+      elementId: import_schema3.z.string().optional().describe("If provided, returns only the subtree rooted at that element id."),
+      includeContent: import_schema3.z.boolean().optional().describe(
+        "If true, includes each node's settings and styles (same shape build-composition accepts as input). Requires elementId."
+      )
     },
     outputSchema: {
-      elementId: import_schema4.z.string(),
-      previewUrl: import_schema4.z.string(),
-      version: import_schema4.z.string()
+      elements: import_schema3.z.array(import_schema3.z.any()).describe(
+        "Skeleton of Elementor elements (id, elType, widgetType, title, nested elements). When includeContent is true, each node also includes settings and styles."
+      )
     },
-    handler: async ({ elementType, parentId }) => {
-      const document2 = (0, import_editor_documents3.getCurrentDocument)();
-      if (!document2?.id) {
-        throw new Error("No active document found.");
-      }
-      const { data } = await (0, import_http_client7.httpService)().post(MCP_PROXY_URL6, {
-        tool: "create-element",
-        input: {
-          parent_id: parentId ?? "document",
-          element: { type: elementType },
-          post_id: document2.id
-        }
-      });
-      return {
-        elementId: data.data.element_id,
-        previewUrl: data.data.preview_url,
-        version: data.data.version
-      };
-    }
-  });
-};
-
-// src/mcp/tools/get-element-config/tool.ts
-var import_editor_elements15 = require("@elementor/editor-elements");
-var import_editor_props8 = require("@elementor/editor-props");
-var import_schema5 = require("@elementor/schema");
-var schema = {
-  elementId: import_schema5.z.string()
-};
-var outputSchema2 = {
-  properties: import_schema5.z.record(import_schema5.z.string(), import_schema5.z.any()).describe("A record mapping PropTypes to their corresponding PropValues"),
-  style: import_schema5.z.record(import_schema5.z.string(), import_schema5.z.any()).describe("A record mapping StyleSchema properties to their corresponding PropValues"),
-  childElements: import_schema5.z.array(
-    import_schema5.z.object({
-      id: import_schema5.z.string(),
-      elementType: import_schema5.z.string(),
-      childElements: import_schema5.z.array(import_schema5.z.any()).describe("An array of child element IDs, when applicable, same structure recursively")
-    })
-  ).describe("An array of child element IDs, when applicable, with recursive structure")
-};
-var structuredElements = (element) => {
-  const children = element.children || [];
-  return children.map((child) => {
-    return {
-      id: child.id,
-      elementType: child.model.get("elType") || child.model.get("widgetType") || "unknown",
-      childElements: structuredElements(child)
-    };
-  });
-};
-var initGetElementConfigTool = (reg) => {
-  const { addTool } = reg;
-  addTool({
-    name: "get-element-configuration-values",
-    description: "Retrieve the element's configuration PropValues for a specific element by unique ID.",
-    schema,
-    outputSchema: outputSchema2,
-    handler: async ({ elementId }) => {
-      const element = (0, import_editor_elements15.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_elements15.getWidgetsCache)()?.[elementType];
-      if (!widgetData) {
-        throw new Error(
-          `Unknown element type: ${elementType}. Check the available-widgets resource for valid types.`
-        );
-      }
-      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 elementRawSettings = element.settings;
-      const propSchema = (0, import_editor_elements15.getWidgetsCache)()?.[elementType]?.atomic_props_schema;
-      if (!elementRawSettings || !propSchema) {
-        throw new Error(`No settings or prop schema found for element ID: ${elementId}`);
+    handler: async ({ postId, elementId, includeContent }) => {
+      const resolvedPostId = postId ?? (0, import_editor_documents2.getCurrentDocument)()?.id;
+      if (!resolvedPostId) {
+        throw new Error("No post ID provided and no active document found.");
       }
-      const propValues = {};
-      const stylePropValues = {};
-      import_editor_props8.Schema.configurableKeys(propSchema).forEach((key) => {
-        propValues[key] = structuredClone(elementRawSettings.get(key));
-      });
-      const elementStyles = (0, import_editor_elements15.getElementStyles)(elementId) || {};
-      const localStyle = Object.values(elementStyles).find((style) => style.label === "local");
-      if (localStyle) {
-        const defaultVariant = localStyle.variants.find(
-          (variant) => variant.meta.breakpoint === "desktop" && !variant.meta.state
-        );
-        if (defaultVariant) {
-          const styleProps = defaultVariant.props || {};
-          Object.keys(styleProps).forEach((stylePropName) => {
-            if (typeof styleProps[stylePropName] !== "undefined") {
-              stylePropValues[stylePropName] = structuredClone(styleProps[stylePropName]);
-            }
-          });
-          if (defaultVariant.custom_css) {
-            stylePropValues.custom_css = atob(defaultVariant.custom_css.raw);
+      try {
+        const { data } = await (0, import_http_client7.httpService)().post(MCP_PROXY_URL5, {
+          tool: "get-page-structure",
+          input: {
+            post_id: resolvedPostId,
+            ...elementId ? { element_id: elementId } : {},
+            ...includeContent ? { include_content: true } : {}
           }
-        }
+        });
+        return {
+          elements: data.data.elements
+        };
+      } catch (error) {
+        throw new Error(getMcpErrorMessage(error, "get-page-structure"));
       }
-      return {
-        properties: {
-          ...propValues
-        },
-        style: {
-          ...stylePropValues
-        },
-        childElements: structuredElements(element)
-      };
     }
   });
 };
 
 // src/mcp/canvas-mcp.ts
 var initCanvasMcp = (reg) => {
-  import_editor_props9.Schema.setDynamicTagNamesResolver(getDynamicTagNamesByCategories);
+  import_editor_props8.Schema.setDynamicTagNamesResolver(getDynamicTagNamesByCategories);
   initWidgetsSchemaResource(reg);
   initAvailableWidgetsResource(reg);
   initDocumentStructureResource(reg);
@@ -5254,17 +5312,15 @@ var initCanvasMcp = (reg) => {
   initEditorStateResource(reg);
   initGeneralContextResource(reg);
   initBestPracticesResource(reg);
-  initGetElementConfigTool(reg);
   initConfigureElementTool(reg);
-  initCreateElementTool(reg);
-  initBuildCompositionTool(reg);
+  initGetPageStructureTool(reg);
   initBreakpointsResource(reg);
 };
 
 // src/mcp/mcp-description.ts
 var ELEMENT_SCHEMA_URI = WIDGET_SCHEMA_URI.replace("{widgetType}", "element-schema");
 var mcpDescription = `Elementor Canvas MCP
-This MCP enables creation, configuration, and styling of elements on the Elementor canvas using the build_composition tool.
+This MCP enables configuration and styling of existing V4 elements on the Elementor canvas using the configure-element tool.
 
 # Core Concepts
 
@@ -5283,66 +5339,54 @@ The \`$$type\` defines how Elementor interprets the value. Providing the correct
 - **Global Classes**: Reusable style sets that can be applied to elements (\`elementor://global-classes\`)
 - **Widget Schemas**: Configuration options for each widget type (\`${WIDGET_SCHEMA_URI}\`)
 
-# Building Compositions with build_composition
+# Configuring Elements with configure-element
 
-The \`build_composition\` tool is the primary way to create elements. It accepts structure (XML), configuration, and styling in a single operation.
+The \`configure-element\` tool updates settings and styles on existing V4 elements. Read the configure-element guide resource before use.
 
 ## Complete Workflow
 
 ### 1. Parse User Requirements
-Understand what needs to be built: structure, content, and styling.
+Understand what needs to change: content, settings, or styling on existing elements.
 
 ### 2. Check Global Resources FIRST
-Always check existing resources before building:
+Always check existing resources before styling:
 - List \`elementor://global-variables\` for available variables (colors, sizes, fonts)
 - List \`elementor://global-classes\` for available style sets
 - **Always prefer using existing global resources over creating inline styles**
 
 ### 3. Retrieve Widget Schemas
-For each widget you'll use:
+For each element you will configure:
 - List \`${WIDGET_SCHEMA_URI}\` to see available widgets
 - Retrieve configuration schema from \`${ELEMENT_SCHEMA_URI}\` for each widget
-- Check the \`llm_guidance\` property for container nesting, \`default_styles\`, and \`default_settings\` (omit default_settings from elementConfig unless the user asks to change them)
+- Check the \`llm_guidance\` property for container nesting, \`default_styles\`, and \`default_settings\`
 
-### 4. Build XML Structure
-Create valid XML with configuration-ids:
-- Each element must have a unique \`configuration-id\` attribute
-- No text nodes, classes, or IDs in XML - structure only
-- Example:
-\`\`\`xml
-<e-container configuration-id="container-1">
-  <e-heading configuration-id="heading-1" />
-  <e-text configuration-id="text-1" />
-</e-container>
-\`\`\`
+### 4. Get Current Element State
+Use page structure and element configuration resources to find element IDs and current values.
 
-### 5. Create elementConfig
-Map each configuration-id to its widget properties using PropValues:
+### 5. Create propertiesToChange
+Map property names to PropValues using the widget schema:
 - Use correct \`$$type\` matching the widget's schema
 - Use global variables in PropValues where applicable
 - Example:
 \`\`\`json
 {
-  "heading-1": {
-    "text": { "$$type": "string", "value": "Welcome" },
-    "tag": { "$$type": "string", "value": "h1" }
-  }
+  "text": { "$$type": "string", "value": "Welcome" },
+  "tag": { "$$type": "string", "value": "h1" }
 }
 \`\`\`
 
 ### 6. Create style
-Map each configuration-id to raw CSS declarations (property \u2192 value strings). The server converts them to native styles and stores any unconvertible declarations as the element custom CSS.
+Provide raw CSS declarations (property \u2192 value strings). The server converts them to native styles and stores any unconvertible declarations as the element custom CSS.
 - Example:
 \`\`\`json
 {
-  "heading-1": "color: #1a1a1a; font-size: 2rem;"
-  }
+  "color": "#1a1a1a",
+  "font-size": "2rem"
 }
 \`\`\`
 
-### 7. Execute build_composition
-Call the tool with your XML structure, elementConfig, and style. The response will contain the created element IDs.
-At the response you will also find llm_instructions for you to do afterwards, read and follow them!
+### 7. Execute configure-element
+Call the tool with elementId, elementType, propertiesToChange, and style as needed.
 
 ## Key Points
 
@@ -5370,7 +5414,7 @@ Note: The "size" property controls image resolution/loading, not visual size. Se
 `;
 
 // src/prevent-link-in-link-commands.ts
-var import_editor_elements16 = require("@elementor/editor-elements");
+var import_editor_elements14 = require("@elementor/editor-elements");
 var import_editor_notifications3 = require("@elementor/editor-notifications");
 var import_editor_v1_adapters21 = require("@elementor/editor-v1-adapters");
 var import_i18n4 = require("@wordpress/i18n");
@@ -5441,25 +5485,25 @@ function shouldBlock(sourceElements, targetElements) {
     return false;
   }
   const isSourceContainsAnAnchor = sourceElements.some((src) => {
-    return src?.id ? (0, import_editor_elements16.isElementAnchored)(src.id) || !!(0, import_editor_elements16.getAnchoredDescendantId)(src.id) : false;
+    return src?.id ? (0, import_editor_elements14.isElementAnchored)(src.id) || !!(0, import_editor_elements14.getAnchoredDescendantId)(src.id) : false;
   });
   if (!isSourceContainsAnAnchor) {
     return false;
   }
   const isTargetContainsAnAnchor = targetElements.some((target) => {
-    return target?.id ? (0, import_editor_elements16.isElementAnchored)(target.id) || !!(0, import_editor_elements16.getAnchoredAncestorId)(target.id) : false;
+    return target?.id ? (0, import_editor_elements14.isElementAnchored)(target.id) || !!(0, import_editor_elements14.getAnchoredAncestorId)(target.id) : false;
   });
   return isTargetContainsAnAnchor;
 }
 
 // src/style-commands/paste-style.ts
-var import_editor_elements19 = require("@elementor/editor-elements");
-var import_editor_props11 = require("@elementor/editor-props");
+var import_editor_elements17 = require("@elementor/editor-elements");
+var import_editor_props10 = require("@elementor/editor-props");
 var import_editor_v1_adapters23 = require("@elementor/editor-v1-adapters");
 
 // src/utils/command-utils.ts
-var import_editor_elements17 = require("@elementor/editor-elements");
-var import_editor_props10 = require("@elementor/editor-props");
+var import_editor_elements15 = require("@elementor/editor-elements");
+var import_editor_props9 = require("@elementor/editor-props");
 var import_i18n5 = require("@wordpress/i18n");
 function hasAtomicWidgets(args) {
   const { containers = [args.container] } = args;
@@ -5477,13 +5521,13 @@ function getClassesProp(container) {
     return null;
   }
   const [propKey] = Object.entries(propsSchema).find(
-    ([, propType]) => propType.kind === "plain" && propType.key === import_editor_props10.CLASSES_PROP_KEY
+    ([, propType]) => propType.kind === "plain" && propType.key === import_editor_props9.CLASSES_PROP_KEY
   ) ?? [];
   return propKey ?? null;
 }
 function getContainerSchema(container) {
   const type = container?.model.get("widgetType") || container?.model.get("elType");
-  const widgetsCache = (0, import_editor_elements17.getWidgetsCache)();
+  const widgetsCache = (0, import_editor_elements15.getWidgetsCache)();
   const elementType = widgetsCache?.[type];
   return elementType?.atomic_props_schema ?? null;
 }
@@ -5496,11 +5540,11 @@ function getClipboardElements(storageKey = "clipboard") {
   }
 }
 function getTitleForContainers(containers) {
-  return containers.length > 1 ? (0, import_i18n5.__)("Elements", "elementor") : (0, import_editor_elements17.getElementLabel)(containers[0].id);
+  return containers.length > 1 ? (0, import_i18n5.__)("Elements", "elementor") : (0, import_editor_elements15.getElementLabel)(containers[0].id);
 }
 
 // src/style-commands/undoable-actions/paste-element-style.ts
-var import_editor_elements18 = require("@elementor/editor-elements");
+var import_editor_elements16 = require("@elementor/editor-elements");
 var import_editor_styles_repository4 = require("@elementor/editor-styles-repository");
 var import_editor_v1_adapters22 = require("@elementor/editor-v1-adapters");
 var import_i18n6 = require("@wordpress/i18n");
@@ -5513,7 +5557,7 @@ var undoablePasteElementStyle = () => (0, import_editor_v1_adapters22.undoable)(
         if (!classesProp) {
           return null;
         }
-        const originalStyles = (0, import_editor_elements18.getElementStyles)(container.id);
+        const originalStyles = (0, import_editor_elements16.getElementStyles)(container.id);
         const [styleId, styleDef] = Object.entries(originalStyles ?? {})[0] ?? [];
         const originalStyle = Object.keys(styleDef ?? {}).length ? styleDef : null;
         const revertData = {
@@ -5522,7 +5566,7 @@ var undoablePasteElementStyle = () => (0, import_editor_v1_adapters22.undoable)(
         };
         if (styleId) {
           newStyle.variants.forEach(({ meta, props, custom_css: customCss }) => {
-            (0, import_editor_elements18.updateElementStyle)({
+            (0, import_editor_elements16.updateElementStyle)({
               elementId,
               styleId,
               meta,
@@ -5533,7 +5577,7 @@ var undoablePasteElementStyle = () => (0, import_editor_v1_adapters22.undoable)(
         } else {
           const [firstVariant] = newStyle.variants;
           const additionalVariants = newStyle.variants.slice(1);
-          revertData.styleId = (0, import_editor_elements18.createElementStyle)({
+          revertData.styleId = (0, import_editor_elements16.createElementStyle)({
             elementId,
             classesProp,
             label: import_editor_styles_repository4.ELEMENTS_STYLES_RESERVED_LABEL,
@@ -5551,7 +5595,7 @@ var undoablePasteElementStyle = () => (0, import_editor_v1_adapters22.undoable)(
           return;
         }
         if (!revertData.originalStyle) {
-          (0, import_editor_elements18.deleteElementStyle)(container.id, revertData.styleId);
+          (0, import_editor_elements16.deleteElementStyle)(container.id, revertData.styleId);
           return;
         }
         const classesProp = getClassesProp(container);
@@ -5560,7 +5604,7 @@ var undoablePasteElementStyle = () => (0, import_editor_v1_adapters22.undoable)(
         }
         const [firstVariant] = revertData.originalStyle.variants;
         const additionalVariants = revertData.originalStyle.variants.slice(1);
-        (0, import_editor_elements18.createElementStyle)({
+        (0, import_editor_elements16.createElementStyle)({
           elementId: container.id,
           classesProp,
           label: import_editor_styles_repository4.ELEMENTS_STYLES_RESERVED_LABEL,
@@ -5597,7 +5641,7 @@ function pasteStyles(args, pasteLocalStyle) {
   }
   const clipboardElements = getClipboardElements(storageKey);
   const [clipboardElement] = clipboardElements ?? [];
-  const clipboardContainer = (0, import_editor_elements19.getContainer)(clipboardElement.id);
+  const clipboardContainer = (0, import_editor_elements17.getContainer)(clipboardElement.id);
   if (!clipboardElement || !clipboardContainer || !isAtomicWidget(clipboardContainer)) {
     return;
   }
@@ -5616,7 +5660,7 @@ function getClassesWithoutLocalStyle(clipboardContainer, style) {
   if (!classesProp) {
     return [];
   }
-  const classesSetting = (0, import_editor_elements19.getElementSetting)(clipboardContainer.id, classesProp);
+  const classesSetting = (0, import_editor_elements17.getElementSetting)(clipboardContainer.id, classesProp);
   return classesSetting?.value.filter((styleId) => styleId !== style?.id) ?? [];
 }
 function pasteClasses(containers, classes) {
@@ -5625,10 +5669,10 @@ function pasteClasses(containers, classes) {
     if (!classesProp) {
       return;
     }
-    const classesSetting = (0, import_editor_elements19.getElementSetting)(container.id, classesProp);
-    const currentClasses = import_editor_props11.classesPropTypeUtil.extract(classesSetting) ?? [];
-    const newClasses = import_editor_props11.classesPropTypeUtil.create(Array.from(/* @__PURE__ */ new Set([...classes, ...currentClasses])));
-    (0, import_editor_elements19.updateElementSettings)({
+    const classesSetting = (0, import_editor_elements17.getElementSetting)(container.id, classesProp);
+    const currentClasses = import_editor_props10.classesPropTypeUtil.extract(classesSetting) ?? [];
+    const newClasses = import_editor_props10.classesPropTypeUtil.create(Array.from(/* @__PURE__ */ new Set([...classes, ...currentClasses])));
+    (0, import_editor_elements17.updateElementSettings)({
       id: container.id,
       props: { [classesProp]: newClasses }
     });
@@ -5639,7 +5683,7 @@ function pasteClasses(containers, classes) {
 var import_editor_v1_adapters25 = require("@elementor/editor-v1-adapters");
 
 // src/style-commands/undoable-actions/reset-element-style.ts
-var import_editor_elements20 = require("@elementor/editor-elements");
+var import_editor_elements18 = require("@elementor/editor-elements");
 var import_editor_styles_repository5 = require("@elementor/editor-styles-repository");
 var import_editor_v1_adapters24 = require("@elementor/editor-v1-adapters");
 var import_i18n7 = require("@wordpress/i18n");
@@ -5648,9 +5692,9 @@ var undoableResetElementStyle = () => (0, import_editor_v1_adapters24.undoable)(
     do: ({ containers }) => {
       return containers.map((container) => {
         const elementId = container.model.get("id");
-        const containerStyles = (0, import_editor_elements20.getElementStyles)(elementId);
+        const containerStyles = (0, import_editor_elements18.getElementStyles)(elementId);
         Object.keys(containerStyles ?? {}).forEach(
-          (styleId) => (0, import_editor_elements20.deleteElementStyle)(elementId, styleId)
+          (styleId) => (0, import_editor_elements18.deleteElementStyle)(elementId, styleId)
         );
         return containerStyles;
       });
@@ -5666,7 +5710,7 @@ var undoableResetElementStyle = () => (0, import_editor_v1_adapters24.undoable)(
         Object.entries(containerStyles ?? {}).forEach(([styleId, style]) => {
           const [firstVariant] = style.variants;
           const additionalVariants = style.variants.slice(1);
-          (0, import_editor_elements20.createElementStyle)({
+          (0, import_editor_elements18.createElementStyle)({
             elementId,
             classesProp,
             styleId,
@@ -5740,15 +5784,15 @@ function init() {
   initCanvasMcp(
     (0, import_editor_mcp4.getMCPByDomain)("canvas", {
       instructions: `Everything related to V4 ( Atomic ) canvas.
-# Canvas workflow for new compositions
-- Configure elements settings and styles
-- Build compositions/sections out of V4 atomic elements using context aware designs using the website resources
-- Get and retrieve element configuration values
+# Canvas workflow
+- Configure element settings and styles with configure-element
+- Get page structure and element configuration values
 `,
       docs: mcpDescription
     })
   );
   initTabsModelExtensions();
+  initListType();
 }
 
 // src/sync/drag-element-from-panel.ts
@@ -5866,10 +5910,10 @@ function useEscapeOnCanvas(canvasDocument, onEscape) {
 }
 
 // src/utils/after-render.ts
-var import_editor_elements21 = require("@elementor/editor-elements");
+var import_editor_elements19 = require("@elementor/editor-elements");
 function doAfterRender(elementIds, callback) {
   const pending = elementIds.map((elementId) => {
-    const view = (0, import_editor_elements21.getContainer)(elementId)?.view;
+    const view = (0, import_editor_elements19.getContainer)(elementId)?.view;
     if (!view || !hasDoAfterRender(view)) {
       return void 0;
     }