@elementor/editor-canvas 4.1.0 → 4.2.0-839

package/dist/index.mjs

@@ -45,12 +45,81 @@ var initBreakpointsResource = (reg) => {
 };
 
 // src/mcp/resources/widgets-schema-resource.ts
-import { getWidgetsCache } from "@elementor/editor-elements";
+import { getWidgetsCache as getWidgetsCache2 } from "@elementor/editor-elements";
 import { ResourceTemplate } from "@elementor/editor-mcp";
 import {
   Schema
 } from "@elementor/editor-props";
 import { getStylesSchema } from "@elementor/editor-styles";
+
+// src/mcp/utils/element-data-util.ts
+import { getWidgetsCache } from "@elementor/editor-elements";
+function hasV3Controls(controls) {
+  return typeof controls === "object" && controls !== null && Object.keys(controls).length > 0;
+}
+function isWidgetAvailableForLLM(config) {
+  if (!config) {
+    return false;
+  }
+  if (config.meta?.llm_support === false) {
+    return false;
+  }
+  if (config.atomic_props_schema) {
+    return true;
+  }
+  return hasV3Controls(config.controls);
+}
+function getWidgetVersion(config) {
+  return config?.atomic_props_schema ? "v4" : "v3";
+}
+function getAvailableWidgets() {
+  const cache = getWidgetsCache() ?? {};
+  return Object.keys(cache).filter((widgetType) => isWidgetAvailableForLLM(cache[widgetType])).sort().map((widgetType) => {
+    const config = cache[widgetType];
+    const description = typeof config?.meta?.description === "string" ? config.meta.description : void 0;
+    return {
+      type: widgetType,
+      version: getWidgetVersion(config),
+      ...description && { description }
+    };
+  });
+}
+
+// src/mcp/resources/widgets-schema-resource.ts
+var V3_LAYOUT_CONTROL_TYPES = /* @__PURE__ */ new Set(["section", "tab", "tabs"]);
+function extractV3ControlsMetadata(controls) {
+  if (!hasV3Controls(controls)) {
+    return {};
+  }
+  const result = {};
+  for (const [controlKey, raw] of Object.entries(controls)) {
+    if (!raw || typeof raw !== "object") {
+      continue;
+    }
+    const control = raw;
+    const controlType = typeof control.type === "string" ? control.type : void 0;
+    if (controlType && V3_LAYOUT_CONTROL_TYPES.has(controlType)) {
+      continue;
+    }
+    const entry = {};
+    if (Object.prototype.hasOwnProperty.call(control, "default")) {
+      entry.default = control.default;
+    }
+    if (controlType) {
+      entry.type = controlType;
+    }
+    if (Object.prototype.hasOwnProperty.call(control, "options") && control.options !== void 0) {
+      const options = control.options;
+      if (options && typeof options === "object" && !Array.isArray(options)) {
+        entry.options = Object.keys(options);
+      } else {
+        entry.options = options;
+      }
+    }
+    result[controlKey] = entry;
+  }
+  return result;
+}
 var WIDGET_SCHEMA_URI = "elementor://widgets/schema/{widgetType}";
 var STYLE_SCHEMA_URI = "elementor://styles/schema/{category}";
 var BEST_PRACTICES_URI = "elementor://styles/best-practices";
