@myop/sdk 0.3.36 → 0.4.0-beta.0

package/dist/module/host/index.js

@@ -1619,9 +1619,7 @@ var MyopIframeComponent = class extends BaseMyopComponent {
       const iframe = this.IframeElement;
       const doc = iframe.contentDocument;
       if (!doc) {
-        console.warn("[MyopIframeComponent] Cannot observe auto size: contentDocument not accessible");
-        return () => {
-        };
+        return this.observeHeightViaBridge();
       }
       const clamp = (value, min, max) => {
         if (min !== void 0 && value < min) return min;
@@ -1765,6 +1763,32 @@ var MyopIframeComponent = class extends BaseMyopComponent {
       this._autoSizeCleanup = cleanup;
       return cleanup;
     });
+    __publicField(this, "_bridgeSizeCleanup");
+    /**
+     * Auto-height for a frame the host can't read (cross-origin). Runs after the IframeSDK
+     * handshake: the frame reports body resizes and the host re-reads the scroll height.
+     */
+    __publicField(this, "observeHeightViaBridge", () => {
+      if (this._bridgeSizeCleanup) return this._bridgeSizeCleanup;
+      let observerCleanup;
+      let stopped = false;
+      const cleanup = () => {
+        stopped = true;
+        observerCleanup == null ? void 0 : observerCleanup();
+        this._bridgeSizeCleanup = void 0;
+      };
+      this._bridgeSizeCleanup = cleanup;
+      this.initiated().then(() => {
+        if (stopped || this.markedForDisposed) return;
+        this.IframeElement.style.position = "relative";
+        this.IframeElement.style.inset = "auto";
+        this.IframeElement.style.width = "100%";
+        this.setHeightBasedOnScrollHeight();
+        observerCleanup = this.send(new SetResizeObserverMessage());
+      }).catch(() => {
+      });
+      return cleanup;
+    });
     __publicField(this, "setSizeBasedOnDocumentElement", () => {
       const cleanupHandler = this.send(new ExecuteScriptMessage(() => {
         const { height, width } = document.documentElement.getBoundingClientRect();
@@ -1810,6 +1834,8 @@ var MyopIframeComponent = class extends BaseMyopComponent {
       return cleanupHandler;
     });
     __publicField(this, "dispose", () => {
+      var _a;
+      (_a = this._bridgeSizeCleanup) == null ? void 0 : _a.call(this);
       if (this._autoSizeCleanup) {
         this._autoSizeCleanup();
         this._autoSizeCleanup = void 0;
@@ -1986,7 +2012,11 @@ var MyopIframeLoader = class extends BaseMyopLoader {
           container.innerHTML = "";
         IframeElement = this.appendChild(container, IframeElement, options);
       }
-      return new MyopIframeComponent(componentDefinition, skin, container, IframeElement, options);
+      const component = new MyopIframeComponent(componentDefinition, skin, container, IframeElement, options);
+      if (typedLoaderConfig.autoHeight && (options == null ? void 0 : options.autoSize) !== false) {
+        component.observeHeightViaBridge();
+      }
+      return component;
     }));
   }
 };
@@ -2100,1182 +2130,1544 @@ var WebcomponentLoader = class extends BaseMyopLoader {
 };
 
 // version:myop-sdk-version
-var myop_sdk_version_default = "0.3.36";
+var myop_sdk_version_default = "0.4.0-beta.0";
 
-// src/webcomponent/messageHandlers/BaseWebComponentMessageHandler.ts
-var BaseWebComponentMessageHandler = class extends BaseContextMessageHandler {
-  constructor(messageToHost, context) {
-    super(messageToHost);
-    this.context = context;
-    __publicField(this, "executor", (event) => {
-      if (event.destination) {
-        const destination = event.destination;
-        if (this.context[destination].context) {
-          const _messageToHost = (message, replayTo) => {
-            this.messageToHost(__spreadProps(__spreadValues({}, message), {
-              source: event.destination ? event.destination : event.source,
-              destination: event.source ? event.source : event.destination
-            }), replayTo);
-          };
-          return this.innerExecutor(event, this.context[destination].context, _messageToHost);
-        } else {
-          debugger;
+// src/helpers/deliveryStore.ts
+var DB_NAME = "myop-delivery";
+var STORE = "components";
+var DB_VERSION = 1;
+var dbPromise = null;
+function openDb() {
+  if (dbPromise) return dbPromise;
+  dbPromise = new Promise((resolve) => {
+    try {
+      if (typeof indexedDB === "undefined") return resolve(null);
+      const req = indexedDB.open(DB_NAME, DB_VERSION);
+      req.onupgradeneeded = () => {
+        const db = req.result;
+        if (!db.objectStoreNames.contains(STORE)) db.createObjectStore(STORE, { keyPath: "key" });
+      };
+      req.onsuccess = () => resolve(req.result);
+      req.onerror = () => resolve(null);
+      req.onblocked = () => resolve(null);
+    } catch (e) {
+      resolve(null);
+    }
+  });
+  return dbPromise;
+}
+function tx(mode, fn) {
+  return openDb().then((db) => new Promise((resolve) => {
+    if (!db) return resolve(null);
+    try {
+      const t = db.transaction(STORE, mode);
+      const req = fn(t.objectStore(STORE));
+      req.onsuccess = () => resolve(req.result);
+      req.onerror = () => resolve(null);
+      t.onabort = () => resolve(null);
+    } catch (e) {
+      resolve(null);
+    }
+  }));
+}
+var HINT_PREFIX = "myop.d.";
+function writeHint(key, tag, expiresAt) {
+  try {
+    localStorage.setItem(HINT_PREFIX + key, JSON.stringify({ t: tag, e: expiresAt }));
+  } catch (e) {
+  }
+}
+function clearHint(key) {
+  try {
+    localStorage.removeItem(HINT_PREFIX + key);
+  } catch (e) {
+  }
+}
+var memory = /* @__PURE__ */ new Map();
+var deliveryStore = {
+  key(host, componentId, env, preview, opt) {
+    return `${host}|${componentId}|${env}|${preview ? "preview" : "live"}|${opt || "raw"}`;
+  },
+  get(key) {
+    return __async(this, null, function* () {
+      const m = memory.get(key);
+      if (m) return m;
+      const e = yield tx("readonly", (s) => s.get(key));
+      if (e) {
+        memory.set(key, e);
+        writeHint(key, e.tag, e.storedAt + e.windowMs);
+      }
+      return e;
+    });
+  },
+  put(entry) {
+    return __async(this, null, function* () {
+      memory.set(entry.key, entry);
+      writeHint(entry.key, entry.tag, entry.storedAt + entry.windowMs);
+      yield tx("readwrite", (s) => s.put(entry));
+    });
+  },
+  drop(key) {
+    return __async(this, null, function* () {
+      memory.delete(key);
+      clearHint(key);
+      yield tx("readwrite", (s) => s.delete(key));
+    });
+  },
+  /** Still usable without asking the server? */
+  fresh(e) {
+    return !!e && Date.now() - e.storedAt < e.windowMs;
+  },
+  /**
+   * The window this response licenses: the server's freshness minus what a CDN already
+   * spent. Returns 0 when the server said nothing about caching, which means "do not
+   * hold this" — the safe reading, and what production sends today.
+   */
+  windowFrom(headers) {
+    const cc = headers.get("cache-control") || "";
+    if (/no-store|no-cache/i.test(cc)) return 0;
+    const m = /s-maxage\s*=\s*(\d+)/i.exec(cc) || /max-age\s*=\s*(\d+)/i.exec(cc);
+    if (!m) return 0;
+    const total = Number(m[1]);
+    const age = Number(headers.get("age") || 0);
+    return Math.max(0, total - (isNaN(age) ? 0 : age)) * 1e3;
+  },
+  /** For tests and for `refresh()`: forget everything this browser holds. */
+  clear() {
+    return __async(this, null, function* () {
+      memory.clear();
+      try {
+        for (let i = localStorage.length - 1; i >= 0; i--) {
+          const k = localStorage.key(i);
+          if (k && k.startsWith(HINT_PREFIX)) localStorage.removeItem(k);
         }
-      } else {
-        debugger;
+      } catch (e) {
       }
+      yield tx("readwrite", (s) => s.clear());
     });
   }
 };
 
-// src/consts.ts
-var myopAttributes = {
-  id: "myop-id"
+// src/helpers/CloudRepository.ts
+var convertV2VariantToComponentConfig = (config) => {
+  return {
+    instance: {
+      id: "auto",
+      componentId: config.componentId,
+      componentName: config.name,
+      skinSelector: {
+        type: "Dedicated",
+        skin: {
+          id: "skin_auto_v2_converted"
+        }
+      }
+    },
+    type: {
+      id: config.id,
+      name: config.name,
+      description: config.description,
+      props: [
+        {
+          id: "in_auto_v2_converted",
+          name: "myop_init_interface",
+          type: "any",
+          behavior: {
+            type: PropConfigBehaviorTypes.code
+          }
+        },
+        {
+          id: "out_auto_v2_converted",
+          name: "myop_cta_handler",
+          type: "any",
+          behavior: {
+            type: PropConfigBehaviorTypes.code
+          }
+        }
+      ],
+      refs: [],
+      skins: [
+        {
+          id: "skin_auto_v2_converted",
+          name: "auto_v2_converted",
+          description: "",
+          //TODO : handle empty :
+          // @ts-ignore
+          loader: config.consume_variant[0].loader
+        }
+      ],
+      defaultSkin: 0
+    },
+    name: config.name
+  };
 };
-
-// src/common/messageHandlers/helpers.ts
-var getElementsByRef = (ref, el) => {
-  return el.querySelectorAll(`[${myopAttributes.id}='${ref.refConfig.selector}']`);
+var GLOBAL_KEY = "__MYOP_CLOUD_REPOSITORY_MAIN__";
+var getGlobalMain = () => {
+  if (typeof window !== "undefined") {
+    return window[GLOBAL_KEY];
+  }
+  if (typeof globalThis !== "undefined") {
+    return globalThis[GLOBAL_KEY];
+  }
+  return void 0;
 };
-
-// src/webcomponent/messageHandlers/bindOnClickHandler.ts
-var BindOnClickHandler = class extends BaseWebComponentMessageHandler {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "messageType", MyopMessages.BindClickMessage);
-    __publicField(this, "innerExecutor", (event, shadowRootRef, messageToHost) => {
-      const items = getElementsByRef(event.ref, shadowRootRef.shadowRoot);
-      const cleanupTasks = [];
-      items.forEach((item) => {
-        const handler = () => {
-          messageToHost(new ClickReplayMessage(event.handlerUniqueId));
-        };
-        item.addEventListener("click", handler);
-        cleanupTasks.push(() => {
-          item.removeEventListener("click", handler);
-        });
-      });
-      return () => {
-        cleanupTasks.forEach((task) => task());
-      };
-    });
+var setGlobalMain = (instance) => {
+  if (typeof window !== "undefined") {
+    window[GLOBAL_KEY] = instance;
+  }
+  if (typeof globalThis !== "undefined") {
+    globalThis[GLOBAL_KEY] = instance;
   }
 };
-
-// src/webcomponent/messageHandlers/changeTextHandler.ts
-var ChangeTextHandler = class extends BaseWebComponentMessageHandler {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "messageType", MyopMessages.ChangeTextMessage);
-    __publicField(this, "innerExecutor", (event, shadowRootRef) => {
-      const items = getElementsByRef(event.ref, shadowRootRef.shadowRoot);
-      items.forEach((item) => {
-        item.textContent = event.content;
-      });
+var _CloudRepository = class _CloudRepository {
+  constructor(_baseUrl = "https://cloud.myop.dev") {
+    this._baseUrl = _baseUrl;
+    // v2 cache - keyed by componentId:env:preview|live
+    // Each Promise is tagged with a `resolved` property after settling (see fetchComponentV2).
+    __publicField(this, "variants", {});
+    // Track which components were preloaded and with what params
+    // Key: componentId, Value: { env, preview }
+    __publicField(this, "preloadedComponents", {});
+    // v1 cache
+    __publicField(this, "userFlows", {});
+    __publicField(this, "_defaultEnv", "production");
+    __publicField(this, "_envExplicitlySet", false);
+    __publicField(this, "_staticMode", false);
+    __publicField(this, "_queryParams", {});
+    /**
+     * Opt-in delivery settings, set by myop.delivery(). Off means: this file behaves
+     * EXACTLY as it did before — same host, same URL, same everything.
+     */
+    __publicField(this, "_delivery", { minify: false, host: null, cache: false });
+    /**
+     * What actually happened, for myop.delivery.stats(). `fellBack` is the number that
+     * matters: it is how you find out the lane is unhealthy without waiting for a
+     * bug report, because a fallback is INVISIBLE to the page (it still renders).
+     */
+    __publicField(this, "_deliveryStats", {
+      requests: 0,
+      viaDelivery: 0,
+      fellBack: 0,
+      lastError: null,
+      /** where the last loads were answered from — the number the client window exists to move */
+      fromMemory: 0,
+      fromStorage: 0,
+      fromNetwork: 0,
+      /** re-checks after the window ended, and how many were answered "nothing changed" */
+      revalidations: 0,
+      unchanged: 0,
+      bytesSaved: 0
     });
+    /**
+     * Local serves waiting to be reported: componentId -> {env, count}.
+     *
+     * THE MEASUREMENT PROBLEM THIS SOLVES. The better this cache works, the more usage
+     * vanishes: a visitor inside their freshness window renders the page with no request,
+     * so neither the server nor the CDN can see them. Left alone, a successful rollout
+     * looks in the ledger exactly like customers leaving.
+     *
+     * So local serves are counted here and reported afterwards, batched, on a path that
+     * never blocks rendering: flushed when the page is hidden (keepalive, so it survives
+     * the tab closing) and opportunistically whenever the SDK is talking to the server
+     * anyway. Nothing is sent while the page is loading, which is the point of the window.
+     */
+    __publicField(this, "_localServes", /* @__PURE__ */ new Map());
+    __publicField(this, "_flushBound", false);
   }
-};
-
-// src/webcomponent/shadowRootRef.ts
-var ShadowRootRef = class extends RootRef {
-  constructor(container, shadowRoot) {
-    super(container, shadowRoot);
-    this.container = container;
-    this.shadowRoot = shadowRoot;
+  static get Main() {
+    const globalMain = getGlobalMain();
+    if (globalMain) {
+      return globalMain;
+    }
+    if (!_CloudRepository._main) {
+      _CloudRepository._main = new _CloudRepository();
+      setGlobalMain(_CloudRepository._main);
+    }
+    return _CloudRepository._main;
   }
-};
-
-// src/webcomponent/messageHandlers/DetectMyopRefsMessageHandler.ts
-var DetectMyopRefsMessageHandler = class extends BaseWebComponentMessageHandler {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "innerExecutor", (event, shadowRootRef) => {
-      const allMyopItems = shadowRootRef.shadowRoot.querySelectorAll(`[${myopAttributes.id}]`);
-      let myopRefs = [];
-      allMyopItems.forEach((item) => {
-        const myopId = item.getAttribute(myopAttributes.id);
-        if (myopId) {
-          myopRefs.push(new MyopElementRef(myopId, item.tagName, item.getBoundingClientRect(), item.offsetTop, item.offsetLeft));
-        }
-      });
-      this.messageToHost(new DetectedMyopRefsMessage(event.handlerUniqueId, myopRefs));
+  /**
+   * How big the component we are NOT re-downloading is. Deliberately measured from what
+   * we hold rather than from Content-Length: once a response is compressed the header is
+   * not readable cross-origin, so reading it there reported 0 every single time.
+   */
+  static sizeOfHeld(e) {
+    var _a, _b, _c, _d, _e;
+    try {
+      return (((_e = (_d = (_c = (_b = (_a = e == null ? void 0 : e.config) == null ? void 0 : _a.type) == null ? void 0 : _b.skins) == null ? void 0 : _c[0]) == null ? void 0 : _d.loader) == null ? void 0 : _e.HTML) || "").length;
+    } catch (e2) {
+      return 0;
+    }
+  }
+  /**
+   * Turn on the opt-in delivery path.
+   *
+   * Opting in IS choosing the delivery stack: this points /consume at `host` (a second,
+   * complete stack reading the same data) and asks for the minified artifact. Leave this
+   * uncalled and nothing about the SDK changes.
+   *
+   * Deliberately mutates THIS instance rather than constructing a new repository:
+   * CloudRepository.Main is a global singleton shared across bundles (see getGlobalMain),
+   * so a second instance would be ignored by every component already using the first.
+   */
+  setDelivery(opts = {}) {
+    if (opts.minify !== void 0) this._delivery.minify = !!opts.minify;
+    if (opts.host !== void 0) this._delivery.host = opts.host;
+    if (opts.cache !== void 0) this._delivery.cache = !!opts.cache;
+  }
+  deliveryStats() {
+    var _a;
+    return __spreadProps(__spreadValues({}, this._deliveryStats), {
+      host: (_a = this._delivery.host) != null ? _a : _CloudRepository.DEFAULT_HOST,
+      minify: this._delivery.minify,
+      cache: this._delivery.cache
     });
-    __publicField(this, "messageType", MyopMessages.DetectMyopRefsMessage);
   }
-};
-
-// src/webcomponent/messageHandlers/setAttributeHandler.ts
-var setAttributeHandler = class extends BaseWebComponentMessageHandler {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "messageType", MyopMessages.SetAttributeMessage);
-    __publicField(this, "innerExecutor", (event, shadowRootRef) => {
-      const items = getElementsByRef(event.ref, shadowRootRef.shadowRoot);
-      items.forEach((item) => {
-        item.setAttribute(event.name, event.value);
-      });
+  /**
+   * Forget what this browser holds, so the next load asks the server.
+   * `refresh()` with no ids drops everything; the counterpart to the window for the case
+   * where a change has to be visible on THIS load — right after someone publishes.
+   */
+  refreshDelivery() {
+    return __async(this, null, function* () {
+      yield deliveryStore.clear();
     });
   }
-};
-
-// src/webcomponent/messageHandlers/addEventListenerHandler.ts
-var AddEventListenerHandler = class extends BaseWebComponentMessageHandler {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "messageType", MyopMessages.AddEventListenerMessage);
-    __publicField(this, "innerExecutor", (event, shadowRootRef, messageToHost) => {
-      const items = getElementsByRef(event.ref, shadowRootRef.shadowRoot);
-      const cleanupTasks = [];
-      items.forEach((item) => {
-        const handler = (e) => {
-          messageToHost(new EventListenerCallbackMessage(event.handlerUniqueId, makeSerializable(e, event.serializableSkeleton)));
-        };
-        item.addEventListener(event.type, handler);
-        cleanupTasks.push(() => {
-          item.removeEventListener(event.type, handler);
-        });
-      });
-      return () => {
-        cleanupTasks.forEach((task) => task());
-      };
-    });
+  noteLocalServe(componentId, env) {
+    const cur = this._localServes.get(componentId);
+    if (cur) cur.count++;
+    else this._localServes.set(componentId, { env, count: 1 });
+    this.bindFlush();
+  }
+  /** Report on page-hide, which is the only event that reliably fires on mobile. */
+  bindFlush() {
+    if (this._flushBound || typeof document === "undefined") return;
+    this._flushBound = true;
+    const onHide = () => {
+      if (document.visibilityState === "hidden") this.flushLocalServes();
+    };
+    document.addEventListener("visibilitychange", onHide);
+    window.addEventListener("pagehide", () => this.flushLocalServes());
   }
-};
-
-// src/webcomponent/messageHandlers/CreateRefComponentMessageHandler.ts
-var CreateRefComponentMessageHandler = class extends BaseWebComponentMessageHandler {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "messageType", MyopMessages.CreateRefComponentMessage);
-    __publicField(this, "innerExecutor", (event, shadowRootRef, messageToHost) => {
-      const createRef = () => __async(this, null, function* () {
-        const allItems = shadowRootRef.shadowRoot.querySelectorAll(`[${myopAttributes.id}='${event.refConfig.selector}']`);
-        if (allItems.length === 1) {
-          const hostSDK2 = HostSDK.Instance();
-          const refComponent = hostSDK2.components.find((c) => c.id === event.options.id);
-          if (refComponent) {
-            refComponent.dispose();
-          } else {
-          }
-          const index = hostSDK2.components.indexOf(refComponent);
-          if (index !== -1) {
-            hostSDK2.components.splice(index, 1);
-          } else {
-          }
-          const implementationComponent = yield hostSDK2.loadComponent(
-            event.nestedComponentConfig,
-            allItems.item(0),
-            event.options
-          );
-          const nestedRefConfig = [];
-          Object.keys(implementationComponent.refs).forEach((refName) => {
-            let ref = implementationComponent.refs[refName];
-            ref = ref.__nonProxied || ref;
-            if (ref.componentDefinition) {
-              nestedRefConfig.push({
-                refName,
-                componentDefinitionId: ref.componentDefinition.id
-              });
-            }
-          });
-          messageToHost(new RefComponentCreatedMessage(event.handlerUniqueId, nestedRefConfig));
-        } else {
-          console.error("CreateRefComponentMessageHandler - DOM element not found");
-          this.messageToHost(new RefComponentCreatedMessage(event.handlerUniqueId, [], true));
-          debugger;
-        }
+  /**
+   * Send what we have. `keepalive` is what makes this work at page-hide: the request
+   * outlives the document. Failure is ignored — a lost usage report must never be
+   * visible to a visitor, and the next page load will report its own.
+   */
+  flushLocalServes() {
+    if (!this._localServes.size) return;
+    const batch = [...this._localServes.entries()].map(([id, v]) => `${id}:${v.env}:${v.count}`).join(",");
+    this._localServes.clear();
+    try {
+      const url = `${this.deliveryHost()}/clientUsage?b=${encodeURIComponent(batch)}`;
+      fetch(url, { keepalive: true, mode: "cors", credentials: "omit" }).catch(() => {
       });
-      createRef().then();
-    });
+    } catch (e) {
+    }
   }
-};
-
-// src/common/messageHandlers/executeScriptHandler.ts
-var ExecuteScriptHandlerExecutor = (event, replier, rootRef) => {
-  const __scriptInputs = event.scriptInputs ? event.scriptInputs : {};
-  __scriptInputs.makeSerializable = makeSerializable;
-  __scriptInputs.send = replier;
-  __scriptInputs.rootRef = rootRef;
-  __scriptInputs.__scriptInputs = __scriptInputs;
-  const dynamicFunction = new Function(`return (${event.script})(...arguments)`);
-  const ret = dynamicFunction(__scriptInputs);
-  replier(ret);
-};
-
-// src/webcomponent/messageHandlers/executeScriptHandler.ts
-var ExecuteScriptHandler = class extends BaseWebComponentMessageHandler {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "messageType", MyopMessages.ExecuteScriptMessage);
-    __publicField(this, "innerExecutor", (event, shadowRootRef, messageToHost) => {
-      const replier = (data) => {
-        messageToHost(new ExecuteScriptReplyMessage(event.handlerUniqueId, data));
-      };
-      ExecuteScriptHandlerExecutor(event, replier, shadowRootRef);
-    });
+  /** Where /consume should be fetched from right now. */
+  deliveryHost() {
+    return this._delivery.host || this._baseUrl;
   }
-};
-
-// src/webcomponent/messageHandlers/GetElementValueHandler.ts
-var getInputValue = (element) => {
-  if (!element) return null;
-  if (element.tagName === "FORM") {
-    const formData = new FormData(element);
-    const dataObject = {
-      formData: {},
-      unmappedData: []
-    };
-    const elements = element.querySelectorAll("input, select, textarea");
-    let autoNameIndexer = -1;
-    elements.forEach((element2) => {
-      if (typeof element2.value === "string") {
-        const myopId = element2.getAttribute(myopAttributes.id);
-        let key = element2.getAttribute("name");
-        const nodeData = {
-          id: element2.id,
-          name: key,
-          value: getInputValue(element2),
-          required: element2.required,
-          validity: makeSerializable(element2.validity, true),
-          myopId
-        };
-        if (!key) {
-          dataObject.unmappedData.push(nodeData);
-        } else {
-          if (dataObject.formData[key]) {
-            if (dataObject.formData[key].value) {
-              dataObject.unmappedData.push(nodeData);
-            } else {
-              dataObject.unmappedData.push(dataObject.formData[key]);
-              dataObject.formData[key] = nodeData;
-            }
-          } else {
-            dataObject.formData[key] = nodeData;
-          }
+  /**
+   * Fetch a delivery URL with ONE fallback to the default host.
+   *
+   * The fallback is the kill switch: break or disable the lane and every client drifts
+   * back to cloud.myop.dev on its own, with no customer deploy. It must therefore be
+   * genuinely silent to the page and genuinely LOUD in stats() — a fallback that nobody
+   * counts is an outage nobody notices.
+   *
+   * Only transport failures and 5xx fall back. A 404 is an answer: the component really
+   * is missing, and retrying elsewhere would only hide it.
+   */
+  deliveryFetch(path) {
+    return __async(this, null, function* () {
+      var _a;
+      if (this._localServes.size) this.flushLocalServes();
+      const host = this.deliveryHost();
+      const primary = `${host}${path}`;
+      this._deliveryStats.requests++;
+      const usingLane = host !== this._baseUrl;
+      try {
+        const res = yield fetch(primary);
+        if (res.ok || res.status < 500 || !usingLane) {
+          if (usingLane && res.ok) this._deliveryStats.viaDelivery++;
+          return res;
         }
+        this._deliveryStats.lastError = `HTTP ${res.status} from ${host}`;
+      } catch (e) {
+        if (!usingLane) throw e;
+        this._deliveryStats.lastError = String((_a = e == null ? void 0 : e.message) != null ? _a : e);
       }
+      this._deliveryStats.fellBack++;
+      console.warn(`[myop] delivery host failed (${this._deliveryStats.lastError}) \u2014 falling back to ${this._baseUrl}`);
+      return yield fetch(`${this._baseUrl}${path}`);
     });
-    return dataObject;
   }
-  if (element.type === "checkbox" || element.type === "radio") {
-    return element.checked ? element.value : null;
+  /**
+   * Enable static mode for self-hosted component registries.
+   * In static mode, URLs are constructed as file paths instead of query params:
+   *   ${baseUrl}/components/${componentId}/${env}.json
+   */
+  enableStaticMode() {
+    this._staticMode = true;
   }
-  if (element.tagName === "INPUT" || element.tagName === "TEXTAREA") {
-    return element.value;
+  /**
+   * Set query parameters to append to all fetch URLs (e.g. for CDN cache busting).
+   * Example: `setQueryParams({ lastupdate: '11112026' })`
+   */
+  setQueryParams(params) {
+    this._queryParams = params;
   }
-  if (element.tagName === "SELECT") {
-    return element.value;
+  /**
+   * Set the default environment for this CloudRepository instance
+   */
+  setEnvironment(env) {
+    this._defaultEnv = env;
+    this._envExplicitlySet = true;
   }
-  if (element.isContentEditable) {
-    return element.innerText || element.textContent;
+  /**
+   * Get the current default environment
+   */
+  getDefaultEnvironment() {
+    return this._defaultEnv;
   }
-  return null;
-};
-var GetElementValueHandler = class extends BaseWebComponentMessageHandler {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "messageType", MyopMessages.GetElementValueMessage);
-    __publicField(this, "innerExecutor", (event, shadowRootRef, messageToHost) => {
-      const items = getElementsByRef(event.ref, shadowRootRef.shadowRoot);
-      items.forEach((item) => {
-        messageToHost(new ElementValueReplayMessage(getInputValue(item)), event);
-      });
-    });
+  // ============ V2 Methods (Default) ============
+  /**
+   * Check if a component is already cached/preloaded (v2)
+   * If env and preview are not provided, checks if ANY version is preloaded
+   */
+  isPreloaded(componentId, env, preview) {
+    if (env !== void 0 || preview !== void 0) {
+      const cacheKey = `${componentId}:${env || this._defaultEnv}:${preview ? "preview" : "live"}`;
+      return cacheKey in this.variants;
+    }
+    return componentId in this.preloadedComponents;
   }
-};
-
-// src/webcomponent/messageHandlers/setInnerHtmlHandler.ts
-var SetInnerHtmlHandler = class extends BaseWebComponentMessageHandler {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "messageType", MyopMessages.SetInnerHtml);
-    __publicField(this, "innerExecutor", (event, shadowRootRef) => {
-      const items = getElementsByRef(event.ref, shadowRootRef.shadowRoot);
-      items.forEach((item) => {
-        item.innerHTML = event.content;
-      });
-    });
+  /**
+   * Get the preloaded params for a component (if preloaded)
+   * Returns undefined if not preloaded
+   */
+  getPreloadedParams(componentId) {
+    return this.preloadedComponents[componentId];
   }
-};
-
-// src/webcomponent/WebComponentSDK.ts
-var WebComponentSDK = class extends BaseMyopSDK {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "alwaysPassEnvelopesToHost", true);
-    //when new web component created.
-    __publicField(this, "connectedCallback", (container, shadow) => {
-      container.addEventListener(myopWebcomponentConsts.webcomponent_message_key, (e) => {
-        const eventContent = e.data ? e.data : e.detail;
-        if (!eventContent || !eventContent.myop) {
-          debugger;
-          throw new Error("recvied webcomponent_message with wrong type");
-        } else {
-          const message = eventContent;
-          this.handleIncomeMessages(e);
-          if (message.messageType === MyopMessages.InitMessage) {
-            const newComponentId = message.content.id;
-            this.components[newComponentId].context = new ShadowRootRef(container, shadow);
-          }
-        }
-      });
-      setTimeout(() => {
-        this.messageToHost(new InitRequest());
-      }, 1);
+  /**
+   * Resolve a component config: fetch it once, then serve it from this
+   * repository's cache.
+   *
+   * This is the name to use. `fetchComponentV2` is the same method under its
+   * versioned name and stays for backward compatibility — note that the
+   * unversioned `fetchComponent` is a *deprecated v1* API and is NOT this.
+   *
+   * Completes the trio with {@link getResolvedConfig} (synchronous read of an
+   * already-resolved config) and {@link hydrateComponent} (seed one you
+   * already hold).
+   *
+   * Prefer the module-level `preloadComponents([id])` in app code; reach for
+   * this when you need an isolated repository instance whose cache lifetime
+   * you control — a server with its own TTL, for example.
+   */
+  resolveComponent(componentId, env, preview) {
+    return __async(this, null, function* () {
+      return this.fetchComponentV2(componentId, env, preview);
     });
-    __publicField(this, "messageToHost", (message, replayTo) => {
-      message.direction = MessageDirection.up;
-      if (!message.replayToHandler && (replayTo == null ? void 0 : replayTo.handlerUniqueId))
-        message.replayToHandler = replayTo.handlerUniqueId;
-      window.myop.hostSDK.send(message);
+  }
+  /**
+   * Fetch a v2 component config
+   * If env/preview not specified and component was preloaded, uses preloaded params
+   *
+   * @see resolveComponent — the unversioned name for this method
+   */
+  fetchComponentV2(componentId, environmentIdentifier, preview) {
+    return __async(this, null, function* () {
+      const { env, usePreview, cacheKey } = this.resolveParams(componentId, environmentIdentifier, preview);
+      console.log("[CloudRepository] fetchComponentV2", {
+        componentId: componentId.slice(0, 8) + "...",
+        env,
+        usePreview,
+        cacheKey,
+        cached: cacheKey in this.variants
+      });
+      if (!this.variants[cacheKey]) {
+        if (!this.preloadedComponents[componentId]) {
+          this.preloadedComponents[componentId] = { env, preview: usePreview };
+        }
+        this.variants[cacheKey] = new Promise(
+          (resolve, reject) => __async(this, null, function* () {
+            try {
+              let url;
+              if (this._staticMode) {
+                const file = usePreview ? "preview" : env;
+                url = `${this._baseUrl}/components/${componentId}/${file}.json`;
+                const qs = new URLSearchParams(this._queryParams).toString();
+                if (qs) url += `?${qs}`;
+              } else {
+                url = `/consume?id=${componentId}&env=${env}`;
+                if (usePreview) {
+                  url += "&preview=true";
+                }
+                if (this._delivery.minify && !usePreview) {
+                  url += "&opt=min";
+                }
+              }
+              const cacheable = this._delivery.cache && !this._staticMode && !usePreview;
+              const storeKey = cacheable ? deliveryStore.key(
+                this.deliveryHost(),
+                componentId,
+                env,
+                usePreview,
+                this._delivery.minify ? "min" : "raw"
+              ) : "";
+              let held = cacheable ? yield deliveryStore.get(storeKey) : null;
+              if (held && deliveryStore.fresh(held)) {
+                this._deliveryStats.fromStorage++;
+                this.noteLocalServe(componentId, env);
+                this.variants[cacheKey].resolved = held.config;
+                resolve(held.config);
+                return;
+              }
+              if (held && held.tag) {
+                const checkUrl = `/consume?ids=${componentId}&env=${env}` + (this._delivery.minify ? "&opt=min" : "") + `&have=${encodeURIComponent(held.tag)}`;
+                this._deliveryStats.revalidations++;
+                try {
+                  const check = yield this.deliveryFetch(checkUrl);
+                  if (check.ok) {
+                    const body = yield check.json();
+                    if ((body.unchanged || []).includes(componentId)) {
+                      this._deliveryStats.unchanged++;
+                      this._deliveryStats.bytesSaved += _CloudRepository.sizeOfHeld(held);
+                      held.storedAt = Date.now();
+                      held.windowMs = deliveryStore.windowFrom(check.headers) || held.windowMs;
+                      yield deliveryStore.put(held);
+                      this.variants[cacheKey].resolved = held.config;
+                      resolve(held.config);
+                      return;
+                    }
+                    const item = (body.items || [])[0];
+                    if (item) {
+                      const cfg = convertV2VariantToComponentConfig(item);
+                      this._deliveryStats.fromNetwork++;
+                      yield deliveryStore.put({
+                        key: storeKey,
+                        config: cfg,
+                        tag: item.tag || null,
+                        storedAt: Date.now(),
+                        windowMs: deliveryStore.windowFrom(check.headers),
+                        host: this.deliveryHost()
+                      });
+                      this.variants[cacheKey].resolved = cfg;
+                      resolve(cfg);
+                      return;
+                    }
+                  }
+                } catch (e) {
+                }
+              }
+              const res = this._staticMode ? yield fetch(url) : yield this.deliveryFetch(url);
+              if (!res.ok) {
+                reject(new Error(`Failed to load component "${componentId}" (${res.status}${this._staticMode ? ` from ${url}` : ""})`));
+                return;
+              }
+              const json = yield res.json();
+              const variant = json.item;
+              if (!variant) {
+                reject(new Error(`Component "${componentId}" not found`));
+                return;
+              }
+              if (!variant.consume_variant || !variant.consume_variant.length) {
+                reject(new Error(`Component "${componentId}" has no implementation for environment "${env}"`));
+                return;
+              }
+              const componentConfig = convertV2VariantToComponentConfig(variant);
+              this._deliveryStats.fromNetwork++;
+              if (cacheable) {
+                yield deliveryStore.put({
+                  key: storeKey,
+                  config: componentConfig,
+                  tag: variant.tag || null,
+                  storedAt: Date.now(),
+                  windowMs: deliveryStore.windowFrom(res.headers),
+                  host: this.deliveryHost()
+                });
+              }
+              this.variants[cacheKey].resolved = componentConfig;
+              resolve(componentConfig);
+            } catch (e) {
+              delete this.variants[cacheKey];
+              reject(e);
+            }
+          })
+        );
+      }
+      return yield this.variants[cacheKey];
     });
-    __publicField(this, "supportedHandlers", [
-      new ChangeTextHandler(this.messageToHost, this.components),
-      new SetInnerHtmlHandler(this.messageToHost, this.components),
-      new BindOnClickHandler(this.messageToHost, this.components),
-      new DetectMyopRefsMessageHandler(this.messageToHost, this.components),
-      new setAttributeHandler(this.messageToHost, this.components),
-      new AddEventListenerHandler(this.messageToHost, this.components),
-      new ExecuteScriptHandler(this.messageToHost, this.components),
-      new GetElementValueHandler(this.messageToHost, this.components),
-      //
-      new CreateRefComponentMessageHandler(this.messageToHost, this.components)
-    ]);
-    __publicField(this, "init", () => {
+  }
+  /**
+   * Synchronous version of fetchComponentV2 — returns the config only if
+   * the fetch already completed, null otherwise.
+   *
+   * Uses the same `this.variants` cache that fetchComponentV2/preloadComponents
+   * populate. Each cached Promise is tagged with a `.resolved` property when
+   * it settles — this method just reads that property. No separate cache.
+   *
+   * Why this exists: React Native needs the config at render time to embed it
+   * in the WebView HTML (can't await in useState). If preloadComponents ran
+   * earlier and the fetch completed, this returns the result synchronously,
+   * skipping the WEBVIEW_READY → fetch → inject round trip entirely.
+   */
+  getResolvedConfig(componentId, env, preview) {
+    var _a;
+    const { cacheKey } = this.resolveParams(componentId, env, preview);
+    return ((_a = this.variants[cacheKey]) == null ? void 0 : _a.resolved) || null;
+  }
+  /**
+   * Resolve which (env, preview) pair — and therefore which cache key — a call
+   * for `componentId` refers to.
+   *
+   * Single source of truth for fetchComponentV2, getResolvedConfig and
+   * hydrateComponent, so a hydrated config always lands on the key a later
+   * fetch will look under.
+   */
+  resolveParams(componentId, environmentIdentifier, preview) {
+    const preloaded = this.preloadedComponents[componentId];
+    const hasExplicitParams = environmentIdentifier !== void 0 || preview !== void 0;
+    let env;
+    let usePreview;
+    if (!hasExplicitParams && preloaded) {
+      env = preloaded.env;
+      usePreview = preloaded.preview;
+    } else {
+      env = environmentIdentifier || this._defaultEnv;
+      const hasEffectiveEnv = environmentIdentifier || this._envExplicitlySet;
+      usePreview = preview === true ? true : preview === false ? false : !hasEffectiveEnv;
+    }
+    return { env, usePreview, cacheKey: `${componentId}:${env}:${usePreview ? "preview" : "live"}` };
+  }
+  /**
+   * Seed an already-resolved component config into the cache, without any
+   * network request.
+   *
+   * The counterpart to {@link fetchComponentV2}: use it when the config was
+   * resolved somewhere else — most often on a server, then embedded in the
+   * page — so the browser can render the component with no round trip.
+   *
+   * After hydrating, `fetchComponentV2`, `getResolvedConfig` and `isPreloaded`
+   * all answer for this component from memory.
+   *
+   * Pass the same `env` / `preview` the config was resolved with; the defaults
+   * match what a plain `fetchComponentV2(componentId)` would have used.
+   */
+  hydrateComponent(componentId, config, env, preview) {
+    const { env: resolvedEnv, usePreview, cacheKey } = this.resolveParams(componentId, env, preview);
+    const promise = Promise.resolve(config);
+    promise.resolved = config;
+    this.variants[cacheKey] = promise;
+    this.preloadedComponents[componentId] = { env: resolvedEnv, preview: usePreview };
+  }
+  // ============ V1 Methods (Legacy) ============
+  /**
+   * Fetch a v1 component from a flow
+   */
+  fetchComponentV1(componentId, flowId) {
+    return __async(this, null, function* () {
+      if (flowId) {
+        const flow = yield this.fetchFlow(flowId);
+        return flow.components.find((c) => c.type.id === componentId);
+      } else {
+        const flow = yield this.fetchAutoFlow(componentId);
+        return flow.components[0];
+      }
+    });
+  }
+  fetchAutoFlow(componentId) {
+    return __async(this, null, function* () {
+      if (!this.userFlows[componentId]) {
+        this.userFlows[componentId] = new Promise(
+          (resolve, reject) => __async(this, null, function* () {
+            try {
+              const res = yield fetch(
+                `${this._baseUrl}/flow?id=${componentId}&auto=true`
+              );
+              const json = yield res.json();
+              resolve(json.item);
+            } catch (e) {
+              delete this.userFlows[componentId];
+              reject(e);
+            }
+          })
+        );
+      }
+      return yield this.userFlows[componentId];
+    });
+  }
+  fetchFlow(flowId) {
+    return __async(this, null, function* () {
+      if (!this.userFlows[flowId]) {
+        this.userFlows[flowId] = new Promise(
+          (resolve, reject) => __async(this, null, function* () {
+            try {
+              const res = yield fetch(
+                `${this._baseUrl}/flow?id=${flowId}&resolve=components`
+              );
+              const json = yield res.json();
+              resolve(json.item);
+            } catch (e) {
+              delete this.userFlows[flowId];
+              reject(e);
+            }
+          })
+        );
+      }
+      return yield this.userFlows[flowId];
+    });
+  }
+  // ============ Backward Compatibility ============
+  /**
+   * @deprecated Use fetchComponentV2 or fetchComponentV1 explicitly
+   * Defaults to v1 behavior for backward compatibility with existing code
+   */
+  fetchComponent(componentId, flowId) {
+    return __async(this, null, function* () {
+      return this.fetchComponentV1(componentId, flowId);
     });
   }
 };
-defineDynamicImport("WebComponentSDK", WebComponentSDK);
+__publicField(_CloudRepository, "_main", null);
+/** The host every request goes to unless delivery() moved it. Never changes. */
+__publicField(_CloudRepository, "DEFAULT_HOST", "https://cloud.myop.dev");
+var CloudRepository = _CloudRepository;
 
-// src/host/loaders/HTMLComponentLoader.ts
-import { EMBEDDED_SDK_CONTENT, HAS_EMBEDDED_SDK } from "./embeddedSDK.js";
-var MYOP_WEB_COMPONENT_MARKER = "<!-- myop-web-component -->";
-var MYOP_WEB_COMPONENT_SCRIPT_ID = "myop-web-component";
-var extractedWebComponentScripts = /* @__PURE__ */ new Map();
-var seen2 = [];
-var sdk;
-var getInitiatedSdk = () => __async(void 0, null, function* () {
-  if (!sdk) {
-    sdk = new WebComponentSDK();
-    sdk.init();
-  }
-  return sdk;
+// src/helpers/cloudRepositoryHelpers.ts
+var _cloudRepository = CloudRepository.Main;
+var DELIVERY_HOST = "https://delivery.myop.dev";
+var delivery = (opts = {}) => {
+  var _a, _b;
+  const wantsLane = opts.minify !== false || opts.cache === true;
+  _cloudRepository.setDelivery({
+    minify: (_a = opts.minify) != null ? _a : false,
+    cache: (_b = opts.cache) != null ? _b : false,
+    host: opts.host !== void 0 ? opts.host : wantsLane ? DELIVERY_HOST : null
+  });
+  return deliveryStats();
+};
+var deliveryRefresh = () => __async(void 0, null, function* () {
+  yield _cloudRepository.refreshDelivery();
+  return deliveryStats();
 });
-function createHTMLElementConstructor(htmlString, ShadowRootMode) {
-  return class extends HTMLElement {
-    connectedCallback() {
-      const mode = ShadowRootMode === ShadowRootModeType.open ? "open" : "closed";
-      const shadow = this.attachShadow({ mode });
-      getInitiatedSdk().then((sdk2) => {
-        sdk2.connectedCallback(this, shadow);
-        shadow.innerHTML = htmlString;
-      });
-    }
-  };
-}
-var createCustomWebComponent = (componentName, html, ShadowRootMode) => {
-  customElements.define(componentName, createHTMLElementConstructor(html, ShadowRootMode));
-  console.log(`define('${componentName}') was called, web component ready to use`);
+var deliveryStats = () => _cloudRepository.deliveryStats();
+var deliveryOff = () => {
+  _cloudRepository.setDelivery({ minify: false, cache: false, host: null });
+  return deliveryStats();
 };
-var toWebComponentName = (str) => {
-  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/(\d+)/g, "-$1").toLowerCase();
+
+// src/webcomponent/messageHandlers/BaseWebComponentMessageHandler.ts
+var BaseWebComponentMessageHandler = class extends BaseContextMessageHandler {
+  constructor(messageToHost, context) {
+    super(messageToHost);
+    this.context = context;
+    __publicField(this, "executor", (event) => {
+      if (event.destination) {
+        const destination = event.destination;
+        if (this.context[destination].context) {
+          const _messageToHost = (message, replayTo) => {
+            this.messageToHost(__spreadProps(__spreadValues({}, message), {
+              source: event.destination ? event.destination : event.source,
+              destination: event.source ? event.source : event.destination
+            }), replayTo);
+          };
+          return this.innerExecutor(event, this.context[destination].context, _messageToHost);
+        } else {
+          debugger;
+        }
+      } else {
+        debugger;
+      }
+    });
+  }
 };
-var toCustomElementName = (name) => {
-  name = toWebComponentName(name);
-  return name.replace(/_/g, "-");
+
+// src/consts.ts
+var myopAttributes = {
+  id: "myop-id"
 };
-var HTMLComponentLoader = class extends BaseMyopLoader {
+
+// src/common/messageHandlers/helpers.ts
+var getElementsByRef = (ref, el) => {
+  return el.querySelectorAll(`[${myopAttributes.id}='${ref.refConfig.selector}']`);
+};
+
+// src/webcomponent/messageHandlers/bindOnClickHandler.ts
+var BindOnClickHandler = class extends BaseWebComponentMessageHandler {
   constructor() {
     super(...arguments);
-    __publicField(this, "type", SkinLoaders.HTMLLoader);
-    __publicField(this, "load", (componentDefinition, skin, container, options) => __async(this, null, function* () {
-      const loaderConfig = skin.loader;
-      const isWC = this.isMyopWebComponent(loaderConfig.HTML);
-      const { mode, isolate } = yield this.resolveRenderMode(componentDefinition, skin, loaderConfig, isWC, options);
-      if (mode === false) {
-        throw new Error(`[Myop] Rendering blocked by render policy for component "${componentDefinition.id}"`);
-      }
-      if (isWC) {
-        if (mode !== "webComponent") {
-          throw new Error(`[Myop] Web-component rendering denied by render policy for component "${componentDefinition.id}"`);
-        }
-        return this.loadExtractedWebComponent(componentDefinition, skin, container, loaderConfig.HTML, options);
-      }
-      let domId = `myop-comp-${uuidv4()}`;
-      let element;
-      if (loaderConfig.shadowRootMode === ShadowRootModeType.localFrame) {
-        const uniqId = uuidv4();
-        const domId2 = `myop-comp-${uniqId}`;
-        let IframeElement = document.createElement("iframe");
-        IframeElement.id = domId2;
-        if (isolate) {
-          IframeElement.setAttribute("sandbox", "allow-scripts allow-forms allow-popups");
-        }
-        IframeElement.style.cssText = `
-                display: block;
-                padding: 0;
-                margin: 0;
-                position: absolute;
-                inset: 0;
-                overflow: hidden;
-                border: none;
-                opacity: ${(options == null ? void 0 : options.hidden) ? "0" : "1"};
-                width: 100%;
-                height: 100%;
-                pointer-events: ${(options == null ? void 0 : options.hidden) ? "none" : "all"};
-            `;
-        if (!container.querySelector('[id^="myop-comp-"]'))
-          container.innerHTML = "";
-        IframeElement = this.appendChild(container, IframeElement, options);
-        const __srcParts = [];
-        const doc = isolate ? {
-          open() {
-          },
-          writeln(s) {
-            __srcParts.push(s);
-          },
-          close() {
-            IframeElement.srcdoc = __srcParts.join("\n");
-          }
-        } : (() => {
-          const d = IframeElement.contentDocument || IframeElement.contentWindow.document;
-          d.open();
-          return d;
-        })();
-        let parsedSizeMeta = null;
-        {
-          const _preParser = new DOMParser();
-          const _preDoc = _preParser.parseFromString(loaderConfig.HTML, "text/html");
-          const sizeMeta = _preDoc.querySelector('meta[name="myop:size"]');
-          if (sizeMeta) {
-            try {
-              parsedSizeMeta = JSON.parse(sizeMeta.getAttribute("content") || "{}");
-            } catch (e) {
-            }
-          }
-        }
-        let HTML2Render = loaderConfig.HTML;
-        if (options == null ? void 0 : options._inspection) {
-          const parser = new DOMParser();
-          const _doc = parser.parseFromString(loaderConfig.HTML, "text/html");
-          const myop_preview_script = _doc.getElementById("myop_preview");
-          myop_preview_script == null ? void 0 : myop_preview_script.removeAttribute("type");
-          const temp = _doc.implementation.createHTMLDocument();
-          temp.body.innerHTML = `<script>
-                        const beforeKeysWindow = new Set(Object.keys(window));
-                        window.myopState = {
-                            beforeKeysWindow,
-                        };
-                <\/script>`;
-          const node = temp.body.firstChild;
-          if (node && _doc.head) {
-            _doc.head.insertBefore(_doc.importNode(node, true), _doc.head.firstChild);
-          }
-          HTML2Render = "<!DOCTYPE html>" + _doc.documentElement.outerHTML;
-        } else if ((options == null ? void 0 : options.data) !== void 0) {
-          const parser = new DOMParser();
-          const _doc = parser.parseFromString(loaderConfig.HTML, "text/html");
-          const myop_preview_script = _doc.getElementById("myop_preview");
-          if (myop_preview_script) {
-            myop_preview_script.remove();
-            HTML2Render = "<!DOCTYPE html>" + _doc.documentElement.outerHTML;
-          }
-        }
-        if (options == null ? void 0 : options.injectCss) {
-          const parser = new DOMParser();
-          const _doc = parser.parseFromString(HTML2Render, "text/html");
-          const styleTag = _doc.createElement("style");
-          styleTag.setAttribute("data-myop-injected", "true");
-          styleTag.textContent = options.injectCss.replace(/<\s*\/\s*style/gi, "<\\/style");
-          (_doc.head || _doc.documentElement).appendChild(styleTag);
-          HTML2Render = "<!DOCTYPE html>" + _doc.documentElement.outerHTML;
-        }
-        doc.writeln(HTML2Render);
-        const sdkScript = HAS_EMBEDDED_SDK ? `<script>${EMBEDDED_SDK_CONTENT}<\/script>` : `<script src="${window.myop.__ROOT_SDK_PUBLIC_URL__}"><\/script>`;
-        const initScript = HAS_EMBEDDED_SDK ? `<script>
-                   const __myop_init = async () => {
-                        const iframeModule = await MyopSDK.getIframeModule();
-                        const IframeSDK = iframeModule.IframeSDK;
-                        const sdk = new IframeSDK();
-                        sdk.init();
-                   }
-                   __myop_init().then();
-                <\/script>` : `<script>
-                   window.__federation__.__public_path__ = window.__federation__.__public_path__;
-                   const __myop_init = async () => {
-                        const {IframeSDK} = (await window.myop.rootSDK.getIframeModule());
-                        const sdk = new IframeSDK();
-                        sdk.init();
-                   }
-                   __myop_init().then();
-                <\/script>`;
-        if (!isolate) {
-          doc.writeln(`${sdkScript}${initScript}`);
-        }
-        if (!isolate && (options == null ? void 0 : options.data) !== void 0) {
-          const ctaQueueScript = `<script>
-                    window.__myop_cta_queue = [];
-                    window.myop_cta_handler = function(action, payload) {
-                        window.__myop_cta_queue.push({action: action, payload: payload});
-                    };
-                <\/script>`;
-          const escapedData = JSON.stringify(options.data).replace(/<\/script/gi, "\\u003c/script");
-          const dataScript = `<script id="__myop_init_data_script">
-                    (function() {
-                        var data = ${escapedData};
-                        var scriptEl = document.getElementById('__myop_init_data_script');
+    __publicField(this, "messageType", MyopMessages.BindClickMessage);
+    __publicField(this, "innerExecutor", (event, shadowRootRef, messageToHost) => {
+      const items = getElementsByRef(event.ref, shadowRootRef.shadowRoot);
+      const cleanupTasks = [];
+      items.forEach((item) => {
+        const handler = () => {
+          messageToHost(new ClickReplayMessage(event.handlerUniqueId));
+        };
+        item.addEventListener("click", handler);
+        cleanupTasks.push(() => {
+          item.removeEventListener("click", handler);
+        });
+      });
+      return () => {
+        cleanupTasks.forEach((task) => task());
+      };
+    });
+  }
+};
 
-                        var callInitInterface = function(fn) {
-                            var startTime = performance.now();
-                            // Mark as pre-injected data call for extension tracking
-                            window.__myop_init_preinjected = true;
-                            try {
-                                fn(data);
-                            } finally {
-                                window.__myop_init_preinjected = false;
-                            }
-                            var duration = performance.now() - startTime;
+// src/webcomponent/messageHandlers/changeTextHandler.ts
+var ChangeTextHandler = class extends BaseWebComponentMessageHandler {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "messageType", MyopMessages.ChangeTextMessage);
+    __publicField(this, "innerExecutor", (event, shadowRootRef) => {
+      const items = getElementsByRef(event.ref, shadowRootRef.shadowRoot);
+      items.forEach((item) => {
+        item.textContent = event.content;
+      });
+    });
+  }
+};
+
+// src/webcomponent/shadowRootRef.ts
+var ShadowRootRef = class extends RootRef {
+  constructor(container, shadowRoot) {
+    super(container, shadowRoot);
+    this.container = container;
+    this.shadowRoot = shadowRoot;
+  }
+};
 
-                            // Notify extension via postMessage (init* = pre-injected)
-                            try {
-                                window.parent.postMessage({
-                                    type: 'MYOP_PREINJECTED_INIT',
-                                    payload: {
-                                        data: data,
-                                        duration: duration,
-                                        timestamp: Date.now()
-                                    }
-                                }, '*');
-                            } catch (e) {}
+// src/webcomponent/messageHandlers/DetectMyopRefsMessageHandler.ts
+var DetectMyopRefsMessageHandler = class extends BaseWebComponentMessageHandler {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "innerExecutor", (event, shadowRootRef) => {
+      const allMyopItems = shadowRootRef.shadowRoot.querySelectorAll(`[${myopAttributes.id}]`);
+      let myopRefs = [];
+      allMyopItems.forEach((item) => {
+        const myopId = item.getAttribute(myopAttributes.id);
+        if (myopId) {
+          myopRefs.push(new MyopElementRef(myopId, item.tagName, item.getBoundingClientRect(), item.offsetTop, item.offsetLeft));
+        }
+      });
+      this.messageToHost(new DetectedMyopRefsMessage(event.handlerUniqueId, myopRefs));
+    });
+    __publicField(this, "messageType", MyopMessages.DetectMyopRefsMessage);
+  }
+};
 
-                            // Cleanup: remove script tag and stored data
-                            if (scriptEl && scriptEl.parentNode) {
-                                scriptEl.parentNode.removeChild(scriptEl);
-                            }
-                            delete window.__myop_init_data;
-                        };
+// src/webcomponent/messageHandlers/setAttributeHandler.ts
+var setAttributeHandler = class extends BaseWebComponentMessageHandler {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "messageType", MyopMessages.SetAttributeMessage);
+    __publicField(this, "innerExecutor", (event, shadowRootRef) => {
+      const items = getElementsByRef(event.ref, shadowRootRef.shadowRoot);
+      items.forEach((item) => {
+        item.setAttribute(event.name, event.value);
+      });
+    });
+  }
+};
 
-                        if (typeof window.myop_init_interface === 'function') {
-                            // Function already exists - call immediately
-                            callInitInterface(window.myop_init_interface);
-                        } else {
-                            // Function not yet defined - store data and watch for definition
-                            window.__myop_init_data = data;
+// src/webcomponent/messageHandlers/addEventListenerHandler.ts
+var AddEventListenerHandler = class extends BaseWebComponentMessageHandler {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "messageType", MyopMessages.AddEventListenerMessage);
+    __publicField(this, "innerExecutor", (event, shadowRootRef, messageToHost) => {
+      const items = getElementsByRef(event.ref, shadowRootRef.shadowRoot);
+      const cleanupTasks = [];
+      items.forEach((item) => {
+        const handler = (e) => {
+          messageToHost(new EventListenerCallbackMessage(event.handlerUniqueId, makeSerializable(e, event.serializableSkeleton)));
+        };
+        item.addEventListener(event.type, handler);
+        cleanupTasks.push(() => {
+          item.removeEventListener(event.type, handler);
+        });
+      });
+      return () => {
+        cleanupTasks.forEach((task) => task());
+      };
+    });
+  }
+};
 
-                            var _original;
-                            Object.defineProperty(window, 'myop_init_interface', {
-                                configurable: true,
-                                enumerable: true,
-                                set: function(fn) {
-                                    _original = fn;
-                                    if (window.__myop_init_data !== undefined) {
-                                        var storedData = window.__myop_init_data;
-                                        delete window.__myop_init_data;
-                                        callInitInterface(fn);
-                                    }
-                                },
-                                get: function() {
-                                    return _original;
-                                }
-                            });
-                        }
-                    })();
-                <\/script>`;
-          doc.writeln(ctaQueueScript + dataScript);
-        }
-        if (isolate) {
-          const escapedData = (options == null ? void 0 : options.data) !== void 0 ? JSON.stringify(options.data).replace(/<\/script/gi, "\\u003c/script") : "undefined";
-          doc.writeln(this.buildIsolationBridge(escapedData));
-        }
-        doc.close();
-        const comp = new MyopIframeComponent(componentDefinition, skin, container, IframeElement, options);
-        if (isolate) comp.enableIsolation();
-        comp.sizeMeta = parsedSizeMeta;
-        comp.initiated().then(() => {
-          if ((options == null ? void 0 : options.autoSize) === false) {
-            return;
+// src/webcomponent/messageHandlers/CreateRefComponentMessageHandler.ts
+var CreateRefComponentMessageHandler = class extends BaseWebComponentMessageHandler {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "messageType", MyopMessages.CreateRefComponentMessage);
+    __publicField(this, "innerExecutor", (event, shadowRootRef, messageToHost) => {
+      const createRef = () => __async(this, null, function* () {
+        const allItems = shadowRootRef.shadowRoot.querySelectorAll(`[${myopAttributes.id}='${event.refConfig.selector}']`);
+        if (allItems.length === 1) {
+          const hostSDK2 = HostSDK.Instance();
+          const refComponent = hostSDK2.components.find((c) => c.id === event.options.id);
+          if (refComponent) {
+            refComponent.dispose();
+          } else {
           }
-          let shown = false;
-          comp.observeAutoSize({
-            forceAutoSize: true,
-            onSizeChange: () => {
-              if (!shown && !(options == null ? void 0 : options.hidden)) {
-                shown = true;
-                comp.show();
-              }
+          const index = hostSDK2.components.indexOf(refComponent);
+          if (index !== -1) {
+            hostSDK2.components.splice(index, 1);
+          } else {
+          }
+          const implementationComponent = yield hostSDK2.loadComponent(
+            event.nestedComponentConfig,
+            allItems.item(0),
+            event.options
+          );
+          const nestedRefConfig = [];
+          Object.keys(implementationComponent.refs).forEach((refName) => {
+            let ref = implementationComponent.refs[refName];
+            ref = ref.__nonProxied || ref;
+            if (ref.componentDefinition) {
+              nestedRefConfig.push({
+                refName,
+                componentDefinitionId: ref.componentDefinition.id
+              });
             }
           });
-        });
-        return comp;
-      }
-      if (loaderConfig.shadowRootMode === ShadowRootModeType.none) {
-        const template = document.createElement("template");
-        template.innerHTML = loaderConfig.HTML;
-        element = template.content.firstElementChild;
-        getInitiatedSdk().then((sdk2) => {
-          sdk2.connectedCallback(element, element);
-        });
-      } else {
-        const customElementName = toCustomElementName(componentDefinition.name + skin.id);
-        if (!seen2.includes(customElementName)) {
-          createCustomWebComponent(customElementName, loaderConfig.HTML, loaderConfig.shadowRootMode);
-          seen2.push(customElementName);
+          messageToHost(new RefComponentCreatedMessage(event.handlerUniqueId, nestedRefConfig));
+        } else {
+          console.error("CreateRefComponentMessageHandler - DOM element not found");
+          this.messageToHost(new RefComponentCreatedMessage(event.handlerUniqueId, [], true));
+          debugger;
+        }
+      });
+      createRef().then();
+    });
+  }
+};
+
+// src/common/messageHandlers/executeScriptHandler.ts
+var ExecuteScriptHandlerExecutor = (event, replier, rootRef) => {
+  const __scriptInputs = event.scriptInputs ? event.scriptInputs : {};
+  __scriptInputs.makeSerializable = makeSerializable;
+  __scriptInputs.send = replier;
+  __scriptInputs.rootRef = rootRef;
+  __scriptInputs.__scriptInputs = __scriptInputs;
+  const dynamicFunction = new Function(`return (${event.script})(...arguments)`);
+  const ret = dynamicFunction(__scriptInputs);
+  replier(ret);
+};
+
+// src/webcomponent/messageHandlers/executeScriptHandler.ts
+var ExecuteScriptHandler = class extends BaseWebComponentMessageHandler {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "messageType", MyopMessages.ExecuteScriptMessage);
+    __publicField(this, "innerExecutor", (event, shadowRootRef, messageToHost) => {
+      const replier = (data) => {
+        messageToHost(new ExecuteScriptReplyMessage(event.handlerUniqueId, data));
+      };
+      ExecuteScriptHandlerExecutor(event, replier, shadowRootRef);
+    });
+  }
+};
+
+// src/webcomponent/messageHandlers/GetElementValueHandler.ts
+var getInputValue = (element) => {
+  if (!element) return null;
+  if (element.tagName === "FORM") {
+    const formData = new FormData(element);
+    const dataObject = {
+      formData: {},
+      unmappedData: []
+    };
+    const elements = element.querySelectorAll("input, select, textarea");
+    let autoNameIndexer = -1;
+    elements.forEach((element2) => {
+      if (typeof element2.value === "string") {
+        const myopId = element2.getAttribute(myopAttributes.id);
+        let key = element2.getAttribute("name");
+        const nodeData = {
+          id: element2.id,
+          name: key,
+          value: getInputValue(element2),
+          required: element2.required,
+          validity: makeSerializable(element2.validity, true),
+          myopId
+        };
+        if (!key) {
+          dataObject.unmappedData.push(nodeData);
+        } else {
+          if (dataObject.formData[key]) {
+            if (dataObject.formData[key].value) {
+              dataObject.unmappedData.push(nodeData);
+            } else {
+              dataObject.unmappedData.push(dataObject.formData[key]);
+              dataObject.formData[key] = nodeData;
+            }
+          } else {
+            dataObject.formData[key] = nodeData;
+          }
         }
-        element = document.createElement(customElementName);
-      }
-      if (!container.querySelector('[id^="myop-comp-"]'))
-        container.innerHTML = "";
-      element.id = domId;
-      if (options == null ? void 0 : options.hidden) {
-        element.style.opacity = "0";
-        element.style.position = "absolute";
-        element.style.height = "0";
-        element.style.width = "0";
-        element.style.pointerEvents = "none";
-        element.style.visibility = "hidden";
       }
-      this.appendChild(container, element, options);
-      return new MyopWebComponent(componentDefinition, skin, container, element, options);
-    }));
+    });
+    return dataObject;
   }
-  /**
-   * Detect if HTML is a Myop Web Component (starts with marker comment)
-   */
-  isMyopWebComponent(html) {
-    return html.trimStart().startsWith(MYOP_WEB_COMPONENT_MARKER);
+  if (element.type === "checkbox" || element.type === "radio") {
+    return element.checked ? element.value : null;
   }
-  /**
-   * Resolve how this component should render, applying the host render policy.
-   * Precedence: options.renderPolicy (per-call) fully replaces the global
-   * hostSDK.setRenderPolicy — so an app can restrict globally and allow specifics.
-   * With no policy set, behavior is unchanged from before (marker ⇒ web component).
-   */
-  resolveRenderMode(componentDefinition, skin, loaderConfig, isWebComponent, options) {
-    return __async(this, null, function* () {
-      var _a, _b, _c, _d;
-      const requestedMode = isWebComponent ? "webComponent" : loaderConfig.isolation || (options == null ? void 0 : options.isolation) ? "isolatedIframe" : "iframe";
-      const policy = (_d = options == null ? void 0 : options.renderPolicy) != null ? _d : (_c = (_b = (_a = window == null ? void 0 : window.myop) == null ? void 0 : _a.hostSDK) == null ? void 0 : _b.getRenderPolicy) == null ? void 0 : _c.call(_b);
-      const mode = policy ? yield policy({ componentDefinition, skin, requestedMode, isWebComponent }) : requestedMode;
-      return { mode, isolate: mode === "isolatedIframe" };
-    });
+  if (element.tagName === "INPUT" || element.tagName === "TEXTAREA") {
+    return element.value;
   }
-  /**
-   * The in-frame bridge for isolated components. Runs inside the sandboxed
-   * (opaque-origin) iframe, translating the same author-facing contract to/from
-   * postMessage since the host has no same-origin access:
-   *   • data-in : parent posts {type:'myop:init'} → calls window.myop_init_interface
-   *               (plus a baked initial value for the first render)
-   *   • data-out: window.myop_cta_handler → parent.postMessage({type:'myop:cta'})
-   *   • resize  : ResizeObserver → parent.postMessage({type:'myop:size'})
-   *
-   * TODO(dev-extension): the isolated path deliberately skips the same-origin
-   * dataScript, so it never posts the `MYOP_PREINJECTED_INIT` message the Myop dev
-   * extension listens for to log the INITIAL render (`init*`). Later init updates and
-   * all CTAs are still tracked (the extension wraps `comp.props`, which our isolated
-   * connectProps branch routes through), so only the first-render payload is missing
-   * from the extension's activity log for isolated components. Closing this would be a
-   * ~1-line `parent.postMessage({type:'MYOP_PREINJECTED_INIT', payload:{data}})` inside
-   * flushInitial() below — intentionally NOT done for now to avoid adding extension-only
-   * traffic to the component runtime. Web components have the same initial-init gap
-   * (initWithData is called on the element, not via comp.props) and it predates this.
-   */
-  buildIsolationBridge(initialDataLiteral) {
-    return `<script>
-            (function () {
-                var __initial = ${initialDataLiteral};
-                var __pending;
-                // data-out (cta)
-                window.myop_cta_handler = function (action, payload) {
-                    try { parent.postMessage({ __myop: true, type: 'myop:cta', action: action, payload: payload }, '*'); } catch (e) {}
-                };
-                function callInit(data) {
-                    if (typeof window.myop_init_interface === 'function') { window.myop_init_interface(data); return true; }
-                    return false;
-                }
-                // data-in (init updates)
-                window.addEventListener('message', function (e) {
-                    var d = e.data;
-                    if (!d || d.__myop !== true) return;
-                    if (d.type === 'myop:init') { if (!callInit(d.data)) __pending = d.data; }
-                });
-                // first render: use a pending update if one arrived, else the baked initial data
-                (function flushInitial() {
-                    var data = (__pending !== undefined) ? __pending : __initial;
-                    if (data === undefined) return;
-                    if (callInit(data)) { __pending = undefined; __initial = undefined; }
-                    else requestAnimationFrame(flushInitial);
-                })();
-                // resize (report content size)
-                function contentHeight() {
-                    // Measure the BODY (content box). documentElement.scrollHeight includes
-                    // the iframe viewport \u2014 which we're driving \u2014 so it would report the
-                    // current frame height, not the content, and never shrink.
-                    var b = document.body;
-                    if (b) return Math.max(b.scrollHeight, b.offsetHeight);
-                    return document.documentElement.scrollHeight;
-                }
-                function postSize() {
-                    try {
-                        parent.postMessage({
-                            __myop: true, type: 'myop:size',
-                            height: contentHeight(),
-                            width: document.documentElement.scrollWidth
-                        }, '*');
-                    } catch (e) {}
-                }
-                // Observe the BODY (reflows with content) \u2014 not documentElement, whose box is
-                // the iframe viewport and would feed back into a resize loop. A MutationObserver
-                // catches content swaps (e.g. innerHTML re-render) that don't change body's box.
-                if (window.ResizeObserver) {
-                    try { var __ro = new ResizeObserver(postSize); if (document.body) __ro.observe(document.body); } catch (e) {}
-                }
-                if (window.MutationObserver && document.body) {
-                    try { new MutationObserver(postSize).observe(document.body, { childList: true, subtree: true, attributes: true, characterData: true }); } catch (e) {}
-                }
-                window.addEventListener('load', postSize);
-                postSize();
-            })();
-        <\/script>`;
+  if (element.tagName === "SELECT") {
+    return element.value;
   }
-  /**
-   * Extract the web component script content from HTML
-   */
-  extractWebComponentScript(html) {
-    const parser = new DOMParser();
-    const doc = parser.parseFromString(html, "text/html");
-    const script = doc.getElementById(MYOP_WEB_COMPONENT_SCRIPT_ID);
-    return (script == null ? void 0 : script.textContent) || null;
+  if (element.isContentEditable) {
+    return element.innerText || element.textContent;
   }
-  /**
-   * Execute the web component script on the host document.
-   * Returns the custom element tag name this script registered.
-   */
-  executeWebComponentScript(scriptContent, scriptId) {
-    const cachedTagName = extractedWebComponentScripts.get(scriptId);
-    if (cachedTagName) {
-      console.log(`[MyopWebComponent] Script already executed for ${scriptId}, reusing <${cachedTagName}>`);
-      return cachedTagName;
-    }
-    const script = document.createElement("script");
-    script.textContent = scriptContent;
-    script.id = `myop-extracted-${scriptId}`;
-    document.head.appendChild(script);
-    const tagName = window.__MYOP_TAG_NAME__;
-    if (tagName) {
-      extractedWebComponentScripts.set(scriptId, tagName);
-    }
-    console.log(`[MyopWebComponent] Executed web component script: ${scriptId} -> <${tagName}>`);
-    return tagName;
+  return null;
+};
+var GetElementValueHandler = class extends BaseWebComponentMessageHandler {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "messageType", MyopMessages.GetElementValueMessage);
+    __publicField(this, "innerExecutor", (event, shadowRootRef, messageToHost) => {
+      const items = getElementsByRef(event.ref, shadowRootRef.shadowRoot);
+      items.forEach((item) => {
+        messageToHost(new ElementValueReplayMessage(getInputValue(item)), event);
+      });
+    });
   }
-  /**
-   * Load a Myop Web Component (extracted and run on host document)
-   */
-  loadExtractedWebComponent(componentDefinition, skin, container, html, options) {
-    return __async(this, null, function* () {
-      const scriptContent = this.extractWebComponentScript(html);
-      if (!scriptContent) {
-        throw new Error('[MyopWebComponent] No <script id="myop-web-component"> found in HTML');
-      }
-      const scriptId = `${componentDefinition.id}-${skin.id}`;
-      const tagName = this.executeWebComponentScript(scriptContent, scriptId);
-      if (!tagName) {
-        throw new Error("[MyopWebComponent] Script did not set window.__MYOP_TAG_NAME__");
-      }
-      const domId = `myop-comp-${uuidv4()}`;
-      const element = document.createElement(tagName);
-      element.id = domId;
-      if (options == null ? void 0 : options.hidden) {
-        element.style.opacity = "0";
-        element.style.position = "absolute";
-        element.style.height = "0";
-        element.style.width = "0";
-        element.style.pointerEvents = "none";
-        element.style.visibility = "hidden";
-      }
-      if (!container.querySelector('[id^="myop-comp-"]')) {
-        container.innerHTML = "";
-      }
-      this.appendChild(container, element, options);
-      const component = new MyopExtractedWebComponent(
-        componentDefinition,
-        skin,
-        container,
-        element,
-        tagName,
-        options
-      );
-      if ((options == null ? void 0 : options.data) !== void 0) {
-        component.initWithData(options.data);
-      }
-      console.log(`[MyopWebComponent] Loaded <${tagName}> into container`);
-      return component;
+};
+
+// src/webcomponent/messageHandlers/setInnerHtmlHandler.ts
+var SetInnerHtmlHandler = class extends BaseWebComponentMessageHandler {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "messageType", MyopMessages.SetInnerHtml);
+    __publicField(this, "innerExecutor", (event, shadowRootRef) => {
+      const items = getElementsByRef(event.ref, shadowRootRef.shadowRoot);
+      items.forEach((item) => {
+        item.innerHTML = event.content;
+      });
+    });
+  }
+};
+
+// src/webcomponent/WebComponentSDK.ts
+var WebComponentSDK = class extends BaseMyopSDK {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "alwaysPassEnvelopesToHost", true);
+    //when new web component created.
+    __publicField(this, "connectedCallback", (container, shadow) => {
+      container.addEventListener(myopWebcomponentConsts.webcomponent_message_key, (e) => {
+        const eventContent = e.data ? e.data : e.detail;
+        if (!eventContent || !eventContent.myop) {
+          debugger;
+          throw new Error("recvied webcomponent_message with wrong type");
+        } else {
+          const message = eventContent;
+          this.handleIncomeMessages(e);
+          if (message.messageType === MyopMessages.InitMessage) {
+            const newComponentId = message.content.id;
+            this.components[newComponentId].context = new ShadowRootRef(container, shadow);
+          }
+        }
+      });
+      setTimeout(() => {
+        this.messageToHost(new InitRequest());
+      }, 1);
+    });
+    __publicField(this, "messageToHost", (message, replayTo) => {
+      message.direction = MessageDirection.up;
+      if (!message.replayToHandler && (replayTo == null ? void 0 : replayTo.handlerUniqueId))
+        message.replayToHandler = replayTo.handlerUniqueId;
+      window.myop.hostSDK.send(message);
+    });
+    __publicField(this, "supportedHandlers", [
+      new ChangeTextHandler(this.messageToHost, this.components),
+      new SetInnerHtmlHandler(this.messageToHost, this.components),
+      new BindOnClickHandler(this.messageToHost, this.components),
+      new DetectMyopRefsMessageHandler(this.messageToHost, this.components),
+      new setAttributeHandler(this.messageToHost, this.components),
+      new AddEventListenerHandler(this.messageToHost, this.components),
+      new ExecuteScriptHandler(this.messageToHost, this.components),
+      new GetElementValueHandler(this.messageToHost, this.components),
+      //
+      new CreateRefComponentMessageHandler(this.messageToHost, this.components)
+    ]);
+    __publicField(this, "init", () => {
     });
   }
 };
-
-// src/helpers/CloudRepository.ts
-var convertV2VariantToComponentConfig = (config) => {
-  return {
-    instance: {
-      id: "auto",
-      componentId: config.componentId,
-      componentName: config.name,
-      skinSelector: {
-        type: "Dedicated",
-        skin: {
-          id: "skin_auto_v2_converted"
+defineDynamicImport("WebComponentSDK", WebComponentSDK);
+
+// src/host/loaders/HTMLComponentLoader.ts
+import { EMBEDDED_SDK_CONTENT, HAS_EMBEDDED_SDK } from "./embeddedSDK.js";
+var MYOP_WEB_COMPONENT_MARKER = "<!-- myop-web-component -->";
+var MYOP_WEB_COMPONENT_SCRIPT_ID = "myop-web-component";
+var extractedWebComponentScripts = /* @__PURE__ */ new Map();
+var seen2 = [];
+var sdk;
+var getInitiatedSdk = () => __async(void 0, null, function* () {
+  if (!sdk) {
+    sdk = new WebComponentSDK();
+    sdk.init();
+  }
+  return sdk;
+});
+function createHTMLElementConstructor(htmlString, ShadowRootMode) {
+  return class extends HTMLElement {
+    connectedCallback() {
+      const mode = ShadowRootMode === ShadowRootModeType.open ? "open" : "closed";
+      const shadow = this.attachShadow({ mode });
+      getInitiatedSdk().then((sdk2) => {
+        sdk2.connectedCallback(this, shadow);
+        shadow.innerHTML = htmlString;
+      });
+    }
+  };
+}
+var createCustomWebComponent = (componentName, html, ShadowRootMode) => {
+  customElements.define(componentName, createHTMLElementConstructor(html, ShadowRootMode));
+  console.log(`define('${componentName}') was called, web component ready to use`);
+};
+var toWebComponentName = (str) => {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/(\d+)/g, "-$1").toLowerCase();
+};
+var toCustomElementName = (name) => {
+  name = toWebComponentName(name);
+  return name.replace(/_/g, "-");
+};
+var HTMLComponentLoader = class extends BaseMyopLoader {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "type", SkinLoaders.HTMLLoader);
+    __publicField(this, "load", (componentDefinition, skin, container, options) => __async(this, null, function* () {
+      const loaderConfig = skin.loader;
+      const isWC = this.isMyopWebComponent(loaderConfig.HTML);
+      const { mode, isolate } = yield this.resolveRenderMode(componentDefinition, skin, loaderConfig, isWC, options);
+      if (mode === false) {
+        throw new Error(`[Myop] Rendering blocked by render policy for component "${componentDefinition.id}"`);
+      }
+      if (isWC) {
+        if (mode !== "webComponent") {
+          throw new Error(`[Myop] Web-component rendering denied by render policy for component "${componentDefinition.id}"`);
         }
+        return this.loadExtractedWebComponent(componentDefinition, skin, container, loaderConfig.HTML, options);
       }
-    },
-    type: {
-      id: config.id,
-      name: config.name,
-      description: config.description,
-      props: [
-        {
-          id: "in_auto_v2_converted",
-          name: "myop_init_interface",
-          type: "any",
-          behavior: {
-            type: PropConfigBehaviorTypes.code
+      let domId = `myop-comp-${uuidv4()}`;
+      let element;
+      if (loaderConfig.shadowRootMode === ShadowRootModeType.localFrame) {
+        const uniqId = uuidv4();
+        const domId2 = `myop-comp-${uniqId}`;
+        let IframeElement = document.createElement("iframe");
+        IframeElement.id = domId2;
+        if (isolate) {
+          IframeElement.setAttribute("sandbox", "allow-scripts allow-forms allow-popups");
+        }
+        IframeElement.style.cssText = `
+                display: block;
+                padding: 0;
+                margin: 0;
+                position: absolute;
+                inset: 0;
+                overflow: hidden;
+                border: none;
+                opacity: ${(options == null ? void 0 : options.hidden) ? "0" : "1"};
+                width: 100%;
+                height: 100%;
+                pointer-events: ${(options == null ? void 0 : options.hidden) ? "none" : "all"};
+            `;
+        if (!container.querySelector('[id^="myop-comp-"]'))
+          container.innerHTML = "";
+        IframeElement = this.appendChild(container, IframeElement, options);
+        const __srcParts = [];
+        const doc = isolate ? {
+          open() {
+          },
+          writeln(s) {
+            __srcParts.push(s);
+          },
+          close() {
+            IframeElement.srcdoc = __srcParts.join("\n");
           }
-        },
+        } : (() => {
+          const d = IframeElement.contentDocument || IframeElement.contentWindow.document;
+          d.open();
+          return d;
+        })();
+        let parsedSizeMeta = null;
         {
-          id: "out_auto_v2_converted",
-          name: "myop_cta_handler",
-          type: "any",
-          behavior: {
-            type: PropConfigBehaviorTypes.code
+          const _preParser = new DOMParser();
+          const _preDoc = _preParser.parseFromString(loaderConfig.HTML, "text/html");
+          const sizeMeta = _preDoc.querySelector('meta[name="myop:size"]');
+          if (sizeMeta) {
+            try {
+              parsedSizeMeta = JSON.parse(sizeMeta.getAttribute("content") || "{}");
+            } catch (e) {
+            }
+          }
+        }
+        let HTML2Render = loaderConfig.HTML;
+        if (options == null ? void 0 : options._inspection) {
+          const parser = new DOMParser();
+          const _doc = parser.parseFromString(loaderConfig.HTML, "text/html");
+          const myop_preview_script = _doc.getElementById("myop_preview");
+          myop_preview_script == null ? void 0 : myop_preview_script.removeAttribute("type");
+          const temp = _doc.implementation.createHTMLDocument();
+          temp.body.innerHTML = `<script>
+                        const beforeKeysWindow = new Set(Object.keys(window));
+                        window.myopState = {
+                            beforeKeysWindow,
+                        };
+                <\/script>`;
+          const node = temp.body.firstChild;
+          if (node && _doc.head) {
+            _doc.head.insertBefore(_doc.importNode(node, true), _doc.head.firstChild);
+          }
+          HTML2Render = "<!DOCTYPE html>" + _doc.documentElement.outerHTML;
+        } else if ((options == null ? void 0 : options.data) !== void 0) {
+          const parser = new DOMParser();
+          const _doc = parser.parseFromString(loaderConfig.HTML, "text/html");
+          const myop_preview_script = _doc.getElementById("myop_preview");
+          if (myop_preview_script) {
+            myop_preview_script.remove();
+            HTML2Render = "<!DOCTYPE html>" + _doc.documentElement.outerHTML;
           }
         }
-      ],
-      refs: [],
-      skins: [
-        {
-          id: "skin_auto_v2_converted",
-          name: "auto_v2_converted",
-          description: "",
-          //TODO : handle empty :
-          // @ts-ignore
-          loader: config.consume_variant[0].loader
+        if (options == null ? void 0 : options.injectCss) {
+          const parser = new DOMParser();
+          const _doc = parser.parseFromString(HTML2Render, "text/html");
+          const styleTag = _doc.createElement("style");
+          styleTag.setAttribute("data-myop-injected", "true");
+          styleTag.textContent = options.injectCss.replace(/<\s*\/\s*style/gi, "<\\/style");
+          (_doc.head || _doc.documentElement).appendChild(styleTag);
+          HTML2Render = "<!DOCTYPE html>" + _doc.documentElement.outerHTML;
+        }
+        doc.writeln(HTML2Render);
+        const sdkScript = HAS_EMBEDDED_SDK ? `<script>${EMBEDDED_SDK_CONTENT}<\/script>` : `<script src="${window.myop.__ROOT_SDK_PUBLIC_URL__}"><\/script>`;
+        const initScript = HAS_EMBEDDED_SDK ? `<script>
+                   const __myop_init = async () => {
+                        const iframeModule = await MyopSDK.getIframeModule();
+                        const IframeSDK = iframeModule.IframeSDK;
+                        const sdk = new IframeSDK();
+                        sdk.init();
+                   }
+                   __myop_init().then();
+                <\/script>` : `<script>
+                   window.__federation__.__public_path__ = window.__federation__.__public_path__;
+                   const __myop_init = async () => {
+                        const {IframeSDK} = (await window.myop.rootSDK.getIframeModule());
+                        const sdk = new IframeSDK();
+                        sdk.init();
+                   }
+                   __myop_init().then();
+                <\/script>`;
+        if (!isolate) {
+          doc.writeln(`${sdkScript}${initScript}`);
+        }
+        if (!isolate && (options == null ? void 0 : options.data) !== void 0) {
+          const ctaQueueScript = `<script>
+                    window.__myop_cta_queue = [];
+                    window.myop_cta_handler = function(action, payload) {
+                        window.__myop_cta_queue.push({action: action, payload: payload});
+                    };
+                <\/script>`;
+          const escapedData = JSON.stringify(options.data).replace(/<\/script/gi, "\\u003c/script");
+          const dataScript = `<script id="__myop_init_data_script">
+                    (function() {
+                        var data = ${escapedData};
+                        var scriptEl = document.getElementById('__myop_init_data_script');
+
+                        var callInitInterface = function(fn) {
+                            var startTime = performance.now();
+                            // Mark as pre-injected data call for extension tracking
+                            window.__myop_init_preinjected = true;
+                            try {
+                                fn(data);
+                            } finally {
+                                window.__myop_init_preinjected = false;
+                            }
+                            var duration = performance.now() - startTime;
+
+                            // Notify extension via postMessage (init* = pre-injected)
+                            try {
+                                window.parent.postMessage({
+                                    type: 'MYOP_PREINJECTED_INIT',
+                                    payload: {
+                                        data: data,
+                                        duration: duration,
+                                        timestamp: Date.now()
+                                    }
+                                }, '*');
+                            } catch (e) {}
+
+                            // Cleanup: remove script tag and stored data
+                            if (scriptEl && scriptEl.parentNode) {
+                                scriptEl.parentNode.removeChild(scriptEl);
+                            }
+                            delete window.__myop_init_data;
+                        };
+
+                        if (typeof window.myop_init_interface === 'function') {
+                            // Function already exists - call immediately
+                            callInitInterface(window.myop_init_interface);
+                        } else {
+                            // Function not yet defined - store data and watch for definition
+                            window.__myop_init_data = data;
+
+                            var _original;
+                            Object.defineProperty(window, 'myop_init_interface', {
+                                configurable: true,
+                                enumerable: true,
+                                set: function(fn) {
+                                    _original = fn;
+                                    if (window.__myop_init_data !== undefined) {
+                                        var storedData = window.__myop_init_data;
+                                        delete window.__myop_init_data;
+                                        callInitInterface(fn);
+                                    }
+                                },
+                                get: function() {
+                                    return _original;
+                                }
+                            });
+                        }
+                    })();
+                <\/script>`;
+          doc.writeln(ctaQueueScript + dataScript);
+        }
+        if (isolate) {
+          const escapedData = (options == null ? void 0 : options.data) !== void 0 ? JSON.stringify(options.data).replace(/<\/script/gi, "\\u003c/script") : "undefined";
+          doc.writeln(this.buildIsolationBridge(escapedData));
         }
-      ],
-      defaultSkin: 0
-    },
-    name: config.name
-  };
-};
-var GLOBAL_KEY = "__MYOP_CLOUD_REPOSITORY_MAIN__";
-var getGlobalMain = () => {
-  if (typeof window !== "undefined") {
-    return window[GLOBAL_KEY];
-  }
-  if (typeof globalThis !== "undefined") {
-    return globalThis[GLOBAL_KEY];
-  }
-  return void 0;
-};
-var setGlobalMain = (instance) => {
-  if (typeof window !== "undefined") {
-    window[GLOBAL_KEY] = instance;
-  }
-  if (typeof globalThis !== "undefined") {
-    globalThis[GLOBAL_KEY] = instance;
-  }
-};
-var _CloudRepository = class _CloudRepository {
-  constructor(_baseUrl = "https://cloud.myop.dev") {
-    this._baseUrl = _baseUrl;
-    // v2 cache - keyed by componentId:env:preview|live
-    // Each Promise is tagged with a `resolved` property after settling (see fetchComponentV2).
-    __publicField(this, "variants", {});
-    // Track which components were preloaded and with what params
-    // Key: componentId, Value: { env, preview }
-    __publicField(this, "preloadedComponents", {});
-    // v1 cache
-    __publicField(this, "userFlows", {});
-    __publicField(this, "_defaultEnv", "production");
-    __publicField(this, "_envExplicitlySet", false);
-    __publicField(this, "_staticMode", false);
-    __publicField(this, "_queryParams", {});
-  }
-  static get Main() {
-    const globalMain = getGlobalMain();
-    if (globalMain) {
-      return globalMain;
-    }
-    if (!_CloudRepository._main) {
-      _CloudRepository._main = new _CloudRepository();
-      setGlobalMain(_CloudRepository._main);
-    }
-    return _CloudRepository._main;
-  }
-  /**
-   * Enable static mode for self-hosted component registries.
-   * In static mode, URLs are constructed as file paths instead of query params:
-   *   ${baseUrl}/components/${componentId}/${env}.json
-   */
-  enableStaticMode() {
-    this._staticMode = true;
-  }
-  /**
-   * Set query parameters to append to all fetch URLs (e.g. for CDN cache busting).
-   * Example: `setQueryParams({ lastupdate: '11112026' })`
-   */
-  setQueryParams(params) {
-    this._queryParams = params;
-  }
-  /**
-   * Set the default environment for this CloudRepository instance
-   */
-  setEnvironment(env) {
-    this._defaultEnv = env;
-    this._envExplicitlySet = true;
-  }
-  /**
-   * Get the current default environment
-   */
-  getDefaultEnvironment() {
-    return this._defaultEnv;
-  }
-  // ============ V2 Methods (Default) ============
-  /**
-   * Check if a component is already cached/preloaded (v2)
-   * If env and preview are not provided, checks if ANY version is preloaded
-   */
-  isPreloaded(componentId, env, preview) {
-    if (env !== void 0 || preview !== void 0) {
-      const cacheKey = `${componentId}:${env || this._defaultEnv}:${preview ? "preview" : "live"}`;
-      return cacheKey in this.variants;
-    }
-    return componentId in this.preloadedComponents;
-  }
-  /**
-   * Get the preloaded params for a component (if preloaded)
-   * Returns undefined if not preloaded
-   */
-  getPreloadedParams(componentId) {
-    return this.preloadedComponents[componentId];
+        doc.close();
+        const comp = new MyopIframeComponent(componentDefinition, skin, container, IframeElement, options);
+        if (isolate) comp.enableIsolation();
+        comp.sizeMeta = parsedSizeMeta;
+        comp.initiated().then(() => {
+          if ((options == null ? void 0 : options.autoSize) === false) {
+            return;
+          }
+          let shown = false;
+          comp.observeAutoSize({
+            forceAutoSize: true,
+            onSizeChange: () => {
+              if (!shown && !(options == null ? void 0 : options.hidden)) {
+                shown = true;
+                comp.show();
+              }
+            }
+          });
+        });
+        return comp;
+      }
+      if (loaderConfig.shadowRootMode === ShadowRootModeType.none) {
+        const template = document.createElement("template");
+        template.innerHTML = loaderConfig.HTML;
+        element = template.content.firstElementChild;
+        getInitiatedSdk().then((sdk2) => {
+          sdk2.connectedCallback(element, element);
+        });
+      } else {
+        const customElementName = toCustomElementName(componentDefinition.name + skin.id);
+        if (!seen2.includes(customElementName)) {
+          createCustomWebComponent(customElementName, loaderConfig.HTML, loaderConfig.shadowRootMode);
+          seen2.push(customElementName);
+        }
+        element = document.createElement(customElementName);
+      }
+      if (!container.querySelector('[id^="myop-comp-"]'))
+        container.innerHTML = "";
+      element.id = domId;
+      if (options == null ? void 0 : options.hidden) {
+        element.style.opacity = "0";
+        element.style.position = "absolute";
+        element.style.height = "0";
+        element.style.width = "0";
+        element.style.pointerEvents = "none";
+        element.style.visibility = "hidden";
+      }
+      this.appendChild(container, element, options);
+      return new MyopWebComponent(componentDefinition, skin, container, element, options);
+    }));
   }
   /**
-   * Resolve a component config: fetch it once, then serve it from this
-   * repository's cache.
-   *
-   * This is the name to use. `fetchComponentV2` is the same method under its
-   * versioned name and stays for backward compatibility — note that the
-   * unversioned `fetchComponent` is a *deprecated v1* API and is NOT this.
-   *
-   * Completes the trio with {@link getResolvedConfig} (synchronous read of an
-   * already-resolved config) and {@link hydrateComponent} (seed one you
-   * already hold).
-   *
-   * Prefer the module-level `preloadComponents([id])` in app code; reach for
-   * this when you need an isolated repository instance whose cache lifetime
-   * you control — a server with its own TTL, for example.
+   * Detect if HTML is a Myop Web Component (starts with marker comment)
    */
-  resolveComponent(componentId, env, preview) {
-    return __async(this, null, function* () {
-      return this.fetchComponentV2(componentId, env, preview);
-    });
+  isMyopWebComponent(html) {
+    return html.trimStart().startsWith(MYOP_WEB_COMPONENT_MARKER);
   }
   /**
-   * Fetch a v2 component config
-   * If env/preview not specified and component was preloaded, uses preloaded params
-   *
-   * @see resolveComponent — the unversioned name for this method
+   * Resolve how this component should render, applying the host render policy.
+   * Precedence: options.renderPolicy (per-call) fully replaces the global
+   * hostSDK.setRenderPolicy — so an app can restrict globally and allow specifics.
+   * With no policy set, behavior is unchanged from before (marker ⇒ web component).
    */
-  fetchComponentV2(componentId, environmentIdentifier, preview) {
+  resolveRenderMode(componentDefinition, skin, loaderConfig, isWebComponent, options) {
     return __async(this, null, function* () {
-      const { env, usePreview, cacheKey } = this.resolveParams(componentId, environmentIdentifier, preview);
-      console.log("[CloudRepository] fetchComponentV2", {
-        componentId: componentId.slice(0, 8) + "...",
-        env,
-        usePreview,
-        cacheKey,
-        cached: cacheKey in this.variants
-      });
-      if (!this.variants[cacheKey]) {
-        if (!this.preloadedComponents[componentId]) {
-          this.preloadedComponents[componentId] = { env, preview: usePreview };
-        }
-        this.variants[cacheKey] = new Promise(
-          (resolve, reject) => __async(this, null, function* () {
-            try {
-              let url;
-              if (this._staticMode) {
-                const file = usePreview ? "preview" : env;
-                url = `${this._baseUrl}/components/${componentId}/${file}.json`;
-                const qs = new URLSearchParams(this._queryParams).toString();
-                if (qs) url += `?${qs}`;
-              } else {
-                url = `${this._baseUrl}/consume?id=${componentId}&env=${env}`;
-                if (usePreview) {
-                  url += "&preview=true";
-                }
-              }
-              const res = yield fetch(url);
-              if (!res.ok) {
-                reject(new Error(`Failed to load component "${componentId}" (${res.status}${this._staticMode ? ` from ${url}` : ""})`));
-                return;
-              }
-              const json = yield res.json();
-              const variant = json.item;
-              if (!variant) {
-                reject(new Error(`Component "${componentId}" not found`));
-                return;
-              }
-              if (!variant.consume_variant || !variant.consume_variant.length) {
-                reject(new Error(`Component "${componentId}" has no implementation for environment "${env}"`));
-                return;
-              }
-              const componentConfig = convertV2VariantToComponentConfig(variant);
-              this.variants[cacheKey].resolved = componentConfig;
-              resolve(componentConfig);
-            } catch (e) {
-              delete this.variants[cacheKey];
-              reject(e);
-            }
-          })
-        );
-      }
-      return yield this.variants[cacheKey];
+      var _a, _b, _c, _d;
+      const requestedMode = isWebComponent ? "webComponent" : loaderConfig.isolation || (options == null ? void 0 : options.isolation) ? "isolatedIframe" : "iframe";
+      const policy = (_d = options == null ? void 0 : options.renderPolicy) != null ? _d : (_c = (_b = (_a = window == null ? void 0 : window.myop) == null ? void 0 : _a.hostSDK) == null ? void 0 : _b.getRenderPolicy) == null ? void 0 : _c.call(_b);
+      const mode = policy ? yield policy({ componentDefinition, skin, requestedMode, isWebComponent }) : requestedMode;
+      return { mode, isolate: mode === "isolatedIframe" };
     });
   }
   /**
-   * Synchronous version of fetchComponentV2 — returns the config only if
-   * the fetch already completed, null otherwise.
-   *
-   * Uses the same `this.variants` cache that fetchComponentV2/preloadComponents
-   * populate. Each cached Promise is tagged with a `.resolved` property when
-   * it settles — this method just reads that property. No separate cache.
+   * The in-frame bridge for isolated components. Runs inside the sandboxed
+   * (opaque-origin) iframe, translating the same author-facing contract to/from
+   * postMessage since the host has no same-origin access:
+   *   • data-in : parent posts {type:'myop:init'} → calls window.myop_init_interface
+   *               (plus a baked initial value for the first render)
+   *   • data-out: window.myop_cta_handler → parent.postMessage({type:'myop:cta'})
+   *   • resize  : ResizeObserver → parent.postMessage({type:'myop:size'})
    *
-   * Why this exists: React Native needs the config at render time to embed it
-   * in the WebView HTML (can't await in useState). If preloadComponents ran
-   * earlier and the fetch completed, this returns the result synchronously,
-   * skipping the WEBVIEW_READY → fetch → inject round trip entirely.
+   * TODO(dev-extension): the isolated path deliberately skips the same-origin
+   * dataScript, so it never posts the `MYOP_PREINJECTED_INIT` message the Myop dev
+   * extension listens for to log the INITIAL render (`init*`). Later init updates and
+   * all CTAs are still tracked (the extension wraps `comp.props`, which our isolated
+   * connectProps branch routes through), so only the first-render payload is missing
+   * from the extension's activity log for isolated components. Closing this would be a
+   * ~1-line `parent.postMessage({type:'MYOP_PREINJECTED_INIT', payload:{data}})` inside
+   * flushInitial() below — intentionally NOT done for now to avoid adding extension-only
+   * traffic to the component runtime. Web components have the same initial-init gap
+   * (initWithData is called on the element, not via comp.props) and it predates this.
    */
-  getResolvedConfig(componentId, env, preview) {
-    var _a;
-    const { cacheKey } = this.resolveParams(componentId, env, preview);
-    return ((_a = this.variants[cacheKey]) == null ? void 0 : _a.resolved) || null;
+  buildIsolationBridge(initialDataLiteral) {
+    return `<script>
+            (function () {
+                var __initial = ${initialDataLiteral};
+                var __pending;
+                // data-out (cta)
+                window.myop_cta_handler = function (action, payload) {
+                    try { parent.postMessage({ __myop: true, type: 'myop:cta', action: action, payload: payload }, '*'); } catch (e) {}
+                };
+                function callInit(data) {
+                    if (typeof window.myop_init_interface === 'function') { window.myop_init_interface(data); return true; }
+                    return false;
+                }
+                // data-in (init updates)
+                window.addEventListener('message', function (e) {
+                    var d = e.data;
+                    if (!d || d.__myop !== true) return;
+                    if (d.type === 'myop:init') { if (!callInit(d.data)) __pending = d.data; }
+                });
+                // first render: use a pending update if one arrived, else the baked initial data
+                (function flushInitial() {
+                    var data = (__pending !== undefined) ? __pending : __initial;
+                    if (data === undefined) return;
+                    if (callInit(data)) { __pending = undefined; __initial = undefined; }
+                    else requestAnimationFrame(flushInitial);
+                })();
+                // resize (report content size)
+                function contentHeight() {
+                    // Measure the BODY (content box). documentElement.scrollHeight includes
+                    // the iframe viewport \u2014 which we're driving \u2014 so it would report the
+                    // current frame height, not the content, and never shrink.
+                    var b = document.body;
+                    if (b) return Math.max(b.scrollHeight, b.offsetHeight);
+                    return document.documentElement.scrollHeight;
+                }
+                function postSize() {
+                    try {
+                        parent.postMessage({
+                            __myop: true, type: 'myop:size',
+                            height: contentHeight(),
+                            width: document.documentElement.scrollWidth
+                        }, '*');
+                    } catch (e) {}
+                }
+                // Observe the BODY (reflows with content) \u2014 not documentElement, whose box is
+                // the iframe viewport and would feed back into a resize loop. A MutationObserver
+                // catches content swaps (e.g. innerHTML re-render) that don't change body's box.
+                if (window.ResizeObserver) {
+                    try { var __ro = new ResizeObserver(postSize); if (document.body) __ro.observe(document.body); } catch (e) {}
+                }
+                if (window.MutationObserver && document.body) {
+                    try { new MutationObserver(postSize).observe(document.body, { childList: true, subtree: true, attributes: true, characterData: true }); } catch (e) {}
+                }
+                window.addEventListener('load', postSize);
+                postSize();
+            })();
+        <\/script>`;
   }
   /**
-   * Resolve which (env, preview) pair — and therefore which cache key — a call
-   * for `componentId` refers to.
-   *
-   * Single source of truth for fetchComponentV2, getResolvedConfig and
-   * hydrateComponent, so a hydrated config always lands on the key a later
-   * fetch will look under.
+   * Extract the web component script content from HTML
    */
-  resolveParams(componentId, environmentIdentifier, preview) {
-    const preloaded = this.preloadedComponents[componentId];
-    const hasExplicitParams = environmentIdentifier !== void 0 || preview !== void 0;
-    let env;
-    let usePreview;
-    if (!hasExplicitParams && preloaded) {
-      env = preloaded.env;
-      usePreview = preloaded.preview;
-    } else {
-      env = environmentIdentifier || this._defaultEnv;
-      const hasEffectiveEnv = environmentIdentifier || this._envExplicitlySet;
-      usePreview = preview === true ? true : preview === false ? false : !hasEffectiveEnv;
-    }
-    return { env, usePreview, cacheKey: `${componentId}:${env}:${usePreview ? "preview" : "live"}` };
+  extractWebComponentScript(html) {
+    const parser = new DOMParser();
+    const doc = parser.parseFromString(html, "text/html");
+    const script = doc.getElementById(MYOP_WEB_COMPONENT_SCRIPT_ID);
+    return (script == null ? void 0 : script.textContent) || null;
   }
   /**
-   * Seed an already-resolved component config into the cache, without any
-   * network request.
-   *
-   * The counterpart to {@link fetchComponentV2}: use it when the config was
-   * resolved somewhere else — most often on a server, then embedded in the
-   * page — so the browser can render the component with no round trip.
-   *
-   * After hydrating, `fetchComponentV2`, `getResolvedConfig` and `isPreloaded`
-   * all answer for this component from memory.
-   *
-   * Pass the same `env` / `preview` the config was resolved with; the defaults
-   * match what a plain `fetchComponentV2(componentId)` would have used.
+   * Execute the web component script on the host document.
+   * Returns the custom element tag name this script registered.
    */
-  hydrateComponent(componentId, config, env, preview) {
-    const { env: resolvedEnv, usePreview, cacheKey } = this.resolveParams(componentId, env, preview);
-    const promise = Promise.resolve(config);
-    promise.resolved = config;
-    this.variants[cacheKey] = promise;
-    this.preloadedComponents[componentId] = { env: resolvedEnv, preview: usePreview };
+  executeWebComponentScript(scriptContent, scriptId) {
+    const cachedTagName = extractedWebComponentScripts.get(scriptId);
+    if (cachedTagName) {
+      console.log(`[MyopWebComponent] Script already executed for ${scriptId}, reusing <${cachedTagName}>`);
+      return cachedTagName;
+    }
+    const script = document.createElement("script");
+    script.textContent = scriptContent;
+    script.id = `myop-extracted-${scriptId}`;
+    document.head.appendChild(script);
+    const tagName = window.__MYOP_TAG_NAME__;
+    if (tagName) {
+      extractedWebComponentScripts.set(scriptId, tagName);
+    }
+    console.log(`[MyopWebComponent] Executed web component script: ${scriptId} -> <${tagName}>`);
+    return tagName;
   }
-  // ============ V1 Methods (Legacy) ============
   /**
-   * Fetch a v1 component from a flow
+   * Load a Myop Web Component (extracted and run on host document)
    */
-  fetchComponentV1(componentId, flowId) {
+  loadExtractedWebComponent(componentDefinition, skin, container, html, options) {
     return __async(this, null, function* () {
-      if (flowId) {
-        const flow = yield this.fetchFlow(flowId);
-        return flow.components.find((c) => c.type.id === componentId);
-      } else {
-        const flow = yield this.fetchAutoFlow(componentId);
-        return flow.components[0];
+      const scriptContent = this.extractWebComponentScript(html);
+      if (!scriptContent) {
+        throw new Error('[MyopWebComponent] No <script id="myop-web-component"> found in HTML');
       }
-    });
-  }
-  fetchAutoFlow(componentId) {
-    return __async(this, null, function* () {
-      if (!this.userFlows[componentId]) {
-        this.userFlows[componentId] = new Promise(
-          (resolve, reject) => __async(this, null, function* () {
-            try {
-              const res = yield fetch(
-                `${this._baseUrl}/flow?id=${componentId}&auto=true`
-              );
-              const json = yield res.json();
-              resolve(json.item);
-            } catch (e) {
-              delete this.userFlows[componentId];
-              reject(e);
-            }
-          })
-        );
+      const scriptId = `${componentDefinition.id}-${skin.id}`;
+      const tagName = this.executeWebComponentScript(scriptContent, scriptId);
+      if (!tagName) {
+        throw new Error("[MyopWebComponent] Script did not set window.__MYOP_TAG_NAME__");
       }
-      return yield this.userFlows[componentId];
-    });
-  }
-  fetchFlow(flowId) {
-    return __async(this, null, function* () {
-      if (!this.userFlows[flowId]) {
-        this.userFlows[flowId] = new Promise(
-          (resolve, reject) => __async(this, null, function* () {
-            try {
-              const res = yield fetch(
-                `${this._baseUrl}/flow?id=${flowId}&resolve=components`
-              );
-              const json = yield res.json();
-              resolve(json.item);
-            } catch (e) {
-              delete this.userFlows[flowId];
-              reject(e);
-            }
-          })
-        );
+      const domId = `myop-comp-${uuidv4()}`;
+      const element = document.createElement(tagName);
+      element.id = domId;
+      if (options == null ? void 0 : options.hidden) {
+        element.style.opacity = "0";
+        element.style.position = "absolute";
+        element.style.height = "0";
+        element.style.width = "0";
+        element.style.pointerEvents = "none";
+        element.style.visibility = "hidden";
       }
-      return yield this.userFlows[flowId];
-    });
-  }
-  // ============ Backward Compatibility ============
-  /**
-   * @deprecated Use fetchComponentV2 or fetchComponentV1 explicitly
-   * Defaults to v1 behavior for backward compatibility with existing code
-   */
-  fetchComponent(componentId, flowId) {
-    return __async(this, null, function* () {
-      return this.fetchComponentV1(componentId, flowId);
+      if (!container.querySelector('[id^="myop-comp-"]')) {
+        container.innerHTML = "";
+      }
+      this.appendChild(container, element, options);
+      const component = new MyopExtractedWebComponent(
+        componentDefinition,
+        skin,
+        container,
+        element,
+        tagName,
+        options
+      );
+      if ((options == null ? void 0 : options.data) !== void 0) {
+        component.initWithData(options.data);
+      }
+      console.log(`[MyopWebComponent] Loaded <${tagName}> into container`);
+      return component;
     });
   }
 };
-__publicField(_CloudRepository, "_main", null);
-var CloudRepository = _CloudRepository;
-
-// src/helpers/cloudRepositoryHelpers.ts
-var _cloudRepository = CloudRepository.Main;
 
 // src/host/myopOverride.ts
 var checkMyopOverride = (componentConfig) => __async(void 0, null, function* () {
@@ -3371,8 +3763,22 @@ var HostSDK = class {
         }
       });
     });
+    // A component's origin is whatever its iframe URL is, so an origin allowlist can't work here.
+    // Instead only frames this SDK created (or adopted) may talk to it. `send()` dispatches
+    // synthetic events, which have no source.
+    __publicField(this, "isTrustedSource", (source) => {
+      if (!source || source === window) return true;
+      const isOwnFrame = (component) => {
+        const element = component.element;
+        return (element == null ? void 0 : element.nodeName) === "IFRAME" && element.contentWindow === source;
+      };
+      return this.components.some(isOwnFrame) || this.components2init.some(isOwnFrame);
+    });
     __publicField(this, "incomingMessageHandler", (event) => {
-      if (event.origin === document.location.origin) {
+      var _a;
+      if (!((_a = event.data) == null ? void 0 : _a.myop)) return;
+      if (!this.isTrustedSource(event.source)) {
+        return;
       }
       if (event.data.myop) {
         if (event.data.direction !== MessageDirection.up && event.data.messageType !== MyopMessages.EnvelopedMessage) {
@@ -3388,8 +3794,8 @@ var HostSDK = class {
         if (myopMessage.messageType === MyopMessages.InitResponse) {
           this.components2init = this.components2init.filter((component2) => component2.id !== myopMessage.content.id);
           const initiatedComponent = this.components.find((component2) => {
-            var _a;
-            return component2.id === ((_a = myopMessage.content) == null ? void 0 : _a.id);
+            var _a2;
+            return component2.id === ((_a2 = myopMessage.content) == null ? void 0 : _a2.id);
           });
           initiatedComponent == null ? void 0 : initiatedComponent.setInitiated();
           return;
@@ -3442,7 +3848,10 @@ var HostSDK = class {
     });
     __publicField(this, "init", (customComponentLoaderCreators) => {
       if (this.initiated) {
-        throw new Error("hostSDK already initiated");
+        if (customComponentLoaderCreators == null ? void 0 : customComponentLoaderCreators.length) {
+          this._registerLoaders(customComponentLoaderCreators);
+        }
+        return;
       }
       const basicLoaders = [
         new MyopIframeLoader(),
@@ -3453,16 +3862,7 @@ var HostSDK = class {
         ...basicLoaders
       ];
       if (customComponentLoaderCreators) {
-        const loaderByType = {};
-        customComponentLoaderCreators.forEach((customComponentLoaderCreator) => {
-          const customLoader = new customComponentLoaderCreator(this.componentsLoaders);
-          loaderByType[customLoader.type] = customLoader;
-        });
-        this.componentsLoaders.forEach((loader) => {
-          if (!loaderByType[loader.type])
-            loaderByType[loader.type] = loader;
-        });
-        this.componentsLoaders = Object.values(loaderByType);
+        this._registerLoaders(customComponentLoaderCreators);
       }
       window.addEventListener(
         "message",
@@ -3472,6 +3872,18 @@ var HostSDK = class {
       console.log("myop hostSDK initiated", document.location.href);
       this.initiated = true;
     });
+    __publicField(this, "_registerLoaders", (customComponentLoaderCreators) => {
+      const loaderByType = {};
+      customComponentLoaderCreators.forEach((customComponentLoaderCreator) => {
+        const customLoader = new customComponentLoaderCreator(this.componentsLoaders);
+        loaderByType[customLoader.type] = customLoader;
+      });
+      this.componentsLoaders.forEach((loader) => {
+        if (!loaderByType[loader.type])
+          loaderByType[loader.type] = loader;
+      });
+      this.componentsLoaders = Object.values(loaderByType);
+    });
     __publicField(this, "_getSkinIdBySkinSelector", (_0, ..._1) => __async(this, [_0, ..._1], function* (skinSelector, experiences = [], hooks) {
       var _a;
       function asyncFind(array, predicate) {
@@ -3654,6 +4066,13 @@ if (!window.myop.hostSDK) {
   }
   window.myop.hostSDK = _hostSDK;
 }
+if (window.myop && !window.myop.delivery) {
+  const api = (opts) => delivery(opts);
+  api.stats = deliveryStats;
+  api.off = deliveryOff;
+  api.refresh = deliveryRefresh;
+  window.myop.delivery = api;
+}
 var hostSDK = window.myop.hostSDK;
 defineDynamicImport("hostSDK", hostSDK);
 
@@ -3789,4 +4208,4 @@ export {
   loaderStyleObject,
   setDebugStyle
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/dynamicImport/defineDynamicImport.ts", "../../../src/common/MyopMessages.ts", "../../../src/messages/index.ts", "../../../src/utils/uuid.ts", "../../../src/utils/utils.ts", "../../../src/messages/BaseMessage.ts", "../../../src/messages/BindClickMessage.ts", "../../../src/messages/ChangeTextMessage.ts", "../../../src/messages/ExecuteScriptMessage.ts", "../../../src/messages/CustomRefMessage.ts", "../../../src/messages/AddEventListenerMessage.ts", "../../../src/messages/SetAttributeMessage.ts", "../../../src/messages/GetElementValueMessage.ts", "../../../src/messages/SetInnerHtml.ts", "../../../src/messages/InitMessage.ts", "../../../src/messages/CreateRefComponentMessage.ts", "../../../src/messages/EnvelopedMessage.ts", "../../../src/messages/DetectMyopRefsMessage.ts", "../../../src/messages/GetAttributeMessage.ts", "../../../src/messages/componentMessages/ExecuteComponentMethod.ts", "../../../src/messages/componentMessages/SetMutationObserverMessage.ts", "../../../src/messages/CleanupMessage.ts", "../../../src/messages/DisposeMessage.ts", "../../../src/messages/componentMessages/SetResizeObserverMessage.ts", "../../../src/host/components/IMyopComponent.ts", "../../../src/common/MyopElementRef.ts", "../../../src/common/baseMessageHandler.ts", "../../../src/common/BaseMyopSDK.ts", "../../../src/common/index.ts", "../../../src/common/utils/serialization.ts", "../../../src/host/logMessages.ts", "../../../src/host/components/myopRefComponent.ts", "../../../src/host/components/myopExtractedWebComponent.ts", "../../../src/host/componentCore.ts", "../../../src/host/components/myopIframeComponent.ts", "../../../src/host/loaders/IMyopLoader.ts", "../../../src/host/loaders/iframeLoader.ts", "../../../src/webcomponent/consts.ts", "../../../src/host/components/myopWebcomponent.ts", "../../../src/host/loaders/webcomponentLoader.ts", "version:myop-sdk-version", "../../../src/webcomponent/messageHandlers/BaseWebComponentMessageHandler.ts", "../../../src/consts.ts", "../../../src/common/messageHandlers/helpers.ts", "../../../src/webcomponent/messageHandlers/bindOnClickHandler.ts", "../../../src/webcomponent/messageHandlers/changeTextHandler.ts", "../../../src/webcomponent/shadowRootRef.ts", "../../../src/webcomponent/messageHandlers/DetectMyopRefsMessageHandler.ts", "../../../src/webcomponent/messageHandlers/setAttributeHandler.ts", "../../../src/webcomponent/messageHandlers/addEventListenerHandler.ts", "../../../src/webcomponent/messageHandlers/CreateRefComponentMessageHandler.ts", "../../../src/common/messageHandlers/executeScriptHandler.ts", "../../../src/webcomponent/messageHandlers/executeScriptHandler.ts", "../../../src/webcomponent/messageHandlers/GetElementValueHandler.ts", "../../../src/webcomponent/messageHandlers/setInnerHtmlHandler.ts", "../../../src/webcomponent/WebComponentSDK.ts", "../../../src/host/loaders/HTMLComponentLoader.ts", "../../../src/helpers/CloudRepository.ts", "../../../src/helpers/cloudRepositoryHelpers.ts", "../../../src/host/myopOverride.ts", "../../../src/host/hostSDK.ts", "../../../src/host/myopLoader.ts"],
  "sourcesContent": ["export const __federation__ = \"__federation__\"\nexport const onLoadKey = \"onLoad\"\nexport const moduleInstanceKey = \"moduleInstance\"\n\nexport const defineDynamicImport = (globalName: string, module: any) => {\n    // @ts-ignore\n    if (window[__federation__] && window[__federation__][globalName] && window[__federation__][globalName][onLoadKey]) {\n        // @ts-ignore\n        window[__federation__][globalName][onLoadKey]({[globalName]: module})\n    } else {\n        //console.log('__federation__ loader not defined for module', module);\n    }\n}", "type StringWithAutocomplete<T> = T | (string & Record<never, never>);\n\nexport type MyopMessageKey = StringWithAutocomplete<keyof typeof MyopMessages | keyof typeof MyopMessages.In>;\n\nexport const MyopMessages = {\n    //host to component\n    'InitRequest': 'InitRequest',\n    'InitResponse': 'InitResponse',\n    'InitMessage': 'InitMessage',\n    'DisposeMessage': 'DisposeMessage',\n\n    'ChangeTextMessage': 'ChangeTextMessage',\n    'BindClickMessage': 'BindClickMessage',\n    'DetectMyopRefsMessage': 'DetectMyopRefsMessage',\n\n    'ExecuteScriptMessage': 'ExecuteScriptMessage',\n\n    'AddEventListenerMessage': 'AddEventListenerMessage',\n    'SetAttributeMessage': 'SetAttributeMessage',\n\n    'CreateRefComponentMessage': 'CreateRefComponentMessage',\n    'EnvelopedMessage': 'EnvelopedMessage',\n\n    'GetElementValueMessage': 'GetElementValueMessage',\n    'GetAttributeMessage': 'GetAttributeMessage',\n\n    'SetInnerHtml': 'SetInnerHtml',\n\n    //component messages\n    'ExecuteComponentMethod': 'ExecuteComponentMethod',\n    'SetMutationObserverMessage': 'SetMutationObserverMessage',\n    'SetResizeObserverMessage': 'SetResizeObserverMessage',\n\n    'CleanupMessage': 'CleanupMessage',\n\n    // external to host :\n    In: {\n        'DetectedMyopRefsMessage': 'DetectedMyopRefsMessage',\n        'ClickReplayMessage': 'ClickReplayMessage',\n        'ExecuteScriptReplyMessage': 'ExecuteScriptReplyMessage',\n\n        'EventListenerCallbackMessage': 'EventListenerCallbackMessage',\n        'ElementValueReplayMessage': 'ElementValueReplayMessage',\n\n        \"GetAttributeReplayMessage\": \"GetAttributeReplayMessage\",\n        'RefComponentCreatedMessage': 'RefComponentCreatedMessage',\n        'EnvelopedMessage': 'EnvelopedMessage',\n\n        'MutationObserverMessage': 'MutationObserverMessage',\n        'CleanupReplayMessage': 'CleanupReplayMessage',\n        'ResizeObserverMessage': 'ResizeObserverMessage'\n    }\n}\n", "export * from './BaseMessage';\n\n//user's messages\nexport * from './BindClickMessage';\nexport * from './ChangeTextMessage';\nexport * from './ExecuteScriptMessage';\nexport * from './CustomRefMessage';\nexport * from './AddEventListenerMessage';\nexport * from './SetAttributeMessage';\nexport * from './GetElementValueMessage';\nexport * from './SetInnerHtml';\n\n//system messages\nexport * from './InitMessage';\nexport * from './CreateRefComponentMessage';\nexport * from './EnvelopedMessage';\nexport * from './DetectMyopRefsMessage';\nexport * from './GetElementValueMessage';\nexport * from  './GetAttributeMessage';\n\nexport * from './componentMessages/ExecuteComponentMethod';\nexport * from './componentMessages/SetMutationObserverMessage';\nexport * from './CleanupMessage';\nexport * from './DisposeMessage';\nexport * from './componentMessages/SetResizeObserverMessage';", "//TODO : reuse from one place.\n// needs to be used in myop-sdk, myop-dashbaord, myop-server, myop-cli ..\n\nexport const uuidv4 = () => {\n    return \"10000000-1000-4000-8000-100000000000\".replace(/[018]/g, c =>\n        (+c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> +c / 4).toString(16)\n    );\n}\n\n// Convert UUID string to bytes\nexport const uuidToBytes = (uuid: string): Uint8Array => {\n    return Uint8Array.from(\n        uuid.replace(/-/g, '').match(/.{1,2}/g)!.map(byte => parseInt(byte, 16))\n    );\n};\n\n// Convert bytes to UUID string\nexport const bytesToUuid = (bytes: Uint8Array): string => {\n    const hex = [...bytes].map(b => b.toString(16).padStart(2, '0')).join('');\n    return [\n        hex.slice(0, 8),\n        hex.slice(8, 12),\n        hex.slice(12, 16),\n        hex.slice(16, 20),\n        hex.slice(20)\n    ].join('-');\n};\n\n// Base64 URL-safe encode\nexport const base64UrlEncode = (bytes: Uint8Array): string => {\n    const base64 = btoa(String.fromCharCode(...bytes));\n    return base64.replace(/\\+/g, '-').replace(/\\//g, '_').replace(/=+$/, '');\n};\n\n// Base64 URL-safe decode\nexport const base64UrlDecode = (str: string): Uint8Array => {\n    let base64 = str.replace(/-/g, '+').replace(/_/g, '/');\n    while (base64.length % 4) base64 += '=';\n    const binary = atob(base64);\n    return Uint8Array.from(binary, char => char.charCodeAt(0));\n};\n\n// Compress an array of UUIDs into a short URL-safe string\nexport const compressUUIDs = (uuids: string[]): string => {\n    const allBytes = uuids.flatMap(uuid => Array.from(uuidToBytes(uuid)));\n    return base64UrlEncode(new Uint8Array(allBytes));\n};\n\n// Decompress from URL-safe string back to an array of UUIDs\nexport const decompressUUIDs = (encoded: string): string[] => {\n    const bytes = base64UrlDecode(encoded);\n    if (bytes.length % 16 !== 0) throw new Error('Invalid input length');\n\n    const uuids: string[] = [];\n    for (let i = 0; i < bytes.length; i += 16) {\n        uuids.push(bytesToUuid(bytes.slice(i, i + 16)));\n    }\n    return uuids;\n};\n", "export * from './uuid.ts'\n\nexport const wait = (ms: number) => {\n    return new Promise(resolve => setTimeout(resolve, ms));\n}", "import {MyopMessageKey} from \"../common/MyopMessages\";\nimport {uuidv4} from \"../utils/utils\";\nimport {IMyopComponent} from \"../host\";\nimport {IRefConfig} from \"../common\";\n\nexport class MessageDirection {\n    static down = 'down' as const\n    static up = 'up' as const\n}\n\nexport type MessageDirectionOption = 'up' | 'down';\n\nexport abstract class BaseMyopMessage<T = any> {\n    id = uuidv4()\n\n    static create<T, U extends new (...args: ConstructorParameters<U>) => T = typeof this>(\n        this: U,\n        ...args: ConstructorParameters<U>\n    ): InstanceType<typeof this> {\n        // @ts-ignore\n        return new this(...args);\n    }\n\n    constructor() {\n        //console.log('meesage id created', this.id, document.location.href);\n    }\n\n    myop = true\n\n    abstract messageType: MyopMessageKey | string;\n\n    content?: T\n\n    // TODO : cant be optional \n    source?: string\n    destination?: string\n\n    route?: string[]\n\n    ref?: Ref\n\n    direction?: MessageDirectionOption\n\n    cleanable: boolean = false\n\n    isTypeof(msg: BaseMyopMessage): boolean {\n        return msg.messageType === this.messageType\n    }\n}\n\nexport abstract class MyopElementMessage<T = any> extends BaseMyopMessage<T> {\n    constructor(public ref: Ref) {\n        super()\n    }\n}\n\nexport abstract class MyopBindReplayMessage<T = any> extends BaseMyopMessage<T> {\n    constructor(public replayToHandler?: string) {\n        super();\n    }\n}\n\nexport abstract class MyopBindMessage<T = any, R extends MyopBindReplayMessage = any> extends BaseMyopMessage<T> {\n\n    public abstract replyMessageKey: MyopMessageKey;\n\n    public handlerUniqueId = uuidv4()\n\n    constructor(public handler: (message: R) => void) {\n        super()\n    }\n}\n\nexport class Ref {\n    public myop = true;\n\n    public __nonProxied?: Ref;\n\n    static create(selector: string, refConfig?: IRefConfig, component?: IMyopComponent) {\n        let _refConfig = refConfig;\n        if (!_refConfig) {\n            _refConfig = {\n                id: '',\n                name: '',\n                description: '',\n                selectorType: 'id-attribute',\n                selector: selector,\n                behavior: {\n                    type: 'code'\n                }\n            } as IRefConfig\n        }\n        return new Ref(_refConfig, component);\n    }\n\n    constructor(public refConfig: IRefConfig, public component?: IMyopComponent) {\n        this.__nonProxied = {\n            ...this,\n            component: null // in order to be serializable\n        }\n    }\n}\n", "import {MyopBindMessage, MyopBindReplayMessage, Ref} from \"./BaseMessage\";\nimport {MyopMessageKey} from \"../common/MyopMessages\";\n\nconst ReplayMessageKey = 'ClickReplayMessage'\n\nexport class BindClickMessage extends MyopBindMessage<void, ClickReplayMessage> {\n    replyMessageKey: MyopMessageKey = ReplayMessageKey\n    messageType = 'BindClickMessage';\n    cleanable = true;\n\n    constructor(public ref: Ref, handler: (message: ClickReplayMessage) => void) {\n        super(handler);\n    }\n}\n\nexport class ClickReplayMessage extends MyopBindReplayMessage {\n    messageType = ReplayMessageKey\n}\n\n", "import {BaseMyopMessage, Ref} from \"./BaseMessage\";\n\nexport class ChangeTextMessage extends BaseMyopMessage<string> {\n\n    messageType = 'ChangeTextMessage';\n\n    constructor(public ref: Ref, text: string) {\n        super();\n        this.content = text\n    }\n}", "import {MyopBindMessage, MyopBindReplayMessage} from \"./BaseMessage\";\nimport {MyopMessageKey} from \"../common/MyopMessages\";\nimport {RootRef} from \"../common\";\nimport {makeSerializable} from \"../common/utils/serialization.ts\";\n\nconst ReplayMessageKey = 'ExecuteScriptReplyMessage'\n\nconst functionBodyRegex = /(?:function\\s*\\w*\\s*\\([^)]*\\)\\s*\\{([\\s\\S]*?)\\}|(\\([^)]*\\)\\s*=>\\s*\\{([\\s\\S]*?)\\}))\\s*$/;\nconst expressionBodyRegex = /\\(\\s*[^)]+\\s*\\)\\s*=>\\s*(.+)/;\n\nexport const stripFunction = (content: string) => {\n    let match = content.match(functionBodyRegex);\n    if (match) {\n        return match[1] || match[3];\n    } else {\n        let match = content.match(expressionBodyRegex);\n        if (match)\n            return match[1].trim();\n    }\n}\n\nexport type scriptInputs = {\n    [key: string]: string | number | boolean\n} | {};\n\nexport type scriptVars<T> = {\n    send: (data: T) => void;\n    // completeStream: () => void;\n    rootRef: RootRef;\n    makeSerializable: typeof makeSerializable\n}\n\nexport type extendedScriptVars<T, I> = {\n    [K in keyof I]: I[K];\n} & scriptVars<T>\n\nexport class ExecuteScriptMessage<T = any, I extends scriptInputs = any> extends MyopBindMessage<string, ExecuteScriptReplyMessage<T>> {\n\n    replyMessageKey: MyopMessageKey = ReplayMessageKey;\n    messageType = 'ExecuteScriptMessage';\n    script: string = ''\n\n    static replierKey = 'send';\n    static completeStreamKey = 'completeStream';\n\n    constructor(script: (vars: extendedScriptVars<T, I>) => T, handler: (message: ExecuteScriptReplyMessage<T>) => void = () => {\n    }, public scriptInputs?: I) {\n        super(handler);\n        this.script = script.toString();\n\n        //TODO: can be remove\n        this.content = script.toString()\n        this.content = stripFunction(this.content);\n    }\n}\n\nexport class ExecuteScriptReplyMessage<T = any> extends MyopBindReplayMessage<T> {\n\n    messageType = ReplayMessageKey;\n\n    constructor(public replayToHandler: string, public content: T) {\n        super(replayToHandler);\n    }\n}\n", "import {\n    ExecuteScriptMessage,\n    ExecuteScriptReplyMessage,\n    extendedScriptVars,\n    scriptInputs, stripFunction\n} from \"./ExecuteScriptMessage.ts\";\n\nexport type customRefScriptInputs = {\n    elementId: string,\n    ref?: HTMLElement,\n    _script?: string,\n    __scriptInputs?: Object\n};\n\nexport class CustomRefMessage<T = any, I extends scriptInputs = customRefScriptInputs> extends ExecuteScriptMessage<T, I & customRefScriptInputs> {\n\n    constructor(script: (vars: extendedScriptVars<T, I & customRefScriptInputs>) => T,\n                public scriptInputs: I & customRefScriptInputs,\n                handler: (message: ExecuteScriptReplyMessage<T>) => void = () => {\n                }) {\n\n        //mock vars\n        // let rootRef, elementId, _script, __scriptInputs;\n        super(({rootRef, elementId, _script, __scriptInputs}) => {\n            const refs = (rootRef.shadowRoot || rootRef.container).querySelectorAll(`[${'myop-id'}='${elementId}']`);\n            if (refs.length) {\n                //  const ref = refs[0];\n\n                //TODO : think about exposing \"refs\" and not only \"ref\"\n                //for cases where the Ref has multiplate implementations\n\n                // @ts-ignore\n                __scriptInputs.ref = refs[0];\n\n                const dynamicFunction = new Function(`return (${_script})(...arguments)`);\n                return dynamicFunction(__scriptInputs);\n\n                // @ts-ignore\n                //return Function('ref', 'rootRef', ...Object.keys(__scriptInputs), _script!)(ref, rootRef, ...Object.values(__scriptInputs))\n            }\n            return null as T;\n        }, handler);\n\n        this.scriptInputs = {\n            ...scriptInputs,\n            //_script: stripFunction(script.toString()),\n            _script: script.toString()\n        };\n    }\n}\n", "import {MyopBindMessage, MyopBindReplayMessage, Ref} from \"./BaseMessage\";\nimport {MyopMessageKey} from \"../common/MyopMessages\";\nimport {Serializable, SerializableSkeleton} from \"../common/utils/serialization.ts\";\n\nconst ReplayMessageKey = 'EventListenerCallbackMessage'\n\nexport class AddEventListenerMessage<T extends keyof HTMLElementEventMap = keyof HTMLElementEventMap> extends MyopBindMessage {\n\n    replyMessageKey: MyopMessageKey = ReplayMessageKey;\n    messageType = 'AddEventListenerMessage';\n    cleanable = true;\n    serializableSkeleton: SerializableSkeleton<HTMLElementEventMap[T]> = false // {} // empty\n\n    constructor(public ref: Ref, public type: T, public handler: (message: EventListenerCallbackMessage) => void) {\n        super(handler)\n    }\n\n    withSerializableSkeleton(serializableSkeleton: SerializableSkeleton<HTMLElementEventMap[T]>) {\n        this.serializableSkeleton = serializableSkeleton;\n        return this;\n    }\n}\n\nexport class EventListenerCallbackMessage extends MyopBindReplayMessage {\n    messageType = ReplayMessageKey;\n\n    constructor(public replayToHandler: string, public e: Serializable<Event>) {\n        super(replayToHandler);\n        this.content = {\n            e\n        }\n    }\n}\n", "import {BaseMyopMessage, Ref,} from \"./BaseMessage\";\n\n\nexport class SetAttributeMessage extends BaseMyopMessage {\n\n    messageType = 'SetAttributeMessage';\n\n    constructor(public ref: Ref, public name: string, public value: string) {\n        super()\n    }\n}\n", "import {MyopBindMessage, MyopBindReplayMessage, Ref} from \"./BaseMessage\";\nimport {MyopMessageKey} from \"../common/MyopMessages\";\nimport {Serializable} from \"../common/utils/serialization.ts\";\n\nconst ReplayMessageKey = 'ElementValueReplayMessage'\n\nexport class GetElementValueMessage extends MyopBindMessage<void, ElementValueReplayMessage> {\n    replyMessageKey: MyopMessageKey = ReplayMessageKey\n    messageType = 'GetElementValueMessage';\n\n    constructor(public ref: Ref, handler: (message: ElementValueReplayMessage) => void) {\n        super(handler);\n    }\n}\n\nexport type FormDataEntry = {\n    id?: string,\n    name?: string,\n    value?: InputElementValue,\n    required?: boolean,\n    validity?: Serializable<ValidityState>,\n    myopId?: string\n}\n\nexport type InputElementFormValue = {\n    formData?: { [key: string]: FormDataEntry }\n    unmappedData?: FormDataEntry[]\n};\n\nexport type InputElementValue = string | InputElementFormValue | null | undefined\n\nexport class ElementValueReplayMessage extends MyopBindReplayMessage {\n    messageType = ReplayMessageKey\n\n    constructor(public content: InputElementValue) {\n        super();\n    }\n}\n\n", "import {BaseMyopMessage, Ref} from \"./BaseMessage.ts\";\n\nexport class SetInnerHtml extends BaseMyopMessage<string> {\n\n    messageType = 'SetInnerHtml';\n\n    constructor(public ref: Ref, innerHtml: string) {\n        super();\n        this.content = innerHtml\n    }\n}", "import { BaseMyopMessage } from \"./BaseMessage\";\n\n// sent by host to components, contains thier id \nexport class InitMessage extends BaseMyopMessage<{ id: string }> {\n    messageType = 'InitMessage';\n\n    constructor(id: string) {\n        super()\n        this.content = { id }\n    }\n\n    isTypeof(msg: BaseMyopMessage): boolean {\n        return msg.messageType === this.messageType\n    }\n}\n\n// component notify host the it was initated \nexport class InitResponse extends InitMessage {\n    messageType = 'InitResponse';\n}\n\n// component ask to host to get initated \nexport class InitRequest extends BaseMyopMessage {\n    messageType = 'InitRequest';\n}\n", "import {MyopBindMessage, MyopBindReplayMessage} from \"./BaseMessage\";\nimport {MyopMessageKey} from \"../common/MyopMessages\";\nimport {IComponentConfig, IRefConfig} from \"../common\";\nimport {loaderOptions} from \"../host/hostSDK.ts\";\n\nconst ReplayMessageKey = 'RefComponentCreatedMessage'\n\nexport class CreateRefComponentMessage extends MyopBindMessage<void, RefComponentCreatedMessage> {\n    replyMessageKey: MyopMessageKey = ReplayMessageKey\n    messageType = 'CreateRefComponentMessage';\n\n    constructor(public refConfig: IRefConfig,\n                public nestedComponentConfig: IComponentConfig,\n                public options: loaderOptions,\n                handler: (message: RefComponentCreatedMessage) => void,\n    ) {\n        super(handler);\n\n    }\n}\n\nexport type NestedRef = {\n    refName: string,\n    componentDefinitionId: string\n}\n\nexport class RefComponentCreatedMessage extends MyopBindReplayMessage {\n    messageType = ReplayMessageKey\n\n    constructor(public replayToHandler: string, public nestedRefs: NestedRef[], public failed?: boolean) {\n        super(replayToHandler);\n    }\n}\n", "import {BaseMyopMessage} from \"./BaseMessage\";\n\nexport class EnvelopedMessage extends BaseMyopMessage {\n    messageType = 'EnvelopedMessage';\n\n    constructor(public destination: string, public message: BaseMyopMessage) {\n        super();\n\n        const innerEnvelopedMessage = (message as EnvelopedMessage);\n        this.route = [destination, ...innerEnvelopedMessage.route ? innerEnvelopedMessage.route : []];\n    }\n}\n", "import {BaseMyopMessage, MyopBindMessage, MyopBindReplayMessage} from \"./BaseMessage\";\nimport {IElementRef} from \"../common\";\n\nconst ReplayMessageKey = 'DetectedMyopRefsMessage'\n\nexport class DetectMyopRefsMessage extends MyopBindMessage<any, DetectedMyopRefsMessage> {\n    messageType = 'DetectMyopRefsMessage'\n    replyMessageKey = ReplayMessageKey;\n}\n\nexport class DetectedMyopRefsMessage extends MyopBindReplayMessage<IElementRef[]> {\n\n    messageType = ReplayMessageKey;\n\n    constructor(public replayToHandler: string, myopElementRefs: IElementRef[]) {\n        super(replayToHandler)\n        this.content = myopElementRefs;\n    }\n\n    isTypeof(msg: BaseMyopMessage<any>): boolean {\n        return msg.messageType === this.messageType\n    }\n}\n", "import {MyopBindMessage, MyopBindReplayMessage, Ref} from \"./BaseMessage\";\nimport {MyopMessageKey} from \"../common/MyopMessages\";\n\nconst ReplayMessageKey = 'GetAttributeReplayMessage'\n\nexport class GetAttributeMessage extends MyopBindMessage<void, GetAttributeReplayMessage> {\n    replyMessageKey: MyopMessageKey = ReplayMessageKey\n    messageType = 'GetAttributeMessage';\n\n    constructor(public ref: Ref, public name: string, handler: (message: GetAttributeReplayMessage) => void) {\n        super(handler);\n    }\n}\n\nexport class GetAttributeReplayMessage extends MyopBindReplayMessage {\n    messageType = ReplayMessageKey\n\n    constructor(public content: string | null) {\n        super();\n    }\n}\n\n", "import {BaseMyopMessage} from \"../BaseMessage\";\nimport {IMyopComponent} from \"../../host\";\n\ntype MethodNames<T> = {\n    // [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;\n    [K in keyof T]: T[K] extends () => void ? K : never;\n}[keyof T];\n\n// Define a type that allows only strings corresponding to the method names of T\ntype MethodString<T> = MethodNames<T> extends infer M ? M extends string ? M : never : never;\n\n\nexport class ExecuteComponentMethod extends BaseMyopMessage {\n    messageType = 'ExecuteComponentMethod';\n\n    constructor(public method: MethodString<IMyopComponent>) {\n        super();\n    }\n}\n", "import {BaseMyopMessage} from \"../BaseMessage\";\n\nexport class SetMutationObserverMessage extends BaseMyopMessage {\n    messageType = 'SetMutationObserverMessage';\n}\n\nexport class MutationObserverMessage extends BaseMyopMessage {\n    messageType = 'MutationObserverMessage';\n}", "import {MyopBindMessage, MyopBindReplayMessage} from \"./BaseMessage\";\nimport {MyopMessageKey} from \"../common/MyopMessages\";\n\nconst ReplayMessageKey = 'CleanupReplayMessage'\n\nexport class CleanupMessage extends MyopBindMessage<void, CleanupReplayMessage> {\n    replyMessageKey: MyopMessageKey = ReplayMessageKey\n    messageType = 'CleanupMessage';\n\n    constructor(public cleanupForMessageId: string, handler: (message: CleanupReplayMessage) => void) {\n        super(handler);\n    }\n}\n\nexport class CleanupReplayMessage extends MyopBindReplayMessage {\n    messageType = ReplayMessageKey\n\n    constructor(public customCleanup: boolean) {\n        super();\n    }\n}\n", "import {BaseMyopMessage} from \"./BaseMessage\";\n\nexport class DisposeMessage extends BaseMyopMessage {\n    messageType = 'DisposeMessage';\n}\n", "import {BaseMyopMessage} from \"../BaseMessage\";\n\nexport class SetResizeObserverMessage extends BaseMyopMessage {\n    cleanable = true;\n    messageType = 'SetResizeObserverMessage';\n}\n\nexport class ResizeObserverMessage extends BaseMyopMessage {\n    messageType = 'ResizeObserverMessage';\n}", "import {MyopMessageKey, MyopMessages} from \"../../common/MyopMessages\";\nimport {\n    BaseMyopMessage,\n    DisposeMessage, ExecuteComponentMethod, MessageDirection,\n    CleanupMessage, CleanupReplayMessage,\n    MyopBindMessage,\n    MyopBindReplayMessage, Ref\n} from \"../../messages\";\nimport {CleanupHandler, IComponentDefinitionConfig} from \"../../common\";\nimport {HostSDK, loaderOptions} from \"../hostSDK.ts\";\n\n/**\n * Result returned by observeAutoSize callback\n */\nexport interface AutoSizeResult {\n    /** Current width (from content) */\n    width: number;\n    /** Current height (from content) */\n    height: number;\n    /** Whether width is being auto-sized */\n    autoSizingWidth: boolean;\n    /** Whether height is being auto-sized */\n    autoSizingHeight: boolean;\n}\n\n/**\n * Options for observeAutoSize method\n */\nexport interface AutoSizeOptions {\n    /** Callback called with size info whenever size changes */\n    onSizeChange?: (result: AutoSizeResult) => void;\n    /** Minimum width constraint */\n    minWidth?: number | string;\n    /** Maximum width constraint */\n    maxWidth?: number | string;\n    /** Minimum height constraint */\n    minHeight?: number | string;\n    /** Maximum height constraint */\n    maxHeight?: number | string;\n    /** Explicit width set by host - if defined, don't auto-size width */\n    explicitWidth?: string | number;\n    /** Explicit height set by host - if defined, don't auto-size height */\n    explicitHeight?: string | number;\n    /** Force auto-size even if container has dimensions */\n    forceAutoSize?: boolean;\n    /** Min height used by loader to detect collapse (default: 50) */\n    loaderMinHeight?: number;\n}\n\n//TODO : change IMyopComponent to ref specific impl\ntype RefTypes = {\n    [key: string]: IMyopComponent | Ref\n};\n\nexport interface IMyopComponent<P = any, R = any> {\n\n    id: string;\n\n    isInitiated: boolean;\n\n    markedForDisposed: boolean;\n\n    setInitiated: () => void\n\n    componentDefinition: IComponentDefinitionConfig\n\n    container: HTMLElement\n\n    //ref components can be element-less\n    element?: HTMLElement\n\n    send: (msg: BaseMyopMessage) => CleanupHandler\n\n    bind(messageType: MyopMessageKey, handler: () => boolean): void;\n\n    bind<T extends BaseMyopMessage>(messageType: MyopMessageKey, handler: (message: T) => boolean): void;\n\n    // boolean returned value = handled or not\n    onMessageReceived: (msg: BaseMyopMessage) => boolean\n\n    initiated: () => Promise<any>;\n\n    dispose: () => void\n\n    hide(): void;\n\n    show(): void;\n\n    inspect(): void;\n\n    /**\n     * Observes the iframe content size and automatically syncs it to the iframe element.\n     * Only available for iframe-based components. Uses direct contentDocument access.\n     * @param options - Configuration options including size change callback and min/max constraints\n     * @returns Cleanup function to stop observing\n     */\n    observeAutoSize?: (options?: AutoSizeOptions) => CleanupHandler;\n\n    /**\n     * Parsed myop:size meta tag from the component HTML.\n     * Set by HTMLComponentLoader before iframe creation.\n     * Used by the React host to determine sizing mode (fill vs content).\n     */\n    sizeMeta?: { width?: string | number; height?: string | number; minWidth?: number; maxWidth?: number; minHeight?: number; maxHeight?: number } | null;\n\n    parent?: IMyopComponent;\n\n    props: P\n\n    refs: R\n}\n\nfunction isInheritFrom(obj: any, baseClass: any) {\n    if (!obj) {\n        return false;\n    }\n\n    const proto = Object.getPrototypeOf(obj);\n\n    if (!proto) {\n        return false;\n    }\n\n    if (proto.constructor.name === baseClass.name) {\n        return true;\n    }\n    return isInheritFrom(proto, baseClass);\n}\n\n// TODO : move : \ntype messageHandler<T> = (message: T) => boolean;\n\nexport abstract class BaseMyopComponent<P = any, R extends RefTypes = RefTypes> implements IMyopComponent<P> {\n    id: string = ''\n\n    messageHandlers: Record<string, messageHandler<any>[]> = {};\n\n    element?: HTMLElement\n\n    protected constructor(public componentDefinition: IComponentDefinitionConfig, public container: HTMLElement, options?: loaderOptions) {\n        this.id = options?.id || HostSDK.Instance().assignId(componentDefinition);\n        const timeout = options?.timeout ? options?.timeout : 5 * 1000;\n        setTimeout(() => {\n            if (!this.isInitiated && this._whenInitiatedReject && !this._markedForDisposed) {\n                this._whenInitiatedReject(`timeout_${timeout} ${this.id}`);\n            }\n        }, timeout);\n\n        // TODO : auto inspect, control from config\n        this.initiated().then(() => {\n            // @ts-ignore\n            if (window.myop.hostSDK.inspected) {\n                this.inspect()\n            }\n        });\n    }\n\n    _markedForDisposed: boolean = false;\n\n    get markedForDisposed(): boolean {\n        return this._markedForDisposed;\n    }\n\n    set markedForDisposed(value: boolean) {\n        if (this._markedForDisposed) {\n            throw new Error('InvalidOperationException: The component is already in the process of being disposed. Dispose operation cannot be performed again until the current disposal process is complete.')\n        }\n        this._markedForDisposed = value;\n    }\n\n    abstract hide(): void;\n\n    abstract show(): void;\n\n    abstract inspect(): CleanupHandler;\n\n    //TODO: use bindWhen with return true predicate ...\n    bind = <T extends BaseMyopMessage>(messageType: string, handler: (message: T) => boolean) => {\n        if (!this.messageHandlers[messageType]) {\n            this.messageHandlers[messageType] = []\n        }\n\n        // handle duplicate registration\n        if (!this.messageHandlers[messageType].includes(handler)) {\n            this.messageHandlers[messageType].push(handler);\n        }\n    }\n\n    bindWhen = <T extends BaseMyopMessage>(messageType: string, predicate: (message: T) => boolean, handler: (message: T) => void): CleanupHandler => {\n        if (!handler) {\n            throw new Error('can\\'t use component.bindWhen without an handler');\n        }\n\n        if (!this.messageHandlers[messageType]) {\n            this.messageHandlers[messageType] = []\n        }\n\n        const handlers = this.messageHandlers[messageType];\n\n        const predicateWrappedHandler = (e: T) => {\n            if (predicate(e)) {\n                handler(e);\n                return true;\n            }\n            return false;\n        };\n\n        //TODO : handle duplicate registration ?\n        handlers.push(predicateWrappedHandler);\n\n        return () => {\n            const index = handlers.indexOf(predicateWrappedHandler);\n            if (index > -1) {\n                handlers.splice(index, 1);\n            }\n        }\n    }\n\n    onMessageReceived(incomeMessage: BaseMyopMessage): boolean {\n        //console.log('onMessageReceived', document.location.href, incomeMessage, this);\n        //TODO : handel special evets ? like initRes ?\n        if (incomeMessage.messageType === MyopMessages.ExecuteComponentMethod) {\n            const typedMessage = (incomeMessage as ExecuteComponentMethod);\n\n            //keeping this.method() so that context will saved\n            if ((this as any)[typedMessage.method]) {\n                (this as any)[typedMessage.method](typedMessage.content);\n            } else {\n                console.log(`method not found ${typedMessage.method} on component`, this)\n            }\n\n            return true;\n        }\n\n        const handlers = this.messageHandlers[incomeMessage.messageType];\n        if (handlers && handlers.length) {\n            let handled = false;\n\n            handlers.forEach(handler => {\n                handled = handled || handler(incomeMessage)\n            })\n            return handled;\n        } else {\n            //TODO : console only when debug config\n            //console.log('no handlers found for ', incomeMessage)\n        }\n        return false;\n    }\n\n    setInitiated = () => {\n        this.isInitiated = true;\n\n        if (this._whenInitiatedResolve)\n            this._whenInitiatedResolve();\n    }\n\n    isInitiated: boolean = false;\n\n    _whenInitiatedResolve?: (value?: any) => any;\n    _whenInitiatedReject?: (value?: any) => any;\n\n    _whenInitiated: Promise<any> = new Promise((resolve, reject) => {\n        this._whenInitiatedResolve = resolve;\n        this._whenInitiatedReject = reject;\n    });\n\n    initiated = () => {\n        return this._whenInitiated;\n    }\n\n    private sendCleanupMessage(message: CleanupMessage): void {\n        message.source = this.id;\n        message.destination = this.id;\n        message.direction = MessageDirection.down;\n\n        const cleanupHandler = this.bindWhen(message.replyMessageKey, (msg: MyopBindReplayMessage) => {\n            return msg.replayToHandler === message.handlerUniqueId\n        }, (m: CleanupReplayMessage) => {\n            message.handler(m);\n            cleanupHandler();\n        });\n\n        const handler = message.handler;\n        // @ts-ignore\n        delete message.handler\n\n        this.send(message);\n\n        message.handler = handler;\n    }\n\n    send(message: BaseMyopMessage): CleanupHandler {\n        //messages that exetracted from envelope already have source in them\n        if (!message.source)\n            message.source = this.id;\n\n        if (!message.destination)\n            message.destination = this.id;\n\n        message.direction = MessageDirection.down;\n\n        let cleanupHandler;\n        // TODO : fix heavy op..\n        //  if (isInheritFrom(message, MyopBindMessage)) {\n        // @ts-ignore\n        if (message.handler) {\n            const typedMessage = (message as MyopBindMessage);\n            cleanupHandler = this.bindWhen(typedMessage.replyMessageKey, (msg: MyopBindReplayMessage) => {\n                return msg.replayToHandler === typedMessage.handlerUniqueId\n            }, typedMessage.handler);\n\n            // @ts-ignore\n            delete message.handler\n        }\n\n        //TODO: think about that\n        if (message.ref) {\n            // serializable\n            message.ref = message.ref.__nonProxied || message.ref;\n        }\n\n        if (message.cleanable) {\n            return () => {\n                this.sendCleanupMessage(new CleanupMessage(message.id, (replay) => {\n                    //TODO : log replay?\n                }));\n\n                if (cleanupHandler) {\n                    cleanupHandler()\n                }\n            };\n        } else {\n            return () => {\n            }\n        }\n    }\n\n    dispose(): void {\n        this.markedForDisposed = true;\n\n        if (!this.isInitiated) {\n            //TODO : use sdk.logger\n            //console.log('disposing before isInitiated', this.id);\n            return;\n        }\n        console.log('disposing component', this.id);\n\n        // //TODO : implement dispose flow\n        // Object.keys(this.refs).forEach(refKey=>{\n        //     this.refs[refKey].dispose();\n        // });\n\n        //TODO : check if there is any time for the o\n        // ther side to proccess to message before die ?\n        //notify the other side SDK\n        this.send(new DisposeMessage())\n\n        const onDisposeHandlers = this.messageHandlers['onDispose']\n        if (onDisposeHandlers) {\n            onDisposeHandlers.forEach(disposeHandler => {\n                //TODO : send null or fix the type ?\n                disposeHandler(null);\n            })\n        }\n\n        //console.log(this.container);\n        //this.container.innerHTML = '';\n        this.messageHandlers = {}\n        this.id += '_disposed';\n        this.isInitiated = false;\n    }\n\n    props: P = {} as unknown as P;\n    refs: R = {} as unknown as R;\n}\n", "export interface IElementRef {\n    myopId?: string\n    htmlTagName: string\n    BoundingRect?: DOMRect\n    offsetTop?: number\n    offsetLeft?: number\n\n    type: string\n}\n\nexport class XPathElementRef implements IElementRef {\n    constructor(public xPath: string,\n                public htmlTagName: string,\n                public BoundingRect?: DOMRect,\n                public offsetTop?: number,\n                public offsetLeft?: number) {\n    }\n\n    public readonly type: string = 'XPathElementRef'\n}\n\nexport class MyopElementRef implements IElementRef {\n    constructor(public myopId: string,\n                public htmlTagName: string,\n                public BoundingRect?: DOMRect,\n                public offsetTop?: number,\n                public offsetLeft?: number) {\n\n    }\n\n    public readonly type: string = 'MyopElementRef'\n}\n", "import {MyopMessageKey} from \"./MyopMessages\";\nimport {BaseMyopMessage, MyopBindMessage, MyopBindReplayMessage} from \"../messages\";\nimport {CleanupHandler} from \"./index.ts\";\n\nexport type IMessageExecutorCleanup = CleanupHandler | Promise<CleanupHandler> | Promise<void> | void;\n\nexport const runExecutorCleanup = async (task: IMessageExecutorCleanup) => {\n    if (typeof task === 'function') {\n        // It's a function, call it\n        task();\n    } else if (task instanceof Promise) {\n        // It's a Promise, await it\n        const result = await task;\n\n        if (typeof result === 'function') {\n            // If the result is a function, call it\n            result();\n        }\n    }\n    // If task is void, do nothing\n}\n\ntype IMessageExecutor<T extends BaseMyopMessage> = (message: T) => IMessageExecutorCleanup;\n\ninterface IMessageHandler<T extends BaseMyopMessage> {\n    messageType: MyopMessageKey\n\n    executor: IMessageExecutor<T>;\n\n    messageToHost: (message: MyopBindReplayMessage, replayTo?: MyopBindMessage) => void;\n}\n\nexport abstract class BaseMessageHandler<T extends BaseMyopMessage = any> implements IMessageHandler<T> {\n\n    //TODO : add dispose method\n\n    constructor(public messageToHost: (message: MyopBindReplayMessage, replayTo?: MyopBindMessage) => void) {\n\n    }\n\n    abstract messageType: MyopMessageKey\n    abstract executor: IMessageExecutor<T>;\n}\n\nexport abstract class BaseContextMessageHandler<T extends BaseMyopMessage = any, E = any> extends BaseMessageHandler<T> {\n    constructor(public messageToHost: (message: MyopBindReplayMessage, replayTo?: MyopBindMessage) => void, public context?: E) {\n        super(messageToHost);\n    }\n}\n", "import {MyopMessages} from \"./MyopMessages\";\nimport {CleanupHandler, runExecutorCleanup} from \"./index.ts\";\nimport {BaseMessageHandler} from \"./baseMessageHandler\";\nimport {\n    BaseMyopMessage, CleanupMessage, CleanupReplayMessage, CreateRefComponentMessage, EnvelopedMessage,\n    InitMessage,\n    InitResponse,\n    MessageDirection,\n    MyopBindMessage,\n    MyopBindReplayMessage\n} from \"../messages\";\n\nexport class HostedComponent<T = any> {\n    send = (message: BaseMyopMessage) => {\n        //debugger;\n    }\n\n    //onMessageReceived: (msg: IMyopMessage) => void;\n\n    constructor(public id: string, public context?: T) {\n\n    }\n}\n\nexport interface IMyopSDK {\n    init: () => void;\n\n    messageToHost: (message: MyopBindReplayMessage, replayTo?: MyopBindMessage) => void\n\n    supportedHandlers: BaseMessageHandler[];\n\n    handleIncomeMessages: (message: BaseMyopMessage) => void\n\n    components: Record<string, HostedComponent>;\n}\n\n// const localHostHandledMessages = [\n//     MyopMessages.InitRequest,\n//     MyopMessages.InitResponse,\n//     //MyopMessages.EnvelopedMessage,\n// ]\n\nexport abstract class BaseMyopSDK implements IMyopSDK {\n\n    abstract messageToHost: (message: MyopBindReplayMessage, replayTo?: MyopBindMessage) => void;\n\n    abstract supportedHandlers: BaseMessageHandler[];\n\n    messageToHandleAfterInit: BaseMyopMessage[] = [];\n\n    components: Record<string, HostedComponent> = {};\n\n    alwaysPassEnvelopesToHost: boolean = false\n\n    messageCleanupCache: Record<string, CleanupHandler | Promise<CleanupHandler>> | Promise<void> = {};\n\n    handleIncomeMessages(event: any) {\n        const eventContent = event.data ? event.data : event.detail;\n\n        if (!eventContent || !eventContent.myop) {\n            // not myop marked event \n            return;\n        } else {\n            let message = eventContent as BaseMyopMessage;\n\n            if (message.direction !== MessageDirection.down) {\n                //console.log('message dropped in baseSDK, direction was ', event.data.direction)\n                return;\n            }\n\n            // if (localHostHandledMessages.includes(message.messageType)) {\n            //     debugger;\n            //     //TODO : fix direction ? message will not proccess otherwise\n            //     window.myop.hostSDK.send(message)\n            //     return;\n            // }\n\n            if (message.messageType === MyopMessages.DisposeMessage) {\n                //debugger;\n\n                //TODO : should not be optional, fix and remove 'if'\n                if (message.destination)\n                    delete this.components[message.destination]\n                return;\n            }\n\n            // We got our id from our hostSDK\n            if (message.messageType === MyopMessages.InitMessage) {\n                //TODO : SDK may serve more than 1 component .. think about that\n                // @ts-ignore\n                const newComponentId = (message as InitMessage).content.id;\n\n                if (this.components[newComponentId]) {\n                    //debugger;\n                    //throw new Error(\"rechived init message for an exsising component.\")\n                    return;\n                }\n\n                this.components[newComponentId] = new HostedComponent(newComponentId)\n                this.messageToHost(new InitResponse(newComponentId));\n\n                // TODO : is it true to not pass further ( to the component )\n                return;\n            }\n\n            // for same HostSDK cases\n            // when both RefComponent and realComponent hosted in the same HostSDK\n            if (message.messageType === MyopMessages.EnvelopedMessage) {\n                const envelopedMessage = (message as EnvelopedMessage);\n                const innerMessage = envelopedMessage.message;\n                message = innerMessage;\n\n                if (this.alwaysPassEnvelopesToHost || this.components[message.destination!]) {\n                    // @ts-ignore\n                    const destinationComponent = myop.hostSDK.components.find(c => c.id === innerMessage.destination);\n                    if (destinationComponent) {\n                        destinationComponent.send(innerMessage);\n                        return;\n                    }\n\n                    // @ts-ignore\n                    const envelopedDestinationComponent = myop.hostSDK.components.find(c => c.id === envelopedMessage.destination);\n                    if (envelopedDestinationComponent) {\n                        envelopedDestinationComponent.send(innerMessage);\n                        return;\n                    }\n                } else {\n                    return;\n                }\n            }\n\n            // if(message.messageType === MyopMessages.CreateRefComponentMessage){\n            //     const typedMessage : CreateRefComponentMessage = message as CreateRefComponentMessage;\n            // //    debugger;\n            // }\n            if (message.messageType) {\n\n                if (message.messageType === MyopMessages.CleanupMessage) {\n                    const typedMessage = message as CleanupMessage;\n                    const cleanup = this.messageCleanupCache[typedMessage.cleanupForMessageId];\n\n                    const cleanupMessage = new CleanupReplayMessage(!!cleanup);\n                    cleanupMessage.destination = message.destination;\n\n                    if (!!cleanup) {\n                        delete this.messageCleanupCache[typedMessage.cleanupForMessageId];\n                        runExecutorCleanup(cleanup).then(() => {\n                            this.messageToHost(cleanupMessage, typedMessage);\n                        }).catch(() => {\n                            //TODO : handel error?\n                        })\n                    } else {\n                        this.messageToHost(cleanupMessage, typedMessage);\n                    }\n                    return;\n                }\n\n                let actionHandlerFound = false;\n\n                this.supportedHandlers.forEach(handler => {\n                    if (handler.messageType === message.messageType) {\n                        actionHandlerFound = true;\n                        const cleanup = handler.executor(message);\n\n                        if (message.cleanable && cleanup) {\n                            this.messageCleanupCache[message.id] = cleanup;\n                        }\n\n                        if (cleanup && !message.cleanable) {\n                            throw new Error(`Cleanup handler generated for non-cleanable message. \nmessageType - ${message.messageType}, handler executor was - ${handler.executor}\n\nPlease review the message definition object & message handler.\nTo ensure cleanup properly set 'cleanable' true at message definition and return IMessageExecutorCleanup from your handlers.`)\n                        }\n\n                        if (!cleanup && message.cleanable) {\n                            throw new Error(`No cleanup handler generated for a cleanable message. \nmessageType - ${message.messageType}, handler executor was - ${handler.executor}\n\nPlease review the message definition object & message handler.\nTo ensure cleanup properly set 'cleanable' true at message definition and return IMessageExecutorCleanup from your handlers.`)\n                        }\n                    }\n                })\n\n                if (!actionHandlerFound) {\n                    //TODO : print with debug config only\n                    //console.log('no message handler was found for ', message)\n                }\n            } else {\n                console.log('unsupported message type')\n            }\n        }\n    }\n\n    abstract init: () => void;\n}\n", "import {MyopMessageKey} from \"./MyopMessages\";\n\nexport * from './MyopElementRef';\nexport * from './baseMessageHandler';\nexport * from './BaseMyopSDK';\n\nexport type CleanupHandler = () => void\n\nexport type Dictionary<T> = { [key: string]: T; };\n\n//export type SkinLoaderType = 'IframeLoader' | 'WebComponentLoader' | 'HTMLLoader' | string;\n\nexport const SkinLoaders = {\n    \"IframeLoader\": \"IframeLoader\",\n    \"WebComponentLoader\": \"WebComponentLoader\",\n    \"HTMLLoader\": \"HTMLLoader\",\n    \"MinimizedLoader\": \"MinimizedLoader\"\n} as const;\nexport type SkinLoaderType = keyof typeof SkinLoaders;\n\nexport type PropType = 'any' | 'string' | 'number' | string; // TODO : <\nexport type RefSelectorType = 'id-attribute' | 'css-selector' | 'xpath' | string;\n\nexport const LoaderFrameworks = {\n    \"react\": \"react\",\n    \"vue\": \"vue\",\n    \"angular\": \"angular\",\n} as const\nexport type LoaderFrameworkType = keyof typeof LoaderFrameworks;\n\nexport interface IWebComponentLoaderConfig extends ISkinLoaderConfig {\n    type: \"WebComponentLoader\";\n    url: string,\n    tag: string,\n    framework?: LoaderFrameworkType\n}\n\nexport interface IIframeLoaderConfig extends ISkinLoaderConfig {\n    type: \"IframeLoader\";\n    url: string\n    autoHeight: boolean\n    height?: string\n    width?: string\n}\n\nexport const ShadowRootModeType = {\n    \"open\": \"open\",\n    \"closed\": \"closed\",\n    \"none\": \"none\",\n    \"localFrame\": \"localFrame\"\n} as const;\n\n\nexport interface IHTMLLoaderConfig extends ISkinLoaderConfig {\n    type: \"HTMLLoader\";\n    HTML: string;\n    //TODO: rename(rootMode/customElementMode) + db migration\n    shadowRootMode?: keyof typeof ShadowRootModeType;\n    autoHeight?: boolean;\n    height?: string;\n    width?: string;\n    /**\n     * When true, an inline-HTML (localFrame) component is rendered in a sandboxed,\n     * cross-origin iframe with NO access to the host document (untrusted code).\n     * The host render policy can also force this regardless of the config value.\n     */\n    isolation?: boolean;\n}\n\n/**\n * How a component is rendered on the host page, in ascending isolation:\n *  - 'webComponent'   \u2014 custom element on the host document (most privileged)\n *  - 'iframe'         \u2014 same-origin inline-HTML iframe (today's default)\n *  - 'isolatedIframe' \u2014 sandboxed, cross-origin iframe (untrusted code)\n */\nexport type RenderMode = 'webComponent' | 'iframe' | 'isolatedIframe';\n\nexport interface RenderPolicyContext {\n    componentDefinition: IComponentDefinitionConfig;\n    skin: ISkinConfig;\n    /** What the component asked for (marker \u21D2 'webComponent', config.isolation \u21D2 'isolatedIframe'). */\n    requestedMode: RenderMode;\n    /** Whether the HTML carries the `<!-- myop-web-component -->` marker. */\n    isWebComponent: boolean;\n}\n\n/**\n * Host-supplied gate deciding how (or whether) a component renders. Return a\n * RenderMode to use, or `false` to block rendering entirely.\n */\nexport type RenderPolicy =\n    (ctx: RenderPolicyContext) => RenderMode | false | Promise<RenderMode | false>;\n\n//for internal dashboard usage\nexport interface IMinimizedLoaderConfig extends ISkinLoaderConfig {\n    type: \"MinimizedLoader\";\n}\n\ninterface DashboardObject {\n    _temp_client_id?: string,\n}\n\ntype Extend<T, U> = T & U;\n\ntype ExtendRecursively<T, E> = {\n    [K in keyof E]: E[K];\n} & {\n    [K in keyof T]: T[K] extends object\n        ? ExtendRecursively<T[K], E>\n        : T[K];\n};\n\nexport type IDashboard<T> = ExtendRecursively<T, DashboardObject>;\n\nexport interface ISkinLoaderConfig {\n    type: SkinLoaderType\n\n    [key: string]: any; // Allows any additional properties\n}\n\nexport interface v2_IReleaseMetadata {\n    environmentId: string;\n    environmentIdentifier: string;\n    releasedOn?: string;\n    releasedBy?: string;\n}\n\nexport interface v2_IVariantConfig extends v2_IMyopStoredObject {\n    loader: ISkinLoaderConfig\n    componentId: string;\n\n    releases?: v2_IReleaseMetadata[]\n}\n\nexport interface ISkinConfig {\n    id: string\n    name: string\n    description: string\n    loader: ISkinLoaderConfig\n    createdBy?: string\n    createdOn?: string\n}\n\nexport interface v2_ISkinConfig extends ISkinConfig {\n    componentId: string\n}\n\nexport interface IMessagePropConfig extends IPropConfig {\n    type: PropType\n    messageType: MyopMessageKey\n}\n\nexport interface IBindMessagePropConfig extends IPropConfig {\n    type: PropType\n    messageType: MyopMessageKey\n}\n\nexport const PropMessageModes = {\n    \"input\": \"input\",\n    \"output\": \"output\"\n} as const;\n\nexport const PropConfigBehaviorTypes = {\n    \"message\": \"message\",\n    \"code\": \"code\"\n} as const;\n\nexport interface IPropMessageBehaviorParam {\n    value: string\n}\n\nexport interface IPropBehavior {\n    type: keyof typeof PropConfigBehaviorTypes\n}\n\nexport interface IPropCodeBehavior extends IPropBehavior {\n    type: \"code\"\n    remap?: string\n}\n\nexport interface IPropMessageBehavior extends IPropBehavior {\n    type: \"message\"\n    message: MyopMessageKey\n    ref: string, //TODO make it id\n    params: IPropMessageBehaviorParam[]\n    mode: keyof typeof PropMessageModes\n}\n\nexport interface IPropConfig {\n    id: string\n    name: string\n    description: string\n    type: PropType\n    behavior: IPropBehavior\n}\n\n\nexport class RefBehaviorType {\n    static code = 'code' as const\n    static component = 'component' as const\n}\n\nexport type IRefBehaviorType = 'code' | 'component';\n\nexport interface IRefBehavior {\n    type: IRefBehaviorType\n}\n\nexport interface IComponentRefBehavior extends IRefBehavior {\n    type: 'component'\n    componentId: string\n\n    /**\n     * @deprecated\n     * Property instance is deprecated and will be removed in future versions.\n     */\n    instance: IComponentInstanceConfig\n}\n\nexport interface ICodeRefBehavior extends IRefBehavior {\n    type: 'code'\n}\n\nexport interface IRefConfig {\n    id: string\n    name: string\n    description: string\n    selectorType: RefSelectorType\n    selector: string\n    behavior: IRefBehavior\n}\n\n/**\n * Experience segment rule\n */\nexport interface IExperienceSegmentRule {\n    property: string;\n    operator: string;\n    value: string;\n}\n\n/**\n * Experience A/B split version\n */\nexport interface IExperienceABSplitVersion {\n    id: string;\n    percentage: number;\n}\n\n/**\n * Experience A/B split configuration\n */\nexport interface IExperienceABSplit {\n    versions: IExperienceABSplitVersion[];\n}\n\n/**\n * Experience segment configuration\n */\nexport interface IExperienceSegment {\n    id: string;\n    name: string;\n    description: string;\n    rules: IExperienceSegmentRule[];\n    useAb: boolean;\n    componentVariants: Record<string, string | Record<string, string>>;\n    abSplit?: IExperienceABSplit;\n    stickyProperties?: string[];\n}\n\n/**\n * Experience definition config (v2)\n */\nexport interface IExperienceDefinitionConfig extends v2_IMyopStoredObject {\n    /** Selected component IDs */\n    components: string[];\n    /** Segment configurations */\n    segments: IExperienceSegment[];\n    /** Fallback variant per component */\n    fallback: Record<string, string>;\n    /** Tags */\n    tags: string[];\n}\n\nexport interface IComponentDefinitionConfig {\n    id: string;\n    name: string,\n    description: string,\n    // props: Record<string, IPropConfig> //id - type\n    // refs: Record<string, IRefConfig>,\n    // skins: Record<string, ISkinConfig>\n    props: IPropConfig[],\n    refs: IRefConfig[],\n    skins: ISkinConfig[],\n    defaultSkin: number;\n\n    //TODO : think about that\n    //resolvedDefinitions?: IComponentDefinitionConfig[]\n    //TODO : move to base class ( IStorableItem or so...)\n\n    createdOn?: string\n    createdBy?: string\n    updatedBy?: string\n}\n\n\nexport interface v2_IBaseMyopObject {\n    id: string,\n    name: string,\n    description: string,\n}\n\nexport interface v2_IMyopStoredObject extends v2_IBaseMyopObject {\n    updatedOn?: string\n    updatedBy?: string\n}\n\nexport interface ComponentAccess {\n    visibility: 'private' | 'unlisted' | 'public';\n    unlisted?: {\n        slug: string;\n    };\n    marketplace?: {\n        status: 'draft' | 'submitted' | 'claimed' | 'closed';\n        description: string;\n        contactEmail: string;\n        deadline: string;\n    };\n}\n\nexport interface v2_IComponentDefinitionConfig extends v2_IMyopStoredObject {\n    variants_ids: string[],\n    DTOs: v2_IDTO[],\n    tags: string[],\n    access?: ComponentAccess,\n\n    //\n    variants_names: string[],\n    variants_data: {\n        name: string;\n        id: string\n        description?: string\n        updatedOn?: string\n        updatedBy?: string\n        has_releases?: boolean\n    }[],\n\n    preview_variant: v2_IVariantConfig;\n    extra?: {\n        firstVariant: v2_IVariantConfig; //when new component creates at the client\n    }\n}\n\nexport interface v2_IDTO extends v2_IMyopStoredObject {\n    data: object\n    methodName: string\n}\n\nexport interface ISkinInstanceConfig {\n    id: string\n}\n\nexport interface ISkinSelectorConfig {\n    type: keyof typeof SkinSelectorTypes,\n    //skins: ISkinInstanceConfig[]\n}\n\nexport const SegmentType = {\n    \"FunctionResult\": \"FunctionResult\",\n} as const;\n\nexport interface ISegmentInstance {\n    segmentId: string;\n    skinSelector: ISkinSelectorConfig\n}\n\nexport interface ISegmentDefinition {\n    id: string;\n    type: keyof typeof SegmentType\n}\n\nexport interface IFunctionResultsSegment extends ISegmentDefinition {\n    id: string;\n    type: typeof SegmentType.FunctionResult\n    name: string\n    description: string\n    function: string\n}\n\nexport const SkinSelectorTypes = {\n    \"Segmented\": \"Segmented\",\n    \"Dedicated\": \"Dedicated\",\n\n    /**\n     * This Selector Type is not yet supported but will be added in a future release.\n     * Please check the documentation for updates.\n     *\n     * @type {string}\n     */\n    \"Default\": \"Default\"\n} as const;\n\n\n/**\n * This Skin Config Type is not yet supported but will be added in a future release.\n * Please check the documentation for updates.\n *\n * @type {IDefaultSkinConfig}\n */\nexport interface IDefaultSkinConfig extends ISkinSelectorConfig {\n    type: typeof SkinSelectorTypes.Default,\n}\n\nexport interface ISegmentedSkinConfig extends ISkinSelectorConfig {\n    type: typeof SkinSelectorTypes.Segmented,\n    segments: ISegmentInstance[]\n}\n\nexport interface IDedicatedSkinConfig extends ISkinSelectorConfig {\n    type: typeof SkinSelectorTypes.Dedicated,\n\n    /**\n     * @deprecated Use {@link skin} instead.\n     * Property skins is deprecated and will be removed in future versions.\n     * Please update your code to use {@link skin} for better compatibility.\n     *\n     * @type {string}\n     */\n    skins?: ISkinInstanceConfig[] // deprecated\n    skin: ISkinInstanceConfig\n}\n\nexport interface IComponentInstanceConfig {\n    id: string;\n    componentId: string;\n\n    //TODO :\n    // RefID ? to support more than 1 component from the same type in composites ?\n\n    //TODO : remove\n    componentName: string; // << check\n\n    skinSelector: ISkinSelectorConfig\n\n    // storing the nested config for ref components\n    nestedComponents?: IComponentInstanceConfig[]\n\n    //only on GET?\n    //TODO : think about that\n    resolvedExperiences?: IExperience[]\n    // will include instance and def config in order to render in production\n    resolvedNestedComponents?: IComponentConfig[]\n}\n\nexport const ExperienceTypes = {\n    \"Segment\": \"Segment\",\n    \"Promo\": \"Promo\",\n    \"AB\": \"AB\"\n} as const;\n\nexport interface IExperience {\n    id: string\n    name: string\n    description: string\n    type: keyof typeof ExperienceTypes\n    experiences: IExperience[]\n    //stickinessFactor\n    //EndDate\n}\n\n// export interface IABExperienceGroup {\n//     id: string\n//     name: string\n//     percentage: number\n// }\n\nexport interface IABExperience extends IExperience {\n    type: typeof ExperienceTypes.AB\n    // groups: IABExperienceGroup[]\n    experiences: IExperience[]\n    percentage: number\n}\n\nexport interface IDateRange {\n    id: string\n    start: Date\n    end: Date\n    timezone: string\n}\n\nexport interface ISegmentExperience extends IExperience {\n    type: keyof typeof ExperienceTypes\n    segment: ISegmentDefinition\n    dateRange?: IDateRange\n}\n\nexport interface IUserFlowDefinition {\n    id: string;\n    name: string;\n    description: string;\n    components: IComponentInstanceConfig[];\n    origins: string[],\n    experiences: IExperience[]\n    branch?: string\n}\n\nexport interface IComponentConfig {\n    instance: IComponentInstanceConfig\n    type: IComponentDefinitionConfig\n\n    // TODO : verify uniqueness (dashboard & server)\n    name: string\n}\n\ninterface IBranchable {\n    branch?: string\n}\n\nexport interface IUserFlow extends Omit<IUserFlowDefinition, 'components'>, IBranchable {\n    components: IComponentConfig[]\n}\n\nexport class RootRef {\n    constructor(public container: HTMLElement, public shadowRoot?: ShadowRoot) {\n\n    }\n\n    getRootDiv = () => {\n        return (this.shadowRoot || this.container).querySelector('div')\n    }\n\n    getRoot = () => {\n        return (this.shadowRoot || this.container);\n    }\n}\n", "export type Serializable<T> =\n    T extends Function ? never : // Exclude functions\n        T extends Array<infer U> ? Serializable<U>[] : // Handle arrays\n            T extends object ? {\n                [K in keyof T as T[K] extends Function ? never : K]: Serializable<T[K]>\n            } : T; // Handle objects\n\nconst isPrimitive = (value) => {\n    return value !== Object(value);\n}\n\nconst isFunction = (value) => {\n    return typeof value === 'function';\n}\n\nexport const containsPrimitivesOnly = (obj) => {\n    if (isPrimitive(obj)) {\n        return true;\n    }\n\n    if (isFunction(obj)) {\n        return false\n    }\n\n    if (Object.getPrototypeOf(obj)) {\n        return false\n    }\n\n    for (const key in obj) {\n        const value = obj[key];\n        if (typeof value === 'object') {\n            // Recursively check if it's a nested object\n            if (!containsPrimitivesOnly(value)) {\n                return false;\n            }\n        } else if (isPrimitive(value)) {\n            continue; // It's a primitive, so we can skip it\n        } else {\n            return false; // Found a non-primitive value\n        }\n    }\n\n    return true; // All values are primitives or nested objects with primitives\n}\n\n// currently support root level only\n// {x: 1, y : 'a', z : ()=>{...}, inner : { x: 1 , y : 'a'} }\n// {x: 1, y : 'a'}\n//https://developer.mozilla.org/en-US/docs/Glossary/Falsy\nexport type SerializableSkeleton<T> = Partial<Record<keyof T, boolean | Partial<Record<string, boolean>>>> | boolean;\n\nexport const makeSerializable = <T>(\n    obj: T,\n    skeleton: SerializableSkeleton<T> = {},\n    includeFalsyKeys: boolean = true, // TODO : use that arg\n    seen: WeakMap<object, Serializable<any>> = new WeakMap()\n): Serializable<T> => {\n\n    if (isPrimitive(obj)) {\n        return obj as Serializable<T>; // Directly return primitive values\n    }\n\n    if (Array.isArray(obj)) {\n        if (seen.has(obj)) {\n            return seen.get(obj)!; // Return the already processed object\n        }\n\n        // Handle array serialization\n        const serializableArray: Serializable<any>[] = [];\n        seen.set(obj, serializableArray); // Store the array in seen\n\n        for (let index = 0; index < obj.length; index++) {\n            const element = obj[index];\n            serializableArray[index] = makeSerializable(element, skeleton, includeFalsyKeys, seen);\n        }\n        return serializableArray as Serializable<T>;\n    }\n\n    if (obj !== null && typeof obj === 'object') {\n        // Check for cyclic references\n        if (seen.has(obj)) {\n            return seen.get(obj)!; // Return the already processed object\n        }\n        const serializableObject: Partial<Serializable<T>> = {};\n        seen.set(obj, serializableObject); // Store the object in seen\n\n        for (const key in obj) {\n            // Check if the key is in the skeleton and if it's a valid key to serialize\n\n            const keyInSkeleton = typeof skeleton == \"boolean\" ? skeleton : skeleton[key];\n\n            if (keyInSkeleton) {\n                if (keyInSkeleton === true) {\n                    // If the skeleton indicates to serialize this key\n                    if (includeFalsyKeys ? obj[key] !== undefined : obj[key]) {\n                        // @ts-ignore\n                        serializableObject[key] = makeSerializable(obj[key], true, includeFalsyKeys, seen);\n                    }\n                } else if (typeof keyInSkeleton === 'object') {\n                    // If the skeleton indicates nested keys to serialize\n                    // @ts-ignore\n                    serializableObject[key] = makeSerializable(obj[key], keyInSkeleton, includeFalsyKeys, seen);\n                }\n            }\n        }\n        return serializableObject as Serializable<T>;\n    }\n\n    return {} as any; // Return an empty object for other cases\n}\n", "export const Errors = {\n    notSerializableRefCall: (prop, arg) => {\n        throw new Error(`\nThe input provided to '${prop.toString()}' is not serializable. Serialization is required to ensure that the data can be safely transferred to the skin implementation. \nThe following types of data are considered non-serializable and cannot be processed:\n\n- Functions\n- DOM elements\n- Class instances\n- Circular references\n- Symbols\n- BigInt values\n\nIn the following execution we detected :\n~~~~~~~~\n${arg} \n~~~~~~~~\nas not serializable.\n\nTo resolve this issue, please ensure that all inputs passed to '${prop.toString()}' are in a serializable format.\nThis typically includes primitive types (strings, numbers, booleans), arrays, and plain objects. \nIf you need to include complex data types, consider converting them to a serializable structure before passing them to the function.\nOr use Myop message that support it: CustomRefMessage, AddEventListenerMessage or ExecuteScriptMessage.\n\nSuggested Fix:\n1. Remove or replace non-serializable values from your input.\n2. If using objects, ensure they do not contain any functions or circular references.\n3. Convert any class instances to plain objects or JSON-compatible formats.\n4. Use dedicated Myop message.\n\nFor more details on serialization and Myop message examples, refer to https://docs.myop.dev\\.\n\n`);\n    }\n}\n\n", "import {BaseMyopComponent, IMyopComponent} from \"./IMyopComponent\";\nimport {BaseMyopMessage, ExecuteComponentMethod} from \"../../messages\";\nimport {IComponentDefinitionConfig} from \"../../common\";\nimport {EnvelopedMessage} from \"../../messages/EnvelopedMessage\";\nimport {loaderOptions} from \"../hostSDK.ts\";\n\nexport class MyopRefComponent extends BaseMyopComponent {\n\n    constructor(public componentDefinition: IComponentDefinitionConfig, public parent: IMyopComponent, options?: loaderOptions) {\n        //TODO : check parentComponent.container...\n        super(componentDefinition, parent.container, options);\n    }\n\n    hide() {\n        //this.send(new ExecuteComponentMethod(arguments.callee.name));\n        this.send(new ExecuteComponentMethod('hide'));\n    }\n\n    show() {\n        this.send(new ExecuteComponentMethod('show'));\n    }\n\n    inspect() {\n        //TODO : support real cleanup\n        //console.log('ref inspect called, creating ExecuteComponentMethod inspect', document.location.href, this.id);\n        return this.send(new ExecuteComponentMethod('inspect'));\n    }\n\n    setHeightBasedOnDocumentElement() {\n        // @ts-ignore\n        this.send(new ExecuteComponentMethod('setHeightBasedOnDocumentElement'));\n    }\n\n    setHeightBasedOnScrollHeight() {\n        // @ts-ignore\n        this.send(new ExecuteComponentMethod('setHeightBasedOnScrollHeight'));\n    }\n\n    onMessageReceived(incomeMessage: BaseMyopMessage): boolean {\n        // if (incomeMessage.messageType === 'MutationObserverMessage') {\n        //  debugger;\n        //     this.setHeightBasedOnScrollHeight();\n        //     return true;\n        // }\n        return super.onMessageReceived(incomeMessage);\n    }\n\n\n    send = (message: BaseMyopMessage) => {\n        //console.log('ref message sending ', message);\n        // @ts-ignore\n        const handler = message.handler\n        const cleanupHandler = super.send(message);\n\n        // this.id will be available on the nested component\n        this.parent.send(new EnvelopedMessage(this.id, message));\n\n        // @ts-ignore\n        message.handler = handler\n        return cleanupHandler;\n    };\n\n    dispose = () => {\n        if (this.isInitiated)\n            this.send(new ExecuteComponentMethod('dispose'));\n        super.dispose();\n    }\n}\n", "import {BaseMyopComponent} from \"./IMyopComponent\";\nimport {BaseMyopMessage} from \"../../messages\";\nimport {CleanupHandler, IComponentDefinitionConfig, ISkinConfig} from \"../../common\";\nimport {setDebugStyle} from \"../componentCore\";\nimport {loaderOptions} from \"../hostSDK\";\n\n/**\n * Component wrapper for Myop Web Components that are extracted from HTML\n * and run directly on the host document (not in an iframe).\n *\n * These components use the native Web Components API (Custom Elements + Shadow DOM)\n * and communicate via direct method calls and CustomEvents instead of postMessage.\n */\nexport class MyopExtractedWebComponent extends BaseMyopComponent {\n    private ctaCleanup?: () => void;\n    private _ctaHandler?: (action: string, payload: unknown) => void;\n    private _ctaQueue: Array<{action: string, payload: unknown}> = [];\n\n    // A single 'myop-cta' listener, attached at construction so CTAs a component\n    // dispatches during its first initWithData() render \u2014 before the host attaches\n    // a handler \u2014 are buffered (and flushed on setCtaHandler), matching the iframe\n    // path's pre-handler CTA queue.\n    private _ctaListener = (e: Event) => {\n        const detail = (e as CustomEvent).detail;\n        if (!detail?.action) return;\n        if (this._ctaHandler && !this.markedForDisposed) {\n            this._ctaHandler(detail.action, detail.payload);\n        } else if (!this._ctaHandler) {\n            this._ctaQueue.push({ action: detail.action, payload: detail.payload });\n        }\n    };\n\n    constructor(\n        componentDefinition: IComponentDefinitionConfig,\n        skin: ISkinConfig,\n        public container: HTMLElement,\n        private customElement: HTMLElement,\n        private tagName: string,\n        options?: loaderOptions\n    ) {\n        super(componentDefinition, container, options);\n        this.element = customElement;\n\n        // Listen BEFORE any initWithData render so init-time CTAs aren't lost.\n        this.customElement.addEventListener('myop-cta', this._ctaListener);\n        this.ctaCleanup = () => this.customElement.removeEventListener('myop-cta', this._ctaListener);\n\n        // Web components are initiated immediately (no postMessage handshake needed)\n        this.setInitiated();\n    }\n\n    cleanupInspect: CleanupHandler = () => {};\n\n    inspect() {\n        this.cleanupInspect = setDebugStyle(this.id, 'MyopExtractedWebComponent', 0, this.container, this.customElement, this.componentDefinition);\n        return this.cleanupInspect;\n    }\n\n    hide() {\n        this.customElement.style.opacity = '0';\n        this.customElement.style.position = 'absolute';\n        this.customElement.style.pointerEvents = 'none';\n        this.customElement.style.visibility = 'hidden';\n        this.customElement.style.height = '0';\n        this.customElement.style.width = '0';\n    }\n\n    show() {\n        this.customElement.style.opacity = '1';\n        this.customElement.style.position = 'unset';\n        this.customElement.style.pointerEvents = 'all';\n        this.customElement.style.visibility = 'visible';\n        this.customElement.style.height = '';\n        this.customElement.style.width = '';\n    }\n\n    /**\n     * Initialize the component with data by calling myop_init_interface directly\n     */\n    initWithData(data: unknown): void {\n        if (typeof (this.customElement as any).myop_init_interface === 'function') {\n            (this.customElement as any).myop_init_interface(data);\n        }\n    }\n\n    /**\n     * Get current data from the component\n     */\n    getData(): unknown {\n        if (typeof (this.customElement as any).myop_init_interface === 'function') {\n            return (this.customElement as any).myop_init_interface();\n        }\n        return undefined;\n    }\n\n    /**\n     * Set CTA handler - unified API with iframe components.\n     * Called via props.myop_cta_handler = handler\n     */\n    setCtaHandler(handler: (action: string, payload: unknown) => void): void {\n        // The 'myop-cta' listener is attached in the constructor, so we only set the\n        // handler and flush anything the component emitted before now (e.g. during the\n        // first initWithData render).\n        this._ctaHandler = handler;\n\n        if (this._ctaQueue.length > 0) {\n            const queue = [...this._ctaQueue];\n            this._ctaQueue = [];\n            queue.forEach(item => {\n                if (!this.markedForDisposed) {\n                    handler(item.action, item.payload);\n                }\n            });\n        }\n    }\n\n    /**\n     * For compatibility with message-based components.\n     * Web components don't use postMessage, so this is a no-op for most messages.\n     */\n    send = (message: BaseMyopMessage<any>) => {\n        // Web components don't use the postMessage system\n        // Instead, interact directly via props.myop_init_interface and props.myop_cta_handler\n        const cleanupHandler = super.send(message);\n\n        // Log for debugging\n        console.debug('[MyopExtractedWebComponent] send() called - web components use direct API instead', message);\n\n        return cleanupHandler;\n    }\n\n    dispose = () => {\n        if (this.ctaCleanup) {\n            this.ctaCleanup();\n        }\n        super.dispose();\n        this.customElement.parentNode?.removeChild(this.customElement);\n    }\n}\n", "//type AConstructorTypeOf<T> = new (...args: any[]) => T;\nimport {IMyopComponent} from \"./components/IMyopComponent\";\nimport {CreateRefComponentMessage, CustomRefMessage, Ref} from \"../messages\";\nimport * as messages from \"../messages\";\nimport {\n    CleanupHandler, IComponentConfig,\n    type IComponentDefinitionConfig,\n    IComponentRefBehavior, IHTMLLoaderConfig, IPropCodeBehavior,\n    IPropConfig, ISkinConfig, PropConfigBehaviorTypes,\n    RefBehaviorType, ShadowRootModeType, SkinLoaders, SkinLoaderType\n} from \"../common\";\nimport {containsPrimitivesOnly} from \"../common/utils/serialization\";\nimport {Errors} from \"./logMessages\";\nimport {MyopRefComponent} from \"./components/myopRefComponent\";\nimport {MyopExtractedWebComponent} from \"./components/myopExtractedWebComponent\";\nimport {MyopIframeComponent} from \"./components/myopIframeComponent\";\nimport {loaderOptions} from \"./hostSDK\";\n\ntype componentDefinitionProps = IComponentDefinitionConfig['props']\n\nconst createDebugTitle = (text: string, top: number, componentDefinitionConfig: IComponentDefinitionConfig) => {\n    const titleEl = document.createElement('a');\n    titleEl.textContent = text;\n    titleEl.style.position = 'relative';\n    titleEl.style.padding = '0 5px';\n    titleEl.style.fontSize = '14px';\n    titleEl.style['top'] = '0';\n    titleEl.style.top = `${top}px`;\n    //titleEl.style.left = '50%';\n    titleEl.style.transform = 'translateX(-50%)';\n    titleEl.target = '_blank';\n    titleEl.href = `https://dashboard.myop.dev/dashboard/component/${componentDefinitionConfig.id}`\n\n    return titleEl;\n};\n\nexport const setDebugStyle = (id: string,\n                              type: string,\n                              top: number,\n                              container: HTMLElement,\n                              componentElement: HTMLElement,\n                              componentDefinitionConfig: IComponentDefinitionConfig\n): CleanupHandler => {\n    //#007BFF (blue) or #FF5722 (orange)\n    //#4CAF50 (green) or #FFC107 (amber)\n    // const topText = createDebugTitle(`${id} : ${type}`, top, componentDefinitionConfig);\n    const topText = createDebugTitle(`${componentDefinitionConfig.name} : ${type}`, top, componentDefinitionConfig);\n    container.insertBefore(topText, componentElement);\n    componentElement.style.border = '1px solid #007BFF';\n    componentElement.style.display = 'block';\n\n    return () => {\n        componentElement.style.border = 'unset';\n        container.removeChild(topText);\n    }\n}\n\nconst reportError = (propConfig: IPropConfig, propName: string, component: IMyopComponent<any, any>) => {\n    if (!propConfig) {\n\n        console.error(\n            // throw new Error(\n            `Error: Undefined Prop\\n\\n` +\n            `It looks like you've tried to use a prop that hasn't been defined.\\n` +\n            `Please check the prop name for any typos or ensure that it is properly defined in the component's prop list.\\n\\n` +\n            `Prop Name: ${propName}\\n` +\n            `Component: ${component.componentDefinition.name}, ID: ${component.componentDefinition.id}\\n\\n` +\n            `For more information, refer to the component page https://dashboard.myop.dev/dashboard/component/${component.componentDefinition.id} or consult the developer guide.`\n        );\n        return true\n    }\n    return false\n}\n\nconst reportUnsupported = (propConfig: IPropConfig, propName: string, component: IMyopComponent<any, any>) => {\n    console.error(\n        `Error: Code Prop Not Supported\\n\\n` +\n        `Currently, code props are only supported in local frame components.\\n` +\n        `\u26A0\uFE0F This is a work in progress feature \u2014 code props will be supported in upcoming versions.\\n\\n` +\n        `In the meantime, you can use message props.\\n\\n` +\n        `Prop Name: ${propName}\\n` +\n        `Component: ${component.componentDefinition.name}, ID: ${component.componentDefinition.id}\\n\\n` +\n        `For more information, refer to the component page https://dashboard.myop.dev/dashboard/component/${component.componentDefinition.id} or consult the developer guide.`\n    );\n}\n\nexport const connectProps = <T extends componentDefinitionProps>(component: IMyopComponent, propsConfig: IPropConfig[], selectedSkin: ISkinConfig) => {\n\n    const propsMap = propsConfig.reduce((previousValue, currentValue) => {\n        return {\n            ...previousValue,\n            [currentValue.name]: {...currentValue}\n        }\n    }, {});\n\n    const propsHandler = {\n        get: (_: IMyopComponent, prop: string) => {\n            // @ts-ignore\n            const propConfig = propsMap[prop];\n\n            if (reportError(propConfig, prop, component)) {\n                return false;\n            }\n\n            if (propConfig.behavior.type === PropConfigBehaviorTypes.code) {\n                // Check for extracted web components FIRST\n                if (component instanceof MyopExtractedWebComponent) {\n                    const typedPropBehavior = propConfig.behavior as IPropCodeBehavior;\n                    const propName = typedPropBehavior.remap || prop;\n\n                    if (propName === 'myop_init_interface') {\n                        // Return a function that gets/sets data (matches iframe behavior)\n                        return (data?: unknown) => {\n                            if (data === undefined) {\n                                return component.getData();\n                            }\n                            component.initWithData(data);\n                        };\n                    }\n\n                    // For myop_cta_handler, return undefined (it's write-only)\n                    return undefined;\n                }\n\n                // Isolated iframe: no same-origin access \u2014 use the postMessage bridge\n                // (same method surface as the extracted-WC branch above).\n                if (component instanceof MyopIframeComponent && component.isolated) {\n                    const typedPropBehavior = propConfig.behavior as IPropCodeBehavior;\n                    const propName = typedPropBehavior.remap || prop;\n                    if (propName === 'myop_init_interface') {\n                        return (data?: unknown) => {\n                            if (data === undefined) return component.getData();\n                            component.initWithData(data);\n                        };\n                    }\n                    return undefined; // myop_cta_handler is write-only\n                }\n\n                // For iframe (localFrame) components\n                if (selectedSkin.loader.type === SkinLoaders.HTMLLoader) {\n                    const typedLoader = selectedSkin.loader as IHTMLLoaderConfig;\n                    if (typedLoader.shadowRootMode === ShadowRootModeType.localFrame) {\n                        const typedPropBehavior = propConfig.behavior as IPropCodeBehavior;\n                        // @ts-ignore\n                        return component.element.contentWindow[typedPropBehavior.remap || prop]\n                    }\n                }\n\n                reportUnsupported(propConfig, prop, component);\n                return false;\n            }\n\n            if (propConfig.mode === 'output') {\n                return new Promise((resolve) => {\n                    const messageParams: any[] = [];\n                    //TODO : turn it into config\n                    if (propConfig.behavior.ref) {\n                        messageParams.push(Ref.create(propConfig.behavior.ref));\n                    }\n\n                    messageParams.push((data: any) => {\n                        resolve(data);\n                    });\n\n                    if (propConfig.behavior.params) {\n                        messageParams.push(...propConfig.behavior.params);\n                    }\n\n                    // @ts-ignore\n                    const messageCtor = messages[propConfig.behavior.message];\n\n                    component.send(new messageCtor(...messageParams));\n                })\n            }\n            return null\n        },\n        set: (_: IMyopComponent, prop: string, value: any) => {\n            // @ts-ignore\n            const propConfig = propsMap[prop];\n\n            if (reportError(propConfig, prop, component)) {\n                return false;\n            }\n\n            if (propConfig.behavior.type === PropConfigBehaviorTypes.code) {\n                // Check for extracted web components FIRST (before localFrame check)\n                // because extracted web components may have shadowRootMode: localFrame in their config\n                // but they run directly on the host document, not in an iframe\n                if (component instanceof MyopExtractedWebComponent) {\n                    const typedPropBehavior = propConfig.behavior as IPropCodeBehavior;\n                    const propName = typedPropBehavior.remap || prop;\n\n                    if (propName === 'myop_cta_handler') {\n                        component.setCtaHandler(value);\n                        return true;\n                    }\n\n                    if (propName === 'myop_init_interface') {\n                        component.initWithData(value);\n                        return true;\n                    }\n                }\n\n                // Isolated iframe: route via the postMessage bridge (no same-origin access).\n                if (component instanceof MyopIframeComponent && component.isolated) {\n                    const typedPropBehavior = propConfig.behavior as IPropCodeBehavior;\n                    const propName = typedPropBehavior.remap || prop;\n                    if (propName === 'myop_cta_handler') { component.setCtaHandler(value); return true; }\n                    if (propName === 'myop_init_interface') { component.initWithData(value); return true; }\n                }\n\n                // For iframe (localFrame) components\n                if (selectedSkin.loader.type === SkinLoaders.HTMLLoader) {\n                    const typedLoader = selectedSkin.loader as IHTMLLoaderConfig;\n                    if (typedLoader.shadowRootMode === ShadowRootModeType.localFrame) {\n                        const typedPropBehavior = propConfig.behavior as IPropCodeBehavior;\n                        const contentWindow = (component.element as HTMLIFrameElement).contentWindow as any;\n                        const propName = typedPropBehavior.remap || prop;\n\n                        // Set the real handler\n                        contentWindow[propName] = value;\n\n                        // Flush CTA queue if this is myop_cta_handler and queue exists\n                        if (propName === 'myop_cta_handler' && contentWindow.__myop_cta_queue) {\n                            const queue = contentWindow.__myop_cta_queue;\n                            contentWindow.__myop_cta_queue = null; // Clear to prevent double-flush\n                            queue.forEach((item: {action: string, payload: any}) => {\n                                // Skip if component was disposed during flush\n                                if (component.markedForDisposed) return;\n                                value(item.action, item.payload);\n                            });\n                        }\n\n                        return true\n                    }\n                }\n\n                reportUnsupported(propConfig, prop, component);\n                return false;\n            } else {\n                //if(propConfig.behavior === PropConfigBehaviorTypes.message)\n                if (propConfig.mode === 'input') {\n                    //TODO : support multi behaviors\n\n                    if (propConfig.behavior.type === 'message') {\n                        const messageParams: any[] = [];\n                        //TODO : turn it into config\n                        if (propConfig.behavior.ref) {\n                            messageParams.push(Ref.create(propConfig.behavior.ref));\n                        }\n                        messageParams.push(value);\n                        if (propConfig.behavior.params) {\n                            messageParams.push(...propConfig.behavior.params);\n                        }\n\n                        // @ts-ignore\n                        const messageCtor = messages[propConfig.behavior.message];\n                        component.send(new messageCtor(...messageParams));\n                        return true\n                    } else {\n                        throw new Error(\n                            `Error: Unsupported Behavior\\n\\n` +\n                            `The 'behavior' field provided is not supported.\\n` +\n                            `Component: ${component.componentDefinition.name}, ID: ${component.componentDefinition.id}\\n\\n` +\n                            `Prop Name: ${prop}\\n` +\n                            `Behavior Field: ${propConfig.behavior.type}\\n\\n` +\n                            `Check the documentation for valid behavior options.`\n                        );\n\n                        return false\n                    }\n                }\n            }\n            return false\n        }\n    }\n\n    component.props = {};\n    component.props = new Proxy(component.props, propsHandler);\n\n    return component as (Omit<IMyopComponent, 'props'> & {\n        props: propTypes<T>\n    })\n}\n\nexport const createRefProxy = (target: Ref, component: IMyopComponent) => {\n    return new Proxy(target, {\n        get(target, prop) {\n\n            // if (prop === '__nonProxied') {\n            //     return target;\n            // }\n\n            // @ts-ignore\n            if (target[prop]) {\n                // @ts-ignore\n                return target[prop];\n            }\n\n            // @ts-ignore\n            const getterFunction = (...args) => {\n                return new Promise((resolve) => {\n                    args.forEach(arg => {\n                        if (!containsPrimitivesOnly(arg)) {\n                            Errors.notSerializableRefCall(prop, arg);\n                        }\n                    });\n                    component.send(new CustomRefMessage(({ref, propName, functionArgs, makeSerializable}) => {\n                            if (ref) {\n                                // @ts-ignore\n                                const value = ref[propName];\n                                if (typeof value === 'function') {\n                                    // @ts-ignore\n                                    return makeSerializable(ref[propName](...functionArgs), true) // Invoke the function and return its result\n                                } else {\n                                    // @ts-ignore\n                                    return makeSerializable(value, true); // Return the property value\n                                }\n                            }\n                            return null;\n                        },\n                        {\n                            //TODO : turn it to config\n                            elementId: target.refConfig.selector,\n                            propName: prop,\n                            functionArgs: args\n                        },\n                        (msg) => {\n                            resolve(msg.content);\n                        }))\n                });\n            };\n\n            //TODO: we can implement things like auto serialization and binding functions here\n            //getterFunction.test = '123';\n\n            return getterFunction;\n\n            //return Reflect.get(target, prop);\n        },\n        set(target, prop: string, value) {\n            component.send(new CustomRefMessage(({ref, propName, propValue}) => {\n                    if (ref)\n                        // @ts-ignore\n                        ref[propName] = propValue;\n                },\n                {\n                    //TODO : fix that\n                    elementId: target.refConfig.selector,\n                    propValue: value,\n                    propName: prop\n                },\n                (msg) => {\n                    //TODO : log?\n                }))\n            return true;\n        },\n    });\n}\n\nexport const createRefComponent = async <T extends IMyopComponent = IMyopComponent>(ref: Ref, componentConfig: IComponentConfig, components: IMyopComponent[], options?: loaderOptions): Promise<T> => {\n    const component = ref.component;\n    if (!component)\n        throw new Error('cant createRefComponent with detached ref');\n\n    //console.log('createRefComponent called', ref, componentConfig);\n\n    return new Promise(async (resolve, reject) => {\n        const refComponent = new MyopRefComponent(componentConfig.type, component, options);\n        components.push(refComponent);\n\n        //for cases where ref components define in the component config\n        // we need to wait for the root component the be initiated before interacting with it\n        await component.initiated();\n\n\n        //TODO :\n        const timeout = setTimeout(() => {\n            //reject('timeout?');\n            reject('timeout');\n        }, 5000);\n\n        component.send(new CreateRefComponentMessage(ref.refConfig,\n            componentConfig,\n            {\n                ...options ? options : {},\n                id: refComponent.id,\n                _hasParent: true\n            },\n            async (message) => {\n\n                //TODO : check if timeout already passed\n                clearTimeout(timeout);\n\n                if (message.failed) {\n                    //TODO :\n                    reject('CreateRefComponentMessage failed');\n                    return;\n                }\n\n                const implementationComponent = components.find(c => c.id == refComponent.id);\n\n                //same memory env, same HostSDK\n                if (implementationComponent !== refComponent) {\n                    //TODO : clean refComponent ?\n\n                    component.refs[ref.refConfig.name] = implementationComponent;\n                    resolve(implementationComponent as unknown as T);\n                    return;\n                } else {\n                    refComponent.setInitiated()\n                    component.refs[ref.refConfig.name] = refComponent;\n                }\n\n                //TODO : here >\n                //TODO : what about reapters ?! dynamic ?!\n                // const exsistingRefComponent = component.refs[ref.refConfig.name] as MyopRefComponent;\n                // if (exsistingRefComponent.id && exsistingRefComponent.parent) {\n                //     component.refs[ref.refConfig.name] = [component.refs[ref.refConfig.name], refComponent];\n                // } else if (Array.isArray(component.refs[ref.refConfig.name])) {\n                //     component.refs[ref.refConfig.name].push(refComponent)\n                // } else {\n                //   component.refs[ref.refConfig.name] = refComponent; //hostSDK.components.find(c => c.id === refComponent.id)!;\n                // }\n\n                //TODO : in webcomponent case the same id will alreday be here, which is good !\n                // name:\n                //     id\n                //     componentDefinitionId\n\n                // for inner components inside ref component :\n                message.nestedRefs.forEach(nestedRefConfig => {\n                    const nestedComponentDefinition = componentConfig.instance.resolvedNestedComponents!.find(c => c.type.id === nestedRefConfig.componentDefinitionId)!.type;\n                    //const nestedComponentDefinition = component.componentDefinition.resolvedDefinitions?.find(def => def.id === nestedRefConfig.componentDefinitionId)!;\n                    // const refConfig = componentConfig.type.refs.find(r => r.name === nestedRefConfig.refName);\n                    // if (!refConfig) {\n                    //     throw new Error('no refConfig found for nested ref');\n                    // }\n\n                    //debugger;\n\n                    const nestedComponent = new MyopRefComponent(nestedComponentDefinition, refComponent);\n                    nestedComponent.setInitiated();\n                    refComponent.refs[nestedRefConfig.refName] = nestedComponent;\n                    components.push(nestedComponent);\n                });\n\n\n                try {\n                    await connectRefs(refComponent, componentConfig, components, true);\n\n                    //TODO :use config check for auto-hight and convert type properly\n                    // @ts-ignore\n                    if (component.setHeightBasedOnScrollHeight)\n                        // @ts-ignore\n                        component.setHeightBasedOnScrollHeight();\n\n                    resolve(refComponent as unknown as T);\n                } catch (e) {\n                    //debugger\n                    reject(e);\n                    // throw e\n                }\n            }));\n    })\n}\n\nexport const connectRefs = async (component: IMyopComponent, componentConfig: IComponentConfig, components: IMyopComponent[], withoutRefComponents: boolean = false) => {\n\n    if (!component.refs)\n        component.refs = {};\n\n    const waitFor = Object.values(component.componentDefinition.refs).map(ref => {\n        return new Promise<void>(async (resolve, reject) => {\n            if (ref.behavior.type == RefBehaviorType.component) {\n                // component.refs[ref.name] =\n\n                if (withoutRefComponents) {\n                    resolve();\n                    return;\n                }\n\n                // component.\n                //TODO : change to get it from the flow\n                let refComponentId = (ref.behavior as IComponentRefBehavior).componentId;\n                if (!refComponentId)\n                    refComponentId = (ref.behavior as IComponentRefBehavior).instance.componentId\n\n                // if (!component.componentDefinition.resolvedDefinitions) {\n                //     reject(new Error('componentConfig provided without resolvedDefinitions check the config object'));\n                //     //throw new Error('componentConfig provided without resolvedDefinitions check the config object');\n                // }\n                // const componentDefinitionConfig = component.componentDefinition.resolvedDefinitions!.find(compdef => compdef.id === refComponentId)!;\n                // //const componentDefinitionConfig = await getComponentDefinitionConfig(componentInstanceConfig.componentId);\n                //\n                // if (!componentDefinitionConfig) {\n                //     reject(new Error('componentConfig provided without resolvedDefinitions check the config object'));\n                //     return;\n                // }\n\n                //TODO: if we have the same component more than once we will need instance id here ...\n                const nestedComponentConfig = componentConfig.instance.resolvedNestedComponents?.find(nestedComponent => nestedComponent.type.id === refComponentId);\n\n                if (!nestedComponentConfig) {\n                    throw new Error('componentConfig provided without nestedComponentConfig check the config object');\n                    return;\n                }\n\n                //const componentInstanceConfig = componentConfig.instance.nestedComponents?.find(componentInstace => componentInstace.componentId === componentDefinitionConfig.id);\n                // if(!componentDefinitionConfig){\n                //     throw new Error('TODO TODO TODO ');\n                //     return;\n                // }\n\n                //TODO :think about that :\n                //   componentDefinitionConfig.resolvedDefinitions = component.componentDefinition.resolvedDefinitions;\n                //   const nestedComponentConfig: IComponentConfig = {\n                //       instance: nestedComponentConfig.instance!,\n                //       type: nestedComponentConfig.type,\n                //       name: nestedComponentConfig.name\n                //   }\n\n                const _ref = Ref.create('', ref, component);\n\n                try {\n                    //console.log('nested !! createRefComponent called');\n                    const nestedComponent = await createRefComponent(_ref, nestedComponentConfig!, components)\n                    //TDOO : put that ref component somewhere?\n\n                    // debugger;\n                    component.refs[ref.name] = nestedComponent;\n\n                    resolve();\n                } catch (e) {\n                    reject(e);\n                }\n            } else {\n                try {\n                    const __nonProxied = Ref.create('', ref, component);\n                    component.refs[ref.name] = createRefProxy(__nonProxied, component);\n                    resolve();\n                } catch (e) {\n                    //alert('?')\n                }\n            }\n        })\n    })\n    try {\n        await Promise.all(waitFor);\n    } catch (e) {\n        //debugger\n        throw e;\n    }\n\n}\n\nexport type propTypes<T extends componentDefinitionProps> = {\n    [Property in keyof T]:\n    T[Property] extends { mode: 'input' } ?\n        T[Property]['type'] :\n        Promise<T[Property]['type']>\n}\n\nexport const exec = async (getter: any) => {\n    return await getter()\n}\n\nexport const actAs = <T>(ref: Ref) => {\n    return ref as unknown as FunctionifyRef<T>\n}\n\nexport type FunctionifyRef<T = any> = {\n    [K in keyof T]: T[K] extends (...args: infer A) => infer R // If it's a function\n        ? (...args: A) => Promise<R> // Convert it to a promised function\n        : T[K]\n};\n", "import {AutoSizeOptions, BaseMyopComponent} from \"./IMyopComponent\";\nimport {\n    BaseMyopMessage,\n    ExecuteComponentMethod,\n    ExecuteScriptMessage, MessageDirection\n} from \"../../messages\";\nimport {CleanupHandler, IComponentDefinitionConfig, ISkinConfig} from \"../../common\";\nimport {setDebugStyle} from \"../componentCore\";\nimport {MyopMessages} from \"../../common/MyopMessages.ts\";\nimport {loaderOptions} from \"../hostSDK.ts\";\n\nexport class MyopIframeComponent extends BaseMyopComponent {\n\n    private _autoSizeCleanup?: CleanupHandler;\n    private _autoSizeOptions?: AutoSizeOptions;\n    private _autoSizeUpdate?: () => void;\n\n    // \u2500\u2500 Isolation (sandboxed cross-origin frame) \u2014 postMessage bridge, host side \u2500\u2500\n    public isolated = false;\n    private _lastData?: unknown;               // cached last-sent data (sync getData)\n    private _ctaHandler?: (action: string, payload: unknown) => void;\n    private _ctaQueue: Array<{ action: string, payload: unknown }> = [];\n    private _isoMsgHandler?: (e: MessageEvent) => void;\n    private _isoSizeOpts?: AutoSizeOptions;\n    private _isoAutoSize = false;                               // bridge sizing only when auto-size is on\n    private _isoLastSize?: { height: number, width?: number };  // last reported size (for the enable race)\n\n    constructor(public componentConfig: IComponentDefinitionConfig, skin: ISkinConfig, public container: HTMLElement, private IframeElement: HTMLIFrameElement, options?: loaderOptions) {\n        super(componentConfig, container, options)\n\n        this.element = this.IframeElement;\n        this._lastData = options?.data;\n        // this.IframeElement.addEventListener('error', () => {\n        //     if (this._whenInitiatedReject)\n        //         this._whenInitiatedReject(`IframeElement error`);\n        // });\n    }\n\n    sizeMeta?: { width?: string | number; height?: string | number; minWidth?: number; maxWidth?: number; minHeight?: number; maxHeight?: number } | null;\n\n    // \u2500\u2500 Isolation bridge (host side) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    /** Attach the host-side postMessage listener for a sandboxed frame. */\n    enableIsolation() {\n        this.isolated = true;\n        // Isolated frames don't run the IframeSDK handshake (no same-origin init),\n        // so mark initiated immediately \u2014 like the extracted web component does.\n        this.setInitiated();\n        this._isoMsgHandler = (e: MessageEvent) => {\n            if (e.source !== this.IframeElement.contentWindow) return;\n            const d: any = e.data;\n            if (!d || d.__myop !== true) return;\n            if (d.type === 'myop:cta') {\n                if (this._ctaHandler && !this.markedForDisposed) this._ctaHandler(d.action, d.payload);\n                else if (!this._ctaHandler) this._ctaQueue.push({ action: d.action, payload: d.payload });\n            } else if (d.type === 'myop:size') {\n                this._applyIsoSize(d.height, d.width);\n            }\n        };\n        window.addEventListener('message', this._isoMsgHandler);\n    }\n\n    /** Data-in \u2014 unified with the extracted-WC API. Posts init over the bridge. */\n    initWithData(data: unknown): void {\n        this._lastData = data;\n        this.IframeElement?.contentWindow?.postMessage({ __myop: true, type: 'myop:init', data }, '*');\n    }\n\n    /** Data-in getter \u2014 returns the last data the host sent (cached, synchronous). */\n    getData(): unknown {\n        return this._lastData;\n    }\n\n    /** Data-out \u2014 unified with the extracted-WC API. Flushes CTAs queued pre-handler. */\n    setCtaHandler(handler: (action: string, payload: unknown) => void): void {\n        this._ctaHandler = handler;\n        if (this._ctaQueue.length > 0) {\n            const queue = [...this._ctaQueue];\n            this._ctaQueue = [];\n            queue.forEach(item => { if (!this.markedForDisposed) handler(item.action, item.payload); });\n        }\n    }\n\n    private _applyIsoSize(height: number, width?: number) {\n        if (!height || Number.isNaN(height)) return;\n        // Always remember the latest reported size so it can be applied if/when\n        // auto-sizing is enabled after the first message arrives.\n        this._isoLastSize = { height, width };\n        // Respect autoSize:false \u2014 the host owns dimensions, so don't touch them.\n        if (!this._isoAutoSize) return;\n        const opts = this._isoSizeOpts;\n        const toNum = (v: number | string | undefined): number | undefined =>\n            v === undefined ? undefined : (typeof v === 'number' ? v : (isNaN(parseFloat(v)) ? undefined : parseFloat(v)));\n        const min = toNum(opts?.minHeight), max = toNum(opts?.maxHeight);\n        let h = height;\n        if (min !== undefined && h < min) h = min;\n        if (max !== undefined && h > max) h = max;\n        // Transition from absolute overlay to document flow at the measured height.\n        this.IframeElement.style.position = 'relative';\n        this.IframeElement.style.inset = 'auto';\n        this.IframeElement.style.height = h + 'px';\n        this.IframeElement.style.width = '100%';\n        opts?.onSizeChange?.({ width: width ?? this.IframeElement.clientWidth, height: h, autoSizingWidth: false, autoSizingHeight: true } as any);\n    }\n\n    cleanupInspect?: CleanupHandler;\n\n    inspect() {\n        // TODO : use better check for inspect mode\n        if (this.cleanupInspect) {\n            //console.log('inspect call more than once');\n            return this.cleanupInspect\n        }\n        this.cleanupInspect = setDebugStyle(this.id, 'MyopIframeComponent', 10, this.container, this.IframeElement, this.componentDefinition);\n        return () => {\n            this.cleanupInspect!();\n            this.cleanupInspect = undefined;\n        };\n    }\n\n    hide() {\n        this.IframeElement.style.opacity = '0';\n        this.IframeElement.style.position = 'absolute'\n        this.IframeElement.style.pointerEvents = 'none'\n        this.IframeElement.style.visibility = 'hidden';\n    }\n\n    show() {\n        this.IframeElement.style.opacity = '1';\n        this.IframeElement.style.position = 'unset'\n        this.IframeElement.style.pointerEvents = 'all'\n        this.IframeElement.style.visibility = 'visible';\n    }\n\n    setHeightBasedOnDocumentElement = () => {\n        const cleanupHandler = this.send(new ExecuteScriptMessage(() => {\n            return window.document.documentElement.scrollHeight;\n        }, (ret) => {\n            this.IframeElement.style.height = `${ret.content}px`;\n            cleanupHandler();\n        }));\n    }\n\n    observeSizeBasedOnDocumentElement = () => {\n        const cleanupHandler = this.send(new ExecuteScriptMessage(({send}) => {\n            const {height, width} = document.documentElement.getBoundingClientRect();\n\n            const observer = new ResizeObserver(() => {\n                const {height, width} = document.documentElement.getBoundingClientRect();\n                send({height, width});\n            });\n            observer.observe(document.documentElement);\n            observer.observe(document.body);\n\n            return {height, width}\n        }, (ret) => {\n            this.IframeElement.style.width = `${ret.content.width}px`;\n            this.IframeElement.style.height = `${ret.content.height}px`;\n        }));\n\n        return cleanupHandler;\n    }\n\n    /**\n     * Observes the iframe content size and automatically syncs it to the iframe element.\n     * Uses direct contentDocument access (same-origin only) for accurate measurements.\n     *\n     * Reentrant: when called again while observers already exist, updates options and\n     * re-evaluates sizing without recreating observers. Cleanup + re-call (e.g. React\n     * re-render) creates fresh observers since cleanup clears the existing ones.\n     *\n     * @param options - Configuration options including size change callback and min/max constraints\n     * @returns Cleanup function to stop observing\n     */\n    observeAutoSize = (options?: AutoSizeOptions): CleanupHandler => {\n        // Store options so updateSize always reads the latest\n        this._autoSizeOptions = options;\n\n        // Isolated frames can't be measured cross-origin \u2014 sizing is driven by\n        // 'myop:size' postMessages from the bridge (see _applyIsoSize).\n        if (this.isolated) {\n            this._isoSizeOpts = options;\n            this._isoAutoSize = true;\n            // Apply the most recent bridge-reported size (it may have arrived before\n            // auto-sizing was turned on).\n            if (this._isoLastSize) this._applyIsoSize(this._isoLastSize.height, this._isoLastSize.width);\n            return () => { this._isoAutoSize = false; this._isoSizeOpts = undefined; };\n        }\n\n        // If observers already exist, re-evaluate with new options and reuse them\n        if (this._autoSizeCleanup && this._autoSizeUpdate) {\n            this._autoSizeUpdate();\n            return this._autoSizeCleanup;\n        }\n\n        const iframe = this.IframeElement;\n        const doc = iframe.contentDocument;\n\n        if (!doc) {\n            console.warn('[MyopIframeComponent] Cannot observe auto size: contentDocument not accessible');\n            return () => {};\n        }\n\n        const clamp = (value: number, min?: number, max?: number): number => {\n            if (min !== undefined && value < min) return min;\n            if (max !== undefined && value > max) return max;\n            return value;\n        };\n\n        // Parse CSS size values to numbers\n        const parseSize = (value: string | number | undefined): number | undefined => {\n            if (value === undefined) return undefined;\n            if (typeof value === \"number\") return value;\n            const parsed = parseFloat(value);\n            return isNaN(parsed) ? undefined : parsed;\n        };\n\n        const updateSize = () => {\n            const contentDoc = iframe.contentDocument;\n            if (!contentDoc) return;\n\n            const opts = this._autoSizeOptions;\n\n            const minWidth = parseSize(opts?.minWidth);\n            const maxWidth = parseSize(opts?.maxWidth);\n            const minHeight = parseSize(opts?.minHeight);\n            const maxHeight = parseSize(opts?.maxHeight);\n            const loaderMinHeight = opts?.loaderMinHeight ?? 50;\n\n            // Resolve explicit dimensions: host options \u2192 sizeMeta fill mode \u2192 width defaults to \"100%\"\n            // Width defaults to \"100%\" (block element behavior) to prevent the shrink-to-0 measurement bug.\n            // Height has no default so it auto-sizes to content.\n            // Only sizeMeta \"100%\" (fill mode) is treated as explicit and disables auto-sizing.\n            // Pixel sizeMeta values (e.g., height: 200) are initial hints, NOT explicit constraints.\n            const sizeMetaFillWidth = this.sizeMeta?.width === \"100%\" ? \"100%\" : undefined;\n            const sizeMetaFillHeight = this.sizeMeta?.height === \"100%\" ? \"100%\" : undefined;\n            const resolvedExplicitWidth = opts?.explicitWidth ?? sizeMetaFillWidth ?? \"100%\";\n            const resolvedExplicitHeight = opts?.explicitHeight ?? sizeMetaFillHeight;\n            const hasExplicitWidth = resolvedExplicitWidth !== undefined;\n            const hasExplicitHeight = resolvedExplicitHeight !== undefined;\n\n            // Detect collapsed dimensions from container (this.container)\n            const containerRect = this.container.getBoundingClientRect();\n            const collapsedWidth = containerRect.width === 0;\n            // Consider collapsed if height is 0 OR equals the loader minHeight\n            const collapsedHeight = containerRect.height === 0 || containerRect.height === loaderMinHeight;\n\n            // Determine which dimensions to auto-size:\n            // - If forceAutoSize is true, auto-size unless explicit dimension is set\n            // - Otherwise, auto-size only if collapsed\n            const shouldAutoWidth = opts?.forceAutoSize\n                ? !hasExplicitWidth\n                : (collapsedWidth && !hasExplicitWidth);\n            const shouldAutoHeight = opts?.forceAutoSize\n                ? !hasExplicitHeight\n                : (collapsedHeight && !hasExplicitHeight);\n\n            // If nothing needs auto-sizing, apply explicit/percentage dimensions\n            if (!shouldAutoWidth && !shouldAutoHeight) {\n                iframe.style.width = typeof resolvedExplicitWidth === 'number' ? `${resolvedExplicitWidth}px` : '100%';\n                iframe.style.height = typeof resolvedExplicitHeight === 'number' ? `${resolvedExplicitHeight}px` : '100%';\n\n                opts?.onSizeChange?.({\n                    width: typeof resolvedExplicitWidth === 'number' ? resolvedExplicitWidth : undefined,\n                    height: typeof resolvedExplicitHeight === 'number' ? resolvedExplicitHeight : undefined,\n                    autoSizingWidth: false,\n                    autoSizingHeight: false,\n                });\n                return;\n            }\n\n            // Disable CSS transitions on iframe and container for the entire\n            // measurement + height-setting cycle. Host apps may set `transition: all`\n            // which would animate the 0px collapse and final height change, causing\n            // visible jumps during scroll.\n            const prevTransition = iframe.style.transition;\n            const container = this.container;\n            const prevContainerTransition = container.style.transition;\n            iframe.style.transition = 'none';\n            container.style.transition = 'none';\n\n            // Quick pre-check: read scrollHeight/Width BEFORE collapsing the iframe.\n            // If content only grew (scrollHeight > iframe height), we can skip the\n            // 0px collapse \u2014 scrollHeight naturally expands beyond the iframe.\n            const currentIframeHeight = iframe.getBoundingClientRect().height;\n            const currentIframeWidth = iframe.getBoundingClientRect().width;\n            const preScrollHeight = Math.ceil(Math.max(contentDoc.documentElement.scrollHeight, contentDoc.body.scrollHeight, contentDoc.body.getBoundingClientRect().height));\n            const preScrollWidth = Math.ceil(Math.max(contentDoc.documentElement.scrollWidth, contentDoc.body.scrollWidth, contentDoc.body.getBoundingClientRect().width));\n\n            let contentWidth = preScrollWidth;\n            let contentHeight = preScrollHeight;\n\n            const heightGrew = shouldAutoHeight && preScrollHeight > currentIframeHeight + 1;\n            const widthGrew = shouldAutoWidth && preScrollWidth > currentIframeWidth + 1;\n\n            // For non-grow cases (shrink or no-change), we must collapse to 0px to\n            // measure the true content height. scrollHeight can never decrease below\n            // the iframe's clientHeight, so shrink is undetectable without collapsing.\n            // With transitions disabled + container min-height held, the collapse\n            // is invisible (no layout shift, no animation).\n            const needsHeightCollapse = shouldAutoHeight && !heightGrew;\n            const needsWidthCollapse = shouldAutoWidth && !widthGrew;\n\n            if (needsHeightCollapse || needsWidthCollapse) {\n                // Hold the container's min-height/width during measurement to prevent\n                // layout shift (elements below the iframe won't jump).\n                const prevMinHeight = container.style.minHeight;\n                const prevMinWidth = container.style.minWidth;\n                if (needsHeightCollapse) container.style.minHeight = `${currentIframeHeight}px`;\n                if (needsWidthCollapse) container.style.minWidth = `${currentIframeWidth}px`;\n\n                if (needsHeightCollapse) iframe.style.height = '0px';\n                if (needsWidthCollapse) iframe.style.width = '0px';\n\n                contentWidth = Math.ceil(Math.max(contentDoc.documentElement.scrollWidth, contentDoc.body.scrollWidth, contentDoc.body.getBoundingClientRect().width));\n                contentHeight = Math.ceil(Math.max(contentDoc.documentElement.scrollHeight, contentDoc.body.scrollHeight, contentDoc.body.getBoundingClientRect().height));\n\n                // Fallback: if collapsing to 0px gave a near-zero measurement, the component\n                // likely has `height: 100%` chains (html > body > .app-container) that cascaded\n                // the collapse into all children. Retry with a nuclear override that forces all\n                // elements to intrinsic sizing. This is only a fallback because the override\n                // breaks explicit pixel heights (e.g. 8px indicator dots \u2192 0px).\n                const needsNuclearHeight = needsHeightCollapse && contentHeight < 2;\n                const needsNuclearWidth = needsWidthCollapse && contentWidth < 2;\n                if (needsNuclearHeight || needsNuclearWidth) {\n                    const measureStyle = contentDoc.createElement('style');\n                    measureStyle.id = '__myop_measure';\n                    const rules: string[] = [];\n                    if (needsNuclearHeight) {\n                        rules.push('height: auto !important', 'min-height: 0 !important', 'max-height: none !important');\n                    }\n                    if (needsNuclearWidth) {\n                        rules.push('width: auto !important', 'min-width: 0 !important', 'max-width: none !important');\n                    }\n                    measureStyle.textContent = `*, *::before, *::after { ${rules.join('; ')}; flex-basis: auto !important; flex-grow: 0 !important; }`;\n                    contentDoc.head.appendChild(measureStyle);\n\n                    contentWidth = Math.ceil(Math.max(contentDoc.documentElement.scrollWidth, contentDoc.body.scrollWidth, contentDoc.body.getBoundingClientRect().width));\n                    contentHeight = Math.ceil(Math.max(contentDoc.documentElement.scrollHeight, contentDoc.body.scrollHeight, contentDoc.body.getBoundingClientRect().height));\n\n                    measureStyle.remove();\n                }\n\n                // Restore container constraints immediately (same frame, before paint)\n                container.style.minHeight = prevMinHeight;\n                container.style.minWidth = prevMinWidth;\n            }\n\n            const width = clamp(contentWidth, minWidth, maxWidth);\n            const height = clamp(contentHeight, minHeight, maxHeight);\n\n            // Set auto-sized dimensions to measured values, non-auto to explicit/100%\n            if (shouldAutoWidth) {\n                iframe.style.width = `${width}px`;\n            } else {\n                iframe.style.width = typeof resolvedExplicitWidth === 'number' ? `${resolvedExplicitWidth}px` : '100%';\n            }\n            if (shouldAutoHeight) {\n                iframe.style.height = `${height}px`;\n            } else {\n                iframe.style.height = typeof resolvedExplicitHeight === 'number' ? `${resolvedExplicitHeight}px` : '100%';\n            }\n\n            // Force reflow so the final dimensions are applied without transition,\n            // then restore the original transitions.\n            // eslint-disable-next-line no-unused-expressions\n            iframe.offsetHeight;\n            iframe.style.transition = prevTransition;\n            container.style.transition = prevContainerTransition;\n\n            // Don't force overflow \u2014 let the component/parent control scrolling.\n            // Only set overflow: auto when content exceeds max constraints.\n            const isWidthConstrained = shouldAutoWidth && maxWidth !== undefined && contentWidth > maxWidth;\n            const isHeightConstrained = shouldAutoHeight && maxHeight !== undefined && contentHeight > maxHeight;\n            contentDoc.documentElement.style.overflowX = isWidthConstrained ? 'auto' : '';\n            contentDoc.documentElement.style.overflowY = isHeightConstrained ? 'auto' : '';\n\n            opts?.onSizeChange?.({\n                width,\n                height,\n                autoSizingWidth: shouldAutoWidth,\n                autoSizingHeight: shouldAutoHeight\n            });\n        };\n\n        // Initial size (run synchronously, not debounced)\n        updateSize();\n\n        // Store updateSize for reentrant calls\n        this._autoSizeUpdate = updateSize;\n\n        // Debounce observer callbacks via rAF \u2014 at most one updateSize per frame.\n        // Prevents layout thrashing from high-frequency mutations (e.g. CSS animations).\n        let rafId: number | undefined;\n        const scheduleUpdate = () => {\n            if (rafId !== undefined) return;\n            rafId = requestAnimationFrame(() => {\n                rafId = undefined;\n                updateSize();\n            });\n        };\n\n        // Observe for changes\n        const resizeObserver = new ResizeObserver(() => scheduleUpdate());\n        resizeObserver.observe(doc.body);\n        resizeObserver.observe(doc.documentElement);\n\n        // MutationObserver catches DOM content changes (e.g. removing list items, toggling views)\n        // that don't trigger ResizeObserver because the body box-size stays the same\n        // (body fills iframe, iframe hasn't shrunk yet).\n        // `attributes: true` catches CSS class/style changes (e.g. display:none toggling views).\n        const mutationObserver = new MutationObserver(() => scheduleUpdate());\n        mutationObserver.observe(doc.body, { childList: true, subtree: true, characterData: true, attributes: true });\n\n        const cleanup = () => {\n            resizeObserver.disconnect();\n            mutationObserver.disconnect();\n            if (rafId !== undefined) {\n                cancelAnimationFrame(rafId);\n                rafId = undefined;\n            }\n            this._autoSizeUpdate = undefined;\n            this._autoSizeCleanup = undefined;\n        };\n        this._autoSizeCleanup = cleanup;\n        return cleanup;\n    }\n\n    setSizeBasedOnDocumentElement = () => {\n        const cleanupHandler = this.send(new ExecuteScriptMessage(() => {\n            const {height, width} = document.documentElement.getBoundingClientRect();\n            return {height, width}\n        }, (ret) => {\n            this.IframeElement.style.width = `${ret.content.width}px`;\n            this.IframeElement.style.height = `${ret.content.height}px`;\n            cleanupHandler();\n        }));\n    }\n\n    setHeightBasedOnScrollHeight = () => {\n        const cleanupHandler = this.send(new ExecuteScriptMessage(() => {\n            // @ts-ignore\n            // return window.document.body.scrollHeight + 'px';\n\n\n            //TODO: fix that hack, keep the function in right format while minified :(\n            const noOp = () => {\n                // No operation performed\n                return 0;\n            }\n            // To ensure it's not optimized away, you can call it at least once\n            let x = noOp();\n            x++;\n            x--;\n\n            //return `${window.document.body.offsetHeight}px`;\n\n            //TODO : check that +1 ?\n            return Math.max(Math.max(\n                    window.document.body.clientHeight,\n                    window.document.body.scrollHeight)\n                , window.document.body.offsetHeight) + x + 'px'\n\n        }, (ret) => {\n            this.IframeElement.style.height = ret.content;\n            cleanupHandler();\n        }));\n    }\n\n    send = (message: BaseMyopMessage): CleanupHandler => {\n        let message_ = {...message} as BaseMyopMessage;\n        //TODO : ?!?! should it be here ?\n        if (message_.messageType === MyopMessages.ExecuteComponentMethod) {\n            const typedMessage = (message_ as ExecuteComponentMethod)\n            this[typedMessage.method]();\n            return () => {\n            }\n        }\n\n        //TODO : fix that hack :(\n        // @ts-ignore\n        //const handler = message.handler\n\n        message_.direction = MessageDirection.down;\n        const cleanupHandler = super.send(message_);\n        this.IframeElement?.contentWindow?.postMessage(message_, '*');\n\n        // @ts-ignore\n        //message.handler = handler\n\n        return cleanupHandler;\n    };\n\n    onMessageReceived(incomeMessage: BaseMyopMessage): boolean {\n        if (incomeMessage.messageType === MyopMessages.In.MutationObserverMessage\n            || incomeMessage.messageType === MyopMessages.In.ResizeObserverMessage) {\n            this.setHeightBasedOnScrollHeight();\n            //debugger\n            //this.setHeightBasedOnDocumentElement();\n            return true;\n        }\n\n        return super.onMessageReceived(incomeMessage);\n    }\n\n    dispose = () => {\n        if (this._autoSizeCleanup) {\n            this._autoSizeCleanup();\n            this._autoSizeCleanup = undefined;\n        }\n        if (this._isoMsgHandler) {\n            window.removeEventListener('message', this._isoMsgHandler);\n            this._isoMsgHandler = undefined;\n        }\n        if (this.cleanupInspect)\n            this.cleanupInspect();\n\n        super.dispose();\n        this.IframeElement.parentNode!.removeChild(this.IframeElement);\n    }\n}\n", "import {IMyopComponent} from \"../components/IMyopComponent\";\nimport {loaderOptions} from \"../hostSDK\";\nimport {IComponentDefinitionConfig, ISkinConfig, SkinLoaderType} from \"../../common\";\n\nexport interface IMyopLoader {\n    type: SkinLoaderType;\n    load: (componentDefinition: IComponentDefinitionConfig, skin: ISkinConfig, container: HTMLElement, options?: loaderOptions) => Promise<IMyopComponent>;\n}\n\nexport abstract class BaseMyopLoader implements IMyopLoader {\n    abstract type: SkinLoaderType;\n    abstract load: (componentDefinition: IComponentDefinitionConfig, skin: ISkinConfig, container: HTMLElement, options?: loaderOptions) => Promise<IMyopComponent>;\n\n    appendChild = (container: HTMLElement, element: HTMLElement, options?: loaderOptions,) => {\n        if (options?.relative) {\n            if (options.relative.direction === 'before') {\n                return container.insertBefore(element, options.relative.child);\n            }\n\n            if (options.relative.direction === 'after') {\n                const nextSibling = options.relative.child?.nextSibling;\n                return container.insertBefore(element, nextSibling ? nextSibling : null);\n            }\n        } else {\n            return container.appendChild(element);\n        }\n    }\n}\n", "import {MyopIframeComponent} from \"../components/myopIframeComponent\";\nimport {BaseMyopLoader} from \"./IMyopLoader\";\nimport {uuidv4} from \"../../utils/utils\";\nimport {loaderOptions} from \"../hostSDK\";\nimport {IComponentDefinitionConfig, IIframeLoaderConfig, ISkinConfig, SkinLoaders} from \"../../common\";\n\nconst addQueryParam = (url: string, param: string, value: string) => {\n    // Create a URL object\n    const urlObj = new URL(url);\n\n    // Add the query parameter\n    urlObj.searchParams.append(param, value);\n\n    // Return the updated URL\n    return urlObj.toString();\n}\n\nexport class MyopIframeLoader extends BaseMyopLoader {\n    type = SkinLoaders.IframeLoader\n\n    // @ts-ignore\n    load = async (componentDefinition: IComponentDefinitionConfig, skin: ISkinConfig, container: HTMLElement, options?: loaderOptions) => {\n        let IframeElement: HTMLIFrameElement;\n\n        const typedLoaderConfig = (skin.loader as IIframeLoaderConfig);\n\n        if (container?.nodeName === \"IFRAME\") {\n            console.log('needs to load into an exsisting Iframe...', typedLoaderConfig.url, container);\n\n            IframeElement = (container as HTMLIFrameElement)\n            IframeElement.src = typedLoaderConfig.url\n        } else {\n            const uniqId = uuidv4();\n            const domId = `myop-comp-${uniqId}`\n\n            IframeElement = document.createElement('iframe');\n            IframeElement.id = domId;\n\n            // Set all styles BEFORE appending to prevent flash at wrong position\n            const iframeStyles = `\n                padding: 0;\n                margin: 0;\n                position: absolute;\n                inset: 0;\n                height: ${typedLoaderConfig.autoHeight || !typedLoaderConfig.height ? '100%' : typedLoaderConfig.height};\n                width: 100%;\n                overflow: hidden;\n                border: none;\n                opacity: ${options?.hidden ? '0' : '1'};\n                pointer-events: ${options?.hidden ? 'none' : 'all'};\n            `;\n            IframeElement.style.cssText = iframeStyles;\n\n            // Set element attributes if provided\n            if (options?.elementAttributes) {\n                Object.entries(options.elementAttributes).forEach(([key, value]) => {\n                    if (value === '' || value === null || value === undefined) {\n                        IframeElement.setAttribute(key, '');\n                    } else {\n                        IframeElement.setAttribute(key, String(value));\n                    }\n                });\n            }\n\n            // in order to handle issue to load iframe inside an iframe with the same url\n            let url2load = (skin.loader as IIframeLoaderConfig).url;\n            if (options?._hasParent)\n                url2load = addQueryParam(url2load, \"_myop-comp\", uniqId);\n\n            IframeElement.src = url2load;\n\n            // TODO : do it only with flag ?\n            if (!container.querySelector('[id^=\"myop-comp-\"]'))\n                container.innerHTML = '';\n\n            IframeElement = this.appendChild(container, IframeElement, options) as HTMLIFrameElement;\n            //   IframeElement = document.getElementById(domId) as HTMLIFrameElement;\n            //NO : IframeElement = container.lastElementChild as HTMLIFrameElement;\n        }\n\n        return new MyopIframeComponent(componentDefinition, skin, container, IframeElement, options);\n    }\n}\n", "export const myopWebcomponentConsts = {\n    webcomponent_message_key: 'myop_webcomponent_message'\n}\n", "import {myopWebcomponentConsts} from \"../../webcomponent/consts\";\nimport {BaseMyopComponent} from \"./IMyopComponent\";\nimport {BaseMyopMessage} from \"../../messages\";\nimport {CleanupHandler, IComponentDefinitionConfig, ISkinConfig} from \"../../common\";\nimport {setDebugStyle} from \"../componentCore\";\nimport {loaderOptions} from \"../hostSDK\";\n\nexport class MyopWebComponent extends BaseMyopComponent {\n\n    constructor(componentDefinition: IComponentDefinitionConfig, skin: ISkinConfig, public container: HTMLElement, private customElement: HTMLElement, options?: loaderOptions) {\n        super(componentDefinition, container , options);\n        this.element = customElement;\n    }\n\n    cleanupInspect: CleanupHandler = () => {\n    }\n\n    inspect() {\n        this.cleanupInspect = setDebugStyle(this.id, 'MyopWebComponent', 0, this.container, this.customElement, this.componentDefinition);\n        return this.cleanupInspect;\n    }\n\n    hide() {\n        this.customElement.style.opacity = '0';\n        this.customElement.style.position = 'absolute'\n        this.customElement.style.pointerEvents = 'none'\n        this.customElement.style.visibility = 'hidden';\n        this.customElement.style.height = '0'\n        this.customElement.style.width = '0'\n    }\n\n    show() {\n        this.customElement.style.opacity = '1';\n        this.customElement.style.position = 'unset'\n        this.customElement.style.pointerEvents = 'all'\n        this.customElement.style.visibility = 'visible';\n        this.customElement.style.height = '';\n        this.customElement.style.width = '';\n    }\n\n    send = (message: BaseMyopMessage<any>) => {\n        let message_ = {...message} as BaseMyopMessage;\n\n        //TODO : can be done without cloning?\n        // @ts-ignore\n        //const handler = message_.handler\n        const cleanupHandler = super.send(message_);\n\n        const msg = new CustomEvent<BaseMyopMessage>(myopWebcomponentConsts.webcomponent_message_key, {\n            // @ts-ignore\n            detail: message_,\n            // bubbles: true,\n            // cancelable: false,\n            // composed: true\n        })\n\n        //this.container.dispatchEvent(msg)\n\n        //sending data from host to the component\n        try {\n            this.customElement.dispatchEvent(msg)\n            // if (this.customElement.children.length > 0) {\n            // } else {\n            //     this.customElement.children[0].dispatchEvent(msg)\n            // }\n        } catch (e) {\n            console.log('error while trying to dispatchEvent', e);\n        }\n\n        // @ts-ignore\n        //message.handler = handler\n\n        return cleanupHandler;\n    }\n\n    dispose = () => {\n        super.dispose();\n        this.customElement.parentNode?.removeChild(this.customElement);\n    }\n}\n", "import {MyopWebComponent} from \"../components/myopWebcomponent\";\nimport {BaseMyopLoader} from \"./IMyopLoader\";\nimport {loaderOptions} from \"../hostSDK.ts\";\nimport {uuidv4, wait} from \"../../utils/utils.ts\";\nimport {IComponentDefinitionConfig, ISkinConfig, IWebComponentLoaderConfig, SkinLoaders} from \"../../common\";\n\nconst seen: Record<string, Promise<void>> = {};\n\nexport class WebcomponentLoader extends BaseMyopLoader {\n\n    type = SkinLoaders.WebComponentLoader\n\n    load = async (componentDefinition: IComponentDefinitionConfig, skin: ISkinConfig, container: HTMLElement, options?: loaderOptions) => {\n\n        const loaderConfig = (skin.loader as IWebComponentLoaderConfig);\n\n        if (!seen[loaderConfig.url]) {\n            // await import( /* @vite-ignore */ webComponentLoadUrl);\n            // console.log('module loaded');\n            seen[loaderConfig.url] = new Promise((resolve, reject) => {\n                const webComponentLoadUrl = loaderConfig.url\n                const script = document.createElement('script');\n                script.type = 'module';\n                script.src = webComponentLoadUrl;\n                script.onload = () => {\n                    resolve();\n                }\n\n                script.onerror = () => {\n                    reject();\n                }\n                document.head.appendChild(script);\n            })\n        } else {\n            console.log('Module alreday loaded or in loading process');\n        }\n\n        await seen[loaderConfig.url];\n\n        //TODO : add retry mechanism in fail case.\n\n        //TODO : fix that hack, should fix the race condition for loaded modules\n        await wait(1);\n\n        let domId = `myop-comp-${uuidv4()}`\n        const element = document.createElement(loaderConfig.tag);\n\n        // TODO : do it only with flag ?\n        if (!container.querySelector('[id^=\"myop-comp-\"]'))\n            container.innerHTML = '';\n\n        //element.style.visibility = 'hidden';\n        element.id = domId;\n\n        if (options?.hidden) {\n            element.style.opacity = '0';\n            element.style.position = 'absolute'\n            element.style.height = '0'\n            element.style.width = '0'\n            element.style.pointerEvents = 'none'\n            element.style.visibility = 'hidden';\n        }\n\n        // if (container.id.startsWith('myop-comp-')) {\n        //     // in place replacement\n        //     container.replaceWith(element);\n        //     //container = element.parentElement!;\n        // } else {\n        //     container.appendChild(element);\n        // }\n\n        if(options?._environment){\n            // @ts-ignore\n            element._myopEnvironment = options?._environment;\n        }\n\n        this.appendChild(container, element, options);\n        //element.innerHTML = `<${loaderConfig.tag} />`;\n        return new MyopWebComponent(componentDefinition, skin, container, element, options);\n    }\n\n}\n", "export default '0.3.36';", "import {BaseContextMessageHandler, HostedComponent} from \"../../common\";\nimport {ShadowRootRef} from \"../shadowRootRef\";\nimport {BaseMyopMessage, MyopBindMessage} from \"../../messages\";\n\nexport type MessageToHost = (message: BaseMyopMessage) => void\n\nexport abstract class BaseWebComponentMessageHandler<T extends BaseMyopMessage = any> extends BaseContextMessageHandler<T, Record<string, HostedComponent<ShadowRootRef>>> {\n\n    abstract messageType: string\n\n    constructor(messageToHost: any, public context: Record<string, HostedComponent<ShadowRootRef>>) {\n        super(messageToHost);\n    }\n\n    abstract innerExecutor: (event: T, shadowRootRef: ShadowRootRef, messageToHost: MessageToHost) => void;\n\n    executor = (event: T) => {\n        //debugger;\n        if (event.destination) {\n            const destination = event.destination;\n            if (this.context[destination].context) {\n\n                // patch the source id, think about that ?\n                const _messageToHost = (message: BaseMyopMessage, replayTo?: MyopBindMessage) => {\n                    this.messageToHost({\n                        ...message,\n                        source: event.destination ? event.destination : event.source,\n                        destination: event.source ? event.source : event.destination\n                    } as BaseMyopMessage, replayTo)\n                }\n\n                return this.innerExecutor(event, this.context[destination].context, _messageToHost);\n            } else {\n                debugger;\n            }\n        } else {\n            debugger;\n        }\n    }\n}\n", "export const myopAttributes = {\n    id: 'myop-id'\n}\n", "import {myopAttributes} from \"../../consts.ts\";\nimport {Ref} from \"../../messages\";\n\nexport const getElementsByRef = (ref: Ref, el: ParentNode) => {\n    return el.querySelectorAll(`[${myopAttributes.id}='${ref.refConfig.selector}']`);\n}\n\nexport const getFirstElementByRef = (ref: Ref, el: ParentNode) => {\n    const elements = getElementsByRef(ref, el);\n    if (elements.length) {\n        return elements.item(0);\n    }\n    return null;\n}", "import {MyopMessages} from \"../../common/MyopMessages\";\nimport {BindClickMessage, ClickReplayMessage, MyopBindMessage} from \"../../messages\";\nimport {ShadowRootRef} from \"../shadowRootRef\";\nimport {BaseWebComponentMessageHandler, MessageToHost} from \"./BaseWebComponentMessageHandler\";\nimport {getElementsByRef} from \"../../common/messageHandlers/helpers\";\n\nexport class BindOnClickHandler extends BaseWebComponentMessageHandler<BindClickMessage> {\n\n    messageType = MyopMessages.BindClickMessage;\n\n    innerExecutor = (event: BindClickMessage, shadowRootRef: ShadowRootRef, messageToHost: MessageToHost) => {\n        const items = getElementsByRef(event.ref, shadowRootRef.shadowRoot)\n        const cleanupTasks: any[] = [];\n\n        items.forEach(item => {\n            const handler = () => {\n                messageToHost(new ClickReplayMessage(event.handlerUniqueId));\n            };\n\n            item.addEventListener('click', handler);\n            cleanupTasks.push(() => {\n                item.removeEventListener('click', handler);\n            })\n        })\n\n        return () => {\n            cleanupTasks.forEach(task => task());\n        }\n    }\n}\n", "import {MyopMessages} from \"../../common/MyopMessages\";\nimport {ShadowRootRef} from \"../shadowRootRef\";\nimport {BaseWebComponentMessageHandler} from \"./BaseWebComponentMessageHandler\";\nimport {MyopElementMessage} from \"../../messages\";\nimport {getElementsByRef} from \"../../common/messageHandlers/helpers\";\n\nexport class ChangeTextHandler extends BaseWebComponentMessageHandler<MyopElementMessage> {\n\n    messageType = MyopMessages.ChangeTextMessage;\n\n    innerExecutor = (event: MyopElementMessage, shadowRootRef: ShadowRootRef) => {\n        const items = getElementsByRef(event.ref, shadowRootRef.shadowRoot);\n        items.forEach(item => {\n            item.textContent = event.content;\n        })\n    }\n}\n", "import {RootRef} from \"../common\";\n\nexport class ShadowRootRef extends RootRef {\n    constructor(public container: HTMLElement, public shadowRoot: ShadowRoot) {\n        super(container, shadowRoot);\n    }\n}\n", "import {MyopElementRef} from \"../../common\";\nimport {myopAttributes} from \"../../consts\";\nimport {BaseWebComponentMessageHandler} from \"./BaseWebComponentMessageHandler\";\nimport {ShadowRootRef} from \"../shadowRootRef\";\nimport {DetectedMyopRefsMessage, DetectMyopRefsMessage} from \"../../messages\";\nimport {MyopMessages} from \"../../common/MyopMessages\";\n\nexport class DetectMyopRefsMessageHandler extends BaseWebComponentMessageHandler<DetectMyopRefsMessage> {\n    innerExecutor = (event: DetectMyopRefsMessage, shadowRootRef: ShadowRootRef) => {\n\n        //debugger;\n        const allMyopItems = shadowRootRef.shadowRoot.querySelectorAll(`[${myopAttributes.id}]`);\n\n        let myopRefs: MyopElementRef[] = [];\n\n        allMyopItems.forEach(item => {\n\n            // TODO : take that back to the dashboard?\n            //console.log(item, item.getBoundingClientRect());\n\n            const myopId = item.getAttribute(myopAttributes.id);\n\n            if (myopId) {\n                //console.log('wc rect',  item.parentElement.getBoundingClientRect(), item.getBoundingClientRect())\n                // @ts-ignore\n                myopRefs.push(new MyopElementRef(myopId, item.tagName, item.getBoundingClientRect(), item.offsetTop, item.offsetLeft))\n            }\n        })\n\n        this.messageToHost(new DetectedMyopRefsMessage(event.handlerUniqueId, myopRefs))\n    };\n\n    messageType = MyopMessages.DetectMyopRefsMessage;\n\n\n}\n", "import {MyopMessages} from \"../../common/MyopMessages\";\nimport {SetAttributeMessage} from \"../../messages\";\nimport {BaseWebComponentMessageHandler} from \"./BaseWebComponentMessageHandler.ts\";\nimport {ShadowRootRef} from \"../shadowRootRef.ts\";\nimport {getElementsByRef} from \"../../common/messageHandlers/helpers\";\n\nexport class setAttributeHandler extends BaseWebComponentMessageHandler<SetAttributeMessage> {\n\n    messageType = MyopMessages.SetAttributeMessage;\n\n    innerExecutor = (event: SetAttributeMessage, shadowRootRef: ShadowRootRef) => {\n        const items = getElementsByRef(event.ref, shadowRootRef.shadowRoot);\n        items.forEach(item => {\n            item.setAttribute(event.name, event.value)\n        })\n    }\n}\n", "import {MyopMessages} from \"../../common/MyopMessages\";\nimport {\n    AddEventListenerMessage,\n    EventListenerCallbackMessage,\n} from \"../../messages\";\nimport {BaseWebComponentMessageHandler, MessageToHost} from \"./BaseWebComponentMessageHandler.ts\";\nimport {ShadowRootRef} from \"../shadowRootRef.ts\";\nimport {getElementsByRef} from \"../../common/messageHandlers/helpers\";\nimport {makeSerializable} from \"../../common/utils/serialization.ts\";\n\nexport class AddEventListenerHandler extends BaseWebComponentMessageHandler<AddEventListenerMessage> {\n\n    messageType = MyopMessages.AddEventListenerMessage;\n\n    innerExecutor = (event: AddEventListenerMessage, shadowRootRef: ShadowRootRef, messageToHost: MessageToHost) => {\n\n        const items = getElementsByRef(event.ref, shadowRootRef.shadowRoot);\n        const cleanupTasks: (() => void)[] = [];\n\n        items.forEach(item => {\n            const handler = (e) => {\n                // in fact when running in WebComponent we can transfer the original e\n                // currently using makeSerializable for nested cases, think about that\n                messageToHost(new EventListenerCallbackMessage(event.handlerUniqueId,  makeSerializable(e, event.serializableSkeleton)));\n            };\n\n            item.addEventListener(event.type, handler);\n\n            cleanupTasks.push(() => {\n                item.removeEventListener(event.type, handler);\n            })\n        });\n\n        return () => {\n            cleanupTasks.forEach(task => task())\n        }\n    }\n}\n", "import {MyopMessages} from \"../../common/MyopMessages\";\nimport {myopAttributes} from \"../../consts\";\nimport {HostSDK} from \"../../host/hostSDK\";\nimport {CreateRefComponentMessage, RefComponentCreatedMessage} from \"../../messages/CreateRefComponentMessage\";\nimport {BaseWebComponentMessageHandler, MessageToHost} from \"./BaseWebComponentMessageHandler\";\nimport {ShadowRootRef} from \"../shadowRootRef\";\nimport {IMyopComponent} from \"../../host\";\n\nexport class CreateRefComponentMessageHandler extends BaseWebComponentMessageHandler<CreateRefComponentMessage> {\n\n    messageType = MyopMessages.CreateRefComponentMessage;\n\n    innerExecutor = (event: CreateRefComponentMessage, shadowRootRef: ShadowRootRef, messageToHost: MessageToHost) => {\n\n        const createRef = async () => {\n            //const allItems = shadowRootRef.shadowRoot.querySelectorAll<HTMLElement>(`[${myopAttributes.id}='${event.ref?.refConfig.selector}']`);\n            const allItems = shadowRootRef.shadowRoot.querySelectorAll<HTMLElement>(`[${myopAttributes.id}='${event.refConfig.selector}']`);\n\n            if (allItems.length === 1) {\n                const hostSDK = HostSDK.Instance();\n\n                const refComponent = hostSDK.components.find(c => c.id === event.options.id)!;\n                if (refComponent) {\n                    ////>>>>\n                    refComponent.dispose();\n                } else {\n                  //  console.log(`failed to find ${event.options.id} in mem scope`, hostSDK);\n                }\n                //we have the ref component in our HostSDK (same memory when using webcomponent)\n                //  refComponent.parent = implementationComponent;\n                //delete the ref component\n                const index = hostSDK.components.indexOf(refComponent);\n                if (index !== -1) {\n                    hostSDK.components.splice(index, 1);\n                    //console.log('createRefComponent called removed temp ref component');\n                } else {\n                    //console.log('createRefComponent called using temp ref component');\n                }\n\n                const implementationComponent = await hostSDK.loadComponent(event.nestedComponentConfig,\n                    allItems.item(0),\n                    event.options)\n\n                //TODO : no need this, pass options from parent\n                //implementationComponent.id = event.predefinedId;\n                //refComponent.id += '.';\n\n                //TODO : not really needed ?\n                // await implementationComponent.initiated();\n\n                const nestedRefConfig: any[] = [];\n\n                Object.keys(implementationComponent.refs).forEach(refName => {\n                    let ref = implementationComponent.refs[refName];\n                    ref = ref.__nonProxied || ref;\n\n                    if ((ref as IMyopComponent).componentDefinition) {\n                        nestedRefConfig.push({\n                            refName,\n                            componentDefinitionId: (ref as IMyopComponent).componentDefinition.id,\n                        });\n                    }\n                })\n\n                messageToHost(new RefComponentCreatedMessage(event.handlerUniqueId, nestedRefConfig));\n            } else {\n                console.error('CreateRefComponentMessageHandler - DOM element not found')\n                this.messageToHost(new RefComponentCreatedMessage(event.handlerUniqueId, [], true));\n\n                debugger;\n            }\n        }\n\n        createRef().then()\n        //returning undefined so it won't act as a cleanup\n    }\n}\n", "import {ExecuteScriptMessage} from \"../../messages\";\nimport {RootRef} from \"../../common\";\nimport {makeSerializable} from \"../utils/serialization.ts\";\n\nexport const ExecuteScriptHandlerExecutor = (event: ExecuteScriptMessage, replier: (data: any) => void, rootRef: RootRef) => {\n    const __scriptInputs = event.scriptInputs ? event.scriptInputs : {}\n    __scriptInputs.makeSerializable = makeSerializable;\n\n    __scriptInputs.send = replier;\n    __scriptInputs.rootRef = rootRef;\n    __scriptInputs.__scriptInputs = __scriptInputs;\n\n    const dynamicFunction = new Function(`return (${event.script})(...arguments)`);\n    const ret = dynamicFunction(__scriptInputs);\n\n    // const dynamicFunction = Function('send', 'rootRef','__scriptInputs', ...Object.keys(__scriptInputs), event.content ? event.content : '')\n    //const ret = dynamicFunction(replier, rootRef, __scriptInputs, ...Object.values(__scriptInputs));\n    replier(ret);\n}\n", "import {MyopMessages} from \"../../common/MyopMessages\";\nimport {ExecuteScriptMessage, ExecuteScriptReplyMessage} from \"../../messages\";\nimport {BaseWebComponentMessageHandler, MessageToHost} from \"./BaseWebComponentMessageHandler.ts\";\nimport {ShadowRootRef} from \"../shadowRootRef.ts\";\nimport {ExecuteScriptHandlerExecutor} from \"../../common/messageHandlers/executeScriptHandler.ts\";\n\nexport class ExecuteScriptHandler extends BaseWebComponentMessageHandler<ExecuteScriptMessage> {\n    messageType = MyopMessages.ExecuteScriptMessage\n\n    innerExecutor = (event: ExecuteScriptMessage, shadowRootRef: ShadowRootRef, messageToHost: MessageToHost) => {\n        const replier = (data: any) => {\n            messageToHost(new ExecuteScriptReplyMessage(event.handlerUniqueId, data));\n        };\n\n        ExecuteScriptHandlerExecutor(event, replier, shadowRootRef);\n    }\n}\n", "import {MyopMessages} from \"../../common/MyopMessages\";\nimport {ElementValueReplayMessage, FormDataEntry, GetElementValueMessage, InputElementValue,} from \"../../messages\";\nimport {BaseWebComponentMessageHandler, MessageToHost} from \"./BaseWebComponentMessageHandler.ts\";\nimport {ShadowRootRef} from \"../shadowRootRef.ts\";\nimport {getElementsByRef} from \"../../common/messageHandlers/helpers\";\nimport {myopAttributes} from \"../../consts.ts\";\nimport {makeSerializable} from \"../../common/utils/serialization.ts\";\n\nconst getInputValue = (element): InputElementValue => {\n    if (!element) return null;\n\n    // Check if it's a form\n    if (element.tagName === 'FORM') {\n        const formData = new FormData(element);\n        const dataObject: InputElementValue = {\n            formData: {},\n            unmappedData: []\n        };\n\n        // Manually add elements without names\n        const elements = element.querySelectorAll('input, select, textarea');\n        let autoNameIndexer = -1;\n\n        elements.forEach(element => {\n            if (typeof element.value === 'string') {\n                const myopId = element.getAttribute(myopAttributes.id);\n                let key = element.getAttribute('name');\n\n                // `_${(++autoNameIndexer)}`\n\n                const nodeData: FormDataEntry = {\n                    id: element.id,\n                    name: key,\n                    value: getInputValue(element),\n                    required: element.required,\n                    validity: makeSerializable(element.validity, true),\n                    myopId,\n                };\n\n                if (!key) {\n                    dataObject.unmappedData!.push(nodeData);\n                } else {\n                    if (dataObject.formData![key]) {\n                        if (dataObject.formData![key].value) {\n                            dataObject.unmappedData!.push(nodeData);\n                        } else {\n                            dataObject.unmappedData!.push(dataObject.formData![key]);\n                            dataObject.formData![key] = nodeData\n                        }\n                    } else {\n                        dataObject.formData![key] = nodeData\n                    }\n                }\n            }\n        });\n\n        return dataObject;\n    }\n\n    // Check if it's a checkbox or radio button\n    if (element.type === 'checkbox' || element.type === 'radio') {\n        return element.checked ? element.value : null;\n    }\n\n    // Handle input and textarea elements\n    if (element.tagName === 'INPUT' || element.tagName === 'TEXTAREA') {\n        return element.value;\n    }\n\n    // Handle select elements (dropdowns)\n    if (element.tagName === 'SELECT') {\n        return element.value;\n    }\n\n    // Handle editable divs (contentEditable)\n    if (element.isContentEditable) {\n        return element.innerText || element.textContent;\n    }\n\n    // If it's an unsupported element type\n    return null;\n}\n\nexport class GetElementValueHandler extends BaseWebComponentMessageHandler<GetElementValueMessage> {\n\n    messageType = MyopMessages.GetElementValueMessage;\n\n    innerExecutor = (event: GetElementValueMessage, shadowRootRef: ShadowRootRef, messageToHost: MessageToHost) => {\n        const items = getElementsByRef(event.ref, shadowRootRef.shadowRoot);\n        items.forEach(item => {\n            // @ts-ignore\n            messageToHost(new ElementValueReplayMessage(getInputValue(item)), event);\n        })\n    }\n}\n", "import {MyopMessages} from \"../../common/MyopMessages\";\nimport {SetInnerHtml} from \"../../messages\";\nimport {ShadowRootRef} from \"../shadowRootRef\";\nimport {BaseWebComponentMessageHandler} from \"./BaseWebComponentMessageHandler\";\nimport {MyopElementMessage} from \"../../messages\";\nimport {getElementsByRef} from \"../../common/messageHandlers/helpers\";\n\nexport class SetInnerHtmlHandler extends BaseWebComponentMessageHandler<SetInnerHtml> {\n\n    messageType = MyopMessages.SetInnerHtml;\n\n    innerExecutor = (event: MyopElementMessage, shadowRootRef: ShadowRootRef) => {\n        const items = getElementsByRef(event.ref, shadowRootRef.shadowRoot);\n        items.forEach(item => {\n            item.innerHTML = event.content;\n        })\n    }\n}\n", "/**\n * @packageDocumentation\n * The Webcomponent SDK is tailored for using Myop components packaged as separate bundles and exposed as web components.<br/>\n * Developers importing this SDK can leverage APIs and utilities specifically crafted to support the lifecycle management and communication patterns required for web components within the Myop architecture.<br/>\n * This SDK promotes reusability and encapsulation, enabling developers to build modular, self-contained components that can be seamlessly integrated into the host application's DOM structure.\n *\n *\n * Once loaded the `RootSDK`, you can load the `IframeSDK`\n * ```js\n * const {WebComponentSDK} = (await window.myop.rootSDK.getWebcomponentModule());\n * ```\n * or\n * ```ts\n * import {getWebcomponentModule} from '@myop/sdk';\n * const {WebComponentSDK} = (await getWebcomponentModule());\n * ```\n * or\n * ```ts\n * import {WebComponentSDK} from '@myop/sdk/webcomponent';\n * ```\n *\n */\nimport {BaseMyopSDK} from \"../common\";\nimport {MyopMessages} from \"../common/MyopMessages\";\nimport {myopWebcomponentConsts} from \"./consts\";\nimport {BaseWebComponentMessageHandler} from \"./messageHandlers/BaseWebComponentMessageHandler\";\nimport {BindOnClickHandler} from \"./messageHandlers/bindOnClickHandler\";\nimport {ChangeTextHandler} from \"./messageHandlers/changeTextHandler\";\nimport {ShadowRootRef} from \"./shadowRootRef\";\nimport {DetectMyopRefsMessageHandler} from \"./messageHandlers/DetectMyopRefsMessageHandler\";\nimport {defineDynamicImport} from \"../dynamicImport/defineDynamicImport\";\nimport {\n    BaseMyopMessage,\n    InitMessage,\n    InitRequest,\n    MessageDirection,\n    MyopBindMessage,\n    MyopBindReplayMessage\n} from \"../messages\";\nimport {setAttributeHandler} from \"./messageHandlers/setAttributeHandler.ts\";\nimport {AddEventListenerHandler} from \"./messageHandlers/addEventListenerHandler.ts\";\nimport {CreateRefComponentMessageHandler} from \"./messageHandlers/CreateRefComponentMessageHandler.ts\";\nimport {ExecuteScriptHandler} from \"./messageHandlers/executeScriptHandler.ts\";\nimport {GetElementValueHandler} from \"./messageHandlers/GetElementValueHandler.ts\";\nimport {SetInnerHtmlHandler} from \"./messageHandlers/setInnerHtmlHandler.ts\";\n\n/**\n * The Webcomponent SDK is tailored for using Myop components packaged as separate bundles and exposed as web components.<br/>\n * Developers importing this SDK can leverage APIs and utilities specifically crafted to support the lifecycle management and communication patterns required for web components within the Myop architecture.<br/>\n * This SDK promotes reusability and encapsulation, enabling developers to build modular, self-contained components that can be seamlessly integrated into the host application's DOM structure.\n *\n *\n * Once loaded the `Root SDK`, you can load the `IframeSDK`\n * ```js\n * const {WebComponentSDK} = (await window.myop.rootSDK.getWebcomponentModule());\n * ```\n * or\n * ```ts\n * import {getWebcomponentModule} from '@myop/sdk';\n * const {WebComponentSDK} = (await getWebcomponentModule());\n * ```\n *\n */\nexport class WebComponentSDK extends BaseMyopSDK {\n\n    alwaysPassEnvelopesToHost = true;\n\n    //when new web component created.\n    connectedCallback = (container: HTMLElement, shadow: ShadowRoot) => {\n        container.addEventListener(myopWebcomponentConsts.webcomponent_message_key, (e: any) => {\n            //debugger;\n            const eventContent = e.data ? e.data : e.detail;\n            if (!eventContent || !eventContent.myop) {\n                debugger;\n                throw new Error('recvied webcomponent_message with wrong type')\n            } else {\n                const message = eventContent as BaseMyopMessage;\n\n                //TODO : send container / compoennt identifier for multil components support\n                this.handleIncomeMessages(e)\n\n                if (message.messageType === MyopMessages.InitMessage) {\n                    // @ts-ignore\n                    const newComponentId = (message as InitMessage).content.id;\n                    this.components[newComponentId].context = new ShadowRootRef(container, shadow)\n\n                    // this.supportedHandlers.forEach(handler => {\n                    //     handler.context = this.shadowRoots;\n                    // });\n                }\n            }\n        })\n\n        //TODO : fix that hack. race condition with host.load when module loaded\n        setTimeout(() => {\n            this.messageToHost(new InitRequest())\n        }, 1)\n    }\n\n    messageToHost = (message: MyopBindReplayMessage, replayTo?: MyopBindMessage) => {\n        message.direction = MessageDirection.up\n        //message.replayToHandler = replayTo?.handlerUniqueId;\n\n        if (!message.replayToHandler && replayTo?.handlerUniqueId)\n            message.replayToHandler = replayTo.handlerUniqueId\n\n        window.myop.hostSDK.send(message)\n    }\n\n    supportedHandlers: BaseWebComponentMessageHandler[] = [\n        new ChangeTextHandler(this.messageToHost, this.components),\n        new SetInnerHtmlHandler(this.messageToHost, this.components),\n        new BindOnClickHandler(this.messageToHost, this.components),\n        new DetectMyopRefsMessageHandler(this.messageToHost, this.components),\n        new setAttributeHandler(this.messageToHost, this.components),\n        new AddEventListenerHandler(this.messageToHost, this.components),\n        new ExecuteScriptHandler(this.messageToHost, this.components),\n        new GetElementValueHandler(this.messageToHost, this.components),\n        //\n        new CreateRefComponentMessageHandler(this.messageToHost, this.components)\n    ];\n\n    public init = () => {\n        //this.myComponentId\n        //this.handleIncomeMessages\n    }\n}\n\ndefineDynamicImport('WebComponentSDK', WebComponentSDK);\n", "import {MyopWebComponent} from \"../components/myopWebcomponent\";\nimport {MyopExtractedWebComponent} from \"../components/myopExtractedWebComponent\";\nimport {BaseMyopLoader} from \"./IMyopLoader\";\nimport {loaderOptions} from \"../hostSDK.ts\";\nimport {uuidv4} from \"../../utils/utils.ts\";\nimport {\n    IComponentDefinitionConfig,\n    IHTMLLoaderConfig,\n    ISkinConfig, ShadowRootModeType,\n    SkinLoaders,\n    RenderMode, RenderPolicy\n} from \"../../common\";\nimport {WebComponentSDK} from \"../../webcomponent\";\nimport {MyopIframeComponent} from \"../components/myopIframeComponent.ts\";\nimport {EMBEDDED_SDK_CONTENT, HAS_EMBEDDED_SDK} from \"../embeddedSDK.ts\";\n//import {getWebcomponentModule} from \"../../SDK.ts\";\n\nconst MYOP_WEB_COMPONENT_MARKER = '<!-- myop-web-component -->';\nconst MYOP_WEB_COMPONENT_SCRIPT_ID = 'myop-web-component';\n\n// Track extracted web component scripts to prevent double registration.\n// Maps scriptId -> the tag name that script registered. The tag MUST be remembered per\n// script: window.__MYOP_TAG_NAME__ is a single global slot that every extracted component\n// overwrites, so on a re-mount (script skipped) it holds whichever component ran last.\nconst extractedWebComponentScripts: Map<string, string> = new Map();\n\nconst seen: string[] = [];\nlet sdk;\nconst getInitiatedSdk = async () => {\n    if (!sdk) {\n        //const {WebComponentSDK} = await getWebcomponentModule()\n        sdk = new WebComponentSDK();\n        sdk.init();\n    }\n    return sdk;\n}\n\nfunction createHTMLElementConstructor(htmlString: string, ShadowRootMode?: keyof typeof ShadowRootModeType): new () => HTMLElement {\n    return class extends HTMLElement {\n\n        connectedCallback() {\n            const mode = ShadowRootMode === ShadowRootModeType.open ? 'open' : 'closed';\n            const shadow = this.attachShadow({mode});\n            getInitiatedSdk().then((sdk) => {\n                sdk.connectedCallback(this, shadow);\n                shadow.innerHTML = htmlString\n            })\n        }\n    };\n}\n\nconst createCustomWebComponent = (componentName: string, html: string, ShadowRootMode?: keyof typeof ShadowRootModeType) => {\n    customElements.define(componentName, createHTMLElementConstructor(html, ShadowRootMode));\n    console.log(`define('${componentName}') was called, web component ready to use`);\n}\n\nconst toWebComponentName = (str) => {\n    return str\n        .replace(/([a-z])([A-Z])/g, '$1-$2') // Add hyphen before uppercase letters\n        .replace(/(\\d+)/g, '-$1') // Add hyphen before digits\n        .toLowerCase(); // Convert to lowercase\n}\n\nconst toCustomElementName = (name: string) => {\n    name = toWebComponentName(name);\n    return name.replace(/_/g, '-');\n}\n\nlet parser: DOMParser; // = new DOMParser();\n\nexport class HTMLComponentLoader extends BaseMyopLoader {\n\n    type = SkinLoaders.HTMLLoader\n\n    /**\n     * Detect if HTML is a Myop Web Component (starts with marker comment)\n     */\n    private isMyopWebComponent(html: string): boolean {\n        return html.trimStart().startsWith(MYOP_WEB_COMPONENT_MARKER);\n    }\n\n    /**\n     * Resolve how this component should render, applying the host render policy.\n     * Precedence: options.renderPolicy (per-call) fully replaces the global\n     * hostSDK.setRenderPolicy \u2014 so an app can restrict globally and allow specifics.\n     * With no policy set, behavior is unchanged from before (marker \u21D2 web component).\n     */\n    private async resolveRenderMode(\n        componentDefinition: IComponentDefinitionConfig,\n        skin: ISkinConfig,\n        loaderConfig: IHTMLLoaderConfig,\n        isWebComponent: boolean,\n        options?: loaderOptions,\n    ): Promise<{ mode: RenderMode | false; isolate: boolean }> {\n        const requestedMode: RenderMode = isWebComponent\n            ? 'webComponent'\n            : ((loaderConfig.isolation || options?.isolation) ? 'isolatedIframe' : 'iframe');\n\n        // per-call policy wins; else global policy on the host SDK singleton.\n        const policy: RenderPolicy | undefined =\n            options?.renderPolicy ?? (window as any)?.myop?.hostSDK?.getRenderPolicy?.();\n\n        const mode: RenderMode | false = policy\n            ? await policy({ componentDefinition, skin, requestedMode, isWebComponent })\n            : requestedMode;\n\n        return { mode, isolate: mode === 'isolatedIframe' };\n    }\n\n    /**\n     * The in-frame bridge for isolated components. Runs inside the sandboxed\n     * (opaque-origin) iframe, translating the same author-facing contract to/from\n     * postMessage since the host has no same-origin access:\n     *   \u2022 data-in : parent posts {type:'myop:init'} \u2192 calls window.myop_init_interface\n     *               (plus a baked initial value for the first render)\n     *   \u2022 data-out: window.myop_cta_handler \u2192 parent.postMessage({type:'myop:cta'})\n     *   \u2022 resize  : ResizeObserver \u2192 parent.postMessage({type:'myop:size'})\n     *\n     * TODO(dev-extension): the isolated path deliberately skips the same-origin\n     * dataScript, so it never posts the `MYOP_PREINJECTED_INIT` message the Myop dev\n     * extension listens for to log the INITIAL render (`init*`). Later init updates and\n     * all CTAs are still tracked (the extension wraps `comp.props`, which our isolated\n     * connectProps branch routes through), so only the first-render payload is missing\n     * from the extension's activity log for isolated components. Closing this would be a\n     * ~1-line `parent.postMessage({type:'MYOP_PREINJECTED_INIT', payload:{data}})` inside\n     * flushInitial() below \u2014 intentionally NOT done for now to avoid adding extension-only\n     * traffic to the component runtime. Web components have the same initial-init gap\n     * (initWithData is called on the element, not via comp.props) and it predates this.\n     */\n    private buildIsolationBridge(initialDataLiteral: string): string {\n        return `<script>\n            (function () {\n                var __initial = ${initialDataLiteral};\n                var __pending;\n                // data-out (cta)\n                window.myop_cta_handler = function (action, payload) {\n                    try { parent.postMessage({ __myop: true, type: 'myop:cta', action: action, payload: payload }, '*'); } catch (e) {}\n                };\n                function callInit(data) {\n                    if (typeof window.myop_init_interface === 'function') { window.myop_init_interface(data); return true; }\n                    return false;\n                }\n                // data-in (init updates)\n                window.addEventListener('message', function (e) {\n                    var d = e.data;\n                    if (!d || d.__myop !== true) return;\n                    if (d.type === 'myop:init') { if (!callInit(d.data)) __pending = d.data; }\n                });\n                // first render: use a pending update if one arrived, else the baked initial data\n                (function flushInitial() {\n                    var data = (__pending !== undefined) ? __pending : __initial;\n                    if (data === undefined) return;\n                    if (callInit(data)) { __pending = undefined; __initial = undefined; }\n                    else requestAnimationFrame(flushInitial);\n                })();\n                // resize (report content size)\n                function contentHeight() {\n                    // Measure the BODY (content box). documentElement.scrollHeight includes\n                    // the iframe viewport \u2014 which we're driving \u2014 so it would report the\n                    // current frame height, not the content, and never shrink.\n                    var b = document.body;\n                    if (b) return Math.max(b.scrollHeight, b.offsetHeight);\n                    return document.documentElement.scrollHeight;\n                }\n                function postSize() {\n                    try {\n                        parent.postMessage({\n                            __myop: true, type: 'myop:size',\n                            height: contentHeight(),\n                            width: document.documentElement.scrollWidth\n                        }, '*');\n                    } catch (e) {}\n                }\n                // Observe the BODY (reflows with content) \u2014 not documentElement, whose box is\n                // the iframe viewport and would feed back into a resize loop. A MutationObserver\n                // catches content swaps (e.g. innerHTML re-render) that don't change body's box.\n                if (window.ResizeObserver) {\n                    try { var __ro = new ResizeObserver(postSize); if (document.body) __ro.observe(document.body); } catch (e) {}\n                }\n                if (window.MutationObserver && document.body) {\n                    try { new MutationObserver(postSize).observe(document.body, { childList: true, subtree: true, attributes: true, characterData: true }); } catch (e) {}\n                }\n                window.addEventListener('load', postSize);\n                postSize();\n            })();\n        </script>`;\n    }\n\n    /**\n     * Extract the web component script content from HTML\n     */\n    private extractWebComponentScript(html: string): string | null {\n        const parser = new DOMParser();\n        const doc = parser.parseFromString(html, 'text/html');\n        const script = doc.getElementById(MYOP_WEB_COMPONENT_SCRIPT_ID);\n        return script?.textContent || null;\n    }\n\n    /**\n     * Execute the web component script on the host document.\n     * Returns the custom element tag name this script registered.\n     */\n    private executeWebComponentScript(scriptContent: string, scriptId: string): string | undefined {\n        // Check if already executed (by script content hash)\n        const cachedTagName = extractedWebComponentScripts.get(scriptId);\n        if (cachedTagName) {\n            console.log(`[MyopWebComponent] Script already executed for ${scriptId}, reusing <${cachedTagName}>`);\n            return cachedTagName;\n        }\n\n        const script = document.createElement('script');\n        script.textContent = scriptContent;\n        script.id = `myop-extracted-${scriptId}`;\n        document.head.appendChild(script);\n\n        // Read the global immediately: the next extracted script to run will overwrite it.\n        const tagName = (window as any).__MYOP_TAG_NAME__;\n        if (tagName) {\n            extractedWebComponentScripts.set(scriptId, tagName);\n        }\n        console.log(`[MyopWebComponent] Executed web component script: ${scriptId} -> <${tagName}>`);\n        return tagName;\n    }\n\n    /**\n     * Load a Myop Web Component (extracted and run on host document)\n     */\n    private async loadExtractedWebComponent(\n        componentDefinition: IComponentDefinitionConfig,\n        skin: ISkinConfig,\n        container: HTMLElement,\n        html: string,\n        options?: loaderOptions\n    ): Promise<MyopExtractedWebComponent> {\n        const scriptContent = this.extractWebComponentScript(html);\n\n        if (!scriptContent) {\n            throw new Error('[MyopWebComponent] No <script id=\"myop-web-component\"> found in HTML');\n        }\n\n        // Use component definition id as script identifier for deduplication\n        const scriptId = `${componentDefinition.id}-${skin.id}`;\n\n        // Execute the script on the host document, or reuse the tag it registered earlier.\n        // Never re-read window.__MYOP_TAG_NAME__ here: on a re-mount the script is skipped and\n        // the global still points at whichever component's script ran last, which would build\n        // this container's element from another component's tag.\n        const tagName = this.executeWebComponentScript(scriptContent, scriptId);\n\n        if (!tagName) {\n            throw new Error('[MyopWebComponent] Script did not set window.__MYOP_TAG_NAME__');\n        }\n\n        // Create the custom element\n        const domId = `myop-comp-${uuidv4()}`;\n        const element = document.createElement(tagName);\n        element.id = domId;\n\n        if (options?.hidden) {\n            element.style.opacity = '0';\n            element.style.position = 'absolute';\n            element.style.height = '0';\n            element.style.width = '0';\n            element.style.pointerEvents = 'none';\n            element.style.visibility = 'hidden';\n        }\n\n        // Clear container if needed\n        if (!container.querySelector('[id^=\"myop-comp-\"]')) {\n            container.innerHTML = '';\n        }\n\n        this.appendChild(container, element, options);\n\n        // Create the component wrapper\n        const component = new MyopExtractedWebComponent(\n            componentDefinition,\n            skin,\n            container,\n            element,\n            tagName,\n            options\n        );\n\n        // Initialize with data if provided\n        if (options?.data !== undefined) {\n            component.initWithData(options.data);\n        }\n\n        console.log(`[MyopWebComponent] Loaded <${tagName}> into container`);\n\n        return component;\n    }\n\n    load = async (componentDefinition: IComponentDefinitionConfig, skin: ISkinConfig, container: HTMLElement, options?: loaderOptions) => {\n\n        const loaderConfig = (skin.loader as IHTMLLoaderConfig);\n\n        const isWC = this.isMyopWebComponent(loaderConfig.HTML);\n        const { mode, isolate } = await this.resolveRenderMode(componentDefinition, skin, loaderConfig, isWC, options);\n\n        if (mode === false) {\n            throw new Error(`[Myop] Rendering blocked by render policy for component \"${componentDefinition.id}\"`);\n        }\n\n        if (isWC) {\n            // Web-component HTML only supports the web-component contract; a policy that\n            // denies it has no iframe fallback (see plan \u00A73.3) \u2014 block rather than\n            // silently render broken. Untrusted contributors must ship iframe components.\n            if (mode !== 'webComponent') {\n                throw new Error(`[Myop] Web-component rendering denied by render policy for component \"${componentDefinition.id}\"`);\n            }\n            return this.loadExtractedWebComponent(componentDefinition, skin, container, loaderConfig.HTML, options);\n        }\n\n        let domId = `myop-comp-${uuidv4()}`\n        let element;\n\n        if (loaderConfig.shadowRootMode === ShadowRootModeType.localFrame) {\n            const uniqId = uuidv4();\n            const domId = `myop-comp-${uniqId}`\n\n            let IframeElement = document.createElement('iframe');\n            IframeElement.id = domId;\n\n            // Full isolation: a sandbox WITHOUT allow-same-origin gives the frame an\n            // opaque origin \u2014 no host DOM/cookies/parent access. Must be set before\n            // the frame navigates (i.e. before srcdoc / append).\n            if (isolate) {\n                IframeElement.setAttribute('sandbox', 'allow-scripts allow-forms allow-popups');\n            }\n\n            // Set all styles BEFORE appending to prevent flash at wrong position\n            IframeElement.style.cssText = `\n                display: block;\n                padding: 0;\n                margin: 0;\n                position: absolute;\n                inset: 0;\n                overflow: hidden;\n                border: none;\n                opacity: ${options?.hidden ? '0' : '1'};\n                width: 100%;\n                height: 100%;\n                pointer-events: ${options?.hidden ? 'none' : 'all'};\n            `;\n\n            // TODO : do it only with flag ?\n            if (!container.querySelector('[id^=\"myop-comp-\"]'))\n                container.innerHTML = '';\n\n            IframeElement = this.appendChild(container, IframeElement, options) as HTMLIFrameElement;\n\n            // Write content into the iframe. An isolated (sandboxed, opaque-origin) frame\n            // can't be doc.write()'n from the host, so accumulate the markup and set it via\n            // srcdoc on close(). Non-isolated frames keep the same-origin doc.write path.\n            const __srcParts: string[] = [];\n            const doc: { open(): void; writeln(s: string): void; close(): void } = isolate\n                ? {\n                    open() {},\n                    writeln(s: string) { __srcParts.push(s); },\n                    close() { IframeElement.srcdoc = __srcParts.join('\\n'); },\n                }\n                : (() => {\n                    //@ts-ignore\n                    const d = IframeElement.contentDocument || IframeElement.contentWindow.document;\n                    d.open();\n                    return d;\n                })();\n\n\n            // Parse myop:size meta tag before iframe creation (same DOMParser pass pattern as myop_preview removal).\n            // This lets the React host determine sizing mode (fill vs content) from the start.\n            let parsedSizeMeta: { width?: string | number; height?: string | number; minWidth?: number; maxWidth?: number; minHeight?: number; maxHeight?: number } | null = null;\n            {\n                const _preParser = new DOMParser();\n                const _preDoc = _preParser.parseFromString(loaderConfig.HTML, 'text/html');\n                const sizeMeta = _preDoc.querySelector('meta[name=\"myop:size\"]');\n                if (sizeMeta) {\n                    try { parsedSizeMeta = JSON.parse(sizeMeta.getAttribute('content') || '{}'); } catch {}\n                }\n            }\n\n            let HTML2Render = loaderConfig.HTML;\n\n            if (options?._inspection) {\n                //inject inspection script for props detection\n                const parser = new DOMParser();\n                const _doc = parser.parseFromString(loaderConfig.HTML, 'text/html');\n\n                // TODO : part of AI components, think about that, document it.\n                const myop_preview_script = _doc.getElementById('myop_preview');\n                myop_preview_script?.removeAttribute('type');\n\n                // Parse the injected HTML string into a node\n                const temp = _doc.implementation.createHTMLDocument();\n                temp.body.innerHTML = `<script>\n                        const beforeKeysWindow = new Set(Object.keys(window));\n                        window.myopState = {\n                            beforeKeysWindow,\n                        };\n                </script>`;\n\n                const node = temp.body.firstChild;\n\n                if (node && _doc.head) {\n                    _doc.head.insertBefore(_doc.importNode(node, true), _doc.head.firstChild);\n                }\n\n                // Prepend DOCTYPE: documentElement.outerHTML returns only <html>...</html>\n                // and drops the doctype, which would put the iframe in quirks mode.\n                // Quirks mode breaks auto-sizing because <body> stretches to the iframe\n                // viewport instead of shrinking to content, so ResizeObserver on body\n                // never fires when content reflows (e.g. after font swap).\n                HTML2Render = '<!DOCTYPE html>' + _doc.documentElement.outerHTML;\n            } else if (options?.data !== undefined) {\n\n                //TODO: improve by do it on the serve once\n\n                // Remove myop_preview script when not in inspection mode\n                const parser = new DOMParser();\n                const _doc = parser.parseFromString(loaderConfig.HTML, 'text/html');\n                const myop_preview_script = _doc.getElementById('myop_preview');\n\n                if (myop_preview_script) {\n                    myop_preview_script.remove();\n                    // See note above: prepend DOCTYPE to keep the iframe in standards mode.\n                    HTML2Render = '<!DOCTYPE html>' + _doc.documentElement.outerHTML;\n                }\n            }\n\n            // Inject host-provided CSS before the iframe is written so styles are\n            // present on first paint (no FOUC). Appended last in <head> so it wins\n            // over the component's own styles via normal cascade order.\n            if (options?.injectCss) {\n                const parser = new DOMParser();\n                const _doc = parser.parseFromString(HTML2Render, 'text/html');\n                const styleTag = _doc.createElement('style');\n                styleTag.setAttribute('data-myop-injected', 'true');\n                // <style> is an HTML raw-text element: the serializer below writes its\n                // contents LITERALLY, without escaping. CSS containing \"</style>\" would\n                // therefore close the tag and inject live markup into the iframe, which\n                // executes same-origin with this page. Neutralize the sequence \u2014 no real\n                // stylesheet contains it. (Same class of bug as the </script> escape in\n                // the data payload below.)\n                styleTag.textContent = options.injectCss.replace(/<\\s*\\/\\s*style/gi, '<\\\\/style');\n                (_doc.head || _doc.documentElement).appendChild(styleTag);\n                // See note above: prepend DOCTYPE to keep the iframe in standards mode.\n                HTML2Render = '<!DOCTYPE html>' + _doc.documentElement.outerHTML;\n            }\n\n\n            doc.writeln(HTML2Render);\n\n            // window.__federation__ =\n            //     { ...window.__federation__,\n            //         //TODO : get from ENV at build time,\n            //         // inject value to module at build time\n            //         // today we doing so just for the CJS version\n            //         __public_path__ :'https://cdn.myop.dev/sdk/next'\n            //         ,...${JSON.stringify(\n            //                 // @ts-ignore\n            //                 window.__federation__)\n            //              }\n            //     };\n\n            // For npm package users with bundlers (Vite/Webpack), inject SDK inline\n            // For CDN users (script tag), use CDN URL\n            const sdkScript = HAS_EMBEDDED_SDK\n                ? `<script>${EMBEDDED_SDK_CONTENT}</script>`\n                : `<script src=\"${window.myop.__ROOT_SDK_PUBLIC_URL__}\"></script>`;\n\n            // Different init script for embedded vs CDN SDK\n            // - Embedded (bundled IIFE): uses MyopSDK.getIframeModule() which returns module directly\n            // - CDN (dynamic loading): uses window.myop.rootSDK.getIframeModule() which wraps with .get()\n            const initScript = HAS_EMBEDDED_SDK\n                ? `<script>\n                   const __myop_init = async () => {\n                        const iframeModule = await MyopSDK.getIframeModule();\n                        const IframeSDK = iframeModule.IframeSDK;\n                        const sdk = new IframeSDK();\n                        sdk.init();\n                   }\n                   __myop_init().then();\n                </script>`\n                : `<script>\n                   window.__federation__.__public_path__ = window.__federation__.__public_path__;\n                   const __myop_init = async () => {\n                        const {IframeSDK} = (await window.myop.rootSDK.getIframeModule());\n                        const sdk = new IframeSDK();\n                        sdk.init();\n                   }\n                   __myop_init().then();\n                </script>`;\n\n            // Isolated frames use the postMessage bridge instead of the same-origin\n            // IframeSDK + data-injection scripts (which rely on host\u2194frame access).\n            if (!isolate) {\n                doc.writeln(`${sdkScript}${initScript}`);\n            }\n\n            // Inject data script if data option is provided\n            if (!isolate && options?.data !== undefined) {\n                // Setup CTA queue - captures any CTAs emitted during init before host registers handler\n                const ctaQueueScript = `<script>\n                    window.__myop_cta_queue = [];\n                    window.myop_cta_handler = function(action, payload) {\n                        window.__myop_cta_queue.push({action: action, payload: payload});\n                    };\n                </script>`;\n\n                // Escape data for safe embedding in script tag\n                // JSON.stringify doesn't escape </script> which could break HTML parsing\n                const escapedData = JSON.stringify(options.data)\n                    .replace(/<\\/script/gi, '\\\\u003c/script');\n\n                // Self-contained data injection script that:\n                // 1. Calls myop_init_interface immediately if already defined\n                // 2. Watches for late-defined myop_init_interface via defineProperty\n                // 3. Cleans up after itself (removes script tag and window data)\n                // 4. Posts message to parent for extension tracking (pre-injected init*)\n                const dataScript = `<script id=\"__myop_init_data_script\">\n                    (function() {\n                        var data = ${escapedData};\n                        var scriptEl = document.getElementById('__myop_init_data_script');\n\n                        var callInitInterface = function(fn) {\n                            var startTime = performance.now();\n                            // Mark as pre-injected data call for extension tracking\n                            window.__myop_init_preinjected = true;\n                            try {\n                                fn(data);\n                            } finally {\n                                window.__myop_init_preinjected = false;\n                            }\n                            var duration = performance.now() - startTime;\n\n                            // Notify extension via postMessage (init* = pre-injected)\n                            try {\n                                window.parent.postMessage({\n                                    type: 'MYOP_PREINJECTED_INIT',\n                                    payload: {\n                                        data: data,\n                                        duration: duration,\n                                        timestamp: Date.now()\n                                    }\n                                }, '*');\n                            } catch (e) {}\n\n                            // Cleanup: remove script tag and stored data\n                            if (scriptEl && scriptEl.parentNode) {\n                                scriptEl.parentNode.removeChild(scriptEl);\n                            }\n                            delete window.__myop_init_data;\n                        };\n\n                        if (typeof window.myop_init_interface === 'function') {\n                            // Function already exists - call immediately\n                            callInitInterface(window.myop_init_interface);\n                        } else {\n                            // Function not yet defined - store data and watch for definition\n                            window.__myop_init_data = data;\n\n                            var _original;\n                            Object.defineProperty(window, 'myop_init_interface', {\n                                configurable: true,\n                                enumerable: true,\n                                set: function(fn) {\n                                    _original = fn;\n                                    if (window.__myop_init_data !== undefined) {\n                                        var storedData = window.__myop_init_data;\n                                        delete window.__myop_init_data;\n                                        callInitInterface(fn);\n                                    }\n                                },\n                                get: function() {\n                                    return _original;\n                                }\n                            });\n                        }\n                    })();\n                </script>`;\n                doc.writeln(ctaQueueScript + dataScript);\n            }\n\n            // Isolated frames: inject the postMessage bridge (init in / cta out / size out).\n            if (isolate) {\n                const escapedData = options?.data !== undefined\n                    ? JSON.stringify(options.data).replace(/<\\/script/gi, '\\\\u003c/script')\n                    : 'undefined';\n                doc.writeln(this.buildIsolationBridge(escapedData));\n            }\n\n            doc.close();\n\n            // TODO : control from dashboard\n            //  (skin.loader as IIframeLoaderConfig).autoHeight = true;\n\n            const comp = new MyopIframeComponent(componentDefinition, skin, container, IframeElement, options);\n\n            // Isolated: wire the host side of the postMessage bridge (cta in, size in, init out).\n            if (isolate) comp.enableIsolation();\n\n            // Store parsed sizeMeta on the component so the React host can read it\n            comp.sizeMeta = parsedSizeMeta;\n\n            // Auto-size: observe content size and sync to iframe dimensions.\n            // This works for all hosts (vanilla SDK, React, Vue, Angular).\n            // If a framework host (e.g. @myop/react) also calls observeAutoSize(),\n            // it cleanly replaces these observers via _autoSizeCleanup tracking.\n            comp.initiated().then(() => {\n                if (options?.autoSize === false) {\n                    // No auto-sizing. Iframe stays position:absolute filling container.\n                    // Host is fully responsible for container dimensions (e.g. React Native WebView).\n                    return;\n                }\n                let shown = false;\n                comp.observeAutoSize({\n                    forceAutoSize: true,\n                    onSizeChange: () => {\n                        // Show after first measurement completes (not before).\n                        // The iframe transitions from absolute overlay to document flow\n                        // at the measured height, preventing flash at wrong size.\n                        if (!shown && !options?.hidden) {\n                            shown = true;\n                            comp.show();\n                        }\n                    }\n                });\n            });\n            // // @ts-ignore\n            // comp.props._global = comp.element.contentWindow;\n            return comp;\n\n        }\n\n        if (loaderConfig.shadowRootMode === ShadowRootModeType.none) {\n            // parser = parser ? parser : new DOMParser();\n            // const doc = parser.parseFromString(loaderConfig.HTML, 'text/html');\n            // element = doc.body.firstChild;\n            //element.setAttribute('id', domId);\n\n            const template = document.createElement('template');\n            template.innerHTML = loaderConfig.HTML;//.trim();\n            element = template.content.firstElementChild;\n\n            //   const firstElement = template.content.firstElementChild;\n            //   const z = firstElement ? firstElement.tagName.toLowerCase() : null;\n            //   debugger;\n            //   console.log(template, firstElement, z)\n            //   element = firstElement\n\n            // const container = document.createElement('tbody');\n            // debugger;\n            // container.innerHTML = loaderConfig.HTML;\n            // element = container.firstElementChild;\n\n            getInitiatedSdk().then((sdk) => {\n                sdk.connectedCallback(element, element);\n            })\n        } else {\n            const customElementName = toCustomElementName(componentDefinition.name + skin.id);\n\n            //TODO : support redefine !\n            if (!seen.includes(customElementName)) {\n                createCustomWebComponent(customElementName, loaderConfig.HTML, loaderConfig.shadowRootMode);\n                seen.push(customElementName);\n            }\n            element = document.createElement(customElementName);\n        }\n        // TODO : do it only with flag ?\n        if (!container.querySelector('[id^=\"myop-comp-\"]'))\n            container.innerHTML = '';\n\n        //element.style.visibility = 'hidden';\n        element.id = domId;\n\n        if (options?.hidden) {\n            element.style.opacity = '0';\n            element.style.position = 'absolute'\n            element.style.height = '0'\n            element.style.width = '0'\n            element.style.pointerEvents = 'none'\n            element.style.visibility = 'hidden';\n        }\n\n        // if (container.id.startsWith('myop-comp-')) {\n        //     // in place replacement\n        //     container.replaceWith(element);\n        //     //container = element.parentElement!;\n        // } else {\n        //     container.appendChild(element);\n        // }\n\n        this.appendChild(container, element, options);\n\n        //element.innerHTML = `<${customElementName} />`;\n        return new MyopWebComponent(componentDefinition, skin, container, element, options);\n    }\n}\n", "import {\n    IComponentConfig,\n    IComponentDefinitionConfig,\n    IComponentInstanceConfig,\n    IDedicatedSkinConfig,\n    IPropConfig,\n    ISkinConfig,\n    IUserFlow,\n    PropConfigBehaviorTypes,\n    v2_IVariantConfig\n} from \"../common\";\n\nconst convertV2VariantToComponentConfig = (config: v2_IVariantConfig): IComponentConfig => {\n    return {\n        instance: {\n            id: 'auto',\n            componentId: config.componentId,\n            componentName: config.name,\n\n            skinSelector: {\n                type: 'Dedicated',\n                skin: {\n                    id: 'skin_auto_v2_converted'\n                }\n            } as IDedicatedSkinConfig\n\n        } as IComponentInstanceConfig,\n        type: {\n            id: config.id,\n            name: config.name,\n            description: config.description,\n            props: [\n                {\n                    id: 'in_auto_v2_converted',\n                    name: 'myop_init_interface',\n                    type: 'any',\n                    behavior: {\n                        type: PropConfigBehaviorTypes.code\n                    }\n                } as IPropConfig,\n\n                {\n                    id: 'out_auto_v2_converted',\n                    name: 'myop_cta_handler',\n                    type: 'any',\n                    behavior: {\n                        type: PropConfigBehaviorTypes.code\n                    }\n                } as IPropConfig\n            ],\n            refs: [],\n            skins: [\n                {\n                    id: 'skin_auto_v2_converted',\n                    name: 'auto_v2_converted',\n                    description: '',\n                    //TODO : handle empty :\n                    // @ts-ignore\n                    loader: config.consume_variant[0].loader\n                } as ISkinConfig\n            ],\n            defaultSkin: 0\n        } as IComponentDefinitionConfig,\n        name: config.name\n    } as IComponentConfig;\n};\n\n/**\n * CloudRepository - Unified cloud data access layer for Myop components\n *\n * Supports both v2 (default) and v1 modes:\n * - v2: Uses /consume endpoint for fetching variants\n * - v1: Uses /flow endpoint for fetching user flows\n */\n// Use a global singleton to ensure only one CloudRepository.Main exists\n// even when the module is loaded multiple times by different bundlers\nconst GLOBAL_KEY = '__MYOP_CLOUD_REPOSITORY_MAIN__';\n\nconst getGlobalMain = (): CloudRepository | undefined => {\n    if (typeof window !== 'undefined') {\n        return (window as any)[GLOBAL_KEY];\n    }\n    if (typeof globalThis !== 'undefined') {\n        return (globalThis as any)[GLOBAL_KEY];\n    }\n    return undefined;\n};\n\nconst setGlobalMain = (instance: CloudRepository) => {\n    if (typeof window !== 'undefined') {\n        (window as any)[GLOBAL_KEY] = instance;\n    }\n    if (typeof globalThis !== 'undefined') {\n        (globalThis as any)[GLOBAL_KEY] = instance;\n    }\n};\n\nexport class CloudRepository {\n    private static _main: CloudRepository | null = null;\n\n    static get Main(): CloudRepository {\n        // Check if a global instance already exists (from another bundle)\n        const globalMain = getGlobalMain();\n        if (globalMain) {\n            return globalMain;\n        }\n\n        // Create new instance if needed\n        if (!CloudRepository._main) {\n            CloudRepository._main = new CloudRepository();\n            setGlobalMain(CloudRepository._main);\n        }\n        return CloudRepository._main;\n    }\n\n    // v2 cache - keyed by componentId:env:preview|live\n    // Each Promise is tagged with a `resolved` property after settling (see fetchComponentV2).\n    private variants: Record<string, Promise<IComponentConfig> & { resolved?: IComponentConfig }> = {};\n\n    // Track which components were preloaded and with what params\n    // Key: componentId, Value: { env, preview }\n    private preloadedComponents: Record<string, { env: string; preview: boolean }> = {};\n\n    // v1 cache\n    private userFlows: Record<string, Promise<IUserFlow>> = {};\n\n    private _defaultEnv = 'production';\n    private _envExplicitlySet = false;\n    private _staticMode = false;\n    private _queryParams: Record<string, string> = {};\n\n    constructor(private _baseUrl = 'https://cloud.myop.dev') {\n    }\n\n    /**\n     * Enable static mode for self-hosted component registries.\n     * In static mode, URLs are constructed as file paths instead of query params:\n     *   ${baseUrl}/components/${componentId}/${env}.json\n     */\n    enableStaticMode() {\n        this._staticMode = true;\n    }\n\n    /**\n     * Set query parameters to append to all fetch URLs (e.g. for CDN cache busting).\n     * Example: `setQueryParams({ lastupdate: '11112026' })`\n     */\n    setQueryParams(params: Record<string, string>) {\n        this._queryParams = params;\n    }\n\n    /**\n     * Set the default environment for this CloudRepository instance\n     */\n    setEnvironment(env: string) {\n        this._defaultEnv = env;\n        this._envExplicitlySet = true;\n    }\n\n    /**\n     * Get the current default environment\n     */\n    getDefaultEnvironment(): string {\n        return this._defaultEnv;\n    }\n\n    // ============ V2 Methods (Default) ============\n\n    /**\n     * Check if a component is already cached/preloaded (v2)\n     * If env and preview are not provided, checks if ANY version is preloaded\n     */\n    isPreloaded(componentId: string, env?: string, preview?: boolean): boolean {\n        // If specific env/preview requested, check exact match\n        if (env !== undefined || preview !== undefined) {\n            const cacheKey = `${componentId}:${env || this._defaultEnv}:${preview ? 'preview' : 'live'}`;\n            return cacheKey in this.variants;\n        }\n        // Otherwise check if any version was preloaded\n        return componentId in this.preloadedComponents;\n    }\n\n    /**\n     * Get the preloaded params for a component (if preloaded)\n     * Returns undefined if not preloaded\n     */\n    getPreloadedParams(componentId: string): { env: string; preview: boolean } | undefined {\n        return this.preloadedComponents[componentId];\n    }\n\n    /**\n     * Resolve a component config: fetch it once, then serve it from this\n     * repository's cache.\n     *\n     * This is the name to use. `fetchComponentV2` is the same method under its\n     * versioned name and stays for backward compatibility \u2014 note that the\n     * unversioned `fetchComponent` is a *deprecated v1* API and is NOT this.\n     *\n     * Completes the trio with {@link getResolvedConfig} (synchronous read of an\n     * already-resolved config) and {@link hydrateComponent} (seed one you\n     * already hold).\n     *\n     * Prefer the module-level `preloadComponents([id])` in app code; reach for\n     * this when you need an isolated repository instance whose cache lifetime\n     * you control \u2014 a server with its own TTL, for example.\n     */\n    async resolveComponent(componentId: string, env?: string, preview?: boolean): Promise<IComponentConfig> {\n        return this.fetchComponentV2(componentId, env, preview);\n    }\n\n    /**\n     * Fetch a v2 component config\n     * If env/preview not specified and component was preloaded, uses preloaded params\n     *\n     * @see resolveComponent \u2014 the unversioned name for this method\n     */\n    async fetchComponentV2(componentId: string, environmentIdentifier?: string, preview?: boolean): Promise<IComponentConfig> {\n        const { env, usePreview, cacheKey } = this.resolveParams(componentId, environmentIdentifier, preview);\n\n        console.log('[CloudRepository] fetchComponentV2', {\n            componentId: componentId.slice(0, 8) + '...',\n            env,\n            usePreview,\n            cacheKey,\n            cached: cacheKey in this.variants\n        });\n\n        if (!this.variants[cacheKey]) {\n            // Track this as preloaded (first fetch counts as preload)\n            if (!this.preloadedComponents[componentId]) {\n                this.preloadedComponents[componentId] = { env, preview: usePreview };\n            }\n\n            // eslint-disable-next-line no-async-promise-executor\n            this.variants[cacheKey] = new Promise(\n                async (resolve, reject) => {\n                    try {\n                        let url: string;\n                        if (this._staticMode) {\n                            const file = usePreview ? 'preview' : env;\n                            url = `${this._baseUrl}/components/${componentId}/${file}.json`;\n                            const qs = new URLSearchParams(this._queryParams).toString();\n                            if (qs) url += `?${qs}`;\n                        } else {\n                            url = `${this._baseUrl}/consume?id=${componentId}&env=${env}`;\n                            if (usePreview) {\n                                url += '&preview=true';\n                            }\n                        }\n                        const res = await fetch(url);\n                        if (!res.ok) {\n                            reject(new Error(`Failed to load component \"${componentId}\" (${res.status}${this._staticMode ? ` from ${url}` : ''})`));\n                            return;\n                        }\n                        const json = await res.json();\n                        const variant = json.item;\n\n                        if (!variant) {\n                            reject(new Error(`Component \"${componentId}\" not found`));\n                            return;\n                        }\n\n                        if (!variant.consume_variant || !variant.consume_variant.length) {\n                            reject(new Error(`Component \"${componentId}\" has no implementation for environment \"${env}\"`));\n                            return;\n                        }\n\n                        const componentConfig = convertV2VariantToComponentConfig(variant);\n                        // Tag the Promise so getResolvedConfig can read it synchronously\n                        (this.variants[cacheKey] as any).resolved = componentConfig;\n                        resolve(componentConfig);\n                    } catch (e) {\n                        // Clear the cached rejected promise so the next call\n                        // makes a fresh request (e.g. after network recovery)\n                        delete this.variants[cacheKey];\n                        reject(e);\n                    }\n                }\n            );\n        }\n\n        return await this.variants[cacheKey];\n    }\n\n    /**\n     * Synchronous version of fetchComponentV2 \u2014 returns the config only if\n     * the fetch already completed, null otherwise.\n     *\n     * Uses the same `this.variants` cache that fetchComponentV2/preloadComponents\n     * populate. Each cached Promise is tagged with a `.resolved` property when\n     * it settles \u2014 this method just reads that property. No separate cache.\n     *\n     * Why this exists: React Native needs the config at render time to embed it\n     * in the WebView HTML (can't await in useState). If preloadComponents ran\n     * earlier and the fetch completed, this returns the result synchronously,\n     * skipping the WEBVIEW_READY \u2192 fetch \u2192 inject round trip entirely.\n     */\n    getResolvedConfig(componentId: string, env?: string, preview?: boolean): IComponentConfig | null {\n        const { cacheKey } = this.resolveParams(componentId, env, preview);\n        return this.variants[cacheKey]?.resolved || null;\n    }\n\n    /**\n     * Resolve which (env, preview) pair \u2014 and therefore which cache key \u2014 a call\n     * for `componentId` refers to.\n     *\n     * Single source of truth for fetchComponentV2, getResolvedConfig and\n     * hydrateComponent, so a hydrated config always lands on the key a later\n     * fetch will look under.\n     */\n    private resolveParams(componentId: string, environmentIdentifier?: string, preview?: boolean) {\n        // If no explicit env/preview and component was preloaded, use preloaded params\n        const preloaded = this.preloadedComponents[componentId];\n        const hasExplicitParams = environmentIdentifier !== undefined || preview !== undefined;\n\n        let env: string;\n        let usePreview: boolean;\n\n        if (!hasExplicitParams && preloaded) {\n            // Use preloaded params\n            env = preloaded.env;\n            usePreview = preloaded.preview;\n        } else {\n            // Use provided params or defaults\n            env = environmentIdentifier || this._defaultEnv;\n            // If preview explicitly true \u2192 true\n            // If preview explicitly false \u2192 false\n            // If preview undefined: env was specified (via param or setEnvironment) \u2192 false, otherwise \u2192 true\n            const hasEffectiveEnv = environmentIdentifier || this._envExplicitlySet;\n            usePreview = preview === true ? true : (preview === false ? false : !hasEffectiveEnv);\n        }\n\n        return { env, usePreview, cacheKey: `${componentId}:${env}:${usePreview ? 'preview' : 'live'}` };\n    }\n\n    /**\n     * Seed an already-resolved component config into the cache, without any\n     * network request.\n     *\n     * The counterpart to {@link fetchComponentV2}: use it when the config was\n     * resolved somewhere else \u2014 most often on a server, then embedded in the\n     * page \u2014 so the browser can render the component with no round trip.\n     *\n     * After hydrating, `fetchComponentV2`, `getResolvedConfig` and `isPreloaded`\n     * all answer for this component from memory.\n     *\n     * Pass the same `env` / `preview` the config was resolved with; the defaults\n     * match what a plain `fetchComponentV2(componentId)` would have used.\n     */\n    hydrateComponent(componentId: string, config: IComponentConfig, env?: string, preview?: boolean): void {\n        const { env: resolvedEnv, usePreview, cacheKey } = this.resolveParams(componentId, env, preview);\n\n        const promise = Promise.resolve(config) as Promise<IComponentConfig> & { resolved?: IComponentConfig };\n        // Tag it the same way fetchComponentV2 does, so getResolvedConfig can\n        // read it synchronously.\n        promise.resolved = config;\n\n        this.variants[cacheKey] = promise;\n        this.preloadedComponents[componentId] = { env: resolvedEnv, preview: usePreview };\n    }\n\n    // ============ V1 Methods (Legacy) ============\n\n    /**\n     * Fetch a v1 component from a flow\n     */\n    async fetchComponentV1(componentId: string, flowId?: string) {\n        if (flowId) {\n            const flow = await this.fetchFlow(flowId);\n            return flow.components.find(c => c.type.id === componentId);\n        } else {\n            const flow = await this.fetchAutoFlow(componentId);\n            return flow.components[0];\n        }\n    }\n\n    async fetchAutoFlow(componentId: string) {\n        if (!this.userFlows[componentId]) {\n            // eslint-disable-next-line no-async-promise-executor\n            this.userFlows[componentId] = new Promise(\n                async (resolve, reject) => {\n                    try {\n                        const res = await fetch(\n                            `${this._baseUrl}/flow?id=${componentId}&auto=true`\n                        );\n                        const json = await res.json();\n                        resolve(json.item);\n                    } catch (e) {\n                        delete this.userFlows[componentId];\n                        reject(e);\n                    }\n                }\n            );\n        }\n\n        return await this.userFlows[componentId];\n    }\n\n    async fetchFlow(flowId: string) {\n        if (!this.userFlows[flowId]) {\n            // eslint-disable-next-line no-async-promise-executor\n            this.userFlows[flowId] = new Promise(\n                async (resolve, reject) => {\n                    try {\n                        const res = await fetch(\n                            `${this._baseUrl}/flow?id=${flowId}&resolve=components`\n                        );\n                        const json = await res.json();\n                        resolve(json.item);\n                    } catch (e) {\n                        delete this.userFlows[flowId];\n                        reject(e);\n                    }\n                }\n            );\n        }\n\n        return await this.userFlows[flowId];\n    }\n\n    // ============ Backward Compatibility ============\n\n    /**\n     * @deprecated Use fetchComponentV2 or fetchComponentV1 explicitly\n     * Defaults to v1 behavior for backward compatibility with existing code\n     */\n    async fetchComponent(componentId: string, flowId?: string) {\n        return this.fetchComponentV1(componentId, flowId);\n    }\n}\n\n/**\n * @deprecated Use CloudRepository instead\n */\nexport const v2_CloudRepository = CloudRepository;\n", "import { CloudRepository } from \"./CloudRepository\";\nimport { IComponentConfig } from \"../common\";\n\nlet _cloudRepository = CloudRepository.Main;\n\nexport const getCloudRepository = () => _cloudRepository;\n\nexport const isPreloaded = (componentId: string, env?: string, preview?: boolean): boolean => {\n    return _cloudRepository.isPreloaded(componentId, env, preview);\n};\n\nexport const getPreloadedParams = (componentId: string) => {\n    return _cloudRepository.getPreloadedParams(componentId);\n};\n\nexport const enableLocalDev = () => {\n    _cloudRepository = new CloudRepository(\"http://localhost:9292\");\n};\n\nexport const setCloudRepositoryUrl = (url: string) => {\n    _cloudRepository = new CloudRepository(url);\n};\n\n/**\n * Configure the SDK to fetch components from a self-hosted static registry (S3, CDN, etc.)\n * instead of the Myop cloud. Components are served as static JSON files:\n *   `${cdnUrl}/components/${componentId}/${environment}.json`\n */\nexport const enableSelfHosted = (cdnUrl: string, queryParams?: Record<string, string>) => {\n    _cloudRepository = new CloudRepository(cdnUrl);\n    _cloudRepository.enableStaticMode();\n    if (queryParams) {\n        _cloudRepository.setQueryParams(queryParams);\n    }\n};\n\nexport const setCloudRepository = (repository: CloudRepository) => {\n    _cloudRepository = repository;\n};\n\nexport const setEnvironment = (env: string) => {\n    _cloudRepository.setEnvironment(env);\n};\n\nexport const getResolvedConfig = (componentId: string, env?: string, preview?: boolean) => {\n    return _cloudRepository.getResolvedConfig(componentId, env, preview);\n};\n\nexport const preloadComponents = async (ids: string[], env?: string, preview?: boolean) => {\n    return Promise.allSettled(\n        ids.map((id) => _cloudRepository.fetchComponentV2(id, env, preview)),\n    );\n};\n\n/**\n * Seed already-resolved component configs into the SDK cache, with no network\n * request. The counterpart to {@link preloadComponents}.\n *\n * Use it when the configs were resolved somewhere else \u2014 typically on a server\n * and embedded in the page \u2014 so the component renders with zero round trips:\n *\n * ```ts\n * // server: const configs = { [id]: await new CloudRepository().fetchComponentV2(id) }\n * // client:\n * hydrateComponents(configs);\n * // <MyopComponent componentId={id} /> now renders without fetching\n * ```\n *\n * Pass the same `env` / `preview` the configs were resolved with; the defaults\n * match what a plain `preloadComponents([id])` would have used.\n */\nexport const hydrateComponents = (\n    configs: Record<string, IComponentConfig>,\n    env?: string,\n    preview?: boolean,\n) => {\n    for (const [id, config] of Object.entries(configs)) {\n        _cloudRepository.hydrateComponent(id, config, env, preview);\n    }\n};\n", "import {decompressUUIDs} from \"../utils/uuid.ts\";\nimport {CloudRepository} from \"../helpers\";\nimport {\n    ExperienceTypes,\n    IComponentConfig, IDedicatedSkinConfig,\n    ISegmentedSkinConfig,\n    ISegmentExperience, ISkinInstanceConfig,\n    SkinSelectorTypes\n} from \"../common\";\n\nexport const checkMyopOverride = async (componentConfig: IComponentConfig): Promise<IComponentConfig | null> => {\n    try {\n        //TODO: support disabling the mechanism\n        const url = new URL(window.location.href);\n        const params = new URLSearchParams(url.search);\n        const myopOverride = params.get('myopOverride');\n        if (myopOverride) {\n            const [source, ...uuids] = decompressUUIDs(myopOverride);\n\n            switch (source) {\n                case 'component': {\n                    const [componentId, skinId] = uuids;\n                    const componentToOverride = await CloudRepository.Main.fetchComponent(componentId);\n                    if (componentToOverride) {\n                        // todo: check fetchAutoFlow. Looks like only one skin is returned\n                        const skin = componentToOverride.type.skins.find(skin => skin.id === skinId);\n                        if (skin) {\n                            // todo: for now just set skin id. Check the cloud implementation\n\n                            componentToOverride.instance.skinSelector = {\n                                type: SkinSelectorTypes.Dedicated,\n                                skin: {\n                                    id: skinId\n                                } as ISkinInstanceConfig\n\n                            } as IDedicatedSkinConfig;\n\n                            return componentToOverride\n                        }\n                    }\n                }\n                    break;\n            //    case 'flow': {\n                default : {\n                   // const [flowId, experimentId] = uuids;\n                    const [flowId, experimentId] = decompressUUIDs(myopOverride);\n                    const flow = await CloudRepository.Main.fetchFlow(flowId);\n                    const componentToOverride = flow.components.find(c => c.type.id === componentConfig.type.id);\n                    if (componentToOverride) {\n                        if (componentToOverride.instance.skinSelector.type === SkinSelectorTypes.Segmented) {\n\n                            if (componentToOverride.instance.resolvedExperiences) {\n                                const resolvedExperience = componentToOverride.instance.resolvedExperiences.find(e => e.id === experimentId);\n\n                                if (resolvedExperience?.type === ExperienceTypes.Segment) {\n\n                                    const typedResolvedExperience = resolvedExperience as ISegmentExperience\n\n                                    const typedSkinSelector = componentToOverride.instance.skinSelector as ISegmentedSkinConfig\n                                    const segment = typedSkinSelector.segments.find(s => s.segmentId === typedResolvedExperience.segment.id);\n                                    if (segment) {\n                                        componentToOverride.instance.skinSelector = segment?.skinSelector;\n                                        return componentToOverride;\n                                    }\n                                }\n                            }\n                        }\n                    }\n                }\n                    break;\n            }\n        }\n    } finally {\n        return null;\n    }\n}", "/**\n * @packageDocumentation\n * The Host SDK is designed for integration within the host application that serves as the container for Myop  components.<br/><br/>\n * It provides essential functionalities and APIs for registering, managing, and communicating with Myop components.<br/><br/>\n * This SDK enables seamless embedding of independently developed components into the host application, ensuring smooth interoperability and consistent user experience across various Myop component implementations.\n */\nimport {defineDynamicImport} from \"../dynamicImport/defineDynamicImport\";\nimport {IMyopLoader} from \"./loaders/IMyopLoader\";\nimport {IMyopComponent} from \"./components/IMyopComponent\";\nimport {MyopMessages} from \"../common/MyopMessages\";\nimport {\n    BaseMyopMessage,\n    EnvelopedMessage, ExecuteComponentMethod,\n    InitMessage,\n    InitResponse, MessageDirection, Ref\n} from \"../messages\";\nimport {MyopIframeLoader} from \"./loaders/iframeLoader\";\nimport {WebcomponentLoader} from \"./loaders/webcomponentLoader\";\nimport {RenderPolicy} from \"../common\";\nimport type {IframeSDK} from \"../Iframe\";\nimport {connectProps, connectRefs, createRefComponent} from \"./componentCore\";\nimport {\n    ExperienceTypes,\n    IComponentConfig,\n    IComponentDefinitionConfig,\n    IDedicatedSkinConfig, IExperience, IFunctionResultsSegment, ISegmentedSkinConfig, ISegmentExperience,\n    ISkinConfig, ISkinSelectorConfig, SkinSelectorTypes,\n\n\n} from \"../common\";\n// @ts-ignore handled by custom esbuild plugin\nimport version from \"myop-sdk-version\";\nimport {HTMLComponentLoader} from \"./loaders/HTMLComponentLoader\";\nimport {checkMyopOverride} from \"./myopOverride.ts\";\n\ninterface componentLoaderCreator {\n    new(loaders: IMyopLoader[]): any;\n}\n\n// const getComponentDefinitionConfig = async (id: string) => {\n//     const res = await fetch(`http://localhost:3000/component?id=${id}`);\n//     const componentDef: IComponentDefinitionConfig = (await res.json()).item;\n//     return componentDef\n// }\n\n//const __ROOT_SDK_PUBLIC_URL__ = 'https://dfdlk2p1m187v.cloudfront.net/myop_sdk.min.js'\nconst __ROOT_SDK_PUBLIC_URL__ = 'https://cdn.myop.dev/sdk/next/myop_sdk.min.js'\n\n/**\n * The Host SDK is designed for integration within the host application that serves as the container for Myop  components.<br/><br/>\n * It provides essential functionalities and APIs for registering, managing, and communicating with Myop components.<br/><br/>\n * This SDK enables seamless embedding of independently developed components into the host application, ensuring smooth interoperability and consistent user experience across various Myop component implementations.\n */\nexport class HostSDK {\n    static Instance = () => window.myop.hostSDK;\n\n    components2init: IMyopComponent[] = [];\n    components: IMyopComponent[] = [];\n    componentsLoaders: IMyopLoader[] = [];\n\n    // Global render policy (allow/deny/mode gate). A per-call options.renderPolicy\n    // takes precedence over this \u2014 see HTMLComponentLoader.resolveRenderMode.\n    private _renderPolicy?: RenderPolicy;\n    public setRenderPolicy = (policy?: RenderPolicy) => { this._renderPolicy = policy; };\n    public getRenderPolicy = (): RenderPolicy | undefined => this._renderPolicy;\n\n    public initiated: boolean = false;\n\n    public version = version;\n\n    type2InstanceCount: Record<string, number> = {};\n    public assignId = (componentDefinition: IComponentDefinitionConfig) => {\n        if (!this.type2InstanceCount[componentDefinition.id]) {\n            this.type2InstanceCount[componentDefinition.id] = 0;\n        }\n        return `${componentDefinition.id}_${++this.type2InstanceCount[componentDefinition.id]}`;\n    }\n\n    //TODO : fix the inspect implementation inside refComponent\n    //then inspected maybe can be dropped\n    private inspected = false;\n    public inspect = () => {\n        if (this.inspected)\n            return;\n\n        this.inspected = true;\n\n        this.components.forEach(component => {\n            if (component.inspect) {\n                component.inspect()\n            }\n        })\n    }\n\n    private incomingMessageHandler = (event: MessageEvent<BaseMyopMessage>) => {\n        //console.log('incomingMessageHandler GOT ', event)\n        //TODO :  if (event.origin !== \"http://example.org:8080\") return;\n        if (event.origin === document.location.origin) {\n            //console.log('I Know that !!!');\n            //  return;\n        }\n        //console.log(\"event on host side \", event);\n\n        if (event.data.myop) {\n            if (event.data.direction !== MessageDirection.up && event.data.messageType !== MyopMessages.EnvelopedMessage) {\n                //console.log('message dropped in hostsdk, direction was ', event.data.direction)\n                return;\n            }\n            // console.log(\"event on host side \", event);\n\n            const myopMessage: BaseMyopMessage = event.data;\n\n            if (myopMessage.messageType === MyopMessages.InitRequest) {\n                this.components2init.forEach(component => {\n                    component.send(new InitMessage(component.id))\n                });\n                return;\n            }\n\n            if (myopMessage.messageType === MyopMessages.InitResponse) {\n                // remove from components 2 init\n                // @ts-ignore\n                this.components2init = this.components2init.filter(component => component.id !== (myopMessage as InitResponse).content.id)\n\n                const initiatedComponent = this.components.find(component => component.id === (myopMessage as InitResponse).content?.id);\n                initiatedComponent?.setInitiated()\n                //initiatedComponent?.parent?.setInitiated();\n                // TODO : is it true to not pass further ( to the component )\n                return;\n            }\n\n            if (myopMessage.messageType === MyopMessages.EnvelopedMessage) {\n                //debugger;\n                const typedMessage = myopMessage as EnvelopedMessage\n                const refComponent = this.components.find(component => component.id === typedMessage.destination);\n\n                if (refComponent) {\n                    if (typedMessage.direction === MessageDirection.down) {\n                        if (typedMessage.message.messageType === ExecuteComponentMethod.name) {\n                            refComponent.onMessageReceived(typedMessage.message)\n                        } else {\n                            //\n                            typedMessage.message.route = typedMessage.route;\n                            refComponent.send(typedMessage.message);\n                        }\n                        return;\n                    }\n                } else {\n                    const innerComponent = this.components.find(component => component.id === typedMessage.message.destination);\n                    if (innerComponent) {\n                        innerComponent.send(typedMessage.message)\n                    } else {\n                        // TODO : log ?\n                    }\n                }\n                // @ts-ignore\n                //component.refs.body.onMessageReceived(myopMessage.message);\n\n                return;\n            }\n\n            const component = this.components.find(component => component.id === myopMessage.destination);\n\n            if (!component) {\n                //no in mem component\n                //pass to parent HostSDK to try process there\n                if (window.myop.IframeSDK) {\n                    window.myop.IframeSDK.messageToHost(myopMessage);\n                }\n                return;\n            }\n\n            if (component) {\n                if (component.onMessageReceived(myopMessage)) {\n                    return;\n                } else {\n                    //not processed in onMessageReceived\n                    //pass to parent HostSDK to try process there\n                    if (window.myop.IframeSDK)\n                        window.myop.IframeSDK.messageToHost(myopMessage);\n                }\n            }\n        }\n\n        // event.source.postMessage(\n        //     \"hi there yourself!  the secret response \" + \"is: rheeeeet!\",\n        //     event.origin,\n        //   );\n    }\n\n    public send = (message: BaseMyopMessage) => {\n        const syntheticEvent = new MessageEvent<BaseMyopMessage>('',\n            {data: message}\n        )\n\n        this.incomingMessageHandler(syntheticEvent);\n    }\n\n    public init = (customComponentLoaderCreators?: componentLoaderCreator[]) => {\n        if (this.initiated) {\n            throw new Error('hostSDK already initiated');\n        }\n\n        const basicLoaders = [\n            new MyopIframeLoader(),\n            new WebcomponentLoader(),\n            new HTMLComponentLoader()\n        ];\n\n        this.componentsLoaders = [\n            ...basicLoaders\n        ];\n\n        if (customComponentLoaderCreators) {\n            //debugger;\n            const loaderByType: Record<string, IMyopLoader> = {};\n\n            customComponentLoaderCreators.forEach(customComponentLoaderCreator => {\n                const customLoader = new customComponentLoaderCreator(this.componentsLoaders);\n                loaderByType[customLoader.type] = customLoader;\n            })\n\n            this.componentsLoaders.forEach(loader => {\n                if (!loaderByType[loader.type])\n                    loaderByType[loader.type] = loader;\n            })\n\n            this.componentsLoaders = Object.values(loaderByType);\n        }\n\n        // Incomming messages from IFrames\n        window.addEventListener(\n            \"message\",\n            this.incomingMessageHandler,\n            false,\n        );\n\n        console.log('myop hostSDK initiated', document.location.href);\n        this.initiated = true;\n    }\n\n    private _getSkinIdBySkinSelector = async (skinSelector: ISkinSelectorConfig, experiences: IExperience[] = [], hooks?: loaderHooks): Promise<string> => {\n        async function asyncFind<T>(\n            array: T[],\n            predicate: (item: T) => Promise<boolean>\n        ): Promise<T | undefined> {\n            for (const item of array) {\n                if (await predicate(item)) {\n                    return item;\n                }\n            }\n            return undefined; // Return undefined if no match is found\n        }\n\n        switch (skinSelector.type) {\n            // @ts-ignore\n            case \"DedicatedSkin\" : //backward compatibility\n            case SkinSelectorTypes.Dedicated: {\n                let selectedSkinId = (skinSelector as IDedicatedSkinConfig).skin?.id\n                    || (skinSelector as IDedicatedSkinConfig).skins![0].id;\n\n                return selectedSkinId;\n            }\n                break;\n            case SkinSelectorTypes.Segmented: {\n                const typedSkinSelector = (skinSelector as ISegmentedSkinConfig)\n                const segment = await asyncFind(typedSkinSelector.segments, async segment => {\n                    if (segment.segmentId === 'Default') {\n                        return true;\n                    }\n\n                    const experience = experiences.find(experience => {\n                        if (experience.type === ExperienceTypes.Segment) {\n                            return (experience as ISegmentExperience).segment.id === segment.segmentId\n                        }\n                        return false;\n                    });\n\n                    if (!experience) {\n                        throw new Error(\"experience not found\");\n                    }\n\n                    const typedExperience = experience as ISegmentExperience;\n                    const typedSegment = (typedExperience.segment as IFunctionResultsSegment)\n\n                    const segmentFunction = (hooks ? hooks : {})[typedSegment.function];\n                    if (segmentFunction) {\n                        const results = await segmentFunction();\n                        return results;\n                    } else {\n                        console.warn(`segmentId:${segment.segmentId}, ${typedSegment.function} function not provided !`)\n                    }\n\n                    return false;\n                });\n\n                if (segment)\n                    return this._getSkinIdBySkinSelector(segment.skinSelector, experiences);\n                else {\n                    debugger;\n                }\n            }\n                break;\n            default: {\n                debugger;\n            }\n        }\n        return '' //TODO\n    }\n\n    private runSkinSelector = async (componentConfig: IComponentConfig, hooks?: loaderHooks) => {\n        const skinId = await this._getSkinIdBySkinSelector(componentConfig.instance.skinSelector, componentConfig.instance.resolvedExperiences, hooks);\n        return componentConfig.type.skins.find(skin => skin.id === skinId);\n    }\n\n    public loaderHooks?: loaderHooks;\n\n    public loadComponent = async <T extends IMyopComponent = IMyopComponent>(componentConfig: IComponentConfig, container?: HTMLElement | Ref, options?: loaderOptions):\n        Promise<T> => {\n\n        if (!container) {\n            debugger;\n            throw new Error('no container was found for this component');\n        }\n\n        const overriddenConfig = await checkMyopOverride(componentConfig);\n        if (overriddenConfig) {\n            //TODO : log\n            componentConfig = overriddenConfig;\n        }\n\n        // // @ts-ignore\n        // if (!container.__nonProxied) {\n        //     const refComponent = (container as unknown as MyopRefComponent);\n        //     //if we got loadComponent over MyopRefComponent\n        //     if (refComponent.id && refComponent.parent) {\n        //         return this.loadComponent(componentConfig, refComponent.ref, options);\n        //\n        //         // let rootComponent: IMyopComponent = refComponent;\n        //         // while(!rootComponent.element && rootComponent.parent){\n        //         //     rootComponent = rootComponent.parent\n        //         // }\n        //         //\n        //         // rootComponent.element\n        //         // //what now ?\n        //     }\n        // }\n\n        const hooks = {...(this.loaderHooks ?? {}), ...(options?.hooks ?? {})};\n\n        const ref = container as Ref;\n        if (ref.myop) {\n            if (ref.component) {\n\n                componentConfig = {...componentConfig};\n                componentConfig.instance = {\n                    ...componentConfig.instance\n                }\n\n                let selectedSkin = await this.runSkinSelector(componentConfig, hooks)!\n                if (!selectedSkin) {\n                    throw new Error(\"runSkinSelector failed to choose skin, check the provided config\");\n                }\n\n                if (options?.hooks?.afterSkinSelected) {\n                    selectedSkin = await options.hooks.afterSkinSelected({...selectedSkin});\n                }\n\n                componentConfig.instance.skinSelector = {\n                    type: SkinSelectorTypes.Dedicated,\n                    skin: selectedSkin\n                    //  skins: [selectedSkin]\n                } as IDedicatedSkinConfig\n\n                if (options) {\n                    options = {...options}\n                    delete options.hooks\n                }\n\n                const refComponent = await createRefComponent<T>(ref, componentConfig, this.components, options);\n\n                //TODO : connect refs and props insode createRefComponent, elsewhere its not really <T>\n                return refComponent;\n            } else {\n                throw new Error('load component got a detached ref.')\n            }\n        }\n\n        container = container as HTMLElement;\n\n        /**\n         *\n         * choose skin on runtime ...\n         *        componentConfig.instance.skinSelector.type\n         */\n\n        let selectedSkin = await this.runSkinSelector(componentConfig, hooks)!\n\n        if (!selectedSkin) {\n            throw new Error(\"runSkinSelector failed to choose skin, check the provided config\");\n        }\n\n        if (options?.hooks?.afterSkinSelected) {\n            selectedSkin = await options.hooks.afterSkinSelected({...selectedSkin});\n        }\n        const componentLoader = this.componentsLoaders.find(loader => loader.type === selectedSkin.loader.type);\n\n        if (!componentLoader) {\n            debugger;\n            throw new Error(`no loader \"${selectedSkin.loader.type}\" was found for component`);\n        }\n\n        //for loaded webcomponent modules to following line creates a race condition with the init message flow\n        let component = await componentLoader.load(componentConfig.type, selectedSkin, container, options);\n\n        // TODO : when this is not true ?\n        if (!component.isInitiated)\n            this.components2init.push(component)\n\n        component.bind('onDispose', () => {\n            //console.log('component dispose', component);\n            this.components = this.components.filter(c => c !== component)\n            this.components2init = this.components2init.filter(c => c !== component)\n            return true;\n        })\n\n        this.components.push(component);\n\n        // true by default\n        if (!options || options.connectProps !== false) {\n            //TODO : make type field conditional type infer \"string\" > string, \"number\" > number, etc...\n            component = connectProps(component, componentConfig.type.props, selectedSkin);\n        }\n\n        try {\n            //TODO : make optional?\n            //TODO : fix issues with timeout and wrong ref names from config vs current skin\n            await connectRefs(component, componentConfig, this.components);\n        } catch (e) {\n            throw e;\n            //debugger;\n            // TOOD : throw ?\n        }\n        if (!options?.skipInit)\n            await component.initiated();\n\n        return component as T;\n    }\n\n    public navigate = async <T extends IMyopComponent = IMyopComponent>(component: IMyopComponent, newComponentConfig: IComponentConfig, options?: navigationOptions) => {\n        if (component.parent) {\n            throw new Error('Navigating on remote ref components is not implemented yet');\n        }\n\n        //component.markedForDisposed = true;\n\n        // if (options?.inplace) {\n        //     if (component.element) {\n        //         let newComponent = await this.loadComponent<T>(newComponentConfig, component.element);\n        //         await newComponent.initiated();\n        //\n        //         if (options.init)\n        //             await options.init(newComponent);\n        //\n        //         return newComponent;\n        //     } else {\n        //         throw new Error('...')\n        //     }\n        // }\n\n        if (options?.staged) {\n            //const selectedSkin = this.runSkinSelector(newComponentConfig)\n            let newComponent = await this.loadComponent<T>(newComponentConfig, component.container, {\n                hidden: true,\n                relative: {direction: 'after', child: component.element!},\n                ...options\n            });\n\n            if (options.init)\n                await options.init(newComponent);\n\n            newComponent.show();\n            component.dispose();\n            return newComponent;\n        } else {\n            const nextSibling = component.element!.nextSibling;\n\n            component.dispose();\n            return this.loadComponent<T>(newComponentConfig, component.container, {\n                relative: {\n                    direction: \"before\",\n                    child: nextSibling,\n                },\n                ...options\n            });\n        }\n    }\n}\n\nexport type navigationOptions = {\n    staged?: boolean,\n    //inplace?: boolean,\n    init?: (component: IMyopComponent) => Promise<void>\n    skipInit?: boolean\n} & loaderOptions\n\ntype relativeLoadConfigDirection = 'before' | 'after';\n\n\nexport type loaderHooks = {\n    afterSkinSelected?: (selectedSkin: ISkinConfig) => Promise<ISkinConfig>\n} &\n    // segmentation hooks\n    ({ [key: string]: () => Promise<boolean> | boolean } | {})\n\n//TODO: support serializable version of that object\nexport interface relativeLoadConfig {\n    //If this is null, then newNode is inserted at the end of node's child nodes.\n    //https://developer.mozilla.org/en-US/docs/Web/API/Node/insertBefore\n    child: ChildNode | null\n    direction: relativeLoadConfigDirection\n}\n\nexport interface IEnvironment {\n    [key: string]: any\n}\n\ntype ElementAttributes = {\n    [key: string]: string | number | boolean | undefined | null;\n};\n\nexport interface loaderOptions {\n    id?: string\n    hidden?: boolean\n    connectProps?: boolean\n    timeout?: number\n    skipInit?: boolean\n    relative?: relativeLoadConfig\n    hooks?: loaderHooks\n    elementAttributes?: ElementAttributes\n    _environment?: IEnvironment\n    _hasParent?: boolean\n    _inspection?: boolean\n    data?: any\n    /**\n     * Raw CSS injected into the component's iframe <head> before first paint.\n     * Appended last so it overrides the component's own styles via cascade order.\n     * Useful for theming v2 (HTML) components \u2014 colors, fonts, spacing, etc.\n     */\n    injectCss?: string\n    /**\n     * Control iframe auto-sizing behavior.\n     * - true (default): iframe auto-sizes to content height, width fills parent.\n     * - false: no sizing logic runs. No observers, no measurements, no style changes.\n     *   The iframe stays at position:absolute filling the container.\n     *   The host is fully responsible for container dimensions.\n     */\n    autoSize?: boolean\n\n    /**\n     * Per-call render policy. Takes precedence over hostSDK.setRenderPolicy \u2014 lets an\n     * app restrict globally and allow (or further restrict) specific loadComponent calls.\n     */\n    renderPolicy?: RenderPolicy\n\n    /**\n     * Force full isolation for an inline-HTML (localFrame) component: sandboxed,\n     * cross-origin iframe with no host-document access. A render policy returning\n     * 'isolatedIframe' has the same effect.\n     */\n    isolation?: boolean\n}\n\nif (!window.myop) {\n    // @ts-ignore\n    window.myop = {\n        __ROOT_SDK_PUBLIC_URL__\n    };\n}\n\nif (!window.myop.hostSDK) {\n    const _hostSDK = new HostSDK();\n    //TODO: enable lazy init?\n    _hostSDK.init();\n\n    if (!window.myop) {\n        // @ts-ignore\n        window.myop = {\n            __ROOT_SDK_PUBLIC_URL__\n        };\n    }\n    window.myop.hostSDK = _hostSDK;\n}\n\n// @ts-ignore\nexport const hostSDK: HostSDK = window.myop.hostSDK;\n\ndefineDynamicImport('hostSDK', hostSDK);\n\ndeclare global {\n    interface Window {\n        myop: {\n            __ROOT_SDK_PUBLIC_URL__: string,\n            hostSDK: HostSDK,\n            IframeSDK: InstanceType<typeof IframeSDK>\n        }\n    }\n}\n", "/**\n * Myop Loader - Shared loader/fallback UI for host frameworks\n * Framework-agnostic implementation using pure DOM\n */\n\n// Myop Logo SVG path\nconst MYOP_LOGO_PATH =\n  \"M151.438 2.7168C177.625 2.76042 248.179 4.2832 300.4 56.7441C350.671 107.245 364.44 114.452 389.967 119.211C392.576 119.436 397.472 119.394 400.802 116.521C403.011 114.614 403.921 109.518 404.265 104.627V5.95996C404.265 4.85556 405.16 3.96023 406.265 3.95996H522.711C523.815 3.95996 524.711 4.85539 524.711 5.95996V122.405C524.711 123.51 523.815 124.405 522.711 124.405H421.998C418.579 124.728 413.852 125.627 410.974 128.095C407.879 130.748 407.042 137.805 406.845 142.661V240.414C406.845 241.436 406.111 242.292 405.093 242.38C366.548 245.717 277.079 228.462 235.837 173.668C202.909 129.919 173.882 122.474 151.458 122.077C150.354 122.058 149.459 121.164 149.459 120.06V4.71582C149.459 3.6114 150.334 2.71519 151.438 2.7168ZM62.2031 0C96.5566 0.000213148 124.405 27.8496 124.405 62.2031C124.405 96.5564 96.5564 124.405 62.2031 124.405C27.8496 124.405 0.000213175 96.5566 0 62.2031C0 27.8495 27.8495 0 62.2031 0Z\";\n\n// Style constants\nexport const LOADER_GRADIENT =\n  \"linear-gradient(135deg, #FF8651 0%, #FFBEA8 50%, #A397F5 100%)\";\nexport const FALLBACK_GRADIENT =\n  \"linear-gradient(135deg, #9CA3AF 0%, #D1D5DB 50%, #E5E7EB 100%)\";\n\n/**\n * Creates the Myop logo SVG element\n */\nexport function createMyopLogoSvg(): SVGSVGElement {\n  const svg = document.createElementNS(\"http://www.w3.org/2000/svg\", \"svg\");\n  svg.setAttribute(\"width\", \"80\");\n  svg.setAttribute(\"viewBox\", \"0 0 525 243\");\n  svg.setAttribute(\"fill\", \"none\");\n\n  const path = document.createElementNS(\"http://www.w3.org/2000/svg\", \"path\");\n  path.setAttribute(\"d\", MYOP_LOGO_PATH);\n  path.setAttribute(\"fill\", \"white\");\n\n  svg.appendChild(path);\n  return svg;\n}\n\n/**\n * Returns the inline HTML string for the Myop logo SVG\n */\nexport function getMyopLogoHtml(): string {\n  return `<svg width=\"80\" viewBox=\"0 0 525 243\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n    <path d=\"${MYOP_LOGO_PATH}\" fill=\"white\"/>\n  </svg>`;\n}\n\n/**\n * Returns the inline styles for the loader container\n */\nexport function getLoaderStyles(fadeDuration: number = 200): string {\n  return `\n    position: absolute;\n    top: 0;\n    left: 0;\n    right: 0;\n    bottom: 0;\n    z-index: 1;\n    background: ${LOADER_GRADIENT};\n    display: flex;\n    justify-content: center;\n    align-items: center;\n    transition: opacity ${fadeDuration}ms ease-out;\n  `;\n}\n\n/**\n * Returns the inline styles for the fallback container\n */\nexport function getFallbackStyles(): string {\n  return `\n    position: absolute;\n    top: 0;\n    left: 0;\n    right: 0;\n    bottom: 0;\n    background: ${FALLBACK_GRADIENT};\n    display: flex;\n    justify-content: center;\n    align-items: center;\n  `;\n}\n\n/**\n * Creates a loader DOM element with the Myop branding\n */\nexport function createLoaderElement(fadeDuration: number = 200): HTMLDivElement {\n  const loader = document.createElement(\"div\");\n  loader.className = \"myop-loader\";\n  loader.style.cssText = getLoaderStyles(fadeDuration);\n  loader.appendChild(createMyopLogoSvg());\n  return loader;\n}\n\n/**\n * Creates a fallback DOM element with the Myop branding\n */\nexport function createFallbackElement(): HTMLDivElement {\n  const fallback = document.createElement(\"div\");\n  fallback.className = \"myop-fallback\";\n  fallback.style.cssText = getFallbackStyles();\n  fallback.appendChild(createMyopLogoSvg());\n  return fallback;\n}\n\n/**\n * Returns the complete loader HTML as a string (for use in templates)\n */\nexport function getLoaderHtml(fadeDuration: number = 200): string {\n  return `<div class=\"myop-loader\" style=\"${getLoaderStyles(fadeDuration).replace(/\\n/g, \" \").replace(/\\s+/g, \" \").trim()}\">\n    ${getMyopLogoHtml()}\n  </div>`;\n}\n\n/**\n * Returns the complete fallback HTML as a string (for use in templates)\n */\nexport function getFallbackHtml(): string {\n  return `<div class=\"myop-fallback\" style=\"${getFallbackStyles().replace(/\\n/g, \" \").replace(/\\s+/g, \" \").trim()}\">\n    ${getMyopLogoHtml()}\n  </div>`;\n}\n\n/**\n * Interface for loader options used by host frameworks\n */\nexport interface MyopLoaderOptions {\n  /** Fade duration in milliseconds (default: 200) */\n  fadeDuration?: number;\n  /** Initial opacity (default: 1) */\n  opacity?: number;\n}\n\n/**\n * CSS-in-JS style objects for frameworks that support them\n */\nexport const loaderStyleObject = {\n  position: \"absolute\" as const,\n  top: 0,\n  left: 0,\n  right: 0,\n  bottom: 0,\n  zIndex: 1,\n  background: LOADER_GRADIENT,\n  display: \"flex\",\n  justifyContent: \"center\",\n  alignItems: \"center\",\n};\n\nexport const fallbackStyleObject = {\n  position: \"absolute\" as const,\n  top: 0,\n  left: 0,\n  right: 0,\n  bottom: 0,\n  background: FALLBACK_GRADIENT,\n  display: \"flex\",\n  justifyContent: \"center\",\n  alignItems: \"center\",\n};\n\nexport const containerStyleObject = {\n  position: \"absolute\" as const,\n  top: 0,\n  left: 0,\n  right: 0,\n  bottom: 0,\n  zIndex: 1,\n  display: \"flex\",\n  justifyContent: \"center\",\n  alignItems: \"center\",\n};\n"],
  "mappings": "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",
  "names": ["ReplayMessageKey", "match", "scriptInputs", "scriptInputs", "ReplayMessageKey", "ReplayMessageKey", "ReplayMessageKey", "ReplayMessageKey", "ReplayMessageKey", "ReplayMessageKey", "seen", "target", "makeSerializable", "height", "width", "hostSDK", "element", "seen", "sdk", "domId", "sdk", "seen", "skin", "component", "segment", "experience", "selectedSkin"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/dynamicImport/defineDynamicImport.ts", "../../../src/common/MyopMessages.ts", "../../../src/messages/index.ts", "../../../src/utils/uuid.ts", "../../../src/utils/utils.ts", "../../../src/messages/BaseMessage.ts", "../../../src/messages/BindClickMessage.ts", "../../../src/messages/ChangeTextMessage.ts", "../../../src/messages/ExecuteScriptMessage.ts", "../../../src/messages/CustomRefMessage.ts", "../../../src/messages/AddEventListenerMessage.ts", "../../../src/messages/SetAttributeMessage.ts", "../../../src/messages/GetElementValueMessage.ts", "../../../src/messages/SetInnerHtml.ts", "../../../src/messages/InitMessage.ts", "../../../src/messages/CreateRefComponentMessage.ts", "../../../src/messages/EnvelopedMessage.ts", "../../../src/messages/DetectMyopRefsMessage.ts", "../../../src/messages/GetAttributeMessage.ts", "../../../src/messages/componentMessages/ExecuteComponentMethod.ts", "../../../src/messages/componentMessages/SetMutationObserverMessage.ts", "../../../src/messages/CleanupMessage.ts", "../../../src/messages/DisposeMessage.ts", "../../../src/messages/componentMessages/SetResizeObserverMessage.ts", "../../../src/host/components/IMyopComponent.ts", "../../../src/common/MyopElementRef.ts", "../../../src/common/baseMessageHandler.ts", "../../../src/common/BaseMyopSDK.ts", "../../../src/common/index.ts", "../../../src/common/utils/serialization.ts", "../../../src/host/logMessages.ts", "../../../src/host/components/myopRefComponent.ts", "../../../src/host/components/myopExtractedWebComponent.ts", "../../../src/host/componentCore.ts", "../../../src/host/components/myopIframeComponent.ts", "../../../src/host/loaders/IMyopLoader.ts", "../../../src/host/loaders/iframeLoader.ts", "../../../src/webcomponent/consts.ts", "../../../src/host/components/myopWebcomponent.ts", "../../../src/host/loaders/webcomponentLoader.ts", "version:myop-sdk-version", "../../../src/helpers/deliveryStore.ts", "../../../src/helpers/CloudRepository.ts", "../../../src/helpers/cloudRepositoryHelpers.ts", "../../../src/webcomponent/messageHandlers/BaseWebComponentMessageHandler.ts", "../../../src/consts.ts", "../../../src/common/messageHandlers/helpers.ts", "../../../src/webcomponent/messageHandlers/bindOnClickHandler.ts", "../../../src/webcomponent/messageHandlers/changeTextHandler.ts", "../../../src/webcomponent/shadowRootRef.ts", "../../../src/webcomponent/messageHandlers/DetectMyopRefsMessageHandler.ts", "../../../src/webcomponent/messageHandlers/setAttributeHandler.ts", "../../../src/webcomponent/messageHandlers/addEventListenerHandler.ts", "../../../src/webcomponent/messageHandlers/CreateRefComponentMessageHandler.ts", "../../../src/common/messageHandlers/executeScriptHandler.ts", "../../../src/webcomponent/messageHandlers/executeScriptHandler.ts", "../../../src/webcomponent/messageHandlers/GetElementValueHandler.ts", "../../../src/webcomponent/messageHandlers/setInnerHtmlHandler.ts", "../../../src/webcomponent/WebComponentSDK.ts", "../../../src/host/loaders/HTMLComponentLoader.ts", "../../../src/host/myopOverride.ts", "../../../src/host/hostSDK.ts", "../../../src/host/myopLoader.ts"],
  "sourcesContent": ["export const __federation__ = \"__federation__\"\nexport const onLoadKey = \"onLoad\"\nexport const moduleInstanceKey = \"moduleInstance\"\n\nexport const defineDynamicImport = (globalName: string, module: any) => {\n    // @ts-ignore\n    if (window[__federation__] && window[__federation__][globalName] && window[__federation__][globalName][onLoadKey]) {\n        // @ts-ignore\n        window[__federation__][globalName][onLoadKey]({[globalName]: module})\n    } else {\n        //console.log('__federation__ loader not defined for module', module);\n    }\n}", "type StringWithAutocomplete<T> = T | (string & Record<never, never>);\n\nexport type MyopMessageKey = StringWithAutocomplete<keyof typeof MyopMessages | keyof typeof MyopMessages.In>;\n\nexport const MyopMessages = {\n    //host to component\n    'InitRequest': 'InitRequest',\n    'InitResponse': 'InitResponse',\n    'InitMessage': 'InitMessage',\n    'DisposeMessage': 'DisposeMessage',\n\n    'ChangeTextMessage': 'ChangeTextMessage',\n    'BindClickMessage': 'BindClickMessage',\n    'DetectMyopRefsMessage': 'DetectMyopRefsMessage',\n\n    'ExecuteScriptMessage': 'ExecuteScriptMessage',\n\n    'AddEventListenerMessage': 'AddEventListenerMessage',\n    'SetAttributeMessage': 'SetAttributeMessage',\n\n    'CreateRefComponentMessage': 'CreateRefComponentMessage',\n    'EnvelopedMessage': 'EnvelopedMessage',\n\n    'GetElementValueMessage': 'GetElementValueMessage',\n    'GetAttributeMessage': 'GetAttributeMessage',\n\n    'SetInnerHtml': 'SetInnerHtml',\n\n    //component messages\n    'ExecuteComponentMethod': 'ExecuteComponentMethod',\n    'SetMutationObserverMessage': 'SetMutationObserverMessage',\n    'SetResizeObserverMessage': 'SetResizeObserverMessage',\n\n    'CleanupMessage': 'CleanupMessage',\n\n    // external to host :\n    In: {\n        'DetectedMyopRefsMessage': 'DetectedMyopRefsMessage',\n        'ClickReplayMessage': 'ClickReplayMessage',\n        'ExecuteScriptReplyMessage': 'ExecuteScriptReplyMessage',\n\n        'EventListenerCallbackMessage': 'EventListenerCallbackMessage',\n        'ElementValueReplayMessage': 'ElementValueReplayMessage',\n\n        \"GetAttributeReplayMessage\": \"GetAttributeReplayMessage\",\n        'RefComponentCreatedMessage': 'RefComponentCreatedMessage',\n        'EnvelopedMessage': 'EnvelopedMessage',\n\n        'MutationObserverMessage': 'MutationObserverMessage',\n        'CleanupReplayMessage': 'CleanupReplayMessage',\n        'ResizeObserverMessage': 'ResizeObserverMessage'\n    }\n}\n", "export * from './BaseMessage';\n\n//user's messages\nexport * from './BindClickMessage';\nexport * from './ChangeTextMessage';\nexport * from './ExecuteScriptMessage';\nexport * from './CustomRefMessage';\nexport * from './AddEventListenerMessage';\nexport * from './SetAttributeMessage';\nexport * from './GetElementValueMessage';\nexport * from './SetInnerHtml';\n\n//system messages\nexport * from './InitMessage';\nexport * from './CreateRefComponentMessage';\nexport * from './EnvelopedMessage';\nexport * from './DetectMyopRefsMessage';\nexport * from './GetElementValueMessage';\nexport * from  './GetAttributeMessage';\n\nexport * from './componentMessages/ExecuteComponentMethod';\nexport * from './componentMessages/SetMutationObserverMessage';\nexport * from './CleanupMessage';\nexport * from './DisposeMessage';\nexport * from './componentMessages/SetResizeObserverMessage';", "//TODO : reuse from one place.\n// needs to be used in myop-sdk, myop-dashbaord, myop-server, myop-cli ..\n\nexport const uuidv4 = () => {\n    return \"10000000-1000-4000-8000-100000000000\".replace(/[018]/g, c =>\n        (+c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> +c / 4).toString(16)\n    );\n}\n\n// Convert UUID string to bytes\nexport const uuidToBytes = (uuid: string): Uint8Array => {\n    return Uint8Array.from(\n        uuid.replace(/-/g, '').match(/.{1,2}/g)!.map(byte => parseInt(byte, 16))\n    );\n};\n\n// Convert bytes to UUID string\nexport const bytesToUuid = (bytes: Uint8Array): string => {\n    const hex = [...bytes].map(b => b.toString(16).padStart(2, '0')).join('');\n    return [\n        hex.slice(0, 8),\n        hex.slice(8, 12),\n        hex.slice(12, 16),\n        hex.slice(16, 20),\n        hex.slice(20)\n    ].join('-');\n};\n\n// Base64 URL-safe encode\nexport const base64UrlEncode = (bytes: Uint8Array): string => {\n    const base64 = btoa(String.fromCharCode(...bytes));\n    return base64.replace(/\\+/g, '-').replace(/\\//g, '_').replace(/=+$/, '');\n};\n\n// Base64 URL-safe decode\nexport const base64UrlDecode = (str: string): Uint8Array => {\n    let base64 = str.replace(/-/g, '+').replace(/_/g, '/');\n    while (base64.length % 4) base64 += '=';\n    const binary = atob(base64);\n    return Uint8Array.from(binary, char => char.charCodeAt(0));\n};\n\n// Compress an array of UUIDs into a short URL-safe string\nexport const compressUUIDs = (uuids: string[]): string => {\n    const allBytes = uuids.flatMap(uuid => Array.from(uuidToBytes(uuid)));\n    return base64UrlEncode(new Uint8Array(allBytes));\n};\n\n// Decompress from URL-safe string back to an array of UUIDs\nexport const decompressUUIDs = (encoded: string): string[] => {\n    const bytes = base64UrlDecode(encoded);\n    if (bytes.length % 16 !== 0) throw new Error('Invalid input length');\n\n    const uuids: string[] = [];\n    for (let i = 0; i < bytes.length; i += 16) {\n        uuids.push(bytesToUuid(bytes.slice(i, i + 16)));\n    }\n    return uuids;\n};\n", "export * from './uuid.ts'\n\nexport const wait = (ms: number) => {\n    return new Promise(resolve => setTimeout(resolve, ms));\n}", "import {MyopMessageKey} from \"../common/MyopMessages\";\nimport {uuidv4} from \"../utils/utils\";\nimport {IMyopComponent} from \"../host\";\nimport {IRefConfig} from \"../common\";\n\nexport class MessageDirection {\n    static down = 'down' as const\n    static up = 'up' as const\n}\n\nexport type MessageDirectionOption = 'up' | 'down';\n\nexport abstract class BaseMyopMessage<T = any> {\n    id = uuidv4()\n\n    static create<T, U extends new (...args: ConstructorParameters<U>) => T = typeof this>(\n        this: U,\n        ...args: ConstructorParameters<U>\n    ): InstanceType<typeof this> {\n        // @ts-ignore\n        return new this(...args);\n    }\n\n    constructor() {\n        //console.log('meesage id created', this.id, document.location.href);\n    }\n\n    myop = true\n\n    abstract messageType: MyopMessageKey | string;\n\n    content?: T\n\n    // TODO : cant be optional \n    source?: string\n    destination?: string\n\n    route?: string[]\n\n    ref?: Ref\n\n    direction?: MessageDirectionOption\n\n    cleanable: boolean = false\n\n    isTypeof(msg: BaseMyopMessage): boolean {\n        return msg.messageType === this.messageType\n    }\n}\n\nexport abstract class MyopElementMessage<T = any> extends BaseMyopMessage<T> {\n    constructor(public ref: Ref) {\n        super()\n    }\n}\n\nexport abstract class MyopBindReplayMessage<T = any> extends BaseMyopMessage<T> {\n    constructor(public replayToHandler?: string) {\n        super();\n    }\n}\n\nexport abstract class MyopBindMessage<T = any, R extends MyopBindReplayMessage = any> extends BaseMyopMessage<T> {\n\n    public abstract replyMessageKey: MyopMessageKey;\n\n    public handlerUniqueId = uuidv4()\n\n    constructor(public handler: (message: R) => void) {\n        super()\n    }\n}\n\nexport class Ref {\n    public myop = true;\n\n    public __nonProxied?: Ref;\n\n    static create(selector: string, refConfig?: IRefConfig, component?: IMyopComponent) {\n        let _refConfig = refConfig;\n        if (!_refConfig) {\n            _refConfig = {\n                id: '',\n                name: '',\n                description: '',\n                selectorType: 'id-attribute',\n                selector: selector,\n                behavior: {\n                    type: 'code'\n                }\n            } as IRefConfig\n        }\n        return new Ref(_refConfig, component);\n    }\n\n    constructor(public refConfig: IRefConfig, public component?: IMyopComponent) {\n        this.__nonProxied = {\n            ...this,\n            component: null // in order to be serializable\n        }\n    }\n}\n", "import {MyopBindMessage, MyopBindReplayMessage, Ref} from \"./BaseMessage\";\nimport {MyopMessageKey} from \"../common/MyopMessages\";\n\nconst ReplayMessageKey = 'ClickReplayMessage'\n\nexport class BindClickMessage extends MyopBindMessage<void, ClickReplayMessage> {\n    replyMessageKey: MyopMessageKey = ReplayMessageKey\n    messageType = 'BindClickMessage';\n    cleanable = true;\n\n    constructor(public ref: Ref, handler: (message: ClickReplayMessage) => void) {\n        super(handler);\n    }\n}\n\nexport class ClickReplayMessage extends MyopBindReplayMessage {\n    messageType = ReplayMessageKey\n}\n\n", "import {BaseMyopMessage, Ref} from \"./BaseMessage\";\n\nexport class ChangeTextMessage extends BaseMyopMessage<string> {\n\n    messageType = 'ChangeTextMessage';\n\n    constructor(public ref: Ref, text: string) {\n        super();\n        this.content = text\n    }\n}", "import {MyopBindMessage, MyopBindReplayMessage} from \"./BaseMessage\";\nimport {MyopMessageKey} from \"../common/MyopMessages\";\nimport {RootRef} from \"../common\";\nimport {makeSerializable} from \"../common/utils/serialization.ts\";\n\nconst ReplayMessageKey = 'ExecuteScriptReplyMessage'\n\nconst functionBodyRegex = /(?:function\\s*\\w*\\s*\\([^)]*\\)\\s*\\{([\\s\\S]*?)\\}|(\\([^)]*\\)\\s*=>\\s*\\{([\\s\\S]*?)\\}))\\s*$/;\nconst expressionBodyRegex = /\\(\\s*[^)]+\\s*\\)\\s*=>\\s*(.+)/;\n\nexport const stripFunction = (content: string) => {\n    let match = content.match(functionBodyRegex);\n    if (match) {\n        return match[1] || match[3];\n    } else {\n        let match = content.match(expressionBodyRegex);\n        if (match)\n            return match[1].trim();\n    }\n}\n\nexport type scriptInputs = {\n    [key: string]: string | number | boolean\n} | {};\n\nexport type scriptVars<T> = {\n    send: (data: T) => void;\n    // completeStream: () => void;\n    rootRef: RootRef;\n    makeSerializable: typeof makeSerializable\n}\n\nexport type extendedScriptVars<T, I> = {\n    [K in keyof I]: I[K];\n} & scriptVars<T>\n\nexport class ExecuteScriptMessage<T = any, I extends scriptInputs = any> extends MyopBindMessage<string, ExecuteScriptReplyMessage<T>> {\n\n    replyMessageKey: MyopMessageKey = ReplayMessageKey;\n    messageType = 'ExecuteScriptMessage';\n    script: string = ''\n\n    static replierKey = 'send';\n    static completeStreamKey = 'completeStream';\n\n    constructor(script: (vars: extendedScriptVars<T, I>) => T, handler: (message: ExecuteScriptReplyMessage<T>) => void = () => {\n    }, public scriptInputs?: I) {\n        super(handler);\n        this.script = script.toString();\n\n        //TODO: can be remove\n        this.content = script.toString()\n        this.content = stripFunction(this.content);\n    }\n}\n\nexport class ExecuteScriptReplyMessage<T = any> extends MyopBindReplayMessage<T> {\n\n    messageType = ReplayMessageKey;\n\n    constructor(public replayToHandler: string, public content: T) {\n        super(replayToHandler);\n    }\n}\n", "import {\n    ExecuteScriptMessage,\n    ExecuteScriptReplyMessage,\n    extendedScriptVars,\n    scriptInputs, stripFunction\n} from \"./ExecuteScriptMessage.ts\";\n\nexport type customRefScriptInputs = {\n    elementId: string,\n    ref?: HTMLElement,\n    _script?: string,\n    __scriptInputs?: Object\n};\n\nexport class CustomRefMessage<T = any, I extends scriptInputs = customRefScriptInputs> extends ExecuteScriptMessage<T, I & customRefScriptInputs> {\n\n    constructor(script: (vars: extendedScriptVars<T, I & customRefScriptInputs>) => T,\n                public scriptInputs: I & customRefScriptInputs,\n                handler: (message: ExecuteScriptReplyMessage<T>) => void = () => {\n                }) {\n\n        //mock vars\n        // let rootRef, elementId, _script, __scriptInputs;\n        super(({rootRef, elementId, _script, __scriptInputs}) => {\n            const refs = (rootRef.shadowRoot || rootRef.container).querySelectorAll(`[${'myop-id'}='${elementId}']`);\n            if (refs.length) {\n                //  const ref = refs[0];\n\n                //TODO : think about exposing \"refs\" and not only \"ref\"\n                //for cases where the Ref has multiplate implementations\n\n                // @ts-ignore\n                __scriptInputs.ref = refs[0];\n\n                const dynamicFunction = new Function(`return (${_script})(...arguments)`);\n                return dynamicFunction(__scriptInputs);\n\n                // @ts-ignore\n                //return Function('ref', 'rootRef', ...Object.keys(__scriptInputs), _script!)(ref, rootRef, ...Object.values(__scriptInputs))\n            }\n            return null as T;\n        }, handler);\n\n        this.scriptInputs = {\n            ...scriptInputs,\n            //_script: stripFunction(script.toString()),\n            _script: script.toString()\n        };\n    }\n}\n", "import {MyopBindMessage, MyopBindReplayMessage, Ref} from \"./BaseMessage\";\nimport {MyopMessageKey} from \"../common/MyopMessages\";\nimport {Serializable, SerializableSkeleton} from \"../common/utils/serialization.ts\";\n\nconst ReplayMessageKey = 'EventListenerCallbackMessage'\n\nexport class AddEventListenerMessage<T extends keyof HTMLElementEventMap = keyof HTMLElementEventMap> extends MyopBindMessage {\n\n    replyMessageKey: MyopMessageKey = ReplayMessageKey;\n    messageType = 'AddEventListenerMessage';\n    cleanable = true;\n    serializableSkeleton: SerializableSkeleton<HTMLElementEventMap[T]> = false // {} // empty\n\n    constructor(public ref: Ref, public type: T, public handler: (message: EventListenerCallbackMessage) => void) {\n        super(handler)\n    }\n\n    withSerializableSkeleton(serializableSkeleton: SerializableSkeleton<HTMLElementEventMap[T]>) {\n        this.serializableSkeleton = serializableSkeleton;\n        return this;\n    }\n}\n\nexport class EventListenerCallbackMessage extends MyopBindReplayMessage {\n    messageType = ReplayMessageKey;\n\n    constructor(public replayToHandler: string, public e: Serializable<Event>) {\n        super(replayToHandler);\n        this.content = {\n            e\n        }\n    }\n}\n", "import {BaseMyopMessage, Ref,} from \"./BaseMessage\";\n\n\nexport class SetAttributeMessage extends BaseMyopMessage {\n\n    messageType = 'SetAttributeMessage';\n\n    constructor(public ref: Ref, public name: string, public value: string) {\n        super()\n    }\n}\n", "import {MyopBindMessage, MyopBindReplayMessage, Ref} from \"./BaseMessage\";\nimport {MyopMessageKey} from \"../common/MyopMessages\";\nimport {Serializable} from \"../common/utils/serialization.ts\";\n\nconst ReplayMessageKey = 'ElementValueReplayMessage'\n\nexport class GetElementValueMessage extends MyopBindMessage<void, ElementValueReplayMessage> {\n    replyMessageKey: MyopMessageKey = ReplayMessageKey\n    messageType = 'GetElementValueMessage';\n\n    constructor(public ref: Ref, handler: (message: ElementValueReplayMessage) => void) {\n        super(handler);\n    }\n}\n\nexport type FormDataEntry = {\n    id?: string,\n    name?: string,\n    value?: InputElementValue,\n    required?: boolean,\n    validity?: Serializable<ValidityState>,\n    myopId?: string\n}\n\nexport type InputElementFormValue = {\n    formData?: { [key: string]: FormDataEntry }\n    unmappedData?: FormDataEntry[]\n};\n\nexport type InputElementValue = string | InputElementFormValue | null | undefined\n\nexport class ElementValueReplayMessage extends MyopBindReplayMessage {\n    messageType = ReplayMessageKey\n\n    constructor(public content: InputElementValue) {\n        super();\n    }\n}\n\n", "import {BaseMyopMessage, Ref} from \"./BaseMessage.ts\";\n\nexport class SetInnerHtml extends BaseMyopMessage<string> {\n\n    messageType = 'SetInnerHtml';\n\n    constructor(public ref: Ref, innerHtml: string) {\n        super();\n        this.content = innerHtml\n    }\n}", "import { BaseMyopMessage } from \"./BaseMessage\";\n\n// sent by host to components, contains thier id \nexport class InitMessage extends BaseMyopMessage<{ id: string }> {\n    messageType = 'InitMessage';\n\n    constructor(id: string) {\n        super()\n        this.content = { id }\n    }\n\n    isTypeof(msg: BaseMyopMessage): boolean {\n        return msg.messageType === this.messageType\n    }\n}\n\n// component notify host the it was initated \nexport class InitResponse extends InitMessage {\n    messageType = 'InitResponse';\n}\n\n// component ask to host to get initated \nexport class InitRequest extends BaseMyopMessage {\n    messageType = 'InitRequest';\n}\n", "import {MyopBindMessage, MyopBindReplayMessage} from \"./BaseMessage\";\nimport {MyopMessageKey} from \"../common/MyopMessages\";\nimport {IComponentConfig, IRefConfig} from \"../common\";\nimport {loaderOptions} from \"../host/hostSDK.ts\";\n\nconst ReplayMessageKey = 'RefComponentCreatedMessage'\n\nexport class CreateRefComponentMessage extends MyopBindMessage<void, RefComponentCreatedMessage> {\n    replyMessageKey: MyopMessageKey = ReplayMessageKey\n    messageType = 'CreateRefComponentMessage';\n\n    constructor(public refConfig: IRefConfig,\n                public nestedComponentConfig: IComponentConfig,\n                public options: loaderOptions,\n                handler: (message: RefComponentCreatedMessage) => void,\n    ) {\n        super(handler);\n\n    }\n}\n\nexport type NestedRef = {\n    refName: string,\n    componentDefinitionId: string\n}\n\nexport class RefComponentCreatedMessage extends MyopBindReplayMessage {\n    messageType = ReplayMessageKey\n\n    constructor(public replayToHandler: string, public nestedRefs: NestedRef[], public failed?: boolean) {\n        super(replayToHandler);\n    }\n}\n", "import {BaseMyopMessage} from \"./BaseMessage\";\n\nexport class EnvelopedMessage extends BaseMyopMessage {\n    messageType = 'EnvelopedMessage';\n\n    constructor(public destination: string, public message: BaseMyopMessage) {\n        super();\n\n        const innerEnvelopedMessage = (message as EnvelopedMessage);\n        this.route = [destination, ...innerEnvelopedMessage.route ? innerEnvelopedMessage.route : []];\n    }\n}\n", "import {BaseMyopMessage, MyopBindMessage, MyopBindReplayMessage} from \"./BaseMessage\";\nimport {IElementRef} from \"../common\";\n\nconst ReplayMessageKey = 'DetectedMyopRefsMessage'\n\nexport class DetectMyopRefsMessage extends MyopBindMessage<any, DetectedMyopRefsMessage> {\n    messageType = 'DetectMyopRefsMessage'\n    replyMessageKey = ReplayMessageKey;\n}\n\nexport class DetectedMyopRefsMessage extends MyopBindReplayMessage<IElementRef[]> {\n\n    messageType = ReplayMessageKey;\n\n    constructor(public replayToHandler: string, myopElementRefs: IElementRef[]) {\n        super(replayToHandler)\n        this.content = myopElementRefs;\n    }\n\n    isTypeof(msg: BaseMyopMessage<any>): boolean {\n        return msg.messageType === this.messageType\n    }\n}\n", "import {MyopBindMessage, MyopBindReplayMessage, Ref} from \"./BaseMessage\";\nimport {MyopMessageKey} from \"../common/MyopMessages\";\n\nconst ReplayMessageKey = 'GetAttributeReplayMessage'\n\nexport class GetAttributeMessage extends MyopBindMessage<void, GetAttributeReplayMessage> {\n    replyMessageKey: MyopMessageKey = ReplayMessageKey\n    messageType = 'GetAttributeMessage';\n\n    constructor(public ref: Ref, public name: string, handler: (message: GetAttributeReplayMessage) => void) {\n        super(handler);\n    }\n}\n\nexport class GetAttributeReplayMessage extends MyopBindReplayMessage {\n    messageType = ReplayMessageKey\n\n    constructor(public content: string | null) {\n        super();\n    }\n}\n\n", "import {BaseMyopMessage} from \"../BaseMessage\";\nimport {IMyopComponent} from \"../../host\";\n\ntype MethodNames<T> = {\n    // [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;\n    [K in keyof T]: T[K] extends () => void ? K : never;\n}[keyof T];\n\n// Define a type that allows only strings corresponding to the method names of T\ntype MethodString<T> = MethodNames<T> extends infer M ? M extends string ? M : never : never;\n\n\nexport class ExecuteComponentMethod extends BaseMyopMessage {\n    messageType = 'ExecuteComponentMethod';\n\n    constructor(public method: MethodString<IMyopComponent>) {\n        super();\n    }\n}\n", "import {BaseMyopMessage} from \"../BaseMessage\";\n\nexport class SetMutationObserverMessage extends BaseMyopMessage {\n    messageType = 'SetMutationObserverMessage';\n}\n\nexport class MutationObserverMessage extends BaseMyopMessage {\n    messageType = 'MutationObserverMessage';\n}", "import {MyopBindMessage, MyopBindReplayMessage} from \"./BaseMessage\";\nimport {MyopMessageKey} from \"../common/MyopMessages\";\n\nconst ReplayMessageKey = 'CleanupReplayMessage'\n\nexport class CleanupMessage extends MyopBindMessage<void, CleanupReplayMessage> {\n    replyMessageKey: MyopMessageKey = ReplayMessageKey\n    messageType = 'CleanupMessage';\n\n    constructor(public cleanupForMessageId: string, handler: (message: CleanupReplayMessage) => void) {\n        super(handler);\n    }\n}\n\nexport class CleanupReplayMessage extends MyopBindReplayMessage {\n    messageType = ReplayMessageKey\n\n    constructor(public customCleanup: boolean) {\n        super();\n    }\n}\n", "import {BaseMyopMessage} from \"./BaseMessage\";\n\nexport class DisposeMessage extends BaseMyopMessage {\n    messageType = 'DisposeMessage';\n}\n", "import {BaseMyopMessage} from \"../BaseMessage\";\n\nexport class SetResizeObserverMessage extends BaseMyopMessage {\n    cleanable = true;\n    messageType = 'SetResizeObserverMessage';\n}\n\nexport class ResizeObserverMessage extends BaseMyopMessage {\n    messageType = 'ResizeObserverMessage';\n}", "import {MyopMessageKey, MyopMessages} from \"../../common/MyopMessages\";\nimport {\n    BaseMyopMessage,\n    DisposeMessage, ExecuteComponentMethod, MessageDirection,\n    CleanupMessage, CleanupReplayMessage,\n    MyopBindMessage,\n    MyopBindReplayMessage, Ref\n} from \"../../messages\";\nimport {CleanupHandler, IComponentDefinitionConfig} from \"../../common\";\nimport {HostSDK, loaderOptions} from \"../hostSDK.ts\";\n\n/**\n * Result returned by observeAutoSize callback\n */\nexport interface AutoSizeResult {\n    /** Current width (from content) */\n    width: number;\n    /** Current height (from content) */\n    height: number;\n    /** Whether width is being auto-sized */\n    autoSizingWidth: boolean;\n    /** Whether height is being auto-sized */\n    autoSizingHeight: boolean;\n}\n\n/**\n * Options for observeAutoSize method\n */\nexport interface AutoSizeOptions {\n    /** Callback called with size info whenever size changes */\n    onSizeChange?: (result: AutoSizeResult) => void;\n    /** Minimum width constraint */\n    minWidth?: number | string;\n    /** Maximum width constraint */\n    maxWidth?: number | string;\n    /** Minimum height constraint */\n    minHeight?: number | string;\n    /** Maximum height constraint */\n    maxHeight?: number | string;\n    /** Explicit width set by host - if defined, don't auto-size width */\n    explicitWidth?: string | number;\n    /** Explicit height set by host - if defined, don't auto-size height */\n    explicitHeight?: string | number;\n    /** Force auto-size even if container has dimensions */\n    forceAutoSize?: boolean;\n    /** Min height used by loader to detect collapse (default: 50) */\n    loaderMinHeight?: number;\n}\n\n//TODO : change IMyopComponent to ref specific impl\ntype RefTypes = {\n    [key: string]: IMyopComponent | Ref\n};\n\nexport interface IMyopComponent<P = any, R = any> {\n\n    id: string;\n\n    isInitiated: boolean;\n\n    markedForDisposed: boolean;\n\n    setInitiated: () => void\n\n    componentDefinition: IComponentDefinitionConfig\n\n    container: HTMLElement\n\n    //ref components can be element-less\n    element?: HTMLElement\n\n    send: (msg: BaseMyopMessage) => CleanupHandler\n\n    bind(messageType: MyopMessageKey, handler: () => boolean): void;\n\n    bind<T extends BaseMyopMessage>(messageType: MyopMessageKey, handler: (message: T) => boolean): void;\n\n    // boolean returned value = handled or not\n    onMessageReceived: (msg: BaseMyopMessage) => boolean\n\n    initiated: () => Promise<any>;\n\n    dispose: () => void\n\n    hide(): void;\n\n    show(): void;\n\n    inspect(): void;\n\n    /**\n     * Observes the iframe content size and automatically syncs it to the iframe element.\n     * Only available for iframe-based components. Uses direct contentDocument access.\n     * @param options - Configuration options including size change callback and min/max constraints\n     * @returns Cleanup function to stop observing\n     */\n    observeAutoSize?: (options?: AutoSizeOptions) => CleanupHandler;\n\n    /**\n     * Parsed myop:size meta tag from the component HTML.\n     * Set by HTMLComponentLoader before iframe creation.\n     * Used by the React host to determine sizing mode (fill vs content).\n     */\n    sizeMeta?: { width?: string | number; height?: string | number; minWidth?: number; maxWidth?: number; minHeight?: number; maxHeight?: number } | null;\n\n    parent?: IMyopComponent;\n\n    props: P\n\n    refs: R\n}\n\nfunction isInheritFrom(obj: any, baseClass: any) {\n    if (!obj) {\n        return false;\n    }\n\n    const proto = Object.getPrototypeOf(obj);\n\n    if (!proto) {\n        return false;\n    }\n\n    if (proto.constructor.name === baseClass.name) {\n        return true;\n    }\n    return isInheritFrom(proto, baseClass);\n}\n\n// TODO : move : \ntype messageHandler<T> = (message: T) => boolean;\n\nexport abstract class BaseMyopComponent<P = any, R extends RefTypes = RefTypes> implements IMyopComponent<P> {\n    id: string = ''\n\n    messageHandlers: Record<string, messageHandler<any>[]> = {};\n\n    element?: HTMLElement\n\n    protected constructor(public componentDefinition: IComponentDefinitionConfig, public container: HTMLElement, options?: loaderOptions) {\n        this.id = options?.id || HostSDK.Instance().assignId(componentDefinition);\n        const timeout = options?.timeout ? options?.timeout : 5 * 1000;\n        setTimeout(() => {\n            if (!this.isInitiated && this._whenInitiatedReject && !this._markedForDisposed) {\n                this._whenInitiatedReject(`timeout_${timeout} ${this.id}`);\n            }\n        }, timeout);\n\n        // TODO : auto inspect, control from config\n        this.initiated().then(() => {\n            // @ts-ignore\n            if (window.myop.hostSDK.inspected) {\n                this.inspect()\n            }\n        });\n    }\n\n    _markedForDisposed: boolean = false;\n\n    get markedForDisposed(): boolean {\n        return this._markedForDisposed;\n    }\n\n    set markedForDisposed(value: boolean) {\n        if (this._markedForDisposed) {\n            throw new Error('InvalidOperationException: The component is already in the process of being disposed. Dispose operation cannot be performed again until the current disposal process is complete.')\n        }\n        this._markedForDisposed = value;\n    }\n\n    abstract hide(): void;\n\n    abstract show(): void;\n\n    abstract inspect(): CleanupHandler;\n\n    //TODO: use bindWhen with return true predicate ...\n    bind = <T extends BaseMyopMessage>(messageType: string, handler: (message: T) => boolean) => {\n        if (!this.messageHandlers[messageType]) {\n            this.messageHandlers[messageType] = []\n        }\n\n        // handle duplicate registration\n        if (!this.messageHandlers[messageType].includes(handler)) {\n            this.messageHandlers[messageType].push(handler);\n        }\n    }\n\n    bindWhen = <T extends BaseMyopMessage>(messageType: string, predicate: (message: T) => boolean, handler: (message: T) => void): CleanupHandler => {\n        if (!handler) {\n            throw new Error('can\\'t use component.bindWhen without an handler');\n        }\n\n        if (!this.messageHandlers[messageType]) {\n            this.messageHandlers[messageType] = []\n        }\n\n        const handlers = this.messageHandlers[messageType];\n\n        const predicateWrappedHandler = (e: T) => {\n            if (predicate(e)) {\n                handler(e);\n                return true;\n            }\n            return false;\n        };\n\n        //TODO : handle duplicate registration ?\n        handlers.push(predicateWrappedHandler);\n\n        return () => {\n            const index = handlers.indexOf(predicateWrappedHandler);\n            if (index > -1) {\n                handlers.splice(index, 1);\n            }\n        }\n    }\n\n    onMessageReceived(incomeMessage: BaseMyopMessage): boolean {\n        //console.log('onMessageReceived', document.location.href, incomeMessage, this);\n        //TODO : handel special evets ? like initRes ?\n        if (incomeMessage.messageType === MyopMessages.ExecuteComponentMethod) {\n            const typedMessage = (incomeMessage as ExecuteComponentMethod);\n\n            //keeping this.method() so that context will saved\n            if ((this as any)[typedMessage.method]) {\n                (this as any)[typedMessage.method](typedMessage.content);\n            } else {\n                console.log(`method not found ${typedMessage.method} on component`, this)\n            }\n\n            return true;\n        }\n\n        const handlers = this.messageHandlers[incomeMessage.messageType];\n        if (handlers && handlers.length) {\n            let handled = false;\n\n            handlers.forEach(handler => {\n                handled = handled || handler(incomeMessage)\n            })\n            return handled;\n        } else {\n            //TODO : console only when debug config\n            //console.log('no handlers found for ', incomeMessage)\n        }\n        return false;\n    }\n\n    setInitiated = () => {\n        this.isInitiated = true;\n\n        if (this._whenInitiatedResolve)\n            this._whenInitiatedResolve();\n    }\n\n    isInitiated: boolean = false;\n\n    _whenInitiatedResolve?: (value?: any) => any;\n    _whenInitiatedReject?: (value?: any) => any;\n\n    _whenInitiated: Promise<any> = new Promise((resolve, reject) => {\n        this._whenInitiatedResolve = resolve;\n        this._whenInitiatedReject = reject;\n    });\n\n    initiated = () => {\n        return this._whenInitiated;\n    }\n\n    private sendCleanupMessage(message: CleanupMessage): void {\n        message.source = this.id;\n        message.destination = this.id;\n        message.direction = MessageDirection.down;\n\n        const cleanupHandler = this.bindWhen(message.replyMessageKey, (msg: MyopBindReplayMessage) => {\n            return msg.replayToHandler === message.handlerUniqueId\n        }, (m: CleanupReplayMessage) => {\n            message.handler(m);\n            cleanupHandler();\n        });\n\n        const handler = message.handler;\n        // @ts-ignore\n        delete message.handler\n\n        this.send(message);\n\n        message.handler = handler;\n    }\n\n    send(message: BaseMyopMessage): CleanupHandler {\n        //messages that exetracted from envelope already have source in them\n        if (!message.source)\n            message.source = this.id;\n\n        if (!message.destination)\n            message.destination = this.id;\n\n        message.direction = MessageDirection.down;\n\n        let cleanupHandler;\n        // TODO : fix heavy op..\n        //  if (isInheritFrom(message, MyopBindMessage)) {\n        // @ts-ignore\n        if (message.handler) {\n            const typedMessage = (message as MyopBindMessage);\n            cleanupHandler = this.bindWhen(typedMessage.replyMessageKey, (msg: MyopBindReplayMessage) => {\n                return msg.replayToHandler === typedMessage.handlerUniqueId\n            }, typedMessage.handler);\n\n            // @ts-ignore\n            delete message.handler\n        }\n\n        //TODO: think about that\n        if (message.ref) {\n            // serializable\n            message.ref = message.ref.__nonProxied || message.ref;\n        }\n\n        if (message.cleanable) {\n            return () => {\n                this.sendCleanupMessage(new CleanupMessage(message.id, (replay) => {\n                    //TODO : log replay?\n                }));\n\n                if (cleanupHandler) {\n                    cleanupHandler()\n                }\n            };\n        } else {\n            return () => {\n            }\n        }\n    }\n\n    dispose(): void {\n        this.markedForDisposed = true;\n\n        if (!this.isInitiated) {\n            //TODO : use sdk.logger\n            //console.log('disposing before isInitiated', this.id);\n            return;\n        }\n        console.log('disposing component', this.id);\n\n        // //TODO : implement dispose flow\n        // Object.keys(this.refs).forEach(refKey=>{\n        //     this.refs[refKey].dispose();\n        // });\n\n        //TODO : check if there is any time for the o\n        // ther side to proccess to message before die ?\n        //notify the other side SDK\n        this.send(new DisposeMessage())\n\n        const onDisposeHandlers = this.messageHandlers['onDispose']\n        if (onDisposeHandlers) {\n            onDisposeHandlers.forEach(disposeHandler => {\n                //TODO : send null or fix the type ?\n                disposeHandler(null);\n            })\n        }\n\n        //console.log(this.container);\n        //this.container.innerHTML = '';\n        this.messageHandlers = {}\n        this.id += '_disposed';\n        this.isInitiated = false;\n    }\n\n    props: P = {} as unknown as P;\n    refs: R = {} as unknown as R;\n}\n", "export interface IElementRef {\n    myopId?: string\n    htmlTagName: string\n    BoundingRect?: DOMRect\n    offsetTop?: number\n    offsetLeft?: number\n\n    type: string\n}\n\nexport class XPathElementRef implements IElementRef {\n    constructor(public xPath: string,\n                public htmlTagName: string,\n                public BoundingRect?: DOMRect,\n                public offsetTop?: number,\n                public offsetLeft?: number) {\n    }\n\n    public readonly type: string = 'XPathElementRef'\n}\n\nexport class MyopElementRef implements IElementRef {\n    constructor(public myopId: string,\n                public htmlTagName: string,\n                public BoundingRect?: DOMRect,\n                public offsetTop?: number,\n                public offsetLeft?: number) {\n\n    }\n\n    public readonly type: string = 'MyopElementRef'\n}\n", "import {MyopMessageKey} from \"./MyopMessages\";\nimport {BaseMyopMessage, MyopBindMessage, MyopBindReplayMessage} from \"../messages\";\nimport {CleanupHandler} from \"./index.ts\";\n\nexport type IMessageExecutorCleanup = CleanupHandler | Promise<CleanupHandler> | Promise<void> | void;\n\nexport const runExecutorCleanup = async (task: IMessageExecutorCleanup) => {\n    if (typeof task === 'function') {\n        // It's a function, call it\n        task();\n    } else if (task instanceof Promise) {\n        // It's a Promise, await it\n        const result = await task;\n\n        if (typeof result === 'function') {\n            // If the result is a function, call it\n            result();\n        }\n    }\n    // If task is void, do nothing\n}\n\ntype IMessageExecutor<T extends BaseMyopMessage> = (message: T) => IMessageExecutorCleanup;\n\ninterface IMessageHandler<T extends BaseMyopMessage> {\n    messageType: MyopMessageKey\n\n    executor: IMessageExecutor<T>;\n\n    messageToHost: (message: MyopBindReplayMessage, replayTo?: MyopBindMessage) => void;\n}\n\nexport abstract class BaseMessageHandler<T extends BaseMyopMessage = any> implements IMessageHandler<T> {\n\n    //TODO : add dispose method\n\n    constructor(public messageToHost: (message: MyopBindReplayMessage, replayTo?: MyopBindMessage) => void) {\n\n    }\n\n    abstract messageType: MyopMessageKey\n    abstract executor: IMessageExecutor<T>;\n}\n\nexport abstract class BaseContextMessageHandler<T extends BaseMyopMessage = any, E = any> extends BaseMessageHandler<T> {\n    constructor(public messageToHost: (message: MyopBindReplayMessage, replayTo?: MyopBindMessage) => void, public context?: E) {\n        super(messageToHost);\n    }\n}\n", "import {MyopMessages} from \"./MyopMessages\";\nimport {CleanupHandler, runExecutorCleanup} from \"./index.ts\";\nimport {BaseMessageHandler} from \"./baseMessageHandler\";\nimport {\n    BaseMyopMessage, CleanupMessage, CleanupReplayMessage, CreateRefComponentMessage, EnvelopedMessage,\n    InitMessage,\n    InitResponse,\n    MessageDirection,\n    MyopBindMessage,\n    MyopBindReplayMessage\n} from \"../messages\";\n\nexport class HostedComponent<T = any> {\n    send = (message: BaseMyopMessage) => {\n        //debugger;\n    }\n\n    //onMessageReceived: (msg: IMyopMessage) => void;\n\n    constructor(public id: string, public context?: T) {\n\n    }\n}\n\nexport interface IMyopSDK {\n    init: () => void;\n\n    messageToHost: (message: MyopBindReplayMessage, replayTo?: MyopBindMessage) => void\n\n    supportedHandlers: BaseMessageHandler[];\n\n    handleIncomeMessages: (message: BaseMyopMessage) => void\n\n    components: Record<string, HostedComponent>;\n}\n\n// const localHostHandledMessages = [\n//     MyopMessages.InitRequest,\n//     MyopMessages.InitResponse,\n//     //MyopMessages.EnvelopedMessage,\n// ]\n\nexport abstract class BaseMyopSDK implements IMyopSDK {\n\n    abstract messageToHost: (message: MyopBindReplayMessage, replayTo?: MyopBindMessage) => void;\n\n    abstract supportedHandlers: BaseMessageHandler[];\n\n    messageToHandleAfterInit: BaseMyopMessage[] = [];\n\n    components: Record<string, HostedComponent> = {};\n\n    alwaysPassEnvelopesToHost: boolean = false\n\n    messageCleanupCache: Record<string, CleanupHandler | Promise<CleanupHandler>> | Promise<void> = {};\n\n    handleIncomeMessages(event: any) {\n        const eventContent = event.data ? event.data : event.detail;\n\n        if (!eventContent || !eventContent.myop) {\n            // not myop marked event \n            return;\n        } else {\n            let message = eventContent as BaseMyopMessage;\n\n            if (message.direction !== MessageDirection.down) {\n                //console.log('message dropped in baseSDK, direction was ', event.data.direction)\n                return;\n            }\n\n            // if (localHostHandledMessages.includes(message.messageType)) {\n            //     debugger;\n            //     //TODO : fix direction ? message will not proccess otherwise\n            //     window.myop.hostSDK.send(message)\n            //     return;\n            // }\n\n            if (message.messageType === MyopMessages.DisposeMessage) {\n                //debugger;\n\n                //TODO : should not be optional, fix and remove 'if'\n                if (message.destination)\n                    delete this.components[message.destination]\n                return;\n            }\n\n            // We got our id from our hostSDK\n            if (message.messageType === MyopMessages.InitMessage) {\n                //TODO : SDK may serve more than 1 component .. think about that\n                // @ts-ignore\n                const newComponentId = (message as InitMessage).content.id;\n\n                if (this.components[newComponentId]) {\n                    //debugger;\n                    //throw new Error(\"rechived init message for an exsising component.\")\n                    return;\n                }\n\n                this.components[newComponentId] = new HostedComponent(newComponentId)\n                this.messageToHost(new InitResponse(newComponentId));\n\n                // TODO : is it true to not pass further ( to the component )\n                return;\n            }\n\n            // for same HostSDK cases\n            // when both RefComponent and realComponent hosted in the same HostSDK\n            if (message.messageType === MyopMessages.EnvelopedMessage) {\n                const envelopedMessage = (message as EnvelopedMessage);\n                const innerMessage = envelopedMessage.message;\n                message = innerMessage;\n\n                if (this.alwaysPassEnvelopesToHost || this.components[message.destination!]) {\n                    // @ts-ignore\n                    const destinationComponent = myop.hostSDK.components.find(c => c.id === innerMessage.destination);\n                    if (destinationComponent) {\n                        destinationComponent.send(innerMessage);\n                        return;\n                    }\n\n                    // @ts-ignore\n                    const envelopedDestinationComponent = myop.hostSDK.components.find(c => c.id === envelopedMessage.destination);\n                    if (envelopedDestinationComponent) {\n                        envelopedDestinationComponent.send(innerMessage);\n                        return;\n                    }\n                } else {\n                    return;\n                }\n            }\n\n            // if(message.messageType === MyopMessages.CreateRefComponentMessage){\n            //     const typedMessage : CreateRefComponentMessage = message as CreateRefComponentMessage;\n            // //    debugger;\n            // }\n            if (message.messageType) {\n\n                if (message.messageType === MyopMessages.CleanupMessage) {\n                    const typedMessage = message as CleanupMessage;\n                    const cleanup = this.messageCleanupCache[typedMessage.cleanupForMessageId];\n\n                    const cleanupMessage = new CleanupReplayMessage(!!cleanup);\n                    cleanupMessage.destination = message.destination;\n\n                    if (!!cleanup) {\n                        delete this.messageCleanupCache[typedMessage.cleanupForMessageId];\n                        runExecutorCleanup(cleanup).then(() => {\n                            this.messageToHost(cleanupMessage, typedMessage);\n                        }).catch(() => {\n                            //TODO : handel error?\n                        })\n                    } else {\n                        this.messageToHost(cleanupMessage, typedMessage);\n                    }\n                    return;\n                }\n\n                let actionHandlerFound = false;\n\n                this.supportedHandlers.forEach(handler => {\n                    if (handler.messageType === message.messageType) {\n                        actionHandlerFound = true;\n                        const cleanup = handler.executor(message);\n\n                        if (message.cleanable && cleanup) {\n                            this.messageCleanupCache[message.id] = cleanup;\n                        }\n\n                        if (cleanup && !message.cleanable) {\n                            throw new Error(`Cleanup handler generated for non-cleanable message. \nmessageType - ${message.messageType}, handler executor was - ${handler.executor}\n\nPlease review the message definition object & message handler.\nTo ensure cleanup properly set 'cleanable' true at message definition and return IMessageExecutorCleanup from your handlers.`)\n                        }\n\n                        if (!cleanup && message.cleanable) {\n                            throw new Error(`No cleanup handler generated for a cleanable message. \nmessageType - ${message.messageType}, handler executor was - ${handler.executor}\n\nPlease review the message definition object & message handler.\nTo ensure cleanup properly set 'cleanable' true at message definition and return IMessageExecutorCleanup from your handlers.`)\n                        }\n                    }\n                })\n\n                if (!actionHandlerFound) {\n                    //TODO : print with debug config only\n                    //console.log('no message handler was found for ', message)\n                }\n            } else {\n                console.log('unsupported message type')\n            }\n        }\n    }\n\n    abstract init: () => void;\n}\n", "import {MyopMessageKey} from \"./MyopMessages\";\n\nexport * from './MyopElementRef';\nexport * from './baseMessageHandler';\nexport * from './BaseMyopSDK';\n\nexport type CleanupHandler = () => void\n\nexport type Dictionary<T> = { [key: string]: T; };\n\n//export type SkinLoaderType = 'IframeLoader' | 'WebComponentLoader' | 'HTMLLoader' | string;\n\nexport const SkinLoaders = {\n    \"IframeLoader\": \"IframeLoader\",\n    \"WebComponentLoader\": \"WebComponentLoader\",\n    \"HTMLLoader\": \"HTMLLoader\",\n    \"MinimizedLoader\": \"MinimizedLoader\"\n} as const;\nexport type SkinLoaderType = keyof typeof SkinLoaders;\n\nexport type PropType = 'any' | 'string' | 'number' | string; // TODO : <\nexport type RefSelectorType = 'id-attribute' | 'css-selector' | 'xpath' | string;\n\nexport const LoaderFrameworks = {\n    \"react\": \"react\",\n    \"vue\": \"vue\",\n    \"angular\": \"angular\",\n} as const\nexport type LoaderFrameworkType = keyof typeof LoaderFrameworks;\n\nexport interface IWebComponentLoaderConfig extends ISkinLoaderConfig {\n    type: \"WebComponentLoader\";\n    url: string,\n    tag: string,\n    framework?: LoaderFrameworkType\n}\n\nexport interface IIframeLoaderConfig extends ISkinLoaderConfig {\n    type: \"IframeLoader\";\n    url: string\n    autoHeight: boolean\n    height?: string\n    width?: string\n}\n\nexport const ShadowRootModeType = {\n    \"open\": \"open\",\n    \"closed\": \"closed\",\n    \"none\": \"none\",\n    \"localFrame\": \"localFrame\"\n} as const;\n\n\nexport interface IHTMLLoaderConfig extends ISkinLoaderConfig {\n    type: \"HTMLLoader\";\n    HTML: string;\n    //TODO: rename(rootMode/customElementMode) + db migration\n    shadowRootMode?: keyof typeof ShadowRootModeType;\n    autoHeight?: boolean;\n    height?: string;\n    width?: string;\n    /**\n     * When true, an inline-HTML (localFrame) component is rendered in a sandboxed,\n     * cross-origin iframe with NO access to the host document (untrusted code).\n     * The host render policy can also force this regardless of the config value.\n     */\n    isolation?: boolean;\n}\n\n/**\n * How a component is rendered on the host page, in ascending isolation:\n *  - 'webComponent'   \u2014 custom element on the host document (most privileged)\n *  - 'iframe'         \u2014 same-origin inline-HTML iframe (today's default)\n *  - 'isolatedIframe' \u2014 sandboxed, cross-origin iframe (untrusted code)\n */\nexport type RenderMode = 'webComponent' | 'iframe' | 'isolatedIframe';\n\nexport interface RenderPolicyContext {\n    componentDefinition: IComponentDefinitionConfig;\n    skin: ISkinConfig;\n    /** What the component asked for (marker \u21D2 'webComponent', config.isolation \u21D2 'isolatedIframe'). */\n    requestedMode: RenderMode;\n    /** Whether the HTML carries the `<!-- myop-web-component -->` marker. */\n    isWebComponent: boolean;\n}\n\n/**\n * Host-supplied gate deciding how (or whether) a component renders. Return a\n * RenderMode to use, or `false` to block rendering entirely.\n */\nexport type RenderPolicy =\n    (ctx: RenderPolicyContext) => RenderMode | false | Promise<RenderMode | false>;\n\n//for internal dashboard usage\nexport interface IMinimizedLoaderConfig extends ISkinLoaderConfig {\n    type: \"MinimizedLoader\";\n}\n\ninterface DashboardObject {\n    _temp_client_id?: string,\n}\n\ntype Extend<T, U> = T & U;\n\ntype ExtendRecursively<T, E> = {\n    [K in keyof E]: E[K];\n} & {\n    [K in keyof T]: T[K] extends object\n        ? ExtendRecursively<T[K], E>\n        : T[K];\n};\n\nexport type IDashboard<T> = ExtendRecursively<T, DashboardObject>;\n\nexport interface ISkinLoaderConfig {\n    type: SkinLoaderType\n\n    [key: string]: any; // Allows any additional properties\n}\n\nexport interface v2_IReleaseMetadata {\n    environmentId: string;\n    environmentIdentifier: string;\n    releasedOn?: string;\n    releasedBy?: string;\n}\n\nexport interface v2_IVariantConfig extends v2_IMyopStoredObject {\n    loader: ISkinLoaderConfig\n    componentId: string;\n\n    releases?: v2_IReleaseMetadata[]\n}\n\nexport interface ISkinConfig {\n    id: string\n    name: string\n    description: string\n    loader: ISkinLoaderConfig\n    createdBy?: string\n    createdOn?: string\n}\n\nexport interface v2_ISkinConfig extends ISkinConfig {\n    componentId: string\n}\n\nexport interface IMessagePropConfig extends IPropConfig {\n    type: PropType\n    messageType: MyopMessageKey\n}\n\nexport interface IBindMessagePropConfig extends IPropConfig {\n    type: PropType\n    messageType: MyopMessageKey\n}\n\nexport const PropMessageModes = {\n    \"input\": \"input\",\n    \"output\": \"output\"\n} as const;\n\nexport const PropConfigBehaviorTypes = {\n    \"message\": \"message\",\n    \"code\": \"code\"\n} as const;\n\nexport interface IPropMessageBehaviorParam {\n    value: string\n}\n\nexport interface IPropBehavior {\n    type: keyof typeof PropConfigBehaviorTypes\n}\n\nexport interface IPropCodeBehavior extends IPropBehavior {\n    type: \"code\"\n    remap?: string\n}\n\nexport interface IPropMessageBehavior extends IPropBehavior {\n    type: \"message\"\n    message: MyopMessageKey\n    ref: string, //TODO make it id\n    params: IPropMessageBehaviorParam[]\n    mode: keyof typeof PropMessageModes\n}\n\nexport interface IPropConfig {\n    id: string\n    name: string\n    description: string\n    type: PropType\n    behavior: IPropBehavior\n}\n\n\nexport class RefBehaviorType {\n    static code = 'code' as const\n    static component = 'component' as const\n}\n\nexport type IRefBehaviorType = 'code' | 'component';\n\nexport interface IRefBehavior {\n    type: IRefBehaviorType\n}\n\nexport interface IComponentRefBehavior extends IRefBehavior {\n    type: 'component'\n    componentId: string\n\n    /**\n     * @deprecated\n     * Property instance is deprecated and will be removed in future versions.\n     */\n    instance: IComponentInstanceConfig\n}\n\nexport interface ICodeRefBehavior extends IRefBehavior {\n    type: 'code'\n}\n\nexport interface IRefConfig {\n    id: string\n    name: string\n    description: string\n    selectorType: RefSelectorType\n    selector: string\n    behavior: IRefBehavior\n}\n\n/**\n * Experience segment rule\n */\nexport interface IExperienceSegmentRule {\n    property: string;\n    operator: string;\n    value: string;\n}\n\n/**\n * Experience A/B split version\n */\nexport interface IExperienceABSplitVersion {\n    id: string;\n    percentage: number;\n}\n\n/**\n * Experience A/B split configuration\n */\nexport interface IExperienceABSplit {\n    versions: IExperienceABSplitVersion[];\n}\n\n/**\n * Experience segment configuration\n */\nexport interface IExperienceSegment {\n    id: string;\n    name: string;\n    description: string;\n    rules: IExperienceSegmentRule[];\n    useAb: boolean;\n    componentVariants: Record<string, string | Record<string, string>>;\n    abSplit?: IExperienceABSplit;\n    stickyProperties?: string[];\n}\n\n/**\n * Experience definition config (v2)\n */\nexport interface IExperienceDefinitionConfig extends v2_IMyopStoredObject {\n    /** Selected component IDs */\n    components: string[];\n    /** Segment configurations */\n    segments: IExperienceSegment[];\n    /** Fallback variant per component */\n    fallback: Record<string, string>;\n    /** Tags */\n    tags: string[];\n}\n\nexport interface IComponentDefinitionConfig {\n    id: string;\n    name: string,\n    description: string,\n    // props: Record<string, IPropConfig> //id - type\n    // refs: Record<string, IRefConfig>,\n    // skins: Record<string, ISkinConfig>\n    props: IPropConfig[],\n    refs: IRefConfig[],\n    skins: ISkinConfig[],\n    defaultSkin: number;\n\n    //TODO : think about that\n    //resolvedDefinitions?: IComponentDefinitionConfig[]\n    //TODO : move to base class ( IStorableItem or so...)\n\n    createdOn?: string\n    createdBy?: string\n    updatedBy?: string\n}\n\n\nexport interface v2_IBaseMyopObject {\n    id: string,\n    name: string,\n    description: string,\n}\n\nexport interface v2_IMyopStoredObject extends v2_IBaseMyopObject {\n    updatedOn?: string\n    updatedBy?: string\n}\n\nexport interface ComponentAccess {\n    visibility: 'private' | 'unlisted' | 'public';\n    unlisted?: {\n        slug: string;\n    };\n    marketplace?: {\n        status: 'draft' | 'submitted' | 'claimed' | 'closed';\n        description: string;\n        contactEmail: string;\n        deadline: string;\n    };\n}\n\nexport interface v2_IComponentDefinitionConfig extends v2_IMyopStoredObject {\n    variants_ids: string[],\n    DTOs: v2_IDTO[],\n    tags: string[],\n    access?: ComponentAccess,\n\n    //\n    variants_names: string[],\n    variants_data: {\n        name: string;\n        id: string\n        description?: string\n        updatedOn?: string\n        updatedBy?: string\n        has_releases?: boolean\n    }[],\n\n    preview_variant: v2_IVariantConfig;\n    extra?: {\n        firstVariant: v2_IVariantConfig; //when new component creates at the client\n    }\n}\n\nexport interface v2_IDTO extends v2_IMyopStoredObject {\n    data: object\n    methodName: string\n}\n\nexport interface ISkinInstanceConfig {\n    id: string\n}\n\nexport interface ISkinSelectorConfig {\n    type: keyof typeof SkinSelectorTypes,\n    //skins: ISkinInstanceConfig[]\n}\n\nexport const SegmentType = {\n    \"FunctionResult\": \"FunctionResult\",\n} as const;\n\nexport interface ISegmentInstance {\n    segmentId: string;\n    skinSelector: ISkinSelectorConfig\n}\n\nexport interface ISegmentDefinition {\n    id: string;\n    type: keyof typeof SegmentType\n}\n\nexport interface IFunctionResultsSegment extends ISegmentDefinition {\n    id: string;\n    type: typeof SegmentType.FunctionResult\n    name: string\n    description: string\n    function: string\n}\n\nexport const SkinSelectorTypes = {\n    \"Segmented\": \"Segmented\",\n    \"Dedicated\": \"Dedicated\",\n\n    /**\n     * This Selector Type is not yet supported but will be added in a future release.\n     * Please check the documentation for updates.\n     *\n     * @type {string}\n     */\n    \"Default\": \"Default\"\n} as const;\n\n\n/**\n * This Skin Config Type is not yet supported but will be added in a future release.\n * Please check the documentation for updates.\n *\n * @type {IDefaultSkinConfig}\n */\nexport interface IDefaultSkinConfig extends ISkinSelectorConfig {\n    type: typeof SkinSelectorTypes.Default,\n}\n\nexport interface ISegmentedSkinConfig extends ISkinSelectorConfig {\n    type: typeof SkinSelectorTypes.Segmented,\n    segments: ISegmentInstance[]\n}\n\nexport interface IDedicatedSkinConfig extends ISkinSelectorConfig {\n    type: typeof SkinSelectorTypes.Dedicated,\n\n    /**\n     * @deprecated Use {@link skin} instead.\n     * Property skins is deprecated and will be removed in future versions.\n     * Please update your code to use {@link skin} for better compatibility.\n     *\n     * @type {string}\n     */\n    skins?: ISkinInstanceConfig[] // deprecated\n    skin: ISkinInstanceConfig\n}\n\nexport interface IComponentInstanceConfig {\n    id: string;\n    componentId: string;\n\n    //TODO :\n    // RefID ? to support more than 1 component from the same type in composites ?\n\n    //TODO : remove\n    componentName: string; // << check\n\n    skinSelector: ISkinSelectorConfig\n\n    // storing the nested config for ref components\n    nestedComponents?: IComponentInstanceConfig[]\n\n    //only on GET?\n    //TODO : think about that\n    resolvedExperiences?: IExperience[]\n    // will include instance and def config in order to render in production\n    resolvedNestedComponents?: IComponentConfig[]\n}\n\nexport const ExperienceTypes = {\n    \"Segment\": \"Segment\",\n    \"Promo\": \"Promo\",\n    \"AB\": \"AB\"\n} as const;\n\nexport interface IExperience {\n    id: string\n    name: string\n    description: string\n    type: keyof typeof ExperienceTypes\n    experiences: IExperience[]\n    //stickinessFactor\n    //EndDate\n}\n\n// export interface IABExperienceGroup {\n//     id: string\n//     name: string\n//     percentage: number\n// }\n\nexport interface IABExperience extends IExperience {\n    type: typeof ExperienceTypes.AB\n    // groups: IABExperienceGroup[]\n    experiences: IExperience[]\n    percentage: number\n}\n\nexport interface IDateRange {\n    id: string\n    start: Date\n    end: Date\n    timezone: string\n}\n\nexport interface ISegmentExperience extends IExperience {\n    type: keyof typeof ExperienceTypes\n    segment: ISegmentDefinition\n    dateRange?: IDateRange\n}\n\nexport interface IUserFlowDefinition {\n    id: string;\n    name: string;\n    description: string;\n    components: IComponentInstanceConfig[];\n    origins: string[],\n    experiences: IExperience[]\n    branch?: string\n}\n\nexport interface IComponentConfig {\n    instance: IComponentInstanceConfig\n    type: IComponentDefinitionConfig\n\n    // TODO : verify uniqueness (dashboard & server)\n    name: string\n}\n\ninterface IBranchable {\n    branch?: string\n}\n\nexport interface IUserFlow extends Omit<IUserFlowDefinition, 'components'>, IBranchable {\n    components: IComponentConfig[]\n}\n\nexport class RootRef {\n    constructor(public container: HTMLElement, public shadowRoot?: ShadowRoot) {\n\n    }\n\n    getRootDiv = () => {\n        return (this.shadowRoot || this.container).querySelector('div')\n    }\n\n    getRoot = () => {\n        return (this.shadowRoot || this.container);\n    }\n}\n", "export type Serializable<T> =\n    T extends Function ? never : // Exclude functions\n        T extends Array<infer U> ? Serializable<U>[] : // Handle arrays\n            T extends object ? {\n                [K in keyof T as T[K] extends Function ? never : K]: Serializable<T[K]>\n            } : T; // Handle objects\n\nconst isPrimitive = (value) => {\n    return value !== Object(value);\n}\n\nconst isFunction = (value) => {\n    return typeof value === 'function';\n}\n\nexport const containsPrimitivesOnly = (obj) => {\n    if (isPrimitive(obj)) {\n        return true;\n    }\n\n    if (isFunction(obj)) {\n        return false\n    }\n\n    if (Object.getPrototypeOf(obj)) {\n        return false\n    }\n\n    for (const key in obj) {\n        const value = obj[key];\n        if (typeof value === 'object') {\n            // Recursively check if it's a nested object\n            if (!containsPrimitivesOnly(value)) {\n                return false;\n            }\n        } else if (isPrimitive(value)) {\n            continue; // It's a primitive, so we can skip it\n        } else {\n            return false; // Found a non-primitive value\n        }\n    }\n\n    return true; // All values are primitives or nested objects with primitives\n}\n\n// currently support root level only\n// {x: 1, y : 'a', z : ()=>{...}, inner : { x: 1 , y : 'a'} }\n// {x: 1, y : 'a'}\n//https://developer.mozilla.org/en-US/docs/Glossary/Falsy\nexport type SerializableSkeleton<T> = Partial<Record<keyof T, boolean | Partial<Record<string, boolean>>>> | boolean;\n\nexport const makeSerializable = <T>(\n    obj: T,\n    skeleton: SerializableSkeleton<T> = {},\n    includeFalsyKeys: boolean = true, // TODO : use that arg\n    seen: WeakMap<object, Serializable<any>> = new WeakMap()\n): Serializable<T> => {\n\n    if (isPrimitive(obj)) {\n        return obj as Serializable<T>; // Directly return primitive values\n    }\n\n    if (Array.isArray(obj)) {\n        if (seen.has(obj)) {\n            return seen.get(obj)!; // Return the already processed object\n        }\n\n        // Handle array serialization\n        const serializableArray: Serializable<any>[] = [];\n        seen.set(obj, serializableArray); // Store the array in seen\n\n        for (let index = 0; index < obj.length; index++) {\n            const element = obj[index];\n            serializableArray[index] = makeSerializable(element, skeleton, includeFalsyKeys, seen);\n        }\n        return serializableArray as Serializable<T>;\n    }\n\n    if (obj !== null && typeof obj === 'object') {\n        // Check for cyclic references\n        if (seen.has(obj)) {\n            return seen.get(obj)!; // Return the already processed object\n        }\n        const serializableObject: Partial<Serializable<T>> = {};\n        seen.set(obj, serializableObject); // Store the object in seen\n\n        for (const key in obj) {\n            // Check if the key is in the skeleton and if it's a valid key to serialize\n\n            const keyInSkeleton = typeof skeleton == \"boolean\" ? skeleton : skeleton[key];\n\n            if (keyInSkeleton) {\n                if (keyInSkeleton === true) {\n                    // If the skeleton indicates to serialize this key\n                    if (includeFalsyKeys ? obj[key] !== undefined : obj[key]) {\n                        // @ts-ignore\n                        serializableObject[key] = makeSerializable(obj[key], true, includeFalsyKeys, seen);\n                    }\n                } else if (typeof keyInSkeleton === 'object') {\n                    // If the skeleton indicates nested keys to serialize\n                    // @ts-ignore\n                    serializableObject[key] = makeSerializable(obj[key], keyInSkeleton, includeFalsyKeys, seen);\n                }\n            }\n        }\n        return serializableObject as Serializable<T>;\n    }\n\n    return {} as any; // Return an empty object for other cases\n}\n", "export const Errors = {\n    notSerializableRefCall: (prop, arg) => {\n        throw new Error(`\nThe input provided to '${prop.toString()}' is not serializable. Serialization is required to ensure that the data can be safely transferred to the skin implementation. \nThe following types of data are considered non-serializable and cannot be processed:\n\n- Functions\n- DOM elements\n- Class instances\n- Circular references\n- Symbols\n- BigInt values\n\nIn the following execution we detected :\n~~~~~~~~\n${arg} \n~~~~~~~~\nas not serializable.\n\nTo resolve this issue, please ensure that all inputs passed to '${prop.toString()}' are in a serializable format.\nThis typically includes primitive types (strings, numbers, booleans), arrays, and plain objects. \nIf you need to include complex data types, consider converting them to a serializable structure before passing them to the function.\nOr use Myop message that support it: CustomRefMessage, AddEventListenerMessage or ExecuteScriptMessage.\n\nSuggested Fix:\n1. Remove or replace non-serializable values from your input.\n2. If using objects, ensure they do not contain any functions or circular references.\n3. Convert any class instances to plain objects or JSON-compatible formats.\n4. Use dedicated Myop message.\n\nFor more details on serialization and Myop message examples, refer to https://docs.myop.dev\\.\n\n`);\n    }\n}\n\n", "import {BaseMyopComponent, IMyopComponent} from \"./IMyopComponent\";\nimport {BaseMyopMessage, ExecuteComponentMethod} from \"../../messages\";\nimport {IComponentDefinitionConfig} from \"../../common\";\nimport {EnvelopedMessage} from \"../../messages/EnvelopedMessage\";\nimport {loaderOptions} from \"../hostSDK.ts\";\n\nexport class MyopRefComponent extends BaseMyopComponent {\n\n    constructor(public componentDefinition: IComponentDefinitionConfig, public parent: IMyopComponent, options?: loaderOptions) {\n        //TODO : check parentComponent.container...\n        super(componentDefinition, parent.container, options);\n    }\n\n    hide() {\n        //this.send(new ExecuteComponentMethod(arguments.callee.name));\n        this.send(new ExecuteComponentMethod('hide'));\n    }\n\n    show() {\n        this.send(new ExecuteComponentMethod('show'));\n    }\n\n    inspect() {\n        //TODO : support real cleanup\n        //console.log('ref inspect called, creating ExecuteComponentMethod inspect', document.location.href, this.id);\n        return this.send(new ExecuteComponentMethod('inspect'));\n    }\n\n    setHeightBasedOnDocumentElement() {\n        // @ts-ignore\n        this.send(new ExecuteComponentMethod('setHeightBasedOnDocumentElement'));\n    }\n\n    setHeightBasedOnScrollHeight() {\n        // @ts-ignore\n        this.send(new ExecuteComponentMethod('setHeightBasedOnScrollHeight'));\n    }\n\n    onMessageReceived(incomeMessage: BaseMyopMessage): boolean {\n        // if (incomeMessage.messageType === 'MutationObserverMessage') {\n        //  debugger;\n        //     this.setHeightBasedOnScrollHeight();\n        //     return true;\n        // }\n        return super.onMessageReceived(incomeMessage);\n    }\n\n\n    send = (message: BaseMyopMessage) => {\n        //console.log('ref message sending ', message);\n        // @ts-ignore\n        const handler = message.handler\n        const cleanupHandler = super.send(message);\n\n        // this.id will be available on the nested component\n        this.parent.send(new EnvelopedMessage(this.id, message));\n\n        // @ts-ignore\n        message.handler = handler\n        return cleanupHandler;\n    };\n\n    dispose = () => {\n        if (this.isInitiated)\n            this.send(new ExecuteComponentMethod('dispose'));\n        super.dispose();\n    }\n}\n", "import {BaseMyopComponent} from \"./IMyopComponent\";\nimport {BaseMyopMessage} from \"../../messages\";\nimport {CleanupHandler, IComponentDefinitionConfig, ISkinConfig} from \"../../common\";\nimport {setDebugStyle} from \"../componentCore\";\nimport {loaderOptions} from \"../hostSDK\";\n\n/**\n * Component wrapper for Myop Web Components that are extracted from HTML\n * and run directly on the host document (not in an iframe).\n *\n * These components use the native Web Components API (Custom Elements + Shadow DOM)\n * and communicate via direct method calls and CustomEvents instead of postMessage.\n */\nexport class MyopExtractedWebComponent extends BaseMyopComponent {\n    private ctaCleanup?: () => void;\n    private _ctaHandler?: (action: string, payload: unknown) => void;\n    private _ctaQueue: Array<{action: string, payload: unknown}> = [];\n\n    // A single 'myop-cta' listener, attached at construction so CTAs a component\n    // dispatches during its first initWithData() render \u2014 before the host attaches\n    // a handler \u2014 are buffered (and flushed on setCtaHandler), matching the iframe\n    // path's pre-handler CTA queue.\n    private _ctaListener = (e: Event) => {\n        const detail = (e as CustomEvent).detail;\n        if (!detail?.action) return;\n        if (this._ctaHandler && !this.markedForDisposed) {\n            this._ctaHandler(detail.action, detail.payload);\n        } else if (!this._ctaHandler) {\n            this._ctaQueue.push({ action: detail.action, payload: detail.payload });\n        }\n    };\n\n    constructor(\n        componentDefinition: IComponentDefinitionConfig,\n        skin: ISkinConfig,\n        public container: HTMLElement,\n        private customElement: HTMLElement,\n        private tagName: string,\n        options?: loaderOptions\n    ) {\n        super(componentDefinition, container, options);\n        this.element = customElement;\n\n        // Listen BEFORE any initWithData render so init-time CTAs aren't lost.\n        this.customElement.addEventListener('myop-cta', this._ctaListener);\n        this.ctaCleanup = () => this.customElement.removeEventListener('myop-cta', this._ctaListener);\n\n        // Web components are initiated immediately (no postMessage handshake needed)\n        this.setInitiated();\n    }\n\n    cleanupInspect: CleanupHandler = () => {};\n\n    inspect() {\n        this.cleanupInspect = setDebugStyle(this.id, 'MyopExtractedWebComponent', 0, this.container, this.customElement, this.componentDefinition);\n        return this.cleanupInspect;\n    }\n\n    hide() {\n        this.customElement.style.opacity = '0';\n        this.customElement.style.position = 'absolute';\n        this.customElement.style.pointerEvents = 'none';\n        this.customElement.style.visibility = 'hidden';\n        this.customElement.style.height = '0';\n        this.customElement.style.width = '0';\n    }\n\n    show() {\n        this.customElement.style.opacity = '1';\n        this.customElement.style.position = 'unset';\n        this.customElement.style.pointerEvents = 'all';\n        this.customElement.style.visibility = 'visible';\n        this.customElement.style.height = '';\n        this.customElement.style.width = '';\n    }\n\n    /**\n     * Initialize the component with data by calling myop_init_interface directly\n     */\n    initWithData(data: unknown): void {\n        if (typeof (this.customElement as any).myop_init_interface === 'function') {\n            (this.customElement as any).myop_init_interface(data);\n        }\n    }\n\n    /**\n     * Get current data from the component\n     */\n    getData(): unknown {\n        if (typeof (this.customElement as any).myop_init_interface === 'function') {\n            return (this.customElement as any).myop_init_interface();\n        }\n        return undefined;\n    }\n\n    /**\n     * Set CTA handler - unified API with iframe components.\n     * Called via props.myop_cta_handler = handler\n     */\n    setCtaHandler(handler: (action: string, payload: unknown) => void): void {\n        // The 'myop-cta' listener is attached in the constructor, so we only set the\n        // handler and flush anything the component emitted before now (e.g. during the\n        // first initWithData render).\n        this._ctaHandler = handler;\n\n        if (this._ctaQueue.length > 0) {\n            const queue = [...this._ctaQueue];\n            this._ctaQueue = [];\n            queue.forEach(item => {\n                if (!this.markedForDisposed) {\n                    handler(item.action, item.payload);\n                }\n            });\n        }\n    }\n\n    /**\n     * For compatibility with message-based components.\n     * Web components don't use postMessage, so this is a no-op for most messages.\n     */\n    send = (message: BaseMyopMessage<any>) => {\n        // Web components don't use the postMessage system\n        // Instead, interact directly via props.myop_init_interface and props.myop_cta_handler\n        const cleanupHandler = super.send(message);\n\n        // Log for debugging\n        console.debug('[MyopExtractedWebComponent] send() called - web components use direct API instead', message);\n\n        return cleanupHandler;\n    }\n\n    dispose = () => {\n        if (this.ctaCleanup) {\n            this.ctaCleanup();\n        }\n        super.dispose();\n        this.customElement.parentNode?.removeChild(this.customElement);\n    }\n}\n", "//type AConstructorTypeOf<T> = new (...args: any[]) => T;\nimport {IMyopComponent} from \"./components/IMyopComponent\";\nimport {CreateRefComponentMessage, CustomRefMessage, Ref} from \"../messages\";\nimport * as messages from \"../messages\";\nimport {\n    CleanupHandler, IComponentConfig,\n    type IComponentDefinitionConfig,\n    IComponentRefBehavior, IHTMLLoaderConfig, IPropCodeBehavior,\n    IPropConfig, ISkinConfig, PropConfigBehaviorTypes,\n    RefBehaviorType, ShadowRootModeType, SkinLoaders, SkinLoaderType\n} from \"../common\";\nimport {containsPrimitivesOnly} from \"../common/utils/serialization\";\nimport {Errors} from \"./logMessages\";\nimport {MyopRefComponent} from \"./components/myopRefComponent\";\nimport {MyopExtractedWebComponent} from \"./components/myopExtractedWebComponent\";\nimport {MyopIframeComponent} from \"./components/myopIframeComponent\";\nimport {loaderOptions} from \"./hostSDK\";\n\ntype componentDefinitionProps = IComponentDefinitionConfig['props']\n\nconst createDebugTitle = (text: string, top: number, componentDefinitionConfig: IComponentDefinitionConfig) => {\n    const titleEl = document.createElement('a');\n    titleEl.textContent = text;\n    titleEl.style.position = 'relative';\n    titleEl.style.padding = '0 5px';\n    titleEl.style.fontSize = '14px';\n    titleEl.style['top'] = '0';\n    titleEl.style.top = `${top}px`;\n    //titleEl.style.left = '50%';\n    titleEl.style.transform = 'translateX(-50%)';\n    titleEl.target = '_blank';\n    titleEl.href = `https://dashboard.myop.dev/dashboard/component/${componentDefinitionConfig.id}`\n\n    return titleEl;\n};\n\nexport const setDebugStyle = (id: string,\n                              type: string,\n                              top: number,\n                              container: HTMLElement,\n                              componentElement: HTMLElement,\n                              componentDefinitionConfig: IComponentDefinitionConfig\n): CleanupHandler => {\n    //#007BFF (blue) or #FF5722 (orange)\n    //#4CAF50 (green) or #FFC107 (amber)\n    // const topText = createDebugTitle(`${id} : ${type}`, top, componentDefinitionConfig);\n    const topText = createDebugTitle(`${componentDefinitionConfig.name} : ${type}`, top, componentDefinitionConfig);\n    container.insertBefore(topText, componentElement);\n    componentElement.style.border = '1px solid #007BFF';\n    componentElement.style.display = 'block';\n\n    return () => {\n        componentElement.style.border = 'unset';\n        container.removeChild(topText);\n    }\n}\n\nconst reportError = (propConfig: IPropConfig, propName: string, component: IMyopComponent<any, any>) => {\n    if (!propConfig) {\n\n        console.error(\n            // throw new Error(\n            `Error: Undefined Prop\\n\\n` +\n            `It looks like you've tried to use a prop that hasn't been defined.\\n` +\n            `Please check the prop name for any typos or ensure that it is properly defined in the component's prop list.\\n\\n` +\n            `Prop Name: ${propName}\\n` +\n            `Component: ${component.componentDefinition.name}, ID: ${component.componentDefinition.id}\\n\\n` +\n            `For more information, refer to the component page https://dashboard.myop.dev/dashboard/component/${component.componentDefinition.id} or consult the developer guide.`\n        );\n        return true\n    }\n    return false\n}\n\nconst reportUnsupported = (propConfig: IPropConfig, propName: string, component: IMyopComponent<any, any>) => {\n    console.error(\n        `Error: Code Prop Not Supported\\n\\n` +\n        `Currently, code props are only supported in local frame components.\\n` +\n        `\u26A0\uFE0F This is a work in progress feature \u2014 code props will be supported in upcoming versions.\\n\\n` +\n        `In the meantime, you can use message props.\\n\\n` +\n        `Prop Name: ${propName}\\n` +\n        `Component: ${component.componentDefinition.name}, ID: ${component.componentDefinition.id}\\n\\n` +\n        `For more information, refer to the component page https://dashboard.myop.dev/dashboard/component/${component.componentDefinition.id} or consult the developer guide.`\n    );\n}\n\nexport const connectProps = <T extends componentDefinitionProps>(component: IMyopComponent, propsConfig: IPropConfig[], selectedSkin: ISkinConfig) => {\n\n    const propsMap = propsConfig.reduce((previousValue, currentValue) => {\n        return {\n            ...previousValue,\n            [currentValue.name]: {...currentValue}\n        }\n    }, {});\n\n    const propsHandler = {\n        get: (_: IMyopComponent, prop: string) => {\n            // @ts-ignore\n            const propConfig = propsMap[prop];\n\n            if (reportError(propConfig, prop, component)) {\n                return false;\n            }\n\n            if (propConfig.behavior.type === PropConfigBehaviorTypes.code) {\n                // Check for extracted web components FIRST\n                if (component instanceof MyopExtractedWebComponent) {\n                    const typedPropBehavior = propConfig.behavior as IPropCodeBehavior;\n                    const propName = typedPropBehavior.remap || prop;\n\n                    if (propName === 'myop_init_interface') {\n                        // Return a function that gets/sets data (matches iframe behavior)\n                        return (data?: unknown) => {\n                            if (data === undefined) {\n                                return component.getData();\n                            }\n                            component.initWithData(data);\n                        };\n                    }\n\n                    // For myop_cta_handler, return undefined (it's write-only)\n                    return undefined;\n                }\n\n                // Isolated iframe: no same-origin access \u2014 use the postMessage bridge\n                // (same method surface as the extracted-WC branch above).\n                if (component instanceof MyopIframeComponent && component.isolated) {\n                    const typedPropBehavior = propConfig.behavior as IPropCodeBehavior;\n                    const propName = typedPropBehavior.remap || prop;\n                    if (propName === 'myop_init_interface') {\n                        return (data?: unknown) => {\n                            if (data === undefined) return component.getData();\n                            component.initWithData(data);\n                        };\n                    }\n                    return undefined; // myop_cta_handler is write-only\n                }\n\n                // For iframe (localFrame) components\n                if (selectedSkin.loader.type === SkinLoaders.HTMLLoader) {\n                    const typedLoader = selectedSkin.loader as IHTMLLoaderConfig;\n                    if (typedLoader.shadowRootMode === ShadowRootModeType.localFrame) {\n                        const typedPropBehavior = propConfig.behavior as IPropCodeBehavior;\n                        // @ts-ignore\n                        return component.element.contentWindow[typedPropBehavior.remap || prop]\n                    }\n                }\n\n                reportUnsupported(propConfig, prop, component);\n                return false;\n            }\n\n            if (propConfig.mode === 'output') {\n                return new Promise((resolve) => {\n                    const messageParams: any[] = [];\n                    //TODO : turn it into config\n                    if (propConfig.behavior.ref) {\n                        messageParams.push(Ref.create(propConfig.behavior.ref));\n                    }\n\n                    messageParams.push((data: any) => {\n                        resolve(data);\n                    });\n\n                    if (propConfig.behavior.params) {\n                        messageParams.push(...propConfig.behavior.params);\n                    }\n\n                    // @ts-ignore\n                    const messageCtor = messages[propConfig.behavior.message];\n\n                    component.send(new messageCtor(...messageParams));\n                })\n            }\n            return null\n        },\n        set: (_: IMyopComponent, prop: string, value: any) => {\n            // @ts-ignore\n            const propConfig = propsMap[prop];\n\n            if (reportError(propConfig, prop, component)) {\n                return false;\n            }\n\n            if (propConfig.behavior.type === PropConfigBehaviorTypes.code) {\n                // Check for extracted web components FIRST (before localFrame check)\n                // because extracted web components may have shadowRootMode: localFrame in their config\n                // but they run directly on the host document, not in an iframe\n                if (component instanceof MyopExtractedWebComponent) {\n                    const typedPropBehavior = propConfig.behavior as IPropCodeBehavior;\n                    const propName = typedPropBehavior.remap || prop;\n\n                    if (propName === 'myop_cta_handler') {\n                        component.setCtaHandler(value);\n                        return true;\n                    }\n\n                    if (propName === 'myop_init_interface') {\n                        component.initWithData(value);\n                        return true;\n                    }\n                }\n\n                // Isolated iframe: route via the postMessage bridge (no same-origin access).\n                if (component instanceof MyopIframeComponent && component.isolated) {\n                    const typedPropBehavior = propConfig.behavior as IPropCodeBehavior;\n                    const propName = typedPropBehavior.remap || prop;\n                    if (propName === 'myop_cta_handler') { component.setCtaHandler(value); return true; }\n                    if (propName === 'myop_init_interface') { component.initWithData(value); return true; }\n                }\n\n                // For iframe (localFrame) components\n                if (selectedSkin.loader.type === SkinLoaders.HTMLLoader) {\n                    const typedLoader = selectedSkin.loader as IHTMLLoaderConfig;\n                    if (typedLoader.shadowRootMode === ShadowRootModeType.localFrame) {\n                        const typedPropBehavior = propConfig.behavior as IPropCodeBehavior;\n                        const contentWindow = (component.element as HTMLIFrameElement).contentWindow as any;\n                        const propName = typedPropBehavior.remap || prop;\n\n                        // Set the real handler\n                        contentWindow[propName] = value;\n\n                        // Flush CTA queue if this is myop_cta_handler and queue exists\n                        if (propName === 'myop_cta_handler' && contentWindow.__myop_cta_queue) {\n                            const queue = contentWindow.__myop_cta_queue;\n                            contentWindow.__myop_cta_queue = null; // Clear to prevent double-flush\n                            queue.forEach((item: {action: string, payload: any}) => {\n                                // Skip if component was disposed during flush\n                                if (component.markedForDisposed) return;\n                                value(item.action, item.payload);\n                            });\n                        }\n\n                        return true\n                    }\n                }\n\n                reportUnsupported(propConfig, prop, component);\n                return false;\n            } else {\n                //if(propConfig.behavior === PropConfigBehaviorTypes.message)\n                if (propConfig.mode === 'input') {\n                    //TODO : support multi behaviors\n\n                    if (propConfig.behavior.type === 'message') {\n                        const messageParams: any[] = [];\n                        //TODO : turn it into config\n                        if (propConfig.behavior.ref) {\n                            messageParams.push(Ref.create(propConfig.behavior.ref));\n                        }\n                        messageParams.push(value);\n                        if (propConfig.behavior.params) {\n                            messageParams.push(...propConfig.behavior.params);\n                        }\n\n                        // @ts-ignore\n                        const messageCtor = messages[propConfig.behavior.message];\n                        component.send(new messageCtor(...messageParams));\n                        return true\n                    } else {\n                        throw new Error(\n                            `Error: Unsupported Behavior\\n\\n` +\n                            `The 'behavior' field provided is not supported.\\n` +\n                            `Component: ${component.componentDefinition.name}, ID: ${component.componentDefinition.id}\\n\\n` +\n                            `Prop Name: ${prop}\\n` +\n                            `Behavior Field: ${propConfig.behavior.type}\\n\\n` +\n                            `Check the documentation for valid behavior options.`\n                        );\n\n                        return false\n                    }\n                }\n            }\n            return false\n        }\n    }\n\n    component.props = {};\n    component.props = new Proxy(component.props, propsHandler);\n\n    return component as (Omit<IMyopComponent, 'props'> & {\n        props: propTypes<T>\n    })\n}\n\nexport const createRefProxy = (target: Ref, component: IMyopComponent) => {\n    return new Proxy(target, {\n        get(target, prop) {\n\n            // if (prop === '__nonProxied') {\n            //     return target;\n            // }\n\n            // @ts-ignore\n            if (target[prop]) {\n                // @ts-ignore\n                return target[prop];\n            }\n\n            // @ts-ignore\n            const getterFunction = (...args) => {\n                return new Promise((resolve) => {\n                    args.forEach(arg => {\n                        if (!containsPrimitivesOnly(arg)) {\n                            Errors.notSerializableRefCall(prop, arg);\n                        }\n                    });\n                    component.send(new CustomRefMessage(({ref, propName, functionArgs, makeSerializable}) => {\n                            if (ref) {\n                                // @ts-ignore\n                                const value = ref[propName];\n                                if (typeof value === 'function') {\n                                    // @ts-ignore\n                                    return makeSerializable(ref[propName](...functionArgs), true) // Invoke the function and return its result\n                                } else {\n                                    // @ts-ignore\n                                    return makeSerializable(value, true); // Return the property value\n                                }\n                            }\n                            return null;\n                        },\n                        {\n                            //TODO : turn it to config\n                            elementId: target.refConfig.selector,\n                            propName: prop,\n                            functionArgs: args\n                        },\n                        (msg) => {\n                            resolve(msg.content);\n                        }))\n                });\n            };\n\n            //TODO: we can implement things like auto serialization and binding functions here\n            //getterFunction.test = '123';\n\n            return getterFunction;\n\n            //return Reflect.get(target, prop);\n        },\n        set(target, prop: string, value) {\n            component.send(new CustomRefMessage(({ref, propName, propValue}) => {\n                    if (ref)\n                        // @ts-ignore\n                        ref[propName] = propValue;\n                },\n                {\n                    //TODO : fix that\n                    elementId: target.refConfig.selector,\n                    propValue: value,\n                    propName: prop\n                },\n                (msg) => {\n                    //TODO : log?\n                }))\n            return true;\n        },\n    });\n}\n\nexport const createRefComponent = async <T extends IMyopComponent = IMyopComponent>(ref: Ref, componentConfig: IComponentConfig, components: IMyopComponent[], options?: loaderOptions): Promise<T> => {\n    const component = ref.component;\n    if (!component)\n        throw new Error('cant createRefComponent with detached ref');\n\n    //console.log('createRefComponent called', ref, componentConfig);\n\n    return new Promise(async (resolve, reject) => {\n        const refComponent = new MyopRefComponent(componentConfig.type, component, options);\n        components.push(refComponent);\n\n        //for cases where ref components define in the component config\n        // we need to wait for the root component the be initiated before interacting with it\n        await component.initiated();\n\n\n        //TODO :\n        const timeout = setTimeout(() => {\n            //reject('timeout?');\n            reject('timeout');\n        }, 5000);\n\n        component.send(new CreateRefComponentMessage(ref.refConfig,\n            componentConfig,\n            {\n                ...options ? options : {},\n                id: refComponent.id,\n                _hasParent: true\n            },\n            async (message) => {\n\n                //TODO : check if timeout already passed\n                clearTimeout(timeout);\n\n                if (message.failed) {\n                    //TODO :\n                    reject('CreateRefComponentMessage failed');\n                    return;\n                }\n\n                const implementationComponent = components.find(c => c.id == refComponent.id);\n\n                //same memory env, same HostSDK\n                if (implementationComponent !== refComponent) {\n                    //TODO : clean refComponent ?\n\n                    component.refs[ref.refConfig.name] = implementationComponent;\n                    resolve(implementationComponent as unknown as T);\n                    return;\n                } else {\n                    refComponent.setInitiated()\n                    component.refs[ref.refConfig.name] = refComponent;\n                }\n\n                //TODO : here >\n                //TODO : what about reapters ?! dynamic ?!\n                // const exsistingRefComponent = component.refs[ref.refConfig.name] as MyopRefComponent;\n                // if (exsistingRefComponent.id && exsistingRefComponent.parent) {\n                //     component.refs[ref.refConfig.name] = [component.refs[ref.refConfig.name], refComponent];\n                // } else if (Array.isArray(component.refs[ref.refConfig.name])) {\n                //     component.refs[ref.refConfig.name].push(refComponent)\n                // } else {\n                //   component.refs[ref.refConfig.name] = refComponent; //hostSDK.components.find(c => c.id === refComponent.id)!;\n                // }\n\n                //TODO : in webcomponent case the same id will alreday be here, which is good !\n                // name:\n                //     id\n                //     componentDefinitionId\n\n                // for inner components inside ref component :\n                message.nestedRefs.forEach(nestedRefConfig => {\n                    const nestedComponentDefinition = componentConfig.instance.resolvedNestedComponents!.find(c => c.type.id === nestedRefConfig.componentDefinitionId)!.type;\n                    //const nestedComponentDefinition = component.componentDefinition.resolvedDefinitions?.find(def => def.id === nestedRefConfig.componentDefinitionId)!;\n                    // const refConfig = componentConfig.type.refs.find(r => r.name === nestedRefConfig.refName);\n                    // if (!refConfig) {\n                    //     throw new Error('no refConfig found for nested ref');\n                    // }\n\n                    //debugger;\n\n                    const nestedComponent = new MyopRefComponent(nestedComponentDefinition, refComponent);\n                    nestedComponent.setInitiated();\n                    refComponent.refs[nestedRefConfig.refName] = nestedComponent;\n                    components.push(nestedComponent);\n                });\n\n\n                try {\n                    await connectRefs(refComponent, componentConfig, components, true);\n\n                    //TODO :use config check for auto-hight and convert type properly\n                    // @ts-ignore\n                    if (component.setHeightBasedOnScrollHeight)\n                        // @ts-ignore\n                        component.setHeightBasedOnScrollHeight();\n\n                    resolve(refComponent as unknown as T);\n                } catch (e) {\n                    //debugger\n                    reject(e);\n                    // throw e\n                }\n            }));\n    })\n}\n\nexport const connectRefs = async (component: IMyopComponent, componentConfig: IComponentConfig, components: IMyopComponent[], withoutRefComponents: boolean = false) => {\n\n    if (!component.refs)\n        component.refs = {};\n\n    const waitFor = Object.values(component.componentDefinition.refs).map(ref => {\n        return new Promise<void>(async (resolve, reject) => {\n            if (ref.behavior.type == RefBehaviorType.component) {\n                // component.refs[ref.name] =\n\n                if (withoutRefComponents) {\n                    resolve();\n                    return;\n                }\n\n                // component.\n                //TODO : change to get it from the flow\n                let refComponentId = (ref.behavior as IComponentRefBehavior).componentId;\n                if (!refComponentId)\n                    refComponentId = (ref.behavior as IComponentRefBehavior).instance.componentId\n\n                // if (!component.componentDefinition.resolvedDefinitions) {\n                //     reject(new Error('componentConfig provided without resolvedDefinitions check the config object'));\n                //     //throw new Error('componentConfig provided without resolvedDefinitions check the config object');\n                // }\n                // const componentDefinitionConfig = component.componentDefinition.resolvedDefinitions!.find(compdef => compdef.id === refComponentId)!;\n                // //const componentDefinitionConfig = await getComponentDefinitionConfig(componentInstanceConfig.componentId);\n                //\n                // if (!componentDefinitionConfig) {\n                //     reject(new Error('componentConfig provided without resolvedDefinitions check the config object'));\n                //     return;\n                // }\n\n                //TODO: if we have the same component more than once we will need instance id here ...\n                const nestedComponentConfig = componentConfig.instance.resolvedNestedComponents?.find(nestedComponent => nestedComponent.type.id === refComponentId);\n\n                if (!nestedComponentConfig) {\n                    throw new Error('componentConfig provided without nestedComponentConfig check the config object');\n                    return;\n                }\n\n                //const componentInstanceConfig = componentConfig.instance.nestedComponents?.find(componentInstace => componentInstace.componentId === componentDefinitionConfig.id);\n                // if(!componentDefinitionConfig){\n                //     throw new Error('TODO TODO TODO ');\n                //     return;\n                // }\n\n                //TODO :think about that :\n                //   componentDefinitionConfig.resolvedDefinitions = component.componentDefinition.resolvedDefinitions;\n                //   const nestedComponentConfig: IComponentConfig = {\n                //       instance: nestedComponentConfig.instance!,\n                //       type: nestedComponentConfig.type,\n                //       name: nestedComponentConfig.name\n                //   }\n\n                const _ref = Ref.create('', ref, component);\n\n                try {\n                    //console.log('nested !! createRefComponent called');\n                    const nestedComponent = await createRefComponent(_ref, nestedComponentConfig!, components)\n                    //TDOO : put that ref component somewhere?\n\n                    // debugger;\n                    component.refs[ref.name] = nestedComponent;\n\n                    resolve();\n                } catch (e) {\n                    reject(e);\n                }\n            } else {\n                try {\n                    const __nonProxied = Ref.create('', ref, component);\n                    component.refs[ref.name] = createRefProxy(__nonProxied, component);\n                    resolve();\n                } catch (e) {\n                    //alert('?')\n                }\n            }\n        })\n    })\n    try {\n        await Promise.all(waitFor);\n    } catch (e) {\n        //debugger\n        throw e;\n    }\n\n}\n\nexport type propTypes<T extends componentDefinitionProps> = {\n    [Property in keyof T]:\n    T[Property] extends { mode: 'input' } ?\n        T[Property]['type'] :\n        Promise<T[Property]['type']>\n}\n\nexport const exec = async (getter: any) => {\n    return await getter()\n}\n\nexport const actAs = <T>(ref: Ref) => {\n    return ref as unknown as FunctionifyRef<T>\n}\n\nexport type FunctionifyRef<T = any> = {\n    [K in keyof T]: T[K] extends (...args: infer A) => infer R // If it's a function\n        ? (...args: A) => Promise<R> // Convert it to a promised function\n        : T[K]\n};\n", "import {AutoSizeOptions, BaseMyopComponent} from \"./IMyopComponent\";\nimport {\n    BaseMyopMessage,\n    ExecuteComponentMethod,\n    ExecuteScriptMessage, MessageDirection, SetResizeObserverMessage\n} from \"../../messages\";\nimport {CleanupHandler, IComponentDefinitionConfig, ISkinConfig} from \"../../common\";\nimport {setDebugStyle} from \"../componentCore\";\nimport {MyopMessages} from \"../../common/MyopMessages.ts\";\nimport {loaderOptions} from \"../hostSDK.ts\";\n\nexport class MyopIframeComponent extends BaseMyopComponent {\n\n    private _autoSizeCleanup?: CleanupHandler;\n    private _autoSizeOptions?: AutoSizeOptions;\n    private _autoSizeUpdate?: () => void;\n\n    // \u2500\u2500 Isolation (sandboxed cross-origin frame) \u2014 postMessage bridge, host side \u2500\u2500\n    public isolated = false;\n    private _lastData?: unknown;               // cached last-sent data (sync getData)\n    private _ctaHandler?: (action: string, payload: unknown) => void;\n    private _ctaQueue: Array<{ action: string, payload: unknown }> = [];\n    private _isoMsgHandler?: (e: MessageEvent) => void;\n    private _isoSizeOpts?: AutoSizeOptions;\n    private _isoAutoSize = false;                               // bridge sizing only when auto-size is on\n    private _isoLastSize?: { height: number, width?: number };  // last reported size (for the enable race)\n\n    constructor(public componentConfig: IComponentDefinitionConfig, skin: ISkinConfig, public container: HTMLElement, private IframeElement: HTMLIFrameElement, options?: loaderOptions) {\n        super(componentConfig, container, options)\n\n        this.element = this.IframeElement;\n        this._lastData = options?.data;\n        // this.IframeElement.addEventListener('error', () => {\n        //     if (this._whenInitiatedReject)\n        //         this._whenInitiatedReject(`IframeElement error`);\n        // });\n    }\n\n    sizeMeta?: { width?: string | number; height?: string | number; minWidth?: number; maxWidth?: number; minHeight?: number; maxHeight?: number } | null;\n\n    // \u2500\u2500 Isolation bridge (host side) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    /** Attach the host-side postMessage listener for a sandboxed frame. */\n    enableIsolation() {\n        this.isolated = true;\n        // Isolated frames don't run the IframeSDK handshake (no same-origin init),\n        // so mark initiated immediately \u2014 like the extracted web component does.\n        this.setInitiated();\n        this._isoMsgHandler = (e: MessageEvent) => {\n            if (e.source !== this.IframeElement.contentWindow) return;\n            const d: any = e.data;\n            if (!d || d.__myop !== true) return;\n            if (d.type === 'myop:cta') {\n                if (this._ctaHandler && !this.markedForDisposed) this._ctaHandler(d.action, d.payload);\n                else if (!this._ctaHandler) this._ctaQueue.push({ action: d.action, payload: d.payload });\n            } else if (d.type === 'myop:size') {\n                this._applyIsoSize(d.height, d.width);\n            }\n        };\n        window.addEventListener('message', this._isoMsgHandler);\n    }\n\n    /** Data-in \u2014 unified with the extracted-WC API. Posts init over the bridge. */\n    initWithData(data: unknown): void {\n        this._lastData = data;\n        this.IframeElement?.contentWindow?.postMessage({ __myop: true, type: 'myop:init', data }, '*');\n    }\n\n    /** Data-in getter \u2014 returns the last data the host sent (cached, synchronous). */\n    getData(): unknown {\n        return this._lastData;\n    }\n\n    /** Data-out \u2014 unified with the extracted-WC API. Flushes CTAs queued pre-handler. */\n    setCtaHandler(handler: (action: string, payload: unknown) => void): void {\n        this._ctaHandler = handler;\n        if (this._ctaQueue.length > 0) {\n            const queue = [...this._ctaQueue];\n            this._ctaQueue = [];\n            queue.forEach(item => { if (!this.markedForDisposed) handler(item.action, item.payload); });\n        }\n    }\n\n    private _applyIsoSize(height: number, width?: number) {\n        if (!height || Number.isNaN(height)) return;\n        // Always remember the latest reported size so it can be applied if/when\n        // auto-sizing is enabled after the first message arrives.\n        this._isoLastSize = { height, width };\n        // Respect autoSize:false \u2014 the host owns dimensions, so don't touch them.\n        if (!this._isoAutoSize) return;\n        const opts = this._isoSizeOpts;\n        const toNum = (v: number | string | undefined): number | undefined =>\n            v === undefined ? undefined : (typeof v === 'number' ? v : (isNaN(parseFloat(v)) ? undefined : parseFloat(v)));\n        const min = toNum(opts?.minHeight), max = toNum(opts?.maxHeight);\n        let h = height;\n        if (min !== undefined && h < min) h = min;\n        if (max !== undefined && h > max) h = max;\n        // Transition from absolute overlay to document flow at the measured height.\n        this.IframeElement.style.position = 'relative';\n        this.IframeElement.style.inset = 'auto';\n        this.IframeElement.style.height = h + 'px';\n        this.IframeElement.style.width = '100%';\n        opts?.onSizeChange?.({ width: width ?? this.IframeElement.clientWidth, height: h, autoSizingWidth: false, autoSizingHeight: true } as any);\n    }\n\n    cleanupInspect?: CleanupHandler;\n\n    inspect() {\n        // TODO : use better check for inspect mode\n        if (this.cleanupInspect) {\n            //console.log('inspect call more than once');\n            return this.cleanupInspect\n        }\n        this.cleanupInspect = setDebugStyle(this.id, 'MyopIframeComponent', 10, this.container, this.IframeElement, this.componentDefinition);\n        return () => {\n            this.cleanupInspect!();\n            this.cleanupInspect = undefined;\n        };\n    }\n\n    hide() {\n        this.IframeElement.style.opacity = '0';\n        this.IframeElement.style.position = 'absolute'\n        this.IframeElement.style.pointerEvents = 'none'\n        this.IframeElement.style.visibility = 'hidden';\n    }\n\n    show() {\n        this.IframeElement.style.opacity = '1';\n        this.IframeElement.style.position = 'unset'\n        this.IframeElement.style.pointerEvents = 'all'\n        this.IframeElement.style.visibility = 'visible';\n    }\n\n    setHeightBasedOnDocumentElement = () => {\n        const cleanupHandler = this.send(new ExecuteScriptMessage(() => {\n            return window.document.documentElement.scrollHeight;\n        }, (ret) => {\n            this.IframeElement.style.height = `${ret.content}px`;\n            cleanupHandler();\n        }));\n    }\n\n    observeSizeBasedOnDocumentElement = () => {\n        const cleanupHandler = this.send(new ExecuteScriptMessage(({send}) => {\n            const {height, width} = document.documentElement.getBoundingClientRect();\n\n            const observer = new ResizeObserver(() => {\n                const {height, width} = document.documentElement.getBoundingClientRect();\n                send({height, width});\n            });\n            observer.observe(document.documentElement);\n            observer.observe(document.body);\n\n            return {height, width}\n        }, (ret) => {\n            this.IframeElement.style.width = `${ret.content.width}px`;\n            this.IframeElement.style.height = `${ret.content.height}px`;\n        }));\n\n        return cleanupHandler;\n    }\n\n    /**\n     * Observes the iframe content size and automatically syncs it to the iframe element.\n     * Uses direct contentDocument access (same-origin only) for accurate measurements.\n     *\n     * Reentrant: when called again while observers already exist, updates options and\n     * re-evaluates sizing without recreating observers. Cleanup + re-call (e.g. React\n     * re-render) creates fresh observers since cleanup clears the existing ones.\n     *\n     * @param options - Configuration options including size change callback and min/max constraints\n     * @returns Cleanup function to stop observing\n     */\n    observeAutoSize = (options?: AutoSizeOptions): CleanupHandler => {\n        // Store options so updateSize always reads the latest\n        this._autoSizeOptions = options;\n\n        // Isolated frames can't be measured cross-origin \u2014 sizing is driven by\n        // 'myop:size' postMessages from the bridge (see _applyIsoSize).\n        if (this.isolated) {\n            this._isoSizeOpts = options;\n            this._isoAutoSize = true;\n            // Apply the most recent bridge-reported size (it may have arrived before\n            // auto-sizing was turned on).\n            if (this._isoLastSize) this._applyIsoSize(this._isoLastSize.height, this._isoLastSize.width);\n            return () => { this._isoAutoSize = false; this._isoSizeOpts = undefined; };\n        }\n\n        // If observers already exist, re-evaluate with new options and reuse them\n        if (this._autoSizeCleanup && this._autoSizeUpdate) {\n            this._autoSizeUpdate();\n            return this._autoSizeCleanup;\n        }\n\n        const iframe = this.IframeElement;\n        const doc = iframe.contentDocument;\n\n        if (!doc) {\n            // Cross-origin (v1 components on the customer's domain): measure inside the frame.\n            return this.observeHeightViaBridge();\n        }\n\n        const clamp = (value: number, min?: number, max?: number): number => {\n            if (min !== undefined && value < min) return min;\n            if (max !== undefined && value > max) return max;\n            return value;\n        };\n\n        // Parse CSS size values to numbers\n        const parseSize = (value: string | number | undefined): number | undefined => {\n            if (value === undefined) return undefined;\n            if (typeof value === \"number\") return value;\n            const parsed = parseFloat(value);\n            return isNaN(parsed) ? undefined : parsed;\n        };\n\n        const updateSize = () => {\n            const contentDoc = iframe.contentDocument;\n            if (!contentDoc) return;\n\n            const opts = this._autoSizeOptions;\n\n            const minWidth = parseSize(opts?.minWidth);\n            const maxWidth = parseSize(opts?.maxWidth);\n            const minHeight = parseSize(opts?.minHeight);\n            const maxHeight = parseSize(opts?.maxHeight);\n            const loaderMinHeight = opts?.loaderMinHeight ?? 50;\n\n            // Resolve explicit dimensions: host options \u2192 sizeMeta fill mode \u2192 width defaults to \"100%\"\n            // Width defaults to \"100%\" (block element behavior) to prevent the shrink-to-0 measurement bug.\n            // Height has no default so it auto-sizes to content.\n            // Only sizeMeta \"100%\" (fill mode) is treated as explicit and disables auto-sizing.\n            // Pixel sizeMeta values (e.g., height: 200) are initial hints, NOT explicit constraints.\n            const sizeMetaFillWidth = this.sizeMeta?.width === \"100%\" ? \"100%\" : undefined;\n            const sizeMetaFillHeight = this.sizeMeta?.height === \"100%\" ? \"100%\" : undefined;\n            const resolvedExplicitWidth = opts?.explicitWidth ?? sizeMetaFillWidth ?? \"100%\";\n            const resolvedExplicitHeight = opts?.explicitHeight ?? sizeMetaFillHeight;\n            const hasExplicitWidth = resolvedExplicitWidth !== undefined;\n            const hasExplicitHeight = resolvedExplicitHeight !== undefined;\n\n            // Detect collapsed dimensions from container (this.container)\n            const containerRect = this.container.getBoundingClientRect();\n            const collapsedWidth = containerRect.width === 0;\n            // Consider collapsed if height is 0 OR equals the loader minHeight\n            const collapsedHeight = containerRect.height === 0 || containerRect.height === loaderMinHeight;\n\n            // Determine which dimensions to auto-size:\n            // - If forceAutoSize is true, auto-size unless explicit dimension is set\n            // - Otherwise, auto-size only if collapsed\n            const shouldAutoWidth = opts?.forceAutoSize\n                ? !hasExplicitWidth\n                : (collapsedWidth && !hasExplicitWidth);\n            const shouldAutoHeight = opts?.forceAutoSize\n                ? !hasExplicitHeight\n                : (collapsedHeight && !hasExplicitHeight);\n\n            // If nothing needs auto-sizing, apply explicit/percentage dimensions\n            if (!shouldAutoWidth && !shouldAutoHeight) {\n                iframe.style.width = typeof resolvedExplicitWidth === 'number' ? `${resolvedExplicitWidth}px` : '100%';\n                iframe.style.height = typeof resolvedExplicitHeight === 'number' ? `${resolvedExplicitHeight}px` : '100%';\n\n                opts?.onSizeChange?.({\n                    width: typeof resolvedExplicitWidth === 'number' ? resolvedExplicitWidth : undefined,\n                    height: typeof resolvedExplicitHeight === 'number' ? resolvedExplicitHeight : undefined,\n                    autoSizingWidth: false,\n                    autoSizingHeight: false,\n                });\n                return;\n            }\n\n            // Disable CSS transitions on iframe and container for the entire\n            // measurement + height-setting cycle. Host apps may set `transition: all`\n            // which would animate the 0px collapse and final height change, causing\n            // visible jumps during scroll.\n            const prevTransition = iframe.style.transition;\n            const container = this.container;\n            const prevContainerTransition = container.style.transition;\n            iframe.style.transition = 'none';\n            container.style.transition = 'none';\n\n            // Quick pre-check: read scrollHeight/Width BEFORE collapsing the iframe.\n            // If content only grew (scrollHeight > iframe height), we can skip the\n            // 0px collapse \u2014 scrollHeight naturally expands beyond the iframe.\n            const currentIframeHeight = iframe.getBoundingClientRect().height;\n            const currentIframeWidth = iframe.getBoundingClientRect().width;\n            const preScrollHeight = Math.ceil(Math.max(contentDoc.documentElement.scrollHeight, contentDoc.body.scrollHeight, contentDoc.body.getBoundingClientRect().height));\n            const preScrollWidth = Math.ceil(Math.max(contentDoc.documentElement.scrollWidth, contentDoc.body.scrollWidth, contentDoc.body.getBoundingClientRect().width));\n\n            let contentWidth = preScrollWidth;\n            let contentHeight = preScrollHeight;\n\n            const heightGrew = shouldAutoHeight && preScrollHeight > currentIframeHeight + 1;\n            const widthGrew = shouldAutoWidth && preScrollWidth > currentIframeWidth + 1;\n\n            // For non-grow cases (shrink or no-change), we must collapse to 0px to\n            // measure the true content height. scrollHeight can never decrease below\n            // the iframe's clientHeight, so shrink is undetectable without collapsing.\n            // With transitions disabled + container min-height held, the collapse\n            // is invisible (no layout shift, no animation).\n            const needsHeightCollapse = shouldAutoHeight && !heightGrew;\n            const needsWidthCollapse = shouldAutoWidth && !widthGrew;\n\n            if (needsHeightCollapse || needsWidthCollapse) {\n                // Hold the container's min-height/width during measurement to prevent\n                // layout shift (elements below the iframe won't jump).\n                const prevMinHeight = container.style.minHeight;\n                const prevMinWidth = container.style.minWidth;\n                if (needsHeightCollapse) container.style.minHeight = `${currentIframeHeight}px`;\n                if (needsWidthCollapse) container.style.minWidth = `${currentIframeWidth}px`;\n\n                if (needsHeightCollapse) iframe.style.height = '0px';\n                if (needsWidthCollapse) iframe.style.width = '0px';\n\n                contentWidth = Math.ceil(Math.max(contentDoc.documentElement.scrollWidth, contentDoc.body.scrollWidth, contentDoc.body.getBoundingClientRect().width));\n                contentHeight = Math.ceil(Math.max(contentDoc.documentElement.scrollHeight, contentDoc.body.scrollHeight, contentDoc.body.getBoundingClientRect().height));\n\n                // Fallback: if collapsing to 0px gave a near-zero measurement, the component\n                // likely has `height: 100%` chains (html > body > .app-container) that cascaded\n                // the collapse into all children. Retry with a nuclear override that forces all\n                // elements to intrinsic sizing. This is only a fallback because the override\n                // breaks explicit pixel heights (e.g. 8px indicator dots \u2192 0px).\n                const needsNuclearHeight = needsHeightCollapse && contentHeight < 2;\n                const needsNuclearWidth = needsWidthCollapse && contentWidth < 2;\n                if (needsNuclearHeight || needsNuclearWidth) {\n                    const measureStyle = contentDoc.createElement('style');\n                    measureStyle.id = '__myop_measure';\n                    const rules: string[] = [];\n                    if (needsNuclearHeight) {\n                        rules.push('height: auto !important', 'min-height: 0 !important', 'max-height: none !important');\n                    }\n                    if (needsNuclearWidth) {\n                        rules.push('width: auto !important', 'min-width: 0 !important', 'max-width: none !important');\n                    }\n                    measureStyle.textContent = `*, *::before, *::after { ${rules.join('; ')}; flex-basis: auto !important; flex-grow: 0 !important; }`;\n                    contentDoc.head.appendChild(measureStyle);\n\n                    contentWidth = Math.ceil(Math.max(contentDoc.documentElement.scrollWidth, contentDoc.body.scrollWidth, contentDoc.body.getBoundingClientRect().width));\n                    contentHeight = Math.ceil(Math.max(contentDoc.documentElement.scrollHeight, contentDoc.body.scrollHeight, contentDoc.body.getBoundingClientRect().height));\n\n                    measureStyle.remove();\n                }\n\n                // Restore container constraints immediately (same frame, before paint)\n                container.style.minHeight = prevMinHeight;\n                container.style.minWidth = prevMinWidth;\n            }\n\n            const width = clamp(contentWidth, minWidth, maxWidth);\n            const height = clamp(contentHeight, minHeight, maxHeight);\n\n            // Set auto-sized dimensions to measured values, non-auto to explicit/100%\n            if (shouldAutoWidth) {\n                iframe.style.width = `${width}px`;\n            } else {\n                iframe.style.width = typeof resolvedExplicitWidth === 'number' ? `${resolvedExplicitWidth}px` : '100%';\n            }\n            if (shouldAutoHeight) {\n                iframe.style.height = `${height}px`;\n            } else {\n                iframe.style.height = typeof resolvedExplicitHeight === 'number' ? `${resolvedExplicitHeight}px` : '100%';\n            }\n\n            // Force reflow so the final dimensions are applied without transition,\n            // then restore the original transitions.\n            // eslint-disable-next-line no-unused-expressions\n            iframe.offsetHeight;\n            iframe.style.transition = prevTransition;\n            container.style.transition = prevContainerTransition;\n\n            // Don't force overflow \u2014 let the component/parent control scrolling.\n            // Only set overflow: auto when content exceeds max constraints.\n            const isWidthConstrained = shouldAutoWidth && maxWidth !== undefined && contentWidth > maxWidth;\n            const isHeightConstrained = shouldAutoHeight && maxHeight !== undefined && contentHeight > maxHeight;\n            contentDoc.documentElement.style.overflowX = isWidthConstrained ? 'auto' : '';\n            contentDoc.documentElement.style.overflowY = isHeightConstrained ? 'auto' : '';\n\n            opts?.onSizeChange?.({\n                width,\n                height,\n                autoSizingWidth: shouldAutoWidth,\n                autoSizingHeight: shouldAutoHeight\n            });\n        };\n\n        // Initial size (run synchronously, not debounced)\n        updateSize();\n\n        // Store updateSize for reentrant calls\n        this._autoSizeUpdate = updateSize;\n\n        // Debounce observer callbacks via rAF \u2014 at most one updateSize per frame.\n        // Prevents layout thrashing from high-frequency mutations (e.g. CSS animations).\n        let rafId: number | undefined;\n        const scheduleUpdate = () => {\n            if (rafId !== undefined) return;\n            rafId = requestAnimationFrame(() => {\n                rafId = undefined;\n                updateSize();\n            });\n        };\n\n        // Observe for changes\n        const resizeObserver = new ResizeObserver(() => scheduleUpdate());\n        resizeObserver.observe(doc.body);\n        resizeObserver.observe(doc.documentElement);\n\n        // MutationObserver catches DOM content changes (e.g. removing list items, toggling views)\n        // that don't trigger ResizeObserver because the body box-size stays the same\n        // (body fills iframe, iframe hasn't shrunk yet).\n        // `attributes: true` catches CSS class/style changes (e.g. display:none toggling views).\n        const mutationObserver = new MutationObserver(() => scheduleUpdate());\n        mutationObserver.observe(doc.body, { childList: true, subtree: true, characterData: true, attributes: true });\n\n        const cleanup = () => {\n            resizeObserver.disconnect();\n            mutationObserver.disconnect();\n            if (rafId !== undefined) {\n                cancelAnimationFrame(rafId);\n                rafId = undefined;\n            }\n            this._autoSizeUpdate = undefined;\n            this._autoSizeCleanup = undefined;\n        };\n        this._autoSizeCleanup = cleanup;\n        return cleanup;\n    }\n\n    private _bridgeSizeCleanup?: CleanupHandler;\n\n    /**\n     * Auto-height for a frame the host can't read (cross-origin). Runs after the IframeSDK\n     * handshake: the frame reports body resizes and the host re-reads the scroll height.\n     */\n    observeHeightViaBridge = (): CleanupHandler => {\n        if (this._bridgeSizeCleanup) return this._bridgeSizeCleanup;\n\n        let observerCleanup: CleanupHandler | undefined;\n        let stopped = false;\n        const cleanup = () => {\n            stopped = true;\n            observerCleanup?.();\n            this._bridgeSizeCleanup = undefined;\n        };\n        this._bridgeSizeCleanup = cleanup;\n\n        this.initiated().then(() => {\n            if (stopped || this.markedForDisposed) return;\n            // Leave the absolute 100% overlay and take part in the container's layout.\n            this.IframeElement.style.position = 'relative';\n            this.IframeElement.style.inset = 'auto';\n            this.IframeElement.style.width = '100%';\n            this.setHeightBasedOnScrollHeight();\n            observerCleanup = this.send(new SetResizeObserverMessage());\n        }).catch(() => {\n        });\n\n        return cleanup;\n    }\n\n    setSizeBasedOnDocumentElement = () => {\n        const cleanupHandler = this.send(new ExecuteScriptMessage(() => {\n            const {height, width} = document.documentElement.getBoundingClientRect();\n            return {height, width}\n        }, (ret) => {\n            this.IframeElement.style.width = `${ret.content.width}px`;\n            this.IframeElement.style.height = `${ret.content.height}px`;\n            cleanupHandler();\n        }));\n    }\n\n    setHeightBasedOnScrollHeight = () => {\n        const cleanupHandler = this.send(new ExecuteScriptMessage(() => {\n            // @ts-ignore\n            // return window.document.body.scrollHeight + 'px';\n\n\n            //TODO: fix that hack, keep the function in right format while minified :(\n            const noOp = () => {\n                // No operation performed\n                return 0;\n            }\n            // To ensure it's not optimized away, you can call it at least once\n            let x = noOp();\n            x++;\n            x--;\n\n            //return `${window.document.body.offsetHeight}px`;\n\n            //TODO : check that +1 ?\n            return Math.max(Math.max(\n                    window.document.body.clientHeight,\n                    window.document.body.scrollHeight)\n                , window.document.body.offsetHeight) + x + 'px'\n\n        }, (ret) => {\n            this.IframeElement.style.height = ret.content;\n            cleanupHandler();\n        }));\n    }\n\n    send = (message: BaseMyopMessage): CleanupHandler => {\n        let message_ = {...message} as BaseMyopMessage;\n        //TODO : ?!?! should it be here ?\n        if (message_.messageType === MyopMessages.ExecuteComponentMethod) {\n            const typedMessage = (message_ as ExecuteComponentMethod)\n            this[typedMessage.method]();\n            return () => {\n            }\n        }\n\n        //TODO : fix that hack :(\n        // @ts-ignore\n        //const handler = message.handler\n\n        message_.direction = MessageDirection.down;\n        const cleanupHandler = super.send(message_);\n        this.IframeElement?.contentWindow?.postMessage(message_, '*');\n\n        // @ts-ignore\n        //message.handler = handler\n\n        return cleanupHandler;\n    };\n\n    onMessageReceived(incomeMessage: BaseMyopMessage): boolean {\n        if (incomeMessage.messageType === MyopMessages.In.MutationObserverMessage\n            || incomeMessage.messageType === MyopMessages.In.ResizeObserverMessage) {\n            this.setHeightBasedOnScrollHeight();\n            //debugger\n            //this.setHeightBasedOnDocumentElement();\n            return true;\n        }\n\n        return super.onMessageReceived(incomeMessage);\n    }\n\n    dispose = () => {\n        this._bridgeSizeCleanup?.();\n        if (this._autoSizeCleanup) {\n            this._autoSizeCleanup();\n            this._autoSizeCleanup = undefined;\n        }\n        if (this._isoMsgHandler) {\n            window.removeEventListener('message', this._isoMsgHandler);\n            this._isoMsgHandler = undefined;\n        }\n        if (this.cleanupInspect)\n            this.cleanupInspect();\n\n        super.dispose();\n        this.IframeElement.parentNode!.removeChild(this.IframeElement);\n    }\n}\n", "import {IMyopComponent} from \"../components/IMyopComponent\";\nimport {loaderOptions} from \"../hostSDK\";\nimport {IComponentDefinitionConfig, ISkinConfig, SkinLoaderType} from \"../../common\";\n\nexport interface IMyopLoader {\n    type: SkinLoaderType;\n    load: (componentDefinition: IComponentDefinitionConfig, skin: ISkinConfig, container: HTMLElement, options?: loaderOptions) => Promise<IMyopComponent>;\n}\n\nexport abstract class BaseMyopLoader implements IMyopLoader {\n    abstract type: SkinLoaderType;\n    abstract load: (componentDefinition: IComponentDefinitionConfig, skin: ISkinConfig, container: HTMLElement, options?: loaderOptions) => Promise<IMyopComponent>;\n\n    appendChild = (container: HTMLElement, element: HTMLElement, options?: loaderOptions,) => {\n        if (options?.relative) {\n            if (options.relative.direction === 'before') {\n                return container.insertBefore(element, options.relative.child);\n            }\n\n            if (options.relative.direction === 'after') {\n                const nextSibling = options.relative.child?.nextSibling;\n                return container.insertBefore(element, nextSibling ? nextSibling : null);\n            }\n        } else {\n            return container.appendChild(element);\n        }\n    }\n}\n", "import {MyopIframeComponent} from \"../components/myopIframeComponent\";\nimport {BaseMyopLoader} from \"./IMyopLoader\";\nimport {uuidv4} from \"../../utils/utils\";\nimport {loaderOptions} from \"../hostSDK\";\nimport {IComponentDefinitionConfig, IIframeLoaderConfig, ISkinConfig, SkinLoaders} from \"../../common\";\n\nconst addQueryParam = (url: string, param: string, value: string) => {\n    // Create a URL object\n    const urlObj = new URL(url);\n\n    // Add the query parameter\n    urlObj.searchParams.append(param, value);\n\n    // Return the updated URL\n    return urlObj.toString();\n}\n\nexport class MyopIframeLoader extends BaseMyopLoader {\n    type = SkinLoaders.IframeLoader\n\n    // @ts-ignore\n    load = async (componentDefinition: IComponentDefinitionConfig, skin: ISkinConfig, container: HTMLElement, options?: loaderOptions) => {\n        let IframeElement: HTMLIFrameElement;\n\n        const typedLoaderConfig = (skin.loader as IIframeLoaderConfig);\n\n        if (container?.nodeName === \"IFRAME\") {\n            console.log('needs to load into an exsisting Iframe...', typedLoaderConfig.url, container);\n\n            IframeElement = (container as HTMLIFrameElement)\n            IframeElement.src = typedLoaderConfig.url\n        } else {\n            const uniqId = uuidv4();\n            const domId = `myop-comp-${uniqId}`\n\n            IframeElement = document.createElement('iframe');\n            IframeElement.id = domId;\n\n            // Set all styles BEFORE appending to prevent flash at wrong position\n            const iframeStyles = `\n                padding: 0;\n                margin: 0;\n                position: absolute;\n                inset: 0;\n                height: ${typedLoaderConfig.autoHeight || !typedLoaderConfig.height ? '100%' : typedLoaderConfig.height};\n                width: 100%;\n                overflow: hidden;\n                border: none;\n                opacity: ${options?.hidden ? '0' : '1'};\n                pointer-events: ${options?.hidden ? 'none' : 'all'};\n            `;\n            IframeElement.style.cssText = iframeStyles;\n\n            // Set element attributes if provided\n            if (options?.elementAttributes) {\n                Object.entries(options.elementAttributes).forEach(([key, value]) => {\n                    if (value === '' || value === null || value === undefined) {\n                        IframeElement.setAttribute(key, '');\n                    } else {\n                        IframeElement.setAttribute(key, String(value));\n                    }\n                });\n            }\n\n            // in order to handle issue to load iframe inside an iframe with the same url\n            let url2load = (skin.loader as IIframeLoaderConfig).url;\n            if (options?._hasParent)\n                url2load = addQueryParam(url2load, \"_myop-comp\", uniqId);\n\n            IframeElement.src = url2load;\n\n            // TODO : do it only with flag ?\n            if (!container.querySelector('[id^=\"myop-comp-\"]'))\n                container.innerHTML = '';\n\n            IframeElement = this.appendChild(container, IframeElement, options) as HTMLIFrameElement;\n            //   IframeElement = document.getElementById(domId) as HTMLIFrameElement;\n            //NO : IframeElement = container.lastElementChild as HTMLIFrameElement;\n        }\n\n        const component = new MyopIframeComponent(componentDefinition, skin, container, IframeElement, options);\n\n        // `autoHeight` in the v1 config used to only set height:100% on an absolute frame, so in an\n        // unsized container the frame stayed at the 150px CSS default.\n        if (typedLoaderConfig.autoHeight && options?.autoSize !== false) {\n            component.observeHeightViaBridge();\n        }\n\n        return component;\n    }\n}\n", "export const myopWebcomponentConsts = {\n    webcomponent_message_key: 'myop_webcomponent_message'\n}\n", "import {myopWebcomponentConsts} from \"../../webcomponent/consts\";\nimport {BaseMyopComponent} from \"./IMyopComponent\";\nimport {BaseMyopMessage} from \"../../messages\";\nimport {CleanupHandler, IComponentDefinitionConfig, ISkinConfig} from \"../../common\";\nimport {setDebugStyle} from \"../componentCore\";\nimport {loaderOptions} from \"../hostSDK\";\n\nexport class MyopWebComponent extends BaseMyopComponent {\n\n    constructor(componentDefinition: IComponentDefinitionConfig, skin: ISkinConfig, public container: HTMLElement, private customElement: HTMLElement, options?: loaderOptions) {\n        super(componentDefinition, container , options);\n        this.element = customElement;\n    }\n\n    cleanupInspect: CleanupHandler = () => {\n    }\n\n    inspect() {\n        this.cleanupInspect = setDebugStyle(this.id, 'MyopWebComponent', 0, this.container, this.customElement, this.componentDefinition);\n        return this.cleanupInspect;\n    }\n\n    hide() {\n        this.customElement.style.opacity = '0';\n        this.customElement.style.position = 'absolute'\n        this.customElement.style.pointerEvents = 'none'\n        this.customElement.style.visibility = 'hidden';\n        this.customElement.style.height = '0'\n        this.customElement.style.width = '0'\n    }\n\n    show() {\n        this.customElement.style.opacity = '1';\n        this.customElement.style.position = 'unset'\n        this.customElement.style.pointerEvents = 'all'\n        this.customElement.style.visibility = 'visible';\n        this.customElement.style.height = '';\n        this.customElement.style.width = '';\n    }\n\n    send = (message: BaseMyopMessage<any>) => {\n        let message_ = {...message} as BaseMyopMessage;\n\n        //TODO : can be done without cloning?\n        // @ts-ignore\n        //const handler = message_.handler\n        const cleanupHandler = super.send(message_);\n\n        const msg = new CustomEvent<BaseMyopMessage>(myopWebcomponentConsts.webcomponent_message_key, {\n            // @ts-ignore\n            detail: message_,\n            // bubbles: true,\n            // cancelable: false,\n            // composed: true\n        })\n\n        //this.container.dispatchEvent(msg)\n\n        //sending data from host to the component\n        try {\n            this.customElement.dispatchEvent(msg)\n            // if (this.customElement.children.length > 0) {\n            // } else {\n            //     this.customElement.children[0].dispatchEvent(msg)\n            // }\n        } catch (e) {\n            console.log('error while trying to dispatchEvent', e);\n        }\n\n        // @ts-ignore\n        //message.handler = handler\n\n        return cleanupHandler;\n    }\n\n    dispose = () => {\n        super.dispose();\n        this.customElement.parentNode?.removeChild(this.customElement);\n    }\n}\n", "import {MyopWebComponent} from \"../components/myopWebcomponent\";\nimport {BaseMyopLoader} from \"./IMyopLoader\";\nimport {loaderOptions} from \"../hostSDK.ts\";\nimport {uuidv4, wait} from \"../../utils/utils.ts\";\nimport {IComponentDefinitionConfig, ISkinConfig, IWebComponentLoaderConfig, SkinLoaders} from \"../../common\";\n\nconst seen: Record<string, Promise<void>> = {};\n\nexport class WebcomponentLoader extends BaseMyopLoader {\n\n    type = SkinLoaders.WebComponentLoader\n\n    load = async (componentDefinition: IComponentDefinitionConfig, skin: ISkinConfig, container: HTMLElement, options?: loaderOptions) => {\n\n        const loaderConfig = (skin.loader as IWebComponentLoaderConfig);\n\n        if (!seen[loaderConfig.url]) {\n            // await import( /* @vite-ignore */ webComponentLoadUrl);\n            // console.log('module loaded');\n            seen[loaderConfig.url] = new Promise((resolve, reject) => {\n                const webComponentLoadUrl = loaderConfig.url\n                const script = document.createElement('script');\n                script.type = 'module';\n                script.src = webComponentLoadUrl;\n                script.onload = () => {\n                    resolve();\n                }\n\n                script.onerror = () => {\n                    reject();\n                }\n                document.head.appendChild(script);\n            })\n        } else {\n            console.log('Module alreday loaded or in loading process');\n        }\n\n        await seen[loaderConfig.url];\n\n        //TODO : add retry mechanism in fail case.\n\n        //TODO : fix that hack, should fix the race condition for loaded modules\n        await wait(1);\n\n        let domId = `myop-comp-${uuidv4()}`\n        const element = document.createElement(loaderConfig.tag);\n\n        // TODO : do it only with flag ?\n        if (!container.querySelector('[id^=\"myop-comp-\"]'))\n            container.innerHTML = '';\n\n        //element.style.visibility = 'hidden';\n        element.id = domId;\n\n        if (options?.hidden) {\n            element.style.opacity = '0';\n            element.style.position = 'absolute'\n            element.style.height = '0'\n            element.style.width = '0'\n            element.style.pointerEvents = 'none'\n            element.style.visibility = 'hidden';\n        }\n\n        // if (container.id.startsWith('myop-comp-')) {\n        //     // in place replacement\n        //     container.replaceWith(element);\n        //     //container = element.parentElement!;\n        // } else {\n        //     container.appendChild(element);\n        // }\n\n        if(options?._environment){\n            // @ts-ignore\n            element._myopEnvironment = options?._environment;\n        }\n\n        this.appendChild(container, element, options);\n        //element.innerHTML = `<${loaderConfig.tag} />`;\n        return new MyopWebComponent(componentDefinition, skin, container, element, options);\n    }\n\n}\n", "export default '0.4.0-beta.0';", "/**\n * The client window: what a returning visitor does NOT ask for.\n *\n * A component the browser already holds, still inside its freshness window, is rendered\n * with no network at all. Once the window ends the browser does not re-download it either\n * \u2014 it sends back the version it holds and is usually told \"unchanged\" in a few hundred\n * bytes.\n *\n * THE WINDOW IS THE SERVER'S, NOT OURS. It comes from the response: `s-maxage` is the\n * freshness the server promised, and `Age` is how much of it a CDN already spent before\n * the bytes reached us. The window we may keep is therefore `s-maxage - Age`, never\n * `s-maxage` \u2014 otherwise a copy that sat at the edge for 55 of its 60 seconds would be\n * held for another 60 here, and a publish would take twice as long to be seen as promised.\n * This is the single easiest thing to get wrong in a client cache, and it is invisible in\n * testing because it only shows up as \"sometimes stale\".\n *\n * IndexedDB, not localStorage: components run to hundreds of KB, localStorage caps around\n * 5 MB and blocks the main thread. Every path degrades to the network \u2014 a browser in\n * private mode, with storage disabled or over quota, must render the page, not fail it.\n */\n\nconst DB_NAME = 'myop-delivery';\nconst STORE = 'components';\nconst DB_VERSION = 1;\n\nexport interface StoredEntry {\n    key: string;\n    /** the resolved component config, exactly as the network path produces it */\n    config: any;\n    /** the server's version token for these bytes: `<rev>~<opt>` */\n    tag: string | null;\n    /** when this browser stored it */\n    storedAt: number;\n    /** how long it may be used without asking, in ms (already Age-adjusted) */\n    windowMs: number;\n    /** which host produced it \u2014 a key from another host is never reused */\n    host: string;\n    /** wire size of the response it came from, so stats can say what the window saved */\n    bytes?: number;\n}\n\nlet dbPromise: Promise<IDBDatabase | null> | null = null;\n\nfunction openDb(): Promise<IDBDatabase | null> {\n    if (dbPromise) return dbPromise;\n    dbPromise = new Promise((resolve) => {\n        try {\n            if (typeof indexedDB === 'undefined') return resolve(null);\n            const req = indexedDB.open(DB_NAME, DB_VERSION);\n            req.onupgradeneeded = () => {\n                const db = req.result;\n                if (!db.objectStoreNames.contains(STORE)) db.createObjectStore(STORE, { keyPath: 'key' });\n            };\n            req.onsuccess = () => resolve(req.result);\n            req.onerror = () => resolve(null);\n            // A blocked upgrade must not hang the page load.\n            req.onblocked = () => resolve(null);\n        } catch {\n            resolve(null);\n        }\n    });\n    return dbPromise;\n}\n\nfunction tx<T>(mode: IDBTransactionMode, fn: (store: IDBObjectStore) => IDBRequest): Promise<T | null> {\n    return openDb().then(db => new Promise<T | null>((resolve) => {\n        if (!db) return resolve(null);\n        try {\n            const t = db.transaction(STORE, mode);\n            const req = fn(t.objectStore(STORE));\n            req.onsuccess = () => resolve(req.result as T);\n            req.onerror = () => resolve(null);\n            t.onabort = () => resolve(null);\n        } catch {\n            resolve(null);\n        }\n    }));\n}\n\n/**\n * A SYNCHRONOUS shadow of what we hold, for code that runs before IndexedDB can answer.\n *\n * The page's HTML can start the component request while the JS bundle is still downloading\n * \u2014 but only if it knows, at parse time, whether a request is needed at all and which one.\n * IndexedDB is async, so an inline script cannot ask it. localStorage can be read\n * synchronously, so each entry mirrors two tiny facts here: the version tag and when the\n * window ends. Nothing else \u2014 the component itself stays in IndexedDB where it belongs.\n *\n * Without this the preload hint is actively harmful: it downloads the whole component\n * every time, including on the visits where the stored copy was going to answer for free.\n * Measured on myop.dev before it existed \u2014 98 KB fetched, then discarded, on every reload.\n */\nconst HINT_PREFIX = 'myop.d.';\n\nfunction writeHint(key: string, tag: string | null, expiresAt: number) {\n    try { localStorage.setItem(HINT_PREFIX + key, JSON.stringify({ t: tag, e: expiresAt })); }\n    catch { /* private mode, quota, disabled \u2014 the hint is an optimisation, never a requirement */ }\n}\n\nfunction clearHint(key: string) {\n    try { localStorage.removeItem(HINT_PREFIX + key); } catch { /* as above */ }\n}\n\n/** A memory layer in front of storage: a second component on the same page must not wait on IO. */\nconst memory = new Map<string, StoredEntry>();\n\nexport const deliveryStore = {\n    key(host: string, componentId: string, env: string, preview: boolean, opt: string) {\n        // The HOST is part of the key. Two stacks can serve the same component with\n        // different freshness, and entries from one must never be read as the other's.\n        return `${host}|${componentId}|${env}|${preview ? 'preview' : 'live'}|${opt || 'raw'}`;\n    },\n\n    async get(key: string): Promise<StoredEntry | null> {\n        const m = memory.get(key);\n        if (m) return m;\n        const e = await tx<StoredEntry>('readonly', s => s.get(key));\n        if (e) {\n            memory.set(key, e);\n            // SELF-HEAL. The two stores can disagree: an entry written before the hint\n            // existed, a browser that evicted localStorage but not IndexedDB, a user who\n            // cleared one. A missing hint makes the preload fall back to the FULL component\n            // while the SDK, which can see IndexedDB, only wants the version check -- two\n            // requests where there should be one. Seen in the wild on the first load after\n            // the hint shipped. Rewriting it here costs nothing and closes the gap for good.\n            writeHint(key, e.tag, e.storedAt + e.windowMs);\n        }\n        return e;\n    },\n\n    async put(entry: StoredEntry): Promise<void> {\n        memory.set(entry.key, entry);\n        writeHint(entry.key, entry.tag, entry.storedAt + entry.windowMs);\n        await tx('readwrite', s => s.put(entry));\n    },\n\n    async drop(key: string): Promise<void> {\n        memory.delete(key);\n        clearHint(key);\n        await tx('readwrite', s => s.delete(key));\n    },\n\n    /** Still usable without asking the server? */\n    fresh(e: StoredEntry | null): boolean {\n        return !!e && (Date.now() - e.storedAt) < e.windowMs;\n    },\n\n    /**\n     * The window this response licenses: the server's freshness minus what a CDN already\n     * spent. Returns 0 when the server said nothing about caching, which means \"do not\n     * hold this\" \u2014 the safe reading, and what production sends today.\n     */\n    windowFrom(headers: Headers): number {\n        const cc = headers.get('cache-control') || '';\n        if (/no-store|no-cache/i.test(cc)) return 0;\n        const m = /s-maxage\\s*=\\s*(\\d+)/i.exec(cc) || /max-age\\s*=\\s*(\\d+)/i.exec(cc);\n        if (!m) return 0;\n        const total = Number(m[1]);\n        const age = Number(headers.get('age') || 0);\n        return Math.max(0, (total - (isNaN(age) ? 0 : age))) * 1000;\n    },\n\n    /** For tests and for `refresh()`: forget everything this browser holds. */\n    async clear(): Promise<void> {\n        memory.clear();\n        try {\n            for (let i = localStorage.length - 1; i >= 0; i--) {\n                const k = localStorage.key(i);\n                if (k && k.startsWith(HINT_PREFIX)) localStorage.removeItem(k);\n            }\n        } catch { /* nothing to clean up if it was never writable */ }\n        await tx('readwrite', s => s.clear());\n    },\n};\n", "import {\n    IComponentConfig,\n    IComponentDefinitionConfig,\n    IComponentInstanceConfig,\n    IDedicatedSkinConfig,\n    IPropConfig,\n    ISkinConfig,\n    IUserFlow,\n    PropConfigBehaviorTypes,\n    v2_IVariantConfig\n} from \"../common\";\nimport { deliveryStore } from \"./deliveryStore\";\n\nconst convertV2VariantToComponentConfig = (config: v2_IVariantConfig): IComponentConfig => {\n    return {\n        instance: {\n            id: 'auto',\n            componentId: config.componentId,\n            componentName: config.name,\n\n            skinSelector: {\n                type: 'Dedicated',\n                skin: {\n                    id: 'skin_auto_v2_converted'\n                }\n            } as IDedicatedSkinConfig\n\n        } as IComponentInstanceConfig,\n        type: {\n            id: config.id,\n            name: config.name,\n            description: config.description,\n            props: [\n                {\n                    id: 'in_auto_v2_converted',\n                    name: 'myop_init_interface',\n                    type: 'any',\n                    behavior: {\n                        type: PropConfigBehaviorTypes.code\n                    }\n                } as IPropConfig,\n\n                {\n                    id: 'out_auto_v2_converted',\n                    name: 'myop_cta_handler',\n                    type: 'any',\n                    behavior: {\n                        type: PropConfigBehaviorTypes.code\n                    }\n                } as IPropConfig\n            ],\n            refs: [],\n            skins: [\n                {\n                    id: 'skin_auto_v2_converted',\n                    name: 'auto_v2_converted',\n                    description: '',\n                    //TODO : handle empty :\n                    // @ts-ignore\n                    loader: config.consume_variant[0].loader\n                } as ISkinConfig\n            ],\n            defaultSkin: 0\n        } as IComponentDefinitionConfig,\n        name: config.name\n    } as IComponentConfig;\n};\n\n/**\n * CloudRepository - Unified cloud data access layer for Myop components\n *\n * Supports both v2 (default) and v1 modes:\n * - v2: Uses /consume endpoint for fetching variants\n * - v1: Uses /flow endpoint for fetching user flows\n */\n// Use a global singleton to ensure only one CloudRepository.Main exists\n// even when the module is loaded multiple times by different bundlers\nconst GLOBAL_KEY = '__MYOP_CLOUD_REPOSITORY_MAIN__';\n\nconst getGlobalMain = (): CloudRepository | undefined => {\n    if (typeof window !== 'undefined') {\n        return (window as any)[GLOBAL_KEY];\n    }\n    if (typeof globalThis !== 'undefined') {\n        return (globalThis as any)[GLOBAL_KEY];\n    }\n    return undefined;\n};\n\nconst setGlobalMain = (instance: CloudRepository) => {\n    if (typeof window !== 'undefined') {\n        (window as any)[GLOBAL_KEY] = instance;\n    }\n    if (typeof globalThis !== 'undefined') {\n        (globalThis as any)[GLOBAL_KEY] = instance;\n    }\n};\n\nexport class CloudRepository {\n    private static _main: CloudRepository | null = null;\n\n    static get Main(): CloudRepository {\n        // Check if a global instance already exists (from another bundle)\n        const globalMain = getGlobalMain();\n        if (globalMain) {\n            return globalMain;\n        }\n\n        // Create new instance if needed\n        if (!CloudRepository._main) {\n            CloudRepository._main = new CloudRepository();\n            setGlobalMain(CloudRepository._main);\n        }\n        return CloudRepository._main;\n    }\n\n    // v2 cache - keyed by componentId:env:preview|live\n    // Each Promise is tagged with a `resolved` property after settling (see fetchComponentV2).\n    private variants: Record<string, Promise<IComponentConfig> & { resolved?: IComponentConfig }> = {};\n\n    // Track which components were preloaded and with what params\n    // Key: componentId, Value: { env, preview }\n    private preloadedComponents: Record<string, { env: string; preview: boolean }> = {};\n\n    // v1 cache\n    private userFlows: Record<string, Promise<IUserFlow>> = {};\n\n    private _defaultEnv = 'production';\n    private _envExplicitlySet = false;\n    private _staticMode = false;\n    private _queryParams: Record<string, string> = {};\n\n    constructor(private _baseUrl = 'https://cloud.myop.dev') {\n    }\n\n    /**\n     * How big the component we are NOT re-downloading is. Deliberately measured from what\n     * we hold rather than from Content-Length: once a response is compressed the header is\n     * not readable cross-origin, so reading it there reported 0 every single time.\n     */\n    private static sizeOfHeld(e: any): number {\n        try { return (e?.config?.type?.skins?.[0]?.loader?.HTML || '').length; } catch { return 0; }\n    }\n\n    /** The host every request goes to unless delivery() moved it. Never changes. */\n    private static readonly DEFAULT_HOST = 'https://cloud.myop.dev';\n\n    /**\n     * Opt-in delivery settings, set by myop.delivery(). Off means: this file behaves\n     * EXACTLY as it did before \u2014 same host, same URL, same everything.\n     */\n    private _delivery: { minify: boolean; host: string | null; cache: boolean } =\n        { minify: false, host: null, cache: false };\n\n    /**\n     * What actually happened, for myop.delivery.stats(). `fellBack` is the number that\n     * matters: it is how you find out the lane is unhealthy without waiting for a\n     * bug report, because a fallback is INVISIBLE to the page (it still renders).\n     */\n    private _deliveryStats = {\n        requests: 0, viaDelivery: 0, fellBack: 0, lastError: null as string | null,\n        /** where the last loads were answered from \u2014 the number the client window exists to move */\n        fromMemory: 0, fromStorage: 0, fromNetwork: 0,\n        /** re-checks after the window ended, and how many were answered \"nothing changed\" */\n        revalidations: 0, unchanged: 0, bytesSaved: 0,\n    };\n\n    /**\n     * Turn on the opt-in delivery path.\n     *\n     * Opting in IS choosing the delivery stack: this points /consume at `host` (a second,\n     * complete stack reading the same data) and asks for the minified artifact. Leave this\n     * uncalled and nothing about the SDK changes.\n     *\n     * Deliberately mutates THIS instance rather than constructing a new repository:\n     * CloudRepository.Main is a global singleton shared across bundles (see getGlobalMain),\n     * so a second instance would be ignored by every component already using the first.\n     */\n    setDelivery(opts: { minify?: boolean; host?: string | null; cache?: boolean } = {}) {\n        if (opts.minify !== undefined) this._delivery.minify = !!opts.minify;\n        if (opts.host !== undefined) this._delivery.host = opts.host;\n        if (opts.cache !== undefined) this._delivery.cache = !!opts.cache;\n    }\n\n    deliveryStats() {\n        return { ...this._deliveryStats, host: this._delivery.host ?? CloudRepository.DEFAULT_HOST,\n                 minify: this._delivery.minify, cache: this._delivery.cache };\n    }\n\n    /**\n     * Forget what this browser holds, so the next load asks the server.\n     * `refresh()` with no ids drops everything; the counterpart to the window for the case\n     * where a change has to be visible on THIS load \u2014 right after someone publishes.\n     */\n    async refreshDelivery(): Promise<void> {\n        await deliveryStore.clear();\n    }\n\n    /**\n     * Local serves waiting to be reported: componentId -> {env, count}.\n     *\n     * THE MEASUREMENT PROBLEM THIS SOLVES. The better this cache works, the more usage\n     * vanishes: a visitor inside their freshness window renders the page with no request,\n     * so neither the server nor the CDN can see them. Left alone, a successful rollout\n     * looks in the ledger exactly like customers leaving.\n     *\n     * So local serves are counted here and reported afterwards, batched, on a path that\n     * never blocks rendering: flushed when the page is hidden (keepalive, so it survives\n     * the tab closing) and opportunistically whenever the SDK is talking to the server\n     * anyway. Nothing is sent while the page is loading, which is the point of the window.\n     */\n    private _localServes = new Map<string, {env: string; count: number}>();\n    private _flushBound = false;\n\n    private noteLocalServe(componentId: string, env: string) {\n        const cur = this._localServes.get(componentId);\n        if (cur) cur.count++;\n        else this._localServes.set(componentId, {env, count: 1});\n        this.bindFlush();\n    }\n\n    /** Report on page-hide, which is the only event that reliably fires on mobile. */\n    private bindFlush() {\n        if (this._flushBound || typeof document === 'undefined') return;\n        this._flushBound = true;\n        const onHide = () => { if (document.visibilityState === 'hidden') this.flushLocalServes(); };\n        document.addEventListener('visibilitychange', onHide);\n        window.addEventListener('pagehide', () => this.flushLocalServes());\n    }\n\n    /**\n     * Send what we have. `keepalive` is what makes this work at page-hide: the request\n     * outlives the document. Failure is ignored \u2014 a lost usage report must never be\n     * visible to a visitor, and the next page load will report its own.\n     */\n    flushLocalServes(): void {\n        if (!this._localServes.size) return;\n        const batch = [...this._localServes.entries()]\n            .map(([id, v]) => `${id}:${v.env}:${v.count}`).join(',');\n        this._localServes.clear();\n        try {\n            const url = `${this.deliveryHost()}/clientUsage?b=${encodeURIComponent(batch)}`;\n            fetch(url, {keepalive: true, mode: 'cors', credentials: 'omit'}).catch(() => {});\n        } catch { /* never the visitor's problem */ }\n    }\n\n    /** Where /consume should be fetched from right now. */\n    private deliveryHost(): string {\n        return this._delivery.host || this._baseUrl;\n    }\n\n    /**\n     * Fetch a delivery URL with ONE fallback to the default host.\n     *\n     * The fallback is the kill switch: break or disable the lane and every client drifts\n     * back to cloud.myop.dev on its own, with no customer deploy. It must therefore be\n     * genuinely silent to the page and genuinely LOUD in stats() \u2014 a fallback that nobody\n     * counts is an outage nobody notices.\n     *\n     * Only transport failures and 5xx fall back. A 404 is an answer: the component really\n     * is missing, and retrying elsewhere would only hide it.\n     */\n    private async deliveryFetch(path: string): Promise<Response> {\n        // We are about to use the network anyway: a good moment to hand over whatever the\n        // window served offline, rather than waiting for the page to be closed.\n        if (this._localServes.size) this.flushLocalServes();\n        const host = this.deliveryHost();\n        const primary = `${host}${path}`;\n        this._deliveryStats.requests++;\n        const usingLane = host !== this._baseUrl;\n        try {\n            const res = await fetch(primary);\n            if (res.ok || res.status < 500 || !usingLane) {\n                if (usingLane && res.ok) this._deliveryStats.viaDelivery++;\n                return res;\n            }\n            this._deliveryStats.lastError = `HTTP ${res.status} from ${host}`;\n        } catch (e: any) {\n            if (!usingLane) throw e;\n            this._deliveryStats.lastError = String(e?.message ?? e);\n        }\n        this._deliveryStats.fellBack++;\n        console.warn(`[myop] delivery host failed (${this._deliveryStats.lastError}) \u2014 falling back to ${this._baseUrl}`);\n        return await fetch(`${this._baseUrl}${path}`);\n    }\n\n    /**\n     * Enable static mode for self-hosted component registries.\n     * In static mode, URLs are constructed as file paths instead of query params:\n     *   ${baseUrl}/components/${componentId}/${env}.json\n     */\n    enableStaticMode() {\n        this._staticMode = true;\n    }\n\n    /**\n     * Set query parameters to append to all fetch URLs (e.g. for CDN cache busting).\n     * Example: `setQueryParams({ lastupdate: '11112026' })`\n     */\n    setQueryParams(params: Record<string, string>) {\n        this._queryParams = params;\n    }\n\n    /**\n     * Set the default environment for this CloudRepository instance\n     */\n    setEnvironment(env: string) {\n        this._defaultEnv = env;\n        this._envExplicitlySet = true;\n    }\n\n    /**\n     * Get the current default environment\n     */\n    getDefaultEnvironment(): string {\n        return this._defaultEnv;\n    }\n\n    // ============ V2 Methods (Default) ============\n\n    /**\n     * Check if a component is already cached/preloaded (v2)\n     * If env and preview are not provided, checks if ANY version is preloaded\n     */\n    isPreloaded(componentId: string, env?: string, preview?: boolean): boolean {\n        // If specific env/preview requested, check exact match\n        if (env !== undefined || preview !== undefined) {\n            const cacheKey = `${componentId}:${env || this._defaultEnv}:${preview ? 'preview' : 'live'}`;\n            return cacheKey in this.variants;\n        }\n        // Otherwise check if any version was preloaded\n        return componentId in this.preloadedComponents;\n    }\n\n    /**\n     * Get the preloaded params for a component (if preloaded)\n     * Returns undefined if not preloaded\n     */\n    getPreloadedParams(componentId: string): { env: string; preview: boolean } | undefined {\n        return this.preloadedComponents[componentId];\n    }\n\n    /**\n     * Resolve a component config: fetch it once, then serve it from this\n     * repository's cache.\n     *\n     * This is the name to use. `fetchComponentV2` is the same method under its\n     * versioned name and stays for backward compatibility \u2014 note that the\n     * unversioned `fetchComponent` is a *deprecated v1* API and is NOT this.\n     *\n     * Completes the trio with {@link getResolvedConfig} (synchronous read of an\n     * already-resolved config) and {@link hydrateComponent} (seed one you\n     * already hold).\n     *\n     * Prefer the module-level `preloadComponents([id])` in app code; reach for\n     * this when you need an isolated repository instance whose cache lifetime\n     * you control \u2014 a server with its own TTL, for example.\n     */\n    async resolveComponent(componentId: string, env?: string, preview?: boolean): Promise<IComponentConfig> {\n        return this.fetchComponentV2(componentId, env, preview);\n    }\n\n    /**\n     * Fetch a v2 component config\n     * If env/preview not specified and component was preloaded, uses preloaded params\n     *\n     * @see resolveComponent \u2014 the unversioned name for this method\n     */\n    async fetchComponentV2(componentId: string, environmentIdentifier?: string, preview?: boolean): Promise<IComponentConfig> {\n        const { env, usePreview, cacheKey } = this.resolveParams(componentId, environmentIdentifier, preview);\n\n        console.log('[CloudRepository] fetchComponentV2', {\n            componentId: componentId.slice(0, 8) + '...',\n            env,\n            usePreview,\n            cacheKey,\n            cached: cacheKey in this.variants\n        });\n\n        if (!this.variants[cacheKey]) {\n            // Track this as preloaded (first fetch counts as preload)\n            if (!this.preloadedComponents[componentId]) {\n                this.preloadedComponents[componentId] = { env, preview: usePreview };\n            }\n\n            // eslint-disable-next-line no-async-promise-executor\n            this.variants[cacheKey] = new Promise(\n                async (resolve, reject) => {\n                    try {\n                        let url: string;\n                        if (this._staticMode) {\n                            const file = usePreview ? 'preview' : env;\n                            url = `${this._baseUrl}/components/${componentId}/${file}.json`;\n                            const qs = new URLSearchParams(this._queryParams).toString();\n                            if (qs) url += `?${qs}`;\n                        } else {\n                            url = `/consume?id=${componentId}&env=${env}`;\n                            if (usePreview) {\n                                url += '&preview=true';\n                            }\n                            // A preview is never minified: the artifact is built from the\n                            // released variant, and an author must see their own edit.\n                            if (this._delivery.minify && !usePreview) {\n                                url += '&opt=min';\n                            }\n                        }\n\n                        // ---- the client window -------------------------------------\n                        // A preview is never held: an author has to see their own edit.\n                        const cacheable = this._delivery.cache && !this._staticMode && !usePreview;\n                        const storeKey = cacheable ? deliveryStore.key(\n                            this.deliveryHost(), componentId, env,\n                            usePreview, this._delivery.minify ? 'min' : 'raw') : '';\n                        let held = cacheable ? await deliveryStore.get(storeKey) : null;\n\n                        if (held && deliveryStore.fresh(held)) {\n                            // Inside the window: no request at all. Counted locally and\n                            // reported later, or this visit is invisible to the ledger.\n                            this._deliveryStats.fromStorage++;\n                            this.noteLocalServe(componentId, env);\n                            (this.variants[cacheKey] as any).resolved = held.config;\n                            resolve(held.config);\n                            return;\n                        }\n\n                        if (held && held.tag) {\n                            // The window ended. Send back the version we hold rather than\n                            // re-downloading: the answer is usually a few hundred bytes.\n                            //\n                            // Deliberately the `ids=`/`have=` route and NOT If-None-Match:\n                            // a request header triggers a CORS preflight, there is no OPTIONS\n                            // route, and it fails in a browser while working perfectly in curl.\n                            // The validator travels in the query string, so it is a plain GET.\n                            const checkUrl = `/consume?ids=${componentId}&env=${env}` +\n                                (this._delivery.minify ? '&opt=min' : '') +\n                                `&have=${encodeURIComponent(held.tag)}`;\n                            this._deliveryStats.revalidations++;\n                            try {\n                                const check = await this.deliveryFetch(checkUrl);\n                                if (check.ok) {\n                                    const body = await check.json();\n                                    if ((body.unchanged || []).includes(componentId)) {\n                                        this._deliveryStats.unchanged++;\n                                        this._deliveryStats.bytesSaved += CloudRepository.sizeOfHeld(held);\n                                        held.storedAt = Date.now();\n                                        held.windowMs = deliveryStore.windowFrom(check.headers) || held.windowMs;\n                                        await deliveryStore.put(held);\n                                        (this.variants[cacheKey] as any).resolved = held.config;\n                                        resolve(held.config);\n                                        return;\n                                    }\n                                    // It changed. The answer already carries the new bytes.\n                                    const item = (body.items || [])[0];\n                                    if (item) {\n                                        const cfg = convertV2VariantToComponentConfig(item);\n                                        this._deliveryStats.fromNetwork++;\n                                        await deliveryStore.put({\n                                            key: storeKey, config: cfg, tag: item.tag || null,\n                                            storedAt: Date.now(),\n                                            windowMs: deliveryStore.windowFrom(check.headers),\n                                            host: this.deliveryHost(),\n                                        } as any);\n                                        (this.variants[cacheKey] as any).resolved = cfg;\n                                        resolve(cfg);\n                                        return;\n                                    }\n                                }\n                            } catch {\n                                // A failed re-check must not fail the page: fall through to\n                                // the ordinary fetch below.\n                            }\n                        }\n\n                        const res = this._staticMode\n                            ? await fetch(url)\n                            : await this.deliveryFetch(url);\n                        if (!res.ok) {\n                            reject(new Error(`Failed to load component \"${componentId}\" (${res.status}${this._staticMode ? ` from ${url}` : ''})`));\n                            return;\n                        }\n                        const json = await res.json();\n                        const variant = json.item;\n\n                        if (!variant) {\n                            reject(new Error(`Component \"${componentId}\" not found`));\n                            return;\n                        }\n\n                        if (!variant.consume_variant || !variant.consume_variant.length) {\n                            reject(new Error(`Component \"${componentId}\" has no implementation for environment \"${env}\"`));\n                            return;\n                        }\n\n                        const componentConfig = convertV2VariantToComponentConfig(variant);\n                        this._deliveryStats.fromNetwork++;\n                        if (cacheable) {\n                            // Hold it for exactly as long as the server said, minus what a\n                            // CDN already spent (deliveryStore.windowFrom).\n                            await deliveryStore.put({\n                                key: storeKey, config: componentConfig,\n                                tag: (variant as any).tag || null,\n                                storedAt: Date.now(),\n                                windowMs: deliveryStore.windowFrom(res.headers),\n                                host: this.deliveryHost(),\n                            } as any);\n                        }\n                        // Tag the Promise so getResolvedConfig can read it synchronously\n                        (this.variants[cacheKey] as any).resolved = componentConfig;\n                        resolve(componentConfig);\n                    } catch (e) {\n                        // Clear the cached rejected promise so the next call\n                        // makes a fresh request (e.g. after network recovery)\n                        delete this.variants[cacheKey];\n                        reject(e);\n                    }\n                }\n            );\n        }\n\n        return await this.variants[cacheKey];\n    }\n\n    /**\n     * Synchronous version of fetchComponentV2 \u2014 returns the config only if\n     * the fetch already completed, null otherwise.\n     *\n     * Uses the same `this.variants` cache that fetchComponentV2/preloadComponents\n     * populate. Each cached Promise is tagged with a `.resolved` property when\n     * it settles \u2014 this method just reads that property. No separate cache.\n     *\n     * Why this exists: React Native needs the config at render time to embed it\n     * in the WebView HTML (can't await in useState). If preloadComponents ran\n     * earlier and the fetch completed, this returns the result synchronously,\n     * skipping the WEBVIEW_READY \u2192 fetch \u2192 inject round trip entirely.\n     */\n    getResolvedConfig(componentId: string, env?: string, preview?: boolean): IComponentConfig | null {\n        const { cacheKey } = this.resolveParams(componentId, env, preview);\n        return this.variants[cacheKey]?.resolved || null;\n    }\n\n    /**\n     * Resolve which (env, preview) pair \u2014 and therefore which cache key \u2014 a call\n     * for `componentId` refers to.\n     *\n     * Single source of truth for fetchComponentV2, getResolvedConfig and\n     * hydrateComponent, so a hydrated config always lands on the key a later\n     * fetch will look under.\n     */\n    private resolveParams(componentId: string, environmentIdentifier?: string, preview?: boolean) {\n        // If no explicit env/preview and component was preloaded, use preloaded params\n        const preloaded = this.preloadedComponents[componentId];\n        const hasExplicitParams = environmentIdentifier !== undefined || preview !== undefined;\n\n        let env: string;\n        let usePreview: boolean;\n\n        if (!hasExplicitParams && preloaded) {\n            // Use preloaded params\n            env = preloaded.env;\n            usePreview = preloaded.preview;\n        } else {\n            // Use provided params or defaults\n            env = environmentIdentifier || this._defaultEnv;\n            // If preview explicitly true \u2192 true\n            // If preview explicitly false \u2192 false\n            // If preview undefined: env was specified (via param or setEnvironment) \u2192 false, otherwise \u2192 true\n            const hasEffectiveEnv = environmentIdentifier || this._envExplicitlySet;\n            usePreview = preview === true ? true : (preview === false ? false : !hasEffectiveEnv);\n        }\n\n        return { env, usePreview, cacheKey: `${componentId}:${env}:${usePreview ? 'preview' : 'live'}` };\n    }\n\n    /**\n     * Seed an already-resolved component config into the cache, without any\n     * network request.\n     *\n     * The counterpart to {@link fetchComponentV2}: use it when the config was\n     * resolved somewhere else \u2014 most often on a server, then embedded in the\n     * page \u2014 so the browser can render the component with no round trip.\n     *\n     * After hydrating, `fetchComponentV2`, `getResolvedConfig` and `isPreloaded`\n     * all answer for this component from memory.\n     *\n     * Pass the same `env` / `preview` the config was resolved with; the defaults\n     * match what a plain `fetchComponentV2(componentId)` would have used.\n     */\n    hydrateComponent(componentId: string, config: IComponentConfig, env?: string, preview?: boolean): void {\n        const { env: resolvedEnv, usePreview, cacheKey } = this.resolveParams(componentId, env, preview);\n\n        const promise = Promise.resolve(config) as Promise<IComponentConfig> & { resolved?: IComponentConfig };\n        // Tag it the same way fetchComponentV2 does, so getResolvedConfig can\n        // read it synchronously.\n        promise.resolved = config;\n\n        this.variants[cacheKey] = promise;\n        this.preloadedComponents[componentId] = { env: resolvedEnv, preview: usePreview };\n    }\n\n    // ============ V1 Methods (Legacy) ============\n\n    /**\n     * Fetch a v1 component from a flow\n     */\n    async fetchComponentV1(componentId: string, flowId?: string) {\n        if (flowId) {\n            const flow = await this.fetchFlow(flowId);\n            return flow.components.find(c => c.type.id === componentId);\n        } else {\n            const flow = await this.fetchAutoFlow(componentId);\n            return flow.components[0];\n        }\n    }\n\n    async fetchAutoFlow(componentId: string) {\n        if (!this.userFlows[componentId]) {\n            // eslint-disable-next-line no-async-promise-executor\n            this.userFlows[componentId] = new Promise(\n                async (resolve, reject) => {\n                    try {\n                        const res = await fetch(\n                            `${this._baseUrl}/flow?id=${componentId}&auto=true`\n                        );\n                        const json = await res.json();\n                        resolve(json.item);\n                    } catch (e) {\n                        delete this.userFlows[componentId];\n                        reject(e);\n                    }\n                }\n            );\n        }\n\n        return await this.userFlows[componentId];\n    }\n\n    async fetchFlow(flowId: string) {\n        if (!this.userFlows[flowId]) {\n            // eslint-disable-next-line no-async-promise-executor\n            this.userFlows[flowId] = new Promise(\n                async (resolve, reject) => {\n                    try {\n                        const res = await fetch(\n                            `${this._baseUrl}/flow?id=${flowId}&resolve=components`\n                        );\n                        const json = await res.json();\n                        resolve(json.item);\n                    } catch (e) {\n                        delete this.userFlows[flowId];\n                        reject(e);\n                    }\n                }\n            );\n        }\n\n        return await this.userFlows[flowId];\n    }\n\n    // ============ Backward Compatibility ============\n\n    /**\n     * @deprecated Use fetchComponentV2 or fetchComponentV1 explicitly\n     * Defaults to v1 behavior for backward compatibility with existing code\n     */\n    async fetchComponent(componentId: string, flowId?: string) {\n        return this.fetchComponentV1(componentId, flowId);\n    }\n}\n\n/**\n * @deprecated Use CloudRepository instead\n */\nexport const v2_CloudRepository = CloudRepository;\n", "import { CloudRepository } from \"./CloudRepository\";\nimport { IComponentConfig } from \"../common\";\n\nlet _cloudRepository = CloudRepository.Main;\n\nexport const getCloudRepository = () => _cloudRepository;\n\nexport const isPreloaded = (componentId: string, env?: string, preview?: boolean): boolean => {\n    return _cloudRepository.isPreloaded(componentId, env, preview);\n};\n\nexport const getPreloadedParams = (componentId: string) => {\n    return _cloudRepository.getPreloadedParams(componentId);\n};\n\nexport const enableLocalDev = () => {\n    _cloudRepository = new CloudRepository(\"http://localhost:9292\");\n};\n\nexport const setCloudRepositoryUrl = (url: string) => {\n    _cloudRepository = new CloudRepository(url);\n};\n\n/**\n * Configure the SDK to fetch components from a self-hosted static registry (S3, CDN, etc.)\n * instead of the Myop cloud. Components are served as static JSON files:\n *   `${cdnUrl}/components/${componentId}/${environment}.json`\n */\nexport const enableSelfHosted = (cdnUrl: string, queryParams?: Record<string, string>) => {\n    _cloudRepository = new CloudRepository(cdnUrl);\n    _cloudRepository.enableStaticMode();\n    if (queryParams) {\n        _cloudRepository.setQueryParams(queryParams);\n    }\n};\n\n/**\n * THE OPT-IN. One call, and nothing changes for anyone who does not make it.\n *\n *   myop.delivery({ minify: true });\n *\n * Opting in IS choosing the delivery lane: a second, complete Myop stack (its own server\n * and CDN) reading the same component data. So this call does two things at once \u2014 it\n * points `/consume` at that stack and asks it for the minified artifact \u2014 which is why\n * turning the feature off is a config value on our side or one line on yours, and never\n * a DNS change.\n *\n * Safety properties, all deliberate:\n *   - If the lane fails (transport error or 5xx), the SDK retries ONCE against\n *     cloud.myop.dev and the page renders anyway. `delivery.stats().fellBack` counts it.\n *   - `cache: true` adds the client window: a component this browser already holds, still\n *     inside the freshness the server promised, is rendered with NO request. Once the\n *     window ends the browser sends back the version it holds instead of re-downloading.\n *   - A preview is never minified and never cached.\n *   - Only /consume moves. Everything else keeps the host it has today.\n *   - Asking for `minify` does not force it: the server decides per component, and a\n *     component that is not enabled is served raw, which is not an error.\n *\n * `host` is for us (a staging lane, a local server); leave it out.\n */\nexport const DELIVERY_HOST = 'https://delivery.myop.dev';\n\nexport const delivery = (opts: { minify?: boolean; cache?: boolean; host?: string | null } = {}) => {\n    const wantsLane = opts.minify !== false || opts.cache === true;\n    _cloudRepository.setDelivery({\n        minify: opts.minify ?? false,\n        cache: opts.cache ?? false,\n        host: opts.host !== undefined ? opts.host : (wantsLane ? DELIVERY_HOST : null),\n    });\n    return deliveryStats();\n};\n\n/**\n * Forget what this browser holds, so the next load asks the server. Use it when a change\n * has to be visible on THIS load \u2014 right after someone publishes \u2014 rather than within the\n * freshness window.\n */\nexport const deliveryRefresh = async () => {\n    await _cloudRepository.refreshDelivery();\n    return deliveryStats();\n};\n\n/**\n * What answered the last requests, and \u2014 the number worth watching \u2014 how many times the\n * SDK had to fall back to the default host because the lane did not answer.\n */\nexport const deliveryStats = () => _cloudRepository.deliveryStats();\n\n/** Undo delivery(): back to the default host and raw bytes, with no reload. */\nexport const deliveryOff = () => {\n    _cloudRepository.setDelivery({ minify: false, cache: false, host: null });\n    return deliveryStats();\n};\n\nexport const setCloudRepository = (repository: CloudRepository) => {\n    _cloudRepository = repository;\n};\n\nexport const setEnvironment = (env: string) => {\n    _cloudRepository.setEnvironment(env);\n};\n\nexport const getResolvedConfig = (componentId: string, env?: string, preview?: boolean) => {\n    return _cloudRepository.getResolvedConfig(componentId, env, preview);\n};\n\nexport const preloadComponents = async (ids: string[], env?: string, preview?: boolean) => {\n    return Promise.allSettled(\n        ids.map((id) => _cloudRepository.fetchComponentV2(id, env, preview)),\n    );\n};\n\n/**\n * Seed already-resolved component configs into the SDK cache, with no network\n * request. The counterpart to {@link preloadComponents}.\n *\n * Use it when the configs were resolved somewhere else \u2014 typically on a server\n * and embedded in the page \u2014 so the component renders with zero round trips:\n *\n * ```ts\n * // server: const configs = { [id]: await new CloudRepository().fetchComponentV2(id) }\n * // client:\n * hydrateComponents(configs);\n * // <MyopComponent componentId={id} /> now renders without fetching\n * ```\n *\n * Pass the same `env` / `preview` the configs were resolved with; the defaults\n * match what a plain `preloadComponents([id])` would have used.\n */\nexport const hydrateComponents = (\n    configs: Record<string, IComponentConfig>,\n    env?: string,\n    preview?: boolean,\n) => {\n    for (const [id, config] of Object.entries(configs)) {\n        _cloudRepository.hydrateComponent(id, config, env, preview);\n    }\n};\n", "import {BaseContextMessageHandler, HostedComponent} from \"../../common\";\nimport {ShadowRootRef} from \"../shadowRootRef\";\nimport {BaseMyopMessage, MyopBindMessage} from \"../../messages\";\n\nexport type MessageToHost = (message: BaseMyopMessage) => void\n\nexport abstract class BaseWebComponentMessageHandler<T extends BaseMyopMessage = any> extends BaseContextMessageHandler<T, Record<string, HostedComponent<ShadowRootRef>>> {\n\n    abstract messageType: string\n\n    constructor(messageToHost: any, public context: Record<string, HostedComponent<ShadowRootRef>>) {\n        super(messageToHost);\n    }\n\n    abstract innerExecutor: (event: T, shadowRootRef: ShadowRootRef, messageToHost: MessageToHost) => void;\n\n    executor = (event: T) => {\n        //debugger;\n        if (event.destination) {\n            const destination = event.destination;\n            if (this.context[destination].context) {\n\n                // patch the source id, think about that ?\n                const _messageToHost = (message: BaseMyopMessage, replayTo?: MyopBindMessage) => {\n                    this.messageToHost({\n                        ...message,\n                        source: event.destination ? event.destination : event.source,\n                        destination: event.source ? event.source : event.destination\n                    } as BaseMyopMessage, replayTo)\n                }\n\n                return this.innerExecutor(event, this.context[destination].context, _messageToHost);\n            } else {\n                debugger;\n            }\n        } else {\n            debugger;\n        }\n    }\n}\n", "export const myopAttributes = {\n    id: 'myop-id'\n}\n", "import {myopAttributes} from \"../../consts.ts\";\nimport {Ref} from \"../../messages\";\n\nexport const getElementsByRef = (ref: Ref, el: ParentNode) => {\n    return el.querySelectorAll(`[${myopAttributes.id}='${ref.refConfig.selector}']`);\n}\n\nexport const getFirstElementByRef = (ref: Ref, el: ParentNode) => {\n    const elements = getElementsByRef(ref, el);\n    if (elements.length) {\n        return elements.item(0);\n    }\n    return null;\n}", "import {MyopMessages} from \"../../common/MyopMessages\";\nimport {BindClickMessage, ClickReplayMessage, MyopBindMessage} from \"../../messages\";\nimport {ShadowRootRef} from \"../shadowRootRef\";\nimport {BaseWebComponentMessageHandler, MessageToHost} from \"./BaseWebComponentMessageHandler\";\nimport {getElementsByRef} from \"../../common/messageHandlers/helpers\";\n\nexport class BindOnClickHandler extends BaseWebComponentMessageHandler<BindClickMessage> {\n\n    messageType = MyopMessages.BindClickMessage;\n\n    innerExecutor = (event: BindClickMessage, shadowRootRef: ShadowRootRef, messageToHost: MessageToHost) => {\n        const items = getElementsByRef(event.ref, shadowRootRef.shadowRoot)\n        const cleanupTasks: any[] = [];\n\n        items.forEach(item => {\n            const handler = () => {\n                messageToHost(new ClickReplayMessage(event.handlerUniqueId));\n            };\n\n            item.addEventListener('click', handler);\n            cleanupTasks.push(() => {\n                item.removeEventListener('click', handler);\n            })\n        })\n\n        return () => {\n            cleanupTasks.forEach(task => task());\n        }\n    }\n}\n", "import {MyopMessages} from \"../../common/MyopMessages\";\nimport {ShadowRootRef} from \"../shadowRootRef\";\nimport {BaseWebComponentMessageHandler} from \"./BaseWebComponentMessageHandler\";\nimport {MyopElementMessage} from \"../../messages\";\nimport {getElementsByRef} from \"../../common/messageHandlers/helpers\";\n\nexport class ChangeTextHandler extends BaseWebComponentMessageHandler<MyopElementMessage> {\n\n    messageType = MyopMessages.ChangeTextMessage;\n\n    innerExecutor = (event: MyopElementMessage, shadowRootRef: ShadowRootRef) => {\n        const items = getElementsByRef(event.ref, shadowRootRef.shadowRoot);\n        items.forEach(item => {\n            item.textContent = event.content;\n        })\n    }\n}\n", "import {RootRef} from \"../common\";\n\nexport class ShadowRootRef extends RootRef {\n    constructor(public container: HTMLElement, public shadowRoot: ShadowRoot) {\n        super(container, shadowRoot);\n    }\n}\n", "import {MyopElementRef} from \"../../common\";\nimport {myopAttributes} from \"../../consts\";\nimport {BaseWebComponentMessageHandler} from \"./BaseWebComponentMessageHandler\";\nimport {ShadowRootRef} from \"../shadowRootRef\";\nimport {DetectedMyopRefsMessage, DetectMyopRefsMessage} from \"../../messages\";\nimport {MyopMessages} from \"../../common/MyopMessages\";\n\nexport class DetectMyopRefsMessageHandler extends BaseWebComponentMessageHandler<DetectMyopRefsMessage> {\n    innerExecutor = (event: DetectMyopRefsMessage, shadowRootRef: ShadowRootRef) => {\n\n        //debugger;\n        const allMyopItems = shadowRootRef.shadowRoot.querySelectorAll(`[${myopAttributes.id}]`);\n\n        let myopRefs: MyopElementRef[] = [];\n\n        allMyopItems.forEach(item => {\n\n            // TODO : take that back to the dashboard?\n            //console.log(item, item.getBoundingClientRect());\n\n            const myopId = item.getAttribute(myopAttributes.id);\n\n            if (myopId) {\n                //console.log('wc rect',  item.parentElement.getBoundingClientRect(), item.getBoundingClientRect())\n                // @ts-ignore\n                myopRefs.push(new MyopElementRef(myopId, item.tagName, item.getBoundingClientRect(), item.offsetTop, item.offsetLeft))\n            }\n        })\n\n        this.messageToHost(new DetectedMyopRefsMessage(event.handlerUniqueId, myopRefs))\n    };\n\n    messageType = MyopMessages.DetectMyopRefsMessage;\n\n\n}\n", "import {MyopMessages} from \"../../common/MyopMessages\";\nimport {SetAttributeMessage} from \"../../messages\";\nimport {BaseWebComponentMessageHandler} from \"./BaseWebComponentMessageHandler.ts\";\nimport {ShadowRootRef} from \"../shadowRootRef.ts\";\nimport {getElementsByRef} from \"../../common/messageHandlers/helpers\";\n\nexport class setAttributeHandler extends BaseWebComponentMessageHandler<SetAttributeMessage> {\n\n    messageType = MyopMessages.SetAttributeMessage;\n\n    innerExecutor = (event: SetAttributeMessage, shadowRootRef: ShadowRootRef) => {\n        const items = getElementsByRef(event.ref, shadowRootRef.shadowRoot);\n        items.forEach(item => {\n            item.setAttribute(event.name, event.value)\n        })\n    }\n}\n", "import {MyopMessages} from \"../../common/MyopMessages\";\nimport {\n    AddEventListenerMessage,\n    EventListenerCallbackMessage,\n} from \"../../messages\";\nimport {BaseWebComponentMessageHandler, MessageToHost} from \"./BaseWebComponentMessageHandler.ts\";\nimport {ShadowRootRef} from \"../shadowRootRef.ts\";\nimport {getElementsByRef} from \"../../common/messageHandlers/helpers\";\nimport {makeSerializable} from \"../../common/utils/serialization.ts\";\n\nexport class AddEventListenerHandler extends BaseWebComponentMessageHandler<AddEventListenerMessage> {\n\n    messageType = MyopMessages.AddEventListenerMessage;\n\n    innerExecutor = (event: AddEventListenerMessage, shadowRootRef: ShadowRootRef, messageToHost: MessageToHost) => {\n\n        const items = getElementsByRef(event.ref, shadowRootRef.shadowRoot);\n        const cleanupTasks: (() => void)[] = [];\n\n        items.forEach(item => {\n            const handler = (e) => {\n                // in fact when running in WebComponent we can transfer the original e\n                // currently using makeSerializable for nested cases, think about that\n                messageToHost(new EventListenerCallbackMessage(event.handlerUniqueId,  makeSerializable(e, event.serializableSkeleton)));\n            };\n\n            item.addEventListener(event.type, handler);\n\n            cleanupTasks.push(() => {\n                item.removeEventListener(event.type, handler);\n            })\n        });\n\n        return () => {\n            cleanupTasks.forEach(task => task())\n        }\n    }\n}\n", "import {MyopMessages} from \"../../common/MyopMessages\";\nimport {myopAttributes} from \"../../consts\";\nimport {HostSDK} from \"../../host/hostSDK\";\nimport {CreateRefComponentMessage, RefComponentCreatedMessage} from \"../../messages/CreateRefComponentMessage\";\nimport {BaseWebComponentMessageHandler, MessageToHost} from \"./BaseWebComponentMessageHandler\";\nimport {ShadowRootRef} from \"../shadowRootRef\";\nimport {IMyopComponent} from \"../../host\";\n\nexport class CreateRefComponentMessageHandler extends BaseWebComponentMessageHandler<CreateRefComponentMessage> {\n\n    messageType = MyopMessages.CreateRefComponentMessage;\n\n    innerExecutor = (event: CreateRefComponentMessage, shadowRootRef: ShadowRootRef, messageToHost: MessageToHost) => {\n\n        const createRef = async () => {\n            //const allItems = shadowRootRef.shadowRoot.querySelectorAll<HTMLElement>(`[${myopAttributes.id}='${event.ref?.refConfig.selector}']`);\n            const allItems = shadowRootRef.shadowRoot.querySelectorAll<HTMLElement>(`[${myopAttributes.id}='${event.refConfig.selector}']`);\n\n            if (allItems.length === 1) {\n                const hostSDK = HostSDK.Instance();\n\n                const refComponent = hostSDK.components.find(c => c.id === event.options.id)!;\n                if (refComponent) {\n                    ////>>>>\n                    refComponent.dispose();\n                } else {\n                  //  console.log(`failed to find ${event.options.id} in mem scope`, hostSDK);\n                }\n                //we have the ref component in our HostSDK (same memory when using webcomponent)\n                //  refComponent.parent = implementationComponent;\n                //delete the ref component\n                const index = hostSDK.components.indexOf(refComponent);\n                if (index !== -1) {\n                    hostSDK.components.splice(index, 1);\n                    //console.log('createRefComponent called removed temp ref component');\n                } else {\n                    //console.log('createRefComponent called using temp ref component');\n                }\n\n                const implementationComponent = await hostSDK.loadComponent(event.nestedComponentConfig,\n                    allItems.item(0),\n                    event.options)\n\n                //TODO : no need this, pass options from parent\n                //implementationComponent.id = event.predefinedId;\n                //refComponent.id += '.';\n\n                //TODO : not really needed ?\n                // await implementationComponent.initiated();\n\n                const nestedRefConfig: any[] = [];\n\n                Object.keys(implementationComponent.refs).forEach(refName => {\n                    let ref = implementationComponent.refs[refName];\n                    ref = ref.__nonProxied || ref;\n\n                    if ((ref as IMyopComponent).componentDefinition) {\n                        nestedRefConfig.push({\n                            refName,\n                            componentDefinitionId: (ref as IMyopComponent).componentDefinition.id,\n                        });\n                    }\n                })\n\n                messageToHost(new RefComponentCreatedMessage(event.handlerUniqueId, nestedRefConfig));\n            } else {\n                console.error('CreateRefComponentMessageHandler - DOM element not found')\n                this.messageToHost(new RefComponentCreatedMessage(event.handlerUniqueId, [], true));\n\n                debugger;\n            }\n        }\n\n        createRef().then()\n        //returning undefined so it won't act as a cleanup\n    }\n}\n", "import {ExecuteScriptMessage} from \"../../messages\";\nimport {RootRef} from \"../../common\";\nimport {makeSerializable} from \"../utils/serialization.ts\";\n\nexport const ExecuteScriptHandlerExecutor = (event: ExecuteScriptMessage, replier: (data: any) => void, rootRef: RootRef) => {\n    const __scriptInputs = event.scriptInputs ? event.scriptInputs : {}\n    __scriptInputs.makeSerializable = makeSerializable;\n\n    __scriptInputs.send = replier;\n    __scriptInputs.rootRef = rootRef;\n    __scriptInputs.__scriptInputs = __scriptInputs;\n\n    const dynamicFunction = new Function(`return (${event.script})(...arguments)`);\n    const ret = dynamicFunction(__scriptInputs);\n\n    // const dynamicFunction = Function('send', 'rootRef','__scriptInputs', ...Object.keys(__scriptInputs), event.content ? event.content : '')\n    //const ret = dynamicFunction(replier, rootRef, __scriptInputs, ...Object.values(__scriptInputs));\n    replier(ret);\n}\n", "import {MyopMessages} from \"../../common/MyopMessages\";\nimport {ExecuteScriptMessage, ExecuteScriptReplyMessage} from \"../../messages\";\nimport {BaseWebComponentMessageHandler, MessageToHost} from \"./BaseWebComponentMessageHandler.ts\";\nimport {ShadowRootRef} from \"../shadowRootRef.ts\";\nimport {ExecuteScriptHandlerExecutor} from \"../../common/messageHandlers/executeScriptHandler.ts\";\n\nexport class ExecuteScriptHandler extends BaseWebComponentMessageHandler<ExecuteScriptMessage> {\n    messageType = MyopMessages.ExecuteScriptMessage\n\n    innerExecutor = (event: ExecuteScriptMessage, shadowRootRef: ShadowRootRef, messageToHost: MessageToHost) => {\n        const replier = (data: any) => {\n            messageToHost(new ExecuteScriptReplyMessage(event.handlerUniqueId, data));\n        };\n\n        ExecuteScriptHandlerExecutor(event, replier, shadowRootRef);\n    }\n}\n", "import {MyopMessages} from \"../../common/MyopMessages\";\nimport {ElementValueReplayMessage, FormDataEntry, GetElementValueMessage, InputElementValue,} from \"../../messages\";\nimport {BaseWebComponentMessageHandler, MessageToHost} from \"./BaseWebComponentMessageHandler.ts\";\nimport {ShadowRootRef} from \"../shadowRootRef.ts\";\nimport {getElementsByRef} from \"../../common/messageHandlers/helpers\";\nimport {myopAttributes} from \"../../consts.ts\";\nimport {makeSerializable} from \"../../common/utils/serialization.ts\";\n\nconst getInputValue = (element): InputElementValue => {\n    if (!element) return null;\n\n    // Check if it's a form\n    if (element.tagName === 'FORM') {\n        const formData = new FormData(element);\n        const dataObject: InputElementValue = {\n            formData: {},\n            unmappedData: []\n        };\n\n        // Manually add elements without names\n        const elements = element.querySelectorAll('input, select, textarea');\n        let autoNameIndexer = -1;\n\n        elements.forEach(element => {\n            if (typeof element.value === 'string') {\n                const myopId = element.getAttribute(myopAttributes.id);\n                let key = element.getAttribute('name');\n\n                // `_${(++autoNameIndexer)}`\n\n                const nodeData: FormDataEntry = {\n                    id: element.id,\n                    name: key,\n                    value: getInputValue(element),\n                    required: element.required,\n                    validity: makeSerializable(element.validity, true),\n                    myopId,\n                };\n\n                if (!key) {\n                    dataObject.unmappedData!.push(nodeData);\n                } else {\n                    if (dataObject.formData![key]) {\n                        if (dataObject.formData![key].value) {\n                            dataObject.unmappedData!.push(nodeData);\n                        } else {\n                            dataObject.unmappedData!.push(dataObject.formData![key]);\n                            dataObject.formData![key] = nodeData\n                        }\n                    } else {\n                        dataObject.formData![key] = nodeData\n                    }\n                }\n            }\n        });\n\n        return dataObject;\n    }\n\n    // Check if it's a checkbox or radio button\n    if (element.type === 'checkbox' || element.type === 'radio') {\n        return element.checked ? element.value : null;\n    }\n\n    // Handle input and textarea elements\n    if (element.tagName === 'INPUT' || element.tagName === 'TEXTAREA') {\n        return element.value;\n    }\n\n    // Handle select elements (dropdowns)\n    if (element.tagName === 'SELECT') {\n        return element.value;\n    }\n\n    // Handle editable divs (contentEditable)\n    if (element.isContentEditable) {\n        return element.innerText || element.textContent;\n    }\n\n    // If it's an unsupported element type\n    return null;\n}\n\nexport class GetElementValueHandler extends BaseWebComponentMessageHandler<GetElementValueMessage> {\n\n    messageType = MyopMessages.GetElementValueMessage;\n\n    innerExecutor = (event: GetElementValueMessage, shadowRootRef: ShadowRootRef, messageToHost: MessageToHost) => {\n        const items = getElementsByRef(event.ref, shadowRootRef.shadowRoot);\n        items.forEach(item => {\n            // @ts-ignore\n            messageToHost(new ElementValueReplayMessage(getInputValue(item)), event);\n        })\n    }\n}\n", "import {MyopMessages} from \"../../common/MyopMessages\";\nimport {SetInnerHtml} from \"../../messages\";\nimport {ShadowRootRef} from \"../shadowRootRef\";\nimport {BaseWebComponentMessageHandler} from \"./BaseWebComponentMessageHandler\";\nimport {MyopElementMessage} from \"../../messages\";\nimport {getElementsByRef} from \"../../common/messageHandlers/helpers\";\n\nexport class SetInnerHtmlHandler extends BaseWebComponentMessageHandler<SetInnerHtml> {\n\n    messageType = MyopMessages.SetInnerHtml;\n\n    innerExecutor = (event: MyopElementMessage, shadowRootRef: ShadowRootRef) => {\n        const items = getElementsByRef(event.ref, shadowRootRef.shadowRoot);\n        items.forEach(item => {\n            item.innerHTML = event.content;\n        })\n    }\n}\n", "/**\n * @packageDocumentation\n * The Webcomponent SDK is tailored for using Myop components packaged as separate bundles and exposed as web components.<br/>\n * Developers importing this SDK can leverage APIs and utilities specifically crafted to support the lifecycle management and communication patterns required for web components within the Myop architecture.<br/>\n * This SDK promotes reusability and encapsulation, enabling developers to build modular, self-contained components that can be seamlessly integrated into the host application's DOM structure.\n *\n *\n * Once loaded the `RootSDK`, you can load the `IframeSDK`\n * ```js\n * const {WebComponentSDK} = (await window.myop.rootSDK.getWebcomponentModule());\n * ```\n * or\n * ```ts\n * import {getWebcomponentModule} from '@myop/sdk';\n * const {WebComponentSDK} = (await getWebcomponentModule());\n * ```\n * or\n * ```ts\n * import {WebComponentSDK} from '@myop/sdk/webcomponent';\n * ```\n *\n */\nimport {BaseMyopSDK} from \"../common\";\nimport {MyopMessages} from \"../common/MyopMessages\";\nimport {myopWebcomponentConsts} from \"./consts\";\nimport {BaseWebComponentMessageHandler} from \"./messageHandlers/BaseWebComponentMessageHandler\";\nimport {BindOnClickHandler} from \"./messageHandlers/bindOnClickHandler\";\nimport {ChangeTextHandler} from \"./messageHandlers/changeTextHandler\";\nimport {ShadowRootRef} from \"./shadowRootRef\";\nimport {DetectMyopRefsMessageHandler} from \"./messageHandlers/DetectMyopRefsMessageHandler\";\nimport {defineDynamicImport} from \"../dynamicImport/defineDynamicImport\";\nimport {\n    BaseMyopMessage,\n    InitMessage,\n    InitRequest,\n    MessageDirection,\n    MyopBindMessage,\n    MyopBindReplayMessage\n} from \"../messages\";\nimport {setAttributeHandler} from \"./messageHandlers/setAttributeHandler.ts\";\nimport {AddEventListenerHandler} from \"./messageHandlers/addEventListenerHandler.ts\";\nimport {CreateRefComponentMessageHandler} from \"./messageHandlers/CreateRefComponentMessageHandler.ts\";\nimport {ExecuteScriptHandler} from \"./messageHandlers/executeScriptHandler.ts\";\nimport {GetElementValueHandler} from \"./messageHandlers/GetElementValueHandler.ts\";\nimport {SetInnerHtmlHandler} from \"./messageHandlers/setInnerHtmlHandler.ts\";\n\n/**\n * The Webcomponent SDK is tailored for using Myop components packaged as separate bundles and exposed as web components.<br/>\n * Developers importing this SDK can leverage APIs and utilities specifically crafted to support the lifecycle management and communication patterns required for web components within the Myop architecture.<br/>\n * This SDK promotes reusability and encapsulation, enabling developers to build modular, self-contained components that can be seamlessly integrated into the host application's DOM structure.\n *\n *\n * Once loaded the `Root SDK`, you can load the `IframeSDK`\n * ```js\n * const {WebComponentSDK} = (await window.myop.rootSDK.getWebcomponentModule());\n * ```\n * or\n * ```ts\n * import {getWebcomponentModule} from '@myop/sdk';\n * const {WebComponentSDK} = (await getWebcomponentModule());\n * ```\n *\n */\nexport class WebComponentSDK extends BaseMyopSDK {\n\n    alwaysPassEnvelopesToHost = true;\n\n    //when new web component created.\n    connectedCallback = (container: HTMLElement, shadow: ShadowRoot) => {\n        container.addEventListener(myopWebcomponentConsts.webcomponent_message_key, (e: any) => {\n            //debugger;\n            const eventContent = e.data ? e.data : e.detail;\n            if (!eventContent || !eventContent.myop) {\n                debugger;\n                throw new Error('recvied webcomponent_message with wrong type')\n            } else {\n                const message = eventContent as BaseMyopMessage;\n\n                //TODO : send container / compoennt identifier for multil components support\n                this.handleIncomeMessages(e)\n\n                if (message.messageType === MyopMessages.InitMessage) {\n                    // @ts-ignore\n                    const newComponentId = (message as InitMessage).content.id;\n                    this.components[newComponentId].context = new ShadowRootRef(container, shadow)\n\n                    // this.supportedHandlers.forEach(handler => {\n                    //     handler.context = this.shadowRoots;\n                    // });\n                }\n            }\n        })\n\n        //TODO : fix that hack. race condition with host.load when module loaded\n        setTimeout(() => {\n            this.messageToHost(new InitRequest())\n        }, 1)\n    }\n\n    messageToHost = (message: MyopBindReplayMessage, replayTo?: MyopBindMessage) => {\n        message.direction = MessageDirection.up\n        //message.replayToHandler = replayTo?.handlerUniqueId;\n\n        if (!message.replayToHandler && replayTo?.handlerUniqueId)\n            message.replayToHandler = replayTo.handlerUniqueId\n\n        window.myop.hostSDK.send(message)\n    }\n\n    supportedHandlers: BaseWebComponentMessageHandler[] = [\n        new ChangeTextHandler(this.messageToHost, this.components),\n        new SetInnerHtmlHandler(this.messageToHost, this.components),\n        new BindOnClickHandler(this.messageToHost, this.components),\n        new DetectMyopRefsMessageHandler(this.messageToHost, this.components),\n        new setAttributeHandler(this.messageToHost, this.components),\n        new AddEventListenerHandler(this.messageToHost, this.components),\n        new ExecuteScriptHandler(this.messageToHost, this.components),\n        new GetElementValueHandler(this.messageToHost, this.components),\n        //\n        new CreateRefComponentMessageHandler(this.messageToHost, this.components)\n    ];\n\n    public init = () => {\n        //this.myComponentId\n        //this.handleIncomeMessages\n    }\n}\n\ndefineDynamicImport('WebComponentSDK', WebComponentSDK);\n", "import {MyopWebComponent} from \"../components/myopWebcomponent\";\nimport {MyopExtractedWebComponent} from \"../components/myopExtractedWebComponent\";\nimport {BaseMyopLoader} from \"./IMyopLoader\";\nimport {loaderOptions} from \"../hostSDK.ts\";\nimport {uuidv4} from \"../../utils/utils.ts\";\nimport {\n    IComponentDefinitionConfig,\n    IHTMLLoaderConfig,\n    ISkinConfig, ShadowRootModeType,\n    SkinLoaders,\n    RenderMode, RenderPolicy\n} from \"../../common\";\nimport {WebComponentSDK} from \"../../webcomponent\";\nimport {MyopIframeComponent} from \"../components/myopIframeComponent.ts\";\nimport {EMBEDDED_SDK_CONTENT, HAS_EMBEDDED_SDK} from \"../embeddedSDK.ts\";\n//import {getWebcomponentModule} from \"../../SDK.ts\";\n\nconst MYOP_WEB_COMPONENT_MARKER = '<!-- myop-web-component -->';\nconst MYOP_WEB_COMPONENT_SCRIPT_ID = 'myop-web-component';\n\n// Track extracted web component scripts to prevent double registration.\n// Maps scriptId -> the tag name that script registered. The tag MUST be remembered per\n// script: window.__MYOP_TAG_NAME__ is a single global slot that every extracted component\n// overwrites, so on a re-mount (script skipped) it holds whichever component ran last.\nconst extractedWebComponentScripts: Map<string, string> = new Map();\n\nconst seen: string[] = [];\nlet sdk;\nconst getInitiatedSdk = async () => {\n    if (!sdk) {\n        //const {WebComponentSDK} = await getWebcomponentModule()\n        sdk = new WebComponentSDK();\n        sdk.init();\n    }\n    return sdk;\n}\n\nfunction createHTMLElementConstructor(htmlString: string, ShadowRootMode?: keyof typeof ShadowRootModeType): new () => HTMLElement {\n    return class extends HTMLElement {\n\n        connectedCallback() {\n            const mode = ShadowRootMode === ShadowRootModeType.open ? 'open' : 'closed';\n            const shadow = this.attachShadow({mode});\n            getInitiatedSdk().then((sdk) => {\n                sdk.connectedCallback(this, shadow);\n                shadow.innerHTML = htmlString\n            })\n        }\n    };\n}\n\nconst createCustomWebComponent = (componentName: string, html: string, ShadowRootMode?: keyof typeof ShadowRootModeType) => {\n    customElements.define(componentName, createHTMLElementConstructor(html, ShadowRootMode));\n    console.log(`define('${componentName}') was called, web component ready to use`);\n}\n\nconst toWebComponentName = (str) => {\n    return str\n        .replace(/([a-z])([A-Z])/g, '$1-$2') // Add hyphen before uppercase letters\n        .replace(/(\\d+)/g, '-$1') // Add hyphen before digits\n        .toLowerCase(); // Convert to lowercase\n}\n\nconst toCustomElementName = (name: string) => {\n    name = toWebComponentName(name);\n    return name.replace(/_/g, '-');\n}\n\nlet parser: DOMParser; // = new DOMParser();\n\nexport class HTMLComponentLoader extends BaseMyopLoader {\n\n    type = SkinLoaders.HTMLLoader\n\n    /**\n     * Detect if HTML is a Myop Web Component (starts with marker comment)\n     */\n    private isMyopWebComponent(html: string): boolean {\n        return html.trimStart().startsWith(MYOP_WEB_COMPONENT_MARKER);\n    }\n\n    /**\n     * Resolve how this component should render, applying the host render policy.\n     * Precedence: options.renderPolicy (per-call) fully replaces the global\n     * hostSDK.setRenderPolicy \u2014 so an app can restrict globally and allow specifics.\n     * With no policy set, behavior is unchanged from before (marker \u21D2 web component).\n     */\n    private async resolveRenderMode(\n        componentDefinition: IComponentDefinitionConfig,\n        skin: ISkinConfig,\n        loaderConfig: IHTMLLoaderConfig,\n        isWebComponent: boolean,\n        options?: loaderOptions,\n    ): Promise<{ mode: RenderMode | false; isolate: boolean }> {\n        const requestedMode: RenderMode = isWebComponent\n            ? 'webComponent'\n            : ((loaderConfig.isolation || options?.isolation) ? 'isolatedIframe' : 'iframe');\n\n        // per-call policy wins; else global policy on the host SDK singleton.\n        const policy: RenderPolicy | undefined =\n            options?.renderPolicy ?? (window as any)?.myop?.hostSDK?.getRenderPolicy?.();\n\n        const mode: RenderMode | false = policy\n            ? await policy({ componentDefinition, skin, requestedMode, isWebComponent })\n            : requestedMode;\n\n        return { mode, isolate: mode === 'isolatedIframe' };\n    }\n\n    /**\n     * The in-frame bridge for isolated components. Runs inside the sandboxed\n     * (opaque-origin) iframe, translating the same author-facing contract to/from\n     * postMessage since the host has no same-origin access:\n     *   \u2022 data-in : parent posts {type:'myop:init'} \u2192 calls window.myop_init_interface\n     *               (plus a baked initial value for the first render)\n     *   \u2022 data-out: window.myop_cta_handler \u2192 parent.postMessage({type:'myop:cta'})\n     *   \u2022 resize  : ResizeObserver \u2192 parent.postMessage({type:'myop:size'})\n     *\n     * TODO(dev-extension): the isolated path deliberately skips the same-origin\n     * dataScript, so it never posts the `MYOP_PREINJECTED_INIT` message the Myop dev\n     * extension listens for to log the INITIAL render (`init*`). Later init updates and\n     * all CTAs are still tracked (the extension wraps `comp.props`, which our isolated\n     * connectProps branch routes through), so only the first-render payload is missing\n     * from the extension's activity log for isolated components. Closing this would be a\n     * ~1-line `parent.postMessage({type:'MYOP_PREINJECTED_INIT', payload:{data}})` inside\n     * flushInitial() below \u2014 intentionally NOT done for now to avoid adding extension-only\n     * traffic to the component runtime. Web components have the same initial-init gap\n     * (initWithData is called on the element, not via comp.props) and it predates this.\n     */\n    private buildIsolationBridge(initialDataLiteral: string): string {\n        return `<script>\n            (function () {\n                var __initial = ${initialDataLiteral};\n                var __pending;\n                // data-out (cta)\n                window.myop_cta_handler = function (action, payload) {\n                    try { parent.postMessage({ __myop: true, type: 'myop:cta', action: action, payload: payload }, '*'); } catch (e) {}\n                };\n                function callInit(data) {\n                    if (typeof window.myop_init_interface === 'function') { window.myop_init_interface(data); return true; }\n                    return false;\n                }\n                // data-in (init updates)\n                window.addEventListener('message', function (e) {\n                    var d = e.data;\n                    if (!d || d.__myop !== true) return;\n                    if (d.type === 'myop:init') { if (!callInit(d.data)) __pending = d.data; }\n                });\n                // first render: use a pending update if one arrived, else the baked initial data\n                (function flushInitial() {\n                    var data = (__pending !== undefined) ? __pending : __initial;\n                    if (data === undefined) return;\n                    if (callInit(data)) { __pending = undefined; __initial = undefined; }\n                    else requestAnimationFrame(flushInitial);\n                })();\n                // resize (report content size)\n                function contentHeight() {\n                    // Measure the BODY (content box). documentElement.scrollHeight includes\n                    // the iframe viewport \u2014 which we're driving \u2014 so it would report the\n                    // current frame height, not the content, and never shrink.\n                    var b = document.body;\n                    if (b) return Math.max(b.scrollHeight, b.offsetHeight);\n                    return document.documentElement.scrollHeight;\n                }\n                function postSize() {\n                    try {\n                        parent.postMessage({\n                            __myop: true, type: 'myop:size',\n                            height: contentHeight(),\n                            width: document.documentElement.scrollWidth\n                        }, '*');\n                    } catch (e) {}\n                }\n                // Observe the BODY (reflows with content) \u2014 not documentElement, whose box is\n                // the iframe viewport and would feed back into a resize loop. A MutationObserver\n                // catches content swaps (e.g. innerHTML re-render) that don't change body's box.\n                if (window.ResizeObserver) {\n                    try { var __ro = new ResizeObserver(postSize); if (document.body) __ro.observe(document.body); } catch (e) {}\n                }\n                if (window.MutationObserver && document.body) {\n                    try { new MutationObserver(postSize).observe(document.body, { childList: true, subtree: true, attributes: true, characterData: true }); } catch (e) {}\n                }\n                window.addEventListener('load', postSize);\n                postSize();\n            })();\n        </script>`;\n    }\n\n    /**\n     * Extract the web component script content from HTML\n     */\n    private extractWebComponentScript(html: string): string | null {\n        const parser = new DOMParser();\n        const doc = parser.parseFromString(html, 'text/html');\n        const script = doc.getElementById(MYOP_WEB_COMPONENT_SCRIPT_ID);\n        return script?.textContent || null;\n    }\n\n    /**\n     * Execute the web component script on the host document.\n     * Returns the custom element tag name this script registered.\n     */\n    private executeWebComponentScript(scriptContent: string, scriptId: string): string | undefined {\n        // Check if already executed (by script content hash)\n        const cachedTagName = extractedWebComponentScripts.get(scriptId);\n        if (cachedTagName) {\n            console.log(`[MyopWebComponent] Script already executed for ${scriptId}, reusing <${cachedTagName}>`);\n            return cachedTagName;\n        }\n\n        const script = document.createElement('script');\n        script.textContent = scriptContent;\n        script.id = `myop-extracted-${scriptId}`;\n        document.head.appendChild(script);\n\n        // Read the global immediately: the next extracted script to run will overwrite it.\n        const tagName = (window as any).__MYOP_TAG_NAME__;\n        if (tagName) {\n            extractedWebComponentScripts.set(scriptId, tagName);\n        }\n        console.log(`[MyopWebComponent] Executed web component script: ${scriptId} -> <${tagName}>`);\n        return tagName;\n    }\n\n    /**\n     * Load a Myop Web Component (extracted and run on host document)\n     */\n    private async loadExtractedWebComponent(\n        componentDefinition: IComponentDefinitionConfig,\n        skin: ISkinConfig,\n        container: HTMLElement,\n        html: string,\n        options?: loaderOptions\n    ): Promise<MyopExtractedWebComponent> {\n        const scriptContent = this.extractWebComponentScript(html);\n\n        if (!scriptContent) {\n            throw new Error('[MyopWebComponent] No <script id=\"myop-web-component\"> found in HTML');\n        }\n\n        // Use component definition id as script identifier for deduplication\n        const scriptId = `${componentDefinition.id}-${skin.id}`;\n\n        // Execute the script on the host document, or reuse the tag it registered earlier.\n        // Never re-read window.__MYOP_TAG_NAME__ here: on a re-mount the script is skipped and\n        // the global still points at whichever component's script ran last, which would build\n        // this container's element from another component's tag.\n        const tagName = this.executeWebComponentScript(scriptContent, scriptId);\n\n        if (!tagName) {\n            throw new Error('[MyopWebComponent] Script did not set window.__MYOP_TAG_NAME__');\n        }\n\n        // Create the custom element\n        const domId = `myop-comp-${uuidv4()}`;\n        const element = document.createElement(tagName);\n        element.id = domId;\n\n        if (options?.hidden) {\n            element.style.opacity = '0';\n            element.style.position = 'absolute';\n            element.style.height = '0';\n            element.style.width = '0';\n            element.style.pointerEvents = 'none';\n            element.style.visibility = 'hidden';\n        }\n\n        // Clear container if needed\n        if (!container.querySelector('[id^=\"myop-comp-\"]')) {\n            container.innerHTML = '';\n        }\n\n        this.appendChild(container, element, options);\n\n        // Create the component wrapper\n        const component = new MyopExtractedWebComponent(\n            componentDefinition,\n            skin,\n            container,\n            element,\n            tagName,\n            options\n        );\n\n        // Initialize with data if provided\n        if (options?.data !== undefined) {\n            component.initWithData(options.data);\n        }\n\n        console.log(`[MyopWebComponent] Loaded <${tagName}> into container`);\n\n        return component;\n    }\n\n    load = async (componentDefinition: IComponentDefinitionConfig, skin: ISkinConfig, container: HTMLElement, options?: loaderOptions) => {\n\n        const loaderConfig = (skin.loader as IHTMLLoaderConfig);\n\n        const isWC = this.isMyopWebComponent(loaderConfig.HTML);\n        const { mode, isolate } = await this.resolveRenderMode(componentDefinition, skin, loaderConfig, isWC, options);\n\n        if (mode === false) {\n            throw new Error(`[Myop] Rendering blocked by render policy for component \"${componentDefinition.id}\"`);\n        }\n\n        if (isWC) {\n            // Web-component HTML only supports the web-component contract; a policy that\n            // denies it has no iframe fallback (see plan \u00A73.3) \u2014 block rather than\n            // silently render broken. Untrusted contributors must ship iframe components.\n            if (mode !== 'webComponent') {\n                throw new Error(`[Myop] Web-component rendering denied by render policy for component \"${componentDefinition.id}\"`);\n            }\n            return this.loadExtractedWebComponent(componentDefinition, skin, container, loaderConfig.HTML, options);\n        }\n\n        let domId = `myop-comp-${uuidv4()}`\n        let element;\n\n        if (loaderConfig.shadowRootMode === ShadowRootModeType.localFrame) {\n            const uniqId = uuidv4();\n            const domId = `myop-comp-${uniqId}`\n\n            let IframeElement = document.createElement('iframe');\n            IframeElement.id = domId;\n\n            // Full isolation: a sandbox WITHOUT allow-same-origin gives the frame an\n            // opaque origin \u2014 no host DOM/cookies/parent access. Must be set before\n            // the frame navigates (i.e. before srcdoc / append).\n            if (isolate) {\n                IframeElement.setAttribute('sandbox', 'allow-scripts allow-forms allow-popups');\n            }\n\n            // Set all styles BEFORE appending to prevent flash at wrong position\n            IframeElement.style.cssText = `\n                display: block;\n                padding: 0;\n                margin: 0;\n                position: absolute;\n                inset: 0;\n                overflow: hidden;\n                border: none;\n                opacity: ${options?.hidden ? '0' : '1'};\n                width: 100%;\n                height: 100%;\n                pointer-events: ${options?.hidden ? 'none' : 'all'};\n            `;\n\n            // TODO : do it only with flag ?\n            if (!container.querySelector('[id^=\"myop-comp-\"]'))\n                container.innerHTML = '';\n\n            IframeElement = this.appendChild(container, IframeElement, options) as HTMLIFrameElement;\n\n            // Write content into the iframe. An isolated (sandboxed, opaque-origin) frame\n            // can't be doc.write()'n from the host, so accumulate the markup and set it via\n            // srcdoc on close(). Non-isolated frames keep the same-origin doc.write path.\n            const __srcParts: string[] = [];\n            const doc: { open(): void; writeln(s: string): void; close(): void } = isolate\n                ? {\n                    open() {},\n                    writeln(s: string) { __srcParts.push(s); },\n                    close() { IframeElement.srcdoc = __srcParts.join('\\n'); },\n                }\n                : (() => {\n                    //@ts-ignore\n                    const d = IframeElement.contentDocument || IframeElement.contentWindow.document;\n                    d.open();\n                    return d;\n                })();\n\n\n            // Parse myop:size meta tag before iframe creation (same DOMParser pass pattern as myop_preview removal).\n            // This lets the React host determine sizing mode (fill vs content) from the start.\n            let parsedSizeMeta: { width?: string | number; height?: string | number; minWidth?: number; maxWidth?: number; minHeight?: number; maxHeight?: number } | null = null;\n            {\n                const _preParser = new DOMParser();\n                const _preDoc = _preParser.parseFromString(loaderConfig.HTML, 'text/html');\n                const sizeMeta = _preDoc.querySelector('meta[name=\"myop:size\"]');\n                if (sizeMeta) {\n                    try { parsedSizeMeta = JSON.parse(sizeMeta.getAttribute('content') || '{}'); } catch {}\n                }\n            }\n\n            let HTML2Render = loaderConfig.HTML;\n\n            if (options?._inspection) {\n                //inject inspection script for props detection\n                const parser = new DOMParser();\n                const _doc = parser.parseFromString(loaderConfig.HTML, 'text/html');\n\n                // TODO : part of AI components, think about that, document it.\n                const myop_preview_script = _doc.getElementById('myop_preview');\n                myop_preview_script?.removeAttribute('type');\n\n                // Parse the injected HTML string into a node\n                const temp = _doc.implementation.createHTMLDocument();\n                temp.body.innerHTML = `<script>\n                        const beforeKeysWindow = new Set(Object.keys(window));\n                        window.myopState = {\n                            beforeKeysWindow,\n                        };\n                </script>`;\n\n                const node = temp.body.firstChild;\n\n                if (node && _doc.head) {\n                    _doc.head.insertBefore(_doc.importNode(node, true), _doc.head.firstChild);\n                }\n\n                // Prepend DOCTYPE: documentElement.outerHTML returns only <html>...</html>\n                // and drops the doctype, which would put the iframe in quirks mode.\n                // Quirks mode breaks auto-sizing because <body> stretches to the iframe\n                // viewport instead of shrinking to content, so ResizeObserver on body\n                // never fires when content reflows (e.g. after font swap).\n                HTML2Render = '<!DOCTYPE html>' + _doc.documentElement.outerHTML;\n            } else if (options?.data !== undefined) {\n\n                //TODO: improve by do it on the serve once\n\n                // Remove myop_preview script when not in inspection mode\n                const parser = new DOMParser();\n                const _doc = parser.parseFromString(loaderConfig.HTML, 'text/html');\n                const myop_preview_script = _doc.getElementById('myop_preview');\n\n                if (myop_preview_script) {\n                    myop_preview_script.remove();\n                    // See note above: prepend DOCTYPE to keep the iframe in standards mode.\n                    HTML2Render = '<!DOCTYPE html>' + _doc.documentElement.outerHTML;\n                }\n            }\n\n            // Inject host-provided CSS before the iframe is written so styles are\n            // present on first paint (no FOUC). Appended last in <head> so it wins\n            // over the component's own styles via normal cascade order.\n            if (options?.injectCss) {\n                const parser = new DOMParser();\n                const _doc = parser.parseFromString(HTML2Render, 'text/html');\n                const styleTag = _doc.createElement('style');\n                styleTag.setAttribute('data-myop-injected', 'true');\n                // <style> is an HTML raw-text element: the serializer below writes its\n                // contents LITERALLY, without escaping. CSS containing \"</style>\" would\n                // therefore close the tag and inject live markup into the iframe, which\n                // executes same-origin with this page. Neutralize the sequence \u2014 no real\n                // stylesheet contains it. (Same class of bug as the </script> escape in\n                // the data payload below.)\n                styleTag.textContent = options.injectCss.replace(/<\\s*\\/\\s*style/gi, '<\\\\/style');\n                (_doc.head || _doc.documentElement).appendChild(styleTag);\n                // See note above: prepend DOCTYPE to keep the iframe in standards mode.\n                HTML2Render = '<!DOCTYPE html>' + _doc.documentElement.outerHTML;\n            }\n\n\n            doc.writeln(HTML2Render);\n\n            // window.__federation__ =\n            //     { ...window.__federation__,\n            //         //TODO : get from ENV at build time,\n            //         // inject value to module at build time\n            //         // today we doing so just for the CJS version\n            //         __public_path__ :'https://cdn.myop.dev/sdk/next'\n            //         ,...${JSON.stringify(\n            //                 // @ts-ignore\n            //                 window.__federation__)\n            //              }\n            //     };\n\n            // For npm package users with bundlers (Vite/Webpack), inject SDK inline\n            // For CDN users (script tag), use CDN URL\n            const sdkScript = HAS_EMBEDDED_SDK\n                ? `<script>${EMBEDDED_SDK_CONTENT}</script>`\n                : `<script src=\"${window.myop.__ROOT_SDK_PUBLIC_URL__}\"></script>`;\n\n            // Different init script for embedded vs CDN SDK\n            // - Embedded (bundled IIFE): uses MyopSDK.getIframeModule() which returns module directly\n            // - CDN (dynamic loading): uses window.myop.rootSDK.getIframeModule() which wraps with .get()\n            const initScript = HAS_EMBEDDED_SDK\n                ? `<script>\n                   const __myop_init = async () => {\n                        const iframeModule = await MyopSDK.getIframeModule();\n                        const IframeSDK = iframeModule.IframeSDK;\n                        const sdk = new IframeSDK();\n                        sdk.init();\n                   }\n                   __myop_init().then();\n                </script>`\n                : `<script>\n                   window.__federation__.__public_path__ = window.__federation__.__public_path__;\n                   const __myop_init = async () => {\n                        const {IframeSDK} = (await window.myop.rootSDK.getIframeModule());\n                        const sdk = new IframeSDK();\n                        sdk.init();\n                   }\n                   __myop_init().then();\n                </script>`;\n\n            // Isolated frames use the postMessage bridge instead of the same-origin\n            // IframeSDK + data-injection scripts (which rely on host\u2194frame access).\n            if (!isolate) {\n                doc.writeln(`${sdkScript}${initScript}`);\n            }\n\n            // Inject data script if data option is provided\n            if (!isolate && options?.data !== undefined) {\n                // Setup CTA queue - captures any CTAs emitted during init before host registers handler\n                const ctaQueueScript = `<script>\n                    window.__myop_cta_queue = [];\n                    window.myop_cta_handler = function(action, payload) {\n                        window.__myop_cta_queue.push({action: action, payload: payload});\n                    };\n                </script>`;\n\n                // Escape data for safe embedding in script tag\n                // JSON.stringify doesn't escape </script> which could break HTML parsing\n                const escapedData = JSON.stringify(options.data)\n                    .replace(/<\\/script/gi, '\\\\u003c/script');\n\n                // Self-contained data injection script that:\n                // 1. Calls myop_init_interface immediately if already defined\n                // 2. Watches for late-defined myop_init_interface via defineProperty\n                // 3. Cleans up after itself (removes script tag and window data)\n                // 4. Posts message to parent for extension tracking (pre-injected init*)\n                const dataScript = `<script id=\"__myop_init_data_script\">\n                    (function() {\n                        var data = ${escapedData};\n                        var scriptEl = document.getElementById('__myop_init_data_script');\n\n                        var callInitInterface = function(fn) {\n                            var startTime = performance.now();\n                            // Mark as pre-injected data call for extension tracking\n                            window.__myop_init_preinjected = true;\n                            try {\n                                fn(data);\n                            } finally {\n                                window.__myop_init_preinjected = false;\n                            }\n                            var duration = performance.now() - startTime;\n\n                            // Notify extension via postMessage (init* = pre-injected)\n                            try {\n                                window.parent.postMessage({\n                                    type: 'MYOP_PREINJECTED_INIT',\n                                    payload: {\n                                        data: data,\n                                        duration: duration,\n                                        timestamp: Date.now()\n                                    }\n                                }, '*');\n                            } catch (e) {}\n\n                            // Cleanup: remove script tag and stored data\n                            if (scriptEl && scriptEl.parentNode) {\n                                scriptEl.parentNode.removeChild(scriptEl);\n                            }\n                            delete window.__myop_init_data;\n                        };\n\n                        if (typeof window.myop_init_interface === 'function') {\n                            // Function already exists - call immediately\n                            callInitInterface(window.myop_init_interface);\n                        } else {\n                            // Function not yet defined - store data and watch for definition\n                            window.__myop_init_data = data;\n\n                            var _original;\n                            Object.defineProperty(window, 'myop_init_interface', {\n                                configurable: true,\n                                enumerable: true,\n                                set: function(fn) {\n                                    _original = fn;\n                                    if (window.__myop_init_data !== undefined) {\n                                        var storedData = window.__myop_init_data;\n                                        delete window.__myop_init_data;\n                                        callInitInterface(fn);\n                                    }\n                                },\n                                get: function() {\n                                    return _original;\n                                }\n                            });\n                        }\n                    })();\n                </script>`;\n                doc.writeln(ctaQueueScript + dataScript);\n            }\n\n            // Isolated frames: inject the postMessage bridge (init in / cta out / size out).\n            if (isolate) {\n                const escapedData = options?.data !== undefined\n                    ? JSON.stringify(options.data).replace(/<\\/script/gi, '\\\\u003c/script')\n                    : 'undefined';\n                doc.writeln(this.buildIsolationBridge(escapedData));\n            }\n\n            doc.close();\n\n            // TODO : control from dashboard\n            //  (skin.loader as IIframeLoaderConfig).autoHeight = true;\n\n            const comp = new MyopIframeComponent(componentDefinition, skin, container, IframeElement, options);\n\n            // Isolated: wire the host side of the postMessage bridge (cta in, size in, init out).\n            if (isolate) comp.enableIsolation();\n\n            // Store parsed sizeMeta on the component so the React host can read it\n            comp.sizeMeta = parsedSizeMeta;\n\n            // Auto-size: observe content size and sync to iframe dimensions.\n            // This works for all hosts (vanilla SDK, React, Vue, Angular).\n            // If a framework host (e.g. @myop/react) also calls observeAutoSize(),\n            // it cleanly replaces these observers via _autoSizeCleanup tracking.\n            comp.initiated().then(() => {\n                if (options?.autoSize === false) {\n                    // No auto-sizing. Iframe stays position:absolute filling container.\n                    // Host is fully responsible for container dimensions (e.g. React Native WebView).\n                    return;\n                }\n                let shown = false;\n                comp.observeAutoSize({\n                    forceAutoSize: true,\n                    onSizeChange: () => {\n                        // Show after first measurement completes (not before).\n                        // The iframe transitions from absolute overlay to document flow\n                        // at the measured height, preventing flash at wrong size.\n                        if (!shown && !options?.hidden) {\n                            shown = true;\n                            comp.show();\n                        }\n                    }\n                });\n            });\n            // // @ts-ignore\n            // comp.props._global = comp.element.contentWindow;\n            return comp;\n\n        }\n\n        if (loaderConfig.shadowRootMode === ShadowRootModeType.none) {\n            // parser = parser ? parser : new DOMParser();\n            // const doc = parser.parseFromString(loaderConfig.HTML, 'text/html');\n            // element = doc.body.firstChild;\n            //element.setAttribute('id', domId);\n\n            const template = document.createElement('template');\n            template.innerHTML = loaderConfig.HTML;//.trim();\n            element = template.content.firstElementChild;\n\n            //   const firstElement = template.content.firstElementChild;\n            //   const z = firstElement ? firstElement.tagName.toLowerCase() : null;\n            //   debugger;\n            //   console.log(template, firstElement, z)\n            //   element = firstElement\n\n            // const container = document.createElement('tbody');\n            // debugger;\n            // container.innerHTML = loaderConfig.HTML;\n            // element = container.firstElementChild;\n\n            getInitiatedSdk().then((sdk) => {\n                sdk.connectedCallback(element, element);\n            })\n        } else {\n            const customElementName = toCustomElementName(componentDefinition.name + skin.id);\n\n            //TODO : support redefine !\n            if (!seen.includes(customElementName)) {\n                createCustomWebComponent(customElementName, loaderConfig.HTML, loaderConfig.shadowRootMode);\n                seen.push(customElementName);\n            }\n            element = document.createElement(customElementName);\n        }\n        // TODO : do it only with flag ?\n        if (!container.querySelector('[id^=\"myop-comp-\"]'))\n            container.innerHTML = '';\n\n        //element.style.visibility = 'hidden';\n        element.id = domId;\n\n        if (options?.hidden) {\n            element.style.opacity = '0';\n            element.style.position = 'absolute'\n            element.style.height = '0'\n            element.style.width = '0'\n            element.style.pointerEvents = 'none'\n            element.style.visibility = 'hidden';\n        }\n\n        // if (container.id.startsWith('myop-comp-')) {\n        //     // in place replacement\n        //     container.replaceWith(element);\n        //     //container = element.parentElement!;\n        // } else {\n        //     container.appendChild(element);\n        // }\n\n        this.appendChild(container, element, options);\n\n        //element.innerHTML = `<${customElementName} />`;\n        return new MyopWebComponent(componentDefinition, skin, container, element, options);\n    }\n}\n", "import {decompressUUIDs} from \"../utils/uuid.ts\";\nimport {CloudRepository} from \"../helpers\";\nimport {\n    ExperienceTypes,\n    IComponentConfig, IDedicatedSkinConfig,\n    ISegmentedSkinConfig,\n    ISegmentExperience, ISkinInstanceConfig,\n    SkinSelectorTypes\n} from \"../common\";\n\nexport const checkMyopOverride = async (componentConfig: IComponentConfig): Promise<IComponentConfig | null> => {\n    try {\n        //TODO: support disabling the mechanism\n        const url = new URL(window.location.href);\n        const params = new URLSearchParams(url.search);\n        const myopOverride = params.get('myopOverride');\n        if (myopOverride) {\n            const [source, ...uuids] = decompressUUIDs(myopOverride);\n\n            switch (source) {\n                case 'component': {\n                    const [componentId, skinId] = uuids;\n                    const componentToOverride = await CloudRepository.Main.fetchComponent(componentId);\n                    if (componentToOverride) {\n                        // todo: check fetchAutoFlow. Looks like only one skin is returned\n                        const skin = componentToOverride.type.skins.find(skin => skin.id === skinId);\n                        if (skin) {\n                            // todo: for now just set skin id. Check the cloud implementation\n\n                            componentToOverride.instance.skinSelector = {\n                                type: SkinSelectorTypes.Dedicated,\n                                skin: {\n                                    id: skinId\n                                } as ISkinInstanceConfig\n\n                            } as IDedicatedSkinConfig;\n\n                            return componentToOverride\n                        }\n                    }\n                }\n                    break;\n            //    case 'flow': {\n                default : {\n                   // const [flowId, experimentId] = uuids;\n                    const [flowId, experimentId] = decompressUUIDs(myopOverride);\n                    const flow = await CloudRepository.Main.fetchFlow(flowId);\n                    const componentToOverride = flow.components.find(c => c.type.id === componentConfig.type.id);\n                    if (componentToOverride) {\n                        if (componentToOverride.instance.skinSelector.type === SkinSelectorTypes.Segmented) {\n\n                            if (componentToOverride.instance.resolvedExperiences) {\n                                const resolvedExperience = componentToOverride.instance.resolvedExperiences.find(e => e.id === experimentId);\n\n                                if (resolvedExperience?.type === ExperienceTypes.Segment) {\n\n                                    const typedResolvedExperience = resolvedExperience as ISegmentExperience\n\n                                    const typedSkinSelector = componentToOverride.instance.skinSelector as ISegmentedSkinConfig\n                                    const segment = typedSkinSelector.segments.find(s => s.segmentId === typedResolvedExperience.segment.id);\n                                    if (segment) {\n                                        componentToOverride.instance.skinSelector = segment?.skinSelector;\n                                        return componentToOverride;\n                                    }\n                                }\n                            }\n                        }\n                    }\n                }\n                    break;\n            }\n        }\n    } finally {\n        return null;\n    }\n}", "/**\n * @packageDocumentation\n * The Host SDK is designed for integration within the host application that serves as the container for Myop  components.<br/><br/>\n * It provides essential functionalities and APIs for registering, managing, and communicating with Myop components.<br/><br/>\n * This SDK enables seamless embedding of independently developed components into the host application, ensuring smooth interoperability and consistent user experience across various Myop component implementations.\n */\nimport {defineDynamicImport} from \"../dynamicImport/defineDynamicImport\";\nimport {IMyopLoader} from \"./loaders/IMyopLoader\";\nimport {IMyopComponent} from \"./components/IMyopComponent\";\nimport {MyopMessages} from \"../common/MyopMessages\";\nimport {\n    BaseMyopMessage,\n    EnvelopedMessage, ExecuteComponentMethod,\n    InitMessage,\n    InitResponse, MessageDirection, Ref\n} from \"../messages\";\nimport {MyopIframeLoader} from \"./loaders/iframeLoader\";\nimport {WebcomponentLoader} from \"./loaders/webcomponentLoader\";\nimport {RenderPolicy} from \"../common\";\nimport type {IframeSDK} from \"../Iframe\";\nimport {connectProps, connectRefs, createRefComponent} from \"./componentCore\";\nimport {\n    ExperienceTypes,\n    IComponentConfig,\n    IComponentDefinitionConfig,\n    IDedicatedSkinConfig, IExperience, IFunctionResultsSegment, ISegmentedSkinConfig, ISegmentExperience,\n    ISkinConfig, ISkinSelectorConfig, SkinSelectorTypes,\n\n\n} from \"../common\";\n// @ts-ignore handled by custom esbuild plugin\nimport version from \"myop-sdk-version\";\nimport {delivery, deliveryOff, deliveryRefresh, deliveryStats} from \"../helpers/cloudRepositoryHelpers\";\nimport {HTMLComponentLoader} from \"./loaders/HTMLComponentLoader\";\nimport {checkMyopOverride} from \"./myopOverride.ts\";\n\ninterface componentLoaderCreator {\n    new(loaders: IMyopLoader[]): any;\n}\n\n// const getComponentDefinitionConfig = async (id: string) => {\n//     const res = await fetch(`http://localhost:3000/component?id=${id}`);\n//     const componentDef: IComponentDefinitionConfig = (await res.json()).item;\n//     return componentDef\n// }\n\n//const __ROOT_SDK_PUBLIC_URL__ = 'https://dfdlk2p1m187v.cloudfront.net/myop_sdk.min.js'\nconst __ROOT_SDK_PUBLIC_URL__ = 'https://cdn.myop.dev/sdk/next/myop_sdk.min.js'\n\n/**\n * The Host SDK is designed for integration within the host application that serves as the container for Myop  components.<br/><br/>\n * It provides essential functionalities and APIs for registering, managing, and communicating with Myop components.<br/><br/>\n * This SDK enables seamless embedding of independently developed components into the host application, ensuring smooth interoperability and consistent user experience across various Myop component implementations.\n */\nexport class HostSDK {\n    static Instance = () => window.myop.hostSDK;\n\n    components2init: IMyopComponent[] = [];\n    components: IMyopComponent[] = [];\n    componentsLoaders: IMyopLoader[] = [];\n\n    // Global render policy (allow/deny/mode gate). A per-call options.renderPolicy\n    // takes precedence over this \u2014 see HTMLComponentLoader.resolveRenderMode.\n    private _renderPolicy?: RenderPolicy;\n    public setRenderPolicy = (policy?: RenderPolicy) => { this._renderPolicy = policy; };\n    public getRenderPolicy = (): RenderPolicy | undefined => this._renderPolicy;\n\n    public initiated: boolean = false;\n\n    public version = version;\n\n    type2InstanceCount: Record<string, number> = {};\n    public assignId = (componentDefinition: IComponentDefinitionConfig) => {\n        if (!this.type2InstanceCount[componentDefinition.id]) {\n            this.type2InstanceCount[componentDefinition.id] = 0;\n        }\n        return `${componentDefinition.id}_${++this.type2InstanceCount[componentDefinition.id]}`;\n    }\n\n    //TODO : fix the inspect implementation inside refComponent\n    //then inspected maybe can be dropped\n    private inspected = false;\n    public inspect = () => {\n        if (this.inspected)\n            return;\n\n        this.inspected = true;\n\n        this.components.forEach(component => {\n            if (component.inspect) {\n                component.inspect()\n            }\n        })\n    }\n\n    // A component's origin is whatever its iframe URL is, so an origin allowlist can't work here.\n    // Instead only frames this SDK created (or adopted) may talk to it. `send()` dispatches\n    // synthetic events, which have no source.\n    private isTrustedSource = (source: MessageEventSource | null) => {\n        if (!source || source === window) return true;\n        const isOwnFrame = (component: IMyopComponent) => {\n            const element = component.element as HTMLIFrameElement | undefined;\n            return element?.nodeName === 'IFRAME' && element.contentWindow === source;\n        };\n        return this.components.some(isOwnFrame) || this.components2init.some(isOwnFrame);\n    }\n\n    private incomingMessageHandler = (event: MessageEvent<BaseMyopMessage>) => {\n        if (!event.data?.myop) return;\n\n        if (!this.isTrustedSource(event.source)) {\n            return;\n        }\n\n        if (event.data.myop) {\n            if (event.data.direction !== MessageDirection.up && event.data.messageType !== MyopMessages.EnvelopedMessage) {\n                //console.log('message dropped in hostsdk, direction was ', event.data.direction)\n                return;\n            }\n            // console.log(\"event on host side \", event);\n\n            const myopMessage: BaseMyopMessage = event.data;\n\n            if (myopMessage.messageType === MyopMessages.InitRequest) {\n                this.components2init.forEach(component => {\n                    component.send(new InitMessage(component.id))\n                });\n                return;\n            }\n\n            if (myopMessage.messageType === MyopMessages.InitResponse) {\n                // remove from components 2 init\n                // @ts-ignore\n                this.components2init = this.components2init.filter(component => component.id !== (myopMessage as InitResponse).content.id)\n\n                const initiatedComponent = this.components.find(component => component.id === (myopMessage as InitResponse).content?.id);\n                initiatedComponent?.setInitiated()\n                //initiatedComponent?.parent?.setInitiated();\n                // TODO : is it true to not pass further ( to the component )\n                return;\n            }\n\n            if (myopMessage.messageType === MyopMessages.EnvelopedMessage) {\n                //debugger;\n                const typedMessage = myopMessage as EnvelopedMessage\n                const refComponent = this.components.find(component => component.id === typedMessage.destination);\n\n                if (refComponent) {\n                    if (typedMessage.direction === MessageDirection.down) {\n                        if (typedMessage.message.messageType === ExecuteComponentMethod.name) {\n                            refComponent.onMessageReceived(typedMessage.message)\n                        } else {\n                            //\n                            typedMessage.message.route = typedMessage.route;\n                            refComponent.send(typedMessage.message);\n                        }\n                        return;\n                    }\n                } else {\n                    const innerComponent = this.components.find(component => component.id === typedMessage.message.destination);\n                    if (innerComponent) {\n                        innerComponent.send(typedMessage.message)\n                    } else {\n                        // TODO : log ?\n                    }\n                }\n                // @ts-ignore\n                //component.refs.body.onMessageReceived(myopMessage.message);\n\n                return;\n            }\n\n            const component = this.components.find(component => component.id === myopMessage.destination);\n\n            if (!component) {\n                //no in mem component\n                //pass to parent HostSDK to try process there\n                if (window.myop.IframeSDK) {\n                    window.myop.IframeSDK.messageToHost(myopMessage);\n                }\n                return;\n            }\n\n            if (component) {\n                if (component.onMessageReceived(myopMessage)) {\n                    return;\n                } else {\n                    //not processed in onMessageReceived\n                    //pass to parent HostSDK to try process there\n                    if (window.myop.IframeSDK)\n                        window.myop.IframeSDK.messageToHost(myopMessage);\n                }\n            }\n        }\n\n        // event.source.postMessage(\n        //     \"hi there yourself!  the secret response \" + \"is: rheeeeet!\",\n        //     event.origin,\n        //   );\n    }\n\n    public send = (message: BaseMyopMessage) => {\n        const syntheticEvent = new MessageEvent<BaseMyopMessage>('',\n            {data: message}\n        )\n\n        this.incomingMessageHandler(syntheticEvent);\n    }\n\n    public init = (customComponentLoaderCreators?: componentLoaderCreator[]) => {\n        if (this.initiated) {\n            // getHostModule() already initiates the SDK, and the README tells hosts to call init()\n            // after it. Only merge custom loaders; the message listener is already attached.\n            if (customComponentLoaderCreators?.length) {\n                this._registerLoaders(customComponentLoaderCreators);\n            }\n            return;\n        }\n\n        const basicLoaders = [\n            new MyopIframeLoader(),\n            new WebcomponentLoader(),\n            new HTMLComponentLoader()\n        ];\n\n        this.componentsLoaders = [\n            ...basicLoaders\n        ];\n\n        if (customComponentLoaderCreators) {\n            this._registerLoaders(customComponentLoaderCreators);\n        }\n\n        // Incomming messages from IFrames\n        window.addEventListener(\n            \"message\",\n            this.incomingMessageHandler,\n            false,\n        );\n\n        console.log('myop hostSDK initiated', document.location.href);\n        this.initiated = true;\n    }\n\n    private _registerLoaders = (customComponentLoaderCreators: componentLoaderCreator[]) => {\n        const loaderByType: Record<string, IMyopLoader> = {};\n\n        customComponentLoaderCreators.forEach(customComponentLoaderCreator => {\n            const customLoader = new customComponentLoaderCreator(this.componentsLoaders);\n            loaderByType[customLoader.type] = customLoader;\n        })\n\n        this.componentsLoaders.forEach(loader => {\n            if (!loaderByType[loader.type])\n                loaderByType[loader.type] = loader;\n        })\n\n        this.componentsLoaders = Object.values(loaderByType);\n    }\n\n    private _getSkinIdBySkinSelector = async (skinSelector: ISkinSelectorConfig, experiences: IExperience[] = [], hooks?: loaderHooks): Promise<string> => {\n        async function asyncFind<T>(\n            array: T[],\n            predicate: (item: T) => Promise<boolean>\n        ): Promise<T | undefined> {\n            for (const item of array) {\n                if (await predicate(item)) {\n                    return item;\n                }\n            }\n            return undefined; // Return undefined if no match is found\n        }\n\n        switch (skinSelector.type) {\n            // @ts-ignore\n            case \"DedicatedSkin\" : //backward compatibility\n            case SkinSelectorTypes.Dedicated: {\n                let selectedSkinId = (skinSelector as IDedicatedSkinConfig).skin?.id\n                    || (skinSelector as IDedicatedSkinConfig).skins![0].id;\n\n                return selectedSkinId;\n            }\n                break;\n            case SkinSelectorTypes.Segmented: {\n                const typedSkinSelector = (skinSelector as ISegmentedSkinConfig)\n                const segment = await asyncFind(typedSkinSelector.segments, async segment => {\n                    if (segment.segmentId === 'Default') {\n                        return true;\n                    }\n\n                    const experience = experiences.find(experience => {\n                        if (experience.type === ExperienceTypes.Segment) {\n                            return (experience as ISegmentExperience).segment.id === segment.segmentId\n                        }\n                        return false;\n                    });\n\n                    if (!experience) {\n                        throw new Error(\"experience not found\");\n                    }\n\n                    const typedExperience = experience as ISegmentExperience;\n                    const typedSegment = (typedExperience.segment as IFunctionResultsSegment)\n\n                    const segmentFunction = (hooks ? hooks : {})[typedSegment.function];\n                    if (segmentFunction) {\n                        const results = await segmentFunction();\n                        return results;\n                    } else {\n                        console.warn(`segmentId:${segment.segmentId}, ${typedSegment.function} function not provided !`)\n                    }\n\n                    return false;\n                });\n\n                if (segment)\n                    return this._getSkinIdBySkinSelector(segment.skinSelector, experiences);\n                else {\n                    debugger;\n                }\n            }\n                break;\n            default: {\n                debugger;\n            }\n        }\n        return '' //TODO\n    }\n\n    private runSkinSelector = async (componentConfig: IComponentConfig, hooks?: loaderHooks) => {\n        const skinId = await this._getSkinIdBySkinSelector(componentConfig.instance.skinSelector, componentConfig.instance.resolvedExperiences, hooks);\n        return componentConfig.type.skins.find(skin => skin.id === skinId);\n    }\n\n    public loaderHooks?: loaderHooks;\n\n    public loadComponent = async <T extends IMyopComponent = IMyopComponent>(componentConfig: IComponentConfig, container?: HTMLElement | Ref, options?: loaderOptions):\n        Promise<T> => {\n\n        if (!container) {\n            debugger;\n            throw new Error('no container was found for this component');\n        }\n\n        const overriddenConfig = await checkMyopOverride(componentConfig);\n        if (overriddenConfig) {\n            //TODO : log\n            componentConfig = overriddenConfig;\n        }\n\n        // // @ts-ignore\n        // if (!container.__nonProxied) {\n        //     const refComponent = (container as unknown as MyopRefComponent);\n        //     //if we got loadComponent over MyopRefComponent\n        //     if (refComponent.id && refComponent.parent) {\n        //         return this.loadComponent(componentConfig, refComponent.ref, options);\n        //\n        //         // let rootComponent: IMyopComponent = refComponent;\n        //         // while(!rootComponent.element && rootComponent.parent){\n        //         //     rootComponent = rootComponent.parent\n        //         // }\n        //         //\n        //         // rootComponent.element\n        //         // //what now ?\n        //     }\n        // }\n\n        const hooks = {...(this.loaderHooks ?? {}), ...(options?.hooks ?? {})};\n\n        const ref = container as Ref;\n        if (ref.myop) {\n            if (ref.component) {\n\n                componentConfig = {...componentConfig};\n                componentConfig.instance = {\n                    ...componentConfig.instance\n                }\n\n                let selectedSkin = await this.runSkinSelector(componentConfig, hooks)!\n                if (!selectedSkin) {\n                    throw new Error(\"runSkinSelector failed to choose skin, check the provided config\");\n                }\n\n                if (options?.hooks?.afterSkinSelected) {\n                    selectedSkin = await options.hooks.afterSkinSelected({...selectedSkin});\n                }\n\n                componentConfig.instance.skinSelector = {\n                    type: SkinSelectorTypes.Dedicated,\n                    skin: selectedSkin\n                    //  skins: [selectedSkin]\n                } as IDedicatedSkinConfig\n\n                if (options) {\n                    options = {...options}\n                    delete options.hooks\n                }\n\n                const refComponent = await createRefComponent<T>(ref, componentConfig, this.components, options);\n\n                //TODO : connect refs and props insode createRefComponent, elsewhere its not really <T>\n                return refComponent;\n            } else {\n                throw new Error('load component got a detached ref.')\n            }\n        }\n\n        container = container as HTMLElement;\n\n        /**\n         *\n         * choose skin on runtime ...\n         *        componentConfig.instance.skinSelector.type\n         */\n\n        let selectedSkin = await this.runSkinSelector(componentConfig, hooks)!\n\n        if (!selectedSkin) {\n            throw new Error(\"runSkinSelector failed to choose skin, check the provided config\");\n        }\n\n        if (options?.hooks?.afterSkinSelected) {\n            selectedSkin = await options.hooks.afterSkinSelected({...selectedSkin});\n        }\n        const componentLoader = this.componentsLoaders.find(loader => loader.type === selectedSkin.loader.type);\n\n        if (!componentLoader) {\n            debugger;\n            throw new Error(`no loader \"${selectedSkin.loader.type}\" was found for component`);\n        }\n\n        //for loaded webcomponent modules to following line creates a race condition with the init message flow\n        let component = await componentLoader.load(componentConfig.type, selectedSkin, container, options);\n\n        // TODO : when this is not true ?\n        if (!component.isInitiated)\n            this.components2init.push(component)\n\n        component.bind('onDispose', () => {\n            //console.log('component dispose', component);\n            this.components = this.components.filter(c => c !== component)\n            this.components2init = this.components2init.filter(c => c !== component)\n            return true;\n        })\n\n        this.components.push(component);\n\n        // true by default\n        if (!options || options.connectProps !== false) {\n            //TODO : make type field conditional type infer \"string\" > string, \"number\" > number, etc...\n            component = connectProps(component, componentConfig.type.props, selectedSkin);\n        }\n\n        try {\n            //TODO : make optional?\n            //TODO : fix issues with timeout and wrong ref names from config vs current skin\n            await connectRefs(component, componentConfig, this.components);\n        } catch (e) {\n            throw e;\n            //debugger;\n            // TOOD : throw ?\n        }\n        if (!options?.skipInit)\n            await component.initiated();\n\n        return component as T;\n    }\n\n    public navigate = async <T extends IMyopComponent = IMyopComponent>(component: IMyopComponent, newComponentConfig: IComponentConfig, options?: navigationOptions) => {\n        if (component.parent) {\n            throw new Error('Navigating on remote ref components is not implemented yet');\n        }\n\n        //component.markedForDisposed = true;\n\n        // if (options?.inplace) {\n        //     if (component.element) {\n        //         let newComponent = await this.loadComponent<T>(newComponentConfig, component.element);\n        //         await newComponent.initiated();\n        //\n        //         if (options.init)\n        //             await options.init(newComponent);\n        //\n        //         return newComponent;\n        //     } else {\n        //         throw new Error('...')\n        //     }\n        // }\n\n        if (options?.staged) {\n            //const selectedSkin = this.runSkinSelector(newComponentConfig)\n            let newComponent = await this.loadComponent<T>(newComponentConfig, component.container, {\n                hidden: true,\n                relative: {direction: 'after', child: component.element!},\n                ...options\n            });\n\n            if (options.init)\n                await options.init(newComponent);\n\n            newComponent.show();\n            component.dispose();\n            return newComponent;\n        } else {\n            const nextSibling = component.element!.nextSibling;\n\n            component.dispose();\n            return this.loadComponent<T>(newComponentConfig, component.container, {\n                relative: {\n                    direction: \"before\",\n                    child: nextSibling,\n                },\n                ...options\n            });\n        }\n    }\n}\n\nexport type navigationOptions = {\n    staged?: boolean,\n    //inplace?: boolean,\n    init?: (component: IMyopComponent) => Promise<void>\n    skipInit?: boolean\n} & loaderOptions\n\ntype relativeLoadConfigDirection = 'before' | 'after';\n\n\nexport type loaderHooks = {\n    afterSkinSelected?: (selectedSkin: ISkinConfig) => Promise<ISkinConfig>\n} &\n    // segmentation hooks\n    ({ [key: string]: () => Promise<boolean> | boolean } | {})\n\n//TODO: support serializable version of that object\nexport interface relativeLoadConfig {\n    //If this is null, then newNode is inserted at the end of node's child nodes.\n    //https://developer.mozilla.org/en-US/docs/Web/API/Node/insertBefore\n    child: ChildNode | null\n    direction: relativeLoadConfigDirection\n}\n\nexport interface IEnvironment {\n    [key: string]: any\n}\n\ntype ElementAttributes = {\n    [key: string]: string | number | boolean | undefined | null;\n};\n\nexport interface loaderOptions {\n    id?: string\n    hidden?: boolean\n    connectProps?: boolean\n    timeout?: number\n    skipInit?: boolean\n    relative?: relativeLoadConfig\n    hooks?: loaderHooks\n    elementAttributes?: ElementAttributes\n    _environment?: IEnvironment\n    _hasParent?: boolean\n    _inspection?: boolean\n    data?: any\n    /**\n     * Raw CSS injected into the component's iframe <head> before first paint.\n     * Appended last so it overrides the component's own styles via cascade order.\n     * Useful for theming v2 (HTML) components \u2014 colors, fonts, spacing, etc.\n     */\n    injectCss?: string\n    /**\n     * Control iframe auto-sizing behavior.\n     * - true (default): iframe auto-sizes to content height, width fills parent.\n     * - false: no sizing logic runs. No observers, no measurements, no style changes.\n     *   The iframe stays at position:absolute filling the container.\n     *   The host is fully responsible for container dimensions.\n     */\n    autoSize?: boolean\n\n    /**\n     * Per-call render policy. Takes precedence over hostSDK.setRenderPolicy \u2014 lets an\n     * app restrict globally and allow (or further restrict) specific loadComponent calls.\n     */\n    renderPolicy?: RenderPolicy\n\n    /**\n     * Force full isolation for an inline-HTML (localFrame) component: sandboxed,\n     * cross-origin iframe with no host-document access. A render policy returning\n     * 'isolatedIframe' has the same effect.\n     */\n    isolation?: boolean\n}\n\nif (!window.myop) {\n    // @ts-ignore\n    window.myop = {\n        __ROOT_SDK_PUBLIC_URL__\n    };\n}\n\nif (!window.myop.hostSDK) {\n    const _hostSDK = new HostSDK();\n    //TODO: enable lazy init?\n    _hostSDK.init();\n\n    if (!window.myop) {\n        // @ts-ignore\n        window.myop = {\n            __ROOT_SDK_PUBLIC_URL__\n        };\n    }\n    window.myop.hostSDK = _hostSDK;\n}\n\n// The opt-in, reachable with no import and no build change on the host page:\n//\n//   myop.delivery({ minify: true, cache: true });   // lane + the client window\n//   myop.delivery.stats();                // what answered, and how often it fell back\n//   myop.delivery.off();                  // back to today's host, no reload\n//\n// Attached here rather than exported only as a module function because the host app that\n// opts in is often loading the SDK from a script tag, where `import` is not available.\nif (window.myop && !(window.myop as any).delivery) {\n    const api: any = (opts?: {minify?: boolean; host?: string | null}) => delivery(opts);\n    api.stats = deliveryStats;\n    api.off = deliveryOff;\n    api.refresh = deliveryRefresh;\n    (window.myop as any).delivery = api;\n}\n\n// @ts-ignore\nexport const hostSDK: HostSDK = window.myop.hostSDK;\n\ndefineDynamicImport('hostSDK', hostSDK);\n\ndeclare global {\n    interface Window {\n        myop: {\n            __ROOT_SDK_PUBLIC_URL__: string,\n            hostSDK: HostSDK,\n            IframeSDK: InstanceType<typeof IframeSDK>\n        }\n    }\n}\n", "/**\n * Myop Loader - Shared loader/fallback UI for host frameworks\n * Framework-agnostic implementation using pure DOM\n */\n\n// Myop Logo SVG path\nconst MYOP_LOGO_PATH =\n  \"M151.438 2.7168C177.625 2.76042 248.179 4.2832 300.4 56.7441C350.671 107.245 364.44 114.452 389.967 119.211C392.576 119.436 397.472 119.394 400.802 116.521C403.011 114.614 403.921 109.518 404.265 104.627V5.95996C404.265 4.85556 405.16 3.96023 406.265 3.95996H522.711C523.815 3.95996 524.711 4.85539 524.711 5.95996V122.405C524.711 123.51 523.815 124.405 522.711 124.405H421.998C418.579 124.728 413.852 125.627 410.974 128.095C407.879 130.748 407.042 137.805 406.845 142.661V240.414C406.845 241.436 406.111 242.292 405.093 242.38C366.548 245.717 277.079 228.462 235.837 173.668C202.909 129.919 173.882 122.474 151.458 122.077C150.354 122.058 149.459 121.164 149.459 120.06V4.71582C149.459 3.6114 150.334 2.71519 151.438 2.7168ZM62.2031 0C96.5566 0.000213148 124.405 27.8496 124.405 62.2031C124.405 96.5564 96.5564 124.405 62.2031 124.405C27.8496 124.405 0.000213175 96.5566 0 62.2031C0 27.8495 27.8495 0 62.2031 0Z\";\n\n// Style constants\nexport const LOADER_GRADIENT =\n  \"linear-gradient(135deg, #FF8651 0%, #FFBEA8 50%, #A397F5 100%)\";\nexport const FALLBACK_GRADIENT =\n  \"linear-gradient(135deg, #9CA3AF 0%, #D1D5DB 50%, #E5E7EB 100%)\";\n\n/**\n * Creates the Myop logo SVG element\n */\nexport function createMyopLogoSvg(): SVGSVGElement {\n  const svg = document.createElementNS(\"http://www.w3.org/2000/svg\", \"svg\");\n  svg.setAttribute(\"width\", \"80\");\n  svg.setAttribute(\"viewBox\", \"0 0 525 243\");\n  svg.setAttribute(\"fill\", \"none\");\n\n  const path = document.createElementNS(\"http://www.w3.org/2000/svg\", \"path\");\n  path.setAttribute(\"d\", MYOP_LOGO_PATH);\n  path.setAttribute(\"fill\", \"white\");\n\n  svg.appendChild(path);\n  return svg;\n}\n\n/**\n * Returns the inline HTML string for the Myop logo SVG\n */\nexport function getMyopLogoHtml(): string {\n  return `<svg width=\"80\" viewBox=\"0 0 525 243\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n    <path d=\"${MYOP_LOGO_PATH}\" fill=\"white\"/>\n  </svg>`;\n}\n\n/**\n * Returns the inline styles for the loader container\n */\nexport function getLoaderStyles(fadeDuration: number = 200): string {\n  return `\n    position: absolute;\n    top: 0;\n    left: 0;\n    right: 0;\n    bottom: 0;\n    z-index: 1;\n    background: ${LOADER_GRADIENT};\n    display: flex;\n    justify-content: center;\n    align-items: center;\n    transition: opacity ${fadeDuration}ms ease-out;\n  `;\n}\n\n/**\n * Returns the inline styles for the fallback container\n */\nexport function getFallbackStyles(): string {\n  return `\n    position: absolute;\n    top: 0;\n    left: 0;\n    right: 0;\n    bottom: 0;\n    background: ${FALLBACK_GRADIENT};\n    display: flex;\n    justify-content: center;\n    align-items: center;\n  `;\n}\n\n/**\n * Creates a loader DOM element with the Myop branding\n */\nexport function createLoaderElement(fadeDuration: number = 200): HTMLDivElement {\n  const loader = document.createElement(\"div\");\n  loader.className = \"myop-loader\";\n  loader.style.cssText = getLoaderStyles(fadeDuration);\n  loader.appendChild(createMyopLogoSvg());\n  return loader;\n}\n\n/**\n * Creates a fallback DOM element with the Myop branding\n */\nexport function createFallbackElement(): HTMLDivElement {\n  const fallback = document.createElement(\"div\");\n  fallback.className = \"myop-fallback\";\n  fallback.style.cssText = getFallbackStyles();\n  fallback.appendChild(createMyopLogoSvg());\n  return fallback;\n}\n\n/**\n * Returns the complete loader HTML as a string (for use in templates)\n */\nexport function getLoaderHtml(fadeDuration: number = 200): string {\n  return `<div class=\"myop-loader\" style=\"${getLoaderStyles(fadeDuration).replace(/\\n/g, \" \").replace(/\\s+/g, \" \").trim()}\">\n    ${getMyopLogoHtml()}\n  </div>`;\n}\n\n/**\n * Returns the complete fallback HTML as a string (for use in templates)\n */\nexport function getFallbackHtml(): string {\n  return `<div class=\"myop-fallback\" style=\"${getFallbackStyles().replace(/\\n/g, \" \").replace(/\\s+/g, \" \").trim()}\">\n    ${getMyopLogoHtml()}\n  </div>`;\n}\n\n/**\n * Interface for loader options used by host frameworks\n */\nexport interface MyopLoaderOptions {\n  /** Fade duration in milliseconds (default: 200) */\n  fadeDuration?: number;\n  /** Initial opacity (default: 1) */\n  opacity?: number;\n}\n\n/**\n * CSS-in-JS style objects for frameworks that support them\n */\nexport const loaderStyleObject = {\n  position: \"absolute\" as const,\n  top: 0,\n  left: 0,\n  right: 0,\n  bottom: 0,\n  zIndex: 1,\n  background: LOADER_GRADIENT,\n  display: \"flex\",\n  justifyContent: \"center\",\n  alignItems: \"center\",\n};\n\nexport const fallbackStyleObject = {\n  position: \"absolute\" as const,\n  top: 0,\n  left: 0,\n  right: 0,\n  bottom: 0,\n  background: FALLBACK_GRADIENT,\n  display: \"flex\",\n  justifyContent: \"center\",\n  alignItems: \"center\",\n};\n\nexport const containerStyleObject = {\n  position: \"absolute\" as const,\n  top: 0,\n  left: 0,\n  right: 0,\n  bottom: 0,\n  zIndex: 1,\n  display: \"flex\",\n  justifyContent: \"center\",\n  alignItems: \"center\",\n};\n"],
  "mappings": "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",
  "names": ["ReplayMessageKey", "match", "scriptInputs", "scriptInputs", "ReplayMessageKey", "ReplayMessageKey", "ReplayMessageKey", "ReplayMessageKey", "ReplayMessageKey", "ReplayMessageKey", "seen", "target", "makeSerializable", "height", "width", "e", "hostSDK", "element", "seen", "sdk", "domId", "sdk", "seen", "skin", "component", "_a", "segment", "experience", "selectedSkin"]
}