@@ -98,7 +167,7 @@ Variables from the user context ARE NOT SUPPORTED AND WILL RESOLVE IN ERROR.
       }
     }),
     {
-      description: "Common styles schema for the specified category"
+      description: "Common styles schema for the specified category (applicable for V4 elements only)"
     },
     async (uri, variables) => {
       const category = typeof variables.category === "string" ? variables.category : variables.category?.[0];
@@ -124,9 +193,9 @@ Variables from the user context ARE NOT SUPPORTED AND WILL RESOLVE IN ERROR.
     "widget-schema-by-type",
     new ResourceTemplate(WIDGET_SCHEMA_URI, {
       list: () => {
-        const cache = getWidgetsCache() || {};
-        const availableWidgets = Object.keys(cache || {}).filter(
-          (widgetType) => cache[widgetType]?.atomic_props_schema && cache[widgetType].meta?.llm_support !== false
+        const cache = getWidgetsCache2() || {};
+        const availableWidgets = Object.keys(cache).filter(
+          (widgetType) => isWidgetAvailableForLLM(cache[widgetType])
         );
         return {
           resources: availableWidgets.map((widgetType) => ({
@@ -141,20 +210,34 @@ Variables from the user context ARE NOT SUPPORTED AND WILL RESOLVE IN ERROR.
     },
     async (uri, variables) => {
       const widgetType = typeof variables.widgetType === "string" ? variables.widgetType : variables.widgetType?.[0];
-      const widgetData = getWidgetsCache()?.[widgetType];
-      const propSchema = widgetData?.atomic_props_schema;
-      if (!propSchema || !widgetData) {
+      const widgetData = getWidgetsCache2()?.[widgetType];
+      if (!widgetData) {
         throw new Error(`No prop schema found for element type: ${widgetType}`);
       }
+      const propSchema = widgetData.atomic_props_schema;
+      if (!propSchema) {
+        if (!hasV3Controls(widgetData.controls)) {
+          throw new Error(`No prop schema found for element type: ${widgetType}`);
+        }
+        const controlMetadata = extractV3ControlsMetadata(widgetData.controls);
+        return {
+          contents: [
+            {
+              uri: uri.toString(),
+              mimeType: "application/json",
+              text: JSON.stringify({
+                widget_version: "v3",
+                message: "This widget exists in the editor but has no atomic props schema (V4). Use control_metadata as non-authoritative hints from legacy controls.",
+                fields_note: "All settings are optional; there is no JSON schema for this widget type.",
+                properties: controlMetadata
+              })
+            }
+          ]
+        };
+      }
       const asJson = Object.fromEntries(
-        Object.entries(propSchema).map(([key, propType]) => [
-          key,
-          Schema.propTypeToJsonSchema(propType)
-        ])
+        Object.entries(propSchema).filter(([key, propType]) => Schema.isPropKeyConfigurable(key, propType)).map(([key, propType]) => [key, Schema.propTypeToJsonSchema(propType)])
       );
-      Schema.nonConfigurablePropKeys.forEach((key) => {
-        delete asJson[key];
-      });
       const description = typeof widgetData?.meta?.description === "string" ? widgetData.meta.description : void 0;
       const defaultStyles = {};
       const baseStyleSchema = widgetData?.base_styles;
@@ -174,7 +257,7 @@ Variables from the user context ARE NOT SUPPORTED AND WILL RESOLVE IN ERROR.
         llmGuidance.default_styles = defaultStyles;
       }
       const allowedChildTypes = widgetData.allowed_child_types;
-      const allWidgets = getWidgetsCache() || {};
+      const allWidgets = getWidgetsCache2() || {};
       const allowedParents = Object.entries(allWidgets).filter(([, parentConfig]) => parentConfig.allowed_child_types?.includes(widgetType)).map(([parentType]) => parentType);
       if (allowedChildTypes?.length || allowedParents.length) {
         llmGuidance.nesting = {
@@ -1049,8 +1132,9 @@ function createProviderSubscriber2({ provider, renderStyles, setStyleItems, getC
         ...style,
         cssName: provider.actions.resolveCssName(style.id)
       }));
-      return renderStyles({ styles: breakToBreakpoints(changedStyles), signal }).then((rendered) => {
-        updateCacheItems(cache, rendered);
+      const breakpointSplit = breakToBreakpoints(changedStyles);
+      return renderStyles({ styles: breakpointSplit, signal }).then((rendered) => {
+        updateCacheItems(cache, changedIds, rendered);
         return getOrderedItems(cache);
       });
     }
@@ -1107,19 +1191,14 @@ function getChangedStyleIds(previous, current) {
 function getOrderedItems(cache) {
   return cache.orderedIds.map((id) => cache.itemsById.get(id)).filter((items) => items !== void 0).flat();
 }
-function updateCacheItems(cache, changedItems) {
+function updateCacheItems(cache, changedIds, changedItems) {
+  for (const id of changedIds) {
+    cache.itemsById.delete(id);
+  }
   for (const item of changedItems) {
-    const existing = cache.itemsById.get(item.id);
-    if (existing) {
-      const idx = existing.findIndex((e) => e.breakpoint === item.breakpoint && e.state === item.state);
-      if (idx >= 0) {
-        existing[idx] = item;
-      } else {
-        existing.push(item);
-      }
-    } else {
-      cache.itemsById.set(item.id, [item]);
-    }
+    const existing = cache.itemsById.get(item.id) || [];
+    existing.push(item);
+    cache.itemsById.set(item.id, existing);
   }
 }
 function rebuildCache(cache, allStyles, items) {
@@ -1178,7 +1257,11 @@ var FORM_FIELD_ELEMENT_TYPES = /* @__PURE__ */ new Set([
   "e-form-label",
   "e-form-checkbox",
   "e-form-submit-button",
-  "e-form-select"
+  "e-form-select",
+  "e-form-radio-button",
+  "e-form-file-upload",
+  "e-form-date-picker",
+  "e-form-time-picker"
 ]);
 function getArgsElementType(args) {
   return args.model?.widgetType || args.model?.elType;
@@ -1393,6 +1476,17 @@ function createClassesTransformer() {
   });
 }
 
+// src/transformers/settings/date-range-transformer.ts
+var dateRangeTransformer = createTransformer((value) => {
+  if (!value || Object.keys(value).length === 0) {
+    return null;
+  }
+  return {
+    min: value.min || null,
+    max: value.max || null
+  };
+});
+
 // src/transformers/settings/date-time-transformer.ts
 var dateTimeTransformer = createTransformer((values) => {
   return values.map((value) => {
@@ -1427,10 +1521,22 @@ var queryTransformer = createTransformer(({ id }) => {
   return id ?? null;
 });
 
+// src/transformers/settings/time-range-transformer.ts
+var timeRangeTransformer = createTransformer((value) => {
+  if (!value || Object.keys(value).length === 0) {
+    return null;
+  }
+  return {
+    min: value.min || null,
+    max: value.max || null
+  };
+});
+
 // src/transformers/shared/image-src-transformer.ts
 var imageSrcTransformer = createTransformer((value) => ({
   id: value.id ?? null,
-  url: value.url ?? null
+  url: value.url ?? null,
+  alt: value.alt ?? null
 }));
 
 // src/transformers/shared/image-transformer.ts
@@ -1438,7 +1544,7 @@ import { getMediaAttachment } from "@elementor/wp-media";
 var imageTransformer = createTransformer(async (value) => {
   const { src, size: size2 } = value;
   if (!src?.id) {
-    return src?.url ? { src: src.url } : null;
+    return src?.url ? { src: src.url, alt: src.alt ?? "" } : null;
   }
   const attachment = await getMediaAttachment({ id: src.id });
   const sizedAttachment = attachment?.sizes?.[size2 ?? ""];
@@ -1446,14 +1552,16 @@ var imageTransformer = createTransformer(async (value) => {
     return {
       src: sizedAttachment.url,
       height: sizedAttachment.height,
-      width: sizedAttachment.width
+      width: sizedAttachment.width,
+      alt: attachment.alt
     };
   }
   if (attachment) {
     return {
       src: attachment.url,
       height: attachment.height,
-      width: attachment.width
+      width: attachment.width,
+      alt: attachment.alt
     };
   }
   return null;
@@ -1540,7 +1648,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).registerFallback(plainTransformer);
+  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);
 }
 
 // src/transformers/styles/background-color-overlay-transformer.ts
@@ -1745,6 +1853,11 @@ var sizeTransformer = createTransformer((value) => {
   return value.unit === "custom" ? value.size : `${value.size}${value.unit}`;
 });
 
+// src/transformers/styles/span-transformer.ts
+var spanTransformer = createTransformer((value) => {
+  return value || 0 === value ? "span " + value : null;
+});
+
 // src/transformers/styles/stroke-transformer.ts
 var strokeTransformer = createTransformer((value) => {
   const parsed = {
@@ -1851,7 +1964,7 @@ function initStyleTransformers() {
       ["block-start", "block-end", "inline-start", "inline-end"],
       ({ propKey, key }) => `${propKey}-${key}`
     )
-  ).register("filter", filterTransformer).register("backdrop-filter", filterTransformer).register("box-shadow", createCombineArrayTransformer(",")).register("background", backgroundTransformer).register("background-overlay", backgroundOverlayTransformer).register("background-color-overlay", backgroundColorOverlayTransformer).register("background-image-overlay", backgroundImageOverlayTransformer).register("background-gradient-overlay", backgroundGradientOverlayTransformer).register("gradient-color-stop", createCombineArrayTransformer(",")).register("color-stop", colorStopTransformer).register("background-image-position-offset", positionTransformer).register("background-image-size-scale", backgroundImageSizeScaleTransformer).register("image-src", imageSrcTransformer).register("image", imageTransformer).register("object-position", positionTransformer).register("transform-origin", transformOriginTransformer).register("perspective-origin", perspectiveOriginTransformer).register("transform-move", transformMoveTransformer).register("transform-scale", transformScaleTransformer).register("transform-rotate", transformRotateTransformer).register("transform-skew", transformSkewTransformer).register("transform-functions", transformFunctionsTransformer).register(
+  ).register("filter", filterTransformer).register("backdrop-filter", filterTransformer).register("box-shadow", createCombineArrayTransformer(",")).register("background", backgroundTransformer).register("background-overlay", backgroundOverlayTransformer).register("background-color-overlay", backgroundColorOverlayTransformer).register("background-image-overlay", backgroundImageOverlayTransformer).register("background-gradient-overlay", backgroundGradientOverlayTransformer).register("gradient-color-stop", createCombineArrayTransformer(",")).register("color-stop", colorStopTransformer).register("background-image-position-offset", positionTransformer).register("background-image-size-scale", backgroundImageSizeScaleTransformer).register("image-src", imageSrcTransformer).register("image", imageTransformer).register("object-position", positionTransformer).register("span", spanTransformer).register("transform-origin", transformOriginTransformer).register("perspective-origin", perspectiveOriginTransformer).register("transform-move", transformMoveTransformer).register("transform-scale", transformScaleTransformer).register("transform-rotate", transformRotateTransformer).register("transform-skew", transformSkewTransformer).register("transform-functions", transformFunctionsTransformer).register(
     "transform",
     createMultiPropsTransformer(
       ["transform-functions", "transform-origin", "perspective", "perspective-origin"],
@@ -1876,7 +1989,7 @@ function initStyleTransformers() {
 }
 
 // src/legacy/init-legacy-views.ts
-import { getWidgetsCache as getWidgetsCache2 } from "@elementor/editor-elements";
+import { getWidgetsCache as getWidgetsCache3 } from "@elementor/editor-elements";
 import { __privateListenTo, v1ReadyEvent as v1ReadyEvent2 } from "@elementor/editor-v1-adapters";
 
 // src/renderers/create-dom-renderer.ts
@@ -2007,6 +2120,60 @@ function createElementViewClassDeclaration() {
 // src/legacy/create-nested-templated-element-type.ts
 import { ELEMENT_STYLE_CHANGE_EVENT } from "@elementor/editor-elements";
 
+// src/legacy/create-pending-element.ts
+import {
+  addModelToParent,
+  findModelInDocument,
+  generateElementId,
+  getContainer
+} from "@elementor/editor-elements";
+function createPendingElement(wrapperView, data, options = {}) {
+  const parentContainer = wrapperView.getContainer();
+  const model = { ...data };
+  if (!model.id) {
+    model.id = generateElementId();
+  }
+  if (!model.elements) {
+    model.elements = [];
+  }
+  const added = addModelToParent(parentContainer.id, model, options);
+  if (!added) {
+    return void 0;
+  }
+  const childId = model.id;
+  const childModel = findModelInDocument(childId);
+  if (!childModel) {
+    return void 0;
+  }
+  const pendingContainer = {
+    id: childId,
+    settings: { get: () => ({}), set: () => ({}), toJSON: () => ({}) },
+    parent: parentContainer,
+    model: childModel,
+    view: void 0,
+    lookup() {
+      return getContainer(childId) ?? pendingContainer;
+    }
+  };
+  wrapperView.once("render", () => {
+    wrapperView.model?.trigger?.("navigator:add", childModel, options);
+  });
+  if (options.edit !== false) {
+    selectChildWhenWrapperRenders(wrapperView, childId);
+  }
+  return { getContainer: () => pendingContainer };
+}
+function selectChildWhenWrapperRenders(wrapperView, childId) {
+  wrapperView.once("render", () => {
+    const childContainer = getContainer(childId);
+    if (childContainer?.model?.trigger) {
+      childContainer.model.trigger("request:edit");
+      return;
+    }
+    wrapperView.model?.trigger?.("request:edit");
+  });
+}
+
 // src/legacy/twig-rendering-utils.ts
 function setupTwigRenderer({ renderer, element }) {
   const templateKey = element.twig_main_template;
@@ -2224,6 +2391,7 @@ function createNestedTemplatedElementView({
   const AtomicElementBaseView = legacyWindow.elementor.modules.elements.views.createAtomicElementBase(type);
   const parentRenderChildren = AtomicElementBaseView.prototype._renderChildren;
   const parentOpenEditingPanel = AtomicElementBaseView.prototype._openEditingPanel;
+  const parentAddElement = AtomicElementBaseView.prototype.addElement;
   return AtomicElementBaseView.extend({
     _abortController: null,
     _lastResolvedSettingsHash: null,
@@ -2331,7 +2499,6 @@ function createNestedTemplatedElementView({
       Array.from(newEl.attributes).forEach((attr) => {
         targetEl.setAttribute(attr.name, attr.value);
       });
-      targetEl.setAttribute("draggable", "true");
       targetEl.innerHTML = overlayHTML + newEl.innerHTML;
       if (needsTagSwap) {
         oldEl.replaceWith(targetEl);
@@ -2423,6 +2590,12 @@ function createNestedTemplatedElementView({
     _openEditingPanel(options) {
       this._doAfterRender(() => parentOpenEditingPanel.call(this, options));
     },
+    addElement(data, options) {
+      if (this.isRendered) {
+        return parentAddElement.call(this, data, options);
+      }
+      return createPendingElement(this, data, options);
+    },
     getInteractionId() {
       const originId = this.model.get("originId");
       const id = this.model.get("id");
@@ -2499,7 +2672,7 @@ import { createRoot } from "react-dom/client";
 
 // src/legacy/replacements/inline-editing/inline-editing-elements.tsx
 import * as React6 from "react";
-import { getContainer, getElementLabel, getElementType as getElementType2 } from "@elementor/editor-elements";
+import { getContainer as getContainer2, getElementLabel, getElementType as getElementType2 } from "@elementor/editor-elements";
 import {
   htmlV3PropTypeUtil as htmlV3PropTypeUtil2,
   parseHtmlChildren,
@@ -2946,7 +3119,7 @@ var InlineEditingReplacement = class extends ReplacementBase {
     runCommandSync(
       "document/elements/set-settings",
       {
-        container: getContainer(this.id),
+        container: getContainer2(this.id),
         settings: {
           [key]: value
         }
@@ -3121,7 +3294,7 @@ function registerElementType(type, elementTypeGenerator) {
 }
 function initLegacyViews() {
   __privateListenTo(v1ReadyEvent2(), () => {
-    const widgetsCache = getWidgetsCache2() ?? {};
+    const widgetsCache = getWidgetsCache3() ?? {};
     const legacyWindow = window;
     const renderer = createDomRenderer();
     registerProPromotionTypes(widgetsCache);
@@ -3207,7 +3380,67 @@ function initTabsModelExtensions() {
   registerModelExtensions("e-tab", tabModelExtensions);
 }
 
+// src/mcp/resources/available-widgets-resource.ts
+import { v1ReadyEvent as v1ReadyEvent3 } from "@elementor/editor-v1-adapters";
+var AVAILABLE_WIDGETS_URI = "elementor://context/available-widgets";
+var AVAILABLE_WIDGETS_URI_V4 = "elementor://context/available-widgets/v4";
+var initAvailableWidgetsResource = (reg) => {
+  const { resource, sendResourceUpdated } = reg;
+  const buildContents = (uri, filterFunction = () => true) => {
+    const widgets = getAvailableWidgets().filter(filterFunction);
+    return {
+      contents: [
+        {
+          uri,
+          mimeType: "application/json",
+          text: JSON.stringify(widgets, null, 2)
+        }
+      ]
+    };
+  };
+  const notifyResourcesUpdated = () => {
+    sendResourceUpdated({
+      uri: AVAILABLE_WIDGETS_URI,
+      ...buildContents(AVAILABLE_WIDGETS_URI)
+    });
+    sendResourceUpdated({
+      uri: AVAILABLE_WIDGETS_URI_V4,
+      ...buildContents(AVAILABLE_WIDGETS_URI_V4, (w) => w.version === "v4")
+    });
+  };
+  resource(
+    "available-widgets-v4",
+    AVAILABLE_WIDGETS_URI_V4,
+    {
+      description: "All registered v4 version widgets"
+    },
+    async () => buildContents(AVAILABLE_WIDGETS_URI_V4, (w) => w.version === "v4")
+  );
+  resource(
+    "available-widgets",
+    AVAILABLE_WIDGETS_URI,
+    {
+      description: "All registered widget types with v3/v4 version metadata and description."
+    },
+    async () => buildContents(AVAILABLE_WIDGETS_URI)
+  );
+  const eventName = v1ReadyEvent3().name;
+  const onV1Ready = () => {
+    const widgets = getAvailableWidgets();
+    if (widgets.length === 0) {
+      return;
+    }
+    window.removeEventListener(eventName, onV1Ready);
+    notifyResourcesUpdated();
+  };
+  window.addEventListener(eventName, onV1Ready);
+  onV1Ready();
+};
+
 // src/mcp/resources/document-structure-resource.ts
+import {
+  getWidgetsCache as getWidgetsCache4
+} from "@elementor/editor-elements";
 import { __privateListenTo as listenTo, commandEndEvent as commandEndEvent4 } from "@elementor/editor-v1-adapters";
 var DOCUMENT_STRUCTURE_URI = "elementor://document/structure";
 var initDocumentStructureResource = (reg) => {
@@ -3228,7 +3461,8 @@ var initDocumentStructureResource = (reg) => {
       commandEndEvent4("document/elements/move"),
       commandEndEvent4("document/elements/copy"),
       commandEndEvent4("document/elements/paste"),
-      commandEndEvent4("editor/documents/attach-preview")
+      commandEndEvent4("editor/documents/attach-preview"),
+      commandEndEvent4("editor/documents/switch")
     ],
     updateDocumentStructure
   );
@@ -3258,9 +3492,7 @@ function getDocumentStructure() {
     return { error: "No active document found" };
   }
   const containers = document2.container?.children || [];
-  const elements = containers.map(
-    (container) => extractElementData(container)
-  );
+  const elements = containers.map((container) => extractElementData(container));
   return {
     documentId: document2.id,
     documentType: document2.config.type,
@@ -3268,6 +3500,16 @@ function getDocumentStructure() {
     elements: elements.filter((el) => el !== null)
   };
 }
+function resolveElementVersion(element) {
+  if (element.model?.config?.atomic) {
+    return "v4";
+  }
+  const widgetType = element.model?.attributes?.widgetType;
+  if (widgetType && getWidgetsCache4()?.[widgetType]?.atomic_props_schema) {
+    return "v4";
+  }
+  return "v3";
+}
 function extractElementData(element) {
   if (!element || !element.model) {
     return null;
@@ -3276,7 +3518,8 @@ function extractElementData(element) {
   const result = {
     id: model.id,
     elType: model.elType,
-    widgetType: model.widgetType || void 0
+    widgetType: model.widgetType || void 0,
+    version: resolveElementVersion(element)
   };
   const title = model.title || element.model?.editor_settings?.title;
   if (title) {
@@ -3288,28 +3531,346 @@ function extractElementData(element) {
   return result;
 }
 
+// src/mcp/resources/editor-state-resource.ts
+import { __privateListenTo as listenTo2, commandEndEvent as commandEndEvent5 } from "@elementor/editor-v1-adapters";
+var CURRENTLY_VIEWED_SCREEN = "The user is currently viewing the Elementor editor";
+var PAGE_CONTENT_CHARACTER_LIMIT = 500;
+var PREVIEW_TEXT_NODE_MIN_LENGTH = 2;
+var EDITOR_STATE_URI = "elementor://context/editor-state";
+var initEditorStateResource = (reg) => {
+  const { resource, sendResourceUpdated } = reg;
+  let lastSerializedState = "";
+  const buildState = () => ({
+    currentlyViewedScreen: CURRENTLY_VIEWED_SCREEN,
+    pageContent: getPageContentFromPreview(),
+    pageTitle: getPageTitle()
+  });
+  const notifyIfChanged = () => {
+    const serialized = JSON.stringify(buildState());
+    if (serialized === lastSerializedState) {
+      return;
+    }
+    lastSerializedState = serialized;
+    sendResourceUpdated({ uri: EDITOR_STATE_URI });
+  };
+  listenTo2(
+    [commandEndEvent5("editor/documents/switch"), commandEndEvent5("editor/documents/attach-preview")],
+    notifyIfChanged
+  );
+  lastSerializedState = JSON.stringify(buildState());
+  resource(
+    "editor-state",
+    EDITOR_STATE_URI,
+    {
+      description: "Editor page title, preview text snapshot, and viewed screen label."
+    },
+    async () => {
+      return {
+        contents: [
+          {
+            uri: EDITOR_STATE_URI,
+            text: JSON.stringify(buildState(), null, 2)
+          }
+        ]
+      };
+    }
+  );
+};
+function getPageContentFromPreview() {
+  try {
+    const root = window.elementor?.$previewContents?.[0];
+    if (!root) {
+      return null;
+    }
+    const content = [];
+    const clone = root.cloneNode(true);
+    clone.querySelectorAll(".elementor-editor-element-settings, #elementor-add-new-section").forEach((el) => {
+      el.remove();
+    });
+    const walk = (node, insideElementorElement = false) => {
+      const isInside = node.classList?.contains("elementor-element") || insideElementorElement;
+      if (node.nodeType === Node.TEXT_NODE && isInside) {
+        const text2 = node.textContent?.trim().replace(/\s+/g, " ");
+        if (text2 && text2.length > PREVIEW_TEXT_NODE_MIN_LENGTH) {
+          content.push(text2);
+        }
+      } else {
+        node.childNodes.forEach((child) => {
+          walk(child, isInside);
+        });
+      }
+    };
+    walk(clone);
+    const text = content.join(" ");
+    if (text.length > PAGE_CONTENT_CHARACTER_LIMIT) {
+      return text.slice(0, PAGE_CONTENT_CHARACTER_LIMIT) + "...";
+    }
+    return text;
+  } catch {
+    return null;
+  }
+}
+function getPageTitle() {
+  try {
+    const extendedWindow = window;
+    const currentDocument = extendedWindow.elementor?.documents?.getCurrent?.();
+    const postTitle = currentDocument?.config?.settings?.post_title;
+    if (postTitle) {
+      return postTitle;
+    }
+    let title = document.title || "Page";
+    title = title.split(/\s*[‹»|–—-]\s*/)[0];
+    const trimmed = title.trim();
+    return trimmed || "Page";
+  } catch {
+    return "Page";
+  }
+}
+
+// src/mcp/resources/general-context-resource.ts
+import { __privateListenTo as listenTo3, commandEndEvent as commandEndEvent6 } from "@elementor/editor-v1-adapters";
+var GENERAL_CONTEXT_URI = "elementor://context/general";
+var initGeneralContextResource = (reg) => {
+  const { resource, sendResourceUpdated } = reg;
+  let lastSerializedPayload = null;
+  const getPageTitle2 = () => {
+    const extendedWindow = window;
+    const title = extendedWindow.elementor?.documents?.getCurrent?.()?.config?.settings?.post_title;
+    if (!title?.trim()) {
+      return null;
+    }
+    return title;
+  };
+  const buildPayload = () => {
+    const extendedWindow = window;
+    const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    const postParam = new URLSearchParams(location.search).get("post");
+    const parsedPostId = postParam ? Number(postParam) : null;
+    const postId = parsedPostId !== null && Number.isFinite(parsedPostId) ? parsedPostId : null;
+    const pageTitle = getPageTitle2();
+    const urlObject = new URL(window.location.href);
+    const pageUrl = urlObject.pathname + urlObject.search;
+    const pageName = pageTitle || "Elementor Editor";
+    const plugins = extendedWindow.angieConfig?.plugins;
+    return {
+      timezone,
+      postId,
+      currentPage: {
+        pageName,
+        pageTitle,
+        pageUrl
+      },
+      ...plugins && { plugins }
+    };
+  };
+  const pushUpdateIfChanged = () => {
+    const serialized = JSON.stringify(buildPayload());
+    if (serialized === lastSerializedPayload) {
+      return;
+    }
+    lastSerializedPayload = serialized;
+    sendResourceUpdated({ uri: GENERAL_CONTEXT_URI });
+  };
+  resource(
+    "general-context",
+    GENERAL_CONTEXT_URI,
+    {
+      description: "General context: timezone, post id, and current page."
+    },
+    async () => {
+      return {
+        contents: [
+          {
+            uri: GENERAL_CONTEXT_URI,
+            mimeType: "application/json",
+            text: JSON.stringify(buildPayload(), null, 2)
+          }
+        ]
+      };
+    }
+  );
+  listenTo3(
+    [
+      commandEndEvent6("editor/documents/switch"),
+      commandEndEvent6("editor/documents/attach-preview"),
+      commandEndEvent6("document/elements/settings")
+    ],
+    pushUpdateIfChanged
+  );
+  pushUpdateIfChanged();
+};
+
+// src/mcp/resources/selected-element-resource.ts
+import { getContainer as getContainer3, getSelectedElements, getWidgetsCache as getWidgetsCache5 } from "@elementor/editor-elements";
+import {
+  __privateListenTo as listenTo4,
+  commandEndEvent as commandEndEvent7
+} from "@elementor/editor-v1-adapters";
+var SELECTED_ELEMENT_URI = "elementor://context/selected-element";
+var initSelectedElementResource = (reg) => {
+  const { resource, sendResourceUpdated } = reg;
+  let currentPayloadText = null;
+  const publishIfChanged = (payload) => {
+    const nextText = JSON.stringify(payload);
+    if (nextText !== currentPayloadText) {
+      currentPayloadText = nextText;
+      sendResourceUpdated({ uri: SELECTED_ELEMENT_URI });
+    }
+  };
+  const onCommand = (e) => {
+    if (e.type !== "command") {
+      return;
+    }
+    const commandEvent = e;
+    if (commandEvent.command === "document/elements/deselect-all") {
+      publishIfChanged(createEmptySelectedElementPayload());
+      return;
+    }
+    if (commandEvent.command !== "document/elements/select" && commandEvent.command !== "document/elements/settings") {
+      return;
+    }
+    const { container } = commandEvent.args || {};
+    if (container?.id) {
+      publishIfChanged(buildPayloadFromContainer(container));
+      return;
+    }
+    publishIfChanged(readSelectionFromEditor());
+  };
+  listenTo4(
+    [
+      commandEndEvent7("document/elements/select"),
+      commandEndEvent7("document/elements/deselect-all"),
+      commandEndEvent7("document/elements/settings")
+    ],
+    onCommand
+  );
+  publishIfChanged(readSelectionFromEditor());
+  resource(
+    "selected-element",
+    SELECTED_ELEMENT_URI,
+    {
+      description: "Currently selected Elementor element context."
+    },
+    async () => {
+      return {
+        contents: [
+          {
+            uri: SELECTED_ELEMENT_URI,
+            text: JSON.stringify(readSelectionFromEditor(), null, 2)
+          }
+        ]
+      };
+    }
+  );
+};
+function createEmptySelectedElementPayload() {
+  return {
+    elementDisplayName: null,
+    elementType: null,
+    properties: null,
+    selectedElementId: null,
+    selectedParentId: null,
+    version: null,
+    widgetType: null
+  };
+}
+function readSelectionFromEditor() {
+  const elements = getSelectedElements();
+  if (elements.length !== 1) {
+    return createEmptySelectedElementPayload();
+  }
+  const container = getContainer3(elements[0].id);
+  return buildPayloadFromContainer(container);
+}
+function buildPayloadFromContainer(container) {
+  if (!container?.id) {
+    return createEmptySelectedElementPayload();
+  }
+  const widgetType = container.model.get("widgetType") ?? null;
+  const elementType = container.type ?? "widget";
+  return {
+    elementDisplayName: getElementDisplayName(container),
+    elementType,
+    properties: getElementProperties(container, widgetType),
+    selectedElementId: container.id,
+    selectedParentId: container.parent?.id ?? null,
+    version: resolveElementVersion2(container, widgetType),
+    widgetType
+  };
+}
+function resolveElementVersion2(container, widgetType) {
+  if (container.model?.config?.atomic) {
+    return "v4";
+  }
+  if (widgetType && getWidgetsCache5()?.[widgetType]?.atomic_props_schema) {
+    return "v4";
+  }
+  return "v3";
+}
+function getElementProperties(container, widgetType) {
+  const settings = container.settings?.toJSON?.();
+  if (!settings || typeof settings !== "object") {
+    return null;
+  }
+  const widgetConfig = widgetType ? getWidgetsCache5()?.[widgetType] : null;
+  const controls = widgetConfig?.controls;
+  const filtered = {};
+  for (const [key, value] of Object.entries(settings)) {
+    if (value === void 0 || value === null || value === "") {
+      continue;
+    }
+    const controlDefault = controls?.[key]?.default;
+    if (controlDefault !== void 0 && JSON.stringify(value) === JSON.stringify(controlDefault)) {
+      continue;
+    }
+    filtered[key] = value;
+  }
+  return Object.keys(filtered).length > 0 ? filtered : null;
+}
+function getElementDisplayName(container) {
+  try {
+    if (container.label) {
+      return container.label;
+    }
+    const widgetType = container.model?.get?.("widgetType");
+    if (widgetType) {
+      const capitalizedType = widgetType.charAt(0).toUpperCase() + widgetType.slice(1);
+      return capitalizedType.replace(/-/g, " ");
+    }
+    if (container.type === "container") {
+      return "Container";
+    }
+    if (container.type === "section") {
+      return "Section";
+    }
+    return `Element ${container.id}`;
+  } catch {
+    return `Element ${container.id}`;
+  }
+}
+
 // src/mcp/tools/build-composition/tool.ts
 import { getCurrentDocument } from "@elementor/editor-documents";
 import {
   createElement as createElement8,
   deleteElement,
-  getContainer as getContainer3,
-  getWidgetsCache as getWidgetsCache6
+  getContainer as getContainer5,
+  getWidgetsCache as getWidgetsCache9
 } from "@elementor/editor-elements";
 
 // src/composition-builder/composition-builder.ts
 import {
   createElement as createElement7,
-  generateElementId,
-  getContainer as getContainer2,
-  getWidgetsCache as getWidgetsCache5
+  generateElementId as generateElementId2,
+  getContainer as getContainer4,
+  getWidgetsCache as getWidgetsCache8
 } from "@elementor/editor-elements";
 
 // src/mcp/utils/do-update-element-property.ts
 import {
   createElementStyle,
   getElementStyles,
-  getWidgetsCache as getWidgetsCache3,
+  getWidgetsCache as getWidgetsCache6,
   updateElementSettings,
   updateElementStyle
 } from "@elementor/editor-elements";
@@ -3402,7 +3963,7 @@ var doUpdateElementProperty = (params) => {
     }
     return;
   }
-  const elementPropSchema = getWidgetsCache3()?.[elementType]?.atomic_props_schema;
+  const elementPropSchema = getWidgetsCache6()?.[elementType]?.atomic_props_schema;
   if (!elementPropSchema) {
     throw new Error(`No prop schema found for element type: ${elementType}`);
   }
@@ -3426,7 +3987,7 @@ var doUpdateElementProperty = (params) => {
 };
 
 // src/mcp/utils/validate-input.ts
-import { getWidgetsCache as getWidgetsCache4 } from "@elementor/editor-elements";
+import { getWidgetsCache as getWidgetsCache7 } from "@elementor/editor-elements";
 import { Schema as Schema3 } from "@elementor/editor-props";
 import { getStylesSchema as getStylesSchema4 } from "@elementor/editor-styles";
 var _widgetsSchema = null;
@@ -3434,7 +3995,7 @@ var validateInput = {
   get widgetsSchema() {
     if (!_widgetsSchema) {
       const schema2 = {};
-      const cache = getWidgetsCache4();
+      const cache = getWidgetsCache7();
       if (!cache) {
         return {};
       }
@@ -3461,7 +4022,7 @@ var validateInput = {
       if (!propSchema) {
         errors.push(`Property "${propName}" is not defined in the schema.`);
         hasInvalidKey = true;
-      } else if (!Schema3.isPropKeyConfigurable(propName)) {
+      } else if (!Schema3.isPropKeyConfigurable(propName, propSchema)) {
         errors.push(`Property "${propName}" is not configurable.`);
       } else {
         const { valid } = Schema3.validatePropValue(propSchema, propValue);
@@ -3514,13 +4075,13 @@ var validateInput = {
 var CompositionBuilder = class _CompositionBuilder {
   elementConfig = {};
   elementStylesConfig = {};
-  elementCusomCSS = {};
+  elementCustomCSS = {};
   rootContainers = [];
   api = {
     createElement: createElement7,
-    getWidgetsCache: getWidgetsCache5,
-    generateElementId,
-    getContainer: getContainer2,
+    getWidgetsCache: getWidgetsCache8,
+    generateElementId: generateElementId2,
+    getContainer: getContainer4,
     doUpdateElementProperty
   };
   xml;
@@ -3551,7 +4112,7 @@ var CompositionBuilder = class _CompositionBuilder {
     this.elementStylesConfig = config;
   }
   setCustomCSS(config) {
-    this.elementCusomCSS = config;
+    this.elementCustomCSS = config;
   }
   getXML() {
     return this.xml;
@@ -3631,7 +4192,7 @@ var CompositionBuilder = class _CompositionBuilder {
     const allConfigIds = /* @__PURE__ */ new Set([
       ...Object.keys(this.elementConfig),
       ...Object.keys(this.elementStylesConfig),
-      ...Object.keys(this.elementCusomCSS)
+      ...Object.keys(this.elementCustomCSS)
     ]);
     for (const configId of allConfigIds) {
       let element, node;
@@ -3642,7 +4203,7 @@ var CompositionBuilder = class _CompositionBuilder {
         if (this.elementConfig[configId]) {
           configErrors.push(msg);
         }
-        if (this.elementStylesConfig[configId] || this.elementCusomCSS[configId]) {
+        if (this.elementStylesConfig[configId] || this.elementCustomCSS[configId]) {
           styleErrors.push(msg);
         }
         continue;
@@ -3692,7 +4253,7 @@ var CompositionBuilder = class _CompositionBuilder {
           }
         }
       }
-      const customCSS = this.elementCusomCSS[configId];
+      const customCSS = this.elementCustomCSS[configId];
       if (customCSS) {
         try {
           this.api.doUpdateElementProperty({
@@ -3763,6 +4324,10 @@ var generatePrompt = () => {
 # RESOURCES (Read before use)
 - [elementor://global-classes] - Check FIRST for reusable classes
 - [elementor://global-variables] - ONLY use variables defined here
+- [${AVAILABLE_WIDGETS_URI}/v4]
+
+# TOOL SUPPORT
+This tool support v4 elements only
 
 # WORKFLOW
 1. Check/create global classes via "create-global-class" tool
@@ -3944,24 +4509,26 @@ var initBuildCompositionsTool = (reg) => {
       { description: "Styles schema", uri: STYLE_SCHEMA_URI },
       { description: "Global Classes", uri: "elementor://global-classes" },
       { description: "Global Variables", uri: "elementor://global-variables" },
-      { description: "Styles best practices", uri: BEST_PRACTICES_URI }
+      { description: "Styles best practices", uri: BEST_PRACTICES_URI },
+      { description: "Available widgets for this tool", uri: AVAILABLE_WIDGETS_URI_V4 }
     ],
     outputSchema,
     modelPreferences: {
       hints: [{ name: "claude-sonnet-4-5" }]
     },
     handler: async (params) => {
+      assertCompositionXmlUsesV4WidgetsOnly(params.xmlStructure);
       const { xmlStructure, elementConfig, stylesConfig, customCSS } = params;
       let generatedXML = "";
       const errors = [];
       const rootContainers = [];
-      const documentContainer = getContainer3("document");
+      const documentContainer = getContainer5("document");
       const currentDocument = getCurrentDocument();
       const targetContainer = getCompositionTargetContainer(documentContainer, currentDocument?.type.value);
       try {
         const compositionBuilder = CompositionBuilder.fromXMLString(xmlStructure, {
           createElement: createElement8,
-          getWidgetsCache: getWidgetsCache6
+          getWidgetsCache: getWidgetsCache9
         });
         compositionBuilder.setElementConfig(elementConfig);
         compositionBuilder.setStylesConfig(stylesConfig);
@@ -4038,6 +4605,31 @@ Remember: Global classes ensure design consistency and reusability. Don't skip a
     }
   });
 };
+function assertCompositionXmlUsesV4WidgetsOnly(xmlStructure) {
+  const doc = new DOMParser().parseFromString(xmlStructure, "application/xml");
+  if (doc.querySelector("parsererror")) {
+    throw new Error("Failed to parse XML string: " + doc);
+  }
+  const widgetsCache = getWidgetsCache9() ?? {};
+  for (const node of doc.querySelectorAll("*")) {
+    const type = node.tagName;
+    const widgetData = widgetsCache[type];
+    if (!widgetData) {
+      continue;
+    }
+    if (widgetData.elType !== "widget") {
+      continue;
+    }
+    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: ${type}`
+      );
+    }
+  }
+}
+
+// src/mcp/tools/configure-element/tool.ts
+import { getWidgetsCache as getWidgetsCache10 } from "@elementor/editor-elements";
 
 // src/mcp/tools/configure-element/prompt.ts
 var configureElementToolPrompt = `Configure an existing element on the page.
@@ -4049,11 +4641,11 @@ var configureElementToolPrompt = `Configure an existing element on the page.
 2. [${STYLE_SCHEMA_URI}]
    Required to understand the styles schema for the widgets. All widgets share the same styles schema, grouped by categories.
    Use this resource to understand which style properties are available for each element, and how to structure the "stylePropertiesToChange" parameter.
-3. If not sure about the PropValues schema, you can use the "get-element-configuration-values" tool to retreive the current PropValues configuration of the element.
+3. If not sure about the PropValues schema, you can use the "get-element-configuration-values" tool to retrieve the current PropValues configuration of the element.
 
 Before using this tool, check the definitions of the elements PropTypes at the resource "widget-schema-by-type" at editor-canvas__elementor://widgets/schema/{widgetType}
 All widgets share a common _style property for styling, which uses the common styles schema.
-Retreive and check the common styles schema at the resource list "styles-schema" at editor-canvas__elementor://styles/schema/{category}
+Retrieve and check the common styles schema at the resource list "styles-schema" at editor-canvas__elementor://styles/schema/{category}
 
 # Parameters
 - propertiesToChange: An object containing the properties to change, with their new values. MANDATORY. When updating a style only, provide an empty object.
@@ -4082,19 +4674,19 @@ PropValue structure:
 }
 
 <IMPORTANT>
-ALWAYS MAKE SURE you have the PropType schemas for the element you are configuring, and the common-styles schema for styling. If you are not sure, retreive the schema from the resources mentioned above.
+ALWAYS MAKE SURE you have the PropType schemas for the element you are configuring, and the common-styles schema for styling. If you are not sure, retrieve the schema from the resources mentioned above.
 </IMPORTANT>
 
 You can use multiple property changes at once by providing multiple entries in the propertiesToChange object, including _style alongside non-style props.
 Some properties are nested, use the root property name, then objects with nested values inside, as the complete schema suggests.
 
-Make sure you have the "widget-schema-by-type" resource available to retreive the PropType schema for the element type you are configuring.
-Make sure you have to "styles-schema" resources available to retreive the common styles schema.
+Make sure you have the "widget-schema-by-type" resource available to retrieve the PropType schema for the element type you are configuring.
+Make sure you have to "styles-schema" resources available to retrieve the common styles schema.
 
 # How to configure elements
 We use a dedicated PropType Schema for configuring elements, including styles. When you configure an element, you must use the EXACT PropType Value as defined in the schema.
 For styleProperties, use the style schema provided, as it also uses the PropType format.
-For all non-primitive types, provide the key property as defined in the schema as $$type in the generated objecct, as it is MANDATORY for parsing.
+For all non-primitive types, provide the key property as defined in the schema as $$type in the generated object, as it is MANDATORY for parsing.
 
 Use the EXACT "PROP-TYPE" Schema given, and ALWAYS include the "key" property from the original configuration for every property you are changing.
 
@@ -4150,7 +4742,7 @@ var inputSchema2 = {
     z2.any().describe(`The style PropValue, refer to [${STYLE_SCHEMA_URI}] how to generate values`),
     z2.any()
   ).describe("An object record containing style property names and their new values to be set on the element").default({}),
-  elementType: z2.string().describe("The type of the element to retreive the schema"),
+  elementType: z2.string().describe("The type of the element to retrieve the schema"),
   elementId: z2.string().describe("The unique id of the element to configure")
 };
 var outputSchema2 = {
@@ -4177,6 +4769,17 @@ var initConfigureElementTool = (reg) => {
       speedPriority: 0.7
     },
     handler: ({ elementId, propertiesToChange, elementType, stylePropertiesToChange }) => {
+      const widgetData = getWidgetsCache10()?.[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 toUpdate = Object.entries(propertiesToChange);
       const { valid, errors } = validateInput.validatePropSchema(elementType, propertiesToChange);
       const { valid: stylesValid, errors: stylesErrors } = validateInput.validateStyles(
@@ -4258,7 +4861,7 @@ Check the styles schema at the resource [${STYLE_SCHEMA_URI.replace(
 }
 
 // src/mcp/tools/get-element-config/tool.ts
-import { getContainer as getContainer4, getElementStyles as getElementStyles2, getWidgetsCache as getWidgetsCache7 } from "@elementor/editor-elements";
+import { getContainer as getContainer6, getElementStyles as getElementStyles2, getWidgetsCache as getWidgetsCache11 } from "@elementor/editor-elements";
 import { Schema as Schema4 } from "@elementor/editor-props";
 import { z as z3 } from "@elementor/schema";
 var schema = {
@@ -4297,12 +4900,24 @@ var initGetElementConfigTool = (reg) => {
       speedPriority: 0.9
     },
     handler: async ({ elementId }) => {
-      const element = getContainer4(elementId);
+      const element = getContainer6(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];
+      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 = getWidgetsCache7()?.[element.model.get("widgetType") || element.model.get("elType") || ""]?.atomic_props_schema;
+      const propSchema = getWidgetsCache11()?.[elementType]?.atomic_props_schema;
       if (!elementRawSettings || !propSchema) {
         throw new Error(`No settings or prop schema found for element ID: ${elementId}`);
       }
@@ -4354,7 +4969,11 @@ var initCanvasMcp = (reg) => {
 `
   );
   initWidgetsSchemaResource(reg);
+  initAvailableWidgetsResource(reg);
   initDocumentStructureResource(reg);
+  initSelectedElementResource(reg);
+  initEditorStateResource(reg);
+  initGeneralContextResource(reg);
   initBuildCompositionsTool(reg);
   initGetElementConfigTool(reg);
   initConfigureElementTool(reg);
@@ -4561,16 +5180,16 @@ function shouldBlock(sourceElements, targetElements) {
 }
 
 // src/style-commands/paste-style.ts
-import { getContainer as getContainer5, getElementSetting, updateElementSettings as updateElementSettings2 } from "@elementor/editor-elements";
+import { getContainer as getContainer7, getElementSetting, updateElementSettings as updateElementSettings2 } from "@elementor/editor-elements";
 import { classesPropTypeUtil } from "@elementor/editor-props";
 import {
-  __privateListenTo as listenTo2,
+  __privateListenTo as listenTo5,
   blockCommand as blockCommand4,
   commandStartEvent
 } from "@elementor/editor-v1-adapters";
 
 // src/utils/command-utils.ts
-import { getElementLabel as getElementLabel2, getWidgetsCache as getWidgetsCache8 } from "@elementor/editor-elements";
+import { getElementLabel as getElementLabel2, getWidgetsCache as getWidgetsCache12 } from "@elementor/editor-elements";
 import { CLASSES_PROP_KEY } from "@elementor/editor-props";
 import { __ as __5 } from "@wordpress/i18n";
 function hasAtomicWidgets(args) {
@@ -4595,7 +5214,7 @@ function getClassesProp(container) {
 }
 function getContainerSchema(container) {
   const type = container?.model.get("widgetType") || container?.model.get("elType");
-  const widgetsCache = getWidgetsCache8();
+  const widgetsCache = getWidgetsCache12();
   const elementType = widgetsCache?.[type];
   return elementType?.atomic_props_schema ?? null;
 }
@@ -4701,7 +5320,7 @@ function initPasteStyleCommand() {
     command: "document/elements/paste-style",
     condition: hasAtomicWidgets
   });
-  listenTo2(
+  listenTo5(
     commandStartEvent("document/elements/paste-style"),
     (e) => pasteStyles(e.args, pasteElementStyleCommand)
   );
@@ -4714,7 +5333,7 @@ function pasteStyles(args, pasteLocalStyle) {
   }
   const clipboardElements = getClipboardElements(storageKey);
   const [clipboardElement] = clipboardElements ?? [];
-  const clipboardContainer = getContainer5(clipboardElement.id);
+  const clipboardContainer = getContainer7(clipboardElement.id);
   if (!clipboardElement || !clipboardContainer || !isAtomicWidget(clipboardContainer)) {
     return;
   }
@@ -4754,7 +5373,7 @@ function pasteClasses(containers, classes) {
 
 // src/style-commands/reset-style.ts
 import {
-  __privateListenTo as listenTo3,
+  __privateListenTo as listenTo6,
   blockCommand as blockCommand5,
   commandStartEvent as commandStartEvent2
 } from "@elementor/editor-v1-adapters";
@@ -4812,7 +5431,7 @@ function initResetStyleCommand() {
     command: "document/elements/reset-style",
     condition: hasAtomicWidgets
   });
-  listenTo3(
+  listenTo6(
     commandStartEvent2("document/elements/reset-style"),
     (e) => resetStyles(e.args, resetElementStyles)
   );
@@ -4910,9 +5529,33 @@ var getLegacyPanelElementView = ({ settings, ...rest }) => {
   });
   return { model: elementModel };
 };
+
+// src/sync/global-styles-imported-event.ts
+var GLOBAL_STYLES_IMPORTED_EVENT = "elementor/global-styles/imported";
+
+// src/utils/after-render.ts
+import { getContainer as getContainer8 } from "@elementor/editor-elements";
+function doAfterRender(elementIds, callback) {
+  const pending = elementIds.map((elementId) => {
+    const view = getContainer8(elementId)?.view;
+    if (!view || !hasDoAfterRender(view)) {
+      return void 0;
+    }
+    return new Promise((resolve) => view._doAfterRender(resolve));
+  }).filter(Boolean);
+  if (pending.length > 0) {
+    Promise.all(pending).then(() => callback(elementIds));
+  } else {
+    callback(elementIds);
+  }
+}
+function hasDoAfterRender(view) {
+  return typeof view?._doAfterRender === "function";
+}
 export {
   BREAKPOINTS_SCHEMA_URI,
   DOCUMENT_STRUCTURE_URI,
+  GLOBAL_STYLES_IMPORTED_EVENT,
   STYLE_SCHEMA_URI,
   UnknownStyleStateError,
   UnknownStyleTypeError,
@@ -4924,6 +5567,7 @@ export {
   createTemplatedElementView,
   createTransformer,
   createTransformersRegistry,
+  doAfterRender,
   endDragElementFromPanel,
   init,
   isAtomicWidget,